Context Navigation

upstream.go@ 157

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

Fix wrong handling of members parameter of RPL_NAMREPLY

Some servers (namely UnrealIRCd) wrongly add a trailing space to the
members parameters of the RPL_NAMREPLY command, which was not handled
correctly.

Adding a trailing space is not legal wrt the IRC specs, but since
UnrealIRCd does it and is in wide use today, we have to work around it.

File size: 27.4 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
	4	"crypto/tls"
[95]	5	"encoding/base64"
[155]	6	"errors"
[13]	7	"fmt"
	8	"io"
	9	"net"
[19]	10	"strconv"
[17]	11	"strings"
[19]	12	"time"
[13]	13
[95]	14	"github.com/emersion/go-sasl"
[13]	15	"gopkg.in/irc.v3"
	16	)
	17
[19]	18	type upstreamChannel struct {
	19	Name string
[46]	20	conn *upstreamConn
[19]	21	Topic string
	22	TopicWho string
	23	TopicTime time.Time
	24	Status channelStatus
[139]	25	modes channelModes
	26	Members map[string]*membership
[25]	27	complete bool
[19]	28	}
	29
[13]	30	type upstreamConn struct {
[77]	31	network *network
[21]	32	logger Logger
[19]	33	net net.Conn
	34	irc *irc.Conn
	35	srv *Server
[37]	36	user *user
[102]	37	outgoing chan<- *irc.Message
[16]	38
	39	serverName string
	40	availableUserModes string
[139]	41	availableChannelModes map[byte]channelModeType
	42	availableChannelTypes string
	43	availableMemberships []membership
[19]	44
	45	registered bool
[42]	46	nick string
[77]	47	username string
	48	realname string
[33]	49	closed bool
[139]	50	modes userModes
[19]	51	channels map[string]*upstreamChannel
[92]	52	caps map[string]string
[153]	53	batches map[string]batch
[95]	54
[155]	55	tagsSupported bool
	56	labelsSupported bool
	57	nextLabelId uint64
[152]	58
[95]	59	saslClient sasl.Client
	60	saslStarted bool
[13]	61	}
	62
[77]	63	func connectToUpstream(network network) (upstreamConn, error) {
	64	logger := &prefixLogger{network.user.srv.Logger, fmt.Sprintf("upstream %q: ", network.Addr)}
[33]	65
[77]	66	addr := network.Addr
	67	if !strings.ContainsRune(addr, ':') {
	68	addr = addr + ":6697"
	69	}
	70
	71	logger.Printf("connecting to TLS server at address %q", addr)
	72	netConn, err := tls.Dial("tcp", addr, nil)
[33]	73	if err != nil {
[77]	74	return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
[33]	75	}
	76
[67]	77	setKeepAlive(netConn)
	78
[102]	79	outgoing := make(chan *irc.Message, 64)
[55]	80	uc := &upstreamConn{
[139]	81	network: network,
	82	logger: logger,
	83	net: netConn,
	84	irc: irc.NewConn(netConn),
	85	srv: network.user.srv,
	86	user: network.user,
	87	outgoing: outgoing,
	88	channels: make(map[string]*upstreamChannel),
	89	caps: make(map[string]string),
[153]	90	batches: make(map[string]batch),
[139]	91	availableChannelTypes: stdChannelTypes,
	92	availableChannelModes: stdChannelModes,
	93	availableMemberships: stdMemberships,
[33]	94	}
	95
	96	go func() {
[102]	97	for msg := range outgoing {
[64]	98	if uc.srv.Debug {
	99	uc.logger.Printf("sent: %v", msg)
	100	}
[55]	101	if err := uc.irc.WriteMessage(msg); err != nil {
	102	uc.logger.Printf("failed to write message: %v", err)
[33]	103	}
	104	}
[55]	105	if err := uc.net.Close(); err != nil {
	106	uc.logger.Printf("failed to close connection: %v", err)
[45]	107	} else {
[55]	108	uc.logger.Printf("connection closed")
[45]	109	}
[33]	110	}()
	111
[55]	112	return uc, nil
[33]	113	}
	114
[55]	115	func (uc *upstreamConn) Close() error {
	116	if uc.closed {
[33]	117	return fmt.Errorf("upstream connection already closed")
	118	}
[102]	119	close(uc.outgoing)
[55]	120	uc.closed = true
[33]	121	return nil
	122	}
	123
[73]	124	func (uc upstreamConn) forEachDownstream(f func(downstreamConn)) {
	125	uc.user.forEachDownstream(func(dc *downstreamConn) {
[77]	126	if dc.network != nil && dc.network != uc.network {
[73]	127	return
	128	}
	129	f(dc)
	130	})
	131	}
	132
[155]	133	func (uc upstreamConn) forEachDownstreamById(id uint64, f func(downstreamConn)) {
	134	uc.forEachDownstream(func(dc *downstreamConn) {
	135	if id != 0 && id != dc.id {
	136	return
	137	}
	138	f(dc)
	139	})
	140	}
	141
[55]	142	func (uc upstreamConn) getChannel(name string) (upstreamChannel, error) {
	143	ch, ok := uc.channels[name]
[19]	144	if !ok {
	145	return nil, fmt.Errorf("unknown channel %q", name)
	146	}
	147	return ch, nil
	148	}
	149
[129]	150	func (uc *upstreamConn) isChannel(entity string) bool {
[139]	151	if i := strings.IndexByte(uc.availableChannelTypes, entity[0]); i >= 0 {
	152	return true
[129]	153	}
	154	return false
	155	}
	156
[139]	157	func (uc upstreamConn) parseMembershipPrefix(s string) (membership membership, nick string) {
	158	for _, m := range uc.availableMemberships {
	159	if m.Prefix == s[0] {
	160	return &m, s[1:]
	161	}
	162	}
	163	return nil, s
	164	}
	165
[55]	166	func (uc upstreamConn) handleMessage(msg irc.Message) error {
[155]	167	var label string
	168	if l, ok := msg.GetTag("label"); ok {
	169	label = l
	170	}
	171
[153]	172	var msgBatch *batch
	173	if batchName, ok := msg.GetTag("batch"); ok {
	174	b, ok := uc.batches[batchName]
	175	if !ok {
	176	return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
	177	}
	178	msgBatch = &b
[155]	179	if label == "" {
	180	label = msgBatch.Label
	181	}
[153]	182	}
	183
[155]	184	var downstreamId uint64 = 0
	185	if label != "" {
	186	var labelOffset uint64
	187	n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamId, &labelOffset)
	188	if err == nil && n < 2 {
	189	err = errors.New("not enough arguments")
	190	}
	191	if err != nil {
	192	return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
	193	}
	194	}
	195
[13]	196	switch msg.Command {
	197	case "PING":
[60]	198	uc.SendMessage(&irc.Message{
[13]	199	Command: "PONG",
[68]	200	Params: msg.Params,
[60]	201	})
[33]	202	return nil
[18]	203	case "NOTICE":
[55]	204	uc.logger.Print(msg)
[97]	205
	206	uc.forEachDownstream(func(dc *downstreamConn) {
	207	dc.SendMessage(msg)
	208	})
[92]	209	case "CAP":
[95]	210	var subCmd string
	211	if err := parseMessageParams(msg, nil, &subCmd); err != nil {
	212	return err
[92]	213	}
[95]	214	subCmd = strings.ToUpper(subCmd)
	215	subParams := msg.Params[2:]
	216	switch subCmd {
	217	case "LS":
	218	if len(subParams) < 1 {
	219	return newNeedMoreParamsError(msg.Command)
	220	}
	221	caps := strings.Fields(subParams[len(subParams)-1])
	222	more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
[92]	223
[95]	224	for _, s := range caps {
	225	kv := strings.SplitN(s, "=", 2)
	226	k := strings.ToLower(kv[0])
	227	var v string
	228	if len(kv) == 2 {
	229	v = kv[1]
	230	}
	231	uc.caps[k] = v
[92]	232	}
	233
[95]	234	if more {
	235	break // wait to receive all capabilities
	236	}
	237
[152]	238	requestCaps := make([]string, 0, 16)
[155]	239	for _, c := range []string{"message-tags", "batch", "labeled-response"} {
[152]	240	if _, ok := uc.caps[c]; ok {
	241	requestCaps = append(requestCaps, c)
	242	}
	243	}
	244
[95]	245	if uc.requestSASL() {
[152]	246	requestCaps = append(requestCaps, "sasl")
	247	}
	248
	249	if len(requestCaps) > 0 {
[95]	250	uc.SendMessage(&irc.Message{
	251	Command: "CAP",
[152]	252	Params: []string{"REQ", strings.Join(requestCaps, " ")},
[95]	253	})
[152]	254	}
	255
	256	if uc.requestSASL() {
[95]	257	break // we'll send CAP END after authentication is completed
	258	}
	259
[92]	260	uc.SendMessage(&irc.Message{
	261	Command: "CAP",
	262	Params: []string{"END"},
	263	})
[95]	264	case "ACK", "NAK":
	265	if len(subParams) < 1 {
	266	return newNeedMoreParamsError(msg.Command)
	267	}
	268	caps := strings.Fields(subParams[0])
	269
	270	for _, name := range caps {
	271	if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
	272	return err
	273	}
	274	}
	275
	276	if uc.saslClient == nil {
	277	uc.SendMessage(&irc.Message{
	278	Command: "CAP",
	279	Params: []string{"END"},
	280	})
	281	}
	282	default:
	283	uc.logger.Printf("unhandled message: %v", msg)
[92]	284	}
[95]	285	case "AUTHENTICATE":
	286	if uc.saslClient == nil {
	287	return fmt.Errorf("received unexpected AUTHENTICATE message")
	288	}
	289
	290	// TODO: if a challenge is 400 bytes long, buffer it
	291	var challengeStr string
	292	if err := parseMessageParams(msg, &challengeStr); err != nil {
	293	uc.SendMessage(&irc.Message{
	294	Command: "AUTHENTICATE",
	295	Params: []string{"*"},
	296	})
	297	return err
	298	}
	299
	300	var challenge []byte
	301	if challengeStr != "+" {
	302	var err error
	303	challenge, err = base64.StdEncoding.DecodeString(challengeStr)
	304	if err != nil {
	305	uc.SendMessage(&irc.Message{
	306	Command: "AUTHENTICATE",
	307	Params: []string{"*"},
	308	})
	309	return err
	310	}
	311	}
	312
	313	var resp []byte
	314	var err error
	315	if !uc.saslStarted {
	316	_, resp, err = uc.saslClient.Start()
	317	uc.saslStarted = true
	318	} else {
	319	resp, err = uc.saslClient.Next(challenge)
	320	}
	321	if err != nil {
	322	uc.SendMessage(&irc.Message{
	323	Command: "AUTHENTICATE",
	324	Params: []string{"*"},
	325	})
	326	return err
	327	}
	328
	329	// TODO: send response in multiple chunks if >= 400 bytes
	330	var respStr = "+"
	331	if resp != nil {
	332	respStr = base64.StdEncoding.EncodeToString(resp)
	333	}
	334
	335	uc.SendMessage(&irc.Message{
	336	Command: "AUTHENTICATE",
	337	Params: []string{respStr},
	338	})
[125]	339	case irc.RPL_LOGGEDIN:
[95]	340	var account string
	341	if err := parseMessageParams(msg, nil, nil, &account); err != nil {
	342	return err
	343	}
	344	uc.logger.Printf("logged in with account %q", account)
[125]	345	case irc.RPL_LOGGEDOUT:
[95]	346	uc.logger.Printf("logged out")
[125]	347	case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
[95]	348	var info string
	349	if err := parseMessageParams(msg, nil, &info); err != nil {
	350	return err
	351	}
	352	switch msg.Command {
[125]	353	case irc.ERR_NICKLOCKED:
[95]	354	uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
[125]	355	case irc.ERR_SASLFAIL:
[95]	356	uc.logger.Printf("SASL authentication failed: %v", info)
[125]	357	case irc.ERR_SASLTOOLONG:
[95]	358	uc.logger.Printf("SASL message too long: %v", info)
	359	}
	360
	361	uc.saslClient = nil
	362	uc.saslStarted = false
	363
	364	uc.SendMessage(&irc.Message{
	365	Command: "CAP",
	366	Params: []string{"END"},
	367	})
[14]	368	case irc.RPL_WELCOME:
[55]	369	uc.registered = true
	370	uc.logger.Printf("connection registered")
[19]	371
[77]	372	channels, err := uc.srv.db.ListChannels(uc.network.ID)
	373	if err != nil {
	374	uc.logger.Printf("failed to list channels from database: %v", err)
	375	break
	376	}
	377
	378	for _, ch := range channels {
[146]	379	params := []string{ch.Name}
	380	if ch.Key != "" {
	381	params = append(params, ch.Key)
	382	}
[60]	383	uc.SendMessage(&irc.Message{
[19]	384	Command: "JOIN",
[146]	385	Params: params,
[60]	386	})
[19]	387	}
[16]	388	case irc.RPL_MYINFO:
[139]	389	if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
[43]	390	return err
[16]	391	}
[139]	392	case irc.RPL_ISUPPORT:
	393	if err := parseMessageParams(msg, nil, nil); err != nil {
	394	return err
[16]	395	}
[139]	396	for _, token := range msg.Params[1 : len(msg.Params)-1] {
	397	negate := false
	398	parameter := token
	399	value := ""
	400	if strings.HasPrefix(token, "-") {
	401	negate = true
	402	token = token[1:]
	403	} else {
	404	if i := strings.IndexByte(token, '='); i >= 0 {
	405	parameter = token[:i]
	406	value = token[i+1:]
	407	}
	408	}
	409	if !negate {
	410	switch parameter {
	411	case "CHANMODES":
	412	parts := strings.SplitN(value, ",", 5)
	413	if len(parts) < 4 {
	414	return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
	415	}
	416	modes := make(map[byte]channelModeType)
	417	for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
	418	for j := 0; j < len(parts[i]); j++ {
	419	mode := parts[i][j]
	420	modes[mode] = mt
	421	}
	422	}
	423	uc.availableChannelModes = modes
	424	case "CHANTYPES":
	425	uc.availableChannelTypes = value
	426	case "PREFIX":
	427	if value == "" {
	428	uc.availableMemberships = nil
	429	} else {
	430	if value[0] != '(' {
	431	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	432	}
	433	sep := strings.IndexByte(value, ')')
	434	if sep < 0 \|\| len(value) != sep*2 {
	435	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	436	}
	437	memberships := make([]membership, len(value)/2-1)
	438	for i := range memberships {
	439	memberships[i] = membership{
	440	Mode: value[i+1],
	441	Prefix: value[sep+i+1],
	442	}
	443	}
	444	uc.availableMemberships = memberships
	445	}
	446	}
	447	} else {
	448	// TODO: handle ISUPPORT negations
	449	}
	450	}
[153]	451	case "BATCH":
	452	var tag string
	453	if err := parseMessageParams(msg, &tag); err != nil {
	454	return err
	455	}
	456
	457	if strings.HasPrefix(tag, "+") {
	458	tag = tag[1:]
	459	if _, ok := uc.batches[tag]; ok {
	460	return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
	461	}
	462	var batchType string
	463	if err := parseMessageParams(msg, nil, &batchType); err != nil {
	464	return err
	465	}
[155]	466	label := label
	467	if label == "" && msgBatch != nil {
	468	label = msgBatch.Label
	469	}
[153]	470	uc.batches[tag] = batch{
	471	Type: batchType,
	472	Params: msg.Params[2:],
	473	Outer: msgBatch,
[155]	474	Label: label,
[153]	475	}
	476	} else if strings.HasPrefix(tag, "-") {
	477	tag = tag[1:]
	478	if _, ok := uc.batches[tag]; !ok {
	479	return fmt.Errorf("unknown BATCH reference tag: %q", tag)
	480	}
	481	delete(uc.batches, tag)
	482	} else {
	483	return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
	484	}
[42]	485	case "NICK":
[83]	486	if msg.Prefix == nil {
	487	return fmt.Errorf("expected a prefix")
	488	}
	489
[43]	490	var newNick string
	491	if err := parseMessageParams(msg, &newNick); err != nil {
	492	return err
[42]	493	}
	494
[55]	495	if msg.Prefix.Name == uc.nick {
	496	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
	497	uc.nick = newNick
[42]	498	}
	499
[55]	500	for _, ch := range uc.channels {
[42]	501	if membership, ok := ch.Members[msg.Prefix.Name]; ok {
	502	delete(ch.Members, msg.Prefix.Name)
	503	ch.Members[newNick] = membership
	504	}
	505	}
[82]	506
	507	if msg.Prefix.Name != uc.nick {
	508	uc.forEachDownstream(func(dc *downstreamConn) {
	509	dc.SendMessage(&irc.Message{
	510	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	511	Command: "NICK",
	512	Params: []string{newNick},
	513	})
	514	})
	515	}
[69]	516	case "JOIN":
	517	if msg.Prefix == nil {
	518	return fmt.Errorf("expected a prefix")
	519	}
[42]	520
[43]	521	var channels string
	522	if err := parseMessageParams(msg, &channels); err != nil {
	523	return err
[19]	524	}
[34]	525
[43]	526	for _, ch := range strings.Split(channels, ",") {
[55]	527	if msg.Prefix.Name == uc.nick {
	528	uc.logger.Printf("joined channel %q", ch)
	529	uc.channels[ch] = &upstreamChannel{
[34]	530	Name: ch,
[55]	531	conn: uc,
[139]	532	Members: make(map[string]*membership),
[34]	533	}
[139]	534
	535	uc.SendMessage(&irc.Message{
	536	Command: "MODE",
	537	Params: []string{ch},
	538	})
[34]	539	} else {
[55]	540	ch, err := uc.getChannel(ch)
[34]	541	if err != nil {
	542	return err
	543	}
[139]	544	ch.Members[msg.Prefix.Name] = nil
[19]	545	}
[69]	546
[73]	547	uc.forEachDownstream(func(dc *downstreamConn) {
[69]	548	dc.SendMessage(&irc.Message{
	549	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	550	Command: "JOIN",
	551	Params: []string{dc.marshalChannel(uc, ch)},
	552	})
	553	})
[19]	554	}
[69]	555	case "PART":
	556	if msg.Prefix == nil {
	557	return fmt.Errorf("expected a prefix")
	558	}
[34]	559
[43]	560	var channels string
	561	if err := parseMessageParams(msg, &channels); err != nil {
	562	return err
[34]	563	}
	564
[43]	565	for _, ch := range strings.Split(channels, ",") {
[55]	566	if msg.Prefix.Name == uc.nick {
	567	uc.logger.Printf("parted channel %q", ch)
	568	delete(uc.channels, ch)
[34]	569	} else {
[55]	570	ch, err := uc.getChannel(ch)
[34]	571	if err != nil {
	572	return err
	573	}
	574	delete(ch.Members, msg.Prefix.Name)
	575	}
[69]	576
[73]	577	uc.forEachDownstream(func(dc *downstreamConn) {
[69]	578	dc.SendMessage(&irc.Message{
	579	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	580	Command: "PART",
	581	Params: []string{dc.marshalChannel(uc, ch)},
	582	})
	583	})
[34]	584	}
[83]	585	case "QUIT":
	586	if msg.Prefix == nil {
	587	return fmt.Errorf("expected a prefix")
	588	}
	589
	590	if msg.Prefix.Name == uc.nick {
	591	uc.logger.Printf("quit")
	592	}
	593
	594	for _, ch := range uc.channels {
	595	delete(ch.Members, msg.Prefix.Name)
	596	}
	597
	598	if msg.Prefix.Name != uc.nick {
	599	uc.forEachDownstream(func(dc *downstreamConn) {
	600	dc.SendMessage(&irc.Message{
	601	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	602	Command: "QUIT",
	603	Params: msg.Params,
	604	})
	605	})
	606	}
[19]	607	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	608	var name, topic string
	609	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	610	return err
[19]	611	}
[55]	612	ch, err := uc.getChannel(name)
[19]	613	if err != nil {
	614	return err
	615	}
	616	if msg.Command == irc.RPL_TOPIC {
[43]	617	ch.Topic = topic
[19]	618	} else {
	619	ch.Topic = ""
	620	}
	621	case "TOPIC":
[43]	622	var name string
[74]	623	if err := parseMessageParams(msg, &name); err != nil {
[43]	624	return err
[19]	625	}
[55]	626	ch, err := uc.getChannel(name)
[19]	627	if err != nil {
	628	return err
	629	}
	630	if len(msg.Params) > 1 {
	631	ch.Topic = msg.Params[1]
	632	} else {
	633	ch.Topic = ""
	634	}
[74]	635	uc.forEachDownstream(func(dc *downstreamConn) {
	636	params := []string{dc.marshalChannel(uc, name)}
	637	if ch.Topic != "" {
	638	params = append(params, ch.Topic)
	639	}
	640	dc.SendMessage(&irc.Message{
	641	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	642	Command: "TOPIC",
	643	Params: params,
	644	})
	645	})
[139]	646	case "MODE":
	647	var name, modeStr string
	648	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	649	return err
	650	}
	651
	652	if !uc.isChannel(name) { // user mode change
	653	if name != uc.nick {
	654	return fmt.Errorf("received MODE message for unknown nick %q", name)
	655	}
	656	return uc.modes.Apply(modeStr)
	657	// TODO: notify downstreams about user mode change?
	658	} else { // channel mode change
	659	ch, err := uc.getChannel(name)
	660	if err != nil {
	661	return err
	662	}
	663
	664	if ch.modes != nil {
	665	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
	666	return err
	667	}
	668	}
	669
	670	uc.forEachDownstream(func(dc *downstreamConn) {
	671	params := []string{dc.marshalChannel(uc, name), modeStr}
	672	params = append(params, msg.Params[2:]...)
	673
	674	dc.SendMessage(&irc.Message{
	675	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	676	Command: "MODE",
	677	Params: params,
	678	})
	679	})
	680	}
	681	case irc.RPL_UMODEIS:
	682	if err := parseMessageParams(msg, nil); err != nil {
	683	return err
	684	}
	685	modeStr := ""
	686	if len(msg.Params) > 1 {
	687	modeStr = msg.Params[1]
	688	}
	689
	690	uc.modes = ""
	691	if err := uc.modes.Apply(modeStr); err != nil {
	692	return err
	693	}
	694	// TODO: send RPL_UMODEIS to downstream connections when applicable
	695	case irc.RPL_CHANNELMODEIS:
	696	var channel string
	697	if err := parseMessageParams(msg, nil, &channel); err != nil {
	698	return err
	699	}
	700	modeStr := ""
	701	if len(msg.Params) > 2 {
	702	modeStr = msg.Params[2]
	703	}
	704
	705	ch, err := uc.getChannel(channel)
	706	if err != nil {
	707	return err
	708	}
	709
	710	firstMode := ch.modes == nil
	711	ch.modes = make(map[byte]string)
	712	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
	713	return err
	714	}
	715	if firstMode {
	716	modeStr, modeParams := ch.modes.Format()
	717
	718	uc.forEachDownstream(func(dc *downstreamConn) {
	719	params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
	720	params = append(params, modeParams...)
	721
	722	dc.SendMessage(&irc.Message{
	723	Prefix: dc.srv.prefix(),
	724	Command: irc.RPL_CHANNELMODEIS,
	725	Params: params,
	726	})
	727	})
	728	}
[19]	729	case rpl_topicwhotime:
[43]	730	var name, who, timeStr string
	731	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	732	return err
[19]	733	}
[55]	734	ch, err := uc.getChannel(name)
[19]	735	if err != nil {
	736	return err
	737	}
[43]	738	ch.TopicWho = who
	739	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	740	if err != nil {
	741	return fmt.Errorf("failed to parse topic time: %v", err)
	742	}
	743	ch.TopicTime = time.Unix(sec, 0)
	744	case irc.RPL_NAMREPLY:
[43]	745	var name, statusStr, members string
	746	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	747	return err
[19]	748	}
[157]	749	members = strings.TrimRight(members, " ")
[140]	750
	751	ch, ok := uc.channels[name]
	752	if !ok {
	753	// NAMES on a channel we have not joined, forward to downstream
[156]	754	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[140]	755	channel := dc.marshalChannel(uc, name)
	756	members := strings.Split(members, " ")
	757	for i, member := range members {
	758	membership, nick := uc.parseMembershipPrefix(member)
	759	members[i] = membership.String() + dc.marshalNick(uc, nick)
	760	}
	761	memberStr := strings.Join(members, " ")
	762
	763	dc.SendMessage(&irc.Message{
	764	Prefix: dc.srv.prefix(),
	765	Command: irc.RPL_NAMREPLY,
	766	Params: []string{dc.nick, statusStr, channel, memberStr},
	767	})
	768	})
	769	return nil
[19]	770	}
	771
[43]	772	status, err := parseChannelStatus(statusStr)
[19]	773	if err != nil {
	774	return err
	775	}
	776	ch.Status = status
	777
[43]	778	for _, s := range strings.Split(members, " ") {
[139]	779	membership, nick := uc.parseMembershipPrefix(s)
[19]	780	ch.Members[nick] = membership
	781	}
	782	case irc.RPL_ENDOFNAMES:
[43]	783	var name string
	784	if err := parseMessageParams(msg, nil, &name); err != nil {
	785	return err
[25]	786	}
[140]	787
	788	ch, ok := uc.channels[name]
	789	if !ok {
	790	// NAMES on a channel we have not joined, forward to downstream
[156]	791	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[140]	792	channel := dc.marshalChannel(uc, name)
	793
	794	dc.SendMessage(&irc.Message{
	795	Prefix: dc.srv.prefix(),
	796	Command: irc.RPL_ENDOFNAMES,
	797	Params: []string{dc.nick, channel, "End of /NAMES list"},
	798	})
	799	})
	800	return nil
[25]	801	}
	802
[34]	803	if ch.complete {
	804	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	805	}
[25]	806	ch.complete = true
[27]	807
[73]	808	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	809	forwardChannel(dc, ch)
[40]	810	})
[127]	811	case irc.RPL_WHOREPLY:
	812	var channel, username, host, server, nick, mode, trailing string
	813	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	814	return err
	815	}
	816
	817	parts := strings.SplitN(trailing, " ", 2)
	818	if len(parts) != 2 {
	819	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	820	}
	821	realname := parts[1]
	822	hops, err := strconv.Atoi(parts[0])
	823	if err != nil {
	824	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	825	}
	826	hops++
	827
	828	trailing = strconv.Itoa(hops) + " " + realname
	829
[156]	830	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[127]	831	channel := channel
	832	if channel != "*" {
	833	channel = dc.marshalChannel(uc, channel)
	834	}
	835	nick := dc.marshalNick(uc, nick)
	836	dc.SendMessage(&irc.Message{
	837	Prefix: dc.srv.prefix(),
	838	Command: irc.RPL_WHOREPLY,
	839	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	840	})
	841	})
	842	case irc.RPL_ENDOFWHO:
	843	var name string
	844	if err := parseMessageParams(msg, nil, &name); err != nil {
	845	return err
	846	}
	847
[156]	848	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[127]	849	name := name
	850	if name != "*" {
	851	// TODO: support WHO masks
	852	name = dc.marshalEntity(uc, name)
	853	}
	854	dc.SendMessage(&irc.Message{
	855	Prefix: dc.srv.prefix(),
	856	Command: irc.RPL_ENDOFWHO,
[142]	857	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	858	})
	859	})
[128]	860	case irc.RPL_WHOISUSER:
	861	var nick, username, host, realname string
	862	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	863	return err
	864	}
	865
[156]	866	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	867	nick := dc.marshalNick(uc, nick)
	868	dc.SendMessage(&irc.Message{
	869	Prefix: dc.srv.prefix(),
	870	Command: irc.RPL_WHOISUSER,
	871	Params: []string{dc.nick, nick, username, host, "*", realname},
	872	})
	873	})
	874	case irc.RPL_WHOISSERVER:
	875	var nick, server, serverInfo string
	876	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	877	return err
	878	}
	879
[156]	880	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	881	nick := dc.marshalNick(uc, nick)
	882	dc.SendMessage(&irc.Message{
	883	Prefix: dc.srv.prefix(),
	884	Command: irc.RPL_WHOISSERVER,
	885	Params: []string{dc.nick, nick, server, serverInfo},
	886	})
	887	})
	888	case irc.RPL_WHOISOPERATOR:
	889	var nick string
	890	if err := parseMessageParams(msg, nil, &nick); err != nil {
	891	return err
	892	}
	893
[156]	894	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	895	nick := dc.marshalNick(uc, nick)
	896	dc.SendMessage(&irc.Message{
	897	Prefix: dc.srv.prefix(),
	898	Command: irc.RPL_WHOISOPERATOR,
	899	Params: []string{dc.nick, nick, "is an IRC operator"},
	900	})
	901	})
	902	case irc.RPL_WHOISIDLE:
	903	var nick string
	904	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	905	return err
	906	}
	907
[156]	908	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	909	nick := dc.marshalNick(uc, nick)
	910	params := []string{dc.nick, nick}
	911	params = append(params, msg.Params[2:]...)
	912	dc.SendMessage(&irc.Message{
	913	Prefix: dc.srv.prefix(),
	914	Command: irc.RPL_WHOISIDLE,
	915	Params: params,
	916	})
	917	})
	918	case irc.RPL_WHOISCHANNELS:
	919	var nick, channelList string
	920	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	921	return err
	922	}
	923	channels := strings.Split(channelList, " ")
	924
[156]	925	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	926	nick := dc.marshalNick(uc, nick)
	927	channelList := make([]string, len(channels))
	928	for i, channel := range channels {
[139]	929	prefix, channel := uc.parseMembershipPrefix(channel)
[128]	930	channel = dc.marshalChannel(uc, channel)
	931	channelList[i] = prefix.String() + channel
	932	}
	933	channels := strings.Join(channelList, " ")
	934	dc.SendMessage(&irc.Message{
	935	Prefix: dc.srv.prefix(),
	936	Command: irc.RPL_WHOISCHANNELS,
	937	Params: []string{dc.nick, nick, channels},
	938	})
	939	})
	940	case irc.RPL_ENDOFWHOIS:
	941	var nick string
	942	if err := parseMessageParams(msg, nil, &nick); err != nil {
	943	return err
	944	}
	945
[156]	946	uc.forEachDownstreamById(downstreamId, func(dc *downstreamConn) {
[128]	947	nick := dc.marshalNick(uc, nick)
	948	dc.SendMessage(&irc.Message{
	949	Prefix: dc.srv.prefix(),
	950	Command: irc.RPL_ENDOFWHOIS,
[142]	951	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	952	})
	953	})
[36]	954	case "PRIVMSG":
[117]	955	if msg.Prefix == nil {
	956	return fmt.Errorf("expected a prefix")
	957	}
	958
	959	var nick string
	960	if err := parseMessageParams(msg, &nick, nil); err != nil {
[69]	961	return err
	962	}
[117]	963
	964	if msg.Prefix.Name == serviceNick {
	965	uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
	966	break
	967	}
	968	if nick == serviceNick {
	969	uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
	970	break
	971	}
	972
[143]	973	uc.network.ring.Produce(msg)
[115]	974	case "INVITE":
	975	var nick string
	976	var channel string
	977	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	978	return err
	979	}
	980
	981	uc.forEachDownstream(func(dc *downstreamConn) {
	982	dc.SendMessage(&irc.Message{
	983	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	984	Command: "INVITE",
	985	Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	986	})
	987	})
[152]	988	case "TAGMSG":
	989	// TODO: relay to downstream connections that accept message-tags
[155]	990	case "ACK":
	991	// Ignore
[16]	992	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	993	// Ignore
	994	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	995	// Ignore
	996	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	997	// Ignore
	998	case rpl_localusers, rpl_globalusers:
	999	// Ignore
[96]	1000	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1001	// Ignore
[13]	1002	default:
[95]	1003	uc.logger.Printf("unhandled message: %v", msg)
[13]	1004	}
[14]	1005	return nil
[13]	1006	}
	1007
[55]	1008	func (uc *upstreamConn) register() {
[77]	1009	uc.nick = uc.network.Nick
	1010	uc.username = uc.network.Username
	1011	if uc.username == "" {
	1012	uc.username = uc.nick
	1013	}
	1014	uc.realname = uc.network.Realname
	1015	if uc.realname == "" {
	1016	uc.realname = uc.nick
	1017	}
	1018
[60]	1019	uc.SendMessage(&irc.Message{
[92]	1020	Command: "CAP",
	1021	Params: []string{"LS", "302"},
	1022	})
	1023
[93]	1024	if uc.network.Pass != "" {
	1025	uc.SendMessage(&irc.Message{
	1026	Command: "PASS",
	1027	Params: []string{uc.network.Pass},
	1028	})
	1029	}
	1030
[92]	1031	uc.SendMessage(&irc.Message{
[13]	1032	Command: "NICK",
[69]	1033	Params: []string{uc.nick},
[60]	1034	})
	1035	uc.SendMessage(&irc.Message{
[13]	1036	Command: "USER",
[77]	1037	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1038	})
[44]	1039	}
[13]	1040
[95]	1041	func (uc *upstreamConn) requestSASL() bool {
	1042	if uc.network.SASL.Mechanism == "" {
	1043	return false
	1044	}
	1045
	1046	v, ok := uc.caps["sasl"]
	1047	if !ok {
	1048	return false
	1049	}
	1050	if v != "" {
	1051	mechanisms := strings.Split(v, ",")
	1052	found := false
	1053	for _, mech := range mechanisms {
	1054	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1055	found = true
	1056	break
	1057	}
	1058	}
	1059	if !found {
	1060	return false
	1061	}
	1062	}
	1063
	1064	return true
	1065	}
	1066
	1067	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1068	auth := &uc.network.SASL
	1069	switch name {
	1070	case "sasl":
	1071	if !ok {
	1072	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1073	return nil
	1074	}
	1075
	1076	switch auth.Mechanism {
	1077	case "PLAIN":
	1078	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1079	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1080	default:
	1081	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1082	}
	1083
	1084	uc.SendMessage(&irc.Message{
	1085	Command: "AUTHENTICATE",
	1086	Params: []string{auth.Mechanism},
	1087	})
[152]	1088	case "message-tags":
	1089	uc.tagsSupported = ok
[155]	1090	case "labeled-response":
	1091	uc.labelsSupported = ok
[95]	1092	}
	1093	return nil
	1094	}
	1095
[103]	1096	func (uc *upstreamConn) readMessages(ch chan<- upstreamIncomingMessage) error {
[13]	1097	for {
[55]	1098	msg, err := uc.irc.ReadMessage()
[13]	1099	if err == io.EOF {
	1100	break
	1101	} else if err != nil {
	1102	return fmt.Errorf("failed to read IRC command: %v", err)
	1103	}
	1104
[64]	1105	if uc.srv.Debug {
	1106	uc.logger.Printf("received: %v", msg)
	1107	}
	1108
[103]	1109	ch <- upstreamIncomingMessage{msg, uc}
[13]	1110	}
	1111
[45]	1112	return nil
[13]	1113	}
[60]	1114
	1115	func (uc upstreamConn) SendMessage(msg irc.Message) {
[102]	1116	uc.outgoing <- msg
[60]	1117	}
[155]	1118
	1119	func (uc upstreamConn) SendMessageLabeled(dc downstreamConn, msg *irc.Message) {
	1120	if uc.labelsSupported {
	1121	if msg.Tags == nil {
	1122	msg.Tags = make(map[string]irc.TagValue)
	1123	}
	1124	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", dc.id, uc.nextLabelId))
	1125	uc.nextLabelId++
	1126	}
	1127	uc.SendMessage(msg)
	1128	}

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

Context Navigation

source: code/trunk/upstream.go@ 157

Download in other formats: