X-Git-Url: http://www.git.cypherpunks.ru/?p=goircd.git;a=blobdiff_plain;f=goircd.go;h=6168eaf62d1dd4fa416cb3f9f7b41681fa5d7e68;hp=f70e11c68e9a21d31fb98460ea1d41451075aedd;hb=6f9d7fae374e5ada6c33f585db748f23fbc49f91;hpb=f46c678ce03915d6f081cf2f78ac7fe885cdb001 diff --git a/goircd.go b/goircd.go index f70e11c..6168eaf 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-2022 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,139 +14,221 @@ 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 ( "crypto/tls" "flag" - "io/ioutil" "log" "net" "os" "os/signal" "path" "path/filepath" + "strconv" "strings" "syscall" ) +const ( + Version = "1.9.1" + + 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") - - tlsKey = flag.String("tls_key", "", "TLS keyfile") - tlsCert = flag.String("tls_cert", "", "TLS certificate") - - 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 Run() { - var client *Client - events := make(chan ClientEvent) - log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile) +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 := ln.Accept() + if err != nil { + log.Println("error during accept", err) + continue + } + NewClient(conn, events) + } +} + +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 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 := os.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 = os.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") + + go func() { + 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 := os.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 := os.WriteFile( + keyPath, + []byte(event.key+"\n"), + permStateFile, + ); err != nil { + log.Printf("can not write statefile %s: %v", keyPath, err) + } + } + }() } - var listener net.Listener - if *tlsKey != "" { - cert, err := tls.LoadX509KeyPair(*tlsCert, *tlsKey) + events := make(chan ClientEvent) + if *bind != "" { + ln, err := net.Listen("tcp", *bind) if err != nil { - log.Fatalf("Could not load TLS keys from %s and %s: %s", *tlsCert, *tlsKey, err) + log.Fatalf("can not listen on %s: %v", *bind, err) } - config := tls.Config{Certificates: []tls.Certificate{cert}} - listener, err = tls.Listen("tcp", *bind, &config) + go listenerLoop(ln, events) + } + if *tlsBind != "" { + cert, err := tls.LoadX509KeyPair(*tlsPEM, *tlsPEM) if err != nil { - log.Fatalf("Can not listen on %s: %v", *bind, err) + log.Fatalf("can not load TLS keys from %s: %s", *tlsPEM, err) } - } else { - var err error - listener, err = net.Listen("tcp", *bind) + config := tls.Config{Certificates: []tls.Certificate{cert}} + ln, err := tls.Listen("tcp", *tlsBind, &config) if err != nil { - log.Fatalf("Can not listen on %s: %v", *bind, err) + log.Fatalf("can not listen on %s: %v", *tlsBind, err) } + go listenerLoop(ln, events) } - log.Println("goircd "+daemon.version+" listening on", *bind) + log.Println("goircd", Version, "started") - if *passwords != "" { - daemon.PasswordsRefresh() - hups := make(chan os.Signal) - signal.Notify(hups, syscall.SIGHUP) - go func() { - for { - <-hups - daemon.PasswordsRefresh() - } - }() - } - - go daemon.Processor(events) - for { - conn, err := listener.Accept() - if err != nil { - log.Println("Error during accepting connection", err) - continue - } - client = NewClient(*hostname, conn) - go client.Processor(events) - } -} + 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") + }() -func main() { - flag.Parse() - Run() + finished := make(chan struct{}) + go Processor(events, finished) + <-finished }