goircd.go

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