Context Navigation

source: code/trunk/downstream.go@ 280

Last change on this file since 280 was 279, checked in by contact, 5 years ago

Remove network.upstream

This is an artifact from when we used locks. No need for this anymore.

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

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

Download in other formats: