X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=daemon.go;h=2bf696ce31229c86a744f0ee64d4c9f287894d32;hb=b35f6e7b3c510bea24c0927073720a459055816e;hp=420ec9121d366440e9ce1fc0ab50e62958c4d025;hpb=def74ddc09249de9ab72001bb00550863d7f27e6;p=goircd.git

diff --git a/daemon.go b/daemon.go
index 420ec91..2bf696c 100644
--- a/daemon.go
+++ b/daemon.go
@@ -25,40 +25,45 @@ 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
-	client_aliveness     map[*Client]*ClientAlivenessState
-	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
+	version            string
+	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 {
-	daemon := Daemon{hostname: hostname, motd: motd}
+func NewDaemon(version, hostname, motd string, logSink chan<- LogEvent, stateSink chan<- StateEvent) *Daemon {
+	daemon := Daemon{version: version, hostname: hostname, motd: motd}
 	daemon.clients = make(map[*Client]bool)
-	daemon.client_aliveness = make(map[*Client]*ClientAlivenessState)
+	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
 }
 
@@ -154,19 +159,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
 		}
@@ -185,26 +196,35 @@ 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")
+		client.ReplyNicknamed("002", "Your host is "+daemon.hostname+", running goircd "+daemon.version)
 		client.ReplyNicknamed("003", "This server was created sometime")
 		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) {
@@ -229,12 +249,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
@@ -246,12 +266,13 @@ 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, ""}
 	}
 }
 
@@ -261,49 +282,50 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 		client := event.client
 
 		// Check for clients aliveness
-		if daemon.last_aliveness_check.Add(ALIVENESS_CHECK).Before(now) {
+		if daemon.lastAlivenessCheck.Add(AlivenessCheck).Before(now) {
 			for c := range daemon.clients {
-				aliveness, alive := daemon.client_aliveness[c]
+				aliveness, alive := daemon.clientAliveness[c]
 				if !alive {
 					continue
 				}
-				if aliveness.timestamp.Add(PING_TIMEOUT).Before(now) {
+				if aliveness.timestamp.Add(PingTimeout).Before(now) {
 					log.Println(c, "ping timeout")
 					c.conn.Close()
 					continue
 				}
-				if !aliveness.ping_sent && aliveness.timestamp.Add(PING_THRESHOLD).Before(now) {
+				if !aliveness.pingSent && aliveness.timestamp.Add(PingThreshold).Before(now) {
 					if c.registered {
 						c.Msg("PING :" + daemon.hostname)
-						aliveness.ping_sent = true
+						aliveness.pingSent = true
 					} else {
 						log.Println(c, "ping timeout")
 						c.conn.Close()
 					}
 				}
 			}
-			daemon.last_aliveness_check = now
+			daemon.lastAlivenessCheck = now
 		}
 
-		switch event.event_type {
-		case EVENT_NEW:
+		switch event.eventType {
+		case EventNew:
 			daemon.clients[client] = true
-			daemon.client_aliveness[client] = &ClientAlivenessState{ping_sent: false, timestamp: now}
-		case EVENT_DEL:
+			daemon.clientAliveness[client] = &ClientAlivenessState{pingSent: false, timestamp: now}
+		case EventDel:
 			delete(daemon.clients, client)
-			delete(daemon.client_aliveness, 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.client_aliveness, client)
+				delete(daemon.clientAliveness, client)
 				client.conn.Close()
 				continue
 			}
@@ -323,7 +345,7 @@ func (daemon *Daemon) Processor(events <-chan ClientEvent) {
 			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")
@@ -345,9 +367,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)
@@ -362,7 +384,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 {
@@ -398,7 +420,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")
@@ -416,7 +438,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")
@@ -428,7 +450,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")
@@ -436,14 +458,41 @@ 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)
+			case "VERSION":
+				var debug string
+				if daemon.Verbose {
+					debug = "debug"
+				} else {
+					debug = ""
+				}
+				client.ReplyNicknamed("351", fmt.Sprintf("%s.%s %s :", daemon.version, debug, daemon.hostname))
 			default:
 				client.ReplyNicknamed("421", command, "Unknown command")
 			}
 		}
-		if aliveness, alive := daemon.client_aliveness[client]; alive {
+		if aliveness, alive := daemon.clientAliveness[client]; alive {
 			aliveness.timestamp = now
-			aliveness.ping_sent = false
+			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()
 }