X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=daemon.go;h=ffd2ef1ffb06c059c4e52e9f76c753a500bbda09;hb=a939b027fdb6ce1d0822e76ec50814678ff0050a;hp=3c1692ffa09a762d9397d65fdf005a7fc9192f2f;hpb=87ba38e7f7aa8c5542bb13c255912a9e1a0f7931;p=goircd.git

diff --git a/daemon.go b/daemon.go
index 3c1692f..ffd2ef1 100644
--- a/daemon.go
+++ b/daemon.go
@@ -25,38 +25,44 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"sync"
 	"time"
 )
 
 const (
-	PING_TIMEOUT    = time.Second * 180 // Max time deadline for client's unresponsiveness
-	PING_THRESHOLD  = time.Second * 90  // Max idle client's time before PING are sent
-	ALIVENESS_CHECK = time.Second * 10  // Client's aliveness check period
+	PingTimeout    = time.Second * 180 // Max time deadline for client's unresponsiveness
+	PingThreshold  = time.Second * 90  // Max idle client's time before PING are sent
+	AlivenessCheck = time.Second * 10  // Client's aliveness check period
 )
 
 var (
-	RE_NICKNAME = regexp.MustCompile("^[a-zA-Z0-9-]{1,9}$")
+	RENickname = regexp.MustCompile("^[a-zA-Z0-9-]{1,9}$")
 )
 
+var passwordsRefreshLock sync.Mutex
+
 type Daemon struct {
-	Verbose              bool
-	hostname             string
-	motd                 string
-	clients              map[*Client]bool
-	rooms                map[string]*Room
-	room_sinks           map[*Room]chan ClientEvent
-	last_aliveness_check time.Time
-	log_sink             chan<- LogEvent
-	state_sink           chan<- StateEvent
+	Verbose            bool
+	hostname           string
+	motd               string
+	clients            map[*Client]bool
+	clientAliveness    map[*Client]*ClientAlivenessState
+	rooms              map[string]*Room
+	roomSinks          map[*Room]chan ClientEvent
+	lastAlivenessCheck time.Time
+	logSink            chan<- LogEvent
+	stateSink          chan<- StateEvent
+	passwords          map[string]string
 }
 
-func NewDaemon(hostname, motd string, log_sink chan<- LogEvent, state_sink chan<- StateEvent) *Daemon {
+func NewDaemon(hostname, motd string, logSink chan<- LogEvent, stateSink chan<- StateEvent) *Daemon {
 	daemon := Daemon{hostname: hostname, motd: motd}
 	daemon.clients = make(map[*Client]bool)
+	daemon.clientAliveness = make(map[*Client]*ClientAlivenessState)
 	daemon.rooms = make(map[string]*Room)
-	daemon.room_sinks = make(map[*Room]chan ClientEvent)
-	daemon.log_sink = log_sink
-	daemon.state_sink = state_sink
+	daemon.roomSinks = make(map[*Room]chan ClientEvent)
+	daemon.logSink = logSink
+	daemon.stateSink = stateSink
 	return &daemon
 }
 
@@ -152,19 +158,25 @@ func (daemon *Daemon) SendList(client *Client, cols []string) {
 // When client finishes NICK/USER workflow, then MOTD and LUSERS are send to him.
 func (daemon *Daemon) ClientRegister(client *Client, command string, cols []string) {
 	switch command {
+	case "PASS":
+		if len(cols) == 1 || len(cols[1]) < 1 {
+			client.ReplyNotEnoughParameters("PASS")
+			return
+		}
+		client.password = cols[1]
 	case "NICK":
 		if len(cols) == 1 || len(cols[1]) < 1 {
 			client.ReplyParts("431", "No nickname given")
 			return
 		}
 		nickname := cols[1]
-		for existing_client := range daemon.clients {
-			if existing_client.nickname == nickname {
+		for existingClient := range daemon.clients {
+			if existingClient.nickname == nickname {
 				client.ReplyParts("433", "*", nickname, "Nickname is already in use")
 				return
 			}
 		}
-		if !RE_NICKNAME.MatchString(nickname) {
+		if !RENickname.MatchString(nickname) {
 			client.ReplyParts("432", "*", cols[1], "Erroneous nickname")
 			return
 		}
@@ -183,6 +195,14 @@ func (daemon *Daemon) ClientRegister(client *Client, command string, cols []stri
 		client.realname = strings.TrimLeft(args[3], ":")
 	}
 	if client.nickname != "*" && client.username != "" {
+		passwordsRefreshLock.Lock()
+		if daemon.passwords != nil && (client.password == "" || daemon.passwords[client.nickname] != client.password) {
+			passwordsRefreshLock.Unlock()
+			client.ReplyParts("462", "You may not register")
+			client.conn.Close()
+			return
+		}
+		passwordsRefreshLock.Unlock()
 		client.registered = true
 		client.ReplyNicknamed("001", "Hi, welcome to IRC")
 		client.ReplyNicknamed("002", "Your host is "+daemon.hostname+", running goircd")
@@ -190,19 +210,20 @@ func (daemon *Daemon) ClientRegister(client *Client, command string, cols []stri
 		client.ReplyNicknamed("004", daemon.hostname+" goircd o o")
 		daemon.SendLusers(client)
 		daemon.SendMotd(client)
+		log.Println(client, "logged in")
 	}
 }
 
 // Register new room in Daemon. Create an object, events sink, save pointers
 // to corresponding daemon's places and start room's processor goroutine.
 func (daemon *Daemon) RoomRegister(name string) (*Room, chan<- ClientEvent) {
-	room_new := NewRoom(daemon.hostname, name, daemon.log_sink, daemon.state_sink)
-	room_new.Verbose = daemon.Verbose
-	room_sink := make(chan ClientEvent)
-	daemon.rooms[name] = room_new
-	daemon.room_sinks[room_new] = room_sink
-	go room_new.Processor(room_sink)
-	return room_new, room_sink
+	roomNew := NewRoom(daemon.hostname, name, daemon.logSink, daemon.stateSink)
+	roomNew.Verbose = daemon.Verbose
+	roomSink := make(chan ClientEvent)
+	daemon.rooms[name] = roomNew
+	daemon.roomSinks[roomNew] = roomSink
+	go roomNew.Processor(roomSink)
+	return roomNew, roomSink
 }
 
 func (daemon *Daemon) HandlerJoin(client *Client, cmd string) {
@@ -227,12 +248,12 @@ func (daemon *Daemon) HandlerJoin(client *Client, cmd string) {
 		}
 		denied := false
 		joined := false
-		for room_existing, room_sink := range daemon.room_sinks {
-			if room == room_existing.name {
-				if (room_existing.key != "") && (room_existing.key != key) {
+		for roomExisting, roomSink := range daemon.roomSinks {
+			if room == roomExisting.name {
+				if (roomExisting.key != "") && (roomExisting.key != key) {
 					denied = true
 				} else {
-					room_sink <- ClientEvent{client, EVENT_NEW, ""}
+					roomSink <- ClientEvent{client, EventNew, ""}
 					joined = true
 				}
 				break
@@ -244,62 +265,71 @@ func (daemon *Daemon) HandlerJoin(client *Client, cmd string) {
 		if denied || joined {
 			continue
 		}
-		room_new, room_sink := daemon.RoomRegister(room)
+		roomNew, roomSink := daemon.RoomRegister(room)
+		log.Println("Room", roomNew, "created")
 		if key != "" {
-			room_new.key = key
-			room_new.StateSave()
+			roomNew.key = key
+			roomNew.StateSave()
 		}
-		room_sink <- ClientEvent{client, EVENT_NEW, ""}
+		roomSink <- ClientEvent{client, EventNew, ""}
 	}
 }
 
 func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 	for event := range events {
+		now := time.Now()
+		client := event.client
 
 		// Check for clients aliveness
-		now := time.Now()
-		if daemon.last_aliveness_check.Add(ALIVENESS_CHECK).Before(now) {
+		if daemon.lastAlivenessCheck.Add(AlivenessCheck).Before(now) {
 			for c := range daemon.clients {
-				if c.timestamp.Add(PING_TIMEOUT).Before(now) {
+				aliveness, alive := daemon.clientAliveness[c]
+				if !alive {
+					continue
+				}
+				if aliveness.timestamp.Add(PingTimeout).Before(now) {
 					log.Println(c, "ping timeout")
 					c.conn.Close()
 					continue
 				}
-				if !c.ping_sent && c.timestamp.Add(PING_THRESHOLD).Before(now) {
+				if !aliveness.pingSent && aliveness.timestamp.Add(PingThreshold).Before(now) {
 					if c.registered {
 						c.Msg("PING :" + daemon.hostname)
-						c.ping_sent = true
+						aliveness.pingSent = true
 					} else {
 						log.Println(c, "ping timeout")
 						c.conn.Close()
 					}
 				}
 			}
-			daemon.last_aliveness_check = now
+			daemon.lastAlivenessCheck = now
 		}
 
-		client := event.client
-		switch event.event_type {
-		case EVENT_NEW:
+		switch event.eventType {
+		case EventNew:
 			daemon.clients[client] = true
-		case EVENT_DEL:
+			daemon.clientAliveness[client] = &ClientAlivenessState{pingSent: false, timestamp: now}
+		case EventDel:
 			delete(daemon.clients, client)
-			for _, room_sink := range daemon.room_sinks {
-				room_sink <- event
+			delete(daemon.clientAliveness, client)
+			for _, roomSink := range daemon.roomSinks {
+				roomSink <- event
 			}
-		case EVENT_MSG:
+		case EventMsg:
 			cols := strings.SplitN(event.text, " ", 2)
 			command := strings.ToUpper(cols[0])
 			if daemon.Verbose {
 				log.Println(client, "command", command)
 			}
 			if command == "QUIT" {
+				log.Println(client, "quit")
 				delete(daemon.clients, client)
+				delete(daemon.clientAliveness, client)
 				client.conn.Close()
 				continue
 			}
 			if !client.registered {
-				go daemon.ClientRegister(client, command, cols)
+				daemon.ClientRegister(client, command, cols)
 				continue
 			}
 			switch command {
@@ -310,11 +340,11 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 					client.ReplyNotEnoughParameters("JOIN")
 					continue
 				}
-				go daemon.HandlerJoin(client, cols[1])
+				daemon.HandlerJoin(client, cols[1])
 			case "LIST":
 				daemon.SendList(client, cols)
 			case "LUSERS":
-				go daemon.SendLusers(client)
+				daemon.SendLusers(client)
 			case "MODE":
 				if len(cols) == 1 || len(cols[1]) < 1 {
 					client.ReplyNotEnoughParameters("MODE")
@@ -336,9 +366,9 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 					continue
 				}
 				if len(cols) == 1 {
-					daemon.room_sinks[r] <- ClientEvent{client, EVENT_MODE, ""}
+					daemon.roomSinks[r] <- ClientEvent{client, EventMode, ""}
 				} else {
-					daemon.room_sinks[r] <- ClientEvent{client, EVENT_MODE, cols[1]}
+					daemon.roomSinks[r] <- ClientEvent{client, EventMode, cols[1]}
 				}
 			case "MOTD":
 				go daemon.SendMotd(client)
@@ -353,7 +383,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 						client.ReplyNoChannel(room)
 						continue
 					}
-					daemon.room_sinks[r] <- ClientEvent{client, EVENT_DEL, ""}
+					daemon.roomSinks[r] <- ClientEvent{client, EventDel, ""}
 				}
 			case "PING":
 				if len(cols) == 1 {
@@ -389,7 +419,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 				if !found {
 					client.ReplyNoNickChan(target)
 				}
-				daemon.room_sinks[r] <- ClientEvent{client, EVENT_MSG, command + " " + strings.TrimLeft(cols[1], ":")}
+				daemon.roomSinks[r] <- ClientEvent{client, EventMsg, command + " " + strings.TrimLeft(cols[1], ":")}
 			case "TOPIC":
 				if len(cols) == 1 {
 					client.ReplyNotEnoughParameters("TOPIC")
@@ -407,7 +437,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 				} else {
 					change = ""
 				}
-				daemon.room_sinks[r] <- ClientEvent{client, EVENT_TOPIC, change}
+				daemon.roomSinks[r] <- ClientEvent{client, EventTopic, change}
 			case "WHO":
 				if len(cols) == 1 || len(cols[1]) < 1 {
 					client.ReplyNotEnoughParameters("WHO")
@@ -419,7 +449,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 					client.ReplyNoChannel(room)
 					continue
 				}
-				daemon.room_sinks[r] <- ClientEvent{client, EVENT_WHO, ""}
+				daemon.roomSinks[r] <- ClientEvent{client, EventWho, ""}
 			case "WHOIS":
 				if len(cols) == 1 || len(cols[1]) < 1 {
 					client.ReplyNotEnoughParameters("WHOIS")
@@ -427,10 +457,33 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 				}
 				cols := strings.Split(cols[1], " ")
 				nicknames := strings.Split(cols[len(cols)-1], ",")
-				go daemon.SendWhois(client, nicknames)
+				daemon.SendWhois(client, nicknames)
 			default:
 				client.ReplyNicknamed("421", command, "Unknown command")
 			}
 		}
+		if aliveness, alive := daemon.clientAliveness[client]; alive {
+			aliveness.timestamp = now
+			aliveness.pingSent = false
+		}
+	}
+}
+
+func (daemon *Daemon) PasswordsRefresh() {
+	contents, err := ioutil.ReadFile(*passwords)
+	if err != nil {
+		log.Fatalf("Can no read passwords file %s: %s", *passwords, err)
+		return
+	}
+	processed := make(map[string]string)
+	for _, entry := range strings.Split(string(contents), "\n") {
+		loginAndPassword := strings.Split(entry, ":")
+		if len(loginAndPassword) == 2 {
+			processed[loginAndPassword[0]] = loginAndPassword[1]
+		}
 	}
+	log.Printf("Read %d passwords", len(processed))
+	passwordsRefreshLock.Lock()
+	daemon.passwords = processed
+	passwordsRefreshLock.Unlock()
 }