Context Navigation

source: code/trunk/upstream.go@ 244

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

Fix upstream NICK handling

uc.nicl was compared to msg.Prefix.Name after being updated to the new nick
The new nick wasn't marshaled

File size: 34.1 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
	4	"crypto/tls"
[95]	5	"encoding/base64"
[155]	6	"errors"
[13]	7	"fmt"
	8	"io"
	9	"net"
[19]	10	"strconv"
[17]	11	"strings"
[19]	12	"time"
[13]	13
[95]	14	"github.com/emersion/go-sasl"
[13]	15	"gopkg.in/irc.v3"
	16	)
	17
[19]	18	type upstreamChannel struct {
[162]	19	Name string
	20	conn *upstreamConn
	21	Topic string
	22	TopicWho string
	23	TopicTime time.Time
	24	Status channelStatus
	25	modes channelModes
	26	creationTime string
	27	Members map[string]*membership
	28	complete bool
[19]	29	}
	30
[13]	31	type upstreamConn struct {
[210]	32	conn
[16]	33
[210]	34	network *network
	35	user *user
	36
[16]	37	serverName string
	38	availableUserModes string
[139]	39	availableChannelModes map[byte]channelModeType
	40	availableChannelTypes string
	41	availableMemberships []membership
[19]	42
	43	registered bool
[42]	44	nick string
[77]	45	username string
	46	realname string
[139]	47	modes userModes
[19]	48	channels map[string]*upstreamChannel
[92]	49	caps map[string]string
[153]	50	batches map[string]batch
[198]	51	away bool
[95]	52
[155]	53	tagsSupported bool
	54	labelsSupported bool
[161]	55	nextLabelID uint64
[152]	56
[95]	57	saslClient sasl.Client
	58	saslStarted bool
[177]	59
	60	// set of LIST commands in progress, per downstream
	61	pendingLISTDownstreamSet map[uint64]struct{}
[178]	62
[215]	63	messageLoggers map[string]*messageLogger
[13]	64	}
	65
[77]	66	func connectToUpstream(network network) (upstreamConn, error) {
	67	logger := &prefixLogger{network.user.srv.Logger, fmt.Sprintf("upstream %q: ", network.Addr)}
[33]	68
[77]	69	addr := network.Addr
	70	if !strings.ContainsRune(addr, ':') {
	71	addr = addr + ":6697"
	72	}
	73
[206]	74	dialer := net.Dialer{Timeout: connectTimeout}
	75
[77]	76	logger.Printf("connecting to TLS server at address %q", addr)
[206]	77	netConn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
[33]	78	if err != nil {
[77]	79	return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
[33]	80	}
	81
[55]	82	uc := &upstreamConn{
[210]	83	conn: *newConn(network.user.srv, netConn, logger),
[177]	84	network: network,
	85	user: network.user,
	86	channels: make(map[string]*upstreamChannel),
	87	caps: make(map[string]string),
	88	batches: make(map[string]batch),
	89	availableChannelTypes: stdChannelTypes,
	90	availableChannelModes: stdChannelModes,
	91	availableMemberships: stdMemberships,
	92	pendingLISTDownstreamSet: make(map[uint64]struct{}),
[215]	93	messageLoggers: make(map[string]*messageLogger),
[33]	94	}
	95
[55]	96	return uc, nil
[33]	97	}
	98
[73]	99	func (uc upstreamConn) forEachDownstream(f func(downstreamConn)) {
[218]	100	uc.network.forEachDownstream(f)
[73]	101	}
	102
[161]	103	func (uc upstreamConn) forEachDownstreamByID(id uint64, f func(downstreamConn)) {
[155]	104	uc.forEachDownstream(func(dc *downstreamConn) {
	105	if id != 0 && id != dc.id {
	106	return
	107	}
	108	f(dc)
	109	})
	110	}
	111
[55]	112	func (uc upstreamConn) getChannel(name string) (upstreamChannel, error) {
	113	ch, ok := uc.channels[name]
[19]	114	if !ok {
	115	return nil, fmt.Errorf("unknown channel %q", name)
	116	}
	117	return ch, nil
	118	}
	119
[129]	120	func (uc *upstreamConn) isChannel(entity string) bool {
[139]	121	if i := strings.IndexByte(uc.availableChannelTypes, entity[0]); i >= 0 {
	122	return true
[129]	123	}
	124	return false
	125	}
	126
[181]	127	func (uc upstreamConn) getPendingLIST() pendingLIST {
[177]	128	for _, pl := range uc.user.pendingLISTs {
	129	if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
	130	continue
	131	}
	132	return &pl
	133	}
	134	return nil
	135	}
	136
[181]	137	func (uc *upstreamConn) endPendingLISTs(all bool) (found bool) {
[177]	138	found = false
	139	for i := 0; i < len(uc.user.pendingLISTs); i++ {
	140	pl := uc.user.pendingLISTs[i]
	141	if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
	142	continue
	143	}
	144	delete(pl.pendingCommands, uc.network.ID)
	145	if len(pl.pendingCommands) == 0 {
	146	uc.user.pendingLISTs = append(uc.user.pendingLISTs[:i], uc.user.pendingLISTs[i+1:]...)
	147	i--
	148	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	149	dc.SendMessage(&irc.Message{
	150	Prefix: dc.srv.prefix(),
	151	Command: irc.RPL_LISTEND,
	152	Params: []string{dc.nick, "End of /LIST"},
	153	})
	154	})
	155	}
	156	found = true
	157	if !all {
	158	delete(uc.pendingLISTDownstreamSet, pl.downstreamID)
	159	uc.user.forEachUpstream(func(uc *upstreamConn) {
[181]	160	uc.trySendLIST(pl.downstreamID)
[177]	161	})
	162	return
	163	}
	164	}
	165	return
	166	}
	167
[181]	168	func (uc *upstreamConn) trySendLIST(downstreamID uint64) {
[177]	169	// must be called with a lock in uc.user.pendingLISTsLock
	170
	171	if _, ok := uc.pendingLISTDownstreamSet[downstreamID]; ok {
	172	// a LIST command is already pending
	173	// we will try again when that command is completed
	174	return
	175	}
	176
	177	for _, pl := range uc.user.pendingLISTs {
	178	if pl.downstreamID != downstreamID {
	179	continue
	180	}
	181	// this is the first pending LIST command list of the downstream
	182	listCommand, ok := pl.pendingCommands[uc.network.ID]
	183	if !ok {
	184	// there is no command for this upstream in these LIST commands
	185	// do not send anything
	186	continue
	187	}
	188	// there is a command for this upstream in these LIST commands
	189	// send it now
	190
	191	uc.SendMessageLabeled(downstreamID, listCommand)
	192
	193	uc.pendingLISTDownstreamSet[downstreamID] = struct{}{}
	194	return
	195	}
	196	}
	197
[139]	198	func (uc upstreamConn) parseMembershipPrefix(s string) (membership membership, nick string) {
	199	for _, m := range uc.availableMemberships {
	200	if m.Prefix == s[0] {
	201	return &m, s[1:]
	202	}
	203	}
	204	return nil, s
	205	}
	206
[55]	207	func (uc upstreamConn) handleMessage(msg irc.Message) error {
[155]	208	var label string
	209	if l, ok := msg.GetTag("label"); ok {
	210	label = l
	211	}
	212
[153]	213	var msgBatch *batch
	214	if batchName, ok := msg.GetTag("batch"); ok {
	215	b, ok := uc.batches[batchName]
	216	if !ok {
	217	return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
	218	}
	219	msgBatch = &b
[155]	220	if label == "" {
	221	label = msgBatch.Label
	222	}
[153]	223	}
	224
[161]	225	var downstreamID uint64 = 0
[155]	226	if label != "" {
	227	var labelOffset uint64
[161]	228	n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
[155]	229	if err == nil && n < 2 {
	230	err = errors.New("not enough arguments")
	231	}
	232	if err != nil {
	233	return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
	234	}
	235	}
	236
[216]	237	if _, ok := msg.Tags["time"]; !ok {
[240]	238	msg.Tags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[216]	239	}
	240
[13]	241	switch msg.Command {
	242	case "PING":
[60]	243	uc.SendMessage(&irc.Message{
[13]	244	Command: "PONG",
[68]	245	Params: msg.Params,
[60]	246	})
[33]	247	return nil
[18]	248	case "NOTICE":
[171]	249	if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
[239]	250	uc.produce("", msg, nil)
[171]	251	} else { // regular user NOTICE
[217]	252	var entity, text string
	253	if err := parseMessageParams(msg, &entity, &text); err != nil {
[171]	254	return err
	255	}
	256
[217]	257	target := entity
	258	if target == uc.nick {
[178]	259	target = msg.Prefix.Name
	260	}
[239]	261	uc.produce(target, msg, nil)
[171]	262	}
[92]	263	case "CAP":
[95]	264	var subCmd string
	265	if err := parseMessageParams(msg, nil, &subCmd); err != nil {
	266	return err
[92]	267	}
[95]	268	subCmd = strings.ToUpper(subCmd)
	269	subParams := msg.Params[2:]
	270	switch subCmd {
	271	case "LS":
	272	if len(subParams) < 1 {
	273	return newNeedMoreParamsError(msg.Command)
	274	}
	275	caps := strings.Fields(subParams[len(subParams)-1])
	276	more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
[92]	277
[95]	278	for _, s := range caps {
	279	kv := strings.SplitN(s, "=", 2)
	280	k := strings.ToLower(kv[0])
	281	var v string
	282	if len(kv) == 2 {
	283	v = kv[1]
	284	}
	285	uc.caps[k] = v
[92]	286	}
	287
[95]	288	if more {
	289	break // wait to receive all capabilities
	290	}
	291
[152]	292	requestCaps := make([]string, 0, 16)
[193]	293	for _, c := range []string{"message-tags", "batch", "labeled-response", "server-time"} {
[152]	294	if _, ok := uc.caps[c]; ok {
	295	requestCaps = append(requestCaps, c)
	296	}
	297	}
	298
[95]	299	if uc.requestSASL() {
[152]	300	requestCaps = append(requestCaps, "sasl")
	301	}
	302
	303	if len(requestCaps) > 0 {
[95]	304	uc.SendMessage(&irc.Message{
	305	Command: "CAP",
[152]	306	Params: []string{"REQ", strings.Join(requestCaps, " ")},
[95]	307	})
[152]	308	}
	309
	310	if uc.requestSASL() {
[95]	311	break // we'll send CAP END after authentication is completed
	312	}
	313
[92]	314	uc.SendMessage(&irc.Message{
	315	Command: "CAP",
	316	Params: []string{"END"},
	317	})
[95]	318	case "ACK", "NAK":
	319	if len(subParams) < 1 {
	320	return newNeedMoreParamsError(msg.Command)
	321	}
	322	caps := strings.Fields(subParams[0])
	323
	324	for _, name := range caps {
	325	if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
	326	return err
	327	}
	328	}
	329
	330	if uc.saslClient == nil {
	331	uc.SendMessage(&irc.Message{
	332	Command: "CAP",
	333	Params: []string{"END"},
	334	})
	335	}
	336	default:
	337	uc.logger.Printf("unhandled message: %v", msg)
[92]	338	}
[95]	339	case "AUTHENTICATE":
	340	if uc.saslClient == nil {
	341	return fmt.Errorf("received unexpected AUTHENTICATE message")
	342	}
	343
	344	// TODO: if a challenge is 400 bytes long, buffer it
	345	var challengeStr string
	346	if err := parseMessageParams(msg, &challengeStr); err != nil {
	347	uc.SendMessage(&irc.Message{
	348	Command: "AUTHENTICATE",
	349	Params: []string{"*"},
	350	})
	351	return err
	352	}
	353
	354	var challenge []byte
	355	if challengeStr != "+" {
	356	var err error
	357	challenge, err = base64.StdEncoding.DecodeString(challengeStr)
	358	if err != nil {
	359	uc.SendMessage(&irc.Message{
	360	Command: "AUTHENTICATE",
	361	Params: []string{"*"},
	362	})
	363	return err
	364	}
	365	}
	366
	367	var resp []byte
	368	var err error
	369	if !uc.saslStarted {
	370	_, resp, err = uc.saslClient.Start()
	371	uc.saslStarted = true
	372	} else {
	373	resp, err = uc.saslClient.Next(challenge)
	374	}
	375	if err != nil {
	376	uc.SendMessage(&irc.Message{
	377	Command: "AUTHENTICATE",
	378	Params: []string{"*"},
	379	})
	380	return err
	381	}
	382
	383	// TODO: send response in multiple chunks if >= 400 bytes
	384	var respStr = "+"
	385	if resp != nil {
	386	respStr = base64.StdEncoding.EncodeToString(resp)
	387	}
	388
	389	uc.SendMessage(&irc.Message{
	390	Command: "AUTHENTICATE",
	391	Params: []string{respStr},
	392	})
[125]	393	case irc.RPL_LOGGEDIN:
[95]	394	var account string
	395	if err := parseMessageParams(msg, nil, nil, &account); err != nil {
	396	return err
	397	}
	398	uc.logger.Printf("logged in with account %q", account)
[125]	399	case irc.RPL_LOGGEDOUT:
[95]	400	uc.logger.Printf("logged out")
[125]	401	case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
[95]	402	var info string
	403	if err := parseMessageParams(msg, nil, &info); err != nil {
	404	return err
	405	}
	406	switch msg.Command {
[125]	407	case irc.ERR_NICKLOCKED:
[95]	408	uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
[125]	409	case irc.ERR_SASLFAIL:
[95]	410	uc.logger.Printf("SASL authentication failed: %v", info)
[125]	411	case irc.ERR_SASLTOOLONG:
[95]	412	uc.logger.Printf("SASL message too long: %v", info)
	413	}
	414
	415	uc.saslClient = nil
	416	uc.saslStarted = false
	417
	418	uc.SendMessage(&irc.Message{
	419	Command: "CAP",
	420	Params: []string{"END"},
	421	})
[14]	422	case irc.RPL_WELCOME:
[55]	423	uc.registered = true
	424	uc.logger.Printf("connection registered")
[19]	425
[77]	426	channels, err := uc.srv.db.ListChannels(uc.network.ID)
	427	if err != nil {
	428	uc.logger.Printf("failed to list channels from database: %v", err)
	429	break
	430	}
	431
	432	for _, ch := range channels {
[146]	433	params := []string{ch.Name}
	434	if ch.Key != "" {
	435	params = append(params, ch.Key)
	436	}
[60]	437	uc.SendMessage(&irc.Message{
[19]	438	Command: "JOIN",
[146]	439	Params: params,
[60]	440	})
[19]	441	}
[16]	442	case irc.RPL_MYINFO:
[139]	443	if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
[43]	444	return err
[16]	445	}
[139]	446	case irc.RPL_ISUPPORT:
	447	if err := parseMessageParams(msg, nil, nil); err != nil {
	448	return err
[16]	449	}
[139]	450	for _, token := range msg.Params[1 : len(msg.Params)-1] {
	451	negate := false
	452	parameter := token
	453	value := ""
	454	if strings.HasPrefix(token, "-") {
	455	negate = true
	456	token = token[1:]
	457	} else {
	458	if i := strings.IndexByte(token, '='); i >= 0 {
	459	parameter = token[:i]
	460	value = token[i+1:]
	461	}
	462	}
	463	if !negate {
	464	switch parameter {
	465	case "CHANMODES":
	466	parts := strings.SplitN(value, ",", 5)
	467	if len(parts) < 4 {
	468	return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
	469	}
	470	modes := make(map[byte]channelModeType)
	471	for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
	472	for j := 0; j < len(parts[i]); j++ {
	473	mode := parts[i][j]
	474	modes[mode] = mt
	475	}
	476	}
	477	uc.availableChannelModes = modes
	478	case "CHANTYPES":
	479	uc.availableChannelTypes = value
	480	case "PREFIX":
	481	if value == "" {
	482	uc.availableMemberships = nil
	483	} else {
	484	if value[0] != '(' {
	485	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	486	}
	487	sep := strings.IndexByte(value, ')')
	488	if sep < 0 \|\| len(value) != sep*2 {
	489	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	490	}
	491	memberships := make([]membership, len(value)/2-1)
	492	for i := range memberships {
	493	memberships[i] = membership{
	494	Mode: value[i+1],
	495	Prefix: value[sep+i+1],
	496	}
	497	}
	498	uc.availableMemberships = memberships
	499	}
	500	}
	501	} else {
	502	// TODO: handle ISUPPORT negations
	503	}
	504	}
[153]	505	case "BATCH":
	506	var tag string
	507	if err := parseMessageParams(msg, &tag); err != nil {
	508	return err
	509	}
	510
	511	if strings.HasPrefix(tag, "+") {
	512	tag = tag[1:]
	513	if _, ok := uc.batches[tag]; ok {
	514	return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
	515	}
	516	var batchType string
	517	if err := parseMessageParams(msg, nil, &batchType); err != nil {
	518	return err
	519	}
[155]	520	label := label
	521	if label == "" && msgBatch != nil {
	522	label = msgBatch.Label
	523	}
[153]	524	uc.batches[tag] = batch{
	525	Type: batchType,
	526	Params: msg.Params[2:],
	527	Outer: msgBatch,
[155]	528	Label: label,
[153]	529	}
	530	} else if strings.HasPrefix(tag, "-") {
	531	tag = tag[1:]
	532	if _, ok := uc.batches[tag]; !ok {
	533	return fmt.Errorf("unknown BATCH reference tag: %q", tag)
	534	}
	535	delete(uc.batches, tag)
	536	} else {
	537	return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
	538	}
[42]	539	case "NICK":
[83]	540	if msg.Prefix == nil {
	541	return fmt.Errorf("expected a prefix")
	542	}
	543
[43]	544	var newNick string
	545	if err := parseMessageParams(msg, &newNick); err != nil {
	546	return err
[42]	547	}
	548
[244]	549	me := false
[55]	550	if msg.Prefix.Name == uc.nick {
	551	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
[244]	552	me = true
[55]	553	uc.nick = newNick
[42]	554	}
	555
[55]	556	for _, ch := range uc.channels {
[42]	557	if membership, ok := ch.Members[msg.Prefix.Name]; ok {
	558	delete(ch.Members, msg.Prefix.Name)
	559	ch.Members[newNick] = membership
[215]	560	uc.appendLog(ch.Name, msg)
[42]	561	}
	562	}
[82]	563
[244]	564	if !me {
[82]	565	uc.forEachDownstream(func(dc *downstreamConn) {
	566	dc.SendMessage(&irc.Message{
	567	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	568	Command: "NICK",
[244]	569	Params: []string{dc.marshalEntity(uc, newNick)},
[82]	570	})
	571	})
	572	}
[69]	573	case "JOIN":
	574	if msg.Prefix == nil {
	575	return fmt.Errorf("expected a prefix")
	576	}
[42]	577
[43]	578	var channels string
	579	if err := parseMessageParams(msg, &channels); err != nil {
	580	return err
[19]	581	}
[34]	582
[43]	583	for _, ch := range strings.Split(channels, ",") {
[55]	584	if msg.Prefix.Name == uc.nick {
	585	uc.logger.Printf("joined channel %q", ch)
	586	uc.channels[ch] = &upstreamChannel{
[34]	587	Name: ch,
[55]	588	conn: uc,
[139]	589	Members: make(map[string]*membership),
[34]	590	}
[139]	591
	592	uc.SendMessage(&irc.Message{
	593	Command: "MODE",
	594	Params: []string{ch},
	595	})
[34]	596	} else {
[55]	597	ch, err := uc.getChannel(ch)
[34]	598	if err != nil {
	599	return err
	600	}
[139]	601	ch.Members[msg.Prefix.Name] = nil
[19]	602	}
[69]	603
[215]	604	uc.appendLog(ch, msg)
[178]	605
[73]	606	uc.forEachDownstream(func(dc *downstreamConn) {
[69]	607	dc.SendMessage(&irc.Message{
	608	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	609	Command: "JOIN",
	610	Params: []string{dc.marshalChannel(uc, ch)},
	611	})
	612	})
[19]	613	}
[69]	614	case "PART":
	615	if msg.Prefix == nil {
	616	return fmt.Errorf("expected a prefix")
	617	}
[34]	618
[43]	619	var channels string
	620	if err := parseMessageParams(msg, &channels); err != nil {
	621	return err
[34]	622	}
	623
[178]	624	var reason string
	625	if len(msg.Params) > 1 {
	626	reason = msg.Params[1]
	627	}
	628
[43]	629	for _, ch := range strings.Split(channels, ",") {
[55]	630	if msg.Prefix.Name == uc.nick {
	631	uc.logger.Printf("parted channel %q", ch)
	632	delete(uc.channels, ch)
[34]	633	} else {
[55]	634	ch, err := uc.getChannel(ch)
[34]	635	if err != nil {
	636	return err
	637	}
	638	delete(ch.Members, msg.Prefix.Name)
	639	}
[69]	640
[215]	641	uc.appendLog(ch, msg)
[178]	642
[73]	643	uc.forEachDownstream(func(dc *downstreamConn) {
[215]	644	params := []string{dc.marshalChannel(uc, ch)}
	645	if reason != "" {
	646	params = append(params, reason)
	647	}
[69]	648	dc.SendMessage(&irc.Message{
	649	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	650	Command: "PART",
[215]	651	Params: params,
[69]	652	})
	653	})
[34]	654	}
[159]	655	case "KICK":
	656	if msg.Prefix == nil {
	657	return fmt.Errorf("expected a prefix")
	658	}
	659
	660	var channel, user string
	661	if err := parseMessageParams(msg, &channel, &user); err != nil {
	662	return err
	663	}
	664
	665	var reason string
	666	if len(msg.Params) > 2 {
[215]	667	reason = msg.Params[2]
[159]	668	}
	669
	670	if user == uc.nick {
	671	uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
	672	delete(uc.channels, channel)
	673	} else {
	674	ch, err := uc.getChannel(channel)
	675	if err != nil {
	676	return err
	677	}
	678	delete(ch.Members, user)
	679	}
	680
[215]	681	uc.appendLog(channel, msg)
[178]	682
[159]	683	uc.forEachDownstream(func(dc *downstreamConn) {
	684	params := []string{dc.marshalChannel(uc, channel), dc.marshalNick(uc, user)}
	685	if reason != "" {
	686	params = append(params, reason)
	687	}
	688	dc.SendMessage(&irc.Message{
	689	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	690	Command: "KICK",
	691	Params: params,
	692	})
	693	})
[83]	694	case "QUIT":
	695	if msg.Prefix == nil {
	696	return fmt.Errorf("expected a prefix")
	697	}
	698
	699	if msg.Prefix.Name == uc.nick {
	700	uc.logger.Printf("quit")
	701	}
	702
	703	for _, ch := range uc.channels {
[178]	704	if _, ok := ch.Members[msg.Prefix.Name]; ok {
	705	delete(ch.Members, msg.Prefix.Name)
	706
[215]	707	uc.appendLog(ch.Name, msg)
[178]	708	}
[83]	709	}
	710
	711	if msg.Prefix.Name != uc.nick {
	712	uc.forEachDownstream(func(dc *downstreamConn) {
	713	dc.SendMessage(&irc.Message{
	714	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	715	Command: "QUIT",
	716	Params: msg.Params,
	717	})
	718	})
	719	}
[19]	720	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	721	var name, topic string
	722	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	723	return err
[19]	724	}
[55]	725	ch, err := uc.getChannel(name)
[19]	726	if err != nil {
	727	return err
	728	}
	729	if msg.Command == irc.RPL_TOPIC {
[43]	730	ch.Topic = topic
[19]	731	} else {
	732	ch.Topic = ""
	733	}
	734	case "TOPIC":
[43]	735	var name string
[74]	736	if err := parseMessageParams(msg, &name); err != nil {
[43]	737	return err
[19]	738	}
[55]	739	ch, err := uc.getChannel(name)
[19]	740	if err != nil {
	741	return err
	742	}
	743	if len(msg.Params) > 1 {
	744	ch.Topic = msg.Params[1]
	745	} else {
	746	ch.Topic = ""
	747	}
[235]	748	uc.appendLog(ch.Name, msg)
[74]	749	uc.forEachDownstream(func(dc *downstreamConn) {
	750	params := []string{dc.marshalChannel(uc, name)}
	751	if ch.Topic != "" {
	752	params = append(params, ch.Topic)
	753	}
	754	dc.SendMessage(&irc.Message{
	755	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	756	Command: "TOPIC",
	757	Params: params,
	758	})
	759	})
[139]	760	case "MODE":
	761	var name, modeStr string
	762	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	763	return err
	764	}
	765
	766	if !uc.isChannel(name) { // user mode change
	767	if name != uc.nick {
	768	return fmt.Errorf("received MODE message for unknown nick %q", name)
	769	}
	770	return uc.modes.Apply(modeStr)
	771	// TODO: notify downstreams about user mode change?
	772	} else { // channel mode change
	773	ch, err := uc.getChannel(name)
	774	if err != nil {
	775	return err
	776	}
	777
	778	if ch.modes != nil {
	779	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
	780	return err
	781	}
	782	}
	783
[215]	784	uc.appendLog(ch.Name, msg)
[178]	785
[139]	786	uc.forEachDownstream(func(dc *downstreamConn) {
	787	params := []string{dc.marshalChannel(uc, name), modeStr}
	788	params = append(params, msg.Params[2:]...)
	789
	790	dc.SendMessage(&irc.Message{
	791	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	792	Command: "MODE",
	793	Params: params,
	794	})
	795	})
	796	}
	797	case irc.RPL_UMODEIS:
	798	if err := parseMessageParams(msg, nil); err != nil {
	799	return err
	800	}
	801	modeStr := ""
	802	if len(msg.Params) > 1 {
	803	modeStr = msg.Params[1]
	804	}
	805
	806	uc.modes = ""
	807	if err := uc.modes.Apply(modeStr); err != nil {
	808	return err
	809	}
	810	// TODO: send RPL_UMODEIS to downstream connections when applicable
	811	case irc.RPL_CHANNELMODEIS:
	812	var channel string
	813	if err := parseMessageParams(msg, nil, &channel); err != nil {
	814	return err
	815	}
	816	modeStr := ""
	817	if len(msg.Params) > 2 {
	818	modeStr = msg.Params[2]
	819	}
	820
	821	ch, err := uc.getChannel(channel)
	822	if err != nil {
	823	return err
	824	}
	825
	826	firstMode := ch.modes == nil
	827	ch.modes = make(map[byte]string)
	828	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
	829	return err
	830	}
	831	if firstMode {
	832	modeStr, modeParams := ch.modes.Format()
	833
	834	uc.forEachDownstream(func(dc *downstreamConn) {
	835	params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
	836	params = append(params, modeParams...)
	837
	838	dc.SendMessage(&irc.Message{
	839	Prefix: dc.srv.prefix(),
	840	Command: irc.RPL_CHANNELMODEIS,
	841	Params: params,
	842	})
	843	})
	844	}
[162]	845	case rpl_creationtime:
	846	var channel, creationTime string
	847	if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
	848	return err
	849	}
	850
	851	ch, err := uc.getChannel(channel)
	852	if err != nil {
	853	return err
	854	}
	855
	856	firstCreationTime := ch.creationTime == ""
	857	ch.creationTime = creationTime
	858	if firstCreationTime {
	859	uc.forEachDownstream(func(dc *downstreamConn) {
	860	dc.SendMessage(&irc.Message{
	861	Prefix: dc.srv.prefix(),
	862	Command: rpl_creationtime,
	863	Params: []string{dc.nick, channel, creationTime},
	864	})
	865	})
	866	}
[19]	867	case rpl_topicwhotime:
[43]	868	var name, who, timeStr string
	869	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	870	return err
[19]	871	}
[55]	872	ch, err := uc.getChannel(name)
[19]	873	if err != nil {
	874	return err
	875	}
[43]	876	ch.TopicWho = who
	877	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	878	if err != nil {
	879	return fmt.Errorf("failed to parse topic time: %v", err)
	880	}
	881	ch.TopicTime = time.Unix(sec, 0)
[177]	882	case irc.RPL_LIST:
	883	var channel, clients, topic string
	884	if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
	885	return err
	886	}
	887
[181]	888	pl := uc.getPendingLIST()
[177]	889	if pl == nil {
	890	return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
	891	}
	892
	893	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	894	dc.SendMessage(&irc.Message{
	895	Prefix: dc.srv.prefix(),
	896	Command: irc.RPL_LIST,
	897	Params: []string{dc.nick, dc.marshalChannel(uc, channel), clients, topic},
	898	})
	899	})
	900	case irc.RPL_LISTEND:
[181]	901	ok := uc.endPendingLISTs(false)
[177]	902	if !ok {
	903	return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
	904	}
[19]	905	case irc.RPL_NAMREPLY:
[43]	906	var name, statusStr, members string
	907	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	908	return err
[19]	909	}
[140]	910
	911	ch, ok := uc.channels[name]
	912	if !ok {
	913	// NAMES on a channel we have not joined, forward to downstream
[161]	914	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	915	channel := dc.marshalChannel(uc, name)
[174]	916	members := splitSpace(members)
[140]	917	for i, member := range members {
	918	membership, nick := uc.parseMembershipPrefix(member)
	919	members[i] = membership.String() + dc.marshalNick(uc, nick)
	920	}
	921	memberStr := strings.Join(members, " ")
	922
	923	dc.SendMessage(&irc.Message{
	924	Prefix: dc.srv.prefix(),
	925	Command: irc.RPL_NAMREPLY,
	926	Params: []string{dc.nick, statusStr, channel, memberStr},
	927	})
	928	})
	929	return nil
[19]	930	}
	931
[43]	932	status, err := parseChannelStatus(statusStr)
[19]	933	if err != nil {
	934	return err
	935	}
	936	ch.Status = status
	937
[174]	938	for _, s := range splitSpace(members) {
[139]	939	membership, nick := uc.parseMembershipPrefix(s)
[19]	940	ch.Members[nick] = membership
	941	}
	942	case irc.RPL_ENDOFNAMES:
[43]	943	var name string
	944	if err := parseMessageParams(msg, nil, &name); err != nil {
	945	return err
[25]	946	}
[140]	947
	948	ch, ok := uc.channels[name]
	949	if !ok {
	950	// NAMES on a channel we have not joined, forward to downstream
[161]	951	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	952	channel := dc.marshalChannel(uc, name)
	953
	954	dc.SendMessage(&irc.Message{
	955	Prefix: dc.srv.prefix(),
	956	Command: irc.RPL_ENDOFNAMES,
	957	Params: []string{dc.nick, channel, "End of /NAMES list"},
	958	})
	959	})
	960	return nil
[25]	961	}
	962
[34]	963	if ch.complete {
	964	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	965	}
[25]	966	ch.complete = true
[27]	967
[73]	968	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	969	forwardChannel(dc, ch)
[40]	970	})
[127]	971	case irc.RPL_WHOREPLY:
	972	var channel, username, host, server, nick, mode, trailing string
	973	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	974	return err
	975	}
	976
	977	parts := strings.SplitN(trailing, " ", 2)
	978	if len(parts) != 2 {
	979	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	980	}
	981	realname := parts[1]
	982	hops, err := strconv.Atoi(parts[0])
	983	if err != nil {
	984	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	985	}
	986	hops++
	987
	988	trailing = strconv.Itoa(hops) + " " + realname
	989
[161]	990	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	991	channel := channel
	992	if channel != "*" {
	993	channel = dc.marshalChannel(uc, channel)
	994	}
	995	nick := dc.marshalNick(uc, nick)
	996	dc.SendMessage(&irc.Message{
	997	Prefix: dc.srv.prefix(),
	998	Command: irc.RPL_WHOREPLY,
	999	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	1000	})
	1001	})
	1002	case irc.RPL_ENDOFWHO:
	1003	var name string
	1004	if err := parseMessageParams(msg, nil, &name); err != nil {
	1005	return err
	1006	}
	1007
[161]	1008	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	1009	name := name
	1010	if name != "*" {
	1011	// TODO: support WHO masks
	1012	name = dc.marshalEntity(uc, name)
	1013	}
	1014	dc.SendMessage(&irc.Message{
	1015	Prefix: dc.srv.prefix(),
	1016	Command: irc.RPL_ENDOFWHO,
[142]	1017	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	1018	})
	1019	})
[128]	1020	case irc.RPL_WHOISUSER:
	1021	var nick, username, host, realname string
	1022	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	1023	return err
	1024	}
	1025
[161]	1026	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1027	nick := dc.marshalNick(uc, nick)
	1028	dc.SendMessage(&irc.Message{
	1029	Prefix: dc.srv.prefix(),
	1030	Command: irc.RPL_WHOISUSER,
	1031	Params: []string{dc.nick, nick, username, host, "*", realname},
	1032	})
	1033	})
	1034	case irc.RPL_WHOISSERVER:
	1035	var nick, server, serverInfo string
	1036	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	1037	return err
	1038	}
	1039
[161]	1040	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1041	nick := dc.marshalNick(uc, nick)
	1042	dc.SendMessage(&irc.Message{
	1043	Prefix: dc.srv.prefix(),
	1044	Command: irc.RPL_WHOISSERVER,
	1045	Params: []string{dc.nick, nick, server, serverInfo},
	1046	})
	1047	})
	1048	case irc.RPL_WHOISOPERATOR:
	1049	var nick string
	1050	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1051	return err
	1052	}
	1053
[161]	1054	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1055	nick := dc.marshalNick(uc, nick)
	1056	dc.SendMessage(&irc.Message{
	1057	Prefix: dc.srv.prefix(),
	1058	Command: irc.RPL_WHOISOPERATOR,
	1059	Params: []string{dc.nick, nick, "is an IRC operator"},
	1060	})
	1061	})
	1062	case irc.RPL_WHOISIDLE:
	1063	var nick string
	1064	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	1065	return err
	1066	}
	1067
[161]	1068	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1069	nick := dc.marshalNick(uc, nick)
	1070	params := []string{dc.nick, nick}
	1071	params = append(params, msg.Params[2:]...)
	1072	dc.SendMessage(&irc.Message{
	1073	Prefix: dc.srv.prefix(),
	1074	Command: irc.RPL_WHOISIDLE,
	1075	Params: params,
	1076	})
	1077	})
	1078	case irc.RPL_WHOISCHANNELS:
	1079	var nick, channelList string
	1080	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	1081	return err
	1082	}
[174]	1083	channels := splitSpace(channelList)
[128]	1084
[161]	1085	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1086	nick := dc.marshalNick(uc, nick)
	1087	channelList := make([]string, len(channels))
	1088	for i, channel := range channels {
[139]	1089	prefix, channel := uc.parseMembershipPrefix(channel)
[128]	1090	channel = dc.marshalChannel(uc, channel)
	1091	channelList[i] = prefix.String() + channel
	1092	}
	1093	channels := strings.Join(channelList, " ")
	1094	dc.SendMessage(&irc.Message{
	1095	Prefix: dc.srv.prefix(),
	1096	Command: irc.RPL_WHOISCHANNELS,
	1097	Params: []string{dc.nick, nick, channels},
	1098	})
	1099	})
	1100	case irc.RPL_ENDOFWHOIS:
	1101	var nick string
	1102	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1103	return err
	1104	}
	1105
[161]	1106	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1107	nick := dc.marshalNick(uc, nick)
	1108	dc.SendMessage(&irc.Message{
	1109	Prefix: dc.srv.prefix(),
	1110	Command: irc.RPL_ENDOFWHOIS,
[142]	1111	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	1112	})
	1113	})
[36]	1114	case "PRIVMSG":
[117]	1115	if msg.Prefix == nil {
	1116	return fmt.Errorf("expected a prefix")
	1117	}
	1118
[217]	1119	var entity, text string
	1120	if err := parseMessageParams(msg, &entity, &text); err != nil {
[69]	1121	return err
	1122	}
[117]	1123
	1124	if msg.Prefix.Name == serviceNick {
	1125	uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
	1126	break
	1127	}
[217]	1128	if entity == serviceNick {
[117]	1129	uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
	1130	break
	1131	}
	1132
[217]	1133	target := entity
	1134	if target == uc.nick {
[178]	1135	target = msg.Prefix.Name
	1136	}
[239]	1137	uc.produce(target, msg, nil)
[115]	1138	case "INVITE":
	1139	var nick string
	1140	var channel string
	1141	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1142	return err
	1143	}
	1144
	1145	uc.forEachDownstream(func(dc *downstreamConn) {
	1146	dc.SendMessage(&irc.Message{
	1147	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	1148	Command: "INVITE",
	1149	Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1150	})
	1151	})
[163]	1152	case irc.RPL_INVITING:
	1153	var nick string
	1154	var channel string
	1155	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1156	return err
	1157	}
	1158
	1159	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1160	dc.SendMessage(&irc.Message{
	1161	Prefix: dc.srv.prefix(),
	1162	Command: irc.RPL_INVITING,
	1163	Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1164	})
	1165	})
[177]	1166	case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
	1167	var command, reason string
	1168	if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
	1169	return err
	1170	}
	1171
	1172	if command == "LIST" {
[181]	1173	ok := uc.endPendingLISTs(false)
[177]	1174	if !ok {
	1175	return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
	1176	}
	1177	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1178	dc.SendMessage(&irc.Message{
	1179	Prefix: uc.srv.prefix(),
	1180	Command: msg.Command,
	1181	Params: []string{dc.nick, "LIST", reason},
	1182	})
	1183	})
	1184	}
[152]	1185	case "TAGMSG":
	1186	// TODO: relay to downstream connections that accept message-tags
[155]	1187	case "ACK":
	1188	// Ignore
[198]	1189	case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
	1190	// Ignore
[16]	1191	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	1192	// Ignore
	1193	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	1194	// Ignore
	1195	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	1196	// Ignore
[177]	1197	case irc.RPL_LISTSTART:
	1198	// Ignore
[14]	1199	case rpl_localusers, rpl_globalusers:
	1200	// Ignore
[96]	1201	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1202	// Ignore
[13]	1203	default:
[95]	1204	uc.logger.Printf("unhandled message: %v", msg)
[13]	1205	}
[14]	1206	return nil
[13]	1207	}
	1208
[174]	1209	func splitSpace(s string) []string {
	1210	return strings.FieldsFunc(s, func(r rune) bool {
	1211	return r == ' '
	1212	})
	1213	}
	1214
[55]	1215	func (uc *upstreamConn) register() {
[77]	1216	uc.nick = uc.network.Nick
	1217	uc.username = uc.network.Username
	1218	if uc.username == "" {
	1219	uc.username = uc.nick
	1220	}
	1221	uc.realname = uc.network.Realname
	1222	if uc.realname == "" {
	1223	uc.realname = uc.nick
	1224	}
	1225
[60]	1226	uc.SendMessage(&irc.Message{
[92]	1227	Command: "CAP",
	1228	Params: []string{"LS", "302"},
	1229	})
	1230
[93]	1231	if uc.network.Pass != "" {
	1232	uc.SendMessage(&irc.Message{
	1233	Command: "PASS",
	1234	Params: []string{uc.network.Pass},
	1235	})
	1236	}
	1237
[92]	1238	uc.SendMessage(&irc.Message{
[13]	1239	Command: "NICK",
[69]	1240	Params: []string{uc.nick},
[60]	1241	})
	1242	uc.SendMessage(&irc.Message{
[13]	1243	Command: "USER",
[77]	1244	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1245	})
[44]	1246	}
[13]	1247
[197]	1248	func (uc *upstreamConn) runUntilRegistered() error {
	1249	for !uc.registered {
[212]	1250	msg, err := uc.ReadMessage()
[197]	1251	if err != nil {
	1252	return fmt.Errorf("failed to read message: %v", err)
	1253	}
	1254
	1255	if err := uc.handleMessage(msg); err != nil {
	1256	return fmt.Errorf("failed to handle message %q: %v", msg, err)
	1257	}
	1258	}
	1259
	1260	return nil
	1261	}
	1262
[95]	1263	func (uc *upstreamConn) requestSASL() bool {
	1264	if uc.network.SASL.Mechanism == "" {
	1265	return false
	1266	}
	1267
	1268	v, ok := uc.caps["sasl"]
	1269	if !ok {
	1270	return false
	1271	}
	1272	if v != "" {
	1273	mechanisms := strings.Split(v, ",")
	1274	found := false
	1275	for _, mech := range mechanisms {
	1276	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1277	found = true
	1278	break
	1279	}
	1280	}
	1281	if !found {
	1282	return false
	1283	}
	1284	}
	1285
	1286	return true
	1287	}
	1288
	1289	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1290	auth := &uc.network.SASL
	1291	switch name {
	1292	case "sasl":
	1293	if !ok {
	1294	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1295	return nil
	1296	}
	1297
	1298	switch auth.Mechanism {
	1299	case "PLAIN":
	1300	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1301	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1302	default:
	1303	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1304	}
	1305
	1306	uc.SendMessage(&irc.Message{
	1307	Command: "AUTHENTICATE",
	1308	Params: []string{auth.Mechanism},
	1309	})
[152]	1310	case "message-tags":
	1311	uc.tagsSupported = ok
[155]	1312	case "labeled-response":
	1313	uc.labelsSupported = ok
[193]	1314	case "batch", "server-time":
	1315	// Nothing to do
	1316	default:
	1317	uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
[95]	1318	}
	1319	return nil
	1320	}
	1321
[165]	1322	func (uc *upstreamConn) readMessages(ch chan<- event) error {
[13]	1323	for {
[210]	1324	msg, err := uc.ReadMessage()
[13]	1325	if err == io.EOF {
	1326	break
	1327	} else if err != nil {
	1328	return fmt.Errorf("failed to read IRC command: %v", err)
	1329	}
	1330
[165]	1331	ch <- eventUpstreamMessage{msg, uc}
[13]	1332	}
	1333
[45]	1334	return nil
[13]	1335	}
[60]	1336
[176]	1337	func (uc upstreamConn) SendMessageLabeled(downstreamID uint64, msg irc.Message) {
[155]	1338	if uc.labelsSupported {
	1339	if msg.Tags == nil {
	1340	msg.Tags = make(map[string]irc.TagValue)
	1341	}
[176]	1342	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
[161]	1343	uc.nextLabelID++
[155]	1344	}
	1345	uc.SendMessage(msg)
	1346	}
[178]	1347
	1348	// TODO: handle moving logs when a network name changes, when support for this is added
[215]	1349	func (uc upstreamConn) appendLog(entity string, msg irc.Message) {
[178]	1350	if uc.srv.LogPath == "" {
	1351	return
	1352	}
[215]	1353
	1354	ml, ok := uc.messageLoggers[entity]
	1355	if !ok {
	1356	ml = newMessageLogger(uc, entity)
	1357	uc.messageLoggers[entity] = ml
[178]	1358	}
	1359
[215]	1360	if err := ml.Append(msg); err != nil {
	1361	uc.logger.Printf("failed to log message: %v", err)
[178]	1362	}
	1363	}
[198]	1364
[239]	1365	func (uc upstreamConn) produce(target string, msg irc.Message, origin *downstreamConn) {
	1366	if target != "" {
	1367	uc.appendLog(target, msg)
	1368	}
	1369
[226]	1370	uc.network.ring.Produce(msg)
[227]	1371
	1372	uc.forEachDownstream(func(dc *downstreamConn) {
[238]	1373	if dc != origin \|\| dc.caps["echo-message"] {
	1374	dc.sendFromUpstream(msg, uc)
	1375	}
[227]	1376	})
[226]	1377	}
	1378
[198]	1379	func (uc *upstreamConn) updateAway() {
	1380	away := true
	1381	uc.forEachDownstream(func(*downstreamConn) {
	1382	away = false
	1383	})
	1384	if away == uc.away {
	1385	return
	1386	}
	1387	if away {
	1388	uc.SendMessage(&irc.Message{
	1389	Command: "AWAY",
	1390	Params: []string{"Auto away"},
	1391	})
	1392	} else {
	1393	uc.SendMessage(&irc.Message{
	1394	Command: "AWAY",
	1395	})
	1396	}
	1397	uc.away = away
	1398	}

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

Download in other formats: