Context Navigation

downstream.go@ 292

Last change on this file since 292 was 292, checked in by delthas, 5 years ago

Add support for multiple user channel memberships

User channel memberships are actually a set of memberships, not a single
value. This introduces memberships, a type representing a set of
memberships, stored as an array of memberships ordered by descending
rank.

This also adds multi-prefix to the permanent downstream and upstream
capabilities, so that we try to get all possible channel memberships.

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

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

Context Navigation

source: code/trunk/downstream.go@ 292

Download in other formats: