goircd.go

   1 /*
   2 goircd -- minimalistic simple Internet Relay Chat (IRC) server
   3 Copyright (C) 2014-2022 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package main
  19
  20 import (
  21         "crypto/tls"
  22         "flag"
  23         "log"
  24         "net"
  25         "os"
  26         "os/signal"
  27         "path"
  28         "path/filepath"
  29         "strconv"
  30         "strings"
  31         "syscall"
  32 )
  33
  34 const (
  35         Version = "1.9.1"
  36
  37         StateTopicFilename = "topic"
  38         StateKeyFilename   = "key"
  39
  40         EventNew   = iota
  41         EventDel   = iota
  42         EventMsg   = iota
  43         EventTopic = iota
  44         EventWho   = iota
  45         EventMode  = iota
  46         EventTerm  = iota
  47         EventTick  = iota
  48 )
  49
  50 type ClientEvent struct {
  51         client    *Client
  52         eventType int
  53         text      string
  54 }
  55
  56 type StateEvent struct {
  57         where string
  58         topic string
  59         key   string
  60 }
  61
  62 var (
  63         hostname       = flag.String("hostname", "localhost", "hostname")
  64         bind           = flag.String("bind", "[::1]:6667", "address to bind to")
  65         cloak          = flag.String("cloak", "", "cloak user's host with the given hostname")
  66         motd           = flag.String("motd", "", "path to MOTD file")
  67         logdir         = flag.String("logdir", "", "absolute path to directory for logs")
  68         statedir       = flag.String("statedir", "", "absolute path to directory for states")
  69         passwords      = flag.String("passwd", "", "optional path to passwords file")
  70         tlsBind        = flag.String("tlsbind", "", "TLS address to bind to")
  71         tlsPEM         = flag.String("tlspem", "", "path to TLS certificat+key PEM file")
  72         permStateDirS  = flag.String("perm-state-dir", "755", "state directory permissions")
  73         permStateFileS = flag.String("perm-state-file", "600", "state files permissions")
  74         permLogFileS   = flag.String("perm-log-file", "644", "log files permissions")
  75         timestamped    = flag.Bool("timestamped", false, "enable timestamps on stderr messages")
  76         verbose        = flag.Bool("verbose", false, "enable verbose logging")
  77         debug          = flag.Bool("debug", false, "enable debug (traffic) logging")
  78
  79         permStateDir  os.FileMode
  80         permStateFile os.FileMode
  81         permLogFile   os.FileMode
  82
  83         stateSink chan StateEvent = make(chan StateEvent)
  84 )
  85
  86 func permParse(s string) os.FileMode {
  87         r, err := strconv.ParseUint(s, 8, 16)
  88         if err != nil {
  89                 log.Fatalln(err)
  90         }
  91         return os.FileMode(r)
  92 }
  93
  94 func listenerLoop(ln net.Listener, events chan ClientEvent) {
  95         for {
  96                 conn, err := ln.Accept()
  97                 if err != nil {
  98                         log.Println("error during accept", err)
  99                         continue
 100                 }
 101                 NewClient(conn, events)
 102         }
 103 }
 104
 105 func main() {
 106         flag.Parse()
 107         permStateDir = permParse(*permStateDirS)
 108         permStateFile = permParse(*permStateFileS)
 109         permLogFile = permParse(*permLogFileS)
 110
 111         if *timestamped {
 112                 log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile)
 113         } else {
 114                 log.SetFlags(log.Lshortfile)
 115         }
 116         log.SetOutput(os.Stdout)
 117
 118         if *logdir == "" {
 119                 // Dummy logger
 120                 go func() {
 121                         for range logSink {
 122                         }
 123                 }()
 124         } else {
 125                 if !path.IsAbs(*logdir) {
 126                         log.Fatalln("need absolute path for logdir")
 127                 }
 128                 go Logger(*logdir, logSink)
 129         }
 130
 131         if *statedir == "" {
 132                 // Dummy statekeeper
 133                 go func() {
 134                         for range stateSink {
 135                         }
 136                 }()
 137         } else {
 138                 if !path.IsAbs(*statedir) {
 139                         log.Fatalln("need absolute path for statedir")
 140                 }
 141                 states, err := filepath.Glob(path.Join(*statedir, "#*"))
 142                 if err != nil {
 143                         log.Fatalln("can not read statedir", err)
 144                 }
 145                 for _, state := range states {
 146                         buf, err := os.ReadFile(path.Join(state, StateTopicFilename))
 147                         if err != nil {
 148                                 log.Fatalf(
 149                                         "can not read state %s/%s: %v",
 150                                         state, StateTopicFilename, err,
 151                                 )
 152                         }
 153                         room := RoomRegister(path.Base(state))
 154                         room.topic = strings.TrimRight(string(buf), "\n")
 155                         buf, err = os.ReadFile(path.Join(state, StateKeyFilename))
 156                         if err == nil {
 157                                 room.key = strings.TrimRight(string(buf), "\n")
 158                         } else {
 159                                 if !os.IsNotExist(err) {
 160                                         log.Fatalf(
 161                                                 "can not read state %s/%s: %v",
 162                                                 state, StateKeyFilename, err,
 163                                         )
 164                                 }
 165                         }
 166                         log.Println("loaded state for room:", room.name)
 167                 }
 168
 169                 go func() {
 170                         for event := range stateSink {
 171                                 statePath := path.Join(*statedir, event.where)
 172                                 if _, err := os.Stat(statePath); os.IsNotExist(err) {
 173                                         if err := os.Mkdir(statePath, permStateDir); err != nil {
 174                                                 log.Printf("can not create state %s: %v", statePath, err)
 175                                                 continue
 176                                         }
 177                                 }
 178
 179                                 topicPath := path.Join(statePath, StateTopicFilename)
 180                                 if err := os.WriteFile(
 181                                         topicPath,
 182                                         []byte(event.topic+"\n"),
 183                                         permStateFile,
 184                                 ); err != nil {
 185                                         log.Printf("can not write statefile %s: %v", topicPath, err)
 186                                         continue
 187                                 }
 188
 189                                 keyPath := path.Join(statePath, StateKeyFilename)
 190                                 if err := os.WriteFile(
 191                                         keyPath,
 192                                         []byte(event.key+"\n"),
 193                                         permStateFile,
 194                                 ); err != nil {
 195                                         log.Printf("can not write statefile %s: %v", keyPath, err)
 196                                 }
 197                         }
 198                 }()
 199         }
 200
 201         events := make(chan ClientEvent)
 202         if *bind != "" {
 203                 ln, err := net.Listen("tcp", *bind)
 204                 if err != nil {
 205                         log.Fatalf("can not listen on %s: %v", *bind, err)
 206                 }
 207                 go listenerLoop(ln, events)
 208         }
 209         if *tlsBind != "" {
 210                 cert, err := tls.LoadX509KeyPair(*tlsPEM, *tlsPEM)
 211                 if err != nil {
 212                         log.Fatalf("can not load TLS keys from %s: %s", *tlsPEM, err)
 213                 }
 214                 config := tls.Config{Certificates: []tls.Certificate{cert}}
 215                 ln, err := tls.Listen("tcp", *tlsBind, &config)
 216                 if err != nil {
 217                         log.Fatalf("can not listen on %s: %v", *tlsBind, err)
 218                 }
 219                 go listenerLoop(ln, events)
 220         }
 221         log.Println("goircd", Version, "started")
 222
 223         needsShutdown := make(chan os.Signal, 0)
 224         signal.Notify(needsShutdown, syscall.SIGTERM, syscall.SIGINT)
 225         go func() {
 226                 <-needsShutdown
 227                 events <- ClientEvent{eventType: EventTerm}
 228                 log.Println("goircd shutting down")
 229         }()
 230
 231         finished := make(chan struct{})
 232         go Processor(events, finished)
 233         <-finished
 234 }