Context Navigation

source: code/trunk/downstream.go@ 692

Last change on this file since 692 was 692, checked in by contact, 4 years ago
Add downstreamConn.isMultiUpstream
File size: 67.9 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
[652]	4	"context"
[91]	5	"crypto/tls"
[112]	6	"encoding/base64"
[655]	7	"errors"
[13]	8	"fmt"
	9	"io"
	10	"net"
[108]	11	"strconv"
[39]	12	"strings"
[91]	13	"time"
[13]	14
[112]	15	"github.com/emersion/go-sasl"
[85]	16	"golang.org/x/crypto/bcrypt"
[13]	17	"gopkg.in/irc.v3"
	18	)
	19
	20	type ircError struct {
	21	Message *irc.Message
	22	}
	23
[85]	24	func (err ircError) Error() string {
	25	return err.Message.String()
	26	}
	27
[13]	28	func newUnknownCommandError(cmd string) ircError {
	29	return ircError{&irc.Message{
	30	Command: irc.ERR_UNKNOWNCOMMAND,
	31	Params: []string{
	32	"*",
	33	cmd,
	34	"Unknown command",
	35	},
	36	}}
	37	}
	38
	39	func newNeedMoreParamsError(cmd string) ircError {
	40	return ircError{&irc.Message{
	41	Command: irc.ERR_NEEDMOREPARAMS,
	42	Params: []string{
	43	"*",
	44	cmd,
	45	"Not enough parameters",
	46	},
	47	}}
	48	}
	49
[319]	50	func newChatHistoryError(subcommand string, target string) ircError {
	51	return ircError{&irc.Message{
	52	Command: "FAIL",
	53	Params: []string{"CHATHISTORY", "MESSAGE_ERROR", subcommand, target, "Messages could not be retrieved"},
	54	}}
	55	}
	56
[85]	57	var errAuthFailed = ircError{&irc.Message{
	58	Command: irc.ERR_PASSWDMISMATCH,
	59	Params: []string{"*", "Invalid username or password"},
	60	}}
[13]	61
[535]	62	func parseBouncerNetID(subcommand, s string) (int64, error) {
[532]	63	id, err := strconv.ParseInt(s, 10, 64)
	64	if err != nil {
	65	return 0, ircError{&irc.Message{
	66	Command: "FAIL",
[535]	67	Params: []string{"BOUNCER", "INVALID_NETID", subcommand, s, "Invalid network ID"},
[532]	68	}}
	69	}
	70	return id, nil
	71	}
	72
[654]	73	func fillNetworkAddrAttrs(attrs irc.Tags, network *Network) {
	74	u, err := network.URL()
	75	if err != nil {
	76	return
	77	}
	78
	79	hasHostPort := true
	80	switch u.Scheme {
	81	case "ircs":
	82	attrs["tls"] = irc.TagValue("1")
	83	case "irc+insecure":
	84	attrs["tls"] = irc.TagValue("0")
	85	default: // e.g. unix://
	86	hasHostPort = false
	87	}
	88	if host, port, err := net.SplitHostPort(u.Host); err == nil && hasHostPort {
	89	attrs["host"] = irc.TagValue(host)
	90	attrs["port"] = irc.TagValue(port)
	91	} else if hasHostPort {
	92	attrs["host"] = irc.TagValue(u.Host)
	93	}
	94	}
	95
[535]	96	func getNetworkAttrs(network *network) irc.Tags {
	97	state := "disconnected"
	98	if uc := network.conn; uc != nil {
	99	state = "connected"
	100	}
	101
	102	attrs := irc.Tags{
	103	"name": irc.TagValue(network.GetName()),
	104	"state": irc.TagValue(state),
[664]	105	"nickname": irc.TagValue(GetNick(&network.user.User, &network.Network)),
[535]	106	}
	107
	108	if network.Username != "" {
	109	attrs["username"] = irc.TagValue(network.Username)
	110	}
[568]	111	if realname := GetRealname(&network.user.User, &network.Network); realname != "" {
	112	attrs["realname"] = irc.TagValue(realname)
[535]	113	}
	114
[654]	115	fillNetworkAddrAttrs(attrs, &network.Network)
	116
	117	return attrs
	118	}
	119
	120	func networkAddrFromAttrs(attrs irc.Tags) string {
	121	host, ok := attrs.GetTag("host")
	122	if !ok {
	123	return ""
	124	}
	125
	126	addr := host
	127	if port, ok := attrs.GetTag("port"); ok {
	128	addr += ":" + port
	129	}
	130
	131	if tlsStr, ok := attrs.GetTag("tls"); ok && tlsStr == "0" {
	132	addr = "irc+insecure://" + tlsStr
	133	}
	134
	135	return addr
	136	}
	137
	138	func updateNetworkAttrs(record *Network, attrs irc.Tags, subcommand string) error {
	139	addrAttrs := irc.Tags{}
	140	fillNetworkAddrAttrs(addrAttrs, record)
	141
	142	updateAddr := false
	143	for k, v := range attrs {
	144	s := string(v)
	145	switch k {
	146	case "host", "port", "tls":
	147	updateAddr = true
	148	addrAttrs[k] = v
	149	case "name":
	150	record.Name = s
	151	case "nickname":
	152	record.Nick = s
	153	case "username":
	154	record.Username = s
	155	case "realname":
	156	record.Realname = s
	157	case "pass":
	158	record.Pass = s
[535]	159	default:
[654]	160	return ircError{&irc.Message{
	161	Command: "FAIL",
	162	Params: []string{"BOUNCER", "UNKNOWN_ATTRIBUTE", subcommand, k, "Unknown attribute"},
	163	}}
[535]	164	}
[654]	165	}
	166
	167	if updateAddr {
	168	record.Addr = networkAddrFromAttrs(addrAttrs)
	169	if record.Addr == "" {
	170	return ircError{&irc.Message{
	171	Command: "FAIL",
	172	Params: []string{"BOUNCER", "NEED_ATTRIBUTE", subcommand, "host", "Missing required host attribute"},
	173	}}
[535]	174	}
	175	}
	176
[654]	177	return nil
[535]	178	}
	179
[411]	180	// ' ' and ':' break the IRC message wire format, '@' and '!' break prefixes,
[565]	181	// '*' and '?' break masks, '$' breaks server masks in PRIVMSG/NOTICE
	182	const illegalNickChars = " :@!*?$"
[404]	183
[275]	184	// permanentDownstreamCaps is the list of always-supported downstream
	185	// capabilities.
	186	var permanentDownstreamCaps = map[string]string{
[535]	187	"batch": "",
	188	"cap-notify": "",
	189	"echo-message": "",
	190	"invite-notify": "",
	191	"message-tags": "",
	192	"sasl": "PLAIN",
	193	"server-time": "",
[540]	194	"setname": "",
[535]	195
	196	"soju.im/bouncer-networks": "",
	197	"soju.im/bouncer-networks-notify": "",
[275]	198	}
	199
[292]	200	// needAllDownstreamCaps is the list of downstream capabilities that
	201	// require support from all upstreams to be enabled
	202	var needAllDownstreamCaps = map[string]string{
[648]	203	"account-notify": "",
	204	"account-tag": "",
	205	"away-notify": "",
	206	"extended-join": "",
	207	"multi-prefix": "",
[685]	208
	209	"draft/extended-monitor": "",
[292]	210	}
	211
[463]	212	// passthroughIsupport is the set of ISUPPORT tokens that are directly passed
	213	// through from the upstream server to downstream clients.
	214	//
	215	// This is only effective in single-upstream mode.
	216	var passthroughIsupport = map[string]bool{
[580]	217	"AWAYLEN": true,
	218	"BOT": true,
	219	"CHANLIMIT": true,
	220	"CHANMODES": true,
	221	"CHANNELLEN": true,
	222	"CHANTYPES": true,
	223	"CLIENTTAGDENY": true,
[683]	224	"ELIST": true,
[580]	225	"EXCEPTS": true,
	226	"EXTBAN": true,
	227	"HOSTLEN": true,
	228	"INVEX": true,
	229	"KICKLEN": true,
	230	"MAXLIST": true,
	231	"MAXTARGETS": true,
	232	"MODES": true,
[684]	233	"MONITOR": true,
[580]	234	"NAMELEN": true,
	235	"NETWORK": true,
	236	"NICKLEN": true,
	237	"PREFIX": true,
	238	"SAFELIST": true,
	239	"TARGMAX": true,
	240	"TOPICLEN": true,
	241	"USERLEN": true,
	242	"UTF8ONLY": true,
[660]	243	"WHOX": true,
[463]	244	}
	245
[13]	246	type downstreamConn struct {
[210]	247	conn
[22]	248
[210]	249	id uint64
	250
[100]	251	registered bool
	252	user *user
	253	nick string
[478]	254	nickCM string
[100]	255	rawUsername string
[168]	256	networkName string
[183]	257	clientName string
[100]	258	realname string
[141]	259	hostname string
[100]	260	password string // empty after authentication
	261	network *network // can be nil
[105]	262
[590]	263	negotiatingCaps bool
[108]	264	capVersion int
[275]	265	supportedCaps map[string]string
[236]	266	caps map[string]bool
[108]	267
[551]	268	lastBatchRef uint64
	269
[684]	270	monitored casemapMap
	271
[112]	272	saslServer sasl.Server
[13]	273	}
	274
[347]	275	func newDownstreamConn(srv Server, ic ircConn, id uint64) downstreamConn {
	276	remoteAddr := ic.RemoteAddr().String()
[323]	277	logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", remoteAddr)}
[398]	278	options := connOptions{Logger: logger}
[55]	279	dc := &downstreamConn{
[398]	280	conn: *newConn(srv, ic, &options),
[276]	281	id: id,
[275]	282	supportedCaps: make(map[string]string),
[276]	283	caps: make(map[string]bool),
[684]	284	monitored: newCasemapMap(0),
[22]	285	}
[323]	286	dc.hostname = remoteAddr
[141]	287	if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
	288	dc.hostname = host
	289	}
[275]	290	for k, v := range permanentDownstreamCaps {
	291	dc.supportedCaps[k] = v
	292	}
[691]	293	// TODO: this is racy, we should only enable chathistory after
	294	// authentication and then check that user.msgStore implements
	295	// chatHistoryMessageStore
	296	if srv.Config().LogPath != "" {
[319]	297	dc.supportedCaps["draft/chathistory"] = ""
	298	}
[55]	299	return dc
[22]	300	}
	301
[55]	302	func (dc downstreamConn) prefix() irc.Prefix {
[27]	303	return &irc.Prefix{
[55]	304	Name: dc.nick,
[184]	305	User: dc.user.Username,
[141]	306	Host: dc.hostname,
[27]	307	}
	308	}
	309
[692]	310	func (dc *downstreamConn) isMultiUpstream() bool {
	311	return dc.network == nil && !dc.caps["soju.im/bouncer-networks"]
	312	}
	313
[90]	314	func (dc downstreamConn) forEachNetwork(f func(network)) {
	315	if dc.network != nil {
	316	f(dc.network)
[692]	317	} else if dc.isMultiUpstream() {
[90]	318	dc.user.forEachNetwork(f)
	319	}
	320	}
	321
[73]	322	func (dc downstreamConn) forEachUpstream(f func(upstreamConn)) {
[692]	323	if dc.network == nil && !dc.isMultiUpstream() {
[532]	324	return
	325	}
[73]	326	dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]	327	if dc.network != nil && uc.network != dc.network {
[73]	328	return
	329	}
	330	f(uc)
	331	})
	332	}
	333
[89]	334	// upstream returns the upstream connection, if any. If there are zero or if
	335	// there are multiple upstream connections, it returns nil.
	336	func (dc downstreamConn) upstream() upstreamConn {
	337	if dc.network == nil {
	338	return nil
	339	}
[279]	340	return dc.network.conn
[89]	341	}
	342
[260]	343	func isOurNick(net *network, nick string) bool {
	344	// TODO: this doesn't account for nick changes
	345	if net.conn != nil {
[478]	346	return net.casemap(nick) == net.conn.nickCM
[260]	347	}
	348	// We're not currently connected to the upstream connection, so we don't
	349	// know whether this name is our nickname. Best-effort: use the network's
	350	// configured nickname and hope it was the one being used when we were
	351	// connected.
[664]	352	return net.casemap(nick) == net.casemap(GetNick(&net.user.User, &net.Network))
[260]	353	}
	354
[249]	355	// marshalEntity converts an upstream entity name (ie. channel or nick) into a
	356	// downstream entity name.
	357	//
	358	// This involves adding a "/<network>" suffix if the entity isn't the current
	359	// user.
[260]	360	func (dc downstreamConn) marshalEntity(net network, name string) string {
[289]	361	if isOurNick(net, name) {
	362	return dc.nick
	363	}
[478]	364	name = partialCasemap(net.casemap, name)
[257]	365	if dc.network != nil {
[260]	366	if dc.network != net {
[258]	367	panic("soju: tried to marshal an entity for another network")
	368	}
[257]	369	return name
[119]	370	}
[260]	371	return name + "/" + net.GetName()
[119]	372	}
	373
[260]	374	func (dc downstreamConn) marshalUserPrefix(net network, prefix irc.Prefix) irc.Prefix {
	375	if isOurNick(net, prefix.Name) {
[257]	376	return dc.prefix()
	377	}
[478]	378	prefix.Name = partialCasemap(net.casemap, prefix.Name)
[130]	379	if dc.network != nil {
[260]	380	if dc.network != net {
[258]	381	panic("soju: tried to marshal a user prefix for another network")
	382	}
[257]	383	return prefix
[119]	384	}
[257]	385	return &irc.Prefix{
[260]	386	Name: prefix.Name + "/" + net.GetName(),
[257]	387	User: prefix.User,
	388	Host: prefix.Host,
	389	}
[119]	390	}
	391
[584]	392	// unmarshalEntityNetwork converts a downstream entity name (ie. channel or
	393	// nick) into an upstream entity name.
[249]	394	//
	395	// This involves removing the "/<network>" suffix.
[584]	396	func (dc downstreamConn) unmarshalEntityNetwork(name string) (network, string, error) {
[464]	397	if dc.network != nil {
[584]	398	return dc.network, name, nil
[464]	399	}
[89]	400
[584]	401	var net *network
[119]	402	if i := strings.LastIndexByte(name, '/'); i >= 0 {
[127]	403	network := name[i+1:]
[119]	404	name = name[:i]
	405
[584]	406	for _, n := range dc.user.networks {
	407	if network == n.GetName() {
	408	net = n
	409	break
[119]	410	}
[584]	411	}
[119]	412	}
	413
[584]	414	if net == nil {
[73]	415	return nil, "", ircError{&irc.Message{
	416	Command: irc.ERR_NOSUCHCHANNEL,
[584]	417	Params: []string{name, "Missing network suffix in name"},
[73]	418	}}
[69]	419	}
[584]	420
	421	return net, name, nil
[69]	422	}
	423
[584]	424	// unmarshalEntity is the same as unmarshalEntityNetwork, but returns the
	425	// upstream connection and fails if the upstream is disconnected.
	426	func (dc downstreamConn) unmarshalEntity(name string) (upstreamConn, string, error) {
	427	net, name, err := dc.unmarshalEntityNetwork(name)
	428	if err != nil {
	429	return nil, "", err
	430	}
	431
	432	if net.conn == nil {
	433	return nil, "", ircError{&irc.Message{
	434	Command: irc.ERR_NOSUCHCHANNEL,
	435	Params: []string{name, "Disconnected from upstream network"},
	436	}}
	437	}
	438
	439	return net.conn, name, nil
	440	}
	441
[268]	442	func (dc downstreamConn) unmarshalText(uc upstreamConn, text string) string {
	443	if dc.upstream() != nil {
	444	return text
	445	}
	446	// TODO: smarter parsing that ignores URLs
	447	return strings.ReplaceAll(text, "/"+uc.network.GetName(), "")
	448	}
	449
[165]	450	func (dc *downstreamConn) readMessages(ch chan<- event) error {
[22]	451	for {
[210]	452	msg, err := dc.ReadMessage()
[655]	453	if errors.Is(err, io.EOF) {
[22]	454	break
	455	} else if err != nil {
	456	return fmt.Errorf("failed to read IRC command: %v", err)
	457	}
	458
[165]	459	ch <- eventDownstreamMessage{msg, dc}
[22]	460	}
	461
[45]	462	return nil
[22]	463	}
	464
[230]	465	// SendMessage sends an outgoing message.
	466	//
	467	// This can only called from the user goroutine.
[55]	468	func (dc downstreamConn) SendMessage(msg irc.Message) {
[230]	469	if !dc.caps["message-tags"] {
[303]	470	if msg.Command == "TAGMSG" {
	471	return
	472	}
[216]	473	msg = msg.Copy()
	474	for name := range msg.Tags {
	475	supported := false
	476	switch name {
	477	case "time":
[230]	478	supported = dc.caps["server-time"]
[559]	479	case "account":
	480	supported = dc.caps["account"]
[216]	481	}
	482	if !supported {
	483	delete(msg.Tags, name)
	484	}
	485	}
	486	}
[551]	487	if !dc.caps["batch"] && msg.Tags["batch"] != "" {
	488	msg = msg.Copy()
	489	delete(msg.Tags, "batch")
	490	}
[419]	491	if msg.Command == "JOIN" && !dc.caps["extended-join"] {
	492	msg.Params = msg.Params[:1]
	493	}
[540]	494	if msg.Command == "SETNAME" && !dc.caps["setname"] {
	495	return
	496	}
[649]	497	if msg.Command == "AWAY" && !dc.caps["away-notify"] {
	498	return
	499	}
[648]	500	if msg.Command == "ACCOUNT" && !dc.caps["account-notify"] {
	501	return
	502	}
[216]	503
[210]	504	dc.conn.SendMessage(msg)
[54]	505	}
	506
[551]	507	func (dc *downstreamConn) SendBatch(typ string, params []string, tags irc.Tags, f func(batchRef irc.TagValue)) {
	508	dc.lastBatchRef++
	509	ref := fmt.Sprintf("%v", dc.lastBatchRef)
	510
	511	if dc.caps["batch"] {
	512	dc.SendMessage(&irc.Message{
	513	Tags: tags,
	514	Prefix: dc.srv.prefix(),
	515	Command: "BATCH",
	516	Params: append([]string{"+" + ref, typ}, params...),
	517	})
	518	}
	519
	520	f(irc.TagValue(ref))
	521
	522	if dc.caps["batch"] {
	523	dc.SendMessage(&irc.Message{
	524	Prefix: dc.srv.prefix(),
	525	Command: "BATCH",
	526	Params: []string{"-" + ref},
	527	})
	528	}
	529	}
	530
[428]	531	// sendMessageWithID sends an outgoing message with the specified internal ID.
	532	func (dc downstreamConn) sendMessageWithID(msg irc.Message, id string) {
	533	dc.SendMessage(msg)
	534
[665]	535	if id == "" \|\| !dc.messageSupportsBacklog(msg) {
[428]	536	return
	537	}
	538
	539	dc.sendPing(id)
	540	}
	541
	542	// advanceMessageWithID advances history to the specified message ID without
	543	// sending a message. This is useful e.g. for self-messages when echo-message
	544	// isn't enabled.
	545	func (dc downstreamConn) advanceMessageWithID(msg irc.Message, id string) {
[665]	546	if id == "" \|\| !dc.messageSupportsBacklog(msg) {
[428]	547	return
	548	}
	549
	550	dc.sendPing(id)
	551	}
	552
	553	// ackMsgID acknowledges that a message has been received.
	554	func (dc *downstreamConn) ackMsgID(id string) {
[488]	555	netID, entity, err := parseMsgID(id, nil)
[428]	556	if err != nil {
	557	dc.logger.Printf("failed to ACK message ID %q: %v", id, err)
	558	return
	559	}
	560
[440]	561	network := dc.user.getNetworkByID(netID)
[428]	562	if network == nil {
	563	return
	564	}
	565
[485]	566	network.delivered.StoreID(entity, dc.clientName, id)
[428]	567	}
	568
	569	func (dc *downstreamConn) sendPing(msgID string) {
[488]	570	token := "soju-msgid-" + msgID
[428]	571	dc.SendMessage(&irc.Message{
	572	Command: "PING",
	573	Params: []string{token},
	574	})
	575	}
	576
	577	func (dc *downstreamConn) handlePong(token string) {
	578	if !strings.HasPrefix(token, "soju-msgid-") {
	579	dc.logger.Printf("received unrecognized PONG token %q", token)
	580	return
	581	}
[488]	582	msgID := strings.TrimPrefix(token, "soju-msgid-")
[428]	583	dc.ackMsgID(msgID)
	584	}
	585
[245]	586	// marshalMessage re-formats a message coming from an upstream connection so
	587	// that it's suitable for being sent on this downstream connection. Only
[665]	588	// messages that may appear in logs are supported, except MODE messages which
	589	// may only appear in single-upstream mode.
[261]	590	func (dc downstreamConn) marshalMessage(msg irc.Message, net network) irc.Message {
[686]	591	msg = msg.Copy()
	592	msg.Prefix = dc.marshalUserPrefix(net, msg.Prefix)
	593
[665]	594	if dc.network != nil {
	595	return msg
	596	}
	597
[227]	598	switch msg.Command {
[303]	599	case "PRIVMSG", "NOTICE", "TAGMSG":
[261]	600	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	601	case "NICK":
	602	// Nick change for another user
[261]	603	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	604	case "JOIN", "PART":
[261]	605	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	606	case "KICK":
[261]	607	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
	608	msg.Params[1] = dc.marshalEntity(net, msg.Params[1])
[245]	609	case "TOPIC":
[261]	610	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[540]	611	case "QUIT", "SETNAME":
[262]	612	// This space is intentionally left blank
[227]	613	default:
	614	panic(fmt.Sprintf("unexpected %q message", msg.Command))
	615	}
	616
[245]	617	return msg
[227]	618	}
	619
[55]	620	func (dc downstreamConn) handleMessage(msg irc.Message) error {
[13]	621	switch msg.Command {
[28]	622	case "QUIT":
[55]	623	return dc.Close()
[13]	624	default:
[55]	625	if dc.registered {
	626	return dc.handleMessageRegistered(msg)
[13]	627	} else {
[55]	628	return dc.handleMessageUnregistered(msg)
[13]	629	}
	630	}
	631	}
	632
[55]	633	func (dc downstreamConn) handleMessageUnregistered(msg irc.Message) error {
[13]	634	switch msg.Command {
	635	case "NICK":
[117]	636	var nick string
	637	if err := parseMessageParams(msg, &nick); err != nil {
[43]	638	return err
[13]	639	}
[404]	640	if strings.ContainsAny(nick, illegalNickChars) {
	641	return ircError{&irc.Message{
	642	Command: irc.ERR_ERRONEUSNICKNAME,
	643	Params: []string{dc.nick, nick, "contains illegal characters"},
	644	}}
	645	}
[478]	646	nickCM := casemapASCII(nick)
	647	if nickCM == serviceNickCM {
[117]	648	return ircError{&irc.Message{
	649	Command: irc.ERR_NICKNAMEINUSE,
	650	Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
	651	}}
	652	}
	653	dc.nick = nick
[478]	654	dc.nickCM = nickCM
[13]	655	case "USER":
[117]	656	if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]	657	return err
[13]	658	}
[85]	659	case "PASS":
	660	if err := parseMessageParams(msg, &dc.password); err != nil {
	661	return err
	662	}
[108]	663	case "CAP":
	664	var subCmd string
	665	if err := parseMessageParams(msg, &subCmd); err != nil {
	666	return err
	667	}
	668	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	669	return err
	670	}
[112]	671	case "AUTHENTICATE":
[230]	672	if !dc.caps["sasl"] {
[112]	673	return ircError{&irc.Message{
[125]	674	Command: irc.ERR_SASLFAIL,
[112]	675	Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
	676	}}
	677	}
	678	if len(msg.Params) == 0 {
	679	return ircError{&irc.Message{
[125]	680	Command: irc.ERR_SASLFAIL,
[112]	681	Params: []string{"*", "Missing AUTHENTICATE argument"},
	682	}}
	683	}
	684	if dc.nick == "" {
	685	return ircError{&irc.Message{
[125]	686	Command: irc.ERR_SASLFAIL,
[112]	687	Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
	688	}}
	689	}
	690
	691	var resp []byte
[653]	692	if msg.Params[0] == "*" {
	693	dc.saslServer = nil
	694	return ircError{&irc.Message{
	695	Command: irc.ERR_SASLABORTED,
	696	Params: []string{"*", "SASL authentication aborted"},
	697	}}
	698	} else if dc.saslServer == nil {
[112]	699	mech := strings.ToUpper(msg.Params[0])
	700	switch mech {
	701	case "PLAIN":
	702	dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
	703	return dc.authenticate(username, password)
	704	}))
	705	default:
	706	return ircError{&irc.Message{
[125]	707	Command: irc.ERR_SASLFAIL,
[112]	708	Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
	709	}}
	710	}
	711	} else if msg.Params[0] == "+" {
	712	resp = nil
	713	} else {
	714	// TODO: multi-line messages
	715	var err error
	716	resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
	717	if err != nil {
	718	dc.saslServer = nil
	719	return ircError{&irc.Message{
[125]	720	Command: irc.ERR_SASLFAIL,
[112]	721	Params: []string{"*", "Invalid base64-encoded response"},
	722	}}
	723	}
	724	}
	725
	726	challenge, done, err := dc.saslServer.Next(resp)
	727	if err != nil {
	728	dc.saslServer = nil
	729	if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
	730	return ircError{&irc.Message{
[125]	731	Command: irc.ERR_SASLFAIL,
[112]	732	Params: []string{"*", ircErr.Message.Params[1]},
	733	}}
	734	}
	735	dc.SendMessage(&irc.Message{
	736	Prefix: dc.srv.prefix(),
[125]	737	Command: irc.ERR_SASLFAIL,
[112]	738	Params: []string{"*", "SASL error"},
	739	})
	740	return fmt.Errorf("SASL authentication failed: %v", err)
	741	} else if done {
	742	dc.saslServer = nil
	743	dc.SendMessage(&irc.Message{
	744	Prefix: dc.srv.prefix(),
[125]	745	Command: irc.RPL_LOGGEDIN,
[306]	746	Params: []string{dc.nick, dc.prefix().String(), dc.user.Username, "You are now logged in"},
[112]	747	})
	748	dc.SendMessage(&irc.Message{
	749	Prefix: dc.srv.prefix(),
[125]	750	Command: irc.RPL_SASLSUCCESS,
[112]	751	Params: []string{dc.nick, "SASL authentication successful"},
	752	})
	753	} else {
	754	challengeStr := "+"
[135]	755	if len(challenge) > 0 {
[112]	756	challengeStr = base64.StdEncoding.EncodeToString(challenge)
	757	}
	758
	759	// TODO: multi-line messages
	760	dc.SendMessage(&irc.Message{
	761	Prefix: dc.srv.prefix(),
	762	Command: "AUTHENTICATE",
	763	Params: []string{challengeStr},
	764	})
	765	}
[532]	766	case "BOUNCER":
	767	var subcommand string
	768	if err := parseMessageParams(msg, &subcommand); err != nil {
	769	return err
	770	}
	771
	772	switch strings.ToUpper(subcommand) {
	773	case "BIND":
	774	var idStr string
	775	if err := parseMessageParams(msg, nil, &idStr); err != nil {
	776	return err
	777	}
	778
	779	if dc.user == nil {
	780	return ircError{&irc.Message{
	781	Command: "FAIL",
	782	Params: []string{"BOUNCER", "ACCOUNT_REQUIRED", "BIND", "Authentication needed to bind to bouncer network"},
	783	}}
	784	}
	785
[535]	786	id, err := parseBouncerNetID(subcommand, idStr)
[532]	787	if err != nil {
	788	return err
	789	}
	790
	791	var match *network
	792	dc.user.forEachNetwork(func(net *network) {
	793	if net.ID == id {
	794	match = net
	795	}
	796	})
	797	if match == nil {
	798	return ircError{&irc.Message{
	799	Command: "FAIL",
	800	Params: []string{"BOUNCER", "INVALID_NETID", idStr, "Unknown network ID"},
	801	}}
	802	}
	803
	804	dc.networkName = match.GetName()
	805	}
[13]	806	default:
[55]	807	dc.logger.Printf("unhandled message: %v", msg)
[13]	808	return newUnknownCommandError(msg.Command)
	809	}
[590]	810	if dc.rawUsername != "" && dc.nick != "" && !dc.negotiatingCaps {
[55]	811	return dc.register()
[13]	812	}
	813	return nil
	814	}
	815
[108]	816	func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]	817	cmd = strings.ToUpper(cmd)
	818
[108]	819	replyTo := dc.nick
	820	if !dc.registered {
	821	replyTo = "*"
	822	}
	823
	824	switch cmd {
	825	case "LS":
	826	if len(args) > 0 {
	827	var err error
	828	if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
	829	return err
	830	}
	831	}
[437]	832	if !dc.registered && dc.capVersion >= 302 {
	833	// Let downstream show everything it supports, and trim
	834	// down the available capabilities when upstreams are
	835	// known.
	836	for k, v := range needAllDownstreamCaps {
	837	dc.supportedCaps[k] = v
	838	}
	839	}
[108]	840
[275]	841	caps := make([]string, 0, len(dc.supportedCaps))
	842	for k, v := range dc.supportedCaps {
	843	if dc.capVersion >= 302 && v != "" {
[276]	844	caps = append(caps, k+"="+v)
[275]	845	} else {
	846	caps = append(caps, k)
	847	}
[112]	848	}
[108]	849
	850	// TODO: multi-line replies
	851	dc.SendMessage(&irc.Message{
	852	Prefix: dc.srv.prefix(),
	853	Command: "CAP",
	854	Params: []string{replyTo, "LS", strings.Join(caps, " ")},
	855	})
	856
[275]	857	if dc.capVersion >= 302 {
	858	// CAP version 302 implicitly enables cap-notify
	859	dc.caps["cap-notify"] = true
	860	}
	861
[108]	862	if !dc.registered {
[590]	863	dc.negotiatingCaps = true
[108]	864	}
	865	case "LIST":
	866	var caps []string
[521]	867	for name, enabled := range dc.caps {
	868	if enabled {
	869	caps = append(caps, name)
	870	}
[108]	871	}
	872
	873	// TODO: multi-line replies
	874	dc.SendMessage(&irc.Message{
	875	Prefix: dc.srv.prefix(),
	876	Command: "CAP",
	877	Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
	878	})
	879	case "REQ":
	880	if len(args) == 0 {
	881	return ircError{&irc.Message{
	882	Command: err_invalidcapcmd,
	883	Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
	884	}}
	885	}
	886
[275]	887	// TODO: atomically ack/nak the whole capability set
[108]	888	caps := strings.Fields(args[0])
	889	ack := true
	890	for _, name := range caps {
	891	name = strings.ToLower(name)
	892	enable := !strings.HasPrefix(name, "-")
	893	if !enable {
	894	name = strings.TrimPrefix(name, "-")
	895	}
	896
[275]	897	if enable == dc.caps[name] {
[108]	898	continue
	899	}
	900
[275]	901	_, ok := dc.supportedCaps[name]
	902	if !ok {
[108]	903	ack = false
[275]	904	break
[108]	905	}
[275]	906
	907	if name == "cap-notify" && dc.capVersion >= 302 && !enable {
	908	// cap-notify cannot be disabled with CAP version 302
	909	ack = false
	910	break
	911	}
	912
	913	dc.caps[name] = enable
[108]	914	}
	915
	916	reply := "NAK"
	917	if ack {
	918	reply = "ACK"
	919	}
	920	dc.SendMessage(&irc.Message{
	921	Prefix: dc.srv.prefix(),
	922	Command: "CAP",
	923	Params: []string{replyTo, reply, args[0]},
	924	})
[590]	925
	926	if !dc.registered {
	927	dc.negotiatingCaps = true
	928	}
[108]	929	case "END":
[590]	930	dc.negotiatingCaps = false
[108]	931	default:
	932	return ircError{&irc.Message{
	933	Command: err_invalidcapcmd,
	934	Params: []string{replyTo, cmd, "Unknown CAP command"},
	935	}}
	936	}
	937	return nil
	938	}
	939
[275]	940	func (dc *downstreamConn) setSupportedCap(name, value string) {
	941	prevValue, hasPrev := dc.supportedCaps[name]
	942	changed := !hasPrev \|\| prevValue != value
	943	dc.supportedCaps[name] = value
	944
	945	if !dc.caps["cap-notify"] \|\| !changed {
	946	return
	947	}
	948
	949	replyTo := dc.nick
	950	if !dc.registered {
	951	replyTo = "*"
	952	}
	953
	954	cap := name
	955	if value != "" && dc.capVersion >= 302 {
	956	cap = name + "=" + value
	957	}
	958
	959	dc.SendMessage(&irc.Message{
	960	Prefix: dc.srv.prefix(),
	961	Command: "CAP",
	962	Params: []string{replyTo, "NEW", cap},
	963	})
	964	}
	965
	966	func (dc *downstreamConn) unsetSupportedCap(name string) {
	967	_, hasPrev := dc.supportedCaps[name]
	968	delete(dc.supportedCaps, name)
	969	delete(dc.caps, name)
	970
	971	if !dc.caps["cap-notify"] \|\| !hasPrev {
	972	return
	973	}
	974
	975	replyTo := dc.nick
	976	if !dc.registered {
	977	replyTo = "*"
	978	}
	979
	980	dc.SendMessage(&irc.Message{
	981	Prefix: dc.srv.prefix(),
	982	Command: "CAP",
	983	Params: []string{replyTo, "DEL", name},
	984	})
	985	}
	986
[276]	987	func (dc *downstreamConn) updateSupportedCaps() {
[292]	988	supportedCaps := make(map[string]bool)
	989	for cap := range needAllDownstreamCaps {
	990	supportedCaps[cap] = true
	991	}
[276]	992	dc.forEachUpstream(func(uc *upstreamConn) {
[292]	993	for cap, supported := range supportedCaps {
	994	supportedCaps[cap] = supported && uc.caps[cap]
	995	}
[276]	996	})
	997
[292]	998	for cap, supported := range supportedCaps {
	999	if supported {
	1000	dc.setSupportedCap(cap, needAllDownstreamCaps[cap])
	1001	} else {
	1002	dc.unsetSupportedCap(cap)
	1003	}
[276]	1004	}
[665]	1005
[691]	1006	if _, ok := dc.user.msgStore.(chatHistoryMessageStore); ok && dc.network != nil {
[665]	1007	dc.setSupportedCap("draft/event-playback", "")
	1008	} else {
	1009	dc.unsetSupportedCap("draft/event-playback")
	1010	}
[276]	1011	}
	1012
[296]	1013	func (dc *downstreamConn) updateNick() {
	1014	if uc := dc.upstream(); uc != nil && uc.nick != dc.nick {
	1015	dc.SendMessage(&irc.Message{
	1016	Prefix: dc.prefix(),
	1017	Command: "NICK",
	1018	Params: []string{uc.nick},
	1019	})
	1020	dc.nick = uc.nick
[478]	1021	dc.nickCM = casemapASCII(dc.nick)
[296]	1022	}
	1023	}
	1024
[540]	1025	func (dc *downstreamConn) updateRealname() {
	1026	if uc := dc.upstream(); uc != nil && uc.realname != dc.realname && dc.caps["setname"] {
	1027	dc.SendMessage(&irc.Message{
	1028	Prefix: dc.prefix(),
	1029	Command: "SETNAME",
	1030	Params: []string{uc.realname},
	1031	})
	1032	dc.realname = uc.realname
	1033	}
	1034	}
	1035
[91]	1036	func sanityCheckServer(addr string) error {
	1037	dialer := net.Dialer{Timeout: 30 * time.Second}
	1038	conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
	1039	if err != nil {
	1040	return err
	1041	}
	1042	return conn.Close()
	1043	}
	1044
[183]	1045	func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]	1046	username = rawUsername
[183]	1047
	1048	i := strings.IndexAny(username, "/@")
	1049	j := strings.LastIndexAny(username, "/@")
	1050	if i >= 0 {
	1051	username = rawUsername[:i]
[73]	1052	}
[183]	1053	if j >= 0 {
[190]	1054	if rawUsername[j] == '@' {
	1055	client = rawUsername[j+1:]
	1056	} else {
	1057	network = rawUsername[j+1:]
	1058	}
[73]	1059	}
[183]	1060	if i >= 0 && j >= 0 && i < j {
[190]	1061	if rawUsername[i] == '@' {
	1062	client = rawUsername[i+1 : j]
	1063	} else {
	1064	network = rawUsername[i+1 : j]
	1065	}
[183]	1066	}
	1067
	1068	return username, client, network
[112]	1069	}
[73]	1070
[168]	1071	func (dc *downstreamConn) authenticate(username, password string) error {
[183]	1072	username, clientName, networkName := unmarshalUsername(username)
[168]	1073
[652]	1074	u, err := dc.srv.db.GetUser(context.TODO(), username)
[173]	1075	if err != nil {
[438]	1076	dc.logger.Printf("failed authentication for %q: user not found: %v", username, err)
[168]	1077	return errAuthFailed
	1078	}
	1079
[322]	1080	// Password auth disabled
	1081	if u.Password == "" {
	1082	return errAuthFailed
	1083	}
	1084
[173]	1085	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]	1086	if err != nil {
[438]	1087	dc.logger.Printf("failed authentication for %q: wrong password: %v", username, err)
[168]	1088	return errAuthFailed
	1089	}
	1090
[173]	1091	dc.user = dc.srv.getUser(username)
	1092	if dc.user == nil {
	1093	dc.logger.Printf("failed authentication for %q: user not active", username)
	1094	return errAuthFailed
	1095	}
[183]	1096	dc.clientName = clientName
[168]	1097	dc.networkName = networkName
	1098	return nil
	1099	}
	1100
	1101	func (dc *downstreamConn) register() error {
	1102	if dc.registered {
	1103	return fmt.Errorf("tried to register twice")
	1104	}
	1105
	1106	password := dc.password
	1107	dc.password = ""
	1108	if dc.user == nil {
	1109	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	1110	return err
	1111	}
	1112	}
	1113
[183]	1114	if dc.clientName == "" && dc.networkName == "" {
	1115	_, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]	1116	}
	1117
	1118	dc.registered = true
[184]	1119	dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]	1120	return nil
	1121	}
	1122
	1123	func (dc *downstreamConn) loadNetwork() error {
	1124	if dc.networkName == "" {
[112]	1125	return nil
	1126	}
[85]	1127
[168]	1128	network := dc.user.getNetwork(dc.networkName)
[112]	1129	if network == nil {
[168]	1130	addr := dc.networkName
[112]	1131	if !strings.ContainsRune(addr, ':') {
	1132	addr = addr + ":6697"
	1133	}
	1134
	1135	dc.logger.Printf("trying to connect to new network %q", addr)
	1136	if err := sanityCheckServer(addr); err != nil {
	1137	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	1138	return ircError{&irc.Message{
	1139	Command: irc.ERR_PASSWDMISMATCH,
[168]	1140	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]	1141	}}
	1142	}
	1143
[354]	1144	// Some clients only allow specifying the nickname (and use the
	1145	// nickname as a username too). Strip the network name from the
	1146	// nickname when auto-saving networks.
	1147	nick, _, _ := unmarshalUsername(dc.nick)
	1148
[168]	1149	dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]	1150	var err error
[676]	1151	network, err = dc.user.createNetwork(context.TODO(), &Network{
[542]	1152	Addr: dc.networkName,
	1153	Nick: nick,
	1154	Enabled: true,
[120]	1155	})
[112]	1156	if err != nil {
	1157	return err
	1158	}
	1159	}
	1160
	1161	dc.network = network
	1162	return nil
	1163	}
	1164
[168]	1165	func (dc *downstreamConn) welcome() error {
	1166	if dc.user == nil \|\| !dc.registered {
	1167	panic("tried to welcome an unregistered connection")
[37]	1168	}
	1169
[168]	1170	// TODO: doing this might take some time. We should do it in dc.register
	1171	// instead, but we'll potentially be adding a new network and this must be
	1172	// done in the user goroutine.
	1173	if err := dc.loadNetwork(); err != nil {
	1174	return err
[85]	1175	}
	1176
[446]	1177	isupport := []string{
[670]	1178	fmt.Sprintf("CHATHISTORY=%v", chatHistoryLimit),
[478]	1179	"CASEMAPPING=ascii",
[446]	1180	}
	1181
[532]	1182	if dc.network != nil {
	1183	isupport = append(isupport, fmt.Sprintf("BOUNCER_NETID=%v", dc.network.ID))
	1184	}
[691]	1185	if title := dc.srv.Config().Title; dc.network == nil && title != "" {
	1186	isupport = append(isupport, "NETWORK="+encodeISUPPORT(title))
[662]	1187	}
[692]	1188	if dc.network == nil && !dc.isMultiUpstream() {
[660]	1189	isupport = append(isupport, "WHOX")
	1190	}
	1191
[463]	1192	if uc := dc.upstream(); uc != nil {
	1193	for k := range passthroughIsupport {
	1194	v, ok := uc.isupport[k]
	1195	if !ok {
	1196	continue
	1197	}
	1198	if v != nil {
	1199	isupport = append(isupport, fmt.Sprintf("%v=%v", k, *v))
	1200	} else {
	1201	isupport = append(isupport, k)
	1202	}
	1203	}
[447]	1204	}
	1205
[55]	1206	dc.SendMessage(&irc.Message{
	1207	Prefix: dc.srv.prefix(),
[13]	1208	Command: irc.RPL_WELCOME,
[98]	1209	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	1210	})
[55]	1211	dc.SendMessage(&irc.Message{
	1212	Prefix: dc.srv.prefix(),
[13]	1213	Command: irc.RPL_YOURHOST,
[691]	1214	Params: []string{dc.nick, "Your host is " + dc.srv.Config().Hostname},
[54]	1215	})
[55]	1216	dc.SendMessage(&irc.Message{
	1217	Prefix: dc.srv.prefix(),
[13]	1218	Command: irc.RPL_MYINFO,
[691]	1219	Params: []string{dc.nick, dc.srv.Config().Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	1220	})
[463]	1221	for _, msg := range generateIsupport(dc.srv.prefix(), dc.nick, isupport) {
	1222	dc.SendMessage(msg)
	1223	}
[553]	1224	if uc := dc.upstream(); uc != nil {
	1225	dc.SendMessage(&irc.Message{
	1226	Prefix: dc.srv.prefix(),
	1227	Command: irc.RPL_UMODEIS,
[672]	1228	Params: []string{dc.nick, "+" + string(uc.modes)},
[553]	1229	})
	1230	}
[692]	1231	if dc.network == nil && !dc.isMultiUpstream() && dc.user.Admin {
[671]	1232	dc.SendMessage(&irc.Message{
	1233	Prefix: dc.srv.prefix(),
	1234	Command: irc.RPL_UMODEIS,
	1235	Params: []string{dc.nick, "+o"},
	1236	})
	1237	}
[13]	1238
[691]	1239	if motd := dc.user.srv.Config().MOTD; motd != "" && dc.network == nil {
[636]	1240	for _, msg := range generateMOTD(dc.srv.prefix(), dc.nick, motd) {
	1241	dc.SendMessage(msg)
	1242	}
	1243	} else {
	1244	motdHint := "No MOTD"
	1245	if dc.network != nil {
	1246	motdHint = "Use /motd to read the message of the day"
	1247	}
	1248	dc.SendMessage(&irc.Message{
	1249	Prefix: dc.srv.prefix(),
	1250	Command: irc.ERR_NOMOTD,
	1251	Params: []string{dc.nick, motdHint},
	1252	})
	1253	}
	1254
[296]	1255	dc.updateNick()
[540]	1256	dc.updateRealname()
[437]	1257	dc.updateSupportedCaps()
[296]	1258
[535]	1259	if dc.caps["soju.im/bouncer-networks-notify"] {
[551]	1260	dc.SendBatch("soju.im/bouncer-networks", nil, nil, func(batchRef irc.TagValue) {
	1261	dc.user.forEachNetwork(func(network *network) {
	1262	idStr := fmt.Sprintf("%v", network.ID)
	1263	attrs := getNetworkAttrs(network)
	1264	dc.SendMessage(&irc.Message{
	1265	Tags: irc.Tags{"batch": batchRef},
	1266	Prefix: dc.srv.prefix(),
	1267	Command: "BOUNCER",
	1268	Params: []string{"NETWORK", idStr, attrs.String()},
	1269	})
[535]	1270	})
	1271	})
	1272	}
	1273
[73]	1274	dc.forEachUpstream(func(uc *upstreamConn) {
[478]	1275	for _, entry := range uc.channels.innerMap {
	1276	ch := entry.value.(*upstreamChannel)
[284]	1277	if !ch.complete {
	1278	continue
	1279	}
[478]	1280	record := uc.network.channels.Value(ch.Name)
	1281	if record != nil && record.Detached {
[284]	1282	continue
	1283	}
[132]	1284
[284]	1285	dc.SendMessage(&irc.Message{
	1286	Prefix: dc.prefix(),
	1287	Command: "JOIN",
	1288	Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
	1289	})
	1290
	1291	forwardChannel(dc, ch)
[30]	1292	}
[143]	1293	})
[50]	1294
[143]	1295	dc.forEachNetwork(func(net *network) {
[496]	1296	if dc.caps["draft/chathistory"] \|\| dc.user.msgStore == nil {
	1297	return
	1298	}
	1299
[253]	1300	// Only send history if we're the first connected client with that name
	1301	// for the network
[482]	1302	firstClient := true
	1303	dc.user.forEachDownstream(func(c *downstreamConn) {
	1304	if c != dc && c.clientName == dc.clientName && c.network == dc.network {
	1305	firstClient = false
	1306	}
	1307	})
	1308	if firstClient {
[485]	1309	net.delivered.ForEachTarget(func(target string) {
[495]	1310	lastDelivered := net.delivered.LoadID(target, dc.clientName)
	1311	if lastDelivered == "" {
	1312	return
	1313	}
	1314
	1315	dc.sendTargetBacklog(net, target, lastDelivered)
	1316
	1317	// Fast-forward history to last message
	1318	targetCM := net.casemap(target)
[666]	1319	lastID, err := dc.user.msgStore.LastMsgID(&net.Network, targetCM, time.Now())
[495]	1320	if err != nil {
	1321	dc.logger.Printf("failed to get last message ID: %v", err)
	1322	return
	1323	}
	1324	net.delivered.StoreID(target, dc.clientName, lastID)
[485]	1325	})
[227]	1326	}
[253]	1327	})
[57]	1328
[253]	1329	return nil
	1330	}
[144]	1331
[665]	1332	// messageSupportsBacklog checks whether the provided message can be sent as
[428]	1333	// part of an history batch.
[665]	1334	func (dc downstreamConn) messageSupportsBacklog(msg irc.Message) bool {
[428]	1335	// Don't replay all messages, because that would mess up client
	1336	// state. For instance we just sent the list of users, sending
	1337	// PART messages for one of these users would be incorrect.
	1338	switch msg.Command {
	1339	case "PRIVMSG", "NOTICE":
	1340	return true
	1341	}
	1342	return false
	1343	}
	1344
[495]	1345	func (dc downstreamConn) sendTargetBacklog(net network, target, msgID string) {
[423]	1346	if dc.caps["draft/chathistory"] \|\| dc.user.msgStore == nil {
[319]	1347	return
	1348	}
[485]	1349
[499]	1350	ch := net.channels.Value(target)
	1351
[675]	1352	ctx, cancel := context.WithTimeout(context.TODO(), backlogTimeout)
[667]	1353	defer cancel()
	1354
[484]	1355	targetCM := net.casemap(target)
[670]	1356	history, err := dc.user.msgStore.LoadLatestID(ctx, &net.Network, targetCM, msgID, backlogLimit)
[452]	1357	if err != nil {
[495]	1358	dc.logger.Printf("failed to send backlog for %q: %v", target, err)
[452]	1359	return
	1360	}
[253]	1361
[551]	1362	dc.SendBatch("chathistory", []string{dc.marshalEntity(net, target)}, nil, func(batchRef irc.TagValue) {
	1363	for _, msg := range history {
	1364	if ch != nil && ch.Detached {
	1365	if net.detachedMessageNeedsRelay(ch, msg) {
	1366	dc.relayDetachedMessage(net, msg)
	1367	}
	1368	} else {
[651]	1369	msg.Tags["batch"] = batchRef
[551]	1370	dc.SendMessage(dc.marshalMessage(msg, net))
[499]	1371	}
[256]	1372	}
[551]	1373	})
[13]	1374	}
	1375
[499]	1376	func (dc downstreamConn) relayDetachedMessage(net network, msg *irc.Message) {
	1377	if msg.Command != "PRIVMSG" && msg.Command != "NOTICE" {
	1378	return
	1379	}
	1380
	1381	sender := msg.Prefix.Name
	1382	target, text := msg.Params[0], msg.Params[1]
	1383	if net.isHighlight(msg) {
	1384	sendServiceNOTICE(dc, fmt.Sprintf("highlight in %v: <%v> %v", dc.marshalEntity(net, target), sender, text))
	1385	} else {
	1386	sendServiceNOTICE(dc, fmt.Sprintf("message in %v: <%v> %v", dc.marshalEntity(net, target), sender, text))
	1387	}
	1388	}
	1389
[103]	1390	func (dc *downstreamConn) runUntilRegistered() error {
	1391	for !dc.registered {
[212]	1392	msg, err := dc.ReadMessage()
[106]	1393	if err != nil {
[655]	1394	return fmt.Errorf("failed to read IRC command: %w", err)
[103]	1395	}
	1396
	1397	err = dc.handleMessage(msg)
	1398	if ircErr, ok := err.(ircError); ok {
	1399	ircErr.Message.Prefix = dc.srv.prefix()
	1400	dc.SendMessage(ircErr.Message)
	1401	} else if err != nil {
	1402	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	1403	}
	1404	}
	1405
	1406	return nil
	1407	}
	1408
[55]	1409	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[675]	1410	ctx, cancel := context.WithTimeout(context.TODO(), handleDownstreamMessageTimeout)
	1411	defer cancel()
	1412
[13]	1413	switch msg.Command {
[111]	1414	case "CAP":
	1415	var subCmd string
	1416	if err := parseMessageParams(msg, &subCmd); err != nil {
	1417	return err
	1418	}
	1419	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	1420	return err
	1421	}
[107]	1422	case "PING":
[412]	1423	var source, destination string
	1424	if err := parseMessageParams(msg, &source); err != nil {
	1425	return err
	1426	}
	1427	if len(msg.Params) > 1 {
	1428	destination = msg.Params[1]
	1429	}
[691]	1430	hostname := dc.srv.Config().Hostname
	1431	if destination != "" && destination != hostname {
[412]	1432	return ircError{&irc.Message{
	1433	Command: irc.ERR_NOSUCHSERVER,
[413]	1434	Params: []string{dc.nick, destination, "No such server"},
[412]	1435	}}
	1436	}
[107]	1437	dc.SendMessage(&irc.Message{
	1438	Prefix: dc.srv.prefix(),
	1439	Command: "PONG",
[691]	1440	Params: []string{hostname, source},
[107]	1441	})
	1442	return nil
[428]	1443	case "PONG":
	1444	if len(msg.Params) == 0 {
	1445	return newNeedMoreParamsError(msg.Command)
	1446	}
	1447	token := msg.Params[len(msg.Params)-1]
	1448	dc.handlePong(token)
[42]	1449	case "USER":
[13]	1450	return ircError{&irc.Message{
	1451	Command: irc.ERR_ALREADYREGISTERED,
[55]	1452	Params: []string{dc.nick, "You may not reregister"},
[13]	1453	}}
[42]	1454	case "NICK":
[429]	1455	var rawNick string
	1456	if err := parseMessageParams(msg, &rawNick); err != nil {
[90]	1457	return err
	1458	}
	1459
[429]	1460	nick := rawNick
[297]	1461	var upstream *upstreamConn
	1462	if dc.upstream() == nil {
	1463	uc, unmarshaledNick, err := dc.unmarshalEntity(nick)
	1464	if err == nil { // NICK nick/network: NICK only on a specific upstream
	1465	upstream = uc
	1466	nick = unmarshaledNick
	1467	}
	1468	}
	1469
[404]	1470	if strings.ContainsAny(nick, illegalNickChars) {
	1471	return ircError{&irc.Message{
	1472	Command: irc.ERR_ERRONEUSNICKNAME,
[430]	1473	Params: []string{dc.nick, rawNick, "contains illegal characters"},
[404]	1474	}}
	1475	}
[478]	1476	if casemapASCII(nick) == serviceNickCM {
[429]	1477	return ircError{&irc.Message{
	1478	Command: irc.ERR_NICKNAMEINUSE,
	1479	Params: []string{dc.nick, rawNick, "Nickname reserved for bouncer service"},
	1480	}}
	1481	}
[404]	1482
[90]	1483	var err error
	1484	dc.forEachNetwork(func(n *network) {
[297]	1485	if err != nil \|\| (upstream != nil && upstream.network != n) {
[90]	1486	return
	1487	}
	1488	n.Nick = nick
[675]	1489	err = dc.srv.db.StoreNetwork(ctx, dc.user.ID, &n.Network)
[90]	1490	})
	1491	if err != nil {
	1492	return err
	1493	}
	1494
[73]	1495	dc.forEachUpstream(func(uc *upstreamConn) {
[297]	1496	if upstream != nil && upstream != uc {
	1497	return
	1498	}
[301]	1499	uc.SendMessageLabeled(dc.id, &irc.Message{
[297]	1500	Command: "NICK",
	1501	Params: []string{nick},
	1502	})
[42]	1503	})
[296]	1504
[512]	1505	if dc.upstream() == nil && upstream == nil && dc.nick != nick {
[296]	1506	dc.SendMessage(&irc.Message{
	1507	Prefix: dc.prefix(),
	1508	Command: "NICK",
	1509	Params: []string{nick},
	1510	})
	1511	dc.nick = nick
[478]	1512	dc.nickCM = casemapASCII(dc.nick)
[296]	1513	}
[540]	1514	case "SETNAME":
	1515	var realname string
	1516	if err := parseMessageParams(msg, &realname); err != nil {
	1517	return err
	1518	}
	1519
[568]	1520	// If the client just resets to the default, just wipe the per-network
	1521	// preference
	1522	storeRealname := realname
	1523	if realname == dc.user.Realname {
	1524	storeRealname = ""
	1525	}
	1526
[540]	1527	var storeErr error
	1528	var needUpdate []Network
	1529	dc.forEachNetwork(func(n *network) {
	1530	// We only need to call updateNetwork for upstreams that don't
	1531	// support setname
	1532	if uc := n.conn; uc != nil && uc.caps["setname"] {
	1533	uc.SendMessageLabeled(dc.id, &irc.Message{
	1534	Command: "SETNAME",
	1535	Params: []string{realname},
	1536	})
	1537
[568]	1538	n.Realname = storeRealname
[675]	1539	if err := dc.srv.db.StoreNetwork(ctx, dc.user.ID, &n.Network); err != nil {
[540]	1540	dc.logger.Printf("failed to store network realname: %v", err)
	1541	storeErr = err
	1542	}
	1543	return
	1544	}
	1545
	1546	record := n.Network // copy network record because we'll mutate it
[568]	1547	record.Realname = storeRealname
[540]	1548	needUpdate = append(needUpdate, record)
	1549	})
	1550
	1551	// Walk the network list as a second step, because updateNetwork
	1552	// mutates the original list
	1553	for _, record := range needUpdate {
[676]	1554	if _, err := dc.user.updateNetwork(ctx, &record); err != nil {
[540]	1555	dc.logger.Printf("failed to update network realname: %v", err)
	1556	storeErr = err
	1557	}
	1558	}
	1559	if storeErr != nil {
	1560	return ircError{&irc.Message{
	1561	Command: "FAIL",
	1562	Params: []string{"SETNAME", "CANNOT_CHANGE_REALNAME", "Failed to update realname"},
	1563	}}
	1564	}
	1565
[651]	1566	if dc.upstream() == nil {
[540]	1567	dc.SendMessage(&irc.Message{
	1568	Prefix: dc.prefix(),
	1569	Command: "SETNAME",
	1570	Params: []string{realname},
	1571	})
	1572	}
[146]	1573	case "JOIN":
	1574	var namesStr string
	1575	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	1576	return err
	1577	}
	1578
[146]	1579	var keys []string
	1580	if len(msg.Params) > 1 {
	1581	keys = strings.Split(msg.Params[1], ",")
	1582	}
	1583
	1584	for i, name := range strings.Split(namesStr, ",") {
[145]	1585	uc, upstreamName, err := dc.unmarshalEntity(name)
	1586	if err != nil {
[158]	1587	return err
[145]	1588	}
[48]	1589
[146]	1590	var key string
	1591	if len(keys) > i {
	1592	key = keys[i]
	1593	}
	1594
[545]	1595	if !uc.isChannel(upstreamName) {
	1596	dc.SendMessage(&irc.Message{
	1597	Prefix: dc.srv.prefix(),
	1598	Command: irc.ERR_NOSUCHCHANNEL,
	1599	Params: []string{name, "Not a channel name"},
	1600	})
	1601	continue
	1602	}
	1603
[146]	1604	params := []string{upstreamName}
	1605	if key != "" {
	1606	params = append(params, key)
	1607	}
[301]	1608	uc.SendMessageLabeled(dc.id, &irc.Message{
[146]	1609	Command: "JOIN",
	1610	Params: params,
[145]	1611	})
[89]	1612
[478]	1613	ch := uc.network.channels.Value(upstreamName)
	1614	if ch != nil {
[285]	1615	// Don't clear the channel key if there's one set
	1616	// TODO: add a way to unset the channel key
[435]	1617	if key != "" {
	1618	ch.Key = key
	1619	}
	1620	uc.network.attach(ch)
	1621	} else {
	1622	ch = &Channel{
	1623	Name: upstreamName,
	1624	Key: key,
	1625	}
[478]	1626	uc.network.channels.SetValue(upstreamName, ch)
[285]	1627	}
[675]	1628	if err := dc.srv.db.StoreChannel(ctx, uc.network.ID, ch); err != nil {
[222]	1629	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
[89]	1630	}
	1631	}
[146]	1632	case "PART":
	1633	var namesStr string
	1634	if err := parseMessageParams(msg, &namesStr); err != nil {
	1635	return err
	1636	}
	1637
	1638	var reason string
	1639	if len(msg.Params) > 1 {
	1640	reason = msg.Params[1]
	1641	}
	1642
	1643	for _, name := range strings.Split(namesStr, ",") {
	1644	uc, upstreamName, err := dc.unmarshalEntity(name)
	1645	if err != nil {
[158]	1646	return err
[146]	1647	}
	1648
[284]	1649	if strings.EqualFold(reason, "detach") {
[478]	1650	ch := uc.network.channels.Value(upstreamName)
	1651	if ch != nil {
[435]	1652	uc.network.detach(ch)
	1653	} else {
	1654	ch = &Channel{
	1655	Name: name,
	1656	Detached: true,
	1657	}
[478]	1658	uc.network.channels.SetValue(upstreamName, ch)
[284]	1659	}
[675]	1660	if err := dc.srv.db.StoreChannel(ctx, uc.network.ID, ch); err != nil {
[435]	1661	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
	1662	}
[284]	1663	} else {
	1664	params := []string{upstreamName}
	1665	if reason != "" {
	1666	params = append(params, reason)
	1667	}
[301]	1668	uc.SendMessageLabeled(dc.id, &irc.Message{
[284]	1669	Command: "PART",
	1670	Params: params,
	1671	})
[146]	1672
[676]	1673	if err := uc.network.deleteChannel(ctx, upstreamName); err != nil {
[284]	1674	dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
	1675	}
[146]	1676	}
	1677	}
[159]	1678	case "KICK":
	1679	var channelStr, userStr string
	1680	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	1681	return err
	1682	}
	1683
	1684	channels := strings.Split(channelStr, ",")
	1685	users := strings.Split(userStr, ",")
	1686
	1687	var reason string
	1688	if len(msg.Params) > 2 {
	1689	reason = msg.Params[2]
	1690	}
	1691
	1692	if len(channels) != 1 && len(channels) != len(users) {
	1693	return ircError{&irc.Message{
	1694	Command: irc.ERR_BADCHANMASK,
	1695	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	1696	}}
	1697	}
	1698
	1699	for i, user := range users {
	1700	var channel string
	1701	if len(channels) == 1 {
	1702	channel = channels[0]
	1703	} else {
	1704	channel = channels[i]
	1705	}
	1706
	1707	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1708	if err != nil {
	1709	return err
	1710	}
	1711
	1712	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1713	if err != nil {
	1714	return err
	1715	}
	1716
	1717	if ucChannel != ucUser {
	1718	return ircError{&irc.Message{
	1719	Command: irc.ERR_USERNOTINCHANNEL,
[400]	1720	Params: []string{dc.nick, user, channel, "They are on another network"},
[159]	1721	}}
	1722	}
	1723	uc := ucChannel
	1724
	1725	params := []string{upstreamChannel, upstreamUser}
	1726	if reason != "" {
	1727	params = append(params, reason)
	1728	}
[301]	1729	uc.SendMessageLabeled(dc.id, &irc.Message{
[159]	1730	Command: "KICK",
	1731	Params: params,
	1732	})
	1733	}
[69]	1734	case "MODE":
[46]	1735	var name string
	1736	if err := parseMessageParams(msg, &name); err != nil {
	1737	return err
	1738	}
	1739
	1740	var modeStr string
	1741	if len(msg.Params) > 1 {
	1742	modeStr = msg.Params[1]
	1743	}
	1744
[478]	1745	if casemapASCII(name) == dc.nickCM {
[46]	1746	if modeStr != "" {
[554]	1747	if uc := dc.upstream(); uc != nil {
[301]	1748	uc.SendMessageLabeled(dc.id, &irc.Message{
[69]	1749	Command: "MODE",
	1750	Params: []string{uc.nick, modeStr},
	1751	})
[554]	1752	} else {
	1753	dc.SendMessage(&irc.Message{
	1754	Prefix: dc.srv.prefix(),
	1755	Command: irc.ERR_UMODEUNKNOWNFLAG,
	1756	Params: []string{dc.nick, "Cannot change user mode in multi-upstream mode"},
	1757	})
	1758	}
[46]	1759	} else {
[553]	1760	var userMode string
	1761	if uc := dc.upstream(); uc != nil {
	1762	userMode = string(uc.modes)
	1763	}
	1764
[55]	1765	dc.SendMessage(&irc.Message{
	1766	Prefix: dc.srv.prefix(),
[46]	1767	Command: irc.RPL_UMODEIS,
[672]	1768	Params: []string{dc.nick, "+" + userMode},
[54]	1769	})
[46]	1770	}
[139]	1771	return nil
[46]	1772	}
[139]	1773
	1774	uc, upstreamName, err := dc.unmarshalEntity(name)
	1775	if err != nil {
	1776	return err
	1777	}
	1778
	1779	if !uc.isChannel(upstreamName) {
	1780	return ircError{&irc.Message{
	1781	Command: irc.ERR_USERSDONTMATCH,
	1782	Params: []string{dc.nick, "Cannot change mode for other users"},
	1783	}}
	1784	}
	1785
	1786	if modeStr != "" {
	1787	params := []string{upstreamName, modeStr}
	1788	params = append(params, msg.Params[2:]...)
[301]	1789	uc.SendMessageLabeled(dc.id, &irc.Message{
[139]	1790	Command: "MODE",
	1791	Params: params,
	1792	})
	1793	} else {
[478]	1794	ch := uc.channels.Value(upstreamName)
	1795	if ch == nil {
[139]	1796	return ircError{&irc.Message{
	1797	Command: irc.ERR_NOSUCHCHANNEL,
	1798	Params: []string{dc.nick, name, "No such channel"},
	1799	}}
	1800	}
	1801
	1802	if ch.modes == nil {
	1803	// we haven't received the initial RPL_CHANNELMODEIS yet
	1804	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	1805	return nil
	1806	}
	1807
	1808	modeStr, modeParams := ch.modes.Format()
	1809	params := []string{dc.nick, name, modeStr}
	1810	params = append(params, modeParams...)
	1811
	1812	dc.SendMessage(&irc.Message{
	1813	Prefix: dc.srv.prefix(),
	1814	Command: irc.RPL_CHANNELMODEIS,
	1815	Params: params,
	1816	})
[162]	1817	if ch.creationTime != "" {
	1818	dc.SendMessage(&irc.Message{
	1819	Prefix: dc.srv.prefix(),
	1820	Command: rpl_creationtime,
	1821	Params: []string{dc.nick, name, ch.creationTime},
	1822	})
	1823	}
[139]	1824	}
[160]	1825	case "TOPIC":
	1826	var channel string
	1827	if err := parseMessageParams(msg, &channel); err != nil {
	1828	return err
	1829	}
	1830
[478]	1831	uc, upstreamName, err := dc.unmarshalEntity(channel)
[160]	1832	if err != nil {
	1833	return err
	1834	}
	1835
	1836	if len(msg.Params) > 1 { // setting topic
	1837	topic := msg.Params[1]
[301]	1838	uc.SendMessageLabeled(dc.id, &irc.Message{
[160]	1839	Command: "TOPIC",
[478]	1840	Params: []string{upstreamName, topic},
[160]	1841	})
	1842	} else { // getting topic
[478]	1843	ch := uc.channels.Value(upstreamName)
	1844	if ch == nil {
[160]	1845	return ircError{&irc.Message{
	1846	Command: irc.ERR_NOSUCHCHANNEL,
[478]	1847	Params: []string{dc.nick, upstreamName, "No such channel"},
[160]	1848	}}
	1849	}
	1850	sendTopic(dc, ch)
	1851	}
[177]	1852	case "LIST":
[681]	1853	network := dc.network
	1854	if network == nil && len(msg.Params) > 0 {
	1855	var err error
	1856	network, msg.Params[0], err = dc.unmarshalEntityNetwork(msg.Params[0])
	1857	if err != nil {
	1858	return err
[177]	1859	}
	1860	}
[681]	1861	if network == nil {
	1862	dc.SendMessage(&irc.Message{
	1863	Prefix: dc.srv.prefix(),
	1864	Command: irc.RPL_LISTEND,
	1865	Params: []string{dc.nick, "LIST without a network suffix is not supported in multi-upstream mode"},
	1866	})
	1867	return nil
	1868	}
[177]	1869
[681]	1870	uc := network.conn
	1871	if uc == nil {
	1872	dc.SendMessage(&irc.Message{
	1873	Prefix: dc.srv.prefix(),
	1874	Command: irc.RPL_LISTEND,
	1875	Params: []string{dc.nick, "Disconnected from upstream server"},
	1876	})
	1877	return nil
	1878	}
	1879
[682]	1880	uc.enqueueCommand(dc, msg)
[140]	1881	case "NAMES":
	1882	if len(msg.Params) == 0 {
	1883	dc.SendMessage(&irc.Message{
	1884	Prefix: dc.srv.prefix(),
	1885	Command: irc.RPL_ENDOFNAMES,
	1886	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1887	})
	1888	return nil
	1889	}
	1890
	1891	channels := strings.Split(msg.Params[0], ",")
	1892	for _, channel := range channels {
[478]	1893	uc, upstreamName, err := dc.unmarshalEntity(channel)
[140]	1894	if err != nil {
	1895	return err
	1896	}
	1897
[478]	1898	ch := uc.channels.Value(upstreamName)
	1899	if ch != nil {
[140]	1900	sendNames(dc, ch)
	1901	} else {
	1902	// NAMES on a channel we have not joined, ask upstream
[176]	1903	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1904	Command: "NAMES",
[478]	1905	Params: []string{upstreamName},
[140]	1906	})
	1907	}
	1908	}
[660]	1909	// For WHOX docs, see:
	1910	// - http://faerion.sourceforge.net/doc/irc/whox.var
	1911	// - https://github.com/quakenet/snircd/blob/master/doc/readme.who
	1912	// Note, many features aren't widely implemented, such as flags and mask2
[127]	1913	case "WHO":
	1914	if len(msg.Params) == 0 {
	1915	// TODO: support WHO without parameters
	1916	dc.SendMessage(&irc.Message{
	1917	Prefix: dc.srv.prefix(),
	1918	Command: irc.RPL_ENDOFWHO,
[140]	1919	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1920	})
	1921	return nil
	1922	}
	1923
[660]	1924	// Clients will use the first mask to match RPL_ENDOFWHO
	1925	endOfWhoToken := msg.Params[0]
[127]	1926
[660]	1927	// TODO: add support for WHOX mask2
	1928	mask := msg.Params[0]
	1929	var options string
	1930	if len(msg.Params) > 1 {
	1931	options = msg.Params[1]
	1932	}
	1933
	1934	optionsParts := strings.SplitN(options, "%", 2)
	1935	// TODO: add support for WHOX flags in optionsParts[0]
	1936	var fields, whoxToken string
	1937	if len(optionsParts) == 2 {
	1938	optionsParts := strings.SplitN(optionsParts[1], ",", 2)
	1939	fields = strings.ToLower(optionsParts[0])
	1940	if len(optionsParts) == 2 && strings.Contains(fields, "t") {
	1941	whoxToken = optionsParts[1]
	1942	}
	1943	}
	1944
	1945	// TODO: support mixed bouncer/upstream WHO queries
	1946	maskCM := casemapASCII(mask)
	1947	if dc.network == nil && maskCM == dc.nickCM {
[142]	1948	// TODO: support AWAY (H/G) in self WHO reply
[658]	1949	flags := "H"
	1950	if dc.user.Admin {
[659]	1951	flags += "*"
[658]	1952	}
[660]	1953	info := whoxInfo{
	1954	Token: whoxToken,
	1955	Username: dc.user.Username,
	1956	Hostname: dc.hostname,
[691]	1957	Server: dc.srv.Config().Hostname,
[660]	1958	Nickname: dc.nick,
	1959	Flags: flags,
[661]	1960	Account: dc.user.Username,
[660]	1961	Realname: dc.realname,
	1962	}
	1963	dc.SendMessage(generateWHOXReply(dc.srv.prefix(), dc.nick, fields, &info))
[142]	1964	dc.SendMessage(&irc.Message{
	1965	Prefix: dc.srv.prefix(),
	1966	Command: irc.RPL_ENDOFWHO,
[660]	1967	Params: []string{dc.nick, endOfWhoToken, "End of /WHO list"},
[142]	1968	})
	1969	return nil
	1970	}
[660]	1971	if maskCM == serviceNickCM {
	1972	info := whoxInfo{
	1973	Token: whoxToken,
	1974	Username: servicePrefix.User,
	1975	Hostname: servicePrefix.Host,
[691]	1976	Server: dc.srv.Config().Hostname,
[660]	1977	Nickname: serviceNick,
	1978	Flags: "H*",
[661]	1979	Account: serviceNick,
[660]	1980	Realname: serviceRealname,
	1981	}
	1982	dc.SendMessage(generateWHOXReply(dc.srv.prefix(), dc.nick, fields, &info))
[343]	1983	dc.SendMessage(&irc.Message{
	1984	Prefix: dc.srv.prefix(),
	1985	Command: irc.RPL_ENDOFWHO,
[660]	1986	Params: []string{dc.nick, endOfWhoToken, "End of /WHO list"},
[343]	1987	})
	1988	return nil
	1989	}
[142]	1990
[660]	1991	// TODO: properly support WHO masks
	1992	uc, upstreamMask, err := dc.unmarshalEntity(mask)
[127]	1993	if err != nil {
	1994	return err
	1995	}
	1996
[660]	1997	params := []string{upstreamMask}
	1998	if options != "" {
	1999	params = append(params, options)
[127]	2000	}
	2001
[682]	2002	uc.enqueueCommand(dc, &irc.Message{
[127]	2003	Command: "WHO",
	2004	Params: params,
	2005	})
[128]	2006	case "WHOIS":
	2007	if len(msg.Params) == 0 {
	2008	return ircError{&irc.Message{
	2009	Command: irc.ERR_NONICKNAMEGIVEN,
	2010	Params: []string{dc.nick, "No nickname given"},
	2011	}}
	2012	}
	2013
	2014	var target, mask string
	2015	if len(msg.Params) == 1 {
	2016	target = ""
	2017	mask = msg.Params[0]
	2018	} else {
	2019	target = msg.Params[0]
	2020	mask = msg.Params[1]
	2021	}
	2022	// TODO: support multiple WHOIS users
	2023	if i := strings.IndexByte(mask, ','); i >= 0 {
	2024	mask = mask[:i]
	2025	}
	2026
[520]	2027	if dc.network == nil && casemapASCII(mask) == dc.nickCM {
[142]	2028	dc.SendMessage(&irc.Message{
	2029	Prefix: dc.srv.prefix(),
	2030	Command: irc.RPL_WHOISUSER,
[184]	2031	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	2032	})
	2033	dc.SendMessage(&irc.Message{
	2034	Prefix: dc.srv.prefix(),
	2035	Command: irc.RPL_WHOISSERVER,
[691]	2036	Params: []string{dc.nick, dc.nick, dc.srv.Config().Hostname, "soju"},
[142]	2037	})
[658]	2038	if dc.user.Admin {
	2039	dc.SendMessage(&irc.Message{
	2040	Prefix: dc.srv.prefix(),
	2041	Command: irc.RPL_WHOISOPERATOR,
	2042	Params: []string{dc.nick, dc.nick, "is a bouncer administrator"},
	2043	})
	2044	}
[142]	2045	dc.SendMessage(&irc.Message{
	2046	Prefix: dc.srv.prefix(),
[661]	2047	Command: rpl_whoisaccount,
	2048	Params: []string{dc.nick, dc.nick, dc.user.Username, "is logged in as"},
	2049	})
	2050	dc.SendMessage(&irc.Message{
	2051	Prefix: dc.srv.prefix(),
[142]	2052	Command: irc.RPL_ENDOFWHOIS,
	2053	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	2054	})
	2055	return nil
	2056	}
[609]	2057	if casemapASCII(mask) == serviceNickCM {
	2058	dc.SendMessage(&irc.Message{
	2059	Prefix: dc.srv.prefix(),
	2060	Command: irc.RPL_WHOISUSER,
	2061	Params: []string{dc.nick, serviceNick, servicePrefix.User, servicePrefix.Host, "*", serviceRealname},
	2062	})
	2063	dc.SendMessage(&irc.Message{
	2064	Prefix: dc.srv.prefix(),
	2065	Command: irc.RPL_WHOISSERVER,
[691]	2066	Params: []string{dc.nick, serviceNick, dc.srv.Config().Hostname, "soju"},
[609]	2067	})
	2068	dc.SendMessage(&irc.Message{
	2069	Prefix: dc.srv.prefix(),
[657]	2070	Command: irc.RPL_WHOISOPERATOR,
	2071	Params: []string{dc.nick, serviceNick, "is the bouncer service"},
	2072	})
	2073	dc.SendMessage(&irc.Message{
	2074	Prefix: dc.srv.prefix(),
[661]	2075	Command: rpl_whoisaccount,
	2076	Params: []string{dc.nick, serviceNick, serviceNick, "is logged in as"},
	2077	})
	2078	dc.SendMessage(&irc.Message{
	2079	Prefix: dc.srv.prefix(),
[609]	2080	Command: irc.RPL_ENDOFWHOIS,
	2081	Params: []string{dc.nick, serviceNick, "End of /WHOIS list"},
	2082	})
	2083	return nil
	2084	}
[142]	2085
[128]	2086	// TODO: support WHOIS masks
	2087	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	2088	if err != nil {
	2089	return err
	2090	}
	2091
	2092	var params []string
	2093	if target != "" {
[299]	2094	if target == mask { // WHOIS nick nick
	2095	params = []string{upstreamNick, upstreamNick}
	2096	} else {
	2097	params = []string{target, upstreamNick}
	2098	}
[128]	2099	} else {
	2100	params = []string{upstreamNick}
	2101	}
	2102
[176]	2103	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	2104	Command: "WHOIS",
	2105	Params: params,
	2106	})
[562]	2107	case "PRIVMSG", "NOTICE":
[58]	2108	var targetsStr, text string
	2109	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	2110	return err
	2111	}
[303]	2112	tags := copyClientTags(msg.Tags)
[58]	2113
	2114	for _, name := range strings.Split(targetsStr, ",") {
[691]	2115	if name == "$"+dc.srv.Config().Hostname \|\| (name == "$*" && dc.network == nil) {
[563]	2116	// "$" means a server mask follows. If it's the bouncer's
	2117	// hostname, broadcast the message to all bouncer users.
	2118	if !dc.user.Admin {
	2119	return ircError{&irc.Message{
	2120	Prefix: dc.srv.prefix(),
	2121	Command: irc.ERR_BADMASK,
	2122	Params: []string{dc.nick, name, "Permission denied to broadcast message to all bouncer users"},
	2123	}}
	2124	}
	2125
	2126	dc.logger.Printf("broadcasting bouncer-wide %v: %v", msg.Command, text)
	2127
	2128	broadcastTags := tags.Copy()
	2129	broadcastTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
	2130	broadcastMsg := &irc.Message{
	2131	Tags: broadcastTags,
	2132	Prefix: servicePrefix,
	2133	Command: msg.Command,
	2134	Params: []string{name, text},
	2135	}
	2136	dc.srv.forEachUser(func(u *user) {
	2137	u.events <- eventBroadcast{broadcastMsg}
	2138	})
	2139	continue
	2140	}
	2141
[529]	2142	if dc.network == nil && casemapASCII(name) == dc.nickCM {
[618]	2143	dc.SendMessage(&irc.Message{
	2144	Tags: msg.Tags.Copy(),
	2145	Prefix: dc.prefix(),
	2146	Command: msg.Command,
	2147	Params: []string{name, text},
	2148	})
[529]	2149	continue
	2150	}
	2151
[562]	2152	if msg.Command == "PRIVMSG" && casemapASCII(name) == serviceNickCM {
[431]	2153	if dc.caps["echo-message"] {
	2154	echoTags := tags.Copy()
	2155	echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
	2156	dc.SendMessage(&irc.Message{
	2157	Tags: echoTags,
	2158	Prefix: dc.prefix(),
[562]	2159	Command: msg.Command,
[431]	2160	Params: []string{name, text},
	2161	})
	2162	}
[677]	2163	handleServicePRIVMSG(ctx, dc, text)
[117]	2164	continue
	2165	}
	2166
[127]	2167	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	2168	if err != nil {
	2169	return err
	2170	}
	2171
[562]	2172	if msg.Command == "PRIVMSG" && uc.network.casemap(upstreamName) == "nickserv" {
[675]	2173	dc.handleNickServPRIVMSG(ctx, uc, text)
[95]	2174	}
	2175
[268]	2176	unmarshaledText := text
	2177	if uc.isChannel(upstreamName) {
	2178	unmarshaledText = dc.unmarshalText(uc, text)
	2179	}
[301]	2180	uc.SendMessageLabeled(dc.id, &irc.Message{
[303]	2181	Tags: tags,
[562]	2182	Command: msg.Command,
[268]	2183	Params: []string{upstreamName, unmarshaledText},
[60]	2184	})
[105]	2185
[303]	2186	echoTags := tags.Copy()
	2187	echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[559]	2188	if uc.account != "" {
	2189	echoTags["account"] = irc.TagValue(uc.account)
	2190	}
[113]	2191	echoMsg := &irc.Message{
[690]	2192	Tags: echoTags,
	2193	Prefix: &irc.Prefix{Name: uc.nick},
[562]	2194	Command: msg.Command,
[113]	2195	Params: []string{upstreamName, text},
	2196	}
[239]	2197	uc.produce(upstreamName, echoMsg, dc)
[435]	2198
	2199	uc.updateChannelAutoDetach(upstreamName)
[58]	2200	}
[303]	2201	case "TAGMSG":
	2202	var targetsStr string
	2203	if err := parseMessageParams(msg, &targetsStr); err != nil {
	2204	return err
	2205	}
	2206	tags := copyClientTags(msg.Tags)
	2207
	2208	for _, name := range strings.Split(targetsStr, ",") {
[617]	2209	if dc.network == nil && casemapASCII(name) == dc.nickCM {
	2210	dc.SendMessage(&irc.Message{
	2211	Tags: msg.Tags.Copy(),
	2212	Prefix: dc.prefix(),
	2213	Command: "TAGMSG",
	2214	Params: []string{name},
	2215	})
	2216	continue
	2217	}
	2218
[616]	2219	if casemapASCII(name) == serviceNickCM {
	2220	continue
	2221	}
	2222
[303]	2223	uc, upstreamName, err := dc.unmarshalEntity(name)
	2224	if err != nil {
	2225	return err
	2226	}
[427]	2227	if _, ok := uc.caps["message-tags"]; !ok {
	2228	continue
	2229	}
[303]	2230
	2231	uc.SendMessageLabeled(dc.id, &irc.Message{
	2232	Tags: tags,
	2233	Command: "TAGMSG",
	2234	Params: []string{upstreamName},
	2235	})
[435]	2236
	2237	uc.updateChannelAutoDetach(upstreamName)
[303]	2238	}
[163]	2239	case "INVITE":
	2240	var user, channel string
	2241	if err := parseMessageParams(msg, &user, &channel); err != nil {
	2242	return err
	2243	}
	2244
	2245	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	2246	if err != nil {
	2247	return err
	2248	}
	2249
	2250	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	2251	if err != nil {
	2252	return err
	2253	}
	2254
	2255	if ucChannel != ucUser {
	2256	return ircError{&irc.Message{
	2257	Command: irc.ERR_USERNOTINCHANNEL,
[401]	2258	Params: []string{dc.nick, user, channel, "They are on another network"},
[163]	2259	}}
	2260	}
	2261	uc := ucChannel
	2262
[176]	2263	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	2264	Command: "INVITE",
	2265	Params: []string{upstreamUser, upstreamChannel},
	2266	})
[684]	2267	case "MONITOR":
	2268	// MONITOR is unsupported in multi-upstream mode
	2269	uc := dc.upstream()
	2270	if uc == nil {
	2271	return newUnknownCommandError(msg.Command)
	2272	}
	2273
	2274	var subcommand string
	2275	if err := parseMessageParams(msg, &subcommand); err != nil {
	2276	return err
	2277	}
	2278
	2279	switch strings.ToUpper(subcommand) {
	2280	case "+", "-":
	2281	var targets string
	2282	if err := parseMessageParams(msg, nil, &targets); err != nil {
	2283	return err
	2284	}
	2285	for _, target := range strings.Split(targets, ",") {
	2286	if subcommand == "+" {
	2287	// Hard limit, just to avoid having downstreams fill our map
	2288	if len(dc.monitored.innerMap) >= 1000 {
	2289	dc.SendMessage(&irc.Message{
	2290	Prefix: dc.srv.prefix(),
	2291	Command: irc.ERR_MONLISTFULL,
	2292	Params: []string{dc.nick, "1000", target, "Bouncer monitor list is full"},
	2293	})
	2294	continue
	2295	}
	2296
	2297	dc.monitored.SetValue(target, nil)
	2298
	2299	if uc.monitored.Has(target) {
	2300	cmd := irc.RPL_MONOFFLINE
	2301	if online := uc.monitored.Value(target); online {
	2302	cmd = irc.RPL_MONONLINE
	2303	}
	2304
	2305	dc.SendMessage(&irc.Message{
	2306	Prefix: dc.srv.prefix(),
	2307	Command: cmd,
	2308	Params: []string{dc.nick, target},
	2309	})
	2310	}
	2311	} else {
	2312	dc.monitored.Delete(target)
	2313	}
	2314	}
	2315	uc.updateMonitor()
	2316	case "C": // clear
	2317	dc.monitored = newCasemapMap(0)
	2318	uc.updateMonitor()
	2319	case "L": // list
	2320	// TODO: be less lazy and pack the list
	2321	for _, entry := range dc.monitored.innerMap {
	2322	dc.SendMessage(&irc.Message{
	2323	Prefix: dc.srv.prefix(),
	2324	Command: irc.RPL_MONLIST,
	2325	Params: []string{dc.nick, entry.originalKey},
	2326	})
	2327	}
	2328	dc.SendMessage(&irc.Message{
	2329	Prefix: dc.srv.prefix(),
	2330	Command: irc.RPL_ENDOFMONLIST,
	2331	Params: []string{dc.nick, "End of MONITOR list"},
	2332	})
	2333	case "S": // status
	2334	// TODO: be less lazy and pack the lists
	2335	for _, entry := range dc.monitored.innerMap {
	2336	target := entry.originalKey
	2337
	2338	cmd := irc.RPL_MONOFFLINE
	2339	if online := uc.monitored.Value(target); online {
	2340	cmd = irc.RPL_MONONLINE
	2341	}
	2342
	2343	dc.SendMessage(&irc.Message{
	2344	Prefix: dc.srv.prefix(),
	2345	Command: cmd,
	2346	Params: []string{dc.nick, target},
	2347	})
	2348	}
	2349	}
[319]	2350	case "CHATHISTORY":
	2351	var subcommand string
	2352	if err := parseMessageParams(msg, &subcommand); err != nil {
	2353	return err
	2354	}
[516]	2355	var target, limitStr string
	2356	var boundsStr [2]string
	2357	switch subcommand {
	2358	case "AFTER", "BEFORE":
	2359	if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &limitStr); err != nil {
	2360	return err
	2361	}
	2362	case "BETWEEN":
	2363	if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &boundsStr[1], &limitStr); err != nil {
	2364	return err
	2365	}
[549]	2366	case "TARGETS":
[688]	2367	if dc.network == nil {
	2368	// Either an unbound bouncer network, in which case we should return no targets,
	2369	// or a multi-upstream downstream, but we don't support CHATHISTORY TARGETS for those yet.
	2370	dc.SendBatch("draft/chathistory-targets", nil, nil, func(batchRef irc.TagValue) {})
	2371	return nil
	2372	}
[549]	2373	if err := parseMessageParams(msg, nil, &boundsStr[0], &boundsStr[1], &limitStr); err != nil {
	2374	return err
	2375	}
[516]	2376	default:
	2377	// TODO: support LATEST, AROUND
[319]	2378	return ircError{&irc.Message{
	2379	Command: "FAIL",
[516]	2380	Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, "Unknown command"},
[319]	2381	}}
	2382	}
	2383
[586]	2384	// We don't save history for our service
	2385	if casemapASCII(target) == serviceNickCM {
	2386	dc.SendBatch("chathistory", []string{target}, nil, func(batchRef irc.TagValue) {})
	2387	return nil
	2388	}
	2389
[441]	2390	store, ok := dc.user.msgStore.(chatHistoryMessageStore)
	2391	if !ok {
[319]	2392	return ircError{&irc.Message{
	2393	Command: irc.ERR_UNKNOWNCOMMAND,
[456]	2394	Params: []string{dc.nick, "CHATHISTORY", "Unknown command"},
[319]	2395	}}
	2396	}
	2397
[585]	2398	network, entity, err := dc.unmarshalEntityNetwork(target)
[319]	2399	if err != nil {
	2400	return err
	2401	}
[585]	2402	entity = network.casemap(entity)
[319]	2403
	2404	// TODO: support msgid criteria
[516]	2405	var bounds [2]time.Time
	2406	bounds[0] = parseChatHistoryBound(boundsStr[0])
	2407	if bounds[0].IsZero() {
[319]	2408	return ircError{&irc.Message{
	2409	Command: "FAIL",
[516]	2410	Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[0], "Invalid first bound"},
[319]	2411	}}
	2412	}
	2413
[516]	2414	if boundsStr[1] != "" {
	2415	bounds[1] = parseChatHistoryBound(boundsStr[1])
	2416	if bounds[1].IsZero() {
	2417	return ircError{&irc.Message{
	2418	Command: "FAIL",
	2419	Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[1], "Invalid second bound"},
	2420	}}
	2421	}
[319]	2422	}
	2423
	2424	limit, err := strconv.Atoi(limitStr)
[670]	2425	if err != nil \|\| limit < 0 \|\| limit > chatHistoryLimit {
[319]	2426	return ircError{&irc.Message{
	2427	Command: "FAIL",
[456]	2428	Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, limitStr, "Invalid limit"},
[319]	2429	}}
	2430	}
	2431
[665]	2432	eventPlayback := dc.caps["draft/event-playback"]
	2433
[387]	2434	var history []*irc.Message
[319]	2435	switch subcommand {
	2436	case "BEFORE":
[667]	2437	history, err = store.LoadBeforeTime(ctx, &network.Network, entity, bounds[0], time.Time{}, limit, eventPlayback)
[360]	2438	case "AFTER":
[667]	2439	history, err = store.LoadAfterTime(ctx, &network.Network, entity, bounds[0], time.Now(), limit, eventPlayback)
[516]	2440	case "BETWEEN":
	2441	if bounds[0].Before(bounds[1]) {
[667]	2442	history, err = store.LoadAfterTime(ctx, &network.Network, entity, bounds[0], bounds[1], limit, eventPlayback)
[516]	2443	} else {
[667]	2444	history, err = store.LoadBeforeTime(ctx, &network.Network, entity, bounds[0], bounds[1], limit, eventPlayback)
[516]	2445	}
[549]	2446	case "TARGETS":
	2447	// TODO: support TARGETS in multi-upstream mode
[667]	2448	targets, err := store.ListTargets(ctx, &network.Network, bounds[0], bounds[1], limit, eventPlayback)
[549]	2449	if err != nil {
[627]	2450	dc.logger.Printf("failed fetching targets for chathistory: %v", err)
[549]	2451	return ircError{&irc.Message{
	2452	Command: "FAIL",
	2453	Params: []string{"CHATHISTORY", "MESSAGE_ERROR", subcommand, "Failed to retrieve targets"},
	2454	}}
	2455	}
	2456
[551]	2457	dc.SendBatch("draft/chathistory-targets", nil, nil, func(batchRef irc.TagValue) {
	2458	for _, target := range targets {
[585]	2459	if ch := network.channels.Value(target.Name); ch != nil && ch.Detached {
[551]	2460	continue
	2461	}
[549]	2462
[551]	2463	dc.SendMessage(&irc.Message{
	2464	Tags: irc.Tags{"batch": batchRef},
	2465	Prefix: dc.srv.prefix(),
	2466	Command: "CHATHISTORY",
	2467	Params: []string{"TARGETS", target.Name, target.LatestMessage.UTC().Format(serverTimeLayout)},
	2468	})
[550]	2469	}
[549]	2470	})
	2471
	2472	return nil
[319]	2473	}
[387]	2474	if err != nil {
[515]	2475	dc.logger.Printf("failed fetching %q messages for chathistory: %v", target, err)
[387]	2476	return newChatHistoryError(subcommand, target)
	2477	}
	2478
[551]	2479	dc.SendBatch("chathistory", []string{target}, nil, func(batchRef irc.TagValue) {
	2480	for _, msg := range history {
	2481	msg.Tags["batch"] = batchRef
[585]	2482	dc.SendMessage(dc.marshalMessage(msg, network))
[551]	2483	}
[387]	2484	})
[532]	2485	case "BOUNCER":
	2486	var subcommand string
	2487	if err := parseMessageParams(msg, &subcommand); err != nil {
	2488	return err
	2489	}
	2490
	2491	switch strings.ToUpper(subcommand) {
[646]	2492	case "BIND":
	2493	return ircError{&irc.Message{
	2494	Command: "FAIL",
	2495	Params: []string{"BOUNCER", "REGISTRATION_IS_COMPLETED", "BIND", "Cannot bind to a network after registration"},
	2496	}}
[532]	2497	case "LISTNETWORKS":
[551]	2498	dc.SendBatch("soju.im/bouncer-networks", nil, nil, func(batchRef irc.TagValue) {
	2499	dc.user.forEachNetwork(func(network *network) {
	2500	idStr := fmt.Sprintf("%v", network.ID)
	2501	attrs := getNetworkAttrs(network)
	2502	dc.SendMessage(&irc.Message{
	2503	Tags: irc.Tags{"batch": batchRef},
	2504	Prefix: dc.srv.prefix(),
	2505	Command: "BOUNCER",
	2506	Params: []string{"NETWORK", idStr, attrs.String()},
	2507	})
[532]	2508	})
	2509	})
	2510	case "ADDNETWORK":
	2511	var attrsStr string
	2512	if err := parseMessageParams(msg, nil, &attrsStr); err != nil {
	2513	return err
	2514	}
	2515	attrs := irc.ParseTags(attrsStr)
	2516
[654]	2517	record := &Network{Nick: dc.nick, Enabled: true}
	2518	if err := updateNetworkAttrs(record, attrs, subcommand); err != nil {
	2519	return err
[532]	2520	}
	2521
[664]	2522	if record.Nick == dc.user.Username {
	2523	record.Nick = ""
	2524	}
[654]	2525	if record.Realname == dc.user.Realname {
	2526	record.Realname = ""
[532]	2527	}
	2528
[676]	2529	network, err := dc.user.createNetwork(ctx, record)
[532]	2530	if err != nil {
	2531	return ircError{&irc.Message{
	2532	Command: "FAIL",
	2533	Params: []string{"BOUNCER", "UNKNOWN_ERROR", subcommand, fmt.Sprintf("Failed to create network: %v", err)},
	2534	}}
	2535	}
	2536
	2537	dc.SendMessage(&irc.Message{
	2538	Prefix: dc.srv.prefix(),
	2539	Command: "BOUNCER",
	2540	Params: []string{"ADDNETWORK", fmt.Sprintf("%v", network.ID)},
	2541	})
	2542	case "CHANGENETWORK":
	2543	var idStr, attrsStr string
	2544	if err := parseMessageParams(msg, nil, &idStr, &attrsStr); err != nil {
	2545	return err
	2546	}
[535]	2547	id, err := parseBouncerNetID(subcommand, idStr)
[532]	2548	if err != nil {
	2549	return err
	2550	}
	2551	attrs := irc.ParseTags(attrsStr)
	2552
	2553	net := dc.user.getNetworkByID(id)
	2554	if net == nil {
	2555	return ircError{&irc.Message{
	2556	Command: "FAIL",
[535]	2557	Params: []string{"BOUNCER", "INVALID_NETID", subcommand, idStr, "Invalid network ID"},
[532]	2558	}}
	2559	}
	2560
	2561	record := net.Network // copy network record because we'll mutate it
[654]	2562	if err := updateNetworkAttrs(&record, attrs, subcommand); err != nil {
	2563	return err
[532]	2564	}
	2565
[664]	2566	if record.Nick == dc.user.Username {
	2567	record.Nick = ""
	2568	}
[654]	2569	if record.Realname == dc.user.Realname {
	2570	record.Realname = ""
	2571	}
	2572
[676]	2573	_, err = dc.user.updateNetwork(ctx, &record)
[532]	2574	if err != nil {
	2575	return ircError{&irc.Message{
	2576	Command: "FAIL",
	2577	Params: []string{"BOUNCER", "UNKNOWN_ERROR", subcommand, fmt.Sprintf("Failed to update network: %v", err)},
	2578	}}
	2579	}
	2580
	2581	dc.SendMessage(&irc.Message{
	2582	Prefix: dc.srv.prefix(),
	2583	Command: "BOUNCER",
	2584	Params: []string{"CHANGENETWORK", idStr},
	2585	})
	2586	case "DELNETWORK":
	2587	var idStr string
	2588	if err := parseMessageParams(msg, nil, &idStr); err != nil {
	2589	return err
	2590	}
[535]	2591	id, err := parseBouncerNetID(subcommand, idStr)
[532]	2592	if err != nil {
	2593	return err
	2594	}
	2595
	2596	net := dc.user.getNetworkByID(id)
	2597	if net == nil {
	2598	return ircError{&irc.Message{
	2599	Command: "FAIL",
[535]	2600	Params: []string{"BOUNCER", "INVALID_NETID", subcommand, idStr, "Invalid network ID"},
[532]	2601	}}
	2602	}
	2603
[676]	2604	if err := dc.user.deleteNetwork(ctx, net.ID); err != nil {
[532]	2605	return err
	2606	}
	2607
	2608	dc.SendMessage(&irc.Message{
	2609	Prefix: dc.srv.prefix(),
	2610	Command: "BOUNCER",
	2611	Params: []string{"DELNETWORK", idStr},
	2612	})
	2613	default:
	2614	return ircError{&irc.Message{
	2615	Command: "FAIL",
	2616	Params: []string{"BOUNCER", "UNKNOWN_COMMAND", subcommand, "Unknown subcommand"},
	2617	}}
	2618	}
[13]	2619	default:
[55]	2620	dc.logger.Printf("unhandled message: %v", msg)
[547]	2621
	2622	// Only forward unknown commands in single-upstream mode
	2623	uc := dc.upstream()
	2624	if uc == nil {
	2625	return newUnknownCommandError(msg.Command)
	2626	}
	2627
	2628	uc.SendMessageLabeled(dc.id, msg)
[13]	2629	}
[42]	2630	return nil
[13]	2631	}
[95]	2632
[675]	2633	func (dc downstreamConn) handleNickServPRIVMSG(ctx context.Context, uc upstreamConn, text string) {
[95]	2634	username, password, ok := parseNickServCredentials(text, uc.nick)
	2635	if !ok {
	2636	return
	2637	}
	2638
[307]	2639	// User may have e.g. EXTERNAL mechanism configured. We do not want to
	2640	// automatically erase the key pair or any other credentials.
	2641	if uc.network.SASL.Mechanism != "" && uc.network.SASL.Mechanism != "PLAIN" {
	2642	return
	2643	}
	2644
[95]	2645	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	2646	n := uc.network
	2647	n.SASL.Mechanism = "PLAIN"
	2648	n.SASL.Plain.Username = username
	2649	n.SASL.Plain.Password = password
[675]	2650	if err := dc.srv.db.StoreNetwork(ctx, dc.user.ID, &n.Network); err != nil {
[95]	2651	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	2652	}
	2653	}
	2654
	2655	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	2656	fields := strings.Fields(text)
	2657	if len(fields) < 2 {
	2658	return "", "", false
	2659	}
	2660	cmd := strings.ToUpper(fields[0])
	2661	params := fields[1:]
	2662	switch cmd {
	2663	case "REGISTER":
	2664	username = nick
	2665	password = params[0]
	2666	case "IDENTIFY":
	2667	if len(params) == 1 {
	2668	username = nick
[182]	2669	password = params[0]
[95]	2670	} else {
	2671	username = params[0]
[182]	2672	password = params[1]
[95]	2673	}
[182]	2674	case "SET":
	2675	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	2676	username = nick
	2677	password = params[1]
	2678	}
[340]	2679	default:
	2680	return "", "", false
[95]	2681	}
	2682	return username, password, true
	2683	}

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

Download in other formats: