Context Navigation

source: code/trunk/downstream.go@ 286

Last change on this file since 286 was 285, checked in by contact, 5 years ago

Don't clear channel key on JOIN

Closes: https://todo.sr.ht/~emersion/soju/50

File size: 34.5 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 {
[284]	770	if !ch.complete {
	771	continue
	772	}
	773	if record, ok := uc.network.channels[ch.Name]; ok && record.Detached {
	774	continue
	775	}
[132]	776
[284]	777	dc.SendMessage(&irc.Message{
	778	Prefix: dc.prefix(),
	779	Command: "JOIN",
	780	Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
	781	})
	782
	783	forwardChannel(dc, ch)
[30]	784	}
[143]	785	})
[50]	786
[143]	787	dc.forEachNetwork(func(net *network) {
[253]	788	// Only send history if we're the first connected client with that name
	789	// for the network
	790	if _, ok := net.offlineClients[dc.clientName]; ok {
	791	dc.sendNetworkHistory(net)
	792	delete(net.offlineClients, dc.clientName)
[227]	793	}
[253]	794	})
[57]	795
[253]	796	return nil
	797	}
[144]	798
[253]	799	func (dc downstreamConn) sendNetworkHistory(net network) {
	800	for target, history := range net.history {
[284]	801	if ch, ok := net.channels[target]; ok && ch.Detached {
	802	continue
	803	}
	804
[253]	805	seq, ok := history.offlineClients[dc.clientName]
	806	if !ok {
	807	continue
	808	}
	809	delete(history.offlineClients, dc.clientName)
	810
	811	// If all clients have received history, no need to keep the
	812	// ring buffer around
	813	if len(history.offlineClients) == 0 {
	814	delete(net.history, target)
	815	}
	816
	817	consumer := history.ring.NewConsumer(seq)
	818
[256]	819	batchRef := "history"
	820	if dc.caps["batch"] {
	821	dc.SendMessage(&irc.Message{
	822	Prefix: dc.srv.prefix(),
	823	Command: "BATCH",
[260]	824	Params: []string{"+" + batchRef, "chathistory", dc.marshalEntity(net, target)},
[256]	825	})
	826	}
	827
[227]	828	for {
[233]	829	msg := consumer.Consume()
[227]	830	if msg == nil {
	831	break
[204]	832	}
	833
[245]	834	// Don't replay all messages, because that would mess up client
	835	// state. For instance we just sent the list of users, sending
	836	// PART messages for one of these users would be incorrect.
	837	ignore := true
	838	switch msg.Command {
	839	case "PRIVMSG", "NOTICE":
	840	ignore = false
	841	}
	842	if ignore {
	843	continue
	844	}
	845
[256]	846	if dc.caps["batch"] {
	847	msg = msg.Copy()
	848	msg.Tags["batch"] = irc.TagValue(batchRef)
	849	}
	850
[261]	851	dc.SendMessage(dc.marshalMessage(msg, net))
[227]	852	}
[256]	853
	854	if dc.caps["batch"] {
	855	dc.SendMessage(&irc.Message{
	856	Prefix: dc.srv.prefix(),
	857	Command: "BATCH",
	858	Params: []string{"-" + batchRef},
	859	})
	860	}
[253]	861	}
[13]	862	}
	863
[103]	864	func (dc *downstreamConn) runUntilRegistered() error {
	865	for !dc.registered {
[212]	866	msg, err := dc.ReadMessage()
[106]	867	if err != nil {
[103]	868	return fmt.Errorf("failed to read IRC command: %v", err)
	869	}
	870
	871	err = dc.handleMessage(msg)
	872	if ircErr, ok := err.(ircError); ok {
	873	ircErr.Message.Prefix = dc.srv.prefix()
	874	dc.SendMessage(ircErr.Message)
	875	} else if err != nil {
	876	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	877	}
	878	}
	879
	880	return nil
	881	}
	882
[55]	883	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	884	switch msg.Command {
[111]	885	case "CAP":
	886	var subCmd string
	887	if err := parseMessageParams(msg, &subCmd); err != nil {
	888	return err
	889	}
	890	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	891	return err
	892	}
[107]	893	case "PING":
	894	dc.SendMessage(&irc.Message{
	895	Prefix: dc.srv.prefix(),
	896	Command: "PONG",
	897	Params: msg.Params,
	898	})
	899	return nil
[42]	900	case "USER":
[13]	901	return ircError{&irc.Message{
	902	Command: irc.ERR_ALREADYREGISTERED,
[55]	903	Params: []string{dc.nick, "You may not reregister"},
[13]	904	}}
[42]	905	case "NICK":
[90]	906	var nick string
	907	if err := parseMessageParams(msg, &nick); err != nil {
	908	return err
	909	}
	910
	911	var err error
	912	dc.forEachNetwork(func(n *network) {
	913	if err != nil {
	914	return
	915	}
	916	n.Nick = nick
	917	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	918	})
	919	if err != nil {
	920	return err
	921	}
	922
[73]	923	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	924	uc.SendMessage(msg)
[42]	925	})
[146]	926	case "JOIN":
	927	var namesStr string
	928	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	929	return err
	930	}
	931
[146]	932	var keys []string
	933	if len(msg.Params) > 1 {
	934	keys = strings.Split(msg.Params[1], ",")
	935	}
	936
	937	for i, name := range strings.Split(namesStr, ",") {
[145]	938	uc, upstreamName, err := dc.unmarshalEntity(name)
	939	if err != nil {
[158]	940	return err
[145]	941	}
[48]	942
[146]	943	var key string
	944	if len(keys) > i {
	945	key = keys[i]
	946	}
	947
	948	params := []string{upstreamName}
	949	if key != "" {
	950	params = append(params, key)
	951	}
[145]	952	uc.SendMessage(&irc.Message{
[146]	953	Command: "JOIN",
	954	Params: params,
[145]	955	})
[89]	956
[284]	957	ch := &Channel{Name: upstreamName, Key: key, Detached: false}
[285]	958	if current, ok := uc.network.channels[ch.Name]; ok && key == "" {
	959	// Don't clear the channel key if there's one set
	960	// TODO: add a way to unset the channel key
	961	ch.Key = current.Key
	962	}
[222]	963	if err := uc.network.createUpdateChannel(ch); err != nil {
	964	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
[89]	965	}
	966	}
[146]	967	case "PART":
	968	var namesStr string
	969	if err := parseMessageParams(msg, &namesStr); err != nil {
	970	return err
	971	}
	972
	973	var reason string
	974	if len(msg.Params) > 1 {
	975	reason = msg.Params[1]
	976	}
	977
	978	for _, name := range strings.Split(namesStr, ",") {
	979	uc, upstreamName, err := dc.unmarshalEntity(name)
	980	if err != nil {
[158]	981	return err
[146]	982	}
	983
[284]	984	if strings.EqualFold(reason, "detach") {
	985	ch := &Channel{Name: upstreamName, Detached: true}
	986	if err := uc.network.createUpdateChannel(ch); err != nil {
	987	dc.logger.Printf("failed to detach channel %q: %v", upstreamName, err)
	988	}
	989	} else {
	990	params := []string{upstreamName}
	991	if reason != "" {
	992	params = append(params, reason)
	993	}
	994	uc.SendMessage(&irc.Message{
	995	Command: "PART",
	996	Params: params,
	997	})
[146]	998
[284]	999	if err := uc.network.deleteChannel(upstreamName); err != nil {
	1000	dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
	1001	}
[146]	1002	}
	1003	}
[159]	1004	case "KICK":
	1005	var channelStr, userStr string
	1006	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	1007	return err
	1008	}
	1009
	1010	channels := strings.Split(channelStr, ",")
	1011	users := strings.Split(userStr, ",")
	1012
	1013	var reason string
	1014	if len(msg.Params) > 2 {
	1015	reason = msg.Params[2]
	1016	}
	1017
	1018	if len(channels) != 1 && len(channels) != len(users) {
	1019	return ircError{&irc.Message{
	1020	Command: irc.ERR_BADCHANMASK,
	1021	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	1022	}}
	1023	}
	1024
	1025	for i, user := range users {
	1026	var channel string
	1027	if len(channels) == 1 {
	1028	channel = channels[0]
	1029	} else {
	1030	channel = channels[i]
	1031	}
	1032
	1033	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1034	if err != nil {
	1035	return err
	1036	}
	1037
	1038	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1039	if err != nil {
	1040	return err
	1041	}
	1042
	1043	if ucChannel != ucUser {
	1044	return ircError{&irc.Message{
	1045	Command: irc.ERR_USERNOTINCHANNEL,
	1046	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1047	}}
	1048	}
	1049	uc := ucChannel
	1050
	1051	params := []string{upstreamChannel, upstreamUser}
	1052	if reason != "" {
	1053	params = append(params, reason)
	1054	}
	1055	uc.SendMessage(&irc.Message{
	1056	Command: "KICK",
	1057	Params: params,
	1058	})
	1059	}
[69]	1060	case "MODE":
[46]	1061	var name string
	1062	if err := parseMessageParams(msg, &name); err != nil {
	1063	return err
	1064	}
	1065
	1066	var modeStr string
	1067	if len(msg.Params) > 1 {
	1068	modeStr = msg.Params[1]
	1069	}
	1070
[139]	1071	if name == dc.nick {
[46]	1072	if modeStr != "" {
[73]	1073	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	1074	uc.SendMessage(&irc.Message{
	1075	Command: "MODE",
	1076	Params: []string{uc.nick, modeStr},
	1077	})
[46]	1078	})
	1079	} else {
[55]	1080	dc.SendMessage(&irc.Message{
	1081	Prefix: dc.srv.prefix(),
[46]	1082	Command: irc.RPL_UMODEIS,
[129]	1083	Params: []string{dc.nick, ""}, // TODO
[54]	1084	})
[46]	1085	}
[139]	1086	return nil
[46]	1087	}
[139]	1088
	1089	uc, upstreamName, err := dc.unmarshalEntity(name)
	1090	if err != nil {
	1091	return err
	1092	}
	1093
	1094	if !uc.isChannel(upstreamName) {
	1095	return ircError{&irc.Message{
	1096	Command: irc.ERR_USERSDONTMATCH,
	1097	Params: []string{dc.nick, "Cannot change mode for other users"},
	1098	}}
	1099	}
	1100
	1101	if modeStr != "" {
	1102	params := []string{upstreamName, modeStr}
	1103	params = append(params, msg.Params[2:]...)
	1104	uc.SendMessage(&irc.Message{
	1105	Command: "MODE",
	1106	Params: params,
	1107	})
	1108	} else {
	1109	ch, ok := uc.channels[upstreamName]
	1110	if !ok {
	1111	return ircError{&irc.Message{
	1112	Command: irc.ERR_NOSUCHCHANNEL,
	1113	Params: []string{dc.nick, name, "No such channel"},
	1114	}}
	1115	}
	1116
	1117	if ch.modes == nil {
	1118	// we haven't received the initial RPL_CHANNELMODEIS yet
	1119	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	1120	return nil
	1121	}
	1122
	1123	modeStr, modeParams := ch.modes.Format()
	1124	params := []string{dc.nick, name, modeStr}
	1125	params = append(params, modeParams...)
	1126
	1127	dc.SendMessage(&irc.Message{
	1128	Prefix: dc.srv.prefix(),
	1129	Command: irc.RPL_CHANNELMODEIS,
	1130	Params: params,
	1131	})
[162]	1132	if ch.creationTime != "" {
	1133	dc.SendMessage(&irc.Message{
	1134	Prefix: dc.srv.prefix(),
	1135	Command: rpl_creationtime,
	1136	Params: []string{dc.nick, name, ch.creationTime},
	1137	})
	1138	}
[139]	1139	}
[160]	1140	case "TOPIC":
	1141	var channel string
	1142	if err := parseMessageParams(msg, &channel); err != nil {
	1143	return err
	1144	}
	1145
	1146	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1147	if err != nil {
	1148	return err
	1149	}
	1150
	1151	if len(msg.Params) > 1 { // setting topic
	1152	topic := msg.Params[1]
	1153	uc.SendMessage(&irc.Message{
	1154	Command: "TOPIC",
	1155	Params: []string{upstreamChannel, topic},
	1156	})
	1157	} else { // getting topic
	1158	ch, ok := uc.channels[upstreamChannel]
	1159	if !ok {
	1160	return ircError{&irc.Message{
	1161	Command: irc.ERR_NOSUCHCHANNEL,
	1162	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1163	}}
	1164	}
	1165	sendTopic(dc, ch)
	1166	}
[177]	1167	case "LIST":
	1168	// TODO: support ELIST when supported by all upstreams
	1169
	1170	pl := pendingLIST{
	1171	downstreamID: dc.id,
	1172	pendingCommands: make(map[int64]*irc.Message),
	1173	}
	1174	var upstreamChannels map[int64][]string
	1175	if len(msg.Params) > 0 {
	1176	upstreamChannels = make(map[int64][]string)
	1177	channels := strings.Split(msg.Params[0], ",")
	1178	for _, channel := range channels {
	1179	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1180	if err != nil {
	1181	return err
	1182	}
	1183	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1184	}
	1185	}
	1186
	1187	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1188	dc.forEachUpstream(func(uc *upstreamConn) {
	1189	var params []string
	1190	if upstreamChannels != nil {
	1191	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1192	params = []string{strings.Join(channels, ",")}
	1193	} else {
	1194	return
	1195	}
	1196	}
	1197	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1198	Command: "LIST",
	1199	Params: params,
	1200	}
[181]	1201	uc.trySendLIST(dc.id)
[177]	1202	})
[140]	1203	case "NAMES":
	1204	if len(msg.Params) == 0 {
	1205	dc.SendMessage(&irc.Message{
	1206	Prefix: dc.srv.prefix(),
	1207	Command: irc.RPL_ENDOFNAMES,
	1208	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1209	})
	1210	return nil
	1211	}
	1212
	1213	channels := strings.Split(msg.Params[0], ",")
	1214	for _, channel := range channels {
	1215	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1216	if err != nil {
	1217	return err
	1218	}
	1219
	1220	ch, ok := uc.channels[upstreamChannel]
	1221	if ok {
	1222	sendNames(dc, ch)
	1223	} else {
	1224	// NAMES on a channel we have not joined, ask upstream
[176]	1225	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1226	Command: "NAMES",
	1227	Params: []string{upstreamChannel},
	1228	})
	1229	}
	1230	}
[127]	1231	case "WHO":
	1232	if len(msg.Params) == 0 {
	1233	// TODO: support WHO without parameters
	1234	dc.SendMessage(&irc.Message{
	1235	Prefix: dc.srv.prefix(),
	1236	Command: irc.RPL_ENDOFWHO,
[140]	1237	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1238	})
	1239	return nil
	1240	}
	1241
	1242	// TODO: support WHO masks
	1243	entity := msg.Params[0]
	1244
[142]	1245	if entity == dc.nick {
	1246	// TODO: support AWAY (H/G) in self WHO reply
	1247	dc.SendMessage(&irc.Message{
	1248	Prefix: dc.srv.prefix(),
	1249	Command: irc.RPL_WHOREPLY,
[184]	1250	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1251	})
	1252	dc.SendMessage(&irc.Message{
	1253	Prefix: dc.srv.prefix(),
	1254	Command: irc.RPL_ENDOFWHO,
	1255	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1256	})
	1257	return nil
	1258	}
	1259
[127]	1260	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1261	if err != nil {
	1262	return err
	1263	}
	1264
	1265	var params []string
	1266	if len(msg.Params) == 2 {
	1267	params = []string{upstreamName, msg.Params[1]}
	1268	} else {
	1269	params = []string{upstreamName}
	1270	}
	1271
[176]	1272	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1273	Command: "WHO",
	1274	Params: params,
	1275	})
[128]	1276	case "WHOIS":
	1277	if len(msg.Params) == 0 {
	1278	return ircError{&irc.Message{
	1279	Command: irc.ERR_NONICKNAMEGIVEN,
	1280	Params: []string{dc.nick, "No nickname given"},
	1281	}}
	1282	}
	1283
	1284	var target, mask string
	1285	if len(msg.Params) == 1 {
	1286	target = ""
	1287	mask = msg.Params[0]
	1288	} else {
	1289	target = msg.Params[0]
	1290	mask = msg.Params[1]
	1291	}
	1292	// TODO: support multiple WHOIS users
	1293	if i := strings.IndexByte(mask, ','); i >= 0 {
	1294	mask = mask[:i]
	1295	}
	1296
[142]	1297	if mask == dc.nick {
	1298	dc.SendMessage(&irc.Message{
	1299	Prefix: dc.srv.prefix(),
	1300	Command: irc.RPL_WHOISUSER,
[184]	1301	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1302	})
	1303	dc.SendMessage(&irc.Message{
	1304	Prefix: dc.srv.prefix(),
	1305	Command: irc.RPL_WHOISSERVER,
	1306	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1307	})
	1308	dc.SendMessage(&irc.Message{
	1309	Prefix: dc.srv.prefix(),
	1310	Command: irc.RPL_ENDOFWHOIS,
	1311	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1312	})
	1313	return nil
	1314	}
	1315
[128]	1316	// TODO: support WHOIS masks
	1317	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1318	if err != nil {
	1319	return err
	1320	}
	1321
	1322	var params []string
	1323	if target != "" {
	1324	params = []string{target, upstreamNick}
	1325	} else {
	1326	params = []string{upstreamNick}
	1327	}
	1328
[176]	1329	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1330	Command: "WHOIS",
	1331	Params: params,
	1332	})
[58]	1333	case "PRIVMSG":
	1334	var targetsStr, text string
	1335	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1336	return err
	1337	}
	1338
	1339	for _, name := range strings.Split(targetsStr, ",") {
[117]	1340	if name == serviceNick {
	1341	handleServicePRIVMSG(dc, text)
	1342	continue
	1343	}
	1344
[127]	1345	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1346	if err != nil {
	1347	return err
	1348	}
	1349
[95]	1350	if upstreamName == "NickServ" {
	1351	dc.handleNickServPRIVMSG(uc, text)
	1352	}
	1353
[268]	1354	unmarshaledText := text
	1355	if uc.isChannel(upstreamName) {
	1356	unmarshaledText = dc.unmarshalText(uc, text)
	1357	}
[69]	1358	uc.SendMessage(&irc.Message{
[58]	1359	Command: "PRIVMSG",
[268]	1360	Params: []string{upstreamName, unmarshaledText},
[60]	1361	})
[105]	1362
[113]	1363	echoMsg := &irc.Message{
	1364	Prefix: &irc.Prefix{
	1365	Name: uc.nick,
	1366	User: uc.username,
	1367	},
[114]	1368	Command: "PRIVMSG",
[113]	1369	Params: []string{upstreamName, text},
	1370	}
[105]	1371
[239]	1372	uc.produce(upstreamName, echoMsg, dc)
[58]	1373	}
[164]	1374	case "NOTICE":
	1375	var targetsStr, text string
	1376	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1377	return err
	1378	}
	1379
	1380	for _, name := range strings.Split(targetsStr, ",") {
	1381	uc, upstreamName, err := dc.unmarshalEntity(name)
	1382	if err != nil {
	1383	return err
	1384	}
	1385
[268]	1386	unmarshaledText := text
	1387	if uc.isChannel(upstreamName) {
	1388	unmarshaledText = dc.unmarshalText(uc, text)
	1389	}
[164]	1390	uc.SendMessage(&irc.Message{
	1391	Command: "NOTICE",
[268]	1392	Params: []string{upstreamName, unmarshaledText},
[164]	1393	})
	1394	}
[163]	1395	case "INVITE":
	1396	var user, channel string
	1397	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1398	return err
	1399	}
	1400
	1401	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1402	if err != nil {
	1403	return err
	1404	}
	1405
	1406	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1407	if err != nil {
	1408	return err
	1409	}
	1410
	1411	if ucChannel != ucUser {
	1412	return ircError{&irc.Message{
	1413	Command: irc.ERR_USERNOTINCHANNEL,
	1414	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1415	}}
	1416	}
	1417	uc := ucChannel
	1418
[176]	1419	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1420	Command: "INVITE",
	1421	Params: []string{upstreamUser, upstreamChannel},
	1422	})
[13]	1423	default:
[55]	1424	dc.logger.Printf("unhandled message: %v", msg)
[13]	1425	return newUnknownCommandError(msg.Command)
	1426	}
[42]	1427	return nil
[13]	1428	}
[95]	1429
	1430	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1431	username, password, ok := parseNickServCredentials(text, uc.nick)
	1432	if !ok {
	1433	return
	1434	}
	1435
	1436	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1437	n := uc.network
	1438	n.SASL.Mechanism = "PLAIN"
	1439	n.SASL.Plain.Username = username
	1440	n.SASL.Plain.Password = password
	1441	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1442	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1443	}
	1444	}
	1445
	1446	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1447	fields := strings.Fields(text)
	1448	if len(fields) < 2 {
	1449	return "", "", false
	1450	}
	1451	cmd := strings.ToUpper(fields[0])
	1452	params := fields[1:]
	1453	switch cmd {
	1454	case "REGISTER":
	1455	username = nick
	1456	password = params[0]
	1457	case "IDENTIFY":
	1458	if len(params) == 1 {
	1459	username = nick
[182]	1460	password = params[0]
[95]	1461	} else {
	1462	username = params[0]
[182]	1463	password = params[1]
[95]	1464	}
[182]	1465	case "SET":
	1466	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1467	username = nick
	1468	password = params[1]
	1469	}
[95]	1470	}
	1471	return username, password, true
	1472	}

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

Download in other formats: