Context Navigation

source: code/trunk/upstream.go@ 290

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

Improve highlight matching

Detect word boundaries instead of just doing a sub-string check.

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

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

Download in other formats: