Changeset 317 in code for trunk/cmd/soju

Timestamp:

Jun 4, 2020, 6:16:23 PM (5 years ago)

Author:

contact

Message:

Allow multiple listeners, default to ircs

Users can now specify multiple "listen" directives in their
configuration file. If -listen is specified on the CLI, it's added to
the list of listeners.

Listeners are now parsed as URLs. If the scheme is missing "ircs" is
assumed. URLs allow to enable/disable TLS on a per-listener basis and
will be used for Unix sockets too.

The default listening address is changed from irc+insecure://:6667 to
ircs://:6697. This avoids setting up an insecure listener opened to
everybody.

File:

• trunk/cmd/soju/main.go (modified) (6 diffs)

trunk/cmd/soju/main.go

@@ -6 +6 @@
         "log"
         "net"
+        "net/url"
+        "strings"
 
         "git.sr.ht/~emersion/soju"
@@ -12 +14 @@
 
 func main() {
-        var addr, configPath string
+        var listen, configPath string
         var debug bool
-        flag.StringVar(&addr, "listen", "", "listening address")
+        flag.StringVar(&listen, "listen", "", "listening address")
         flag.StringVar(&configPath, "config", "", "path to configuration file")
         flag.BoolVar(&debug, "debug", false, "enable debug logging")
@@ -30 +32 @@
         }
 
-        if addr != "" {
-                cfg.Addr = addr
+        if listen != "" {
+                cfg.Listen = append(cfg.Listen, listen)
+        }
+        if len(cfg.Listen) == 0 {
+                cfg.Listen = []string{":6697"}
         }
 
@@ -39 +44 @@
         }
 
-        var ln net.Listener
+        var tlsCfg *tls.Config
         if cfg.TLS != nil {
                 cert, err := tls.LoadX509KeyPair(cfg.TLS.CertPath, cfg.TLS.KeyPath)
@@ -45 +50 @@
                         log.Fatalf("failed to load TLS certificate and key: %v", err)
                 }
-
-                tlsCfg := &tls.Config{Certificates: []tls.Certificate{cert}}
-                ln, err = tls.Listen("tcp", cfg.Addr, tlsCfg)
-                if err != nil {
-                        log.Fatalf("failed to start TLS listener: %v", err)
-                }
-        } else {
-                var err error
-                ln, err = net.Listen("tcp", cfg.Addr)
-                if err != nil {
-                        log.Fatalf("failed to start listener: %v", err)
-                }
+                tlsCfg = &tls.Config{Certificates: []tls.Certificate{cert}}
         }
 
@@ -65 +59 @@
         srv.Debug = debug
 
-        log.Printf("server listening on %q", cfg.Addr)
-        go func() {
-                if err := srv.Run(); err != nil {
-                        log.Fatal(err)
+        for _, listen := range cfg.Listen {
+                listenURI := listen
+                if !strings.Contains(listenURI, ":/") {
+                        // This is a raw domain name, make it an URL with an empty scheme
+                        listenURI = "//" + listenURI
                 }
-        }()
-        log.Fatal(srv.Serve(ln))
+                u, err := url.Parse(listenURI)
+                if err != nil {
+                        log.Fatalf("failed to parse listen URI %q: %v", listen, err)
+                }
+
+                switch u.Scheme {
+                case "ircs", "":
+                        if tlsCfg == nil {
+                                log.Fatalf("failed to listen on %q: missing TLS configuration", listen)
+                        }
+                        host := u.Host
+                        if _, _, err := net.SplitHostPort(host); err != nil {
+                                host = host + ":6697"
+                        }
+                        ln, err := tls.Listen("tcp", host, tlsCfg)
+                        if err != nil {
+                                log.Fatalf("failed to start TLS listener on %q: %v", listen, err)
+                        }
+                        go func() {
+                                log.Fatal(srv.Serve(ln))
+                        }()
+                case "irc+insecure":
+                        host := u.Host
+                        if _, _, err := net.SplitHostPort(host); err != nil {
+                                host = host + ":6667"
+                        }
+                        ln, err := net.Listen("tcp", host)
+                        if err != nil {
+                                log.Fatalf("failed to start listener on %q: %v", listen, err)
+                        }
+                        go func() {
+                                log.Fatal(srv.Serve(ln))
+                        }()
+                default:
+                        log.Fatalf("failed to listen on %q: unsupported scheme", listen)
+                }
+
+                log.Printf("server listening on %q", listen)
+        }
+        log.Fatal(srv.Run())
 }