Context Navigation

source: code/trunk/downstream.go@ 648

Last change on this file since 648 was 648, checked in by contact, 4 years ago
Add support for account-notify
File size: 62.1 KB

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

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

Download in other formats: