Context Navigation

source: code/trunk/upstream.go@ 281

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

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

Download in other formats: