Fix several races

diff --git a/client.go b/client.go
index 950cbcaba02100a28fb0b9f994a41e026548ad56..07a209b61d0a524653e56714bfa7fe81b10e4ebf 100644 (file)
--- a/client.go
+++ b/client.go
@@ -34,13 +34,16 @@ type Client struct {
        hostname   string
        conn       net.Conn
        registered bool
        hostname   string
        conn       net.Conn
        registered bool

-       ping_sent  bool
-       timestamp  time.Time

        nickname   string
        username   string
        realname   string
 }
 
        nickname   string
        username   string
        realname   string
 }
 

+type ClientAlivenessState struct {
+       ping_sent bool
+       timestamp time.Time
+}
+

 func (client Client) String() string {
        return client.nickname + "!" + client.username + "@" + client.conn.RemoteAddr().String()
 }
 func (client Client) String() string {
        return client.nickname + "!" + client.username + "@" + client.conn.RemoteAddr().String()
 }


@@ -65,8 +68,6 @@ func (client *Client) Processor(sink chan<- ClientEvent) {
                        sink <- ClientEvent{client, EVENT_DEL, ""}
                        break
                }
                        sink <- ClientEvent{client, EVENT_DEL, ""}
                        break
                }

-               client.timestamp = time.Now()
-               client.ping_sent = false

                buf_net = bytes.TrimRight(buf_net, "\x00")
                buf = append(buf, buf_net...)
                if !bytes.HasSuffix(buf, []byte(CRLF)) {
                buf_net = bytes.TrimRight(buf_net, "\x00")
                buf = append(buf, buf_net...)
                if !bytes.HasSuffix(buf, []byte(CRLF)) {

diff --git a/client_test.go b/client_test.go
index 22cc401ea920bacc0e36c245145359be47d851d1..82756c8ad5008cf28a63b524901f18becc4cb0cd 100644 (file)
--- a/client_test.go
+++ b/client_test.go
@@ -105,7 +105,6 @@ func TestNewClient(t *testing.T) {
        }
        conn.inbound <- "foo"
        event = <-sink
        }
        conn.inbound <- "foo"
        event = <-sink

-       ts1 := client.timestamp

        if (event.event_type != EVENT_MSG) || (event.text != "foo") {
                t.Fatal("no first MSG", event)
        }
        if (event.event_type != EVENT_MSG) || (event.text != "foo") {
                t.Fatal("no first MSG", event)
        }


@@ -115,9 +114,6 @@ func TestNewClient(t *testing.T) {
                t.Fatal("no second MSG", event)
        }
        conn.inbound <- ""
                t.Fatal("no second MSG", event)
        }
        conn.inbound <- ""

-       if client.timestamp.Before(ts1) || client.timestamp.Equal(ts1) {
-               t.Fatal("timestamp updating")
-       }

        event = <-sink
        if event.event_type != EVENT_DEL {
                t.Fatal("no client termination", event)
        event = <-sink
        if event.event_type != EVENT_DEL {
                t.Fatal("no client termination", event)

diff --git a/daemon.go b/daemon.go
index 3c1692ffa09a762d9397d65fdf005a7fc9192f2f..420ec9121d366440e9ce1fc0ab50e62958c4d025 100644 (file)
--- a/daemon.go
+++ b/daemon.go
@@ -43,6 +43,7 @@ type Daemon struct {
        hostname             string
        motd                 string
        clients              map[*Client]bool
        hostname             string
        motd                 string
        clients              map[*Client]bool

+       client_aliveness     map[*Client]*ClientAlivenessState

        rooms                map[string]*Room
        room_sinks           map[*Room]chan ClientEvent
        last_aliveness_check time.Time
        rooms                map[string]*Room
        room_sinks           map[*Room]chan ClientEvent
        last_aliveness_check time.Time


@@ -53,6 +54,7 @@ type Daemon struct {
 func NewDaemon(hostname, motd string, log_sink chan<- LogEvent, state_sink chan<- StateEvent) *Daemon {
        daemon := Daemon{hostname: hostname, motd: motd}
        daemon.clients = make(map[*Client]bool)
 func NewDaemon(hostname, motd string, log_sink chan<- LogEvent, state_sink chan<- StateEvent) *Daemon {
        daemon := Daemon{hostname: hostname, motd: motd}
        daemon.clients = make(map[*Client]bool)

+       daemon.client_aliveness = make(map[*Client]*ClientAlivenessState)

        daemon.rooms = make(map[string]*Room)
        daemon.room_sinks = make(map[*Room]chan ClientEvent)
        daemon.log_sink = log_sink
        daemon.rooms = make(map[string]*Room)
        daemon.room_sinks = make(map[*Room]chan ClientEvent)
        daemon.log_sink = log_sink


@@ -255,20 +257,25 @@ func (daemon *Daemon) HandlerJoin(client *Client, cmd string) {
 
 func (daemon *Daemon) Processor(events <-chan ClientEvent) {
        for event := range events {
 
 func (daemon *Daemon) Processor(events <-chan ClientEvent) {
        for event := range events {

+               now := time.Now()
+               client := event.client

 
                // Check for clients aliveness
 
                // Check for clients aliveness

-               now := time.Now()

                if daemon.last_aliveness_check.Add(ALIVENESS_CHECK).Before(now) {
                        for c := range daemon.clients {
                if daemon.last_aliveness_check.Add(ALIVENESS_CHECK).Before(now) {
                        for c := range daemon.clients {

-                               if c.timestamp.Add(PING_TIMEOUT).Before(now) {
+                               aliveness, alive := daemon.client_aliveness[c]
+                               if !alive {
+                                       continue
+                               }
+                               if aliveness.timestamp.Add(PING_TIMEOUT).Before(now) {

                                        log.Println(c, "ping timeout")
                                        c.conn.Close()
                                        continue
                                }
                                        log.Println(c, "ping timeout")
                                        c.conn.Close()
                                        continue
                                }

-                               if !c.ping_sent && c.timestamp.Add(PING_THRESHOLD).Before(now) {
+                               if !aliveness.ping_sent && aliveness.timestamp.Add(PING_THRESHOLD).Before(now) {

                                        if c.registered {
                                                c.Msg("PING :" + daemon.hostname)
                                        if c.registered {
                                                c.Msg("PING :" + daemon.hostname)

-                                               c.ping_sent = true
+                                               aliveness.ping_sent = true

                                        } else {
                                                log.Println(c, "ping timeout")
                                                c.conn.Close()
                                        } else {
                                                log.Println(c, "ping timeout")
                                                c.conn.Close()


@@ -278,12 +285,13 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
                        daemon.last_aliveness_check = now
                }
 
                        daemon.last_aliveness_check = now
                }
 

-               client := event.client

                switch event.event_type {
                case EVENT_NEW:
                        daemon.clients[client] = true
                switch event.event_type {
                case EVENT_NEW:
                        daemon.clients[client] = true

+                       daemon.client_aliveness[client] = &ClientAlivenessState{ping_sent: false, timestamp: now}

                case EVENT_DEL:
                        delete(daemon.clients, client)
                case EVENT_DEL:
                        delete(daemon.clients, client)

+                       delete(daemon.client_aliveness, client)

                        for _, room_sink := range daemon.room_sinks {
                                room_sink <- event
                        }
                        for _, room_sink := range daemon.room_sinks {
                                room_sink <- event
                        }


@@ -295,11 +303,12 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
                        }
                        if command == "QUIT" {
                                delete(daemon.clients, client)
                        }
                        if command == "QUIT" {
                                delete(daemon.clients, client)

+                               delete(daemon.client_aliveness, client)

                                client.conn.Close()
                                continue
                        }
                        if !client.registered {
                                client.conn.Close()
                                continue
                        }
                        if !client.registered {

-                               go daemon.ClientRegister(client, command, cols)
+                               daemon.ClientRegister(client, command, cols)

                                continue
                        }
                        switch command {
                                continue
                        }
                        switch command {


@@ -310,7 +319,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
                                        client.ReplyNotEnoughParameters("JOIN")
                                        continue
                                }
                                        client.ReplyNotEnoughParameters("JOIN")
                                        continue
                                }

-                               go daemon.HandlerJoin(client, cols[1])
+                               daemon.HandlerJoin(client, cols[1])

                        case "LIST":
                                daemon.SendList(client, cols)
                        case "LUSERS":
                        case "LIST":
                                daemon.SendList(client, cols)
                        case "LUSERS":


@@ -432,5 +441,9 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
                                client.ReplyNicknamed("421", command, "Unknown command")
                        }
                }
                                client.ReplyNicknamed("421", command, "Unknown command")
                        }
                }

+               if aliveness, alive := daemon.client_aliveness[client]; alive {
+                       aliveness.timestamp = now
+                       aliveness.ping_sent = false
+               }

        }
 }
        }
 }

diff --git a/room.go b/room.go
index ccd7ae923992be8eab4cc72f15510bd66b8f003b..6fc2bcaa94b8b072858c7afd59d5d17f22f6b0f8 100644 (file)
--- a/room.go
+++ b/room.go
@@ -106,7 +106,7 @@ func (room *Room) Processor(events <-chan ClientEvent) {
                        }
                        delete(room.members, client)
                        msg := fmt.Sprintf(":%s PART %s :%s", client, room.name, client.nickname)
                        }
                        delete(room.members, client)
                        msg := fmt.Sprintf(":%s PART %s :%s", client, room.name, client.nickname)

-                       go room.Broadcast(msg)
+                       room.Broadcast(msg)

                        room.log_sink <- LogEvent{room.name, client.nickname, "left", true}
                case EVENT_TOPIC:
                        if _, subscribed := room.members[client]; !subscribed {
                        room.log_sink <- LogEvent{room.name, client.nickname, "left", true}
                case EVENT_TOPIC:
                        if _, subscribed := room.members[client]; !subscribed {