Context Navigation

source: code/trunk/upstream.go@ 240

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

Fix server-time tags timezone

We need to use UTC time.

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
[55]	549	if msg.Prefix.Name == uc.nick {
	550	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
	551	uc.nick = newNick
[42]	552	}
	553
[55]	554	for _, ch := range uc.channels {
[42]	555	if membership, ok := ch.Members[msg.Prefix.Name]; ok {
	556	delete(ch.Members, msg.Prefix.Name)
	557	ch.Members[newNick] = membership
[215]	558	uc.appendLog(ch.Name, msg)
[42]	559	}
	560	}
[82]	561
	562	if msg.Prefix.Name != uc.nick {
	563	uc.forEachDownstream(func(dc *downstreamConn) {
	564	dc.SendMessage(&irc.Message{
	565	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	566	Command: "NICK",
	567	Params: []string{newNick},
	568	})
	569	})
	570	}
[69]	571	case "JOIN":
	572	if msg.Prefix == nil {
	573	return fmt.Errorf("expected a prefix")
	574	}
[42]	575
[43]	576	var channels string
	577	if err := parseMessageParams(msg, &channels); err != nil {
	578	return err
[19]	579	}
[34]	580
[43]	581	for _, ch := range strings.Split(channels, ",") {
[55]	582	if msg.Prefix.Name == uc.nick {
	583	uc.logger.Printf("joined channel %q", ch)
	584	uc.channels[ch] = &upstreamChannel{
[34]	585	Name: ch,
[55]	586	conn: uc,
[139]	587	Members: make(map[string]*membership),
[34]	588	}
[139]	589
	590	uc.SendMessage(&irc.Message{
	591	Command: "MODE",
	592	Params: []string{ch},
	593	})
[34]	594	} else {
[55]	595	ch, err := uc.getChannel(ch)
[34]	596	if err != nil {
	597	return err
	598	}
[139]	599	ch.Members[msg.Prefix.Name] = nil
[19]	600	}
[69]	601
[215]	602	uc.appendLog(ch, msg)
[178]	603
[73]	604	uc.forEachDownstream(func(dc *downstreamConn) {
[69]	605	dc.SendMessage(&irc.Message{
	606	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	607	Command: "JOIN",
	608	Params: []string{dc.marshalChannel(uc, ch)},
	609	})
	610	})
[19]	611	}
[69]	612	case "PART":
	613	if msg.Prefix == nil {
	614	return fmt.Errorf("expected a prefix")
	615	}
[34]	616
[43]	617	var channels string
	618	if err := parseMessageParams(msg, &channels); err != nil {
	619	return err
[34]	620	}
	621
[178]	622	var reason string
	623	if len(msg.Params) > 1 {
	624	reason = msg.Params[1]
	625	}
	626
[43]	627	for _, ch := range strings.Split(channels, ",") {
[55]	628	if msg.Prefix.Name == uc.nick {
	629	uc.logger.Printf("parted channel %q", ch)
	630	delete(uc.channels, ch)
[34]	631	} else {
[55]	632	ch, err := uc.getChannel(ch)
[34]	633	if err != nil {
	634	return err
	635	}
	636	delete(ch.Members, msg.Prefix.Name)
	637	}
[69]	638
[215]	639	uc.appendLog(ch, msg)
[178]	640
[73]	641	uc.forEachDownstream(func(dc *downstreamConn) {
[215]	642	params := []string{dc.marshalChannel(uc, ch)}
	643	if reason != "" {
	644	params = append(params, reason)
	645	}
[69]	646	dc.SendMessage(&irc.Message{
	647	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	648	Command: "PART",
[215]	649	Params: params,
[69]	650	})
	651	})
[34]	652	}
[159]	653	case "KICK":
	654	if msg.Prefix == nil {
	655	return fmt.Errorf("expected a prefix")
	656	}
	657
	658	var channel, user string
	659	if err := parseMessageParams(msg, &channel, &user); err != nil {
	660	return err
	661	}
	662
	663	var reason string
	664	if len(msg.Params) > 2 {
[215]	665	reason = msg.Params[2]
[159]	666	}
	667
	668	if user == uc.nick {
	669	uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
	670	delete(uc.channels, channel)
	671	} else {
	672	ch, err := uc.getChannel(channel)
	673	if err != nil {
	674	return err
	675	}
	676	delete(ch.Members, user)
	677	}
	678
[215]	679	uc.appendLog(channel, msg)
[178]	680
[159]	681	uc.forEachDownstream(func(dc *downstreamConn) {
	682	params := []string{dc.marshalChannel(uc, channel), dc.marshalNick(uc, user)}
	683	if reason != "" {
	684	params = append(params, reason)
	685	}
	686	dc.SendMessage(&irc.Message{
	687	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	688	Command: "KICK",
	689	Params: params,
	690	})
	691	})
[83]	692	case "QUIT":
	693	if msg.Prefix == nil {
	694	return fmt.Errorf("expected a prefix")
	695	}
	696
	697	if msg.Prefix.Name == uc.nick {
	698	uc.logger.Printf("quit")
	699	}
	700
	701	for _, ch := range uc.channels {
[178]	702	if _, ok := ch.Members[msg.Prefix.Name]; ok {
	703	delete(ch.Members, msg.Prefix.Name)
	704
[215]	705	uc.appendLog(ch.Name, msg)
[178]	706	}
[83]	707	}
	708
	709	if msg.Prefix.Name != uc.nick {
	710	uc.forEachDownstream(func(dc *downstreamConn) {
	711	dc.SendMessage(&irc.Message{
	712	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	713	Command: "QUIT",
	714	Params: msg.Params,
	715	})
	716	})
	717	}
[19]	718	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	719	var name, topic string
	720	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	721	return err
[19]	722	}
[55]	723	ch, err := uc.getChannel(name)
[19]	724	if err != nil {
	725	return err
	726	}
	727	if msg.Command == irc.RPL_TOPIC {
[43]	728	ch.Topic = topic
[19]	729	} else {
	730	ch.Topic = ""
	731	}
	732	case "TOPIC":
[43]	733	var name string
[74]	734	if err := parseMessageParams(msg, &name); err != nil {
[43]	735	return err
[19]	736	}
[55]	737	ch, err := uc.getChannel(name)
[19]	738	if err != nil {
	739	return err
	740	}
	741	if len(msg.Params) > 1 {
	742	ch.Topic = msg.Params[1]
	743	} else {
	744	ch.Topic = ""
	745	}
[235]	746	uc.appendLog(ch.Name, msg)
[74]	747	uc.forEachDownstream(func(dc *downstreamConn) {
	748	params := []string{dc.marshalChannel(uc, name)}
	749	if ch.Topic != "" {
	750	params = append(params, ch.Topic)
	751	}
	752	dc.SendMessage(&irc.Message{
	753	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	754	Command: "TOPIC",
	755	Params: params,
	756	})
	757	})
[139]	758	case "MODE":
	759	var name, modeStr string
	760	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	761	return err
	762	}
	763
	764	if !uc.isChannel(name) { // user mode change
	765	if name != uc.nick {
	766	return fmt.Errorf("received MODE message for unknown nick %q", name)
	767	}
	768	return uc.modes.Apply(modeStr)
	769	// TODO: notify downstreams about user mode change?
	770	} else { // channel mode change
	771	ch, err := uc.getChannel(name)
	772	if err != nil {
	773	return err
	774	}
	775
	776	if ch.modes != nil {
	777	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
	778	return err
	779	}
	780	}
	781
[215]	782	uc.appendLog(ch.Name, msg)
[178]	783
[139]	784	uc.forEachDownstream(func(dc *downstreamConn) {
	785	params := []string{dc.marshalChannel(uc, name), modeStr}
	786	params = append(params, msg.Params[2:]...)
	787
	788	dc.SendMessage(&irc.Message{
	789	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	790	Command: "MODE",
	791	Params: params,
	792	})
	793	})
	794	}
	795	case irc.RPL_UMODEIS:
	796	if err := parseMessageParams(msg, nil); err != nil {
	797	return err
	798	}
	799	modeStr := ""
	800	if len(msg.Params) > 1 {
	801	modeStr = msg.Params[1]
	802	}
	803
	804	uc.modes = ""
	805	if err := uc.modes.Apply(modeStr); err != nil {
	806	return err
	807	}
	808	// TODO: send RPL_UMODEIS to downstream connections when applicable
	809	case irc.RPL_CHANNELMODEIS:
	810	var channel string
	811	if err := parseMessageParams(msg, nil, &channel); err != nil {
	812	return err
	813	}
	814	modeStr := ""
	815	if len(msg.Params) > 2 {
	816	modeStr = msg.Params[2]
	817	}
	818
	819	ch, err := uc.getChannel(channel)
	820	if err != nil {
	821	return err
	822	}
	823
	824	firstMode := ch.modes == nil
	825	ch.modes = make(map[byte]string)
	826	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
	827	return err
	828	}
	829	if firstMode {
	830	modeStr, modeParams := ch.modes.Format()
	831
	832	uc.forEachDownstream(func(dc *downstreamConn) {
	833	params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
	834	params = append(params, modeParams...)
	835
	836	dc.SendMessage(&irc.Message{
	837	Prefix: dc.srv.prefix(),
	838	Command: irc.RPL_CHANNELMODEIS,
	839	Params: params,
	840	})
	841	})
	842	}
[162]	843	case rpl_creationtime:
	844	var channel, creationTime string
	845	if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
	846	return err
	847	}
	848
	849	ch, err := uc.getChannel(channel)
	850	if err != nil {
	851	return err
	852	}
	853
	854	firstCreationTime := ch.creationTime == ""
	855	ch.creationTime = creationTime
	856	if firstCreationTime {
	857	uc.forEachDownstream(func(dc *downstreamConn) {
	858	dc.SendMessage(&irc.Message{
	859	Prefix: dc.srv.prefix(),
	860	Command: rpl_creationtime,
	861	Params: []string{dc.nick, channel, creationTime},
	862	})
	863	})
	864	}
[19]	865	case rpl_topicwhotime:
[43]	866	var name, who, timeStr string
	867	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	868	return err
[19]	869	}
[55]	870	ch, err := uc.getChannel(name)
[19]	871	if err != nil {
	872	return err
	873	}
[43]	874	ch.TopicWho = who
	875	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	876	if err != nil {
	877	return fmt.Errorf("failed to parse topic time: %v", err)
	878	}
	879	ch.TopicTime = time.Unix(sec, 0)
[177]	880	case irc.RPL_LIST:
	881	var channel, clients, topic string
	882	if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
	883	return err
	884	}
	885
[181]	886	pl := uc.getPendingLIST()
[177]	887	if pl == nil {
	888	return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
	889	}
	890
	891	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	892	dc.SendMessage(&irc.Message{
	893	Prefix: dc.srv.prefix(),
	894	Command: irc.RPL_LIST,
	895	Params: []string{dc.nick, dc.marshalChannel(uc, channel), clients, topic},
	896	})
	897	})
	898	case irc.RPL_LISTEND:
[181]	899	ok := uc.endPendingLISTs(false)
[177]	900	if !ok {
	901	return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
	902	}
[19]	903	case irc.RPL_NAMREPLY:
[43]	904	var name, statusStr, members string
	905	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	906	return err
[19]	907	}
[140]	908
	909	ch, ok := uc.channels[name]
	910	if !ok {
	911	// NAMES on a channel we have not joined, forward to downstream
[161]	912	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	913	channel := dc.marshalChannel(uc, name)
[174]	914	members := splitSpace(members)
[140]	915	for i, member := range members {
	916	membership, nick := uc.parseMembershipPrefix(member)
	917	members[i] = membership.String() + dc.marshalNick(uc, nick)
	918	}
	919	memberStr := strings.Join(members, " ")
	920
	921	dc.SendMessage(&irc.Message{
	922	Prefix: dc.srv.prefix(),
	923	Command: irc.RPL_NAMREPLY,
	924	Params: []string{dc.nick, statusStr, channel, memberStr},
	925	})
	926	})
	927	return nil
[19]	928	}
	929
[43]	930	status, err := parseChannelStatus(statusStr)
[19]	931	if err != nil {
	932	return err
	933	}
	934	ch.Status = status
	935
[174]	936	for _, s := range splitSpace(members) {
[139]	937	membership, nick := uc.parseMembershipPrefix(s)
[19]	938	ch.Members[nick] = membership
	939	}
	940	case irc.RPL_ENDOFNAMES:
[43]	941	var name string
	942	if err := parseMessageParams(msg, nil, &name); err != nil {
	943	return err
[25]	944	}
[140]	945
	946	ch, ok := uc.channels[name]
	947	if !ok {
	948	// NAMES on a channel we have not joined, forward to downstream
[161]	949	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	950	channel := dc.marshalChannel(uc, name)
	951
	952	dc.SendMessage(&irc.Message{
	953	Prefix: dc.srv.prefix(),
	954	Command: irc.RPL_ENDOFNAMES,
	955	Params: []string{dc.nick, channel, "End of /NAMES list"},
	956	})
	957	})
	958	return nil
[25]	959	}
	960
[34]	961	if ch.complete {
	962	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	963	}
[25]	964	ch.complete = true
[27]	965
[73]	966	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	967	forwardChannel(dc, ch)
[40]	968	})
[127]	969	case irc.RPL_WHOREPLY:
	970	var channel, username, host, server, nick, mode, trailing string
	971	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	972	return err
	973	}
	974
	975	parts := strings.SplitN(trailing, " ", 2)
	976	if len(parts) != 2 {
	977	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	978	}
	979	realname := parts[1]
	980	hops, err := strconv.Atoi(parts[0])
	981	if err != nil {
	982	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	983	}
	984	hops++
	985
	986	trailing = strconv.Itoa(hops) + " " + realname
	987
[161]	988	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	989	channel := channel
	990	if channel != "*" {
	991	channel = dc.marshalChannel(uc, channel)
	992	}
	993	nick := dc.marshalNick(uc, nick)
	994	dc.SendMessage(&irc.Message{
	995	Prefix: dc.srv.prefix(),
	996	Command: irc.RPL_WHOREPLY,
	997	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	998	})
	999	})
	1000	case irc.RPL_ENDOFWHO:
	1001	var name string
	1002	if err := parseMessageParams(msg, nil, &name); err != nil {
	1003	return err
	1004	}
	1005
[161]	1006	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	1007	name := name
	1008	if name != "*" {
	1009	// TODO: support WHO masks
	1010	name = dc.marshalEntity(uc, name)
	1011	}
	1012	dc.SendMessage(&irc.Message{
	1013	Prefix: dc.srv.prefix(),
	1014	Command: irc.RPL_ENDOFWHO,
[142]	1015	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	1016	})
	1017	})
[128]	1018	case irc.RPL_WHOISUSER:
	1019	var nick, username, host, realname string
	1020	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	1021	return err
	1022	}
	1023
[161]	1024	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1025	nick := dc.marshalNick(uc, nick)
	1026	dc.SendMessage(&irc.Message{
	1027	Prefix: dc.srv.prefix(),
	1028	Command: irc.RPL_WHOISUSER,
	1029	Params: []string{dc.nick, nick, username, host, "*", realname},
	1030	})
	1031	})
	1032	case irc.RPL_WHOISSERVER:
	1033	var nick, server, serverInfo string
	1034	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	1035	return err
	1036	}
	1037
[161]	1038	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1039	nick := dc.marshalNick(uc, nick)
	1040	dc.SendMessage(&irc.Message{
	1041	Prefix: dc.srv.prefix(),
	1042	Command: irc.RPL_WHOISSERVER,
	1043	Params: []string{dc.nick, nick, server, serverInfo},
	1044	})
	1045	})
	1046	case irc.RPL_WHOISOPERATOR:
	1047	var nick string
	1048	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1049	return err
	1050	}
	1051
[161]	1052	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1053	nick := dc.marshalNick(uc, nick)
	1054	dc.SendMessage(&irc.Message{
	1055	Prefix: dc.srv.prefix(),
	1056	Command: irc.RPL_WHOISOPERATOR,
	1057	Params: []string{dc.nick, nick, "is an IRC operator"},
	1058	})
	1059	})
	1060	case irc.RPL_WHOISIDLE:
	1061	var nick string
	1062	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	1063	return err
	1064	}
	1065
[161]	1066	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1067	nick := dc.marshalNick(uc, nick)
	1068	params := []string{dc.nick, nick}
	1069	params = append(params, msg.Params[2:]...)
	1070	dc.SendMessage(&irc.Message{
	1071	Prefix: dc.srv.prefix(),
	1072	Command: irc.RPL_WHOISIDLE,
	1073	Params: params,
	1074	})
	1075	})
	1076	case irc.RPL_WHOISCHANNELS:
	1077	var nick, channelList string
	1078	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	1079	return err
	1080	}
[174]	1081	channels := splitSpace(channelList)
[128]	1082
[161]	1083	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1084	nick := dc.marshalNick(uc, nick)
	1085	channelList := make([]string, len(channels))
	1086	for i, channel := range channels {
[139]	1087	prefix, channel := uc.parseMembershipPrefix(channel)
[128]	1088	channel = dc.marshalChannel(uc, channel)
	1089	channelList[i] = prefix.String() + channel
	1090	}
	1091	channels := strings.Join(channelList, " ")
	1092	dc.SendMessage(&irc.Message{
	1093	Prefix: dc.srv.prefix(),
	1094	Command: irc.RPL_WHOISCHANNELS,
	1095	Params: []string{dc.nick, nick, channels},
	1096	})
	1097	})
	1098	case irc.RPL_ENDOFWHOIS:
	1099	var nick string
	1100	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1101	return err
	1102	}
	1103
[161]	1104	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1105	nick := dc.marshalNick(uc, nick)
	1106	dc.SendMessage(&irc.Message{
	1107	Prefix: dc.srv.prefix(),
	1108	Command: irc.RPL_ENDOFWHOIS,
[142]	1109	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	1110	})
	1111	})
[36]	1112	case "PRIVMSG":
[117]	1113	if msg.Prefix == nil {
	1114	return fmt.Errorf("expected a prefix")
	1115	}
	1116
[217]	1117	var entity, text string
	1118	if err := parseMessageParams(msg, &entity, &text); err != nil {
[69]	1119	return err
	1120	}
[117]	1121
	1122	if msg.Prefix.Name == serviceNick {
	1123	uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
	1124	break
	1125	}
[217]	1126	if entity == serviceNick {
[117]	1127	uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
	1128	break
	1129	}
	1130
[217]	1131	target := entity
	1132	if target == uc.nick {
[178]	1133	target = msg.Prefix.Name
	1134	}
[239]	1135	uc.produce(target, msg, nil)
[115]	1136	case "INVITE":
	1137	var nick string
	1138	var channel string
	1139	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1140	return err
	1141	}
	1142
	1143	uc.forEachDownstream(func(dc *downstreamConn) {
	1144	dc.SendMessage(&irc.Message{
	1145	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	1146	Command: "INVITE",
	1147	Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1148	})
	1149	})
[163]	1150	case irc.RPL_INVITING:
	1151	var nick string
	1152	var channel string
	1153	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1154	return err
	1155	}
	1156
	1157	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1158	dc.SendMessage(&irc.Message{
	1159	Prefix: dc.srv.prefix(),
	1160	Command: irc.RPL_INVITING,
	1161	Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1162	})
	1163	})
[177]	1164	case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
	1165	var command, reason string
	1166	if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
	1167	return err
	1168	}
	1169
	1170	if command == "LIST" {
[181]	1171	ok := uc.endPendingLISTs(false)
[177]	1172	if !ok {
	1173	return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
	1174	}
	1175	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1176	dc.SendMessage(&irc.Message{
	1177	Prefix: uc.srv.prefix(),
	1178	Command: msg.Command,
	1179	Params: []string{dc.nick, "LIST", reason},
	1180	})
	1181	})
	1182	}
[152]	1183	case "TAGMSG":
	1184	// TODO: relay to downstream connections that accept message-tags
[155]	1185	case "ACK":
	1186	// Ignore
[198]	1187	case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
	1188	// Ignore
[16]	1189	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	1190	// Ignore
	1191	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	1192	// Ignore
	1193	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	1194	// Ignore
[177]	1195	case irc.RPL_LISTSTART:
	1196	// Ignore
[14]	1197	case rpl_localusers, rpl_globalusers:
	1198	// Ignore
[96]	1199	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1200	// Ignore
[13]	1201	default:
[95]	1202	uc.logger.Printf("unhandled message: %v", msg)
[13]	1203	}
[14]	1204	return nil
[13]	1205	}
	1206
[174]	1207	func splitSpace(s string) []string {
	1208	return strings.FieldsFunc(s, func(r rune) bool {
	1209	return r == ' '
	1210	})
	1211	}
	1212
[55]	1213	func (uc *upstreamConn) register() {
[77]	1214	uc.nick = uc.network.Nick
	1215	uc.username = uc.network.Username
	1216	if uc.username == "" {
	1217	uc.username = uc.nick
	1218	}
	1219	uc.realname = uc.network.Realname
	1220	if uc.realname == "" {
	1221	uc.realname = uc.nick
	1222	}
	1223
[60]	1224	uc.SendMessage(&irc.Message{
[92]	1225	Command: "CAP",
	1226	Params: []string{"LS", "302"},
	1227	})
	1228
[93]	1229	if uc.network.Pass != "" {
	1230	uc.SendMessage(&irc.Message{
	1231	Command: "PASS",
	1232	Params: []string{uc.network.Pass},
	1233	})
	1234	}
	1235
[92]	1236	uc.SendMessage(&irc.Message{
[13]	1237	Command: "NICK",
[69]	1238	Params: []string{uc.nick},
[60]	1239	})
	1240	uc.SendMessage(&irc.Message{
[13]	1241	Command: "USER",
[77]	1242	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1243	})
[44]	1244	}
[13]	1245
[197]	1246	func (uc *upstreamConn) runUntilRegistered() error {
	1247	for !uc.registered {
[212]	1248	msg, err := uc.ReadMessage()
[197]	1249	if err != nil {
	1250	return fmt.Errorf("failed to read message: %v", err)
	1251	}
	1252
	1253	if err := uc.handleMessage(msg); err != nil {
	1254	return fmt.Errorf("failed to handle message %q: %v", msg, err)
	1255	}
	1256	}
	1257
	1258	return nil
	1259	}
	1260
[95]	1261	func (uc *upstreamConn) requestSASL() bool {
	1262	if uc.network.SASL.Mechanism == "" {
	1263	return false
	1264	}
	1265
	1266	v, ok := uc.caps["sasl"]
	1267	if !ok {
	1268	return false
	1269	}
	1270	if v != "" {
	1271	mechanisms := strings.Split(v, ",")
	1272	found := false
	1273	for _, mech := range mechanisms {
	1274	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1275	found = true
	1276	break
	1277	}
	1278	}
	1279	if !found {
	1280	return false
	1281	}
	1282	}
	1283
	1284	return true
	1285	}
	1286
	1287	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1288	auth := &uc.network.SASL
	1289	switch name {
	1290	case "sasl":
	1291	if !ok {
	1292	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1293	return nil
	1294	}
	1295
	1296	switch auth.Mechanism {
	1297	case "PLAIN":
	1298	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1299	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1300	default:
	1301	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1302	}
	1303
	1304	uc.SendMessage(&irc.Message{
	1305	Command: "AUTHENTICATE",
	1306	Params: []string{auth.Mechanism},
	1307	})
[152]	1308	case "message-tags":
	1309	uc.tagsSupported = ok
[155]	1310	case "labeled-response":
	1311	uc.labelsSupported = ok
[193]	1312	case "batch", "server-time":
	1313	// Nothing to do
	1314	default:
	1315	uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
[95]	1316	}
	1317	return nil
	1318	}
	1319
[165]	1320	func (uc *upstreamConn) readMessages(ch chan<- event) error {
[13]	1321	for {
[210]	1322	msg, err := uc.ReadMessage()
[13]	1323	if err == io.EOF {
	1324	break
	1325	} else if err != nil {
	1326	return fmt.Errorf("failed to read IRC command: %v", err)
	1327	}
	1328
[165]	1329	ch <- eventUpstreamMessage{msg, uc}
[13]	1330	}
	1331
[45]	1332	return nil
[13]	1333	}
[60]	1334
[176]	1335	func (uc upstreamConn) SendMessageLabeled(downstreamID uint64, msg irc.Message) {
[155]	1336	if uc.labelsSupported {
	1337	if msg.Tags == nil {
	1338	msg.Tags = make(map[string]irc.TagValue)
	1339	}
[176]	1340	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
[161]	1341	uc.nextLabelID++
[155]	1342	}
	1343	uc.SendMessage(msg)
	1344	}
[178]	1345
	1346	// TODO: handle moving logs when a network name changes, when support for this is added
[215]	1347	func (uc upstreamConn) appendLog(entity string, msg irc.Message) {
[178]	1348	if uc.srv.LogPath == "" {
	1349	return
	1350	}
[215]	1351
	1352	ml, ok := uc.messageLoggers[entity]
	1353	if !ok {
	1354	ml = newMessageLogger(uc, entity)
	1355	uc.messageLoggers[entity] = ml
[178]	1356	}
	1357
[215]	1358	if err := ml.Append(msg); err != nil {
	1359	uc.logger.Printf("failed to log message: %v", err)
[178]	1360	}
	1361	}
[198]	1362
[239]	1363	func (uc upstreamConn) produce(target string, msg irc.Message, origin *downstreamConn) {
	1364	if target != "" {
	1365	uc.appendLog(target, msg)
	1366	}
	1367
[226]	1368	uc.network.ring.Produce(msg)
[227]	1369
	1370	uc.forEachDownstream(func(dc *downstreamConn) {
[238]	1371	if dc != origin \|\| dc.caps["echo-message"] {
	1372	dc.sendFromUpstream(msg, uc)
	1373	}
[227]	1374	})
[226]	1375	}
	1376
[198]	1377	func (uc *upstreamConn) updateAway() {
	1378	away := true
	1379	uc.forEachDownstream(func(*downstreamConn) {
	1380	away = false
	1381	})
	1382	if away == uc.away {
	1383	return
	1384	}
	1385	if away {
	1386	uc.SendMessage(&irc.Message{
	1387	Command: "AWAY",
	1388	Params: []string{"Auto away"},
	1389	})
	1390	} else {
	1391	uc.SendMessage(&irc.Message{
	1392	Command: "AWAY",
	1393	})
	1394	}
	1395	uc.away = away
	1396	}

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

Download in other formats: