Context Navigation

source: code/trunk/upstream.go@ 381

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

Don't perform TLS handshake in connectToUpstream

This defers TLS handshake until the first read or write operation. This
allows the upcoming identd server to register the connection before the
TLS handshake is complete, and is necessary because some IRC servers
send an ident request before that.

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

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

Download in other formats: