source: code/trunk/cmd/soju/main.go@ 470

Last change on this file since 470 was 470, checked in by contact, 4 years ago

Don't add "irc" in ALPN list for WebSocket servers

This is incorrect because HTTP listeners don't handle plain IRC
connections. This also prevents net/http from setting up an HTTP/2
server.
File size: 4.9 KB
Line 
1package main
2
3import (
4 "crypto/tls"
5 "flag"
6 "log"
7 "net"
8 "net/http"
9 "net/url"
10 "os"
11 "os/signal"
12 "strings"
13 "syscall"
14
15 "github.com/pires/go-proxyproto"
16
17 "git.sr.ht/~emersion/soju"
18 "git.sr.ht/~emersion/soju/config"
19)
20
21func main() {
22 var listen, configPath string
23 var debug bool
24 flag.StringVar(&listen, "listen", "", "listening address")
25 flag.StringVar(&configPath, "config", "", "path to configuration file")
26 flag.BoolVar(&debug, "debug", false, "enable debug logging")
27 flag.Parse()
28
29 var cfg *config.Server
30 if configPath != "" {
31 var err error
32 cfg, err = config.Load(configPath)
33 if err != nil {
34 log.Fatalf("failed to load config file: %v", err)
35 }
36 } else {
37 cfg = config.Defaults()
38 }
39
40 if listen != "" {
41 cfg.Listen = append(cfg.Listen, listen)
42 }
43 if len(cfg.Listen) == 0 {
44 cfg.Listen = []string{":6697"}
45 }
46
47 db, err := soju.OpenSQLDB(cfg.SQLDriver, cfg.SQLSource)
48 if err != nil {
49 log.Fatalf("failed to open database: %v", err)
50 }
51
52 var tlsCfg *tls.Config
53 if cfg.TLS != nil {
54 cert, err := tls.LoadX509KeyPair(cfg.TLS.CertPath, cfg.TLS.KeyPath)
55 if err != nil {
56 log.Fatalf("failed to load TLS certificate and key: %v", err)
57 }
58 tlsCfg = &tls.Config{Certificates: []tls.Certificate{cert}}
59 }
60
61 srv := soju.NewServer(db)
62 // TODO: load from config/DB
63 srv.Hostname = cfg.Hostname
64 srv.LogPath = cfg.LogPath
65 srv.HTTPOrigins = cfg.HTTPOrigins
66 srv.AcceptProxyIPs = cfg.AcceptProxyIPs
67 srv.Debug = debug
68
69 for _, listen := range cfg.Listen {
70 listenURI := listen
71 if !strings.Contains(listenURI, ":/") {
72 // This is a raw domain name, make it an URL with an empty scheme
73 listenURI = "//" + listenURI
74 }
75 u, err := url.Parse(listenURI)
76 if err != nil {
77 log.Fatalf("failed to parse listen URI %q: %v", listen, err)
78 }
79
80 switch u.Scheme {
81 case "ircs", "":
82 if tlsCfg == nil {
83 log.Fatalf("failed to listen on %q: missing TLS configuration", listen)
84 }
85 host := u.Host
86 if _, _, err := net.SplitHostPort(host); err != nil {
87 host = host + ":6697"
88 }
89 ircsTLSCfg := tlsCfg.Clone()
90 ircsTLSCfg.NextProtos = []string{"irc"}
91 ln, err := tls.Listen("tcp", host, ircsTLSCfg)
92 if err != nil {
93 log.Fatalf("failed to start TLS listener on %q: %v", listen, err)
94 }
95 ln = proxyProtoListener(ln, srv)
96 go func() {
97 if err := srv.Serve(ln); err != nil {
98 log.Printf("serving %q: %v", listen, err)
99 }
100 }()
101 case "irc+insecure":
102 host := u.Host
103 if _, _, err := net.SplitHostPort(host); err != nil {
104 host = host + ":6667"
105 }
106 ln, err := net.Listen("tcp", host)
107 if err != nil {
108 log.Fatalf("failed to start listener on %q: %v", listen, err)
109 }
110 ln = proxyProtoListener(ln, srv)
111 go func() {
112 if err := srv.Serve(ln); err != nil {
113 log.Printf("serving %q: %v", listen, err)
114 }
115 }()
116 case "unix":
117 ln, err := net.Listen("unix", u.Path)
118 if err != nil {
119 log.Fatalf("failed to start listener on %q: %v", listen, err)
120 }
121 ln = proxyProtoListener(ln, srv)
122 go func() {
123 if err := srv.Serve(ln); err != nil {
124 log.Printf("serving %q: %v", listen, err)
125 }
126 }()
127 case "wss":
128 addr := u.Host
129 if _, _, err := net.SplitHostPort(addr); err != nil {
130 addr = addr + ":https"
131 }
132 httpSrv := http.Server{
133 Addr: addr,
134 TLSConfig: tlsCfg,
135 Handler: srv,
136 }
137 go func() {
138 if err := httpSrv.ListenAndServeTLS("", ""); err != nil {
139 log.Fatalf("serving %q: %v", listen, err)
140 }
141 }()
142 case "ws+insecure":
143 addr := u.Host
144 if _, _, err := net.SplitHostPort(addr); err != nil {
145 addr = addr + ":http"
146 }
147 httpSrv := http.Server{
148 Addr: addr,
149 Handler: srv,
150 }
151 go func() {
152 if err := httpSrv.ListenAndServe(); err != nil {
153 log.Fatalf("serving %q: %v", listen, err)
154 }
155 }()
156 case "ident":
157 if srv.Identd == nil {
158 srv.Identd = soju.NewIdentd()
159 }
160
161 host := u.Host
162 if _, _, err := net.SplitHostPort(host); err != nil {
163 host = host + ":113"
164 }
165 ln, err := net.Listen("tcp", host)
166 if err != nil {
167 log.Fatalf("failed to start listener on %q: %v", listen, err)
168 }
169 ln = proxyProtoListener(ln, srv)
170 go func() {
171 if err := srv.Identd.Serve(ln); err != nil {
172 log.Printf("serving %q: %v", listen, err)
173 }
174 }()
175 default:
176 log.Fatalf("failed to listen on %q: unsupported scheme", listen)
177 }
178
179 log.Printf("server listening on %q", listen)
180 }
181
182 sigCh := make(chan os.Signal, 1)
183 signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
184
185 if err := srv.Start(); err != nil {
186 log.Fatal(err)
187 }
188
189 <-sigCh
190 log.Print("shutting down server")
191 srv.Shutdown()
192}
193
194func proxyProtoListener(ln net.Listener, srv *soju.Server) net.Listener {
195 return &proxyproto.Listener{
196 Listener: ln,
197 Policy: func(upstream net.Addr) (proxyproto.Policy, error) {
198 tcpAddr, ok := upstream.(*net.TCPAddr)
199 if !ok {
200 return proxyproto.IGNORE, nil
201 }
202 if srv.AcceptProxyIPs.Contains(tcpAddr.IP) {
203 return proxyproto.USE, nil
204 }
205 return proxyproto.IGNORE, nil
206 },
207 }
208}
Note: See TracBrowser for help on using the repository browser.