Context Navigation

source: code/trunk/upstream.go@ 723

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

Use RPL_LOGGEDIN/OUT to mirror upstream status

This will allow clients to properly show/hide UI to login and
register.

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

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

Download in other formats: