Context Navigation

source: code/trunk/upstream.go@ 346

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

Reply to WHO BouncerServ

Closes: https://todo.sr.ht/~emersion/soju/75

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

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

Download in other formats: