Context Navigation

source: code/trunk/downstream.go@ 438

Last change on this file since 438 was 438, checked in by hubert, 4 years ago
Improve dc.authenticate()'s error messages
File size: 45.4 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
[411]	60	// ' ' and ':' break the IRC message wire format, '@' and '!' break prefixes,
	61	// '*' and '?' break masks
	62	const illegalNickChars = " :@!*?"
[404]	63
[275]	64	// permanentDownstreamCaps is the list of always-supported downstream
	65	// capabilities.
	66	var permanentDownstreamCaps = map[string]string{
[276]	67	"batch": "",
	68	"cap-notify": "",
[275]	69	"echo-message": "",
	70	"message-tags": "",
[276]	71	"sasl": "PLAIN",
	72	"server-time": "",
[275]	73	}
	74
[292]	75	// needAllDownstreamCaps is the list of downstream capabilities that
	76	// require support from all upstreams to be enabled
	77	var needAllDownstreamCaps = map[string]string{
[419]	78	"away-notify": "",
	79	"extended-join": "",
	80	"multi-prefix": "",
[292]	81	}
	82
[13]	83	type downstreamConn struct {
[210]	84	conn
[22]	85
[210]	86	id uint64
	87
[100]	88	registered bool
	89	user *user
	90	nick string
	91	rawUsername string
[168]	92	networkName string
[183]	93	clientName string
[100]	94	realname string
[141]	95	hostname string
[100]	96	password string // empty after authentication
	97	network *network // can be nil
[105]	98
[108]	99	negociatingCaps bool
	100	capVersion int
[275]	101	supportedCaps map[string]string
[236]	102	caps map[string]bool
[108]	103
[112]	104	saslServer sasl.Server
[13]	105	}
	106
[347]	107	func newDownstreamConn(srv Server, ic ircConn, id uint64) downstreamConn {
	108	remoteAddr := ic.RemoteAddr().String()
[323]	109	logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", remoteAddr)}
[398]	110	options := connOptions{Logger: logger}
[55]	111	dc := &downstreamConn{
[398]	112	conn: *newConn(srv, ic, &options),
[276]	113	id: id,
[275]	114	supportedCaps: make(map[string]string),
[276]	115	caps: make(map[string]bool),
[22]	116	}
[323]	117	dc.hostname = remoteAddr
[141]	118	if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
	119	dc.hostname = host
	120	}
[275]	121	for k, v := range permanentDownstreamCaps {
	122	dc.supportedCaps[k] = v
	123	}
[319]	124	if srv.LogPath != "" {
	125	dc.supportedCaps["draft/chathistory"] = ""
	126	}
[55]	127	return dc
[22]	128	}
	129
[55]	130	func (dc downstreamConn) prefix() irc.Prefix {
[27]	131	return &irc.Prefix{
[55]	132	Name: dc.nick,
[184]	133	User: dc.user.Username,
[141]	134	Host: dc.hostname,
[27]	135	}
	136	}
	137
[90]	138	func (dc downstreamConn) forEachNetwork(f func(network)) {
	139	if dc.network != nil {
	140	f(dc.network)
	141	} else {
	142	dc.user.forEachNetwork(f)
	143	}
	144	}
	145
[73]	146	func (dc downstreamConn) forEachUpstream(f func(upstreamConn)) {
	147	dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]	148	if dc.network != nil && uc.network != dc.network {
[73]	149	return
	150	}
	151	f(uc)
	152	})
	153	}
	154
[89]	155	// upstream returns the upstream connection, if any. If there are zero or if
	156	// there are multiple upstream connections, it returns nil.
	157	func (dc downstreamConn) upstream() upstreamConn {
	158	if dc.network == nil {
	159	return nil
	160	}
[279]	161	return dc.network.conn
[89]	162	}
	163
[260]	164	func isOurNick(net *network, nick string) bool {
	165	// TODO: this doesn't account for nick changes
	166	if net.conn != nil {
	167	return nick == net.conn.nick
	168	}
	169	// We're not currently connected to the upstream connection, so we don't
	170	// know whether this name is our nickname. Best-effort: use the network's
	171	// configured nickname and hope it was the one being used when we were
	172	// connected.
	173	return nick == net.Nick
	174	}
	175
[249]	176	// marshalEntity converts an upstream entity name (ie. channel or nick) into a
	177	// downstream entity name.
	178	//
	179	// This involves adding a "/<network>" suffix if the entity isn't the current
	180	// user.
[260]	181	func (dc downstreamConn) marshalEntity(net network, name string) string {
[289]	182	if isOurNick(net, name) {
	183	return dc.nick
	184	}
[257]	185	if dc.network != nil {
[260]	186	if dc.network != net {
[258]	187	panic("soju: tried to marshal an entity for another network")
	188	}
[257]	189	return name
[119]	190	}
[260]	191	return name + "/" + net.GetName()
[119]	192	}
	193
[260]	194	func (dc downstreamConn) marshalUserPrefix(net network, prefix irc.Prefix) irc.Prefix {
	195	if isOurNick(net, prefix.Name) {
[257]	196	return dc.prefix()
	197	}
[130]	198	if dc.network != nil {
[260]	199	if dc.network != net {
[258]	200	panic("soju: tried to marshal a user prefix for another network")
	201	}
[257]	202	return prefix
[119]	203	}
[257]	204	return &irc.Prefix{
[260]	205	Name: prefix.Name + "/" + net.GetName(),
[257]	206	User: prefix.User,
	207	Host: prefix.Host,
	208	}
[119]	209	}
	210
[249]	211	// unmarshalEntity converts a downstream entity name (ie. channel or nick) into
	212	// an upstream entity name.
	213	//
	214	// This involves removing the "/<network>" suffix.
[127]	215	func (dc downstreamConn) unmarshalEntity(name string) (upstreamConn, string, error) {
[89]	216	if uc := dc.upstream(); uc != nil {
	217	return uc, name, nil
	218	}
	219
[127]	220	var conn *upstreamConn
[119]	221	if i := strings.LastIndexByte(name, '/'); i >= 0 {
[127]	222	network := name[i+1:]
[119]	223	name = name[:i]
	224
	225	dc.forEachUpstream(func(uc *upstreamConn) {
	226	if network != uc.network.GetName() {
	227	return
	228	}
	229	conn = uc
	230	})
	231	}
	232
[127]	233	if conn == nil {
[73]	234	return nil, "", ircError{&irc.Message{
	235	Command: irc.ERR_NOSUCHCHANNEL,
	236	Params: []string{name, "No such channel"},
	237	}}
[69]	238	}
[127]	239	return conn, name, nil
[69]	240	}
	241
[268]	242	func (dc downstreamConn) unmarshalText(uc upstreamConn, text string) string {
	243	if dc.upstream() != nil {
	244	return text
	245	}
	246	// TODO: smarter parsing that ignores URLs
	247	return strings.ReplaceAll(text, "/"+uc.network.GetName(), "")
	248	}
	249
[165]	250	func (dc *downstreamConn) readMessages(ch chan<- event) error {
[22]	251	for {
[210]	252	msg, err := dc.ReadMessage()
[22]	253	if err == io.EOF {
	254	break
	255	} else if err != nil {
	256	return fmt.Errorf("failed to read IRC command: %v", err)
	257	}
	258
[165]	259	ch <- eventDownstreamMessage{msg, dc}
[22]	260	}
	261
[45]	262	return nil
[22]	263	}
	264
[230]	265	// SendMessage sends an outgoing message.
	266	//
	267	// This can only called from the user goroutine.
[55]	268	func (dc downstreamConn) SendMessage(msg irc.Message) {
[230]	269	if !dc.caps["message-tags"] {
[303]	270	if msg.Command == "TAGMSG" {
	271	return
	272	}
[216]	273	msg = msg.Copy()
	274	for name := range msg.Tags {
	275	supported := false
	276	switch name {
	277	case "time":
[230]	278	supported = dc.caps["server-time"]
[216]	279	}
	280	if !supported {
	281	delete(msg.Tags, name)
	282	}
	283	}
	284	}
[419]	285	if msg.Command == "JOIN" && !dc.caps["extended-join"] {
	286	msg.Params = msg.Params[:1]
	287	}
[216]	288
[210]	289	dc.conn.SendMessage(msg)
[54]	290	}
	291
[428]	292	// sendMessageWithID sends an outgoing message with the specified internal ID.
	293	func (dc downstreamConn) sendMessageWithID(msg irc.Message, id string) {
	294	dc.SendMessage(msg)
	295
	296	if id == "" \|\| !dc.messageSupportsHistory(msg) {
	297	return
	298	}
	299
	300	dc.sendPing(id)
	301	}
	302
	303	// advanceMessageWithID advances history to the specified message ID without
	304	// sending a message. This is useful e.g. for self-messages when echo-message
	305	// isn't enabled.
	306	func (dc downstreamConn) advanceMessageWithID(msg irc.Message, id string) {
	307	if id == "" \|\| !dc.messageSupportsHistory(msg) {
	308	return
	309	}
	310
	311	dc.sendPing(id)
	312	}
	313
	314	// ackMsgID acknowledges that a message has been received.
	315	func (dc *downstreamConn) ackMsgID(id string) {
	316	netName, entity, _, _, err := parseMsgID(id)
	317	if err != nil {
	318	dc.logger.Printf("failed to ACK message ID %q: %v", id, err)
	319	return
	320	}
	321
	322	network := dc.user.getNetwork(netName)
	323	if network == nil {
	324	return
	325	}
	326
	327	history, ok := network.history[entity]
	328	if !ok {
	329	return
	330	}
	331
	332	history.clients[dc.clientName] = id
	333	}
	334
	335	func (dc *downstreamConn) sendPing(msgID string) {
	336	token := "soju-msgid-" + base64.RawURLEncoding.EncodeToString([]byte(msgID))
	337	dc.SendMessage(&irc.Message{
	338	Command: "PING",
	339	Params: []string{token},
	340	})
	341	}
	342
	343	func (dc *downstreamConn) handlePong(token string) {
	344	if !strings.HasPrefix(token, "soju-msgid-") {
	345	dc.logger.Printf("received unrecognized PONG token %q", token)
	346	return
	347	}
	348	token = strings.TrimPrefix(token, "soju-msgid-")
	349	b, err := base64.RawURLEncoding.DecodeString(token)
	350	if err != nil {
	351	dc.logger.Printf("received malformed PONG token: %v", err)
	352	return
	353	}
	354	msgID := string(b)
	355
	356	dc.ackMsgID(msgID)
	357	}
	358
[245]	359	// marshalMessage re-formats a message coming from an upstream connection so
	360	// that it's suitable for being sent on this downstream connection. Only
[293]	361	// messages that may appear in logs are supported, except MODE.
[261]	362	func (dc downstreamConn) marshalMessage(msg irc.Message, net network) irc.Message {
[227]	363	msg = msg.Copy()
[261]	364	msg.Prefix = dc.marshalUserPrefix(net, msg.Prefix)
[245]	365
[227]	366	switch msg.Command {
[303]	367	case "PRIVMSG", "NOTICE", "TAGMSG":
[261]	368	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	369	case "NICK":
	370	// Nick change for another user
[261]	371	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	372	case "JOIN", "PART":
[261]	373	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	374	case "KICK":
[261]	375	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
	376	msg.Params[1] = dc.marshalEntity(net, msg.Params[1])
[245]	377	case "TOPIC":
[261]	378	msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]	379	case "QUIT":
[262]	380	// This space is intentionally left blank
[227]	381	default:
	382	panic(fmt.Sprintf("unexpected %q message", msg.Command))
	383	}
	384
[245]	385	return msg
[227]	386	}
	387
[55]	388	func (dc downstreamConn) handleMessage(msg irc.Message) error {
[13]	389	switch msg.Command {
[28]	390	case "QUIT":
[55]	391	return dc.Close()
[13]	392	default:
[55]	393	if dc.registered {
	394	return dc.handleMessageRegistered(msg)
[13]	395	} else {
[55]	396	return dc.handleMessageUnregistered(msg)
[13]	397	}
	398	}
	399	}
	400
[55]	401	func (dc downstreamConn) handleMessageUnregistered(msg irc.Message) error {
[13]	402	switch msg.Command {
	403	case "NICK":
[117]	404	var nick string
	405	if err := parseMessageParams(msg, &nick); err != nil {
[43]	406	return err
[13]	407	}
[404]	408	if strings.ContainsAny(nick, illegalNickChars) {
	409	return ircError{&irc.Message{
	410	Command: irc.ERR_ERRONEUSNICKNAME,
	411	Params: []string{dc.nick, nick, "contains illegal characters"},
	412	}}
	413	}
[117]	414	if nick == serviceNick {
	415	return ircError{&irc.Message{
	416	Command: irc.ERR_NICKNAMEINUSE,
	417	Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
	418	}}
	419	}
	420	dc.nick = nick
[13]	421	case "USER":
[117]	422	if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]	423	return err
[13]	424	}
[85]	425	case "PASS":
	426	if err := parseMessageParams(msg, &dc.password); err != nil {
	427	return err
	428	}
[108]	429	case "CAP":
	430	var subCmd string
	431	if err := parseMessageParams(msg, &subCmd); err != nil {
	432	return err
	433	}
	434	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	435	return err
	436	}
[112]	437	case "AUTHENTICATE":
[230]	438	if !dc.caps["sasl"] {
[112]	439	return ircError{&irc.Message{
[125]	440	Command: irc.ERR_SASLFAIL,
[112]	441	Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
	442	}}
	443	}
	444	if len(msg.Params) == 0 {
	445	return ircError{&irc.Message{
[125]	446	Command: irc.ERR_SASLFAIL,
[112]	447	Params: []string{"*", "Missing AUTHENTICATE argument"},
	448	}}
	449	}
	450	if dc.nick == "" {
	451	return ircError{&irc.Message{
[125]	452	Command: irc.ERR_SASLFAIL,
[112]	453	Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
	454	}}
	455	}
	456
	457	var resp []byte
	458	if dc.saslServer == nil {
	459	mech := strings.ToUpper(msg.Params[0])
	460	switch mech {
	461	case "PLAIN":
	462	dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
	463	return dc.authenticate(username, password)
	464	}))
	465	default:
	466	return ircError{&irc.Message{
[125]	467	Command: irc.ERR_SASLFAIL,
[112]	468	Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
	469	}}
	470	}
	471	} else if msg.Params[0] == "*" {
	472	dc.saslServer = nil
	473	return ircError{&irc.Message{
[125]	474	Command: irc.ERR_SASLABORTED,
[112]	475	Params: []string{"*", "SASL authentication aborted"},
	476	}}
	477	} else if msg.Params[0] == "+" {
	478	resp = nil
	479	} else {
	480	// TODO: multi-line messages
	481	var err error
	482	resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
	483	if err != nil {
	484	dc.saslServer = nil
	485	return ircError{&irc.Message{
[125]	486	Command: irc.ERR_SASLFAIL,
[112]	487	Params: []string{"*", "Invalid base64-encoded response"},
	488	}}
	489	}
	490	}
	491
	492	challenge, done, err := dc.saslServer.Next(resp)
	493	if err != nil {
	494	dc.saslServer = nil
	495	if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
	496	return ircError{&irc.Message{
[125]	497	Command: irc.ERR_SASLFAIL,
[112]	498	Params: []string{"*", ircErr.Message.Params[1]},
	499	}}
	500	}
	501	dc.SendMessage(&irc.Message{
	502	Prefix: dc.srv.prefix(),
[125]	503	Command: irc.ERR_SASLFAIL,
[112]	504	Params: []string{"*", "SASL error"},
	505	})
	506	return fmt.Errorf("SASL authentication failed: %v", err)
	507	} else if done {
	508	dc.saslServer = nil
	509	dc.SendMessage(&irc.Message{
	510	Prefix: dc.srv.prefix(),
[125]	511	Command: irc.RPL_LOGGEDIN,
[306]	512	Params: []string{dc.nick, dc.prefix().String(), dc.user.Username, "You are now logged in"},
[112]	513	})
	514	dc.SendMessage(&irc.Message{
	515	Prefix: dc.srv.prefix(),
[125]	516	Command: irc.RPL_SASLSUCCESS,
[112]	517	Params: []string{dc.nick, "SASL authentication successful"},
	518	})
	519	} else {
	520	challengeStr := "+"
[135]	521	if len(challenge) > 0 {
[112]	522	challengeStr = base64.StdEncoding.EncodeToString(challenge)
	523	}
	524
	525	// TODO: multi-line messages
	526	dc.SendMessage(&irc.Message{
	527	Prefix: dc.srv.prefix(),
	528	Command: "AUTHENTICATE",
	529	Params: []string{challengeStr},
	530	})
	531	}
[13]	532	default:
[55]	533	dc.logger.Printf("unhandled message: %v", msg)
[13]	534	return newUnknownCommandError(msg.Command)
	535	}
[108]	536	if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
[55]	537	return dc.register()
[13]	538	}
	539	return nil
	540	}
	541
[108]	542	func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]	543	cmd = strings.ToUpper(cmd)
	544
[108]	545	replyTo := dc.nick
	546	if !dc.registered {
	547	replyTo = "*"
	548	}
	549
	550	switch cmd {
	551	case "LS":
	552	if len(args) > 0 {
	553	var err error
	554	if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
	555	return err
	556	}
	557	}
[437]	558	if !dc.registered && dc.capVersion >= 302 {
	559	// Let downstream show everything it supports, and trim
	560	// down the available capabilities when upstreams are
	561	// known.
	562	for k, v := range needAllDownstreamCaps {
	563	dc.supportedCaps[k] = v
	564	}
	565	}
[108]	566
[275]	567	caps := make([]string, 0, len(dc.supportedCaps))
	568	for k, v := range dc.supportedCaps {
	569	if dc.capVersion >= 302 && v != "" {
[276]	570	caps = append(caps, k+"="+v)
[275]	571	} else {
	572	caps = append(caps, k)
	573	}
[112]	574	}
[108]	575
	576	// TODO: multi-line replies
	577	dc.SendMessage(&irc.Message{
	578	Prefix: dc.srv.prefix(),
	579	Command: "CAP",
	580	Params: []string{replyTo, "LS", strings.Join(caps, " ")},
	581	})
	582
[275]	583	if dc.capVersion >= 302 {
	584	// CAP version 302 implicitly enables cap-notify
	585	dc.caps["cap-notify"] = true
	586	}
	587
[108]	588	if !dc.registered {
	589	dc.negociatingCaps = true
	590	}
	591	case "LIST":
	592	var caps []string
	593	for name := range dc.caps {
	594	caps = append(caps, name)
	595	}
	596
	597	// TODO: multi-line replies
	598	dc.SendMessage(&irc.Message{
	599	Prefix: dc.srv.prefix(),
	600	Command: "CAP",
	601	Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
	602	})
	603	case "REQ":
	604	if len(args) == 0 {
	605	return ircError{&irc.Message{
	606	Command: err_invalidcapcmd,
	607	Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
	608	}}
	609	}
	610
[275]	611	// TODO: atomically ack/nak the whole capability set
[108]	612	caps := strings.Fields(args[0])
	613	ack := true
	614	for _, name := range caps {
	615	name = strings.ToLower(name)
	616	enable := !strings.HasPrefix(name, "-")
	617	if !enable {
	618	name = strings.TrimPrefix(name, "-")
	619	}
	620
[275]	621	if enable == dc.caps[name] {
[108]	622	continue
	623	}
	624
[275]	625	_, ok := dc.supportedCaps[name]
	626	if !ok {
[108]	627	ack = false
[275]	628	break
[108]	629	}
[275]	630
	631	if name == "cap-notify" && dc.capVersion >= 302 && !enable {
	632	// cap-notify cannot be disabled with CAP version 302
	633	ack = false
	634	break
	635	}
	636
	637	dc.caps[name] = enable
[108]	638	}
	639
	640	reply := "NAK"
	641	if ack {
	642	reply = "ACK"
	643	}
	644	dc.SendMessage(&irc.Message{
	645	Prefix: dc.srv.prefix(),
	646	Command: "CAP",
	647	Params: []string{replyTo, reply, args[0]},
	648	})
	649	case "END":
	650	dc.negociatingCaps = false
	651	default:
	652	return ircError{&irc.Message{
	653	Command: err_invalidcapcmd,
	654	Params: []string{replyTo, cmd, "Unknown CAP command"},
	655	}}
	656	}
	657	return nil
	658	}
	659
[275]	660	func (dc *downstreamConn) setSupportedCap(name, value string) {
	661	prevValue, hasPrev := dc.supportedCaps[name]
	662	changed := !hasPrev \|\| prevValue != value
	663	dc.supportedCaps[name] = value
	664
	665	if !dc.caps["cap-notify"] \|\| !changed {
	666	return
	667	}
	668
	669	replyTo := dc.nick
	670	if !dc.registered {
	671	replyTo = "*"
	672	}
	673
	674	cap := name
	675	if value != "" && dc.capVersion >= 302 {
	676	cap = name + "=" + value
	677	}
	678
	679	dc.SendMessage(&irc.Message{
	680	Prefix: dc.srv.prefix(),
	681	Command: "CAP",
	682	Params: []string{replyTo, "NEW", cap},
	683	})
	684	}
	685
	686	func (dc *downstreamConn) unsetSupportedCap(name string) {
	687	_, hasPrev := dc.supportedCaps[name]
	688	delete(dc.supportedCaps, name)
	689	delete(dc.caps, name)
	690
	691	if !dc.caps["cap-notify"] \|\| !hasPrev {
	692	return
	693	}
	694
	695	replyTo := dc.nick
	696	if !dc.registered {
	697	replyTo = "*"
	698	}
	699
	700	dc.SendMessage(&irc.Message{
	701	Prefix: dc.srv.prefix(),
	702	Command: "CAP",
	703	Params: []string{replyTo, "DEL", name},
	704	})
	705	}
	706
[276]	707	func (dc *downstreamConn) updateSupportedCaps() {
[292]	708	supportedCaps := make(map[string]bool)
	709	for cap := range needAllDownstreamCaps {
	710	supportedCaps[cap] = true
	711	}
[276]	712	dc.forEachUpstream(func(uc *upstreamConn) {
[292]	713	for cap, supported := range supportedCaps {
	714	supportedCaps[cap] = supported && uc.caps[cap]
	715	}
[276]	716	})
	717
[292]	718	for cap, supported := range supportedCaps {
	719	if supported {
	720	dc.setSupportedCap(cap, needAllDownstreamCaps[cap])
	721	} else {
	722	dc.unsetSupportedCap(cap)
	723	}
[276]	724	}
	725	}
	726
[296]	727	func (dc *downstreamConn) updateNick() {
	728	if uc := dc.upstream(); uc != nil && uc.nick != dc.nick {
	729	dc.SendMessage(&irc.Message{
	730	Prefix: dc.prefix(),
	731	Command: "NICK",
	732	Params: []string{uc.nick},
	733	})
	734	dc.nick = uc.nick
	735	}
	736	}
	737
[91]	738	func sanityCheckServer(addr string) error {
	739	dialer := net.Dialer{Timeout: 30 * time.Second}
	740	conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
	741	if err != nil {
	742	return err
	743	}
	744	return conn.Close()
	745	}
	746
[183]	747	func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]	748	username = rawUsername
[183]	749
	750	i := strings.IndexAny(username, "/@")
	751	j := strings.LastIndexAny(username, "/@")
	752	if i >= 0 {
	753	username = rawUsername[:i]
[73]	754	}
[183]	755	if j >= 0 {
[190]	756	if rawUsername[j] == '@' {
	757	client = rawUsername[j+1:]
	758	} else {
	759	network = rawUsername[j+1:]
	760	}
[73]	761	}
[183]	762	if i >= 0 && j >= 0 && i < j {
[190]	763	if rawUsername[i] == '@' {
	764	client = rawUsername[i+1 : j]
	765	} else {
	766	network = rawUsername[i+1 : j]
	767	}
[183]	768	}
	769
	770	return username, client, network
[112]	771	}
[73]	772
[168]	773	func (dc *downstreamConn) authenticate(username, password string) error {
[183]	774	username, clientName, networkName := unmarshalUsername(username)
[168]	775
[173]	776	u, err := dc.srv.db.GetUser(username)
	777	if err != nil {
[438]	778	dc.logger.Printf("failed authentication for %q: user not found: %v", username, err)
[168]	779	return errAuthFailed
	780	}
	781
[322]	782	// Password auth disabled
	783	if u.Password == "" {
	784	return errAuthFailed
	785	}
	786
[173]	787	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]	788	if err != nil {
[438]	789	dc.logger.Printf("failed authentication for %q: wrong password: %v", username, err)
[168]	790	return errAuthFailed
	791	}
	792
[173]	793	dc.user = dc.srv.getUser(username)
	794	if dc.user == nil {
	795	dc.logger.Printf("failed authentication for %q: user not active", username)
	796	return errAuthFailed
	797	}
[183]	798	dc.clientName = clientName
[168]	799	dc.networkName = networkName
	800	return nil
	801	}
	802
	803	func (dc *downstreamConn) register() error {
	804	if dc.registered {
	805	return fmt.Errorf("tried to register twice")
	806	}
	807
	808	password := dc.password
	809	dc.password = ""
	810	if dc.user == nil {
	811	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	812	return err
	813	}
	814	}
	815
[183]	816	if dc.clientName == "" && dc.networkName == "" {
	817	_, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]	818	}
	819
	820	dc.registered = true
[184]	821	dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]	822	return nil
	823	}
	824
	825	func (dc *downstreamConn) loadNetwork() error {
	826	if dc.networkName == "" {
[112]	827	return nil
	828	}
[85]	829
[168]	830	network := dc.user.getNetwork(dc.networkName)
[112]	831	if network == nil {
[168]	832	addr := dc.networkName
[112]	833	if !strings.ContainsRune(addr, ':') {
	834	addr = addr + ":6697"
	835	}
	836
	837	dc.logger.Printf("trying to connect to new network %q", addr)
	838	if err := sanityCheckServer(addr); err != nil {
	839	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	840	return ircError{&irc.Message{
	841	Command: irc.ERR_PASSWDMISMATCH,
[168]	842	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]	843	}}
	844	}
	845
[354]	846	// Some clients only allow specifying the nickname (and use the
	847	// nickname as a username too). Strip the network name from the
	848	// nickname when auto-saving networks.
	849	nick, _, _ := unmarshalUsername(dc.nick)
	850
[168]	851	dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]	852	var err error
[120]	853	network, err = dc.user.createNetwork(&Network{
[168]	854	Addr: dc.networkName,
[354]	855	Nick: nick,
[120]	856	})
[112]	857	if err != nil {
	858	return err
	859	}
	860	}
	861
	862	dc.network = network
	863	return nil
	864	}
	865
[168]	866	func (dc *downstreamConn) welcome() error {
	867	if dc.user == nil \|\| !dc.registered {
	868	panic("tried to welcome an unregistered connection")
[37]	869	}
	870
[168]	871	// TODO: doing this might take some time. We should do it in dc.register
	872	// instead, but we'll potentially be adding a new network and this must be
	873	// done in the user goroutine.
	874	if err := dc.loadNetwork(); err != nil {
	875	return err
[85]	876	}
	877
[55]	878	dc.SendMessage(&irc.Message{
	879	Prefix: dc.srv.prefix(),
[13]	880	Command: irc.RPL_WELCOME,
[98]	881	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	882	})
[55]	883	dc.SendMessage(&irc.Message{
	884	Prefix: dc.srv.prefix(),
[13]	885	Command: irc.RPL_YOURHOST,
[55]	886	Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]	887	})
[55]	888	dc.SendMessage(&irc.Message{
	889	Prefix: dc.srv.prefix(),
[13]	890	Command: irc.RPL_CREATED,
[55]	891	Params: []string{dc.nick, "Who cares when the server was created?"},
[54]	892	})
[55]	893	dc.SendMessage(&irc.Message{
	894	Prefix: dc.srv.prefix(),
[13]	895	Command: irc.RPL_MYINFO,
[98]	896	Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	897	})
[93]	898	// TODO: RPL_ISUPPORT
[319]	899	// TODO: send CHATHISTORY in RPL_ISUPPORT when implemented
[55]	900	dc.SendMessage(&irc.Message{
	901	Prefix: dc.srv.prefix(),
[13]	902	Command: irc.ERR_NOMOTD,
[55]	903	Params: []string{dc.nick, "No MOTD"},
[54]	904	})
[13]	905
[296]	906	dc.updateNick()
[437]	907	dc.updateSupportedCaps()
[296]	908
[73]	909	dc.forEachUpstream(func(uc *upstreamConn) {
[30]	910	for _, ch := range uc.channels {
[284]	911	if !ch.complete {
	912	continue
	913	}
	914	if record, ok := uc.network.channels[ch.Name]; ok && record.Detached {
	915	continue
	916	}
[132]	917
[284]	918	dc.SendMessage(&irc.Message{
	919	Prefix: dc.prefix(),
	920	Command: "JOIN",
	921	Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
	922	})
	923
	924	forwardChannel(dc, ch)
[30]	925	}
[143]	926	})
[50]	927
[143]	928	dc.forEachNetwork(func(net *network) {
[253]	929	// Only send history if we're the first connected client with that name
	930	// for the network
	931	if _, ok := net.offlineClients[dc.clientName]; ok {
	932	dc.sendNetworkHistory(net)
	933	delete(net.offlineClients, dc.clientName)
[227]	934	}
[409]	935
	936	// Fast-forward history to last message
	937	for target, history := range net.history {
	938	if ch, ok := net.channels[target]; ok && ch.Detached {
	939	continue
	940	}
	941
[423]	942	lastID, err := dc.user.msgStore.LastMsgID(net, target, time.Now())
[409]	943	if err != nil {
	944	dc.logger.Printf("failed to get last message ID: %v", err)
	945	continue
	946	}
	947	history.clients[dc.clientName] = lastID
	948	}
[253]	949	})
[57]	950
[253]	951	return nil
	952	}
[144]	953
[428]	954	// messageSupportsHistory checks whether the provided message can be sent as
	955	// part of an history batch.
	956	func (dc downstreamConn) messageSupportsHistory(msg irc.Message) bool {
	957	// Don't replay all messages, because that would mess up client
	958	// state. For instance we just sent the list of users, sending
	959	// PART messages for one of these users would be incorrect.
	960	// TODO: add support for draft/event-playback
	961	switch msg.Command {
	962	case "PRIVMSG", "NOTICE":
	963	return true
	964	}
	965	return false
	966	}
	967
[253]	968	func (dc downstreamConn) sendNetworkHistory(net network) {
[423]	969	if dc.caps["draft/chathistory"] \|\| dc.user.msgStore == nil {
[319]	970	return
	971	}
[253]	972	for target, history := range net.history {
[284]	973	if ch, ok := net.channels[target]; ok && ch.Detached {
	974	continue
	975	}
	976
[409]	977	lastDelivered, ok := history.clients[dc.clientName]
[253]	978	if !ok {
	979	continue
	980	}
	981
[409]	982	limit := 4000
[423]	983	history, err := dc.user.msgStore.LoadLatestID(net, target, lastDelivered, limit)
[409]	984	if err != nil {
	985	dc.logger.Printf("failed to send implicit history for %q: %v", target, err)
	986	continue
	987	}
[253]	988
[256]	989	batchRef := "history"
	990	if dc.caps["batch"] {
	991	dc.SendMessage(&irc.Message{
	992	Prefix: dc.srv.prefix(),
	993	Command: "BATCH",
[260]	994	Params: []string{"+" + batchRef, "chathistory", dc.marshalEntity(net, target)},
[256]	995	})
	996	}
	997
[409]	998	for _, msg := range history {
[428]	999	if !dc.messageSupportsHistory(msg) {
[245]	1000	continue
	1001	}
	1002
[256]	1003	if dc.caps["batch"] {
	1004	msg.Tags["batch"] = irc.TagValue(batchRef)
	1005	}
[261]	1006	dc.SendMessage(dc.marshalMessage(msg, net))
[227]	1007	}
[256]	1008
	1009	if dc.caps["batch"] {
	1010	dc.SendMessage(&irc.Message{
	1011	Prefix: dc.srv.prefix(),
	1012	Command: "BATCH",
	1013	Params: []string{"-" + batchRef},
	1014	})
	1015	}
[253]	1016	}
[13]	1017	}
	1018
[103]	1019	func (dc *downstreamConn) runUntilRegistered() error {
	1020	for !dc.registered {
[212]	1021	msg, err := dc.ReadMessage()
[106]	1022	if err != nil {
[103]	1023	return fmt.Errorf("failed to read IRC command: %v", err)
	1024	}
	1025
	1026	err = dc.handleMessage(msg)
	1027	if ircErr, ok := err.(ircError); ok {
	1028	ircErr.Message.Prefix = dc.srv.prefix()
	1029	dc.SendMessage(ircErr.Message)
	1030	} else if err != nil {
	1031	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	1032	}
	1033	}
	1034
	1035	return nil
	1036	}
	1037
[55]	1038	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	1039	switch msg.Command {
[111]	1040	case "CAP":
	1041	var subCmd string
	1042	if err := parseMessageParams(msg, &subCmd); err != nil {
	1043	return err
	1044	}
	1045	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	1046	return err
	1047	}
[107]	1048	case "PING":
[412]	1049	var source, destination string
	1050	if err := parseMessageParams(msg, &source); err != nil {
	1051	return err
	1052	}
	1053	if len(msg.Params) > 1 {
	1054	destination = msg.Params[1]
	1055	}
	1056	if destination != "" && destination != dc.srv.Hostname {
	1057	return ircError{&irc.Message{
	1058	Command: irc.ERR_NOSUCHSERVER,
[413]	1059	Params: []string{dc.nick, destination, "No such server"},
[412]	1060	}}
	1061	}
[107]	1062	dc.SendMessage(&irc.Message{
	1063	Prefix: dc.srv.prefix(),
	1064	Command: "PONG",
[412]	1065	Params: []string{dc.srv.Hostname, source},
[107]	1066	})
	1067	return nil
[428]	1068	case "PONG":
	1069	if len(msg.Params) == 0 {
	1070	return newNeedMoreParamsError(msg.Command)
	1071	}
	1072	token := msg.Params[len(msg.Params)-1]
	1073	dc.handlePong(token)
[42]	1074	case "USER":
[13]	1075	return ircError{&irc.Message{
	1076	Command: irc.ERR_ALREADYREGISTERED,
[55]	1077	Params: []string{dc.nick, "You may not reregister"},
[13]	1078	}}
[42]	1079	case "NICK":
[429]	1080	var rawNick string
	1081	if err := parseMessageParams(msg, &rawNick); err != nil {
[90]	1082	return err
	1083	}
	1084
[429]	1085	nick := rawNick
[297]	1086	var upstream *upstreamConn
	1087	if dc.upstream() == nil {
	1088	uc, unmarshaledNick, err := dc.unmarshalEntity(nick)
	1089	if err == nil { // NICK nick/network: NICK only on a specific upstream
	1090	upstream = uc
	1091	nick = unmarshaledNick
	1092	}
	1093	}
	1094
[404]	1095	if strings.ContainsAny(nick, illegalNickChars) {
	1096	return ircError{&irc.Message{
	1097	Command: irc.ERR_ERRONEUSNICKNAME,
[430]	1098	Params: []string{dc.nick, rawNick, "contains illegal characters"},
[404]	1099	}}
	1100	}
[429]	1101	if nick == serviceNick {
	1102	return ircError{&irc.Message{
	1103	Command: irc.ERR_NICKNAMEINUSE,
	1104	Params: []string{dc.nick, rawNick, "Nickname reserved for bouncer service"},
	1105	}}
	1106	}
[404]	1107
[90]	1108	var err error
	1109	dc.forEachNetwork(func(n *network) {
[297]	1110	if err != nil \|\| (upstream != nil && upstream.network != n) {
[90]	1111	return
	1112	}
	1113	n.Nick = nick
[421]	1114	err = dc.srv.db.StoreNetwork(dc.user.ID, &n.Network)
[90]	1115	})
	1116	if err != nil {
	1117	return err
	1118	}
	1119
[73]	1120	dc.forEachUpstream(func(uc *upstreamConn) {
[297]	1121	if upstream != nil && upstream != uc {
	1122	return
	1123	}
[301]	1124	uc.SendMessageLabeled(dc.id, &irc.Message{
[297]	1125	Command: "NICK",
	1126	Params: []string{nick},
	1127	})
[42]	1128	})
[296]	1129
	1130	if dc.upstream() == nil && dc.nick != nick {
	1131	dc.SendMessage(&irc.Message{
	1132	Prefix: dc.prefix(),
	1133	Command: "NICK",
	1134	Params: []string{nick},
	1135	})
	1136	dc.nick = nick
	1137	}
[146]	1138	case "JOIN":
	1139	var namesStr string
	1140	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	1141	return err
	1142	}
	1143
[146]	1144	var keys []string
	1145	if len(msg.Params) > 1 {
	1146	keys = strings.Split(msg.Params[1], ",")
	1147	}
	1148
	1149	for i, name := range strings.Split(namesStr, ",") {
[145]	1150	uc, upstreamName, err := dc.unmarshalEntity(name)
	1151	if err != nil {
[158]	1152	return err
[145]	1153	}
[48]	1154
[146]	1155	var key string
	1156	if len(keys) > i {
	1157	key = keys[i]
	1158	}
	1159
	1160	params := []string{upstreamName}
	1161	if key != "" {
	1162	params = append(params, key)
	1163	}
[301]	1164	uc.SendMessageLabeled(dc.id, &irc.Message{
[146]	1165	Command: "JOIN",
	1166	Params: params,
[145]	1167	})
[89]	1168
[435]	1169	var ch *Channel
	1170	var ok bool
	1171	if ch, ok = uc.network.channels[upstreamName]; ok {
[285]	1172	// Don't clear the channel key if there's one set
	1173	// TODO: add a way to unset the channel key
[435]	1174	if key != "" {
	1175	ch.Key = key
	1176	}
	1177	uc.network.attach(ch)
	1178	} else {
	1179	ch = &Channel{
	1180	Name: upstreamName,
	1181	Key: key,
	1182	}
	1183	uc.network.channels[upstreamName] = ch
[285]	1184	}
[435]	1185	if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
[222]	1186	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
[89]	1187	}
	1188	}
[146]	1189	case "PART":
	1190	var namesStr string
	1191	if err := parseMessageParams(msg, &namesStr); err != nil {
	1192	return err
	1193	}
	1194
	1195	var reason string
	1196	if len(msg.Params) > 1 {
	1197	reason = msg.Params[1]
	1198	}
	1199
	1200	for _, name := range strings.Split(namesStr, ",") {
	1201	uc, upstreamName, err := dc.unmarshalEntity(name)
	1202	if err != nil {
[158]	1203	return err
[146]	1204	}
	1205
[284]	1206	if strings.EqualFold(reason, "detach") {
[435]	1207	var ch *Channel
	1208	var ok bool
	1209	if ch, ok = uc.network.channels[upstreamName]; ok {
	1210	uc.network.detach(ch)
	1211	} else {
	1212	ch = &Channel{
	1213	Name: name,
	1214	Detached: true,
	1215	}
	1216	uc.network.channels[upstreamName] = ch
[284]	1217	}
[435]	1218	if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
	1219	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
	1220	}
[284]	1221	} else {
	1222	params := []string{upstreamName}
	1223	if reason != "" {
	1224	params = append(params, reason)
	1225	}
[301]	1226	uc.SendMessageLabeled(dc.id, &irc.Message{
[284]	1227	Command: "PART",
	1228	Params: params,
	1229	})
[146]	1230
[284]	1231	if err := uc.network.deleteChannel(upstreamName); err != nil {
	1232	dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
	1233	}
[146]	1234	}
	1235	}
[159]	1236	case "KICK":
	1237	var channelStr, userStr string
	1238	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	1239	return err
	1240	}
	1241
	1242	channels := strings.Split(channelStr, ",")
	1243	users := strings.Split(userStr, ",")
	1244
	1245	var reason string
	1246	if len(msg.Params) > 2 {
	1247	reason = msg.Params[2]
	1248	}
	1249
	1250	if len(channels) != 1 && len(channels) != len(users) {
	1251	return ircError{&irc.Message{
	1252	Command: irc.ERR_BADCHANMASK,
	1253	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	1254	}}
	1255	}
	1256
	1257	for i, user := range users {
	1258	var channel string
	1259	if len(channels) == 1 {
	1260	channel = channels[0]
	1261	} else {
	1262	channel = channels[i]
	1263	}
	1264
	1265	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1266	if err != nil {
	1267	return err
	1268	}
	1269
	1270	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1271	if err != nil {
	1272	return err
	1273	}
	1274
	1275	if ucChannel != ucUser {
	1276	return ircError{&irc.Message{
	1277	Command: irc.ERR_USERNOTINCHANNEL,
[400]	1278	Params: []string{dc.nick, user, channel, "They are on another network"},
[159]	1279	}}
	1280	}
	1281	uc := ucChannel
	1282
	1283	params := []string{upstreamChannel, upstreamUser}
	1284	if reason != "" {
	1285	params = append(params, reason)
	1286	}
[301]	1287	uc.SendMessageLabeled(dc.id, &irc.Message{
[159]	1288	Command: "KICK",
	1289	Params: params,
	1290	})
	1291	}
[69]	1292	case "MODE":
[46]	1293	var name string
	1294	if err := parseMessageParams(msg, &name); err != nil {
	1295	return err
	1296	}
	1297
	1298	var modeStr string
	1299	if len(msg.Params) > 1 {
	1300	modeStr = msg.Params[1]
	1301	}
	1302
[139]	1303	if name == dc.nick {
[46]	1304	if modeStr != "" {
[73]	1305	dc.forEachUpstream(func(uc *upstreamConn) {
[301]	1306	uc.SendMessageLabeled(dc.id, &irc.Message{
[69]	1307	Command: "MODE",
	1308	Params: []string{uc.nick, modeStr},
	1309	})
[46]	1310	})
	1311	} else {
[55]	1312	dc.SendMessage(&irc.Message{
	1313	Prefix: dc.srv.prefix(),
[46]	1314	Command: irc.RPL_UMODEIS,
[129]	1315	Params: []string{dc.nick, ""}, // TODO
[54]	1316	})
[46]	1317	}
[139]	1318	return nil
[46]	1319	}
[139]	1320
	1321	uc, upstreamName, err := dc.unmarshalEntity(name)
	1322	if err != nil {
	1323	return err
	1324	}
	1325
	1326	if !uc.isChannel(upstreamName) {
	1327	return ircError{&irc.Message{
	1328	Command: irc.ERR_USERSDONTMATCH,
	1329	Params: []string{dc.nick, "Cannot change mode for other users"},
	1330	}}
	1331	}
	1332
	1333	if modeStr != "" {
	1334	params := []string{upstreamName, modeStr}
	1335	params = append(params, msg.Params[2:]...)
[301]	1336	uc.SendMessageLabeled(dc.id, &irc.Message{
[139]	1337	Command: "MODE",
	1338	Params: params,
	1339	})
	1340	} else {
	1341	ch, ok := uc.channels[upstreamName]
	1342	if !ok {
	1343	return ircError{&irc.Message{
	1344	Command: irc.ERR_NOSUCHCHANNEL,
	1345	Params: []string{dc.nick, name, "No such channel"},
	1346	}}
	1347	}
	1348
	1349	if ch.modes == nil {
	1350	// we haven't received the initial RPL_CHANNELMODEIS yet
	1351	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	1352	return nil
	1353	}
	1354
	1355	modeStr, modeParams := ch.modes.Format()
	1356	params := []string{dc.nick, name, modeStr}
	1357	params = append(params, modeParams...)
	1358
	1359	dc.SendMessage(&irc.Message{
	1360	Prefix: dc.srv.prefix(),
	1361	Command: irc.RPL_CHANNELMODEIS,
	1362	Params: params,
	1363	})
[162]	1364	if ch.creationTime != "" {
	1365	dc.SendMessage(&irc.Message{
	1366	Prefix: dc.srv.prefix(),
	1367	Command: rpl_creationtime,
	1368	Params: []string{dc.nick, name, ch.creationTime},
	1369	})
	1370	}
[139]	1371	}
[160]	1372	case "TOPIC":
	1373	var channel string
	1374	if err := parseMessageParams(msg, &channel); err != nil {
	1375	return err
	1376	}
	1377
	1378	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1379	if err != nil {
	1380	return err
	1381	}
	1382
	1383	if len(msg.Params) > 1 { // setting topic
	1384	topic := msg.Params[1]
[301]	1385	uc.SendMessageLabeled(dc.id, &irc.Message{
[160]	1386	Command: "TOPIC",
	1387	Params: []string{upstreamChannel, topic},
	1388	})
	1389	} else { // getting topic
	1390	ch, ok := uc.channels[upstreamChannel]
	1391	if !ok {
	1392	return ircError{&irc.Message{
	1393	Command: irc.ERR_NOSUCHCHANNEL,
	1394	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1395	}}
	1396	}
	1397	sendTopic(dc, ch)
	1398	}
[177]	1399	case "LIST":
	1400	// TODO: support ELIST when supported by all upstreams
	1401
	1402	pl := pendingLIST{
	1403	downstreamID: dc.id,
	1404	pendingCommands: make(map[int64]*irc.Message),
	1405	}
[298]	1406	var upstream *upstreamConn
[177]	1407	var upstreamChannels map[int64][]string
	1408	if len(msg.Params) > 0 {
[298]	1409	uc, upstreamMask, err := dc.unmarshalEntity(msg.Params[0])
	1410	if err == nil && upstreamMask == "" { // LIST /network: send LIST only to one network
	1411	upstream = uc
	1412	} else {
	1413	upstreamChannels = make(map[int64][]string)
	1414	channels := strings.Split(msg.Params[0], ",")
	1415	for _, channel := range channels {
	1416	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1417	if err != nil {
	1418	return err
	1419	}
	1420	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
[177]	1421	}
	1422	}
	1423	}
	1424
	1425	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1426	dc.forEachUpstream(func(uc *upstreamConn) {
[298]	1427	if upstream != nil && upstream != uc {
	1428	return
	1429	}
[177]	1430	var params []string
	1431	if upstreamChannels != nil {
	1432	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1433	params = []string{strings.Join(channels, ",")}
	1434	} else {
	1435	return
	1436	}
	1437	}
	1438	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1439	Command: "LIST",
	1440	Params: params,
	1441	}
[181]	1442	uc.trySendLIST(dc.id)
[177]	1443	})
[140]	1444	case "NAMES":
	1445	if len(msg.Params) == 0 {
	1446	dc.SendMessage(&irc.Message{
	1447	Prefix: dc.srv.prefix(),
	1448	Command: irc.RPL_ENDOFNAMES,
	1449	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1450	})
	1451	return nil
	1452	}
	1453
	1454	channels := strings.Split(msg.Params[0], ",")
	1455	for _, channel := range channels {
	1456	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1457	if err != nil {
	1458	return err
	1459	}
	1460
	1461	ch, ok := uc.channels[upstreamChannel]
	1462	if ok {
	1463	sendNames(dc, ch)
	1464	} else {
	1465	// NAMES on a channel we have not joined, ask upstream
[176]	1466	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1467	Command: "NAMES",
	1468	Params: []string{upstreamChannel},
	1469	})
	1470	}
	1471	}
[127]	1472	case "WHO":
	1473	if len(msg.Params) == 0 {
	1474	// TODO: support WHO without parameters
	1475	dc.SendMessage(&irc.Message{
	1476	Prefix: dc.srv.prefix(),
	1477	Command: irc.RPL_ENDOFWHO,
[140]	1478	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1479	})
	1480	return nil
	1481	}
	1482
	1483	// TODO: support WHO masks
	1484	entity := msg.Params[0]
	1485
[142]	1486	if entity == dc.nick {
	1487	// TODO: support AWAY (H/G) in self WHO reply
	1488	dc.SendMessage(&irc.Message{
	1489	Prefix: dc.srv.prefix(),
	1490	Command: irc.RPL_WHOREPLY,
[184]	1491	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1492	})
	1493	dc.SendMessage(&irc.Message{
	1494	Prefix: dc.srv.prefix(),
	1495	Command: irc.RPL_ENDOFWHO,
	1496	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1497	})
	1498	return nil
	1499	}
[343]	1500	if entity == serviceNick {
	1501	dc.SendMessage(&irc.Message{
	1502	Prefix: dc.srv.prefix(),
	1503	Command: irc.RPL_WHOREPLY,
	1504	Params: []string{serviceNick, "*", servicePrefix.User, servicePrefix.Host, dc.srv.Hostname, serviceNick, "H", "0 " + serviceRealname},
	1505	})
	1506	dc.SendMessage(&irc.Message{
	1507	Prefix: dc.srv.prefix(),
	1508	Command: irc.RPL_ENDOFWHO,
	1509	Params: []string{dc.nick, serviceNick, "End of /WHO list"},
	1510	})
	1511	return nil
	1512	}
[142]	1513
[127]	1514	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1515	if err != nil {
	1516	return err
	1517	}
	1518
	1519	var params []string
	1520	if len(msg.Params) == 2 {
	1521	params = []string{upstreamName, msg.Params[1]}
	1522	} else {
	1523	params = []string{upstreamName}
	1524	}
	1525
[176]	1526	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1527	Command: "WHO",
	1528	Params: params,
	1529	})
[128]	1530	case "WHOIS":
	1531	if len(msg.Params) == 0 {
	1532	return ircError{&irc.Message{
	1533	Command: irc.ERR_NONICKNAMEGIVEN,
	1534	Params: []string{dc.nick, "No nickname given"},
	1535	}}
	1536	}
	1537
	1538	var target, mask string
	1539	if len(msg.Params) == 1 {
	1540	target = ""
	1541	mask = msg.Params[0]
	1542	} else {
	1543	target = msg.Params[0]
	1544	mask = msg.Params[1]
	1545	}
	1546	// TODO: support multiple WHOIS users
	1547	if i := strings.IndexByte(mask, ','); i >= 0 {
	1548	mask = mask[:i]
	1549	}
	1550
[142]	1551	if mask == dc.nick {
	1552	dc.SendMessage(&irc.Message{
	1553	Prefix: dc.srv.prefix(),
	1554	Command: irc.RPL_WHOISUSER,
[184]	1555	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1556	})
	1557	dc.SendMessage(&irc.Message{
	1558	Prefix: dc.srv.prefix(),
	1559	Command: irc.RPL_WHOISSERVER,
	1560	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1561	})
	1562	dc.SendMessage(&irc.Message{
	1563	Prefix: dc.srv.prefix(),
	1564	Command: irc.RPL_ENDOFWHOIS,
	1565	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1566	})
	1567	return nil
	1568	}
	1569
[128]	1570	// TODO: support WHOIS masks
	1571	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1572	if err != nil {
	1573	return err
	1574	}
	1575
	1576	var params []string
	1577	if target != "" {
[299]	1578	if target == mask { // WHOIS nick nick
	1579	params = []string{upstreamNick, upstreamNick}
	1580	} else {
	1581	params = []string{target, upstreamNick}
	1582	}
[128]	1583	} else {
	1584	params = []string{upstreamNick}
	1585	}
	1586
[176]	1587	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1588	Command: "WHOIS",
	1589	Params: params,
	1590	})
[58]	1591	case "PRIVMSG":
	1592	var targetsStr, text string
	1593	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1594	return err
	1595	}
[303]	1596	tags := copyClientTags(msg.Tags)
[58]	1597
	1598	for _, name := range strings.Split(targetsStr, ",") {
[117]	1599	if name == serviceNick {
[431]	1600	if dc.caps["echo-message"] {
	1601	echoTags := tags.Copy()
	1602	echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
	1603	dc.SendMessage(&irc.Message{
	1604	Tags: echoTags,
	1605	Prefix: dc.prefix(),
	1606	Command: "PRIVMSG",
	1607	Params: []string{name, text},
	1608	})
	1609	}
[117]	1610	handleServicePRIVMSG(dc, text)
	1611	continue
	1612	}
	1613
[127]	1614	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1615	if err != nil {
	1616	return err
	1617	}
	1618
[95]	1619	if upstreamName == "NickServ" {
	1620	dc.handleNickServPRIVMSG(uc, text)
	1621	}
	1622
[268]	1623	unmarshaledText := text
	1624	if uc.isChannel(upstreamName) {
	1625	unmarshaledText = dc.unmarshalText(uc, text)
	1626	}
[301]	1627	uc.SendMessageLabeled(dc.id, &irc.Message{
[303]	1628	Tags: tags,
[58]	1629	Command: "PRIVMSG",
[268]	1630	Params: []string{upstreamName, unmarshaledText},
[60]	1631	})
[105]	1632
[303]	1633	echoTags := tags.Copy()
	1634	echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[113]	1635	echoMsg := &irc.Message{
[303]	1636	Tags: echoTags,
[113]	1637	Prefix: &irc.Prefix{
	1638	Name: uc.nick,
	1639	User: uc.username,
	1640	},
[114]	1641	Command: "PRIVMSG",
[113]	1642	Params: []string{upstreamName, text},
	1643	}
[239]	1644	uc.produce(upstreamName, echoMsg, dc)
[435]	1645
	1646	uc.updateChannelAutoDetach(upstreamName)
[58]	1647	}
[164]	1648	case "NOTICE":
	1649	var targetsStr, text string
	1650	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1651	return err
	1652	}
[303]	1653	tags := copyClientTags(msg.Tags)
[164]	1654
	1655	for _, name := range strings.Split(targetsStr, ",") {
	1656	uc, upstreamName, err := dc.unmarshalEntity(name)
	1657	if err != nil {
	1658	return err
	1659	}
	1660
[268]	1661	unmarshaledText := text
	1662	if uc.isChannel(upstreamName) {
	1663	unmarshaledText = dc.unmarshalText(uc, text)
	1664	}
[301]	1665	uc.SendMessageLabeled(dc.id, &irc.Message{
[303]	1666	Tags: tags,
[164]	1667	Command: "NOTICE",
[268]	1668	Params: []string{upstreamName, unmarshaledText},
[164]	1669	})
[435]	1670
	1671	uc.updateChannelAutoDetach(upstreamName)
[164]	1672	}
[303]	1673	case "TAGMSG":
	1674	var targetsStr string
	1675	if err := parseMessageParams(msg, &targetsStr); err != nil {
	1676	return err
	1677	}
	1678	tags := copyClientTags(msg.Tags)
	1679
	1680	for _, name := range strings.Split(targetsStr, ",") {
	1681	uc, upstreamName, err := dc.unmarshalEntity(name)
	1682	if err != nil {
	1683	return err
	1684	}
[427]	1685	if _, ok := uc.caps["message-tags"]; !ok {
	1686	continue
	1687	}
[303]	1688
	1689	uc.SendMessageLabeled(dc.id, &irc.Message{
	1690	Tags: tags,
	1691	Command: "TAGMSG",
	1692	Params: []string{upstreamName},
	1693	})
[435]	1694
	1695	uc.updateChannelAutoDetach(upstreamName)
[303]	1696	}
[163]	1697	case "INVITE":
	1698	var user, channel string
	1699	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1700	return err
	1701	}
	1702
	1703	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1704	if err != nil {
	1705	return err
	1706	}
	1707
	1708	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1709	if err != nil {
	1710	return err
	1711	}
	1712
	1713	if ucChannel != ucUser {
	1714	return ircError{&irc.Message{
	1715	Command: irc.ERR_USERNOTINCHANNEL,
[401]	1716	Params: []string{dc.nick, user, channel, "They are on another network"},
[163]	1717	}}
	1718	}
	1719	uc := ucChannel
	1720
[176]	1721	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1722	Command: "INVITE",
	1723	Params: []string{upstreamUser, upstreamChannel},
	1724	})
[319]	1725	case "CHATHISTORY":
	1726	var subcommand string
	1727	if err := parseMessageParams(msg, &subcommand); err != nil {
	1728	return err
	1729	}
	1730	var target, criteria, limitStr string
	1731	if err := parseMessageParams(msg, nil, &target, &criteria, &limitStr); err != nil {
	1732	return ircError{&irc.Message{
	1733	Command: "FAIL",
	1734	Params: []string{"CHATHISTORY", "NEED_MORE_PARAMS", subcommand, "Missing parameters"},
	1735	}}
	1736	}
	1737
[423]	1738	if dc.user.msgStore == nil {
[319]	1739	return ircError{&irc.Message{
	1740	Command: irc.ERR_UNKNOWNCOMMAND,
	1741	Params: []string{dc.nick, subcommand, "Unknown command"},
	1742	}}
	1743	}
	1744
	1745	uc, entity, err := dc.unmarshalEntity(target)
	1746	if err != nil {
	1747	return err
	1748	}
	1749
	1750	// TODO: support msgid criteria
	1751	criteriaParts := strings.SplitN(criteria, "=", 2)
	1752	if len(criteriaParts) != 2 \|\| criteriaParts[0] != "timestamp" {
	1753	return ircError{&irc.Message{
	1754	Command: "FAIL",
	1755	Params: []string{"CHATHISTORY", "UNKNOWN_CRITERIA", criteria, "Unknown criteria"},
	1756	}}
	1757	}
	1758
	1759	timestamp, err := time.Parse(serverTimeLayout, criteriaParts[1])
	1760	if err != nil {
	1761	return ircError{&irc.Message{
	1762	Command: "FAIL",
	1763	Params: []string{"CHATHISTORY", "INVALID_CRITERIA", criteria, "Invalid criteria"},
	1764	}}
	1765	}
	1766
	1767	limit, err := strconv.Atoi(limitStr)
	1768	if err != nil \|\| limit < 0 \|\| limit > dc.srv.HistoryLimit {
	1769	return ircError{&irc.Message{
	1770	Command: "FAIL",
	1771	Params: []string{"CHATHISTORY", "INVALID_LIMIT", limitStr, "Invalid limit"},
	1772	}}
	1773	}
	1774
[387]	1775	var history []*irc.Message
[319]	1776	switch subcommand {
	1777	case "BEFORE":
[423]	1778	history, err = dc.user.msgStore.LoadBeforeTime(uc.network, entity, timestamp, limit)
[360]	1779	case "AFTER":
[423]	1780	history, err = dc.user.msgStore.LoadAfterTime(uc.network, entity, timestamp, limit)
[319]	1781	default:
[360]	1782	// TODO: support LATEST, BETWEEN
[319]	1783	return ircError{&irc.Message{
	1784	Command: "FAIL",
	1785	Params: []string{"CHATHISTORY", "UNKNOWN_COMMAND", subcommand, "Unknown command"},
	1786	}}
	1787	}
[387]	1788	if err != nil {
	1789	dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
	1790	return newChatHistoryError(subcommand, target)
	1791	}
	1792
	1793	batchRef := "history"
	1794	dc.SendMessage(&irc.Message{
	1795	Prefix: dc.srv.prefix(),
	1796	Command: "BATCH",
	1797	Params: []string{"+" + batchRef, "chathistory", target},
	1798	})
	1799
	1800	for _, msg := range history {
	1801	msg.Tags["batch"] = irc.TagValue(batchRef)
	1802	dc.SendMessage(dc.marshalMessage(msg, uc.network))
	1803	}
	1804
	1805	dc.SendMessage(&irc.Message{
	1806	Prefix: dc.srv.prefix(),
	1807	Command: "BATCH",
	1808	Params: []string{"-" + batchRef},
	1809	})
[13]	1810	default:
[55]	1811	dc.logger.Printf("unhandled message: %v", msg)
[13]	1812	return newUnknownCommandError(msg.Command)
	1813	}
[42]	1814	return nil
[13]	1815	}
[95]	1816
	1817	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1818	username, password, ok := parseNickServCredentials(text, uc.nick)
	1819	if !ok {
	1820	return
	1821	}
	1822
[307]	1823	// User may have e.g. EXTERNAL mechanism configured. We do not want to
	1824	// automatically erase the key pair or any other credentials.
	1825	if uc.network.SASL.Mechanism != "" && uc.network.SASL.Mechanism != "PLAIN" {
	1826	return
	1827	}
	1828
[95]	1829	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1830	n := uc.network
	1831	n.SASL.Mechanism = "PLAIN"
	1832	n.SASL.Plain.Username = username
	1833	n.SASL.Plain.Password = password
[421]	1834	if err := dc.srv.db.StoreNetwork(dc.user.ID, &n.Network); err != nil {
[95]	1835	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1836	}
	1837	}
	1838
	1839	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1840	fields := strings.Fields(text)
	1841	if len(fields) < 2 {
	1842	return "", "", false
	1843	}
	1844	cmd := strings.ToUpper(fields[0])
	1845	params := fields[1:]
	1846	switch cmd {
	1847	case "REGISTER":
	1848	username = nick
	1849	password = params[0]
	1850	case "IDENTIFY":
	1851	if len(params) == 1 {
	1852	username = nick
[182]	1853	password = params[0]
[95]	1854	} else {
	1855	username = params[0]
[182]	1856	password = params[1]
[95]	1857	}
[182]	1858	case "SET":
	1859	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1860	username = nick
	1861	password = params[1]
	1862	}
[340]	1863	default:
	1864	return "", "", false
[95]	1865	}
	1866	return username, password, true
	1867	}

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

Download in other formats: