Context Navigation

upstream.go@ 421

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

Add support for the extended-join capability

This simple implementation only advertises extended-join to downstreams
when all upstreams support it.

In the future, it could be modified so that soju buffers incoming
upstream JOINs, sends a WHO, waits for the reply, and sends an extended
join to the downstream; so that soju could advertise that capability
even when some or all upstreams do not support it. This is not the case
in this commit.

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

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

Context Navigation

source: code/trunk/upstream.go@ 421

Download in other formats: