Context Navigation

source: code/trunk/upstream.go@ 685

Last change on this file since 685 was 685, checked in by delthas, 4 years ago

Add support for draft/extended-monitor

References: https://github.com/ircv3/ircv3-specifications/pull/466

File size: 50.5 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
[652]	4	"context"
[307]	5	"crypto"
	6	"crypto/sha256"
[13]	7	"crypto/tls"
[307]	8	"crypto/x509"
[95]	9	"encoding/base64"
[155]	10	"errors"
[13]	11	"fmt"
	12	"io"
	13	"net"
[19]	14	"strconv"
[17]	15	"strings"
[19]	16	"time"
[13]	17
[95]	18	"github.com/emersion/go-sasl"
[13]	19	"gopkg.in/irc.v3"
	20	)
	21
[282]	22	// permanentUpstreamCaps is the static list of upstream capabilities always
	23	// requested when supported.
	24	var permanentUpstreamCaps = map[string]bool{
[559]	25	"account-tag": true,
[282]	26	"away-notify": true,
	27	"batch": true,
[419]	28	"extended-join": true,
[448]	29	"invite-notify": true,
[282]	30	"labeled-response": true,
	31	"message-tags": true,
[292]	32	"multi-prefix": true,
[282]	33	"server-time": true,
[540]	34	"setname": true,
[685]	35
	36	"draft/extended-monitor": true,
[282]	37	}
	38
[399]	39	type registrationError string
	40
	41	func (err registrationError) Error() string {
	42	return fmt.Sprintf("registration error: %v", string(err))
	43	}
	44
[19]	45	type upstreamChannel struct {
[162]	46	Name string
	47	conn *upstreamConn
	48	Topic string
[405]	49	TopicWho *irc.Prefix
[162]	50	TopicTime time.Time
	51	Status channelStatus
	52	modes channelModes
	53	creationTime string
[478]	54	Members membershipsCasemapMap
[162]	55	complete bool
[435]	56	detachTimer *time.Timer
[19]	57	}
	58
[435]	59	func (uc *upstreamChannel) updateAutoDetach(dur time.Duration) {
	60	if uc.detachTimer != nil {
	61	uc.detachTimer.Stop()
	62	uc.detachTimer = nil
	63	}
	64
	65	if dur == 0 {
	66	return
	67	}
	68
	69	uc.detachTimer = time.AfterFunc(dur, func() {
	70	uc.conn.network.user.events <- eventChannelDetach{
	71	uc: uc.conn,
	72	name: uc.Name,
	73	}
	74	})
	75	}
	76
[681]	77	type pendingUpstreamCommand struct {
	78	downstreamID uint64
[682]	79	msg *irc.Message
[681]	80	}
	81
[13]	82	type upstreamConn struct {
[210]	83	conn
[16]	84
[210]	85	network *network
	86	user *user
	87
[16]	88	serverName string
	89	availableUserModes string
[139]	90	availableChannelModes map[byte]channelModeType
	91	availableChannelTypes string
	92	availableMemberships []membership
[460]	93	isupport map[string]*string
[19]	94
[277]	95	registered bool
	96	nick string
[478]	97	nickCM string
[277]	98	username string
	99	realname string
	100	modes userModes
[478]	101	channels upstreamChannelCasemapMap
[277]	102	supportedCaps map[string]string
[278]	103	caps map[string]bool
[277]	104	batches map[string]batch
	105	away bool
[559]	106	account string
[278]	107	nextLabelID uint64
[684]	108	monitored monitorCasemapMap
[95]	109
	110	saslClient sasl.Client
	111	saslStarted bool
[177]	112
[478]	113	casemapIsSet bool
	114
[682]	115	// Queue of commands in progress, indexed by type. The first entry has been
	116	// sent to the server and is awaiting reply. The following entries have not
	117	// been sent yet.
	118	pendingCmds map[string][]pendingUpstreamCommand
[552]	119
	120	gotMotd bool
[13]	121	}
	122
[77]	123	func connectToUpstream(network network) (upstreamConn, error) {
[502]	124	logger := &prefixLogger{network.user.logger, fmt.Sprintf("upstream %q: ", network.GetName())}
[33]	125
[352]	126	dialer := net.Dialer{Timeout: connectTimeout}
[269]	127
[457]	128	u, err := network.URL()
[352]	129	if err != nil {
[457]	130	return nil, err
[352]	131	}
[206]	132
[269]	133	var netConn net.Conn
[352]	134	switch u.Scheme {
[269]	135	case "ircs":
[352]	136	addr := u.Host
[381]	137	host, _, err := net.SplitHostPort(u.Host)
	138	if err != nil {
	139	host = u.Host
	140	addr = u.Host + ":6697"
[269]	141	}
	142
	143	logger.Printf("connecting to TLS server at address %q", addr)
[307]	144
[455]	145	tlsConfig := &tls.Config{ServerName: host, NextProtos: []string{"irc"}}
[307]	146	if network.SASL.Mechanism == "EXTERNAL" {
	147	if network.SASL.External.CertBlob == nil {
	148	return nil, fmt.Errorf("missing certificate for authentication")
	149	}
	150	if network.SASL.External.PrivKeyBlob == nil {
	151	return nil, fmt.Errorf("missing private key for authentication")
	152	}
	153	key, err := x509.ParsePKCS8PrivateKey(network.SASL.External.PrivKeyBlob)
	154	if err != nil {
	155	return nil, fmt.Errorf("failed to parse private key: %v", err)
	156	}
[381]	157	tlsConfig.Certificates = []tls.Certificate{
	158	{
	159	Certificate: [][]byte{network.SASL.External.CertBlob},
	160	PrivateKey: key.(crypto.PrivateKey),
[307]	161	},
	162	}
	163	logger.Printf("using TLS client certificate %x", sha256.Sum256(network.SASL.External.CertBlob))
	164	}
	165
[381]	166	netConn, err = dialer.Dial("tcp", addr)
[352]	167	if err != nil {
	168	return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
	169	}
[381]	170
	171	// Don't do the TLS handshake immediately, because we need to register
	172	// the new connection with identd ASAP. See:
	173	// https://todo.sr.ht/~emersion/soju/69#event-41859
	174	netConn = tls.Client(netConn, tlsConfig)
[270]	175	case "irc+insecure":
[352]	176	addr := u.Host
[351]	177	if _, _, err := net.SplitHostPort(addr); err != nil {
[270]	178	addr = addr + ":6667"
	179	}
	180
	181	logger.Printf("connecting to plain-text server at address %q", addr)
	182	netConn, err = dialer.Dial("tcp", addr)
[352]	183	if err != nil {
	184	return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
	185	}
[369]	186	case "irc+unix", "unix":
[353]	187	logger.Printf("connecting to Unix socket at path %q", u.Path)
	188	netConn, err = dialer.Dial("unix", u.Path)
	189	if err != nil {
	190	return nil, fmt.Errorf("failed to connect to Unix socket %q: %v", u.Path, err)
	191	}
[269]	192	default:
[352]	193	return nil, fmt.Errorf("failed to dial %q: unknown scheme: %v", network.Addr, u.Scheme)
[269]	194	}
[33]	195
[398]	196	options := connOptions{
[402]	197	Logger: logger,
[398]	198	RateLimitDelay: upstreamMessageDelay,
	199	RateLimitBurst: upstreamMessageBurst,
	200	}
	201
[55]	202	uc := &upstreamConn{
[681]	203	conn: *newConn(network.user.srv, newNetIRCConn(netConn), &options),
	204	network: network,
	205	user: network.user,
	206	channels: upstreamChannelCasemapMap{newCasemapMap(0)},
	207	supportedCaps: make(map[string]string),
	208	caps: make(map[string]bool),
	209	batches: make(map[string]batch),
	210	availableChannelTypes: stdChannelTypes,
	211	availableChannelModes: stdChannelModes,
	212	availableMemberships: stdMemberships,
	213	isupport: make(map[string]*string),
[682]	214	pendingCmds: make(map[string][]pendingUpstreamCommand),
[684]	215	monitored: monitorCasemapMap{newCasemapMap(0)},
[33]	216	}
[55]	217	return uc, nil
[33]	218	}
	219
[73]	220	func (uc upstreamConn) forEachDownstream(f func(downstreamConn)) {
[218]	221	uc.network.forEachDownstream(f)
[73]	222	}
	223
[161]	224	func (uc upstreamConn) forEachDownstreamByID(id uint64, f func(downstreamConn)) {
[155]	225	uc.forEachDownstream(func(dc *downstreamConn) {
	226	if id != 0 && id != dc.id {
	227	return
	228	}
	229	f(dc)
	230	})
	231	}
	232
[682]	233	func (uc upstreamConn) downstreamByID(id uint64) downstreamConn {
	234	for _, dc := range uc.user.downstreamConns {
	235	if dc.id == id {
	236	return dc
	237	}
	238	}
	239	return nil
	240	}
	241
[55]	242	func (uc upstreamConn) getChannel(name string) (upstreamChannel, error) {
[478]	243	ch := uc.channels.Value(name)
	244	if ch == nil {
[19]	245	return nil, fmt.Errorf("unknown channel %q", name)
	246	}
	247	return ch, nil
	248	}
	249
[129]	250	func (uc *upstreamConn) isChannel(entity string) bool {
[454]	251	return strings.ContainsRune(uc.availableChannelTypes, rune(entity[0]))
[129]	252	}
	253
[478]	254	func (uc *upstreamConn) isOurNick(nick string) bool {
	255	return uc.nickCM == uc.network.casemap(nick)
	256	}
	257
[682]	258	func (uc *upstreamConn) endPendingCommands() {
	259	for _, l := range uc.pendingCmds {
	260	for _, pendingCmd := range l {
	261	dc := uc.downstreamByID(pendingCmd.downstreamID)
	262	if dc == nil {
	263	continue
	264	}
	265
	266	switch pendingCmd.msg.Command {
	267	case "LIST":
	268	dc.SendMessage(&irc.Message{
	269	Prefix: dc.srv.prefix(),
	270	Command: irc.RPL_LISTEND,
	271	Params: []string{dc.nick, "End of /LIST"},
	272	})
	273	case "WHO":
	274	mask := "*"
	275	if len(pendingCmd.msg.Params) > 0 {
	276	mask = pendingCmd.msg.Params[0]
	277	}
	278	dc.SendMessage(&irc.Message{
	279	Prefix: dc.srv.prefix(),
	280	Command: irc.RPL_ENDOFWHO,
	281	Params: []string{dc.nick, mask, "End of /WHO"},
	282	})
	283	default:
	284	panic(fmt.Errorf("Unsupported pending command %q", pendingCmd.msg.Command))
	285	}
	286	}
[177]	287	}
[682]	288
	289	uc.pendingCmds = make(map[string][]pendingUpstreamCommand)
[177]	290	}
	291
[682]	292	func (uc *upstreamConn) sendNextPendingCommand(cmd string) {
	293	if len(uc.pendingCmds[cmd]) == 0 {
[681]	294	return
[177]	295	}
[682]	296	uc.SendMessage(uc.pendingCmds[cmd][0].msg)
[177]	297	}
	298
[682]	299	func (uc upstreamConn) enqueueCommand(dc downstreamConn, msg *irc.Message) {
	300	switch msg.Command {
	301	case "LIST", "WHO":
	302	// Supported
	303	default:
	304	panic(fmt.Errorf("Unsupported pending command %q", msg.Command))
	305	}
	306
	307	uc.pendingCmds[msg.Command] = append(uc.pendingCmds[msg.Command], pendingUpstreamCommand{
[681]	308	downstreamID: dc.id,
[682]	309	msg: msg,
[681]	310	})
	311
[682]	312	if len(uc.pendingCmds[msg.Command]) == 1 {
	313	uc.sendNextPendingCommand(msg.Command)
[177]	314	}
[681]	315	}
[177]	316
[682]	317	func (uc upstreamConn) currentPendingCommand(cmd string) (downstreamConn, *irc.Message) {
	318	if len(uc.pendingCmds[cmd]) == 0 {
[681]	319	return nil, nil
	320	}
	321
[682]	322	pendingCmd := uc.pendingCmds[cmd][0]
	323	return uc.downstreamByID(pendingCmd.downstreamID), pendingCmd.msg
[681]	324	}
[177]	325
[682]	326	func (uc upstreamConn) dequeueCommand(cmd string) (downstreamConn, *irc.Message) {
	327	dc, msg := uc.currentPendingCommand(cmd)
[681]	328
[682]	329	if len(uc.pendingCmds[cmd]) > 0 {
	330	copy(uc.pendingCmds[cmd], uc.pendingCmds[cmd][1:])
	331	uc.pendingCmds[cmd] = uc.pendingCmds[cmd][:len(uc.pendingCmds[cmd])-1]
[177]	332	}
[681]	333
[682]	334	uc.sendNextPendingCommand(cmd)
[681]	335
[682]	336	return dc, msg
[177]	337	}
	338
[292]	339	func (uc upstreamConn) parseMembershipPrefix(s string) (ms memberships, nick string) {
	340	memberships := make(memberships, 0, 4)
	341	i := 0
[139]	342	for _, m := range uc.availableMemberships {
[292]	343	if i >= len(s) {
	344	break
[139]	345	}
[292]	346	if s[i] == m.Prefix {
	347	memberships = append(memberships, m)
	348	i++
	349	}
[139]	350	}
[292]	351	return &memberships, s[i:]
[139]	352	}
	353
[55]	354	func (uc upstreamConn) handleMessage(msg irc.Message) error {
[155]	355	var label string
	356	if l, ok := msg.GetTag("label"); ok {
	357	label = l
[526]	358	delete(msg.Tags, "label")
[155]	359	}
	360
[153]	361	var msgBatch *batch
	362	if batchName, ok := msg.GetTag("batch"); ok {
	363	b, ok := uc.batches[batchName]
	364	if !ok {
	365	return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
	366	}
	367	msgBatch = &b
[155]	368	if label == "" {
	369	label = msgBatch.Label
	370	}
[443]	371	delete(msg.Tags, "batch")
[153]	372	}
	373
[161]	374	var downstreamID uint64 = 0
[155]	375	if label != "" {
	376	var labelOffset uint64
[161]	377	n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
[155]	378	if err == nil && n < 2 {
	379	err = errors.New("not enough arguments")
	380	}
	381	if err != nil {
	382	return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
	383	}
	384	}
	385
[216]	386	if _, ok := msg.Tags["time"]; !ok {
[240]	387	msg.Tags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[216]	388	}
	389
[13]	390	switch msg.Command {
	391	case "PING":
[60]	392	uc.SendMessage(&irc.Message{
[13]	393	Command: "PONG",
[68]	394	Params: msg.Params,
[60]	395	})
[33]	396	return nil
[303]	397	case "NOTICE", "PRIVMSG", "TAGMSG":
[273]	398	if msg.Prefix == nil {
	399	return fmt.Errorf("expected a prefix")
	400	}
	401
[286]	402	var entity, text string
[303]	403	if msg.Command != "TAGMSG" {
	404	if err := parseMessageParams(msg, &entity, &text); err != nil {
	405	return err
	406	}
	407	} else {
	408	if err := parseMessageParams(msg, &entity); err != nil {
	409	return err
	410	}
[286]	411	}
	412
	413	if msg.Prefix.Name == serviceNick {
	414	uc.logger.Printf("skipping %v from soju's service: %v", msg.Command, msg)
	415	break
	416	}
	417	if entity == serviceNick {
	418	uc.logger.Printf("skipping %v to soju's service: %v", msg.Command, msg)
	419	break
	420	}
	421
[171]	422	if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
[239]	423	uc.produce("", msg, nil)
[303]	424	} else { // regular user message
[217]	425	target := entity
[478]	426	if uc.isOurNick(target) {
[178]	427	target = msg.Prefix.Name
	428	}
[287]	429
[478]	430	ch := uc.network.channels.Value(target)
[505]	431	if ch != nil && msg.Command != "TAGMSG" {
[435]	432	if ch.Detached {
[499]	433	uc.handleDetachedMessage(ch, msg)
[435]	434	}
	435
[499]	436	highlight := uc.network.isHighlight(msg)
[435]	437	if ch.DetachOn == FilterMessage \|\| ch.DetachOn == FilterDefault \|\| (ch.DetachOn == FilterHighlight && highlight) {
	438	uc.updateChannelAutoDetach(target)
	439	}
[287]	440	}
[435]	441
	442	uc.produce(target, msg, nil)
[171]	443	}
[92]	444	case "CAP":
[95]	445	var subCmd string
	446	if err := parseMessageParams(msg, nil, &subCmd); err != nil {
	447	return err
[92]	448	}
[95]	449	subCmd = strings.ToUpper(subCmd)
	450	subParams := msg.Params[2:]
	451	switch subCmd {
	452	case "LS":
	453	if len(subParams) < 1 {
	454	return newNeedMoreParamsError(msg.Command)
	455	}
[281]	456	caps := subParams[len(subParams)-1]
[95]	457	more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
[92]	458
[281]	459	uc.handleSupportedCaps(caps)
[92]	460
[95]	461	if more {
	462	break // wait to receive all capabilities
	463	}
	464
[281]	465	uc.requestCaps()
[152]	466
[95]	467	if uc.requestSASL() {
	468	break // we'll send CAP END after authentication is completed
	469	}
	470
[92]	471	uc.SendMessage(&irc.Message{
	472	Command: "CAP",
	473	Params: []string{"END"},
	474	})
[95]	475	case "ACK", "NAK":
	476	if len(subParams) < 1 {
	477	return newNeedMoreParamsError(msg.Command)
	478	}
	479	caps := strings.Fields(subParams[0])
	480
	481	for _, name := range caps {
	482	if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
	483	return err
	484	}
	485	}
	486
[281]	487	if uc.registered {
	488	uc.forEachDownstream(func(dc *downstreamConn) {
	489	dc.updateSupportedCaps()
	490	})
	491	}
	492	case "NEW":
	493	if len(subParams) < 1 {
	494	return newNeedMoreParamsError(msg.Command)
	495	}
	496	uc.handleSupportedCaps(subParams[0])
	497	uc.requestCaps()
	498	case "DEL":
	499	if len(subParams) < 1 {
	500	return newNeedMoreParamsError(msg.Command)
	501	}
	502	caps := strings.Fields(subParams[0])
	503
	504	for _, c := range caps {
	505	delete(uc.supportedCaps, c)
	506	delete(uc.caps, c)
	507	}
	508
	509	if uc.registered {
	510	uc.forEachDownstream(func(dc *downstreamConn) {
	511	dc.updateSupportedCaps()
	512	})
	513	}
[95]	514	default:
	515	uc.logger.Printf("unhandled message: %v", msg)
[92]	516	}
[95]	517	case "AUTHENTICATE":
	518	if uc.saslClient == nil {
	519	return fmt.Errorf("received unexpected AUTHENTICATE message")
	520	}
	521
	522	// TODO: if a challenge is 400 bytes long, buffer it
	523	var challengeStr string
	524	if err := parseMessageParams(msg, &challengeStr); err != nil {
	525	uc.SendMessage(&irc.Message{
	526	Command: "AUTHENTICATE",
	527	Params: []string{"*"},
	528	})
	529	return err
	530	}
	531
	532	var challenge []byte
	533	if challengeStr != "+" {
	534	var err error
	535	challenge, err = base64.StdEncoding.DecodeString(challengeStr)
	536	if err != nil {
	537	uc.SendMessage(&irc.Message{
	538	Command: "AUTHENTICATE",
	539	Params: []string{"*"},
	540	})
	541	return err
	542	}
	543	}
	544
	545	var resp []byte
	546	var err error
	547	if !uc.saslStarted {
	548	_, resp, err = uc.saslClient.Start()
	549	uc.saslStarted = true
	550	} else {
	551	resp, err = uc.saslClient.Next(challenge)
	552	}
	553	if err != nil {
	554	uc.SendMessage(&irc.Message{
	555	Command: "AUTHENTICATE",
	556	Params: []string{"*"},
	557	})
	558	return err
	559	}
	560
	561	// TODO: send response in multiple chunks if >= 400 bytes
	562	var respStr = "+"
[318]	563	if len(resp) != 0 {
[95]	564	respStr = base64.StdEncoding.EncodeToString(resp)
	565	}
	566
	567	uc.SendMessage(&irc.Message{
	568	Command: "AUTHENTICATE",
	569	Params: []string{respStr},
	570	})
[125]	571	case irc.RPL_LOGGEDIN:
[559]	572	if err := parseMessageParams(msg, nil, nil, &uc.account); err != nil {
[95]	573	return err
	574	}
[559]	575	uc.logger.Printf("logged in with account %q", uc.account)
[125]	576	case irc.RPL_LOGGEDOUT:
[559]	577	uc.account = ""
[95]	578	uc.logger.Printf("logged out")
[125]	579	case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
[95]	580	var info string
	581	if err := parseMessageParams(msg, nil, &info); err != nil {
	582	return err
	583	}
	584	switch msg.Command {
[125]	585	case irc.ERR_NICKLOCKED:
[95]	586	uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
[125]	587	case irc.ERR_SASLFAIL:
[95]	588	uc.logger.Printf("SASL authentication failed: %v", info)
[125]	589	case irc.ERR_SASLTOOLONG:
[95]	590	uc.logger.Printf("SASL message too long: %v", info)
	591	}
	592
	593	uc.saslClient = nil
	594	uc.saslStarted = false
	595
	596	uc.SendMessage(&irc.Message{
	597	Command: "CAP",
	598	Params: []string{"END"},
	599	})
[14]	600	case irc.RPL_WELCOME:
[55]	601	uc.registered = true
	602	uc.logger.Printf("connection registered")
[19]	603
[478]	604	if uc.network.channels.Len() > 0 {
[350]	605	var channels, keys []string
[478]	606	for _, entry := range uc.network.channels.innerMap {
	607	ch := entry.value.(*Channel)
[350]	608	channels = append(channels, ch.Name)
[310]	609	keys = append(keys, ch.Key)
	610	}
[350]	611
	612	for _, msg := range join(channels, keys) {
	613	uc.SendMessage(msg)
	614	}
[19]	615	}
[16]	616	case irc.RPL_MYINFO:
[139]	617	if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
[43]	618	return err
[16]	619	}
[139]	620	case irc.RPL_ISUPPORT:
	621	if err := parseMessageParams(msg, nil, nil); err != nil {
	622	return err
[16]	623	}
[463]	624
	625	var downstreamIsupport []string
[139]	626	for _, token := range msg.Params[1 : len(msg.Params)-1] {
	627	parameter := token
[460]	628	var negate, hasValue bool
	629	var value string
[139]	630	if strings.HasPrefix(token, "-") {
	631	negate = true
	632	token = token[1:]
[459]	633	} else if i := strings.IndexByte(token, '='); i >= 0 {
	634	parameter = token[:i]
	635	value = token[i+1:]
[460]	636	hasValue = true
[139]	637	}
[460]	638
	639	if hasValue {
	640	uc.isupport[parameter] = &value
	641	} else if !negate {
	642	uc.isupport[parameter] = nil
	643	} else {
	644	delete(uc.isupport, parameter)
	645	}
	646
[462]	647	var err error
	648	switch parameter {
[478]	649	case "CASEMAPPING":
	650	casemap, ok := parseCasemappingToken(value)
	651	if !ok {
	652	casemap = casemapRFC1459
	653	}
	654	uc.network.updateCasemapping(casemap)
	655	uc.nickCM = uc.network.casemap(uc.nick)
	656	uc.casemapIsSet = true
[462]	657	case "CHANMODES":
	658	if !negate {
	659	err = uc.handleChanModes(value)
	660	} else {
	661	uc.availableChannelModes = stdChannelModes
	662	}
	663	case "CHANTYPES":
	664	if !negate {
[139]	665	uc.availableChannelTypes = value
[462]	666	} else {
	667	uc.availableChannelTypes = stdChannelTypes
[139]	668	}
[462]	669	case "PREFIX":
	670	if !negate {
	671	err = uc.handleMemberships(value)
	672	} else {
	673	uc.availableMemberships = stdMemberships
	674	}
[139]	675	}
[462]	676	if err != nil {
	677	return err
	678	}
[463]	679
	680	if passthroughIsupport[parameter] {
	681	downstreamIsupport = append(downstreamIsupport, token)
	682	}
[139]	683	}
[463]	684
	685	uc.forEachDownstream(func(dc *downstreamConn) {
	686	if dc.network == nil {
	687	return
	688	}
	689	msgs := generateIsupport(dc.srv.prefix(), dc.nick, downstreamIsupport)
	690	for _, msg := range msgs {
	691	dc.SendMessage(msg)
	692	}
	693	})
[478]	694	case irc.ERR_NOMOTD, irc.RPL_ENDOFMOTD:
	695	if !uc.casemapIsSet {
	696	// upstream did not send any CASEMAPPING token, thus
	697	// we assume it implements the old RFCs with rfc1459.
	698	uc.casemapIsSet = true
	699	uc.network.updateCasemapping(casemapRFC1459)
	700	uc.nickCM = uc.network.casemap(uc.nick)
	701	}
[552]	702
	703	if !uc.gotMotd {
	704	// Ignore the initial MOTD upon connection, but forward
	705	// subsequent MOTD messages downstream
	706	uc.gotMotd = true
	707	return nil
	708	}
	709
[553]	710	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	711	dc.SendMessage(&irc.Message{
	712	Prefix: uc.srv.prefix(),
[552]	713	Command: msg.Command,
[553]	714	Params: msg.Params,
[552]	715	})
	716	})
[153]	717	case "BATCH":
	718	var tag string
	719	if err := parseMessageParams(msg, &tag); err != nil {
	720	return err
	721	}
	722
	723	if strings.HasPrefix(tag, "+") {
	724	tag = tag[1:]
	725	if _, ok := uc.batches[tag]; ok {
	726	return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
	727	}
	728	var batchType string
	729	if err := parseMessageParams(msg, nil, &batchType); err != nil {
	730	return err
	731	}
[155]	732	label := label
	733	if label == "" && msgBatch != nil {
	734	label = msgBatch.Label
	735	}
[153]	736	uc.batches[tag] = batch{
	737	Type: batchType,
	738	Params: msg.Params[2:],
	739	Outer: msgBatch,
[155]	740	Label: label,
[153]	741	}
	742	} else if strings.HasPrefix(tag, "-") {
	743	tag = tag[1:]
	744	if _, ok := uc.batches[tag]; !ok {
	745	return fmt.Errorf("unknown BATCH reference tag: %q", tag)
	746	}
	747	delete(uc.batches, tag)
	748	} else {
	749	return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
	750	}
[42]	751	case "NICK":
[83]	752	if msg.Prefix == nil {
	753	return fmt.Errorf("expected a prefix")
	754	}
	755
[43]	756	var newNick string
	757	if err := parseMessageParams(msg, &newNick); err != nil {
	758	return err
[42]	759	}
	760
[244]	761	me := false
[478]	762	if uc.isOurNick(msg.Prefix.Name) {
[55]	763	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
[244]	764	me = true
[55]	765	uc.nick = newNick
[478]	766	uc.nickCM = uc.network.casemap(uc.nick)
[42]	767	}
	768
