Context Navigation

source: code/trunk/upstream.go@ 554

Last change on this file since 554 was 553, checked in by greg, 4 years ago

Forward user mode changes in single-upstream mode

References: https://todo.sr.ht/~emersion/soju/20

File size: 46.5 KB

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

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

Download in other formats: