X-Git-Url: http://www.git.cypherpunks.ru/?p=goircd.git;a=blobdiff_plain;f=goircd.go;h=f8aad490d8a47b44f900c022ea9ee7adb7e37bdd;hp=aeca83a73a19756058f3490ca7260a145729da44;hb=b7fb219307483d2c31b5dad1f559f325f2fd1a5e;hpb=de49f5eeba0117dd09fcdc290ef99ba6a5e2656d diff --git a/goircd.go b/goircd.go index aeca83a..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,124 +14,222 @@ 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 ( - "bytes" "crypto/tls" "flag" + "io/ioutil" "log" "net" "os" + "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 ( - 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") - - ssl = flag.Bool("ssl", false, "Use SSL only.") - sslKey = flag.String("ssl_key", "", "SSL keyfile.") - sslCert = flag.String("ssl_cert", "", "SSL certificate.") + 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) - log_sink := make(chan LogEvent) if *logdir == "" { // Dummy logger go func() { - for _ = range log_sink { + 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, log_sink) - log.Println(*logdir, "logger initialized") + go Logger(*logdir, logSink) } - state_sink := make(chan StateEvent) - daemon := NewDaemon(*hostname, *motd, log_sink, state_sink) if *statedir == "" { // Dummy statekeeper go func() { - for _ = range state_sink { + 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(*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 { - fd, err := os.Open(state) + buf, err := ioutil.ReadFile(path.Join(state, StateTopicFilename)) if err != nil { - log.Fatalln("Can not open state", state, err) + log.Fatalf( + "can not read state %s/%s: %v", + state, StateTopicFilename, err, + ) } - buf := make([]byte, 1024) - _, err = fd.Read(buf) - fd.Close() - if err != nil { - log.Fatalln("Can not read state", state, err) + 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 { + if !os.IsNotExist(err) { + log.Fatalf( + "can not read state %s/%s: %v", + state, StateKeyFilename, err, + ) + } } - room, _ := daemon.RoomRegister(path.Base(state)) - buf = bytes.TrimRight(buf, "\x00") - contents := strings.Split(string(buf), "\n") - room.topic = contents[0] - room.key = contents[1] - log.Println("Loaded state for room", room.name) + log.Println("loaded state for room:", room.name) } - go StateKeeper(*statedir, state_sink) - 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 := 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) + } + } + }() } - var listener net.Listener - if *ssl { - cert, err := tls.LoadX509KeyPair(*sslCert, *sslKey) + events := make(chan ClientEvent) + if *bind != "" { + ln, err := net.Listen("tcp", *bind) if err != nil { - log.Fatalf("Could not load SSL keys from %s and %s: %s", *sslCert, *sslKey, 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("Listening on", *bind) + log.Println("goircd", Version, "started") - 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 }