[478]	769	for _, entry := range uc.channels.innerMap {
	770	ch := entry.value.(*upstreamChannel)
	771	memberships := ch.Members.Value(msg.Prefix.Name)
	772	if memberships != nil {
	773	ch.Members.Delete(msg.Prefix.Name)
	774	ch.Members.SetValue(newNick, memberships)
[215]	775	uc.appendLog(ch.Name, msg)
[42]	776	}
	777	}
[82]	778
[244]	779	if !me {
[82]	780	uc.forEachDownstream(func(dc *downstreamConn) {
[261]	781	dc.SendMessage(dc.marshalMessage(msg, uc.network))
[82]	782	})
[296]	783	} else {
	784	uc.forEachDownstream(func(dc *downstreamConn) {
	785	dc.updateNick()
	786	})
[82]	787	}
[540]	788	case "SETNAME":
	789	if msg.Prefix == nil {
	790	return fmt.Errorf("expected a prefix")
	791	}
	792
	793	var newRealname string
	794	if err := parseMessageParams(msg, &newRealname); err != nil {
	795	return err
	796	}
	797
	798	// TODO: consider appending this message to logs
	799
	800	if uc.isOurNick(msg.Prefix.Name) {
	801	uc.logger.Printf("changed realname from %q to %q", uc.realname, newRealname)
	802	uc.realname = newRealname
	803
	804	uc.forEachDownstream(func(dc *downstreamConn) {
	805	dc.updateRealname()
	806	})
	807	} else {
	808	uc.forEachDownstream(func(dc *downstreamConn) {
	809	dc.SendMessage(dc.marshalMessage(msg, uc.network))
	810	})
	811	}
[69]	812	case "JOIN":
	813	if msg.Prefix == nil {
	814	return fmt.Errorf("expected a prefix")
	815	}
[42]	816
[43]	817	var channels string
	818	if err := parseMessageParams(msg, &channels); err != nil {
	819	return err
[19]	820	}
[34]	821
[43]	822	for _, ch := range strings.Split(channels, ",") {
[478]	823	if uc.isOurNick(msg.Prefix.Name) {
[55]	824	uc.logger.Printf("joined channel %q", ch)
[478]	825	members := membershipsCasemapMap{newCasemapMap(0)}
	826	members.casemap = uc.network.casemap
	827	uc.channels.SetValue(ch, &upstreamChannel{
[34]	828	Name: ch,
[55]	829	conn: uc,
[478]	830	Members: members,
	831	})
[435]	832	uc.updateChannelAutoDetach(ch)
[139]	833
	834	uc.SendMessage(&irc.Message{
	835	Command: "MODE",
	836	Params: []string{ch},
	837	})
[34]	838	} else {
[55]	839	ch, err := uc.getChannel(ch)
[34]	840	if err != nil {
	841	return err
	842	}
[478]	843	ch.Members.SetValue(msg.Prefix.Name, &memberships{})
[19]	844	}
[69]	845
[245]	846	chMsg := msg.Copy()
	847	chMsg.Params[0] = ch
	848	uc.produce(ch, chMsg, nil)
[19]	849	}
[69]	850	case "PART":
	851	if msg.Prefix == nil {
	852	return fmt.Errorf("expected a prefix")
	853	}
[34]	854
[43]	855	var channels string
	856	if err := parseMessageParams(msg, &channels); err != nil {
	857	return err
[34]	858	}
	859
[43]	860	for _, ch := range strings.Split(channels, ",") {
[478]	861	if uc.isOurNick(msg.Prefix.Name) {
[55]	862	uc.logger.Printf("parted channel %q", ch)
[478]	863	uch := uc.channels.Value(ch)
	864	if uch != nil {
	865	uc.channels.Delete(ch)
[435]	866	uch.updateAutoDetach(0)
	867	}
[34]	868	} else {
[55]	869	ch, err := uc.getChannel(ch)
[34]	870	if err != nil {
	871	return err
	872	}
[478]	873	ch.Members.Delete(msg.Prefix.Name)
[34]	874	}
[69]	875
[245]	876	chMsg := msg.Copy()
	877	chMsg.Params[0] = ch
	878	uc.produce(ch, chMsg, nil)
[34]	879	}
[159]	880	case "KICK":
	881	if msg.Prefix == nil {
	882	return fmt.Errorf("expected a prefix")
	883	}
	884
	885	var channel, user string
	886	if err := parseMessageParams(msg, &channel, &user); err != nil {
	887	return err
	888	}
	889
[478]	890	if uc.isOurNick(user) {
[159]	891	uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
[478]	892	uc.channels.Delete(channel)
[159]	893	} else {
	894	ch, err := uc.getChannel(channel)
	895	if err != nil {
	896	return err
	897	}
[478]	898	ch.Members.Delete(user)
[159]	899	}
	900
[245]	901	uc.produce(channel, msg, nil)
[83]	902	case "QUIT":
	903	if msg.Prefix == nil {
	904	return fmt.Errorf("expected a prefix")
	905	}
	906
[478]	907	if uc.isOurNick(msg.Prefix.Name) {
[83]	908	uc.logger.Printf("quit")
	909	}
	910
[478]	911	for _, entry := range uc.channels.innerMap {
	912	ch := entry.value.(*upstreamChannel)
	913	if ch.Members.Has(msg.Prefix.Name) {
	914	ch.Members.Delete(msg.Prefix.Name)
[178]	915
[215]	916	uc.appendLog(ch.Name, msg)
[178]	917	}
[83]	918	}
	919
	920	if msg.Prefix.Name != uc.nick {
	921	uc.forEachDownstream(func(dc *downstreamConn) {
[261]	922	dc.SendMessage(dc.marshalMessage(msg, uc.network))
[83]	923	})
	924	}
[19]	925	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	926	var name, topic string
	927	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	928	return err
[19]	929	}
[55]	930	ch, err := uc.getChannel(name)
[19]	931	if err != nil {
	932	return err
	933	}
	934	if msg.Command == irc.RPL_TOPIC {
[43]	935	ch.Topic = topic
[19]	936	} else {
	937	ch.Topic = ""
	938	}
	939	case "TOPIC":
[405]	940	if msg.Prefix == nil {
	941	return fmt.Errorf("expected a prefix")
	942	}
	943
[43]	944	var name string
[74]	945	if err := parseMessageParams(msg, &name); err != nil {
[43]	946	return err
[19]	947	}
[55]	948	ch, err := uc.getChannel(name)
[19]	949	if err != nil {
	950	return err
	951	}
	952	if len(msg.Params) > 1 {
	953	ch.Topic = msg.Params[1]
[405]	954	ch.TopicWho = msg.Prefix.Copy()
	955	ch.TopicTime = time.Now() // TODO use msg.Tags["time"]
[19]	956	} else {
	957	ch.Topic = ""
	958	}
[245]	959	uc.produce(ch.Name, msg, nil)
[139]	960	case "MODE":
	961	var name, modeStr string
	962	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	963	return err
	964	}
	965
	966	if !uc.isChannel(name) { // user mode change
	967	if name != uc.nick {
	968	return fmt.Errorf("received MODE message for unknown nick %q", name)
	969	}
[553]	970
	971	if err := uc.modes.Apply(modeStr); err != nil {
	972	return err
	973	}
	974
	975	uc.forEachDownstream(func(dc *downstreamConn) {
	976	if dc.upstream() == nil {
	977	return
	978	}
	979
	980	dc.SendMessage(msg)
	981	})
[139]	982	} else { // channel mode change
	983	ch, err := uc.getChannel(name)
	984	if err != nil {
	985	return err
	986	}
	987
[293]	988	needMarshaling, err := applyChannelModes(ch, modeStr, msg.Params[2:])
	989	if err != nil {
	990	return err
[139]	991	}
	992
[293]	993	uc.appendLog(ch.Name, msg)
	994
[478]	995	c := uc.network.channels.Value(name)
	996	if c == nil \|\| !c.Detached {
[338]	997	uc.forEachDownstream(func(dc *downstreamConn) {
	998	params := make([]string, len(msg.Params))
	999	params[0] = dc.marshalEntity(uc.network, name)
	1000	params[1] = modeStr
	1001
	1002	copy(params[2:], msg.Params[2:])
	1003	for i, modeParam := range params[2:] {
	1004	if _, ok := needMarshaling[i]; ok {
	1005	params[2+i] = dc.marshalEntity(uc.network, modeParam)
	1006	}
[293]	1007	}
	1008
[338]	1009	dc.SendMessage(&irc.Message{
	1010	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
	1011	Command: "MODE",
	1012	Params: params,
	1013	})
[293]	1014	})
[338]	1015	}
[139]	1016	}
	1017	case irc.RPL_UMODEIS:
	1018	if err := parseMessageParams(msg, nil); err != nil {
	1019	return err
	1020	}
	1021	modeStr := ""
	1022	if len(msg.Params) > 1 {
	1023	modeStr = msg.Params[1]
	1024	}
	1025
	1026	uc.modes = ""
	1027	if err := uc.modes.Apply(modeStr); err != nil {
	1028	return err
	1029	}
[553]	1030
	1031	uc.forEachDownstream(func(dc *downstreamConn) {
	1032	if dc.upstream() == nil {
	1033	return
	1034	}
	1035
	1036	dc.SendMessage(msg)
	1037	})
[139]	1038	case irc.RPL_CHANNELMODEIS:
	1039	var channel string
	1040	if err := parseMessageParams(msg, nil, &channel); err != nil {
	1041	return err
	1042	}
	1043	modeStr := ""
	1044	if len(msg.Params) > 2 {
	1045	modeStr = msg.Params[2]
	1046	}
	1047
	1048	ch, err := uc.getChannel(channel)
	1049	if err != nil {
	1050	return err
	1051	}
	1052
	1053	firstMode := ch.modes == nil
	1054	ch.modes = make(map[byte]string)
[293]	1055	if _, err := applyChannelModes(ch, modeStr, msg.Params[3:]); err != nil {
[139]	1056	return err
	1057	}
	1058	if firstMode {
[478]	1059	c := uc.network.channels.Value(channel)
	1060	if c == nil \|\| !c.Detached {
[338]	1061	modeStr, modeParams := ch.modes.Format()
[139]	1062
[338]	1063	uc.forEachDownstream(func(dc *downstreamConn) {
	1064	params := []string{dc.nick, dc.marshalEntity(uc.network, channel), modeStr}
	1065	params = append(params, modeParams...)
[139]	1066
[338]	1067	dc.SendMessage(&irc.Message{
	1068	Prefix: dc.srv.prefix(),
	1069	Command: irc.RPL_CHANNELMODEIS,
	1070	Params: params,
	1071	})
[139]	1072	})
[338]	1073	}
[139]	1074	}
[162]	1075	case rpl_creationtime:
	1076	var channel, creationTime string
	1077	if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
	1078	return err
	1079	}
	1080
	1081	ch, err := uc.getChannel(channel)
	1082	if err != nil {
	1083	return err
	1084	}
	1085
	1086	firstCreationTime := ch.creationTime == ""
	1087	ch.creationTime = creationTime
	1088	if firstCreationTime {
	1089	uc.forEachDownstream(func(dc *downstreamConn) {
	1090	dc.SendMessage(&irc.Message{
	1091	Prefix: dc.srv.prefix(),
	1092	Command: rpl_creationtime,
[403]	1093	Params: []string{dc.nick, dc.marshalEntity(uc.network, ch.Name), creationTime},
[162]	1094	})
	1095	})
	1096	}
[19]	1097	case rpl_topicwhotime:
[43]	1098	var name, who, timeStr string
	1099	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	1100	return err
[19]	1101	}
[55]	1102	ch, err := uc.getChannel(name)
[19]	1103	if err != nil {
	1104	return err
	1105	}
[405]	1106	firstTopicWhoTime := ch.TopicWho == nil
	1107	ch.TopicWho = irc.ParsePrefix(who)
[43]	1108	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	1109	if err != nil {
	1110	return fmt.Errorf("failed to parse topic time: %v", err)
	1111	}
	1112	ch.TopicTime = time.Unix(sec, 0)
[405]	1113	if firstTopicWhoTime {
	1114	uc.forEachDownstream(func(dc *downstreamConn) {
	1115	topicWho := dc.marshalUserPrefix(uc.network, ch.TopicWho)
	1116	dc.SendMessage(&irc.Message{
	1117	Prefix: dc.srv.prefix(),
	1118	Command: rpl_topicwhotime,
	1119	Params: []string{
	1120	dc.nick,
	1121	dc.marshalEntity(uc.network, ch.Name),
	1122	topicWho.String(),
	1123	timeStr,
	1124	},
	1125	})
	1126	})
	1127	}
[177]	1128	case irc.RPL_LIST:
	1129	var channel, clients, topic string
	1130	if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
	1131	return err
	1132	}
	1133
[682]	1134	dc, cmd := uc.currentPendingCommand("LIST")
[681]	1135	if cmd == nil {
[177]	1136	return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
[681]	1137	} else if dc == nil {
	1138	return nil
[177]	1139	}
	1140
[681]	1141	dc.SendMessage(&irc.Message{
	1142	Prefix: dc.srv.prefix(),
	1143	Command: irc.RPL_LIST,
	1144	Params: []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
[177]	1145	})
	1146	case irc.RPL_LISTEND:
[682]	1147	dc, cmd := uc.dequeueCommand("LIST")
[681]	1148	if cmd == nil {
[177]	1149	return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
[681]	1150	} else if dc == nil {
	1151	return nil
[177]	1152	}
[681]	1153
	1154	dc.SendMessage(&irc.Message{
	1155	Prefix: dc.srv.prefix(),
	1156	Command: irc.RPL_LISTEND,
	1157	Params: []string{dc.nick, "End of /LIST"},
	1158	})
[19]	1159	case irc.RPL_NAMREPLY:
[43]	1160	var name, statusStr, members string
	1161	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	1162	return err
[19]	1163	}
[140]	1164
[478]	1165	ch := uc.channels.Value(name)
	1166	if ch == nil {
[140]	1167	// NAMES on a channel we have not joined, forward to downstream
[161]	1168	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1169	channel := dc.marshalEntity(uc.network, name)
[174]	1170	members := splitSpace(members)
[140]	1171	for i, member := range members {
[292]	1172	memberships, nick := uc.parseMembershipPrefix(member)
	1173	members[i] = memberships.Format(dc) + dc.marshalEntity(uc.network, nick)
[140]	1174	}
	1175	memberStr := strings.Join(members, " ")
	1176
	1177	dc.SendMessage(&irc.Message{
	1178	Prefix: dc.srv.prefix(),
	1179	Command: irc.RPL_NAMREPLY,
	1180	Params: []string{dc.nick, statusStr, channel, memberStr},
	1181	})
	1182	})
	1183	return nil
[19]	1184	}
	1185
[43]	1186	status, err := parseChannelStatus(statusStr)
[19]	1187	if err != nil {
	1188	return err
	1189	}
	1190	ch.Status = status
	1191
[174]	1192	for _, s := range splitSpace(members) {
[292]	1193	memberships, nick := uc.parseMembershipPrefix(s)
[478]	1194	ch.Members.SetValue(nick, memberships)
[19]	1195	}
	1196	case irc.RPL_ENDOFNAMES:
[43]	1197	var name string
	1198	if err := parseMessageParams(msg, nil, &name); err != nil {
	1199	return err
[25]	1200	}
[140]	1201
[478]	1202	ch := uc.channels.Value(name)
	1203	if ch == nil {
[140]	1204	// NAMES on a channel we have not joined, forward to downstream
[161]	1205	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1206	channel := dc.marshalEntity(uc.network, name)
[140]	1207
	1208	dc.SendMessage(&irc.Message{
	1209	Prefix: dc.srv.prefix(),
	1210	Command: irc.RPL_ENDOFNAMES,
	1211	Params: []string{dc.nick, channel, "End of /NAMES list"},
	1212	})
	1213	})
	1214	return nil
[25]	1215	}
	1216
[34]	1217	if ch.complete {
	1218	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	1219	}
[25]	1220	ch.complete = true
[27]	1221
[478]	1222	c := uc.network.channels.Value(name)
	1223	if c == nil \|\| !c.Detached {
[338]	1224	uc.forEachDownstream(func(dc *downstreamConn) {
	1225	forwardChannel(dc, ch)
	1226	})
	1227	}
[127]	1228	case irc.RPL_WHOREPLY:
	1229	var channel, username, host, server, nick, mode, trailing string
	1230	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	1231	return err
	1232	}
	1233
[682]	1234	dc, cmd := uc.currentPendingCommand("WHO")
	1235	if cmd == nil {
	1236	return fmt.Errorf("unexpected RPL_WHOREPLY: no matching pending WHO")
	1237	} else if dc == nil {
	1238	return nil
	1239	}
	1240
[127]	1241	parts := strings.SplitN(trailing, " ", 2)
	1242	if len(parts) != 2 {
	1243	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	1244	}
	1245	realname := parts[1]
	1246	hops, err := strconv.Atoi(parts[0])
	1247	if err != nil {
	1248	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	1249	}
	1250	hops++
	1251
	1252	trailing = strconv.Itoa(hops) + " " + realname
	1253
[682]	1254	if channel != "*" {
	1255	channel = dc.marshalEntity(uc.network, channel)
	1256	}
	1257	nick = dc.marshalEntity(uc.network, nick)
	1258	dc.SendMessage(&irc.Message{
	1259	Prefix: dc.srv.prefix(),
	1260	Command: irc.RPL_WHOREPLY,
	1261	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
[127]	1262	})
[682]	1263	case rpl_whospcrpl:
	1264	dc, cmd := uc.currentPendingCommand("WHO")
	1265	if cmd == nil {
	1266	return fmt.Errorf("unexpected RPL_WHOSPCRPL: no matching pending WHO")
	1267	} else if dc == nil {
	1268	return nil
	1269	}
	1270
	1271	// Only supported in single-upstream mode, so forward as-is
	1272	dc.SendMessage(msg)
[127]	1273	case irc.RPL_ENDOFWHO:
	1274	var name string
	1275	if err := parseMessageParams(msg, nil, &name); err != nil {
	1276	return err
	1277	}
	1278
[682]	1279	dc, cmd := uc.dequeueCommand("WHO")
	1280	if cmd == nil {
	1281	return fmt.Errorf("unexpected RPL_ENDOFWHO: no matching pending WHO")
	1282	} else if dc == nil {
	1283	return nil
	1284	}
	1285
	1286	mask := "*"
	1287	if len(cmd.Params) > 0 {
	1288	mask = cmd.Params[0]
	1289	}
	1290	dc.SendMessage(&irc.Message{
	1291	Prefix: dc.srv.prefix(),
	1292	Command: irc.RPL_ENDOFWHO,
	1293	Params: []string{dc.nick, mask, "End of /WHO list"},
[127]	1294	})
[128]	1295	case irc.RPL_WHOISUSER:
	1296	var nick, username, host, realname string
	1297	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	1298	return err
	1299	}
	1300
[161]	1301	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1302	nick := dc.marshalEntity(uc.network, nick)
[128]	1303	dc.SendMessage(&irc.Message{
	1304	Prefix: dc.srv.prefix(),
	1305	Command: irc.RPL_WHOISUSER,
	1306	Params: []string{dc.nick, nick, username, host, "*", realname},
	1307	})
	1308	})
	1309	case irc.RPL_WHOISSERVER:
	1310	var nick, server, serverInfo string
	1311	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	1312	return err
	1313	}
	1314
[161]	1315	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1316	nick := dc.marshalEntity(uc.network, nick)
[128]	1317	dc.SendMessage(&irc.Message{
	1318	Prefix: dc.srv.prefix(),
	1319	Command: irc.RPL_WHOISSERVER,
	1320	Params: []string{dc.nick, nick, server, serverInfo},
	1321	})
	1322	})
	1323	case irc.RPL_WHOISOPERATOR:
	1324	var nick string
	1325	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1326	return err
	1327	}
	1328
[161]	1329	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1330	nick := dc.marshalEntity(uc.network, nick)
[128]	1331	dc.SendMessage(&irc.Message{
	1332	Prefix: dc.srv.prefix(),
	1333	Command: irc.RPL_WHOISOPERATOR,
	1334	Params: []string{dc.nick, nick, "is an IRC operator"},
	1335	})
	1336	})
	1337	case irc.RPL_WHOISIDLE:
	1338	var nick string
	1339	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	1340	return err
	1341	}
	1342
[161]	1343	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1344	nick := dc.marshalEntity(uc.network, nick)
[128]	1345	params := []string{dc.nick, nick}
	1346	params = append(params, msg.Params[2:]...)
	1347	dc.SendMessage(&irc.Message{
	1348	Prefix: dc.srv.prefix(),
	1349	Command: irc.RPL_WHOISIDLE,
	1350	Params: params,
	1351	})
	1352	})
	1353	case irc.RPL_WHOISCHANNELS:
	1354	var nick, channelList string
	1355	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	1356	return err
	1357	}
[174]	1358	channels := splitSpace(channelList)
[128]	1359
[161]	1360	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1361	nick := dc.marshalEntity(uc.network, nick)
[128]	1362	channelList := make([]string, len(channels))
	1363	for i, channel := range channels {
[139]	1364	prefix, channel := uc.parseMembershipPrefix(channel)
[260]	1365	channel = dc.marshalEntity(uc.network, channel)
[292]	1366	channelList[i] = prefix.Format(dc) + channel
[128]	1367	}
	1368	channels := strings.Join(channelList, " ")
	1369	dc.SendMessage(&irc.Message{
	1370	Prefix: dc.srv.prefix(),
	1371	Command: irc.RPL_WHOISCHANNELS,
	1372	Params: []string{dc.nick, nick, channels},
	1373	})
	1374	})
	1375	case irc.RPL_ENDOFWHOIS:
	1376	var nick string
	1377	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1378	return err
	1379	}
	1380
[161]	1381	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1382	nick := dc.marshalEntity(uc.network, nick)
[128]	1383	dc.SendMessage(&irc.Message{
	1384	Prefix: dc.srv.prefix(),
	1385	Command: irc.RPL_ENDOFWHOIS,
[142]	1386	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	1387	})
	1388	})
[115]	1389	case "INVITE":
[273]	1390	var nick, channel string
[115]	1391	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1392	return err
	1393	}
	1394
[478]	1395	weAreInvited := uc.isOurNick(nick)
[448]	1396
[115]	1397	uc.forEachDownstream(func(dc *downstreamConn) {
[448]	1398	if !weAreInvited && !dc.caps["invite-notify"] {
	1399	return
	1400	}
[115]	1401	dc.SendMessage(&irc.Message{
[260]	1402	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
[115]	1403	Command: "INVITE",
[260]	1404	Params: []string{dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
[115]	1405	})
	1406	})
[163]	1407	case irc.RPL_INVITING:
[273]	1408	var nick, channel string
[304]	1409	if err := parseMessageParams(msg, nil, &nick, &channel); err != nil {
[163]	1410	return err
	1411	}
	1412
	1413	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1414	dc.SendMessage(&irc.Message{
	1415	Prefix: dc.srv.prefix(),
	1416	Command: irc.RPL_INVITING,
[260]	1417	Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
[163]	1418	})
	1419	})
[684]	1420	case irc.RPL_MONONLINE, irc.RPL_MONOFFLINE:
	1421	var targetsStr string
	1422	if err := parseMessageParams(msg, nil, &targetsStr); err != nil {
	1423	return err
	1424	}
	1425	targets := strings.Split(targetsStr, ",")
	1426
	1427	online := msg.Command == irc.RPL_MONONLINE
	1428	for _, target := range targets {
	1429	prefix := irc.ParsePrefix(target)
	1430	uc.monitored.SetValue(prefix.Name, online)
	1431	}
	1432
	1433	uc.forEachDownstream(func(dc *downstreamConn) {
	1434	for _, target := range targets {
	1435	prefix := irc.ParsePrefix(target)
	1436	if dc.monitored.Has(prefix.Name) {
	1437	dc.SendMessage(&irc.Message{
	1438	Prefix: dc.srv.prefix(),
	1439	Command: msg.Command,
	1440	Params: []string{dc.nick, target},
	1441	})
	1442	}
	1443	}
	1444	})
	1445	case irc.ERR_MONLISTFULL:
	1446	var limit, targetsStr string
	1447	if err := parseMessageParams(msg, nil, &limit, &targetsStr); err != nil {
	1448	return err
	1449	}
	1450
	1451	targets := strings.Split(targetsStr, ",")
	1452	uc.forEachDownstream(func(dc *downstreamConn) {
	1453	for _, target := range targets {
	1454	if dc.monitored.Has(target) {
	1455	dc.SendMessage(&irc.Message{
	1456	Prefix: dc.srv.prefix(),
	1457	Command: msg.Command,
	1458	Params: []string{dc.nick, limit, target},
	1459	})
	1460	}
	1461	}
	1462	})
[272]	1463	case irc.RPL_AWAY:
	1464	var nick, reason string
	1465	if err := parseMessageParams(msg, nil, &nick, &reason); err != nil {
	1466	return err
	1467	}
	1468
[274]	1469	uc.forEachDownstream(func(dc *downstreamConn) {
[272]	1470	dc.SendMessage(&irc.Message{
	1471	Prefix: dc.srv.prefix(),
	1472	Command: irc.RPL_AWAY,
	1473	Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), reason},
	1474	})
	1475	})
[649]	1476	case "AWAY", "ACCOUNT":
[276]	1477	if msg.Prefix == nil {
	1478	return fmt.Errorf("expected a prefix")
	1479	}
	1480
	1481	uc.forEachDownstream(func(dc *downstreamConn) {
	1482	dc.SendMessage(&irc.Message{
	1483	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
[648]	1484	Command: msg.Command,
	1485	Params: msg.Params,
	1486	})
	1487	})
[300]	1488	case irc.RPL_BANLIST, irc.RPL_INVITELIST, irc.RPL_EXCEPTLIST:
	1489	var channel, mask string
	1490	if err := parseMessageParams(msg, nil, &channel, &mask); err != nil {
	1491	return err
	1492	}
	1493	var addNick, addTime string
	1494	if len(msg.Params) >= 5 {
	1495	addNick = msg.Params[3]
	1496	addTime = msg.Params[4]
	1497	}
	1498
	1499	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1500	channel := dc.marshalEntity(uc.network, channel)
	1501
	1502	var params []string
	1503	if addNick != "" && addTime != "" {
	1504	addNick := dc.marshalEntity(uc.network, addNick)
	1505	params = []string{dc.nick, channel, mask, addNick, addTime}
	1506	} else {
	1507	params = []string{dc.nick, channel, mask}
	1508	}
	1509
	1510	dc.SendMessage(&irc.Message{
	1511	Prefix: dc.srv.prefix(),
	1512	Command: msg.Command,
	1513	Params: params,
	1514	})
	1515	})
	1516	case irc.RPL_ENDOFBANLIST, irc.RPL_ENDOFINVITELIST, irc.RPL_ENDOFEXCEPTLIST:
	1517	var channel, trailing string
	1518	if err := parseMessageParams(msg, nil, &channel, &trailing); err != nil {
	1519	return err
	1520	}
	1521
	1522	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1523	upstreamChannel := dc.marshalEntity(uc.network, channel)
	1524	dc.SendMessage(&irc.Message{
	1525	Prefix: dc.srv.prefix(),
	1526	Command: msg.Command,
	1527	Params: []string{dc.nick, upstreamChannel, trailing},
	1528	})
	1529	})
[302]	1530	case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
	1531	var command, reason string
	1532	if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
	1533	return err
	1534	}
	1535
[682]	1536	if command == "LIST" \|\| command == "WHO" {
	1537	dc, _ := uc.dequeueCommand(command)
	1538	if dc != nil && downstreamID == 0 {
	1539	downstreamID = dc.id
	1540	}
[302]	1541	}
	1542
[355]	1543	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1544	dc.SendMessage(&irc.Message{
	1545	Prefix: uc.srv.prefix(),
	1546	Command: msg.Command,
	1547	Params: []string{dc.nick, command, reason},
[302]	1548	})
[355]	1549	})
[155]	1550	case "ACK":
	1551	// Ignore
[198]	1552	case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
	1553	// Ignore
[16]	1554	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	1555	// Ignore
	1556	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
[561]	1557	fallthrough
	1558	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
	1559	fallthrough
	1560	case rpl_localusers, rpl_globalusers:
	1561	fallthrough
[478]	1562	case irc.RPL_MOTDSTART, irc.RPL_MOTD:
[561]	1563	// Ignore these messages if they're part of the initial registration
	1564	// message burst. Forward them if the user explicitly asked for them.
[552]	1565	if !uc.gotMotd {
	1566	return nil
	1567	}
	1568
[553]	1569	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1570	dc.SendMessage(&irc.Message{
	1571	Prefix: uc.srv.prefix(),
[552]	1572	Command: msg.Command,
[553]	1573	Params: msg.Params,
[552]	1574	})
	1575	})
[177]	1576	case irc.RPL_LISTSTART:
	1577	// Ignore
[390]	1578	case "ERROR":
	1579	var text string
	1580	if err := parseMessageParams(msg, &text); err != nil {
	1581	return err
	1582	}
	1583	return fmt.Errorf("fatal server error: %v", text)
[389]	1584	case irc.ERR_PASSWDMISMATCH, irc.ERR_ERRONEUSNICKNAME, irc.ERR_NICKNAMEINUSE, irc.ERR_NICKCOLLISION, irc.ERR_UNAVAILRESOURCE, irc.ERR_NOPERMFORHOST, irc.ERR_YOUREBANNEDCREEP:
[342]	1585	if !uc.registered {
[399]	1586	text := msg.Params[len(msg.Params)-1]
	1587	return registrationError(text)
[342]	1588	}
	1589	fallthrough
[13]	1590	default:
[95]	1591	uc.logger.Printf("unhandled message: %v", msg)
[355]	1592
	1593	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1594	// best effort marshaling for unknown messages, replies and errors:
	1595	// most numerics start with the user nick, marshal it if that's the case
	1596	// otherwise, conservately keep the params without marshaling
	1597	params := msg.Params
	1598	if _, err := strconv.Atoi(msg.Command); err == nil { // numeric
	1599	if len(msg.Params) > 0 && isOurNick(uc.network, msg.Params[0]) {
	1600	params[0] = dc.nick
[302]	1601	}
[355]	1602	}
	1603	dc.SendMessage(&irc.Message{
	1604	Prefix: uc.srv.prefix(),
	1605	Command: msg.Command,
	1606	Params: params,
[302]	1607	})
[355]	1608	})
[13]	1609	}
[14]	1610	return nil
[13]	1611	}
	1612
[499]	1613	func (uc upstreamConn) handleDetachedMessage(ch Channel, msg *irc.Message) {
	1614	if uc.network.detachedMessageNeedsRelay(ch, msg) {
[435]	1615	uc.forEachDownstream(func(dc *downstreamConn) {
[499]	1616	dc.relayDetachedMessage(uc.network, msg)
[435]	1617	})
	1618	}
[499]	1619	if ch.ReattachOn == FilterMessage \|\| (ch.ReattachOn == FilterHighlight && uc.network.isHighlight(msg)) {
[435]	1620	uc.network.attach(ch)
[652]	1621	if err := uc.srv.db.StoreChannel(context.TODO(), uc.network.ID, ch); err != nil {
[435]	1622	uc.logger.Printf("failed to update channel %q: %v", ch.Name, err)
	1623	}
	1624	}
	1625	}
	1626
[458]	1627	func (uc *upstreamConn) handleChanModes(s string) error {
	1628	parts := strings.SplitN(s, ",", 5)
	1629	if len(parts) < 4 {
	1630	return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", s)
	1631	}
	1632	modes := make(map[byte]channelModeType)
	1633	for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
	1634	for j := 0; j < len(parts[i]); j++ {
	1635	mode := parts[i][j]
	1636	modes[mode] = mt
	1637	}
	1638	}
	1639	uc.availableChannelModes = modes
	1640	return nil
	1641	}
	1642
	1643	func (uc *upstreamConn) handleMemberships(s string) error {
	1644	if s == "" {
	1645	uc.availableMemberships = nil
	1646	return nil
	1647	}
	1648
	1649	if s[0] != '(' {
	1650	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
	1651	}
	1652	sep := strings.IndexByte(s, ')')
	1653	if sep < 0 \|\| len(s) != sep*2 {
	1654	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
	1655	}
	1656	memberships := make([]membership, len(s)/2-1)
	1657	for i := range memberships {
	1658	memberships[i] = membership{
	1659	Mode: s[i+1],
	1660	Prefix: s[sep+i+1],
	1661	}
	1662	}
	1663	uc.availableMemberships = memberships
	1664	return nil
	1665	}
	1666
[281]	1667	func (uc *upstreamConn) handleSupportedCaps(capsStr string) {
	1668	caps := strings.Fields(capsStr)
	1669	for _, s := range caps {
	1670	kv := strings.SplitN(s, "=", 2)
	1671	k := strings.ToLower(kv[0])
	1672	var v string
	1673	if len(kv) == 2 {
	1674	v = kv[1]
	1675	}
	1676	uc.supportedCaps[k] = v
	1677	}
	1678	}
	1679
	1680	func (uc *upstreamConn) requestCaps() {
	1681	var requestCaps []string
[282]	1682	for c := range permanentUpstreamCaps {
[281]	1683	if _, ok := uc.supportedCaps[c]; ok && !uc.caps[c] {
	1684	requestCaps = append(requestCaps, c)
	1685	}
	1686	}
	1687
	1688	if uc.requestSASL() && !uc.caps["sasl"] {
	1689	requestCaps = append(requestCaps, "sasl")
	1690	}
	1691
[282]	1692	if len(requestCaps) == 0 {
	1693	return
	1694	}
	1695
	1696	uc.SendMessage(&irc.Message{
	1697	Command: "CAP",
	1698	Params: []string{"REQ", strings.Join(requestCaps, " ")},
	1699	})
	1700	}
	1701
	1702	func (uc *upstreamConn) requestSASL() bool {
	1703	if uc.network.SASL.Mechanism == "" {
	1704	return false
	1705	}
	1706
	1707	v, ok := uc.supportedCaps["sasl"]
	1708	if !ok {
	1709	return false
	1710	}
	1711	if v != "" {
	1712	mechanisms := strings.Split(v, ",")
	1713	found := false
	1714	for _, mech := range mechanisms {
	1715	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1716	found = true
	1717	break
	1718	}
	1719	}
	1720	if !found {
	1721	return false
	1722	}
	1723	}
	1724
	1725	return true
	1726	}
	1727
	1728	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1729	uc.caps[name] = ok
	1730
	1731	switch name {
	1732	case "sasl":
	1733	if !ok {
	1734	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1735	return nil
	1736	}
	1737
	1738	auth := &uc.network.SASL
	1739	switch auth.Mechanism {
	1740	case "PLAIN":
	1741	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1742	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
[307]	1743	case "EXTERNAL":
	1744	uc.logger.Printf("starting SASL EXTERNAL authentication")
	1745	uc.saslClient = sasl.NewExternalClient("")
[282]	1746	default:
	1747	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1748	}
	1749
[281]	1750	uc.SendMessage(&irc.Message{
[282]	1751	Command: "AUTHENTICATE",
	1752	Params: []string{auth.Mechanism},
[281]	1753	})
[282]	1754	default:
	1755	if permanentUpstreamCaps[name] {
	1756	break
	1757	}
	1758	uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
[281]	1759	}
[282]	1760	return nil
[281]	1761	}
	1762
[174]	1763	func splitSpace(s string) []string {
	1764	return strings.FieldsFunc(s, func(r rune) bool {
	1765	return r == ' '
	1766	})
	1767	}
	1768
[55]	1769	func (uc *upstreamConn) register() {
[664]	1770	uc.nick = GetNick(&uc.user.User, &uc.network.Network)
[478]	1771	uc.nickCM = uc.network.casemap(uc.nick)
[674]	1772	uc.username = GetUsername(&uc.user.User, &uc.network.Network)
[568]	1773	uc.realname = GetRealname(&uc.user.User, &uc.network.Network)
[77]	1774
[60]	1775	uc.SendMessage(&irc.Message{
[92]	1776	Command: "CAP",
	1777	Params: []string{"LS", "302"},
	1778	})
	1779
[93]	1780	if uc.network.Pass != "" {
	1781	uc.SendMessage(&irc.Message{
	1782	Command: "PASS",
	1783	Params: []string{uc.network.Pass},
	1784	})
	1785	}
	1786
[92]	1787	uc.SendMessage(&irc.Message{
[13]	1788	Command: "NICK",
[69]	1789	Params: []string{uc.nick},
[60]	1790	})
	1791	uc.SendMessage(&irc.Message{
[13]	1792	Command: "USER",
[77]	1793	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1794	})
[44]	1795	}
[13]	1796
[197]	1797	func (uc *upstreamConn) runUntilRegistered() error {
	1798	for !uc.registered {
[212]	1799	msg, err := uc.ReadMessage()
[197]	1800	if err != nil {
	1801	return fmt.Errorf("failed to read message: %v", err)
	1802	}
	1803
	1804	if err := uc.handleMessage(msg); err != nil {
[399]	1805	if _, ok := err.(registrationError); ok {
	1806	return err
	1807	} else {
	1808	msg.Tags = nil // prevent message tags from cluttering logs
	1809	return fmt.Errorf("failed to handle message %q: %v", msg, err)
	1810	}
[197]	1811	}
	1812	}
	1813
[263]	1814	for _, command := range uc.network.ConnectCommands {
	1815	m, err := irc.ParseMessage(command)
	1816	if err != nil {
	1817	uc.logger.Printf("failed to parse connect command %q: %v", command, err)
	1818	} else {
	1819	uc.SendMessage(m)
	1820	}
	1821	}
	1822
[197]	1823	return nil
	1824	}
	1825
[165]	1826	func (uc *upstreamConn) readMessages(ch chan<- event) error {
[13]	1827	for {
[210]	1828	msg, err := uc.ReadMessage()
[655]	1829	if errors.Is(err, io.EOF) {
[13]	1830	break
	1831	} else if err != nil {
	1832	return fmt.Errorf("failed to read IRC command: %v", err)
	1833	}
	1834
[165]	1835	ch <- eventUpstreamMessage{msg, uc}
[13]	1836	}
	1837
[45]	1838	return nil
[13]	1839	}
[60]	1840
[303]	1841	func (uc upstreamConn) SendMessage(msg irc.Message) {
	1842	if !uc.caps["message-tags"] {
	1843	msg = msg.Copy()
	1844	msg.Tags = nil
	1845	}
	1846
	1847	uc.conn.SendMessage(msg)
	1848	}
	1849
[176]	1850	func (uc upstreamConn) SendMessageLabeled(downstreamID uint64, msg irc.Message) {
[278]	1851	if uc.caps["labeled-response"] {
[155]	1852	if msg.Tags == nil {
	1853	msg.Tags = make(map[string]irc.TagValue)
	1854	}
[176]	1855	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
[161]	1856	uc.nextLabelID++
[155]	1857	}
	1858	uc.SendMessage(msg)
	1859	}
[178]	1860
[428]	1861	// appendLog appends a message to the log file.
	1862	//
	1863	// The internal message ID is returned. If the message isn't recorded in the
	1864	// log file, an empty string is returned.
	1865	func (uc upstreamConn) appendLog(entity string, msg irc.Message) (msgID string) {
[423]	1866	if uc.user.msgStore == nil {
[428]	1867	return ""
[178]	1868	}
[486]	1869
[563]	1870	// Don't store messages with a server mask target
	1871	if strings.HasPrefix(entity, "$") {
	1872	return ""
	1873	}
	1874
[486]	1875	entityCM := uc.network.casemap(entity)
	1876	if entityCM == "nickserv" {
[468]	1877	// The messages sent/received from NickServ may contain
	1878	// security-related information (like passwords). Don't store these.
	1879	return ""
	1880	}
[215]	1881
[485]	1882	if !uc.network.delivered.HasTarget(entity) {
[482]	1883	// This is the first message we receive from this target. Save the last
	1884	// message ID in delivery receipts, so that we can send the new message
	1885	// in the backlog if an offline client reconnects.
[666]	1886	lastID, err := uc.user.msgStore.LastMsgID(&uc.network.Network, entityCM, time.Now())
[409]	1887	if err != nil {
	1888	uc.logger.Printf("failed to log message: failed to get last message ID: %v", err)
[428]	1889	return ""
[409]	1890	}
	1891
[489]	1892	uc.network.delivered.ForEachClient(func(clientName string) {
[485]	1893	uc.network.delivered.StoreID(entity, clientName, lastID)
[489]	1894	})
[253]	1895	}
	1896
[666]	1897	msgID, err := uc.user.msgStore.Append(&uc.network.Network, entityCM, msg)
[409]	1898	if err != nil {
	1899	uc.logger.Printf("failed to log message: %v", err)
[428]	1900	return ""
[409]	1901	}
[406]	1902
[428]	1903	return msgID
[253]	1904	}
	1905
[409]	1906	// produce appends a message to the logs and forwards it to connected downstream
	1907	// connections.
[245]	1908	//
	1909	// If origin is not nil and origin doesn't support echo-message, the message is
	1910	// forwarded to all connections except origin.
[239]	1911	func (uc upstreamConn) produce(target string, msg irc.Message, origin *downstreamConn) {
[428]	1912	var msgID string
[239]	1913	if target != "" {
[428]	1914	msgID = uc.appendLog(target, msg)
[239]	1915	}
	1916
[284]	1917	// Don't forward messages if it's a detached channel
[478]	1918	ch := uc.network.channels.Value(target)
[499]	1919	detached := ch != nil && ch.Detached
[284]	1920
[227]	1921	uc.forEachDownstream(func(dc *downstreamConn) {
[499]	1922	if !detached && (dc != origin \|\| dc.caps["echo-message"]) {
[428]	1923	dc.sendMessageWithID(dc.marshalMessage(msg, uc.network), msgID)
	1924	} else {
	1925	dc.advanceMessageWithID(msg, msgID)
[238]	1926	}
[227]	1927	})
[226]	1928	}
	1929
[198]	1930	func (uc *upstreamConn) updateAway() {
	1931	away := true
	1932	uc.forEachDownstream(func(*downstreamConn) {
	1933	away = false
	1934	})
	1935	if away == uc.away {
	1936	return
	1937	}
	1938	if away {
	1939	uc.SendMessage(&irc.Message{
	1940	Command: "AWAY",
	1941	Params: []string{"Auto away"},
	1942	})
	1943	} else {
	1944	uc.SendMessage(&irc.Message{
	1945	Command: "AWAY",
	1946	})
	1947	}
	1948	uc.away = away
	1949	}
[435]	1950
	1951	func (uc *upstreamConn) updateChannelAutoDetach(name string) {
[478]	1952	uch := uc.channels.Value(name)
	1953	if uch == nil {
	1954	return
[435]	1955	}
[478]	1956	ch := uc.network.channels.Value(name)
	1957	if ch == nil \|\| ch.Detached {
	1958	return
	1959	}
	1960	uch.updateAutoDetach(ch.DetachAfter)
[435]	1961	}
[684]	1962
	1963	func (uc *upstreamConn) updateMonitor() {
	1964	add := make(map[string]struct{})
	1965	var addList []string
	1966	seen := make(map[string]struct{})
	1967	uc.forEachDownstream(func(dc *downstreamConn) {
	1968	for targetCM := range dc.monitored.innerMap {
	1969	if !uc.monitored.Has(targetCM) {
	1970	if _, ok := add[targetCM]; !ok {
	1971	addList = append(addList, targetCM)
	1972	}
	1973	add[targetCM] = struct{}{}
	1974	} else {
	1975	seen[targetCM] = struct{}{}
	1976	}
	1977	}
	1978	})
	1979
	1980	removeAll := true
	1981	var removeList []string
	1982	for targetCM, entry := range uc.monitored.innerMap {
	1983	if _, ok := seen[targetCM]; ok {
	1984	removeAll = false
	1985	} else {
	1986	removeList = append(removeList, entry.originalKey)
	1987	}
	1988	}
	1989
	1990	// TODO: better handle the case where len(uc.monitored) + len(addList)
	1991	// exceeds the limit, probably by immediately sending ERR_MONLISTFULL?
	1992
	1993	if removeAll && len(addList) == 0 && len(removeList) > 0 {
	1994	// Optimization when the last MONITOR-aware downstream disconnects
	1995	uc.SendMessage(&irc.Message{
	1996	Command: "MONITOR",
	1997	Params: []string{"C"},
	1998	})
	1999	} else {
	2000	msgs := generateMonitor("-", removeList)
	2001	msgs = append(msgs, generateMonitor("+", addList)...)
	2002	for _, msg := range msgs {
	2003	uc.SendMessage(msg)
	2004	}
	2005	}
	2006
	2007	for _, target := range removeList {
	2008	uc.monitored.Delete(target)
	2009	}
	2010	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: