2020-03-13 13:13:03 -04:00
|
|
|
package soju
|
2020-02-04 04:46:22 -05:00
|
|
|
|
|
|
|
import (
|
2021-10-18 13:15:15 -04:00
|
|
|
"context"
|
2021-10-29 10:18:34 -04:00
|
|
|
"errors"
|
2020-02-04 04:46:22 -05:00
|
|
|
"fmt"
|
2021-10-29 10:18:34 -04:00
|
|
|
"io"
|
2020-02-07 05:36:42 -05:00
|
|
|
"log"
|
2021-03-18 07:08:25 -04:00
|
|
|
"mime"
|
2020-02-04 04:46:22 -05:00
|
|
|
"net"
|
2020-04-23 16:25:43 -04:00
|
|
|
"net/http"
|
2021-11-15 15:40:17 -05:00
|
|
|
"runtime/debug"
|
2020-02-06 15:30:44 -05:00
|
|
|
"sync"
|
2020-04-23 16:25:43 -04:00
|
|
|
"sync/atomic"
|
2020-02-18 11:26:17 -05:00
|
|
|
"time"
|
2020-02-04 04:46:22 -05:00
|
|
|
|
2021-11-27 05:48:10 -05:00
|
|
|
"github.com/SherClockHolmes/webpush-go"
|
2021-11-15 13:25:32 -05:00
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
2021-11-15 14:36:14 -05:00
|
|
|
"github.com/prometheus/client_golang/prometheus/promauto"
|
2022-11-14 06:06:58 -05:00
|
|
|
"gopkg.in/irc.v4"
|
2020-04-23 16:25:43 -04:00
|
|
|
"nhooyr.io/websocket"
|
2020-07-22 11:03:01 -04:00
|
|
|
|
|
|
|
"git.sr.ht/~emersion/soju/config"
|
2022-05-09 06:34:43 -04:00
|
|
|
"git.sr.ht/~emersion/soju/database"
|
2022-05-09 10:36:54 -04:00
|
|
|
"git.sr.ht/~emersion/soju/identd"
|
2020-02-04 04:46:22 -05:00
|
|
|
)
|
|
|
|
|
2020-02-18 11:26:17 -05:00
|
|
|
// TODO: make configurable
|
2021-12-02 06:12:23 -05:00
|
|
|
var retryConnectMinDelay = time.Minute
|
|
|
|
var retryConnectMaxDelay = 10 * time.Minute
|
|
|
|
var retryConnectJitter = time.Minute
|
2020-04-01 10:41:17 -04:00
|
|
|
var connectTimeout = 15 * time.Second
|
2020-04-01 10:25:03 -04:00
|
|
|
var writeTimeout = 10 * time.Second
|
2020-08-19 13:28:29 -04:00
|
|
|
var upstreamMessageDelay = 2 * time.Second
|
|
|
|
var upstreamMessageBurst = 10
|
2021-11-08 12:11:24 -05:00
|
|
|
var backlogTimeout = 10 * time.Second
|
|
|
|
var handleDownstreamMessageTimeout = 10 * time.Second
|
2021-11-17 08:54:03 -05:00
|
|
|
var downstreamRegisterTimeout = 30 * time.Second
|
2021-11-03 13:29:21 -04:00
|
|
|
var chatHistoryLimit = 1000
|
|
|
|
var backlogLimit = 4000
|
2020-02-18 11:26:17 -05:00
|
|
|
|
2021-11-27 05:48:10 -05:00
|
|
|
var errWebPushSubscriptionExpired = fmt.Errorf("Web Push subscription expired")
|
|
|
|
|
2020-02-06 09:50:46 -05:00
|
|
|
type Logger interface {
|
|
|
|
Printf(format string, v ...interface{})
|
2021-12-06 12:35:49 -05:00
|
|
|
Debugf(format string, v ...interface{})
|
|
|
|
}
|
|
|
|
|
|
|
|
type logger struct {
|
|
|
|
*log.Logger
|
|
|
|
debug bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l logger) Debugf(format string, v ...interface{}) {
|
|
|
|
if !l.debug {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
l.Logger.Printf(format, v...)
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewLogger(out io.Writer, debug bool) Logger {
|
|
|
|
return logger{
|
2022-08-02 04:09:36 -04:00
|
|
|
Logger: log.New(out, "", log.LstdFlags),
|
2021-12-06 12:35:49 -05:00
|
|
|
debug: debug,
|
|
|
|
}
|
2020-02-06 09:50:46 -05:00
|
|
|
}
|
|
|
|
|
2020-02-06 14:25:37 -05:00
|
|
|
type prefixLogger struct {
|
|
|
|
logger Logger
|
|
|
|
prefix string
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ Logger = (*prefixLogger)(nil)
|
|
|
|
|
|
|
|
func (l *prefixLogger) Printf(format string, v ...interface{}) {
|
|
|
|
v = append([]interface{}{l.prefix}, v...)
|
|
|
|
l.logger.Printf("%v"+format, v...)
|
|
|
|
}
|
|
|
|
|
2021-12-06 12:35:49 -05:00
|
|
|
func (l *prefixLogger) Debugf(format string, v ...interface{}) {
|
|
|
|
v = append([]interface{}{l.prefix}, v...)
|
|
|
|
l.logger.Debugf("%v"+format, v...)
|
|
|
|
}
|
|
|
|
|
2021-11-15 14:48:00 -05:00
|
|
|
type int64Gauge struct {
|
|
|
|
v int64 // atomic
|
|
|
|
}
|
|
|
|
|
|
|
|
func (g *int64Gauge) Add(delta int64) {
|
|
|
|
atomic.AddInt64(&g.v, delta)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (g *int64Gauge) Value() int64 {
|
|
|
|
return atomic.LoadInt64(&g.v)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (g *int64Gauge) Float64() float64 {
|
|
|
|
return float64(g.Value())
|
|
|
|
}
|
|
|
|
|
2022-01-19 16:35:46 -05:00
|
|
|
type retryListener struct {
|
|
|
|
net.Listener
|
|
|
|
Logger Logger
|
|
|
|
|
|
|
|
delay time.Duration
|
|
|
|
}
|
|
|
|
|
2022-05-09 10:36:54 -04:00
|
|
|
func NewRetryListener(ln net.Listener) net.Listener {
|
|
|
|
return &retryListener{Listener: ln}
|
|
|
|
}
|
|
|
|
|
2022-01-19 16:35:46 -05:00
|
|
|
func (ln *retryListener) Accept() (net.Conn, error) {
|
|
|
|
for {
|
|
|
|
conn, err := ln.Listener.Accept()
|
|
|
|
if ne, ok := err.(net.Error); ok && ne.Temporary() {
|
|
|
|
if ln.delay == 0 {
|
|
|
|
ln.delay = 5 * time.Millisecond
|
|
|
|
} else {
|
|
|
|
ln.delay *= 2
|
|
|
|
}
|
|
|
|
if max := 1 * time.Second; ln.delay > max {
|
|
|
|
ln.delay = max
|
|
|
|
}
|
|
|
|
if ln.Logger != nil {
|
|
|
|
ln.Logger.Printf("accept error (retrying in %v): %v", ln.delay, err)
|
|
|
|
}
|
|
|
|
time.Sleep(ln.delay)
|
|
|
|
} else {
|
|
|
|
ln.delay = 0
|
|
|
|
return conn, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-15 18:38:04 -05:00
|
|
|
type Config struct {
|
2021-10-07 14:43:10 -04:00
|
|
|
Hostname string
|
2021-11-02 17:38:07 -04:00
|
|
|
Title string
|
2021-10-07 14:43:10 -04:00
|
|
|
LogPath string
|
|
|
|
HTTPOrigins []string
|
|
|
|
AcceptProxyIPs config.IPSet
|
|
|
|
MaxUserNetworks int
|
2021-11-15 18:38:04 -05:00
|
|
|
MOTD string
|
2021-10-21 13:14:39 -04:00
|
|
|
UpstreamUserIPs []*net.IPNet
|
2021-11-15 18:38:04 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
type Server struct {
|
2021-11-15 13:25:32 -05:00
|
|
|
Logger Logger
|
2022-05-09 10:36:54 -04:00
|
|
|
Identd *identd.Identd // can be nil
|
2021-11-15 13:25:32 -05:00
|
|
|
MetricsRegistry prometheus.Registerer // can be nil
|
2020-03-04 12:22:58 -05:00
|
|
|
|
2021-11-15 14:48:00 -05:00
|
|
|
config atomic.Value // *Config
|
2022-05-09 06:34:43 -04:00
|
|
|
db database.Database
|
2021-11-15 14:48:00 -05:00
|
|
|
stopWG sync.WaitGroup
|
2020-02-06 15:11:35 -05:00
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
lock sync.Mutex
|
|
|
|
listeners map[net.Listener]struct{}
|
|
|
|
users map[string]*user
|
2022-09-18 15:37:45 -04:00
|
|
|
shutdown bool
|
2021-11-15 14:48:00 -05:00
|
|
|
|
|
|
|
metrics struct {
|
|
|
|
downstreams int64Gauge
|
2021-11-15 14:58:36 -05:00
|
|
|
upstreams int64Gauge
|
2021-11-15 15:11:23 -05:00
|
|
|
|
|
|
|
upstreamOutMessagesTotal prometheus.Counter
|
|
|
|
upstreamInMessagesTotal prometheus.Counter
|
|
|
|
downstreamOutMessagesTotal prometheus.Counter
|
|
|
|
downstreamInMessagesTotal prometheus.Counter
|
2021-12-02 05:15:51 -05:00
|
|
|
|
|
|
|
upstreamConnectErrorsTotal prometheus.Counter
|
2021-11-15 14:48:00 -05:00
|
|
|
}
|
2021-11-27 05:48:10 -05:00
|
|
|
|
|
|
|
webPush *database.WebPushConfig
|
2020-02-07 05:36:42 -05:00
|
|
|
}
|
|
|
|
|
2022-05-09 06:34:43 -04:00
|
|
|
func NewServer(db database.Database) *Server {
|
2021-10-13 04:58:34 -04:00
|
|
|
srv := &Server{
|
2021-12-06 12:35:49 -05:00
|
|
|
Logger: NewLogger(log.Writer(), true),
|
2021-11-15 18:38:04 -05:00
|
|
|
db: db,
|
|
|
|
listeners: make(map[net.Listener]struct{}),
|
|
|
|
users: make(map[string]*user),
|
2020-02-07 05:36:42 -05:00
|
|
|
}
|
2021-11-17 05:41:11 -05:00
|
|
|
srv.config.Store(&Config{
|
|
|
|
Hostname: "localhost",
|
|
|
|
MaxUserNetworks: -1,
|
|
|
|
})
|
2021-10-13 04:58:34 -04:00
|
|
|
return srv
|
2020-02-04 12:56:07 -05:00
|
|
|
}
|
2020-02-04 04:46:22 -05:00
|
|
|
|
2020-02-04 12:56:07 -05:00
|
|
|
func (s *Server) prefix() *irc.Prefix {
|
2021-11-15 18:38:04 -05:00
|
|
|
return &irc.Prefix{Name: s.Config().Hostname}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) Config() *Config {
|
|
|
|
return s.config.Load().(*Config)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) SetConfig(cfg *Config) {
|
|
|
|
s.config.Store(cfg)
|
2020-02-04 12:56:07 -05:00
|
|
|
}
|
2020-02-04 05:25:53 -05:00
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
func (s *Server) Start() error {
|
2021-11-15 14:36:14 -05:00
|
|
|
s.registerMetrics()
|
|
|
|
|
2021-11-27 05:48:10 -05:00
|
|
|
if err := s.loadWebPushConfig(context.TODO()); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-10-18 13:15:15 -04:00
|
|
|
users, err := s.db.ListUsers(context.TODO())
|
2020-03-04 12:22:58 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2020-03-03 09:26:19 -05:00
|
|
|
}
|
2020-02-07 05:36:42 -05:00
|
|
|
|
|
|
|
s.lock.Lock()
|
2020-08-07 09:31:07 -04:00
|
|
|
for i := range users {
|
|
|
|
s.addUserLocked(&users[i])
|
2020-02-06 10:03:07 -05:00
|
|
|
}
|
2020-03-04 12:22:58 -05:00
|
|
|
s.lock.Unlock()
|
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-11-15 14:36:14 -05:00
|
|
|
func (s *Server) registerMetrics() {
|
|
|
|
factory := promauto.With(s.MetricsRegistry)
|
|
|
|
|
|
|
|
factory.NewGaugeFunc(prometheus.GaugeOpts{
|
|
|
|
Name: "soju_users_active",
|
|
|
|
Help: "Current number of active users",
|
|
|
|
}, func() float64 {
|
|
|
|
s.lock.Lock()
|
|
|
|
n := len(s.users)
|
|
|
|
s.lock.Unlock()
|
|
|
|
return float64(n)
|
|
|
|
})
|
|
|
|
|
|
|
|
factory.NewGaugeFunc(prometheus.GaugeOpts{
|
|
|
|
Name: "soju_downstreams_active",
|
|
|
|
Help: "Current number of downstream connections",
|
2021-11-15 14:48:00 -05:00
|
|
|
}, s.metrics.downstreams.Float64)
|
2021-11-15 14:58:36 -05:00
|
|
|
|
|
|
|
factory.NewGaugeFunc(prometheus.GaugeOpts{
|
|
|
|
Name: "soju_upstreams_active",
|
|
|
|
Help: "Current number of upstream connections",
|
|
|
|
}, s.metrics.upstreams.Float64)
|
2021-11-15 15:11:23 -05:00
|
|
|
|
|
|
|
s.metrics.upstreamOutMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "soju_upstream_out_messages_total",
|
|
|
|
Help: "Total number of outgoing messages sent to upstream servers",
|
|
|
|
})
|
|
|
|
|
|
|
|
s.metrics.upstreamInMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "soju_upstream_in_messages_total",
|
|
|
|
Help: "Total number of incoming messages received from upstream servers",
|
|
|
|
})
|
|
|
|
|
|
|
|
s.metrics.downstreamOutMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "soju_downstream_out_messages_total",
|
|
|
|
Help: "Total number of outgoing messages sent to downstream clients",
|
|
|
|
})
|
|
|
|
|
|
|
|
s.metrics.downstreamInMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "soju_downstream_in_messages_total",
|
|
|
|
Help: "Total number of incoming messages received from downstream clients",
|
|
|
|
})
|
2021-12-02 05:15:51 -05:00
|
|
|
|
|
|
|
s.metrics.upstreamConnectErrorsTotal = factory.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "soju_upstream_connect_errors_total",
|
|
|
|
Help: "Total number of upstream connection errors",
|
|
|
|
})
|
2021-11-15 14:36:14 -05:00
|
|
|
}
|
|
|
|
|
2021-11-27 05:48:10 -05:00
|
|
|
func (s *Server) loadWebPushConfig(ctx context.Context) error {
|
|
|
|
configs, err := s.db.ListWebPushConfigs(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to list Web push configs: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(configs) > 1 {
|
|
|
|
return fmt.Errorf("expected zero or one Web push config, got %v", len(configs))
|
|
|
|
} else if len(configs) == 1 {
|
|
|
|
s.webPush = &configs[0]
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
s.Logger.Printf("generating Web push VAPID key pair")
|
|
|
|
priv, pub, err := webpush.GenerateVAPIDKeys()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to generate Web push VAPID key pair: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
config := new(database.WebPushConfig)
|
|
|
|
config.VAPIDKeys.Public = pub
|
|
|
|
config.VAPIDKeys.Private = priv
|
|
|
|
if err := s.db.StoreWebPushConfig(ctx, config); err != nil {
|
|
|
|
return fmt.Errorf("failed to store Web push config: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
s.webPush = config
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) sendWebPush(ctx context.Context, sub *webpush.Subscription, vapidPubKey string, msg *irc.Message) error {
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
|
|
|
|
defer cancel()
|
|
|
|
|
2022-08-17 10:04:11 -04:00
|
|
|
var urgency webpush.Urgency
|
|
|
|
switch msg.Command {
|
|
|
|
case "PRIVMSG", "NOTICE", "INVITE":
|
|
|
|
urgency = webpush.UrgencyHigh
|
|
|
|
default:
|
|
|
|
urgency = webpush.UrgencyNormal
|
|
|
|
}
|
|
|
|
|
2021-11-27 05:48:10 -05:00
|
|
|
options := webpush.Options{
|
|
|
|
VAPIDPublicKey: s.webPush.VAPIDKeys.Public,
|
|
|
|
VAPIDPrivateKey: s.webPush.VAPIDKeys.Private,
|
|
|
|
Subscriber: "https://soju.im",
|
|
|
|
TTL: 7 * 24 * 60 * 60, // seconds
|
2022-08-17 10:04:11 -04:00
|
|
|
Urgency: urgency,
|
2021-11-27 05:48:10 -05:00
|
|
|
RecordSize: 2048,
|
|
|
|
}
|
|
|
|
|
|
|
|
if vapidPubKey != options.VAPIDPublicKey {
|
|
|
|
return fmt.Errorf("unknown VAPID public key %q", vapidPubKey)
|
|
|
|
}
|
|
|
|
|
|
|
|
payload := []byte(msg.String())
|
|
|
|
resp, err := webpush.SendNotificationWithContext(ctx, payload, sub, &options)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
resp.Body.Close()
|
|
|
|
|
|
|
|
// 404 means the subscription has expired as per RFC 8030 section 7.3
|
|
|
|
if resp.StatusCode == http.StatusNotFound {
|
|
|
|
return errWebPushSubscriptionExpired
|
|
|
|
} else if resp.StatusCode/100 != 2 {
|
|
|
|
return fmt.Errorf("HTTP error: %v", resp.Status)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
func (s *Server) Shutdown() {
|
2022-09-18 15:43:31 -04:00
|
|
|
s.Logger.Printf("shutting down server")
|
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
s.lock.Lock()
|
2022-09-18 15:37:45 -04:00
|
|
|
s.shutdown = true
|
2021-02-09 11:34:46 -05:00
|
|
|
for ln := range s.listeners {
|
|
|
|
if err := ln.Close(); err != nil {
|
|
|
|
s.Logger.Printf("failed to stop listener: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for _, u := range s.users {
|
|
|
|
u.events <- eventStop{}
|
|
|
|
}
|
|
|
|
s.lock.Unlock()
|
|
|
|
|
2022-09-18 15:43:31 -04:00
|
|
|
s.Logger.Printf("waiting for users to finish")
|
2021-02-09 11:34:46 -05:00
|
|
|
s.stopWG.Wait()
|
2021-10-05 05:53:38 -04:00
|
|
|
|
|
|
|
if err := s.db.Close(); err != nil {
|
|
|
|
s.Logger.Printf("failed to close DB: %v", err)
|
|
|
|
}
|
2020-02-06 10:03:07 -05:00
|
|
|
}
|
|
|
|
|
2022-05-09 06:34:43 -04:00
|
|
|
func (s *Server) createUser(ctx context.Context, user *database.User) (*user, error) {
|
2020-06-06 19:30:27 -04:00
|
|
|
s.lock.Lock()
|
|
|
|
defer s.lock.Unlock()
|
|
|
|
|
|
|
|
if _, ok := s.users[user.Username]; ok {
|
|
|
|
return nil, fmt.Errorf("user %q already exists", user.Username)
|
|
|
|
}
|
|
|
|
|
2021-11-08 14:29:14 -05:00
|
|
|
err := s.db.StoreUser(ctx, user)
|
2020-06-06 19:30:27 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("could not create user in db: %v", err)
|
|
|
|
}
|
|
|
|
|
2020-08-07 09:31:07 -04:00
|
|
|
return s.addUserLocked(user), nil
|
2020-06-06 19:30:27 -04:00
|
|
|
}
|
|
|
|
|
2021-06-23 13:21:18 -04:00
|
|
|
func (s *Server) forEachUser(f func(*user)) {
|
|
|
|
s.lock.Lock()
|
|
|
|
for _, u := range s.users {
|
|
|
|
f(u)
|
|
|
|
}
|
|
|
|
s.lock.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-02-07 05:39:56 -05:00
|
|
|
func (s *Server) getUser(name string) *user {
|
|
|
|
s.lock.Lock()
|
|
|
|
u := s.users[name]
|
|
|
|
s.lock.Unlock()
|
|
|
|
return u
|
|
|
|
}
|
|
|
|
|
2022-05-09 06:34:43 -04:00
|
|
|
func (s *Server) addUserLocked(user *database.User) *user {
|
2020-08-07 09:31:07 -04:00
|
|
|
s.Logger.Printf("starting bouncer for user %q", user.Username)
|
|
|
|
u := newUser(s, user)
|
|
|
|
s.users[u.Username] = u
|
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
s.stopWG.Add(1)
|
|
|
|
|
2020-08-07 09:31:07 -04:00
|
|
|
go func() {
|
2021-11-15 15:40:17 -05:00
|
|
|
defer func() {
|
|
|
|
if err := recover(); err != nil {
|
2022-04-04 03:54:48 -04:00
|
|
|
s.Logger.Printf("panic serving user %q: %v\n%v", user.Username, err, string(debug.Stack()))
|
2021-11-15 15:40:17 -05:00
|
|
|
}
|
|
|
|
|
2021-12-08 09:00:02 -05:00
|
|
|
s.lock.Lock()
|
|
|
|
delete(s.users, u.Username)
|
|
|
|
s.lock.Unlock()
|
2020-08-07 09:31:07 -04:00
|
|
|
|
2021-12-08 09:00:02 -05:00
|
|
|
s.stopWG.Done()
|
|
|
|
}()
|
2021-02-09 11:34:46 -05:00
|
|
|
|
2021-12-08 09:00:02 -05:00
|
|
|
u.run()
|
2020-08-07 09:31:07 -04:00
|
|
|
}()
|
|
|
|
|
|
|
|
return u
|
|
|
|
}
|
|
|
|
|
2022-04-04 03:59:16 -04:00
|
|
|
var lastDownstreamID uint64
|
2020-04-23 16:25:43 -04:00
|
|
|
|
2020-07-01 11:02:37 -04:00
|
|
|
func (s *Server) handle(ic ircConn) {
|
2021-11-15 15:40:17 -05:00
|
|
|
defer func() {
|
|
|
|
if err := recover(); err != nil {
|
2022-08-07 16:38:13 -04:00
|
|
|
s.Logger.Printf("panic serving downstream %q: %v\n%v", ic.RemoteAddr(), err, string(debug.Stack()))
|
2021-11-15 15:40:17 -05:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2022-09-18 15:37:45 -04:00
|
|
|
s.lock.Lock()
|
|
|
|
shutdown := s.shutdown
|
|
|
|
s.lock.Unlock()
|
|
|
|
|
2021-11-15 14:48:00 -05:00
|
|
|
s.metrics.downstreams.Add(1)
|
2020-04-23 16:25:43 -04:00
|
|
|
id := atomic.AddUint64(&lastDownstreamID, 1)
|
2020-07-01 11:02:37 -04:00
|
|
|
dc := newDownstreamConn(s, ic, id)
|
2022-09-18 15:37:45 -04:00
|
|
|
if shutdown {
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
|
|
Command: "ERROR",
|
|
|
|
Params: []string{"Server is shutting down"},
|
|
|
|
})
|
|
|
|
} else if err := dc.runUntilRegistered(); err != nil {
|
2021-10-29 10:03:04 -04:00
|
|
|
if !errors.Is(err, io.EOF) {
|
2021-12-06 12:27:36 -05:00
|
|
|
dc.logger.Printf("%v", err)
|
2021-10-29 10:03:04 -04:00
|
|
|
}
|
2020-04-23 16:25:43 -04:00
|
|
|
} else {
|
|
|
|
dc.user.events <- eventDownstreamConnected{dc}
|
|
|
|
if err := dc.readMessages(dc.user.events); err != nil {
|
2021-12-06 12:27:36 -05:00
|
|
|
dc.logger.Printf("%v", err)
|
2020-04-23 16:25:43 -04:00
|
|
|
}
|
|
|
|
dc.user.events <- eventDownstreamDisconnected{dc}
|
|
|
|
}
|
|
|
|
dc.Close()
|
2021-11-15 14:48:00 -05:00
|
|
|
s.metrics.downstreams.Add(-1)
|
2020-04-23 16:25:43 -04:00
|
|
|
}
|
|
|
|
|
2020-02-04 05:25:53 -05:00
|
|
|
func (s *Server) Serve(ln net.Listener) error {
|
2022-01-19 16:35:46 -05:00
|
|
|
ln = &retryListener{
|
|
|
|
Listener: ln,
|
|
|
|
Logger: &prefixLogger{logger: s.Logger, prefix: fmt.Sprintf("listener %v: ", ln.Addr())},
|
|
|
|
}
|
|
|
|
|
2021-02-09 11:34:46 -05:00
|
|
|
s.lock.Lock()
|
|
|
|
s.listeners[ln] = struct{}{}
|
|
|
|
s.lock.Unlock()
|
|
|
|
|
|
|
|
s.stopWG.Add(1)
|
|
|
|
|
|
|
|
defer func() {
|
|
|
|
s.lock.Lock()
|
|
|
|
delete(s.listeners, ln)
|
|
|
|
s.lock.Unlock()
|
|
|
|
|
|
|
|
s.stopWG.Done()
|
|
|
|
}()
|
|
|
|
|
2020-02-04 04:46:22 -05:00
|
|
|
for {
|
2020-04-23 16:25:43 -04:00
|
|
|
conn, err := ln.Accept()
|
2021-10-05 08:02:59 -04:00
|
|
|
if isErrClosed(err) {
|
2021-02-09 11:34:46 -05:00
|
|
|
return nil
|
|
|
|
} else if err != nil {
|
2020-02-04 04:46:22 -05:00
|
|
|
return fmt.Errorf("failed to accept connection: %v", err)
|
|
|
|
}
|
|
|
|
|
2020-07-01 11:02:37 -04:00
|
|
|
go s.handle(newNetIRCConn(conn))
|
2020-04-23 16:25:43 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
|
|
|
conn, err := websocket.Accept(w, req, &websocket.AcceptOptions{
|
2021-09-28 15:25:06 -04:00
|
|
|
Subprotocols: []string{"text.ircv3.net"}, // non-compliant, fight me
|
2021-11-15 18:38:04 -05:00
|
|
|
OriginPatterns: s.Config().HTTPOrigins,
|
2020-04-23 16:25:43 -04:00
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
s.Logger.Printf("failed to serve HTTP connection: %v", err)
|
|
|
|
return
|
2020-02-04 04:46:22 -05:00
|
|
|
}
|
2020-06-29 12:33:23 -04:00
|
|
|
|
2020-07-22 11:03:01 -04:00
|
|
|
isProxy := false
|
2020-06-29 12:33:23 -04:00
|
|
|
if host, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
|
|
|
|
if ip := net.ParseIP(host); ip != nil {
|
2021-11-15 18:38:04 -05:00
|
|
|
isProxy = s.Config().AcceptProxyIPs.Contains(ip)
|
2020-06-29 12:33:23 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-18 08:22:28 -04:00
|
|
|
// Only trust the Forwarded header field if this is a trusted proxy IP
|
2020-06-29 12:33:23 -04:00
|
|
|
// to prevent users from spoofing the remote address
|
2020-06-29 12:27:43 -04:00
|
|
|
remoteAddr := req.RemoteAddr
|
2021-03-18 07:08:25 -04:00
|
|
|
if isProxy {
|
|
|
|
forwarded := parseForwarded(req.Header)
|
2021-03-18 08:21:38 -04:00
|
|
|
if forwarded["for"] != "" {
|
|
|
|
remoteAddr = forwarded["for"]
|
2021-03-18 07:08:25 -04:00
|
|
|
}
|
2020-06-29 12:27:43 -04:00
|
|
|
}
|
2020-06-29 12:33:23 -04:00
|
|
|
|
2020-07-01 11:02:37 -04:00
|
|
|
s.handle(newWebsocketIRCConn(conn, remoteAddr))
|
2020-02-04 04:46:22 -05:00
|
|
|
}
|
2021-03-18 07:08:25 -04:00
|
|
|
|
|
|
|
func parseForwarded(h http.Header) map[string]string {
|
|
|
|
forwarded := h.Get("Forwarded")
|
|
|
|
if forwarded == "" {
|
2021-03-18 08:22:28 -04:00
|
|
|
return map[string]string{
|
|
|
|
"for": h.Get("X-Forwarded-For"),
|
|
|
|
"proto": h.Get("X-Forwarded-Proto"),
|
|
|
|
"host": h.Get("X-Forwarded-Host"),
|
|
|
|
}
|
2021-03-18 07:08:25 -04:00
|
|
|
}
|
|
|
|
// Hack to easily parse header parameters
|
|
|
|
_, params, _ := mime.ParseMediaType("hack; " + forwarded)
|
|
|
|
return params
|
|
|
|
}
|
2021-10-05 13:12:25 -04:00
|
|
|
|
|
|
|
type ServerStats struct {
|
|
|
|
Users int
|
|
|
|
Downstreams int64
|
2021-11-15 14:58:36 -05:00
|
|
|
Upstreams int64
|
2021-10-05 13:12:25 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Server) Stats() *ServerStats {
|
|
|
|
var stats ServerStats
|
|
|
|
s.lock.Lock()
|
|
|
|
stats.Users = len(s.users)
|
|
|
|
s.lock.Unlock()
|
2021-11-15 14:48:00 -05:00
|
|
|
stats.Downstreams = s.metrics.downstreams.Value()
|
2021-11-15 14:58:36 -05:00
|
|
|
stats.Upstreams = s.metrics.upstreams.Value()
|
2021-10-05 13:12:25 -04:00
|
|
|
return &stats
|
|
|
|
}
|