Context Navigation

source: code/trunk/upstream.go@ 402

Last change on this file since 402 was 402, checked in by contact, 5 years ago
go fmt
File size: 42.4 KB

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

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

Download in other formats: