313c6e7f97
Once the downstream connection has logged in with their bouncer credentials, allow them to issue more SASL auths which will be redirected to the upstream network. This allows downstream clients to provide UIs to login to transparently login to upstream networks.
2056 lines
52 KiB
Go
2056 lines
52 KiB
Go
package soju
|
|
|
|
import (
|
|
"context"
|
|
"crypto"
|
|
"crypto/sha256"
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/emersion/go-sasl"
|
|
"gopkg.in/irc.v3"
|
|
)
|
|
|
|
// permanentUpstreamCaps is the static list of upstream capabilities always
|
|
// requested when supported.
|
|
var permanentUpstreamCaps = map[string]bool{
|
|
"account-notify": true,
|
|
"account-tag": true,
|
|
"away-notify": true,
|
|
"batch": true,
|
|
"extended-join": true,
|
|
"invite-notify": true,
|
|
"labeled-response": true,
|
|
"message-tags": true,
|
|
"multi-prefix": true,
|
|
"sasl": true,
|
|
"server-time": true,
|
|
"setname": true,
|
|
|
|
"draft/extended-monitor": true,
|
|
}
|
|
|
|
type registrationError string
|
|
|
|
func (err registrationError) Error() string {
|
|
return fmt.Sprintf("registration error: %v", string(err))
|
|
}
|
|
|
|
type upstreamChannel struct {
|
|
Name string
|
|
conn *upstreamConn
|
|
Topic string
|
|
TopicWho *irc.Prefix
|
|
TopicTime time.Time
|
|
Status channelStatus
|
|
modes channelModes
|
|
creationTime string
|
|
Members membershipsCasemapMap
|
|
complete bool
|
|
detachTimer *time.Timer
|
|
}
|
|
|
|
func (uc *upstreamChannel) updateAutoDetach(dur time.Duration) {
|
|
if uc.detachTimer != nil {
|
|
uc.detachTimer.Stop()
|
|
uc.detachTimer = nil
|
|
}
|
|
|
|
if dur == 0 {
|
|
return
|
|
}
|
|
|
|
uc.detachTimer = time.AfterFunc(dur, func() {
|
|
uc.conn.network.user.events <- eventChannelDetach{
|
|
uc: uc.conn,
|
|
name: uc.Name,
|
|
}
|
|
})
|
|
}
|
|
|
|
type pendingUpstreamCommand struct {
|
|
downstreamID uint64
|
|
msg *irc.Message
|
|
}
|
|
|
|
type upstreamConn struct {
|
|
conn
|
|
|
|
network *network
|
|
user *user
|
|
|
|
serverName string
|
|
availableUserModes string
|
|
availableChannelModes map[byte]channelModeType
|
|
availableChannelTypes string
|
|
availableMemberships []membership
|
|
isupport map[string]*string
|
|
|
|
registered bool
|
|
nick string
|
|
nickCM string
|
|
username string
|
|
realname string
|
|
modes userModes
|
|
channels upstreamChannelCasemapMap
|
|
supportedCaps map[string]string
|
|
caps map[string]bool
|
|
batches map[string]batch
|
|
away bool
|
|
account string
|
|
nextLabelID uint64
|
|
monitored monitorCasemapMap
|
|
|
|
saslClient sasl.Client
|
|
saslStarted bool
|
|
|
|
casemapIsSet bool
|
|
|
|
// Queue of commands in progress, indexed by type. The first entry has been
|
|
// sent to the server and is awaiting reply. The following entries have not
|
|
// been sent yet.
|
|
pendingCmds map[string][]pendingUpstreamCommand
|
|
|
|
gotMotd bool
|
|
}
|
|
|
|
func connectToUpstream(network *network) (*upstreamConn, error) {
|
|
logger := &prefixLogger{network.user.logger, fmt.Sprintf("upstream %q: ", network.GetName())}
|
|
|
|
dialer := net.Dialer{Timeout: connectTimeout}
|
|
|
|
u, err := network.URL()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var netConn net.Conn
|
|
switch u.Scheme {
|
|
case "ircs":
|
|
addr := u.Host
|
|
host, _, err := net.SplitHostPort(u.Host)
|
|
if err != nil {
|
|
host = u.Host
|
|
addr = u.Host + ":6697"
|
|
}
|
|
|
|
dialer.LocalAddr, err = network.user.localTCPAddrForHost(host)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to pick local IP for remote host %q: %v", host, err)
|
|
}
|
|
|
|
logger.Printf("connecting to TLS server at address %q", addr)
|
|
|
|
tlsConfig := &tls.Config{ServerName: host, NextProtos: []string{"irc"}}
|
|
if network.SASL.Mechanism == "EXTERNAL" {
|
|
if network.SASL.External.CertBlob == nil {
|
|
return nil, fmt.Errorf("missing certificate for authentication")
|
|
}
|
|
if network.SASL.External.PrivKeyBlob == nil {
|
|
return nil, fmt.Errorf("missing private key for authentication")
|
|
}
|
|
key, err := x509.ParsePKCS8PrivateKey(network.SASL.External.PrivKeyBlob)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse private key: %v", err)
|
|
}
|
|
tlsConfig.Certificates = []tls.Certificate{
|
|
{
|
|
Certificate: [][]byte{network.SASL.External.CertBlob},
|
|
PrivateKey: key.(crypto.PrivateKey),
|
|
},
|
|
}
|
|
logger.Printf("using TLS client certificate %x", sha256.Sum256(network.SASL.External.CertBlob))
|
|
}
|
|
|
|
netConn, err = dialer.Dial("tcp", addr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
|
|
}
|
|
|
|
// Don't do the TLS handshake immediately, because we need to register
|
|
// the new connection with identd ASAP. See:
|
|
// https://todo.sr.ht/~emersion/soju/69#event-41859
|
|
netConn = tls.Client(netConn, tlsConfig)
|
|
case "irc+insecure":
|
|
addr := u.Host
|
|
host, _, err := net.SplitHostPort(addr)
|
|
if err != nil {
|
|
host = u.Host
|
|
addr = u.Host + ":6667"
|
|
}
|
|
|
|
dialer.LocalAddr, err = network.user.localTCPAddrForHost(host)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to pick local IP for remote host %q: %v", host, err)
|
|
}
|
|
|
|
logger.Printf("connecting to plain-text server at address %q", addr)
|
|
netConn, err = dialer.Dial("tcp", addr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
|
|
}
|
|
case "irc+unix", "unix":
|
|
logger.Printf("connecting to Unix socket at path %q", u.Path)
|
|
netConn, err = dialer.Dial("unix", u.Path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to connect to Unix socket %q: %v", u.Path, err)
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("failed to dial %q: unknown scheme: %v", network.Addr, u.Scheme)
|
|
}
|
|
|
|
options := connOptions{
|
|
Logger: logger,
|
|
RateLimitDelay: upstreamMessageDelay,
|
|
RateLimitBurst: upstreamMessageBurst,
|
|
}
|
|
|
|
uc := &upstreamConn{
|
|
conn: *newConn(network.user.srv, newNetIRCConn(netConn), &options),
|
|
network: network,
|
|
user: network.user,
|
|
channels: upstreamChannelCasemapMap{newCasemapMap(0)},
|
|
supportedCaps: make(map[string]string),
|
|
caps: make(map[string]bool),
|
|
batches: make(map[string]batch),
|
|
availableChannelTypes: stdChannelTypes,
|
|
availableChannelModes: stdChannelModes,
|
|
availableMemberships: stdMemberships,
|
|
isupport: make(map[string]*string),
|
|
pendingCmds: make(map[string][]pendingUpstreamCommand),
|
|
monitored: monitorCasemapMap{newCasemapMap(0)},
|
|
}
|
|
return uc, nil
|
|
}
|
|
|
|
func (uc *upstreamConn) forEachDownstream(f func(*downstreamConn)) {
|
|
uc.network.forEachDownstream(f)
|
|
}
|
|
|
|
func (uc *upstreamConn) forEachDownstreamByID(id uint64, f func(*downstreamConn)) {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if id != 0 && id != dc.id {
|
|
return
|
|
}
|
|
f(dc)
|
|
})
|
|
}
|
|
|
|
func (uc *upstreamConn) downstreamByID(id uint64) *downstreamConn {
|
|
for _, dc := range uc.user.downstreamConns {
|
|
if dc.id == id {
|
|
return dc
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
|
|
ch := uc.channels.Value(name)
|
|
if ch == nil {
|
|
return nil, fmt.Errorf("unknown channel %q", name)
|
|
}
|
|
return ch, nil
|
|
}
|
|
|
|
func (uc *upstreamConn) isChannel(entity string) bool {
|
|
return strings.ContainsRune(uc.availableChannelTypes, rune(entity[0]))
|
|
}
|
|
|
|
func (uc *upstreamConn) isOurNick(nick string) bool {
|
|
return uc.nickCM == uc.network.casemap(nick)
|
|
}
|
|
|
|
func (uc *upstreamConn) endPendingCommands() {
|
|
for _, l := range uc.pendingCmds {
|
|
for _, pendingCmd := range l {
|
|
dc := uc.downstreamByID(pendingCmd.downstreamID)
|
|
if dc == nil {
|
|
continue
|
|
}
|
|
|
|
switch pendingCmd.msg.Command {
|
|
case "LIST":
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_LISTEND,
|
|
Params: []string{dc.nick, "End of /LIST"},
|
|
})
|
|
case "WHO":
|
|
mask := "*"
|
|
if len(pendingCmd.msg.Params) > 0 {
|
|
mask = pendingCmd.msg.Params[0]
|
|
}
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_ENDOFWHO,
|
|
Params: []string{dc.nick, mask, "End of /WHO"},
|
|
})
|
|
case "AUTHENTICATE":
|
|
dc.endSASL(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.ERR_SASLABORTED,
|
|
Params: []string{dc.nick, "SASL authentication aborted"},
|
|
})
|
|
default:
|
|
panic(fmt.Errorf("Unsupported pending command %q", pendingCmd.msg.Command))
|
|
}
|
|
}
|
|
}
|
|
|
|
uc.pendingCmds = make(map[string][]pendingUpstreamCommand)
|
|
}
|
|
|
|
func (uc *upstreamConn) sendNextPendingCommand(cmd string) {
|
|
if len(uc.pendingCmds[cmd]) == 0 {
|
|
return
|
|
}
|
|
uc.SendMessage(uc.pendingCmds[cmd][0].msg)
|
|
}
|
|
|
|
func (uc *upstreamConn) enqueueCommand(dc *downstreamConn, msg *irc.Message) {
|
|
switch msg.Command {
|
|
case "LIST", "WHO", "AUTHENTICATE":
|
|
// Supported
|
|
default:
|
|
panic(fmt.Errorf("Unsupported pending command %q", msg.Command))
|
|
}
|
|
|
|
uc.pendingCmds[msg.Command] = append(uc.pendingCmds[msg.Command], pendingUpstreamCommand{
|
|
downstreamID: dc.id,
|
|
msg: msg,
|
|
})
|
|
|
|
if len(uc.pendingCmds[msg.Command]) == 1 {
|
|
uc.sendNextPendingCommand(msg.Command)
|
|
}
|
|
}
|
|
|
|
func (uc *upstreamConn) currentPendingCommand(cmd string) (*downstreamConn, *irc.Message) {
|
|
if len(uc.pendingCmds[cmd]) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
pendingCmd := uc.pendingCmds[cmd][0]
|
|
return uc.downstreamByID(pendingCmd.downstreamID), pendingCmd.msg
|
|
}
|
|
|
|
func (uc *upstreamConn) dequeueCommand(cmd string) (*downstreamConn, *irc.Message) {
|
|
dc, msg := uc.currentPendingCommand(cmd)
|
|
|
|
if len(uc.pendingCmds[cmd]) > 0 {
|
|
copy(uc.pendingCmds[cmd], uc.pendingCmds[cmd][1:])
|
|
uc.pendingCmds[cmd] = uc.pendingCmds[cmd][:len(uc.pendingCmds[cmd])-1]
|
|
}
|
|
|
|
uc.sendNextPendingCommand(cmd)
|
|
|
|
return dc, msg
|
|
}
|
|
|
|
func (uc *upstreamConn) parseMembershipPrefix(s string) (ms *memberships, nick string) {
|
|
memberships := make(memberships, 0, 4)
|
|
i := 0
|
|
for _, m := range uc.availableMemberships {
|
|
if i >= len(s) {
|
|
break
|
|
}
|
|
if s[i] == m.Prefix {
|
|
memberships = append(memberships, m)
|
|
i++
|
|
}
|
|
}
|
|
return &memberships, s[i:]
|
|
}
|
|
|
|
func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
|
|
var label string
|
|
if l, ok := msg.GetTag("label"); ok {
|
|
label = l
|
|
delete(msg.Tags, "label")
|
|
}
|
|
|
|
var msgBatch *batch
|
|
if batchName, ok := msg.GetTag("batch"); ok {
|
|
b, ok := uc.batches[batchName]
|
|
if !ok {
|
|
return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
|
|
}
|
|
msgBatch = &b
|
|
if label == "" {
|
|
label = msgBatch.Label
|
|
}
|
|
delete(msg.Tags, "batch")
|
|
}
|
|
|
|
var downstreamID uint64 = 0
|
|
if label != "" {
|
|
var labelOffset uint64
|
|
n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
|
|
if err == nil && n < 2 {
|
|
err = errors.New("not enough arguments")
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
|
|
}
|
|
}
|
|
|
|
if _, ok := msg.Tags["time"]; !ok {
|
|
msg.Tags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
|
|
}
|
|
|
|
switch msg.Command {
|
|
case "PING":
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "PONG",
|
|
Params: msg.Params,
|
|
})
|
|
return nil
|
|
case "NOTICE", "PRIVMSG", "TAGMSG":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var entity, text string
|
|
if msg.Command != "TAGMSG" {
|
|
if err := parseMessageParams(msg, &entity, &text); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err := parseMessageParams(msg, &entity); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if msg.Prefix.Name == serviceNick {
|
|
uc.logger.Printf("skipping %v from soju's service: %v", msg.Command, msg)
|
|
break
|
|
}
|
|
if entity == serviceNick {
|
|
uc.logger.Printf("skipping %v to soju's service: %v", msg.Command, msg)
|
|
break
|
|
}
|
|
|
|
if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
|
|
uc.produce("", msg, nil)
|
|
} else { // regular user message
|
|
target := entity
|
|
if uc.isOurNick(target) {
|
|
target = msg.Prefix.Name
|
|
}
|
|
|
|
ch := uc.network.channels.Value(target)
|
|
if ch != nil && msg.Command != "TAGMSG" {
|
|
if ch.Detached {
|
|
uc.handleDetachedMessage(ch, msg)
|
|
}
|
|
|
|
highlight := uc.network.isHighlight(msg)
|
|
if ch.DetachOn == FilterMessage || ch.DetachOn == FilterDefault || (ch.DetachOn == FilterHighlight && highlight) {
|
|
uc.updateChannelAutoDetach(target)
|
|
}
|
|
}
|
|
|
|
uc.produce(target, msg, nil)
|
|
}
|
|
case "CAP":
|
|
var subCmd string
|
|
if err := parseMessageParams(msg, nil, &subCmd); err != nil {
|
|
return err
|
|
}
|
|
subCmd = strings.ToUpper(subCmd)
|
|
subParams := msg.Params[2:]
|
|
switch subCmd {
|
|
case "LS":
|
|
if len(subParams) < 1 {
|
|
return newNeedMoreParamsError(msg.Command)
|
|
}
|
|
caps := subParams[len(subParams)-1]
|
|
more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
|
|
|
|
uc.handleSupportedCaps(caps)
|
|
|
|
if more {
|
|
break // wait to receive all capabilities
|
|
}
|
|
|
|
uc.requestCaps()
|
|
|
|
if uc.requestSASL() {
|
|
break // we'll send CAP END after authentication is completed
|
|
}
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "CAP",
|
|
Params: []string{"END"},
|
|
})
|
|
case "ACK", "NAK":
|
|
if len(subParams) < 1 {
|
|
return newNeedMoreParamsError(msg.Command)
|
|
}
|
|
caps := strings.Fields(subParams[0])
|
|
|
|
for _, name := range caps {
|
|
if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if uc.registered {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateSupportedCaps()
|
|
})
|
|
}
|
|
case "NEW":
|
|
if len(subParams) < 1 {
|
|
return newNeedMoreParamsError(msg.Command)
|
|
}
|
|
uc.handleSupportedCaps(subParams[0])
|
|
uc.requestCaps()
|
|
case "DEL":
|
|
if len(subParams) < 1 {
|
|
return newNeedMoreParamsError(msg.Command)
|
|
}
|
|
caps := strings.Fields(subParams[0])
|
|
|
|
for _, c := range caps {
|
|
delete(uc.supportedCaps, c)
|
|
delete(uc.caps, c)
|
|
}
|
|
|
|
if uc.registered {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateSupportedCaps()
|
|
})
|
|
}
|
|
default:
|
|
uc.logger.Printf("unhandled message: %v", msg)
|
|
}
|
|
case "AUTHENTICATE":
|
|
if uc.saslClient == nil {
|
|
return fmt.Errorf("received unexpected AUTHENTICATE message")
|
|
}
|
|
|
|
// TODO: if a challenge is 400 bytes long, buffer it
|
|
var challengeStr string
|
|
if err := parseMessageParams(msg, &challengeStr); err != nil {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AUTHENTICATE",
|
|
Params: []string{"*"},
|
|
})
|
|
return err
|
|
}
|
|
|
|
var challenge []byte
|
|
if challengeStr != "+" {
|
|
var err error
|
|
challenge, err = base64.StdEncoding.DecodeString(challengeStr)
|
|
if err != nil {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AUTHENTICATE",
|
|
Params: []string{"*"},
|
|
})
|
|
return err
|
|
}
|
|
}
|
|
|
|
var resp []byte
|
|
var err error
|
|
if !uc.saslStarted {
|
|
_, resp, err = uc.saslClient.Start()
|
|
uc.saslStarted = true
|
|
} else {
|
|
resp, err = uc.saslClient.Next(challenge)
|
|
}
|
|
if err != nil {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AUTHENTICATE",
|
|
Params: []string{"*"},
|
|
})
|
|
return err
|
|
}
|
|
|
|
// TODO: send response in multiple chunks if >= 400 bytes
|
|
var respStr = "+"
|
|
if len(resp) != 0 {
|
|
respStr = base64.StdEncoding.EncodeToString(resp)
|
|
}
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AUTHENTICATE",
|
|
Params: []string{respStr},
|
|
})
|
|
case irc.RPL_LOGGEDIN:
|
|
if err := parseMessageParams(msg, nil, nil, &uc.account); err != nil {
|
|
return err
|
|
}
|
|
uc.logger.Printf("logged in with account %q", uc.account)
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateAccount()
|
|
})
|
|
case irc.RPL_LOGGEDOUT:
|
|
uc.account = ""
|
|
uc.logger.Printf("logged out")
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateAccount()
|
|
})
|
|
case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
|
|
var info string
|
|
if err := parseMessageParams(msg, nil, &info); err != nil {
|
|
return err
|
|
}
|
|
switch msg.Command {
|
|
case irc.ERR_NICKLOCKED:
|
|
uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
|
|
case irc.ERR_SASLFAIL:
|
|
uc.logger.Printf("SASL authentication failed: %v", info)
|
|
case irc.ERR_SASLTOOLONG:
|
|
uc.logger.Printf("SASL message too long: %v", info)
|
|
}
|
|
|
|
uc.saslClient = nil
|
|
uc.saslStarted = false
|
|
|
|
if dc, _ := uc.dequeueCommand("AUTHENTICATE"); dc != nil && dc.sasl != nil {
|
|
if msg.Command == irc.RPL_SASLSUCCESS {
|
|
uc.network.autoSaveSASLPlain(context.TODO(), dc.sasl.plainUsername, dc.sasl.plainPassword)
|
|
}
|
|
|
|
dc.endSASL(msg)
|
|
}
|
|
|
|
if !uc.registered {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "CAP",
|
|
Params: []string{"END"},
|
|
})
|
|
}
|
|
case irc.RPL_WELCOME:
|
|
uc.registered = true
|
|
uc.logger.Printf("connection registered")
|
|
|
|
if uc.network.channels.Len() > 0 {
|
|
var channels, keys []string
|
|
for _, entry := range uc.network.channels.innerMap {
|
|
ch := entry.value.(*Channel)
|
|
channels = append(channels, ch.Name)
|
|
keys = append(keys, ch.Key)
|
|
}
|
|
|
|
for _, msg := range join(channels, keys) {
|
|
uc.SendMessage(msg)
|
|
}
|
|
}
|
|
case irc.RPL_MYINFO:
|
|
if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
|
|
return err
|
|
}
|
|
case irc.RPL_ISUPPORT:
|
|
if err := parseMessageParams(msg, nil, nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
var downstreamIsupport []string
|
|
for _, token := range msg.Params[1 : len(msg.Params)-1] {
|
|
parameter := token
|
|
var negate, hasValue bool
|
|
var value string
|
|
if strings.HasPrefix(token, "-") {
|
|
negate = true
|
|
token = token[1:]
|
|
} else if i := strings.IndexByte(token, '='); i >= 0 {
|
|
parameter = token[:i]
|
|
value = token[i+1:]
|
|
hasValue = true
|
|
}
|
|
|
|
if hasValue {
|
|
uc.isupport[parameter] = &value
|
|
} else if !negate {
|
|
uc.isupport[parameter] = nil
|
|
} else {
|
|
delete(uc.isupport, parameter)
|
|
}
|
|
|
|
var err error
|
|
switch parameter {
|
|
case "CASEMAPPING":
|
|
casemap, ok := parseCasemappingToken(value)
|
|
if !ok {
|
|
casemap = casemapRFC1459
|
|
}
|
|
uc.network.updateCasemapping(casemap)
|
|
uc.nickCM = uc.network.casemap(uc.nick)
|
|
uc.casemapIsSet = true
|
|
case "CHANMODES":
|
|
if !negate {
|
|
err = uc.handleChanModes(value)
|
|
} else {
|
|
uc.availableChannelModes = stdChannelModes
|
|
}
|
|
case "CHANTYPES":
|
|
if !negate {
|
|
uc.availableChannelTypes = value
|
|
} else {
|
|
uc.availableChannelTypes = stdChannelTypes
|
|
}
|
|
case "PREFIX":
|
|
if !negate {
|
|
err = uc.handleMemberships(value)
|
|
} else {
|
|
uc.availableMemberships = stdMemberships
|
|
}
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if passthroughIsupport[parameter] {
|
|
downstreamIsupport = append(downstreamIsupport, token)
|
|
}
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if dc.network == nil {
|
|
return
|
|
}
|
|
msgs := generateIsupport(dc.srv.prefix(), dc.nick, downstreamIsupport)
|
|
for _, msg := range msgs {
|
|
dc.SendMessage(msg)
|
|
}
|
|
})
|
|
case irc.ERR_NOMOTD, irc.RPL_ENDOFMOTD:
|
|
if !uc.casemapIsSet {
|
|
// upstream did not send any CASEMAPPING token, thus
|
|
// we assume it implements the old RFCs with rfc1459.
|
|
uc.casemapIsSet = true
|
|
uc.network.updateCasemapping(casemapRFC1459)
|
|
uc.nickCM = uc.network.casemap(uc.nick)
|
|
}
|
|
|
|
if !uc.gotMotd {
|
|
// Ignore the initial MOTD upon connection, but forward
|
|
// subsequent MOTD messages downstream
|
|
uc.gotMotd = true
|
|
return nil
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: uc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: msg.Params,
|
|
})
|
|
})
|
|
case "BATCH":
|
|
var tag string
|
|
if err := parseMessageParams(msg, &tag); err != nil {
|
|
return err
|
|
}
|
|
|
|
if strings.HasPrefix(tag, "+") {
|
|
tag = tag[1:]
|
|
if _, ok := uc.batches[tag]; ok {
|
|
return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
|
|
}
|
|
var batchType string
|
|
if err := parseMessageParams(msg, nil, &batchType); err != nil {
|
|
return err
|
|
}
|
|
label := label
|
|
if label == "" && msgBatch != nil {
|
|
label = msgBatch.Label
|
|
}
|
|
uc.batches[tag] = batch{
|
|
Type: batchType,
|
|
Params: msg.Params[2:],
|
|
Outer: msgBatch,
|
|
Label: label,
|
|
}
|
|
} else if strings.HasPrefix(tag, "-") {
|
|
tag = tag[1:]
|
|
if _, ok := uc.batches[tag]; !ok {
|
|
return fmt.Errorf("unknown BATCH reference tag: %q", tag)
|
|
}
|
|
delete(uc.batches, tag)
|
|
} else {
|
|
return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
|
|
}
|
|
case "NICK":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var newNick string
|
|
if err := parseMessageParams(msg, &newNick); err != nil {
|
|
return err
|
|
}
|
|
|
|
me := false
|
|
if uc.isOurNick(msg.Prefix.Name) {
|
|
uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
|
|
me = true
|
|
uc.nick = newNick
|
|
uc.nickCM = uc.network.casemap(uc.nick)
|
|
}
|
|
|
|
for _, entry := range uc.channels.innerMap {
|
|
ch := entry.value.(*upstreamChannel)
|
|
memberships := ch.Members.Value(msg.Prefix.Name)
|
|
if memberships != nil {
|
|
ch.Members.Delete(msg.Prefix.Name)
|
|
ch.Members.SetValue(newNick, memberships)
|
|
uc.appendLog(ch.Name, msg)
|
|
}
|
|
}
|
|
|
|
if !me {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(dc.marshalMessage(msg, uc.network))
|
|
})
|
|
} else {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateNick()
|
|
})
|
|
}
|
|
case "SETNAME":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var newRealname string
|
|
if err := parseMessageParams(msg, &newRealname); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: consider appending this message to logs
|
|
|
|
if uc.isOurNick(msg.Prefix.Name) {
|
|
uc.logger.Printf("changed realname from %q to %q", uc.realname, newRealname)
|
|
uc.realname = newRealname
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.updateRealname()
|
|
})
|
|
} else {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(dc.marshalMessage(msg, uc.network))
|
|
})
|
|
}
|
|
case "JOIN":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var channels string
|
|
if err := parseMessageParams(msg, &channels); err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, ch := range strings.Split(channels, ",") {
|
|
if uc.isOurNick(msg.Prefix.Name) {
|
|
uc.logger.Printf("joined channel %q", ch)
|
|
members := membershipsCasemapMap{newCasemapMap(0)}
|
|
members.casemap = uc.network.casemap
|
|
uc.channels.SetValue(ch, &upstreamChannel{
|
|
Name: ch,
|
|
conn: uc,
|
|
Members: members,
|
|
})
|
|
uc.updateChannelAutoDetach(ch)
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "MODE",
|
|
Params: []string{ch},
|
|
})
|
|
} else {
|
|
ch, err := uc.getChannel(ch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ch.Members.SetValue(msg.Prefix.Name, &memberships{})
|
|
}
|
|
|
|
chMsg := msg.Copy()
|
|
chMsg.Params[0] = ch
|
|
uc.produce(ch, chMsg, nil)
|
|
}
|
|
case "PART":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var channels string
|
|
if err := parseMessageParams(msg, &channels); err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, ch := range strings.Split(channels, ",") {
|
|
if uc.isOurNick(msg.Prefix.Name) {
|
|
uc.logger.Printf("parted channel %q", ch)
|
|
uch := uc.channels.Value(ch)
|
|
if uch != nil {
|
|
uc.channels.Delete(ch)
|
|
uch.updateAutoDetach(0)
|
|
}
|
|
} else {
|
|
ch, err := uc.getChannel(ch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ch.Members.Delete(msg.Prefix.Name)
|
|
}
|
|
|
|
chMsg := msg.Copy()
|
|
chMsg.Params[0] = ch
|
|
uc.produce(ch, chMsg, nil)
|
|
}
|
|
case "KICK":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var channel, user string
|
|
if err := parseMessageParams(msg, &channel, &user); err != nil {
|
|
return err
|
|
}
|
|
|
|
if uc.isOurNick(user) {
|
|
uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
|
|
uc.channels.Delete(channel)
|
|
} else {
|
|
ch, err := uc.getChannel(channel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ch.Members.Delete(user)
|
|
}
|
|
|
|
uc.produce(channel, msg, nil)
|
|
case "QUIT":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
if uc.isOurNick(msg.Prefix.Name) {
|
|
uc.logger.Printf("quit")
|
|
}
|
|
|
|
for _, entry := range uc.channels.innerMap {
|
|
ch := entry.value.(*upstreamChannel)
|
|
if ch.Members.Has(msg.Prefix.Name) {
|
|
ch.Members.Delete(msg.Prefix.Name)
|
|
|
|
uc.appendLog(ch.Name, msg)
|
|
}
|
|
}
|
|
|
|
if msg.Prefix.Name != uc.nick {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(dc.marshalMessage(msg, uc.network))
|
|
})
|
|
}
|
|
case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
|
|
var name, topic string
|
|
if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
|
|
return err
|
|
}
|
|
ch, err := uc.getChannel(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if msg.Command == irc.RPL_TOPIC {
|
|
ch.Topic = topic
|
|
} else {
|
|
ch.Topic = ""
|
|
}
|
|
case "TOPIC":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
var name string
|
|
if err := parseMessageParams(msg, &name); err != nil {
|
|
return err
|
|
}
|
|
ch, err := uc.getChannel(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(msg.Params) > 1 {
|
|
ch.Topic = msg.Params[1]
|
|
ch.TopicWho = msg.Prefix.Copy()
|
|
ch.TopicTime = time.Now() // TODO use msg.Tags["time"]
|
|
} else {
|
|
ch.Topic = ""
|
|
}
|
|
uc.produce(ch.Name, msg, nil)
|
|
case "MODE":
|
|
var name, modeStr string
|
|
if err := parseMessageParams(msg, &name, &modeStr); err != nil {
|
|
return err
|
|
}
|
|
|
|
if !uc.isChannel(name) { // user mode change
|
|
if name != uc.nick {
|
|
return fmt.Errorf("received MODE message for unknown nick %q", name)
|
|
}
|
|
|
|
if err := uc.modes.Apply(modeStr); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if dc.upstream() == nil {
|
|
return
|
|
}
|
|
|
|
dc.SendMessage(msg)
|
|
})
|
|
} else { // channel mode change
|
|
ch, err := uc.getChannel(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
needMarshaling, err := applyChannelModes(ch, modeStr, msg.Params[2:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.appendLog(ch.Name, msg)
|
|
|
|
c := uc.network.channels.Value(name)
|
|
if c == nil || !c.Detached {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
params := make([]string, len(msg.Params))
|
|
params[0] = dc.marshalEntity(uc.network, name)
|
|
params[1] = modeStr
|
|
|
|
copy(params[2:], msg.Params[2:])
|
|
for i, modeParam := range params[2:] {
|
|
if _, ok := needMarshaling[i]; ok {
|
|
params[2+i] = dc.marshalEntity(uc.network, modeParam)
|
|
}
|
|
}
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
|
|
Command: "MODE",
|
|
Params: params,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
case irc.RPL_UMODEIS:
|
|
if err := parseMessageParams(msg, nil); err != nil {
|
|
return err
|
|
}
|
|
modeStr := ""
|
|
if len(msg.Params) > 1 {
|
|
modeStr = msg.Params[1]
|
|
}
|
|
|
|
uc.modes = ""
|
|
if err := uc.modes.Apply(modeStr); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if dc.upstream() == nil {
|
|
return
|
|
}
|
|
|
|
dc.SendMessage(msg)
|
|
})
|
|
case irc.RPL_CHANNELMODEIS:
|
|
var channel string
|
|
if err := parseMessageParams(msg, nil, &channel); err != nil {
|
|
return err
|
|
}
|
|
modeStr := ""
|
|
if len(msg.Params) > 2 {
|
|
modeStr = msg.Params[2]
|
|
}
|
|
|
|
ch, err := uc.getChannel(channel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
firstMode := ch.modes == nil
|
|
ch.modes = make(map[byte]string)
|
|
if _, err := applyChannelModes(ch, modeStr, msg.Params[3:]); err != nil {
|
|
return err
|
|
}
|
|
if firstMode {
|
|
c := uc.network.channels.Value(channel)
|
|
if c == nil || !c.Detached {
|
|
modeStr, modeParams := ch.modes.Format()
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
params := []string{dc.nick, dc.marshalEntity(uc.network, channel), modeStr}
|
|
params = append(params, modeParams...)
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_CHANNELMODEIS,
|
|
Params: params,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
case rpl_creationtime:
|
|
var channel, creationTime string
|
|
if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
|
|
return err
|
|
}
|
|
|
|
ch, err := uc.getChannel(channel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
firstCreationTime := ch.creationTime == ""
|
|
ch.creationTime = creationTime
|
|
if firstCreationTime {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: rpl_creationtime,
|
|
Params: []string{dc.nick, dc.marshalEntity(uc.network, ch.Name), creationTime},
|
|
})
|
|
})
|
|
}
|
|
case rpl_topicwhotime:
|
|
var name, who, timeStr string
|
|
if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
|
|
return err
|
|
}
|
|
ch, err := uc.getChannel(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
firstTopicWhoTime := ch.TopicWho == nil
|
|
ch.TopicWho = irc.ParsePrefix(who)
|
|
sec, err := strconv.ParseInt(timeStr, 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to parse topic time: %v", err)
|
|
}
|
|
ch.TopicTime = time.Unix(sec, 0)
|
|
if firstTopicWhoTime {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
topicWho := dc.marshalUserPrefix(uc.network, ch.TopicWho)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: rpl_topicwhotime,
|
|
Params: []string{
|
|
dc.nick,
|
|
dc.marshalEntity(uc.network, ch.Name),
|
|
topicWho.String(),
|
|
timeStr,
|
|
},
|
|
})
|
|
})
|
|
}
|
|
case irc.RPL_LIST:
|
|
var channel, clients, topic string
|
|
if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
|
|
return err
|
|
}
|
|
|
|
dc, cmd := uc.currentPendingCommand("LIST")
|
|
if cmd == nil {
|
|
return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
|
|
} else if dc == nil {
|
|
return nil
|
|
}
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_LIST,
|
|
Params: []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
|
|
})
|
|
case irc.RPL_LISTEND:
|
|
dc, cmd := uc.dequeueCommand("LIST")
|
|
if cmd == nil {
|
|
return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
|
|
} else if dc == nil {
|
|
return nil
|
|
}
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_LISTEND,
|
|
Params: []string{dc.nick, "End of /LIST"},
|
|
})
|
|
case irc.RPL_NAMREPLY:
|
|
var name, statusStr, members string
|
|
if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
|
|
return err
|
|
}
|
|
|
|
ch := uc.channels.Value(name)
|
|
if ch == nil {
|
|
// NAMES on a channel we have not joined, forward to downstream
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
channel := dc.marshalEntity(uc.network, name)
|
|
members := splitSpace(members)
|
|
for i, member := range members {
|
|
memberships, nick := uc.parseMembershipPrefix(member)
|
|
members[i] = memberships.Format(dc) + dc.marshalEntity(uc.network, nick)
|
|
}
|
|
memberStr := strings.Join(members, " ")
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_NAMREPLY,
|
|
Params: []string{dc.nick, statusStr, channel, memberStr},
|
|
})
|
|
})
|
|
return nil
|
|
}
|
|
|
|
status, err := parseChannelStatus(statusStr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ch.Status = status
|
|
|
|
for _, s := range splitSpace(members) {
|
|
memberships, nick := uc.parseMembershipPrefix(s)
|
|
ch.Members.SetValue(nick, memberships)
|
|
}
|
|
case irc.RPL_ENDOFNAMES:
|
|
var name string
|
|
if err := parseMessageParams(msg, nil, &name); err != nil {
|
|
return err
|
|
}
|
|
|
|
ch := uc.channels.Value(name)
|
|
if ch == nil {
|
|
// NAMES on a channel we have not joined, forward to downstream
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
channel := dc.marshalEntity(uc.network, name)
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_ENDOFNAMES,
|
|
Params: []string{dc.nick, channel, "End of /NAMES list"},
|
|
})
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if ch.complete {
|
|
return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
|
|
}
|
|
ch.complete = true
|
|
|
|
c := uc.network.channels.Value(name)
|
|
if c == nil || !c.Detached {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
forwardChannel(dc, ch)
|
|
})
|
|
}
|
|
case irc.RPL_WHOREPLY:
|
|
var channel, username, host, server, nick, mode, trailing string
|
|
if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
|
|
return err
|
|
}
|
|
|
|
dc, cmd := uc.currentPendingCommand("WHO")
|
|
if cmd == nil {
|
|
return fmt.Errorf("unexpected RPL_WHOREPLY: no matching pending WHO")
|
|
} else if dc == nil {
|
|
return nil
|
|
}
|
|
|
|
parts := strings.SplitN(trailing, " ", 2)
|
|
if len(parts) != 2 {
|
|
return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
|
|
}
|
|
realname := parts[1]
|
|
hops, err := strconv.Atoi(parts[0])
|
|
if err != nil {
|
|
return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
|
|
}
|
|
hops++
|
|
|
|
trailing = strconv.Itoa(hops) + " " + realname
|
|
|
|
if channel != "*" {
|
|
channel = dc.marshalEntity(uc.network, channel)
|
|
}
|
|
nick = dc.marshalEntity(uc.network, nick)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOREPLY,
|
|
Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
|
|
})
|
|
case rpl_whospcrpl:
|
|
dc, cmd := uc.currentPendingCommand("WHO")
|
|
if cmd == nil {
|
|
return fmt.Errorf("unexpected RPL_WHOSPCRPL: no matching pending WHO")
|
|
} else if dc == nil {
|
|
return nil
|
|
}
|
|
|
|
// Only supported in single-upstream mode, so forward as-is
|
|
dc.SendMessage(msg)
|
|
case irc.RPL_ENDOFWHO:
|
|
var name string
|
|
if err := parseMessageParams(msg, nil, &name); err != nil {
|
|
return err
|
|
}
|
|
|
|
dc, cmd := uc.dequeueCommand("WHO")
|
|
if cmd == nil {
|
|
return fmt.Errorf("unexpected RPL_ENDOFWHO: no matching pending WHO")
|
|
} else if dc == nil {
|
|
return nil
|
|
}
|
|
|
|
mask := "*"
|
|
if len(cmd.Params) > 0 {
|
|
mask = cmd.Params[0]
|
|
}
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_ENDOFWHO,
|
|
Params: []string{dc.nick, mask, "End of /WHO list"},
|
|
})
|
|
case irc.RPL_WHOISUSER:
|
|
var nick, username, host, realname string
|
|
if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOISUSER,
|
|
Params: []string{dc.nick, nick, username, host, "*", realname},
|
|
})
|
|
})
|
|
case irc.RPL_WHOISSERVER:
|
|
var nick, server, serverInfo string
|
|
if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOISSERVER,
|
|
Params: []string{dc.nick, nick, server, serverInfo},
|
|
})
|
|
})
|
|
case irc.RPL_WHOISOPERATOR:
|
|
var nick string
|
|
if err := parseMessageParams(msg, nil, &nick); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOISOPERATOR,
|
|
Params: []string{dc.nick, nick, "is an IRC operator"},
|
|
})
|
|
})
|
|
case irc.RPL_WHOISIDLE:
|
|
var nick string
|
|
if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
params := []string{dc.nick, nick}
|
|
params = append(params, msg.Params[2:]...)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOISIDLE,
|
|
Params: params,
|
|
})
|
|
})
|
|
case irc.RPL_WHOISCHANNELS:
|
|
var nick, channelList string
|
|
if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
|
|
return err
|
|
}
|
|
channels := splitSpace(channelList)
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
channelList := make([]string, len(channels))
|
|
for i, channel := range channels {
|
|
prefix, channel := uc.parseMembershipPrefix(channel)
|
|
channel = dc.marshalEntity(uc.network, channel)
|
|
channelList[i] = prefix.Format(dc) + channel
|
|
}
|
|
channels := strings.Join(channelList, " ")
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_WHOISCHANNELS,
|
|
Params: []string{dc.nick, nick, channels},
|
|
})
|
|
})
|
|
case irc.RPL_ENDOFWHOIS:
|
|
var nick string
|
|
if err := parseMessageParams(msg, nil, &nick); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
nick := dc.marshalEntity(uc.network, nick)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_ENDOFWHOIS,
|
|
Params: []string{dc.nick, nick, "End of /WHOIS list"},
|
|
})
|
|
})
|
|
case "INVITE":
|
|
var nick, channel string
|
|
if err := parseMessageParams(msg, &nick, &channel); err != nil {
|
|
return err
|
|
}
|
|
|
|
weAreInvited := uc.isOurNick(nick)
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if !weAreInvited && !dc.caps["invite-notify"] {
|
|
return
|
|
}
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
|
|
Command: "INVITE",
|
|
Params: []string{dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
|
|
})
|
|
})
|
|
case irc.RPL_INVITING:
|
|
var nick, channel string
|
|
if err := parseMessageParams(msg, nil, &nick, &channel); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_INVITING,
|
|
Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
|
|
})
|
|
})
|
|
case irc.RPL_MONONLINE, irc.RPL_MONOFFLINE:
|
|
var targetsStr string
|
|
if err := parseMessageParams(msg, nil, &targetsStr); err != nil {
|
|
return err
|
|
}
|
|
targets := strings.Split(targetsStr, ",")
|
|
|
|
online := msg.Command == irc.RPL_MONONLINE
|
|
for _, target := range targets {
|
|
prefix := irc.ParsePrefix(target)
|
|
uc.monitored.SetValue(prefix.Name, online)
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
for _, target := range targets {
|
|
prefix := irc.ParsePrefix(target)
|
|
if dc.monitored.Has(prefix.Name) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: []string{dc.nick, target},
|
|
})
|
|
}
|
|
}
|
|
})
|
|
case irc.ERR_MONLISTFULL:
|
|
var limit, targetsStr string
|
|
if err := parseMessageParams(msg, nil, &limit, &targetsStr); err != nil {
|
|
return err
|
|
}
|
|
|
|
targets := strings.Split(targetsStr, ",")
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
for _, target := range targets {
|
|
if dc.monitored.Has(target) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: []string{dc.nick, limit, target},
|
|
})
|
|
}
|
|
}
|
|
})
|
|
case irc.RPL_AWAY:
|
|
var nick, reason string
|
|
if err := parseMessageParams(msg, nil, &nick, &reason); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: irc.RPL_AWAY,
|
|
Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), reason},
|
|
})
|
|
})
|
|
case "AWAY", "ACCOUNT":
|
|
if msg.Prefix == nil {
|
|
return fmt.Errorf("expected a prefix")
|
|
}
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
|
|
Command: msg.Command,
|
|
Params: msg.Params,
|
|
})
|
|
})
|
|
case irc.RPL_BANLIST, irc.RPL_INVITELIST, irc.RPL_EXCEPTLIST:
|
|
var channel, mask string
|
|
if err := parseMessageParams(msg, nil, &channel, &mask); err != nil {
|
|
return err
|
|
}
|
|
var addNick, addTime string
|
|
if len(msg.Params) >= 5 {
|
|
addNick = msg.Params[3]
|
|
addTime = msg.Params[4]
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
channel := dc.marshalEntity(uc.network, channel)
|
|
|
|
var params []string
|
|
if addNick != "" && addTime != "" {
|
|
addNick := dc.marshalEntity(uc.network, addNick)
|
|
params = []string{dc.nick, channel, mask, addNick, addTime}
|
|
} else {
|
|
params = []string{dc.nick, channel, mask}
|
|
}
|
|
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: params,
|
|
})
|
|
})
|
|
case irc.RPL_ENDOFBANLIST, irc.RPL_ENDOFINVITELIST, irc.RPL_ENDOFEXCEPTLIST:
|
|
var channel, trailing string
|
|
if err := parseMessageParams(msg, nil, &channel, &trailing); err != nil {
|
|
return err
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
upstreamChannel := dc.marshalEntity(uc.network, channel)
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: dc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: []string{dc.nick, upstreamChannel, trailing},
|
|
})
|
|
})
|
|
case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
|
|
var command, reason string
|
|
if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
|
|
return err
|
|
}
|
|
|
|
if command == "LIST" || command == "WHO" {
|
|
dc, _ := uc.dequeueCommand(command)
|
|
if dc != nil && downstreamID == 0 {
|
|
downstreamID = dc.id
|
|
}
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: uc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: []string{dc.nick, command, reason},
|
|
})
|
|
})
|
|
case "ACK":
|
|
// Ignore
|
|
case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
|
|
// Ignore
|
|
case irc.RPL_YOURHOST, irc.RPL_CREATED:
|
|
// Ignore
|
|
case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
|
|
fallthrough
|
|
case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
|
|
fallthrough
|
|
case rpl_localusers, rpl_globalusers:
|
|
fallthrough
|
|
case irc.RPL_MOTDSTART, irc.RPL_MOTD:
|
|
// Ignore these messages if they're part of the initial registration
|
|
// message burst. Forward them if the user explicitly asked for them.
|
|
if !uc.gotMotd {
|
|
return nil
|
|
}
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: uc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: msg.Params,
|
|
})
|
|
})
|
|
case irc.RPL_LISTSTART:
|
|
// Ignore
|
|
case "ERROR":
|
|
var text string
|
|
if err := parseMessageParams(msg, &text); err != nil {
|
|
return err
|
|
}
|
|
return fmt.Errorf("fatal server error: %v", text)
|
|
case irc.ERR_PASSWDMISMATCH, irc.ERR_ERRONEUSNICKNAME, irc.ERR_NICKNAMEINUSE, irc.ERR_NICKCOLLISION, irc.ERR_UNAVAILRESOURCE, irc.ERR_NOPERMFORHOST, irc.ERR_YOUREBANNEDCREEP:
|
|
if !uc.registered {
|
|
text := msg.Params[len(msg.Params)-1]
|
|
return registrationError(text)
|
|
}
|
|
fallthrough
|
|
default:
|
|
uc.logger.Printf("unhandled message: %v", msg)
|
|
|
|
uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
|
|
// best effort marshaling for unknown messages, replies and errors:
|
|
// most numerics start with the user nick, marshal it if that's the case
|
|
// otherwise, conservately keep the params without marshaling
|
|
params := msg.Params
|
|
if _, err := strconv.Atoi(msg.Command); err == nil { // numeric
|
|
if len(msg.Params) > 0 && isOurNick(uc.network, msg.Params[0]) {
|
|
params[0] = dc.nick
|
|
}
|
|
}
|
|
dc.SendMessage(&irc.Message{
|
|
Prefix: uc.srv.prefix(),
|
|
Command: msg.Command,
|
|
Params: params,
|
|
})
|
|
})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) handleDetachedMessage(ch *Channel, msg *irc.Message) {
|
|
if uc.network.detachedMessageNeedsRelay(ch, msg) {
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
dc.relayDetachedMessage(uc.network, msg)
|
|
})
|
|
}
|
|
if ch.ReattachOn == FilterMessage || (ch.ReattachOn == FilterHighlight && uc.network.isHighlight(msg)) {
|
|
uc.network.attach(ch)
|
|
if err := uc.srv.db.StoreChannel(context.TODO(), uc.network.ID, ch); err != nil {
|
|
uc.logger.Printf("failed to update channel %q: %v", ch.Name, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (uc *upstreamConn) handleChanModes(s string) error {
|
|
parts := strings.SplitN(s, ",", 5)
|
|
if len(parts) < 4 {
|
|
return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", s)
|
|
}
|
|
modes := make(map[byte]channelModeType)
|
|
for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
|
|
for j := 0; j < len(parts[i]); j++ {
|
|
mode := parts[i][j]
|
|
modes[mode] = mt
|
|
}
|
|
}
|
|
uc.availableChannelModes = modes
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) handleMemberships(s string) error {
|
|
if s == "" {
|
|
uc.availableMemberships = nil
|
|
return nil
|
|
}
|
|
|
|
if s[0] != '(' {
|
|
return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
|
|
}
|
|
sep := strings.IndexByte(s, ')')
|
|
if sep < 0 || len(s) != sep*2 {
|
|
return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
|
|
}
|
|
memberships := make([]membership, len(s)/2-1)
|
|
for i := range memberships {
|
|
memberships[i] = membership{
|
|
Mode: s[i+1],
|
|
Prefix: s[sep+i+1],
|
|
}
|
|
}
|
|
uc.availableMemberships = memberships
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) handleSupportedCaps(capsStr string) {
|
|
caps := strings.Fields(capsStr)
|
|
for _, s := range caps {
|
|
kv := strings.SplitN(s, "=", 2)
|
|
k := strings.ToLower(kv[0])
|
|
var v string
|
|
if len(kv) == 2 {
|
|
v = kv[1]
|
|
}
|
|
uc.supportedCaps[k] = v
|
|
}
|
|
}
|
|
|
|
func (uc *upstreamConn) requestCaps() {
|
|
var requestCaps []string
|
|
for c := range permanentUpstreamCaps {
|
|
if _, ok := uc.supportedCaps[c]; ok && !uc.caps[c] {
|
|
requestCaps = append(requestCaps, c)
|
|
}
|
|
}
|
|
|
|
if len(requestCaps) == 0 {
|
|
return
|
|
}
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "CAP",
|
|
Params: []string{"REQ", strings.Join(requestCaps, " ")},
|
|
})
|
|
}
|
|
|
|
func (uc *upstreamConn) requestSASL() bool {
|
|
if uc.network.SASL.Mechanism == "" {
|
|
return false
|
|
}
|
|
|
|
v, ok := uc.supportedCaps["sasl"]
|
|
if !ok {
|
|
return false
|
|
}
|
|
if v != "" {
|
|
mechanisms := strings.Split(v, ",")
|
|
found := false
|
|
for _, mech := range mechanisms {
|
|
if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
|
|
uc.caps[name] = ok
|
|
|
|
switch name {
|
|
case "sasl":
|
|
if !uc.requestSASL() {
|
|
return nil
|
|
}
|
|
if !ok {
|
|
uc.logger.Printf("server refused to acknowledge the SASL capability")
|
|
return nil
|
|
}
|
|
|
|
auth := &uc.network.SASL
|
|
switch auth.Mechanism {
|
|
case "PLAIN":
|
|
uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
|
|
uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
|
|
case "EXTERNAL":
|
|
uc.logger.Printf("starting SASL EXTERNAL authentication")
|
|
uc.saslClient = sasl.NewExternalClient("")
|
|
default:
|
|
return fmt.Errorf("unsupported SASL mechanism %q", name)
|
|
}
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AUTHENTICATE",
|
|
Params: []string{auth.Mechanism},
|
|
})
|
|
default:
|
|
if permanentUpstreamCaps[name] {
|
|
break
|
|
}
|
|
uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func splitSpace(s string) []string {
|
|
return strings.FieldsFunc(s, func(r rune) bool {
|
|
return r == ' '
|
|
})
|
|
}
|
|
|
|
func (uc *upstreamConn) register() {
|
|
uc.nick = GetNick(&uc.user.User, &uc.network.Network)
|
|
uc.nickCM = uc.network.casemap(uc.nick)
|
|
uc.username = GetUsername(&uc.user.User, &uc.network.Network)
|
|
uc.realname = GetRealname(&uc.user.User, &uc.network.Network)
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "CAP",
|
|
Params: []string{"LS", "302"},
|
|
})
|
|
|
|
if uc.network.Pass != "" {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "PASS",
|
|
Params: []string{uc.network.Pass},
|
|
})
|
|
}
|
|
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "NICK",
|
|
Params: []string{uc.nick},
|
|
})
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "USER",
|
|
Params: []string{uc.username, "0", "*", uc.realname},
|
|
})
|
|
}
|
|
|
|
func (uc *upstreamConn) ReadMessage() (*irc.Message, error) {
|
|
msg, err := uc.conn.ReadMessage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
uc.srv.metrics.upstreamInMessagesTotal.Inc()
|
|
return msg, nil
|
|
}
|
|
|
|
func (uc *upstreamConn) runUntilRegistered() error {
|
|
for !uc.registered {
|
|
msg, err := uc.ReadMessage()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read message: %v", err)
|
|
}
|
|
|
|
if err := uc.handleMessage(msg); err != nil {
|
|
if _, ok := err.(registrationError); ok {
|
|
return err
|
|
} else {
|
|
msg.Tags = nil // prevent message tags from cluttering logs
|
|
return fmt.Errorf("failed to handle message %q: %v", msg, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, command := range uc.network.ConnectCommands {
|
|
m, err := irc.ParseMessage(command)
|
|
if err != nil {
|
|
uc.logger.Printf("failed to parse connect command %q: %v", command, err)
|
|
} else {
|
|
uc.SendMessage(m)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) readMessages(ch chan<- event) error {
|
|
for {
|
|
msg, err := uc.ReadMessage()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
} else if err != nil {
|
|
return fmt.Errorf("failed to read IRC command: %v", err)
|
|
}
|
|
|
|
ch <- eventUpstreamMessage{msg, uc}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (uc *upstreamConn) SendMessage(msg *irc.Message) {
|
|
if !uc.caps["message-tags"] {
|
|
msg = msg.Copy()
|
|
msg.Tags = nil
|
|
}
|
|
|
|
uc.srv.metrics.upstreamOutMessagesTotal.Inc()
|
|
uc.conn.SendMessage(msg)
|
|
}
|
|
|
|
func (uc *upstreamConn) SendMessageLabeled(downstreamID uint64, msg *irc.Message) {
|
|
if uc.caps["labeled-response"] {
|
|
if msg.Tags == nil {
|
|
msg.Tags = make(map[string]irc.TagValue)
|
|
}
|
|
msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
|
|
uc.nextLabelID++
|
|
}
|
|
uc.SendMessage(msg)
|
|
}
|
|
|
|
// appendLog appends a message to the log file.
|
|
//
|
|
// The internal message ID is returned. If the message isn't recorded in the
|
|
// log file, an empty string is returned.
|
|
func (uc *upstreamConn) appendLog(entity string, msg *irc.Message) (msgID string) {
|
|
if uc.user.msgStore == nil {
|
|
return ""
|
|
}
|
|
|
|
// Don't store messages with a server mask target
|
|
if strings.HasPrefix(entity, "$") {
|
|
return ""
|
|
}
|
|
|
|
entityCM := uc.network.casemap(entity)
|
|
if entityCM == "nickserv" {
|
|
// The messages sent/received from NickServ may contain
|
|
// security-related information (like passwords). Don't store these.
|
|
return ""
|
|
}
|
|
|
|
if !uc.network.delivered.HasTarget(entity) {
|
|
// This is the first message we receive from this target. Save the last
|
|
// message ID in delivery receipts, so that we can send the new message
|
|
// in the backlog if an offline client reconnects.
|
|
lastID, err := uc.user.msgStore.LastMsgID(&uc.network.Network, entityCM, time.Now())
|
|
if err != nil {
|
|
uc.logger.Printf("failed to log message: failed to get last message ID: %v", err)
|
|
return ""
|
|
}
|
|
|
|
uc.network.delivered.ForEachClient(func(clientName string) {
|
|
uc.network.delivered.StoreID(entity, clientName, lastID)
|
|
})
|
|
}
|
|
|
|
msgID, err := uc.user.msgStore.Append(&uc.network.Network, entityCM, msg)
|
|
if err != nil {
|
|
uc.logger.Printf("failed to log message: %v", err)
|
|
return ""
|
|
}
|
|
|
|
return msgID
|
|
}
|
|
|
|
// produce appends a message to the logs and forwards it to connected downstream
|
|
// connections.
|
|
//
|
|
// If origin is not nil and origin doesn't support echo-message, the message is
|
|
// forwarded to all connections except origin.
|
|
func (uc *upstreamConn) produce(target string, msg *irc.Message, origin *downstreamConn) {
|
|
var msgID string
|
|
if target != "" {
|
|
msgID = uc.appendLog(target, msg)
|
|
}
|
|
|
|
// Don't forward messages if it's a detached channel
|
|
ch := uc.network.channels.Value(target)
|
|
detached := ch != nil && ch.Detached
|
|
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
if !detached && (dc != origin || dc.caps["echo-message"]) {
|
|
dc.sendMessageWithID(dc.marshalMessage(msg, uc.network), msgID)
|
|
} else {
|
|
dc.advanceMessageWithID(msg, msgID)
|
|
}
|
|
})
|
|
}
|
|
|
|
func (uc *upstreamConn) updateAway() {
|
|
away := true
|
|
uc.forEachDownstream(func(*downstreamConn) {
|
|
away = false
|
|
})
|
|
if away == uc.away {
|
|
return
|
|
}
|
|
if away {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AWAY",
|
|
Params: []string{"Auto away"},
|
|
})
|
|
} else {
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "AWAY",
|
|
})
|
|
}
|
|
uc.away = away
|
|
}
|
|
|
|
func (uc *upstreamConn) updateChannelAutoDetach(name string) {
|
|
uch := uc.channels.Value(name)
|
|
if uch == nil {
|
|
return
|
|
}
|
|
ch := uc.network.channels.Value(name)
|
|
if ch == nil || ch.Detached {
|
|
return
|
|
}
|
|
uch.updateAutoDetach(ch.DetachAfter)
|
|
}
|
|
|
|
func (uc *upstreamConn) updateMonitor() {
|
|
add := make(map[string]struct{})
|
|
var addList []string
|
|
seen := make(map[string]struct{})
|
|
uc.forEachDownstream(func(dc *downstreamConn) {
|
|
for targetCM := range dc.monitored.innerMap {
|
|
if !uc.monitored.Has(targetCM) {
|
|
if _, ok := add[targetCM]; !ok {
|
|
addList = append(addList, targetCM)
|
|
}
|
|
add[targetCM] = struct{}{}
|
|
} else {
|
|
seen[targetCM] = struct{}{}
|
|
}
|
|
}
|
|
})
|
|
|
|
removeAll := true
|
|
var removeList []string
|
|
for targetCM, entry := range uc.monitored.innerMap {
|
|
if _, ok := seen[targetCM]; ok {
|
|
removeAll = false
|
|
} else {
|
|
removeList = append(removeList, entry.originalKey)
|
|
}
|
|
}
|
|
|
|
// TODO: better handle the case where len(uc.monitored) + len(addList)
|
|
// exceeds the limit, probably by immediately sending ERR_MONLISTFULL?
|
|
|
|
if removeAll && len(addList) == 0 && len(removeList) > 0 {
|
|
// Optimization when the last MONITOR-aware downstream disconnects
|
|
uc.SendMessage(&irc.Message{
|
|
Command: "MONITOR",
|
|
Params: []string{"C"},
|
|
})
|
|
} else {
|
|
msgs := generateMonitor("-", removeList)
|
|
msgs = append(msgs, generateMonitor("+", addList)...)
|
|
for _, msg := range msgs {
|
|
uc.SendMessage(msg)
|
|
}
|
|
}
|
|
|
|
for _, target := range removeList {
|
|
uc.monitored.Delete(target)
|
|
}
|
|
}
|