Context Navigation

upstream.go@ 298

Last change on this file since 298 was 296, checked in by delthas, 5 years ago

Update downstream nicks in single-server mode and after NICK

Previously, the downstream nick was never changed, even when the
downstream sent a NICK message or was in single-server mode with a
different nick.

This adds support for updating the downstream nick in the following
cases:

when a downstream sends NICK
additionally, in single-server mode:
- when a downstream connects and its single network is connected
- when an upstream connects
- when an upstream sends NICK

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

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

Context Navigation

source: code/trunk/upstream.go@ 298

Download in other formats: