Context Navigation

upstream.go@ 304

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

Fix parsing upstream RPL_INVITING messages

Previously, we did not skip the first RPL_INVITING parameter, which is
the user nick (like in all replies), which made the parsing for that
reply incorrect.

This fixes RPL_INVITING parsing by skipping the first parameter.

File size: 39.7 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
[303]	323	case "NOTICE", "PRIVMSG", "TAGMSG":
[273]	324	if msg.Prefix == nil {
	325	return fmt.Errorf("expected a prefix")
	326	}
	327
[286]	328	var entity, text string
[303]	329	if msg.Command != "TAGMSG" {
	330	if err := parseMessageParams(msg, &entity, &text); err != nil {
	331	return err
	332	}
	333	} else {
	334	if err := parseMessageParams(msg, &entity); err != nil {
	335	return err
	336	}
[286]	337	}
	338
	339	if msg.Prefix.Name == serviceNick {
	340	uc.logger.Printf("skipping %v from soju's service: %v", msg.Command, msg)
	341	break
	342	}
	343	if entity == serviceNick {
	344	uc.logger.Printf("skipping %v to soju's service: %v", msg.Command, msg)
	345	break
	346	}
	347
[171]	348	if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
[239]	349	uc.produce("", msg, nil)
[303]	350	} else { // regular user message
[217]	351	target := entity
	352	if target == uc.nick {
[178]	353	target = msg.Prefix.Name
	354	}
[239]	355	uc.produce(target, msg, nil)
[287]	356
[288]	357	highlight := msg.Prefix.Name != uc.nick && isHighlight(text, uc.nick)
[287]	358	if ch, ok := uc.network.channels[target]; ok && ch.Detached && highlight {
	359	uc.forEachDownstream(func(dc *downstreamConn) {
	360	sendServiceNOTICE(dc, fmt.Sprintf("highlight in %v: <%v> %v", dc.marshalEntity(uc.network, ch.Name), msg.Prefix.Name, text))
	361	})
	362	}
[171]	363	}
[92]	364	case "CAP":
[95]	365	var subCmd string
	366	if err := parseMessageParams(msg, nil, &subCmd); err != nil {
	367	return err
[92]	368	}
[95]	369	subCmd = strings.ToUpper(subCmd)
	370	subParams := msg.Params[2:]
	371	switch subCmd {
	372	case "LS":
	373	if len(subParams) < 1 {
	374	return newNeedMoreParamsError(msg.Command)
	375	}
[281]	376	caps := subParams[len(subParams)-1]
[95]	377	more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
[92]	378
[281]	379	uc.handleSupportedCaps(caps)
[92]	380
[95]	381	if more {
	382	break // wait to receive all capabilities
	383	}
	384
[281]	385	uc.requestCaps()
[152]	386
[95]	387	if uc.requestSASL() {
	388	break // we'll send CAP END after authentication is completed
	389	}
	390
[92]	391	uc.SendMessage(&irc.Message{
	392	Command: "CAP",
	393	Params: []string{"END"},
	394	})
[95]	395	case "ACK", "NAK":
	396	if len(subParams) < 1 {
	397	return newNeedMoreParamsError(msg.Command)
	398	}
	399	caps := strings.Fields(subParams[0])
	400
	401	for _, name := range caps {
	402	if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
	403	return err
	404	}
	405	}
	406
[281]	407	if uc.registered {
	408	uc.forEachDownstream(func(dc *downstreamConn) {
	409	dc.updateSupportedCaps()
	410	})
	411	}
	412	case "NEW":
	413	if len(subParams) < 1 {
	414	return newNeedMoreParamsError(msg.Command)
	415	}
	416	uc.handleSupportedCaps(subParams[0])
	417	uc.requestCaps()
	418	case "DEL":
	419	if len(subParams) < 1 {
	420	return newNeedMoreParamsError(msg.Command)
	421	}
	422	caps := strings.Fields(subParams[0])
	423
	424	for _, c := range caps {
	425	delete(uc.supportedCaps, c)
	426	delete(uc.caps, c)
	427	}
	428
	429	if uc.registered {
	430	uc.forEachDownstream(func(dc *downstreamConn) {
	431	dc.updateSupportedCaps()
	432	})
	433	}
[95]	434	default:
	435	uc.logger.Printf("unhandled message: %v", msg)
[92]	436	}
[95]	437	case "AUTHENTICATE":
	438	if uc.saslClient == nil {
	439	return fmt.Errorf("received unexpected AUTHENTICATE message")
	440	}
	441
	442	// TODO: if a challenge is 400 bytes long, buffer it
	443	var challengeStr string
	444	if err := parseMessageParams(msg, &challengeStr); err != nil {
	445	uc.SendMessage(&irc.Message{
	446	Command: "AUTHENTICATE",
	447	Params: []string{"*"},
	448	})
	449	return err
	450	}
	451
	452	var challenge []byte
	453	if challengeStr != "+" {
	454	var err error
	455	challenge, err = base64.StdEncoding.DecodeString(challengeStr)
	456	if err != nil {
	457	uc.SendMessage(&irc.Message{
	458	Command: "AUTHENTICATE",
	459	Params: []string{"*"},
	460	})
	461	return err
	462	}
	463	}
	464
	465	var resp []byte
	466	var err error
	467	if !uc.saslStarted {
	468	_, resp, err = uc.saslClient.Start()
	469	uc.saslStarted = true
	470	} else {
	471	resp, err = uc.saslClient.Next(challenge)
	472	}
	473	if err != nil {
	474	uc.SendMessage(&irc.Message{
	475	Command: "AUTHENTICATE",
	476	Params: []string{"*"},
	477	})
	478	return err
	479	}
	480
	481	// TODO: send response in multiple chunks if >= 400 bytes
	482	var respStr = "+"
	483	if resp != nil {
	484	respStr = base64.StdEncoding.EncodeToString(resp)
	485	}
	486
	487	uc.SendMessage(&irc.Message{
	488	Command: "AUTHENTICATE",
	489	Params: []string{respStr},
	490	})
[125]	491	case irc.RPL_LOGGEDIN:
[95]	492	var account string
	493	if err := parseMessageParams(msg, nil, nil, &account); err != nil {
	494	return err
	495	}
	496	uc.logger.Printf("logged in with account %q", account)
[125]	497	case irc.RPL_LOGGEDOUT:
[95]	498	uc.logger.Printf("logged out")
[125]	499	case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
[95]	500	var info string
	501	if err := parseMessageParams(msg, nil, &info); err != nil {
	502	return err
	503	}
	504	switch msg.Command {
[125]	505	case irc.ERR_NICKLOCKED:
[95]	506	uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
[125]	507	case irc.ERR_SASLFAIL:
[95]	508	uc.logger.Printf("SASL authentication failed: %v", info)
[125]	509	case irc.ERR_SASLTOOLONG:
[95]	510	uc.logger.Printf("SASL message too long: %v", info)
	511	}
	512
	513	uc.saslClient = nil
	514	uc.saslStarted = false
	515
	516	uc.SendMessage(&irc.Message{
	517	Command: "CAP",
	518	Params: []string{"END"},
	519	})
[14]	520	case irc.RPL_WELCOME:
[55]	521	uc.registered = true
	522	uc.logger.Printf("connection registered")
[19]	523
[276]	524	uc.forEachDownstream(func(dc *downstreamConn) {
	525	dc.updateSupportedCaps()
	526	})
	527
[267]	528	for _, ch := range uc.network.channels {
[146]	529	params := []string{ch.Name}
	530	if ch.Key != "" {
	531	params = append(params, ch.Key)
	532	}
[60]	533	uc.SendMessage(&irc.Message{
[19]	534	Command: "JOIN",
[146]	535	Params: params,
[60]	536	})
[19]	537	}
[16]	538	case irc.RPL_MYINFO:
[139]	539	if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
[43]	540	return err
[16]	541	}
[139]	542	case irc.RPL_ISUPPORT:
	543	if err := parseMessageParams(msg, nil, nil); err != nil {
	544	return err
[16]	545	}
[139]	546	for _, token := range msg.Params[1 : len(msg.Params)-1] {
	547	negate := false
	548	parameter := token
	549	value := ""
	550	if strings.HasPrefix(token, "-") {
	551	negate = true
	552	token = token[1:]
	553	} else {
	554	if i := strings.IndexByte(token, '='); i >= 0 {
	555	parameter = token[:i]
	556	value = token[i+1:]
	557	}
	558	}
	559	if !negate {
	560	switch parameter {
	561	case "CHANMODES":
	562	parts := strings.SplitN(value, ",", 5)
	563	if len(parts) < 4 {
	564	return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
	565	}
	566	modes := make(map[byte]channelModeType)
	567	for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
	568	for j := 0; j < len(parts[i]); j++ {
	569	mode := parts[i][j]
	570	modes[mode] = mt
	571	}
	572	}
	573	uc.availableChannelModes = modes
	574	case "CHANTYPES":
	575	uc.availableChannelTypes = value
	576	case "PREFIX":
	577	if value == "" {
	578	uc.availableMemberships = nil
	579	} else {
	580	if value[0] != '(' {
	581	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	582	}
	583	sep := strings.IndexByte(value, ')')
	584	if sep < 0 \|\| len(value) != sep*2 {
	585	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	586	}
	587	memberships := make([]membership, len(value)/2-1)
	588	for i := range memberships {
	589	memberships[i] = membership{
	590	Mode: value[i+1],
	591	Prefix: value[sep+i+1],
	592	}
	593	}
	594	uc.availableMemberships = memberships
	595	}
	596	}
	597	} else {
	598	// TODO: handle ISUPPORT negations
	599	}
	600	}
[153]	601	case "BATCH":
	602	var tag string
	603	if err := parseMessageParams(msg, &tag); err != nil {
	604	return err
	605	}
	606
	607	if strings.HasPrefix(tag, "+") {
	608	tag = tag[1:]
	609	if _, ok := uc.batches[tag]; ok {
	610	return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
	611	}
	612	var batchType string
	613	if err := parseMessageParams(msg, nil, &batchType); err != nil {
	614	return err
	615	}
[155]	616	label := label
	617	if label == "" && msgBatch != nil {
	618	label = msgBatch.Label
	619	}
[153]	620	uc.batches[tag] = batch{
	621	Type: batchType,
	622	Params: msg.Params[2:],
	623	Outer: msgBatch,
[155]	624	Label: label,
[153]	625	}
	626	} else if strings.HasPrefix(tag, "-") {
	627	tag = tag[1:]
	628	if _, ok := uc.batches[tag]; !ok {
	629	return fmt.Errorf("unknown BATCH reference tag: %q", tag)
	630	}
	631	delete(uc.batches, tag)
	632	} else {
	633	return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
	634	}
[42]	635	case "NICK":
[83]	636	if msg.Prefix == nil {
	637	return fmt.Errorf("expected a prefix")
	638	}
	639
[43]	640	var newNick string
	641	if err := parseMessageParams(msg, &newNick); err != nil {
	642	return err
[42]	643	}
	644
[244]	645	me := false
[55]	646	if msg.Prefix.Name == uc.nick {
	647	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
[244]	648	me = true
[55]	649	uc.nick = newNick
[42]	650	}
	651
[55]	652	for _, ch := range uc.channels {
[292]	653	if memberships, ok := ch.Members[msg.Prefix.Name]; ok {
[42]	654	delete(ch.Members, msg.Prefix.Name)
[292]	655	ch.Members[newNick] = memberships
[215]	656	uc.appendLog(ch.Name, msg)
[253]	657	uc.appendHistory(ch.Name, msg)
[42]	658	}
	659	}
[82]	660
[244]	661	if !me {
[82]	662	uc.forEachDownstream(func(dc *downstreamConn) {
[261]	663	dc.SendMessage(dc.marshalMessage(msg, uc.network))
[82]	664	})
[296]	665	} else {
	666	uc.forEachDownstream(func(dc *downstreamConn) {
	667	dc.updateNick()
	668	})
[82]	669	}
[69]	670	case "JOIN":
	671	if msg.Prefix == nil {
	672	return fmt.Errorf("expected a prefix")
	673	}
[42]	674
[43]	675	var channels string
	676	if err := parseMessageParams(msg, &channels); err != nil {
	677	return err
[19]	678	}
[34]	679
[43]	680	for _, ch := range strings.Split(channels, ",") {
[55]	681	if msg.Prefix.Name == uc.nick {
	682	uc.logger.Printf("joined channel %q", ch)
	683	uc.channels[ch] = &upstreamChannel{
[34]	684	Name: ch,
[55]	685	conn: uc,
[292]	686	Members: make(map[string]*memberships),
[34]	687	}
[139]	688
	689	uc.SendMessage(&irc.Message{
	690	Command: "MODE",
	691	Params: []string{ch},
	692	})
[34]	693	} else {
[55]	694	ch, err := uc.getChannel(ch)
[34]	695	if err != nil {
	696	return err
	697	}
[294]	698	ch.Members[msg.Prefix.Name] = &memberships{}
[19]	699	}
[69]	700
[245]	701	chMsg := msg.Copy()
	702	chMsg.Params[0] = ch
	703	uc.produce(ch, chMsg, nil)
[19]	704	}
[69]	705	case "PART":
	706	if msg.Prefix == nil {
	707	return fmt.Errorf("expected a prefix")
	708	}
[34]	709
[43]	710	var channels string
	711	if err := parseMessageParams(msg, &channels); err != nil {
	712	return err
[34]	713	}
	714
[43]	715	for _, ch := range strings.Split(channels, ",") {
[55]	716	if msg.Prefix.Name == uc.nick {
	717	uc.logger.Printf("parted channel %q", ch)
	718	delete(uc.channels, ch)
[34]	719	} else {
[55]	720	ch, err := uc.getChannel(ch)
[34]	721	if err != nil {
	722	return err
	723	}
	724	delete(ch.Members, msg.Prefix.Name)
	725	}
[69]	726
[245]	727	chMsg := msg.Copy()
	728	chMsg.Params[0] = ch
	729	uc.produce(ch, chMsg, nil)
[34]	730	}
[159]	731	case "KICK":
	732	if msg.Prefix == nil {
	733	return fmt.Errorf("expected a prefix")
	734	}
	735
	736	var channel, user string
	737	if err := parseMessageParams(msg, &channel, &user); err != nil {
	738	return err
	739	}
	740
	741	if user == uc.nick {
	742	uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
	743	delete(uc.channels, channel)
	744	} else {
	745	ch, err := uc.getChannel(channel)
	746	if err != nil {
	747	return err
	748	}
	749	delete(ch.Members, user)
	750	}
	751
[245]	752	uc.produce(channel, msg, nil)
[83]	753	case "QUIT":
	754	if msg.Prefix == nil {
	755	return fmt.Errorf("expected a prefix")
	756	}
	757
	758	if msg.Prefix.Name == uc.nick {
	759	uc.logger.Printf("quit")
	760	}
	761
	762	for _, ch := range uc.channels {
[178]	763	if _, ok := ch.Members[msg.Prefix.Name]; ok {
	764	delete(ch.Members, msg.Prefix.Name)
	765
[215]	766	uc.appendLog(ch.Name, msg)
[253]	767	uc.appendHistory(ch.Name, msg)
[178]	768	}
[83]	769	}
	770
	771	if msg.Prefix.Name != uc.nick {
	772	uc.forEachDownstream(func(dc *downstreamConn) {
[261]	773	dc.SendMessage(dc.marshalMessage(msg, uc.network))
[83]	774	})
	775	}
[19]	776	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	777	var name, topic string
	778	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	779	return err
[19]	780	}
[55]	781	ch, err := uc.getChannel(name)
[19]	782	if err != nil {
	783	return err
	784	}
	785	if msg.Command == irc.RPL_TOPIC {
[43]	786	ch.Topic = topic
[19]	787	} else {
	788	ch.Topic = ""
	789	}
	790	case "TOPIC":
[43]	791	var name string
[74]	792	if err := parseMessageParams(msg, &name); err != nil {
[43]	793	return err
[19]	794	}
[55]	795	ch, err := uc.getChannel(name)
[19]	796	if err != nil {
	797	return err
	798	}
	799	if len(msg.Params) > 1 {
	800	ch.Topic = msg.Params[1]
	801	} else {
	802	ch.Topic = ""
	803	}
[245]	804	uc.produce(ch.Name, msg, nil)
[139]	805	case "MODE":
	806	var name, modeStr string
	807	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	808	return err
	809	}
	810
	811	if !uc.isChannel(name) { // user mode change
	812	if name != uc.nick {
	813	return fmt.Errorf("received MODE message for unknown nick %q", name)
	814	}
	815	return uc.modes.Apply(modeStr)
	816	// TODO: notify downstreams about user mode change?
	817	} else { // channel mode change
	818	ch, err := uc.getChannel(name)
	819	if err != nil {
	820	return err
	821	}
	822
[293]	823	needMarshaling, err := applyChannelModes(ch, modeStr, msg.Params[2:])
	824	if err != nil {
	825	return err
[139]	826	}
	827
[293]	828	uc.appendLog(ch.Name, msg)
	829	uc.forEachDownstream(func(dc *downstreamConn) {
	830	params := make([]string, len(msg.Params))
	831	params[0] = dc.marshalEntity(uc.network, name)
	832	params[1] = modeStr
	833
	834	copy(params[2:], msg.Params[2:])
	835	for i, modeParam := range params[2:] {
	836	if _, ok := needMarshaling[i]; ok {
	837	params[2+i] = dc.marshalEntity(uc.network, modeParam)
	838	}
	839	}
	840
	841	dc.SendMessage(&irc.Message{
	842	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
	843	Command: "MODE",
	844	Params: params,
	845	})
	846	})
[139]	847	}
	848	case irc.RPL_UMODEIS:
	849	if err := parseMessageParams(msg, nil); err != nil {
	850	return err
	851	}
	852	modeStr := ""
	853	if len(msg.Params) > 1 {
	854	modeStr = msg.Params[1]
	855	}
	856
	857	uc.modes = ""
	858	if err := uc.modes.Apply(modeStr); err != nil {
	859	return err
	860	}
	861	// TODO: send RPL_UMODEIS to downstream connections when applicable
	862	case irc.RPL_CHANNELMODEIS:
	863	var channel string
	864	if err := parseMessageParams(msg, nil, &channel); err != nil {
	865	return err
	866	}
	867	modeStr := ""
	868	if len(msg.Params) > 2 {
	869	modeStr = msg.Params[2]
	870	}
	871
	872	ch, err := uc.getChannel(channel)
	873	if err != nil {
	874	return err
	875	}
	876
	877	firstMode := ch.modes == nil
	878	ch.modes = make(map[byte]string)
[293]	879	if _, err := applyChannelModes(ch, modeStr, msg.Params[3:]); err != nil {
[139]	880	return err
	881	}
	882	if firstMode {
	883	modeStr, modeParams := ch.modes.Format()
	884
	885	uc.forEachDownstream(func(dc *downstreamConn) {
[260]	886	params := []string{dc.nick, dc.marshalEntity(uc.network, channel), modeStr}
[139]	887	params = append(params, modeParams...)
	888
	889	dc.SendMessage(&irc.Message{
	890	Prefix: dc.srv.prefix(),
	891	Command: irc.RPL_CHANNELMODEIS,
	892	Params: params,
	893	})
	894	})
	895	}
[162]	896	case rpl_creationtime:
	897	var channel, creationTime string
	898	if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
	899	return err
	900	}
	901
	902	ch, err := uc.getChannel(channel)
	903	if err != nil {
	904	return err
	905	}
	906
	907	firstCreationTime := ch.creationTime == ""
	908	ch.creationTime = creationTime
	909	if firstCreationTime {
	910	uc.forEachDownstream(func(dc *downstreamConn) {
	911	dc.SendMessage(&irc.Message{
	912	Prefix: dc.srv.prefix(),
	913	Command: rpl_creationtime,
	914	Params: []string{dc.nick, channel, creationTime},
	915	})
	916	})
	917	}
[19]	918	case rpl_topicwhotime:
[43]	919	var name, who, timeStr string
	920	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	921	return err
[19]	922	}
[55]	923	ch, err := uc.getChannel(name)
[19]	924	if err != nil {
	925	return err
	926	}
[43]	927	ch.TopicWho = who
	928	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	929	if err != nil {
	930	return fmt.Errorf("failed to parse topic time: %v", err)
	931	}
	932	ch.TopicTime = time.Unix(sec, 0)
[177]	933	case irc.RPL_LIST:
	934	var channel, clients, topic string
	935	if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
	936	return err
	937	}
	938
[181]	939	pl := uc.getPendingLIST()
[177]	940	if pl == nil {
	941	return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
	942	}
	943
	944	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	945	dc.SendMessage(&irc.Message{
	946	Prefix: dc.srv.prefix(),
	947	Command: irc.RPL_LIST,
[260]	948	Params: []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
[177]	949	})
	950	})
	951	case irc.RPL_LISTEND:
[181]	952	ok := uc.endPendingLISTs(false)
[177]	953	if !ok {
	954	return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
	955	}
[19]	956	case irc.RPL_NAMREPLY:
[43]	957	var name, statusStr, members string
	958	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	959	return err
[19]	960	}
[140]	961
	962	ch, ok := uc.channels[name]
	963	if !ok {
	964	// NAMES on a channel we have not joined, forward to downstream
[161]	965	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	966	channel := dc.marshalEntity(uc.network, name)
[174]	967	members := splitSpace(members)
[140]	968	for i, member := range members {
[292]	969	memberships, nick := uc.parseMembershipPrefix(member)
	970	members[i] = memberships.Format(dc) + dc.marshalEntity(uc.network, nick)
[140]	971	}
	972	memberStr := strings.Join(members, " ")
	973
	974	dc.SendMessage(&irc.Message{
	975	Prefix: dc.srv.prefix(),
	976	Command: irc.RPL_NAMREPLY,
	977	Params: []string{dc.nick, statusStr, channel, memberStr},
	978	})
	979	})
	980	return nil
[19]	981	}
	982
[43]	983	status, err := parseChannelStatus(statusStr)
[19]	984	if err != nil {
	985	return err
	986	}
	987	ch.Status = status
	988
[174]	989	for _, s := range splitSpace(members) {
[292]	990	memberships, nick := uc.parseMembershipPrefix(s)
	991	ch.Members[nick] = memberships
[19]	992	}
	993	case irc.RPL_ENDOFNAMES:
[43]	994	var name string
	995	if err := parseMessageParams(msg, nil, &name); err != nil {
	996	return err
[25]	997	}
[140]	998
	999	ch, ok := uc.channels[name]
	1000	if !ok {
	1001	// NAMES on a channel we have not joined, forward to downstream
[161]	1002	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1003	channel := dc.marshalEntity(uc.network, name)
[140]	1004
	1005	dc.SendMessage(&irc.Message{
	1006	Prefix: dc.srv.prefix(),
	1007	Command: irc.RPL_ENDOFNAMES,
	1008	Params: []string{dc.nick, channel, "End of /NAMES list"},
	1009	})
	1010	})
	1011	return nil
[25]	1012	}
	1013
[34]	1014	if ch.complete {
	1015	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	1016	}
[25]	1017	ch.complete = true
[27]	1018
[73]	1019	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	1020	forwardChannel(dc, ch)
[40]	1021	})
[127]	1022	case irc.RPL_WHOREPLY:
	1023	var channel, username, host, server, nick, mode, trailing string
	1024	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	1025	return err
	1026	}
	1027
	1028	parts := strings.SplitN(trailing, " ", 2)
	1029	if len(parts) != 2 {
	1030	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	1031	}
	1032	realname := parts[1]
	1033	hops, err := strconv.Atoi(parts[0])
	1034	if err != nil {
	1035	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	1036	}
	1037	hops++
	1038
	1039	trailing = strconv.Itoa(hops) + " " + realname
	1040
[161]	1041	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	1042	channel := channel
	1043	if channel != "*" {
[260]	1044	channel = dc.marshalEntity(uc.network, channel)
[127]	1045	}
[260]	1046	nick := dc.marshalEntity(uc.network, nick)
[127]	1047	dc.SendMessage(&irc.Message{
	1048	Prefix: dc.srv.prefix(),
	1049	Command: irc.RPL_WHOREPLY,
	1050	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	1051	})
	1052	})
	1053	case irc.RPL_ENDOFWHO:
	1054	var name string
	1055	if err := parseMessageParams(msg, nil, &name); err != nil {
	1056	return err
	1057	}
	1058
[161]	1059	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	1060	name := name
	1061	if name != "*" {
	1062	// TODO: support WHO masks
[260]	1063	name = dc.marshalEntity(uc.network, name)
[127]	1064	}
	1065	dc.SendMessage(&irc.Message{
	1066	Prefix: dc.srv.prefix(),
	1067	Command: irc.RPL_ENDOFWHO,
[142]	1068	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	1069	})
	1070	})
[128]	1071	case irc.RPL_WHOISUSER:
	1072	var nick, username, host, realname string
	1073	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	1074	return err
	1075	}
	1076
[161]	1077	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1078	nick := dc.marshalEntity(uc.network, nick)
[128]	1079	dc.SendMessage(&irc.Message{
	1080	Prefix: dc.srv.prefix(),
	1081	Command: irc.RPL_WHOISUSER,
	1082	Params: []string{dc.nick, nick, username, host, "*", realname},
	1083	})
	1084	})
	1085	case irc.RPL_WHOISSERVER:
	1086	var nick, server, serverInfo string
	1087	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	1088	return err
	1089	}
	1090
[161]	1091	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1092	nick := dc.marshalEntity(uc.network, nick)
[128]	1093	dc.SendMessage(&irc.Message{
	1094	Prefix: dc.srv.prefix(),
	1095	Command: irc.RPL_WHOISSERVER,
	1096	Params: []string{dc.nick, nick, server, serverInfo},
	1097	})
	1098	})
	1099	case irc.RPL_WHOISOPERATOR:
	1100	var nick string
	1101	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1102	return err
	1103	}
	1104
[161]	1105	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1106	nick := dc.marshalEntity(uc.network, nick)
[128]	1107	dc.SendMessage(&irc.Message{
	1108	Prefix: dc.srv.prefix(),
	1109	Command: irc.RPL_WHOISOPERATOR,
	1110	Params: []string{dc.nick, nick, "is an IRC operator"},
	1111	})
	1112	})
	1113	case irc.RPL_WHOISIDLE:
	1114	var nick string
	1115	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	1116	return err
	1117	}
	1118
[161]	1119	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1120	nick := dc.marshalEntity(uc.network, nick)
[128]	1121	params := []string{dc.nick, nick}
	1122	params = append(params, msg.Params[2:]...)
	1123	dc.SendMessage(&irc.Message{
	1124	Prefix: dc.srv.prefix(),
	1125	Command: irc.RPL_WHOISIDLE,
	1126	Params: params,
	1127	})
	1128	})
	1129	case irc.RPL_WHOISCHANNELS:
	1130	var nick, channelList string
	1131	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	1132	return err
	1133	}
[174]	1134	channels := splitSpace(channelList)
[128]	1135
[161]	1136	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1137	nick := dc.marshalEntity(uc.network, nick)
[128]	1138	channelList := make([]string, len(channels))
	1139	for i, channel := range channels {
[139]	1140	prefix, channel := uc.parseMembershipPrefix(channel)
[260]	1141	channel = dc.marshalEntity(uc.network, channel)
[292]	1142	channelList[i] = prefix.Format(dc) + channel
[128]	1143	}
	1144	channels := strings.Join(channelList, " ")
	1145	dc.SendMessage(&irc.Message{
	1146	Prefix: dc.srv.prefix(),
	1147	Command: irc.RPL_WHOISCHANNELS,
	1148	Params: []string{dc.nick, nick, channels},
	1149	})
	1150	})
	1151	case irc.RPL_ENDOFWHOIS:
	1152	var nick string
	1153	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1154	return err
	1155	}
	1156
[161]	1157	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[260]	1158	nick := dc.marshalEntity(uc.network, nick)
[128]	1159	dc.SendMessage(&irc.Message{
	1160	Prefix: dc.srv.prefix(),
	1161	Command: irc.RPL_ENDOFWHOIS,
[142]	1162	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	1163	})
	1164	})
[115]	1165	case "INVITE":
[273]	1166	var nick, channel string
[115]	1167	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1168	return err
	1169	}
	1170
	1171	uc.forEachDownstream(func(dc *downstreamConn) {
	1172	dc.SendMessage(&irc.Message{
[260]	1173	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
[115]	1174	Command: "INVITE",
[260]	1175	Params: []string{dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
[115]	1176	})
	1177	})
[163]	1178	case irc.RPL_INVITING:
[273]	1179	var nick, channel string
[304]	1180	if err := parseMessageParams(msg, nil, &nick, &channel); err != nil {
[163]	1181	return err
	1182	}
	1183
	1184	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1185	dc.SendMessage(&irc.Message{
	1186	Prefix: dc.srv.prefix(),
	1187	Command: irc.RPL_INVITING,
[260]	1188	Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
[163]	1189	})
	1190	})
[272]	1191	case irc.RPL_AWAY:
	1192	var nick, reason string
	1193	if err := parseMessageParams(msg, nil, &nick, &reason); err != nil {
	1194	return err
	1195	}
	1196
[274]	1197	uc.forEachDownstream(func(dc *downstreamConn) {
[272]	1198	dc.SendMessage(&irc.Message{
	1199	Prefix: dc.srv.prefix(),
	1200	Command: irc.RPL_AWAY,
	1201	Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), reason},
	1202	})
	1203	})
[276]	1204	case "AWAY":
	1205	if msg.Prefix == nil {
	1206	return fmt.Errorf("expected a prefix")
	1207	}
	1208
	1209	uc.forEachDownstream(func(dc *downstreamConn) {
	1210	if !dc.caps["away-notify"] {
	1211	return
	1212	}
	1213	dc.SendMessage(&irc.Message{
	1214	Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
	1215	Command: "AWAY",
	1216	Params: msg.Params,
	1217	})
	1218	})
[300]	1219	case irc.RPL_BANLIST, irc.RPL_INVITELIST, irc.RPL_EXCEPTLIST:
	1220	var channel, mask string
	1221	if err := parseMessageParams(msg, nil, &channel, &mask); err != nil {
	1222	return err
	1223	}
	1224	var addNick, addTime string
	1225	if len(msg.Params) >= 5 {
	1226	addNick = msg.Params[3]
	1227	addTime = msg.Params[4]
	1228	}
	1229
	1230	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1231	channel := dc.marshalEntity(uc.network, channel)
	1232
	1233	var params []string
	1234	if addNick != "" && addTime != "" {
	1235	addNick := dc.marshalEntity(uc.network, addNick)
	1236	params = []string{dc.nick, channel, mask, addNick, addTime}
	1237	} else {
	1238	params = []string{dc.nick, channel, mask}
	1239	}
	1240
	1241	dc.SendMessage(&irc.Message{
	1242	Prefix: dc.srv.prefix(),
	1243	Command: msg.Command,
	1244	Params: params,
	1245	})
	1246	})
	1247	case irc.RPL_ENDOFBANLIST, irc.RPL_ENDOFINVITELIST, irc.RPL_ENDOFEXCEPTLIST:
	1248	var channel, trailing string
	1249	if err := parseMessageParams(msg, nil, &channel, &trailing); err != nil {
	1250	return err
	1251	}
	1252
	1253	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1254	upstreamChannel := dc.marshalEntity(uc.network, channel)
	1255	dc.SendMessage(&irc.Message{
	1256	Prefix: dc.srv.prefix(),
	1257	Command: msg.Command,
	1258	Params: []string{dc.nick, upstreamChannel, trailing},
	1259	})
	1260	})
[302]	1261	case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
	1262	var command, reason string
	1263	if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
	1264	return err
	1265	}
	1266
	1267	if command == "LIST" {
	1268	ok := uc.endPendingLISTs(false)
	1269	if !ok {
	1270	return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
	1271	}
	1272	}
	1273
	1274	if downstreamID != 0 {
	1275	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1276	dc.SendMessage(&irc.Message{
	1277	Prefix: uc.srv.prefix(),
	1278	Command: msg.Command,
	1279	Params: []string{dc.nick, command, reason},
	1280	})
	1281	})
	1282	}
[155]	1283	case "ACK":
	1284	// Ignore
[198]	1285	case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
	1286	// Ignore
[16]	1287	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	1288	// Ignore
	1289	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	1290	// Ignore
	1291	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	1292	// Ignore
[177]	1293	case irc.RPL_LISTSTART:
	1294	// Ignore
[14]	1295	case rpl_localusers, rpl_globalusers:
	1296	// Ignore
[96]	1297	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1298	// Ignore
[13]	1299	default:
[95]	1300	uc.logger.Printf("unhandled message: %v", msg)
[302]	1301	if downstreamID != 0 {
	1302	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1303	// best effort marshaling for unknown messages, replies and errors:
	1304	// most numerics start with the user nick, marshal it if that's the case
	1305	// otherwise, conservately keep the params without marshaling
	1306	params := msg.Params
	1307	if _, err := strconv.Atoi(msg.Command); err == nil { // numeric
	1308	if len(msg.Params) > 0 && isOurNick(uc.network, msg.Params[0]) {
	1309	params[0] = dc.nick
	1310	}
	1311	}
	1312	dc.SendMessage(&irc.Message{
	1313	Prefix: uc.srv.prefix(),
	1314	Command: msg.Command,
	1315	Params: params,
	1316	})
	1317	})
	1318	}
[13]	1319	}
[14]	1320	return nil
[13]	1321	}
	1322
[281]	1323	func (uc *upstreamConn) handleSupportedCaps(capsStr string) {
	1324	caps := strings.Fields(capsStr)
	1325	for _, s := range caps {
	1326	kv := strings.SplitN(s, "=", 2)
	1327	k := strings.ToLower(kv[0])
	1328	var v string
	1329	if len(kv) == 2 {
	1330	v = kv[1]
	1331	}
	1332	uc.supportedCaps[k] = v
	1333	}
	1334	}
	1335
	1336	func (uc *upstreamConn) requestCaps() {
	1337	var requestCaps []string
[282]	1338	for c := range permanentUpstreamCaps {
[281]	1339	if _, ok := uc.supportedCaps[c]; ok && !uc.caps[c] {
	1340	requestCaps = append(requestCaps, c)
	1341	}
	1342	}
	1343
	1344	if uc.requestSASL() && !uc.caps["sasl"] {
	1345	requestCaps = append(requestCaps, "sasl")
	1346	}
	1347
[282]	1348	if len(requestCaps) == 0 {
	1349	return
	1350	}
	1351
	1352	uc.SendMessage(&irc.Message{
	1353	Command: "CAP",
	1354	Params: []string{"REQ", strings.Join(requestCaps, " ")},
	1355	})
	1356	}
	1357
	1358	func (uc *upstreamConn) requestSASL() bool {
	1359	if uc.network.SASL.Mechanism == "" {
	1360	return false
	1361	}
	1362
	1363	v, ok := uc.supportedCaps["sasl"]
	1364	if !ok {
	1365	return false
	1366	}
	1367	if v != "" {
	1368	mechanisms := strings.Split(v, ",")
	1369	found := false
	1370	for _, mech := range mechanisms {
	1371	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1372	found = true
	1373	break
	1374	}
	1375	}
	1376	if !found {
	1377	return false
	1378	}
	1379	}
	1380
	1381	return true
	1382	}
	1383
	1384	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1385	uc.caps[name] = ok
	1386
	1387	switch name {
	1388	case "sasl":
	1389	if !ok {
	1390	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1391	return nil
	1392	}
	1393
	1394	auth := &uc.network.SASL
	1395	switch auth.Mechanism {
	1396	case "PLAIN":
	1397	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1398	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1399	default:
	1400	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1401	}
	1402
[281]	1403	uc.SendMessage(&irc.Message{
[282]	1404	Command: "AUTHENTICATE",
	1405	Params: []string{auth.Mechanism},
[281]	1406	})
[282]	1407	default:
	1408	if permanentUpstreamCaps[name] {
	1409	break
	1410	}
	1411	uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
[281]	1412	}
[282]	1413	return nil
[281]	1414	}
	1415
[174]	1416	func splitSpace(s string) []string {
	1417	return strings.FieldsFunc(s, func(r rune) bool {
	1418	return r == ' '
	1419	})
	1420	}
	1421
[55]	1422	func (uc *upstreamConn) register() {
[77]	1423	uc.nick = uc.network.Nick
	1424	uc.username = uc.network.Username
	1425	if uc.username == "" {
	1426	uc.username = uc.nick
	1427	}
	1428	uc.realname = uc.network.Realname
	1429	if uc.realname == "" {
	1430	uc.realname = uc.nick
	1431	}
	1432
[60]	1433	uc.SendMessage(&irc.Message{
[92]	1434	Command: "CAP",
	1435	Params: []string{"LS", "302"},
	1436	})
	1437
[93]	1438	if uc.network.Pass != "" {
	1439	uc.SendMessage(&irc.Message{
	1440	Command: "PASS",
	1441	Params: []string{uc.network.Pass},
	1442	})
	1443	}
	1444
[92]	1445	uc.SendMessage(&irc.Message{
[13]	1446	Command: "NICK",
[69]	1447	Params: []string{uc.nick},
[60]	1448	})
	1449	uc.SendMessage(&irc.Message{
[13]	1450	Command: "USER",
[77]	1451	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1452	})
[44]	1453	}
[13]	1454
[197]	1455	func (uc *upstreamConn) runUntilRegistered() error {
	1456	for !uc.registered {
[212]	1457	msg, err := uc.ReadMessage()
[197]	1458	if err != nil {
	1459	return fmt.Errorf("failed to read message: %v", err)
	1460	}
	1461
	1462	if err := uc.handleMessage(msg); err != nil {
	1463	return fmt.Errorf("failed to handle message %q: %v", msg, err)
	1464	}
	1465	}
	1466
[263]	1467	for _, command := range uc.network.ConnectCommands {
	1468	m, err := irc.ParseMessage(command)
	1469	if err != nil {
	1470	uc.logger.Printf("failed to parse connect command %q: %v", command, err)
	1471	} else {
	1472	uc.SendMessage(m)
	1473	}
	1474	}
	1475
[197]	1476	return nil
	1477	}
	1478
[165]	1479	func (uc *upstreamConn) readMessages(ch chan<- event) error {
[13]	1480	for {
[210]	1481	msg, err := uc.ReadMessage()
[13]	1482	if err == io.EOF {
	1483	break
	1484	} else if err != nil {
	1485	return fmt.Errorf("failed to read IRC command: %v", err)
	1486	}
	1487
[165]	1488	ch <- eventUpstreamMessage{msg, uc}
[13]	1489	}
	1490
[45]	1491	return nil
[13]	1492	}
[60]	1493
[303]	1494	func (uc upstreamConn) SendMessage(msg irc.Message) {
	1495	if !uc.caps["message-tags"] {
	1496	msg = msg.Copy()
	1497	msg.Tags = nil
	1498	}
	1499
	1500	uc.conn.SendMessage(msg)
	1501	}
	1502
[176]	1503	func (uc upstreamConn) SendMessageLabeled(downstreamID uint64, msg irc.Message) {
[278]	1504	if uc.caps["labeled-response"] {
[155]	1505	if msg.Tags == nil {
	1506	msg.Tags = make(map[string]irc.TagValue)
	1507	}
[176]	1508	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
[161]	1509	uc.nextLabelID++
[155]	1510	}
	1511	uc.SendMessage(msg)
	1512	}
[178]	1513
	1514	// TODO: handle moving logs when a network name changes, when support for this is added
[215]	1515	func (uc upstreamConn) appendLog(entity string, msg irc.Message) {
[178]	1516	if uc.srv.LogPath == "" {
	1517	return
	1518	}
[215]	1519
	1520	ml, ok := uc.messageLoggers[entity]
	1521	if !ok {
[248]	1522	ml = newMessageLogger(uc.network, entity)
[215]	1523	uc.messageLoggers[entity] = ml
[178]	1524	}
	1525
[215]	1526	if err := ml.Append(msg); err != nil {
	1527	uc.logger.Printf("failed to log message: %v", err)
[178]	1528	}
	1529	}
[198]	1530
[253]	1531	// appendHistory appends a message to the history. entity can be empty.
	1532	func (uc upstreamConn) appendHistory(entity string, msg irc.Message) {
[284]	1533	detached := false
	1534	if ch, ok := uc.network.channels[entity]; ok {
	1535	detached = ch.Detached
	1536	}
	1537
[253]	1538	// If no client is offline, no need to append the message to the buffer
[284]	1539	if len(uc.network.offlineClients) == 0 && !detached {
[253]	1540	return
	1541	}
	1542
	1543	history, ok := uc.network.history[entity]
	1544	if !ok {
	1545	history = &networkHistory{
	1546	offlineClients: make(map[string]uint64),
	1547	ring: NewRing(uc.srv.RingCap),
	1548	}
	1549	uc.network.history[entity] = history
	1550
	1551	for clientName, _ := range uc.network.offlineClients {
	1552	history.offlineClients[clientName] = 0
	1553	}
[284]	1554
	1555	if detached {
	1556	// If the channel is detached, online clients act as offline
	1557	// clients too
	1558	uc.forEachDownstream(func(dc *downstreamConn) {
	1559	history.offlineClients[dc.clientName] = 0
	1560	})
	1561	}
[253]	1562	}
	1563
	1564	history.ring.Produce(msg)
	1565	}
	1566
[245]	1567	// produce appends a message to the logs, adds it to the history and forwards
	1568	// it to connected downstream connections.
	1569	//
	1570	// If origin is not nil and origin doesn't support echo-message, the message is
	1571	// forwarded to all connections except origin.
[239]	1572	func (uc upstreamConn) produce(target string, msg irc.Message, origin *downstreamConn) {
	1573	if target != "" {
	1574	uc.appendLog(target, msg)
	1575	}
	1576
[253]	1577	uc.appendHistory(target, msg)
[227]	1578
[284]	1579	// Don't forward messages if it's a detached channel
	1580	if ch, ok := uc.network.channels[target]; ok && ch.Detached {
	1581	return
	1582	}
	1583
[227]	1584	uc.forEachDownstream(func(dc *downstreamConn) {
[238]	1585	if dc != origin \|\| dc.caps["echo-message"] {
[261]	1586	dc.SendMessage(dc.marshalMessage(msg, uc.network))
[238]	1587	}
[227]	1588	})
[226]	1589	}
	1590
[198]	1591	func (uc *upstreamConn) updateAway() {
	1592	away := true
	1593	uc.forEachDownstream(func(*downstreamConn) {
	1594	away = false
	1595	})
	1596	if away == uc.away {
	1597	return
	1598	}
	1599	if away {
	1600	uc.SendMessage(&irc.Message{
	1601	Command: "AWAY",
	1602	Params: []string{"Auto away"},
	1603	})
	1604	} else {
	1605	uc.SendMessage(&irc.Message{
	1606	Command: "AWAY",
	1607	})
	1608	}
	1609	uc.away = away
	1610	}

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

Context Navigation

source: code/trunk/upstream.go@ 304

Download in other formats: