Context Navigation

source: code/trunk/downstream.go@ 349

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

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

Download in other formats: