X-Git-Url: http://www.git.cypherpunks.ru/?p=goircd.git;a=blobdiff_plain;f=goircd.go;h=f8aad490d8a47b44f900c022ea9ee7adb7e37bdd;hp=b0f5e07716db40625c08378d046670c9154c68d8;hb=b7fb219307483d2c31b5dad1f559f325f2fd1a5e;hpb=85e6538f2f610ad66bf0be0eff5bdcf05f1b8e3c diff --git a/goircd.go b/goircd.go index b0f5e07..f8aad49 100644 --- a/goircd.go +++ b/goircd.go @@ -1,11 +1,10 @@ /* goircd -- minimalistic simple Internet Relay Chat (IRC) server -Copyright (C) 2014 Sergey Matveev +Copyright (C) 2014-2020 Sergey Matveev This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. +the Free Software Foundation, version 3 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -15,6 +14,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ + package main import ( @@ -27,133 +27,209 @@ import ( "os/signal" "path" "path/filepath" + "strconv" "strings" "syscall" ) +const ( + Version = "1.9.0" + + StateTopicFilename = "topic" + StateKeyFilename = "key" + + EventNew = iota + EventDel = iota + EventMsg = iota + EventTopic = iota + EventWho = iota + EventMode = iota + EventTerm = iota + EventTick = iota +) + +type ClientEvent struct { + client *Client + eventType int + text string +} + +type StateEvent struct { + where string + topic string + key string +} + var ( - version string - hostname = flag.String("hostname", "localhost", "Hostname") - bind = flag.String("bind", ":6667", "Address to bind to") - motd = flag.String("motd", "", "Path to MOTD file") - logdir = flag.String("logdir", "", "Absolute path to directory for logs") - statedir = flag.String("statedir", "", "Absolute path to directory for states") - passwords = flag.String("passwords", "", "Optional path to passwords file") - - tlsBind = flag.String("tlsbind", "", "TLS address to bind to") - tlsPEM = flag.String("tlspem", "", "Path to TLS certificat+key PEM file") - - verbose = flag.Bool("v", false, "Enable verbose logging.") + hostname = flag.String("hostname", "localhost", "hostname") + bind = flag.String("bind", "[::1]:6667", "address to bind to") + cloak = flag.String("cloak", "", "cloak user's host with the given hostname") + motd = flag.String("motd", "", "path to MOTD file") + logdir = flag.String("logdir", "", "absolute path to directory for logs") + statedir = flag.String("statedir", "", "absolute path to directory for states") + passwords = flag.String("passwd", "", "optional path to passwords file") + tlsBind = flag.String("tlsbind", "", "TLS address to bind to") + tlsPEM = flag.String("tlspem", "", "path to TLS certificat+key PEM file") + permStateDirS = flag.String("perm-state-dir", "755", "state directory permissions") + permStateFileS = flag.String("perm-state-file", "600", "state files permissions") + permLogFileS = flag.String("perm-log-file", "644", "log files permissions") + timestamped = flag.Bool("timestamped", false, "enable timestamps on stderr messages") + verbose = flag.Bool("verbose", false, "enable verbose logging") + debug = flag.Bool("debug", false, "enable debug (traffic) logging") + + permStateDir os.FileMode + permStateFile os.FileMode + permLogFile os.FileMode + + stateSink chan StateEvent = make(chan StateEvent) ) -func listenerLoop(sock net.Listener, events chan<- ClientEvent) { +func permParse(s string) os.FileMode { + r, err := strconv.ParseUint(s, 8, 16) + if err != nil { + log.Fatalln(err) + } + return os.FileMode(r) +} + +func listenerLoop(ln net.Listener, events chan ClientEvent) { for { - conn, err := sock.Accept() + conn, err := ln.Accept() if err != nil { - log.Println("Error during accepting connection", err) + log.Println("error during accept", err) continue } - client := NewClient(*hostname, conn) - go client.Processor(events) + NewClient(conn, events) } } -func Run() { - events := make(chan ClientEvent) - log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile) +func main() { + flag.Parse() + permStateDir = permParse(*permStateDirS) + permStateFile = permParse(*permStateFileS) + permLogFile = permParse(*permLogFileS) + + if *timestamped { + log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile) + } else { + log.SetFlags(log.Lshortfile) + } + log.SetOutput(os.Stdout) - logSink := make(chan LogEvent) if *logdir == "" { // Dummy logger go func() { - for _ = range logSink { + for range logSink { } }() } else { if !path.IsAbs(*logdir) { - log.Fatalln("Need absolute path for logdir") - return + log.Fatalln("need absolute path for logdir") } go Logger(*logdir, logSink) - log.Println(*logdir, "logger initialized") } - stateSink := make(chan StateEvent) - daemon := NewDaemon(version, *hostname, *motd, logSink, stateSink) - daemon.Verbose = *verbose - log.Println("goircd "+daemon.version+" is starting") if *statedir == "" { // Dummy statekeeper go func() { - for _ = range stateSink { + for range stateSink { } }() } else { if !path.IsAbs(*statedir) { - log.Fatalln("Need absolute path for statedir") + log.Fatalln("need absolute path for statedir") } states, err := filepath.Glob(path.Join(*statedir, "#*")) if err != nil { - log.Fatalln("Can not read statedir", err) + log.Fatalln("can not read statedir", err) } for _, state := range states { - buf, err := ioutil.ReadFile(state) + buf, err := ioutil.ReadFile(path.Join(state, StateTopicFilename)) if err != nil { - log.Fatalf("Can not read state %s: %v", state, err) + log.Fatalf( + "can not read state %s/%s: %v", + state, StateTopicFilename, err, + ) } - room, _ := daemon.RoomRegister(path.Base(state)) - contents := strings.Split(string(buf), "\n") - if len(contents) < 2 { - log.Printf("State corrupted for %s: %q", room.name, contents) + room := RoomRegister(path.Base(state)) + room.topic = strings.TrimRight(string(buf), "\n") + buf, err = ioutil.ReadFile(path.Join(state, StateKeyFilename)) + if err == nil { + room.key = strings.TrimRight(string(buf), "\n") } else { - room.topic = contents[0] - room.key = contents[1] - log.Println("Loaded state for room", room.name) + if !os.IsNotExist(err) { + log.Fatalf( + "can not read state %s/%s: %v", + state, StateKeyFilename, err, + ) + } } + log.Println("loaded state for room:", room.name) } - go StateKeeper(*statedir, stateSink) - log.Println(*statedir, "statekeeper initialized") - } - if *passwords != "" { - daemon.PasswordsRefresh() - hups := make(chan os.Signal) - signal.Notify(hups, syscall.SIGHUP) go func() { - for { - <-hups - daemon.PasswordsRefresh() + for event := range stateSink { + statePath := path.Join(*statedir, event.where) + if _, err := os.Stat(statePath); os.IsNotExist(err) { + if err := os.Mkdir(statePath, permStateDir); err != nil { + log.Printf("can not create state %s: %v", statePath, err) + continue + } + } + + topicPath := path.Join(statePath, StateTopicFilename) + if err := ioutil.WriteFile( + topicPath, + []byte(event.topic+"\n"), + permStateFile, + ); err != nil { + log.Printf("can not write statefile %s: %v", topicPath, err) + continue + } + + keyPath := path.Join(statePath, StateKeyFilename) + if err := ioutil.WriteFile( + keyPath, + []byte(event.key+"\n"), + permStateFile, + ); err != nil { + log.Printf("can not write statefile %s: %v", keyPath, err) + } } }() } - + events := make(chan ClientEvent) if *bind != "" { - listener, err := net.Listen("tcp", *bind) + ln, err := net.Listen("tcp", *bind) if err != nil { - log.Fatalf("Can not listen on %s: %v", *bind, err) + log.Fatalf("can not listen on %s: %v", *bind, err) } - log.Println("Raw listening on", *bind) - go listenerLoop(listener, events) + go listenerLoop(ln, events) } if *tlsBind != "" { cert, err := tls.LoadX509KeyPair(*tlsPEM, *tlsPEM) if err != nil { - log.Fatalf("Could not load TLS keys from %s: %s", *tlsPEM, err) + log.Fatalf("can not load TLS keys from %s: %s", *tlsPEM, err) } config := tls.Config{Certificates: []tls.Certificate{cert}} - listenerTLS, err := tls.Listen("tcp", *tlsBind, &config) + ln, err := tls.Listen("tcp", *tlsBind, &config) if err != nil { - log.Fatalf("Can not listen on %s: %v", *tlsBind, err) + log.Fatalf("can not listen on %s: %v", *tlsBind, err) } - log.Println("TLS listening on", *tlsBind) - go listenerLoop(listenerTLS, events) + go listenerLoop(ln, events) } - - daemon.Processor(events) -} - -func main() { - flag.Parse() - Run() + log.Println("goircd", Version, "started") + + needsShutdown := make(chan os.Signal, 0) + signal.Notify(needsShutdown, syscall.SIGTERM, syscall.SIGINT) + go func() { + <-needsShutdown + events <- ClientEvent{eventType: EventTerm} + log.Println("goircd shutting down") + }() + + finished := make(chan struct{}) + go Processor(events, finished) + <-finished }