Context Navigation

source: code/trunk/upstream.go@ 155

Last change on this file since 155 was 155, checked in by delthas, 5 years ago
Add upstream labeled-response capability support
File size: 27.2 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	}
[140]	749
	750	ch, ok := uc.channels[name]
	751	if !ok {
	752	// NAMES on a channel we have not joined, forward to downstream
	753	uc.forEachDownstream(func(dc *downstreamConn) {
	754	channel := dc.marshalChannel(uc, name)
	755	members := strings.Split(members, " ")
	756	for i, member := range members {
	757	membership, nick := uc.parseMembershipPrefix(member)
	758	members[i] = membership.String() + dc.marshalNick(uc, nick)
	759	}
	760	memberStr := strings.Join(members, " ")
	761
	762	dc.SendMessage(&irc.Message{
	763	Prefix: dc.srv.prefix(),
	764	Command: irc.RPL_NAMREPLY,
	765	Params: []string{dc.nick, statusStr, channel, memberStr},
	766	})
	767	})
	768	return nil
[19]	769	}
	770
[43]	771	status, err := parseChannelStatus(statusStr)
[19]	772	if err != nil {
	773	return err
	774	}
	775	ch.Status = status
	776
[43]	777	for _, s := range strings.Split(members, " ") {
[139]	778	membership, nick := uc.parseMembershipPrefix(s)
[19]	779	ch.Members[nick] = membership
	780	}
	781	case irc.RPL_ENDOFNAMES:
[43]	782	var name string
	783	if err := parseMessageParams(msg, nil, &name); err != nil {
	784	return err
[25]	785	}
[140]	786
	787	ch, ok := uc.channels[name]
	788	if !ok {
	789	// NAMES on a channel we have not joined, forward to downstream
	790	uc.forEachDownstream(func(dc *downstreamConn) {
	791	channel := dc.marshalChannel(uc, name)
	792
	793	dc.SendMessage(&irc.Message{
	794	Prefix: dc.srv.prefix(),
	795	Command: irc.RPL_ENDOFNAMES,
	796	Params: []string{dc.nick, channel, "End of /NAMES list"},
	797	})
	798	})
	799	return nil
[25]	800	}
	801
[34]	802	if ch.complete {
	803	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	804	}
[25]	805	ch.complete = true
[27]	806
[73]	807	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	808	forwardChannel(dc, ch)
[40]	809	})
[127]	810	case irc.RPL_WHOREPLY:
	811	var channel, username, host, server, nick, mode, trailing string
	812	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	813	return err
	814	}
	815
	816	parts := strings.SplitN(trailing, " ", 2)
	817	if len(parts) != 2 {
	818	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	819	}
	820	realname := parts[1]
	821	hops, err := strconv.Atoi(parts[0])
	822	if err != nil {
	823	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	824	}
	825	hops++
	826
	827	trailing = strconv.Itoa(hops) + " " + realname
	828
	829	uc.forEachDownstream(func(dc *downstreamConn) {
	830	channel := channel
	831	if channel != "*" {
	832	channel = dc.marshalChannel(uc, channel)
	833	}
	834	nick := dc.marshalNick(uc, nick)
	835	dc.SendMessage(&irc.Message{
	836	Prefix: dc.srv.prefix(),
	837	Command: irc.RPL_WHOREPLY,
	838	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	839	})
	840	})
	841	case irc.RPL_ENDOFWHO:
	842	var name string
	843	if err := parseMessageParams(msg, nil, &name); err != nil {
	844	return err
	845	}
	846
	847	uc.forEachDownstream(func(dc *downstreamConn) {
	848	name := name
	849	if name != "*" {
	850	// TODO: support WHO masks
	851	name = dc.marshalEntity(uc, name)
	852	}
	853	dc.SendMessage(&irc.Message{
	854	Prefix: dc.srv.prefix(),
	855	Command: irc.RPL_ENDOFWHO,
[142]	856	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	857	})
	858	})
[128]	859	case irc.RPL_WHOISUSER:
	860	var nick, username, host, realname string
	861	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	862	return err
	863	}
	864
	865	uc.forEachDownstream(func(dc *downstreamConn) {
	866	nick := dc.marshalNick(uc, nick)
	867	dc.SendMessage(&irc.Message{
	868	Prefix: dc.srv.prefix(),
	869	Command: irc.RPL_WHOISUSER,
	870	Params: []string{dc.nick, nick, username, host, "*", realname},
	871	})
	872	})
	873	case irc.RPL_WHOISSERVER:
	874	var nick, server, serverInfo string
	875	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	876	return err
	877	}
	878
	879	uc.forEachDownstream(func(dc *downstreamConn) {
	880	nick := dc.marshalNick(uc, nick)
	881	dc.SendMessage(&irc.Message{
	882	Prefix: dc.srv.prefix(),
	883	Command: irc.RPL_WHOISSERVER,
	884	Params: []string{dc.nick, nick, server, serverInfo},
	885	})
	886	})
	887	case irc.RPL_WHOISOPERATOR:
	888	var nick string
	889	if err := parseMessageParams(msg, nil, &nick); err != nil {
	890	return err
	891	}
	892
	893	uc.forEachDownstream(func(dc *downstreamConn) {
	894	nick := dc.marshalNick(uc, nick)
	895	dc.SendMessage(&irc.Message{
	896	Prefix: dc.srv.prefix(),
	897	Command: irc.RPL_WHOISOPERATOR,
	898	Params: []string{dc.nick, nick, "is an IRC operator"},
	899	})
	900	})
	901	case irc.RPL_WHOISIDLE:
	902	var nick string
	903	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	904	return err
	905	}
	906
	907	uc.forEachDownstream(func(dc *downstreamConn) {
	908	nick := dc.marshalNick(uc, nick)
	909	params := []string{dc.nick, nick}
	910	params = append(params, msg.Params[2:]...)
	911	dc.SendMessage(&irc.Message{
	912	Prefix: dc.srv.prefix(),
	913	Command: irc.RPL_WHOISIDLE,
	914	Params: params,
	915	})
	916	})
	917	case irc.RPL_WHOISCHANNELS:
	918	var nick, channelList string
	919	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	920	return err
	921	}
	922	channels := strings.Split(channelList, " ")
	923
	924	uc.forEachDownstream(func(dc *downstreamConn) {
	925	nick := dc.marshalNick(uc, nick)
	926	channelList := make([]string, len(channels))
	927	for i, channel := range channels {
[139]	928	prefix, channel := uc.parseMembershipPrefix(channel)
[128]	929	channel = dc.marshalChannel(uc, channel)
	930	channelList[i] = prefix.String() + channel
	931	}
	932	channels := strings.Join(channelList, " ")
	933	dc.SendMessage(&irc.Message{
	934	Prefix: dc.srv.prefix(),
	935	Command: irc.RPL_WHOISCHANNELS,
	936	Params: []string{dc.nick, nick, channels},
	937	})
	938	})
	939	case irc.RPL_ENDOFWHOIS:
	940	var nick string
	941	if err := parseMessageParams(msg, nil, &nick); err != nil {
	942	return err
	943	}
	944
	945	uc.forEachDownstream(func(dc *downstreamConn) {
	946	nick := dc.marshalNick(uc, nick)
	947	dc.SendMessage(&irc.Message{
	948	Prefix: dc.srv.prefix(),
	949	Command: irc.RPL_ENDOFWHOIS,
[142]	950	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	951	})
	952	})
[36]	953	case "PRIVMSG":
[117]	954	if msg.Prefix == nil {
	955	return fmt.Errorf("expected a prefix")
	956	}
	957
	958	var nick string
	959	if err := parseMessageParams(msg, &nick, nil); err != nil {
[69]	960	return err
	961	}
[117]	962
	963	if msg.Prefix.Name == serviceNick {
	964	uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
	965	break
	966	}
	967	if nick == serviceNick {
	968	uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
	969	break
	970	}
	971
[143]	972	uc.network.ring.Produce(msg)
[115]	973	case "INVITE":
	974	var nick string
	975	var channel string
	976	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	977	return err
	978	}
	979
	980	uc.forEachDownstream(func(dc *downstreamConn) {
	981	dc.SendMessage(&irc.Message{
	982	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	983	Command: "INVITE",
	984	Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	985	})
	986	})
[152]	987	case "TAGMSG":
	988	// TODO: relay to downstream connections that accept message-tags
[155]	989	case "ACK":
	990	// Ignore
[16]	991	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	992	// Ignore
	993	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	994	// Ignore
	995	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	996	// Ignore
	997	case rpl_localusers, rpl_globalusers:
	998	// Ignore
[96]	999	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1000	// Ignore
[13]	1001	default:
[95]	1002	uc.logger.Printf("unhandled message: %v", msg)
[13]	1003	}
[14]	1004	return nil
[13]	1005	}
	1006
[55]	1007	func (uc *upstreamConn) register() {
[77]	1008	uc.nick = uc.network.Nick
	1009	uc.username = uc.network.Username
	1010	if uc.username == "" {
	1011	uc.username = uc.nick
	1012	}
	1013	uc.realname = uc.network.Realname
	1014	if uc.realname == "" {
	1015	uc.realname = uc.nick
	1016	}
	1017
[60]	1018	uc.SendMessage(&irc.Message{
[92]	1019	Command: "CAP",
	1020	Params: []string{"LS", "302"},
	1021	})
	1022
[93]	1023	if uc.network.Pass != "" {
	1024	uc.SendMessage(&irc.Message{
	1025	Command: "PASS",
	1026	Params: []string{uc.network.Pass},
	1027	})
	1028	}
	1029
[92]	1030	uc.SendMessage(&irc.Message{
[13]	1031	Command: "NICK",
[69]	1032	Params: []string{uc.nick},
[60]	1033	})
	1034	uc.SendMessage(&irc.Message{
[13]	1035	Command: "USER",
[77]	1036	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1037	})
[44]	1038	}
[13]	1039
[95]	1040	func (uc *upstreamConn) requestSASL() bool {
	1041	if uc.network.SASL.Mechanism == "" {
	1042	return false
	1043	}
	1044
	1045	v, ok := uc.caps["sasl"]
	1046	if !ok {
	1047	return false
	1048	}
	1049	if v != "" {
	1050	mechanisms := strings.Split(v, ",")
	1051	found := false
	1052	for _, mech := range mechanisms {
	1053	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1054	found = true
	1055	break
	1056	}
	1057	}
	1058	if !found {
	1059	return false
	1060	}
	1061	}
	1062
	1063	return true
	1064	}
	1065
	1066	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1067	auth := &uc.network.SASL
	1068	switch name {
	1069	case "sasl":
	1070	if !ok {
	1071	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1072	return nil
	1073	}
	1074
	1075	switch auth.Mechanism {
	1076	case "PLAIN":
	1077	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1078	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1079	default:
	1080	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1081	}
	1082
	1083	uc.SendMessage(&irc.Message{
	1084	Command: "AUTHENTICATE",
	1085	Params: []string{auth.Mechanism},
	1086	})
[152]	1087	case "message-tags":
	1088	uc.tagsSupported = ok
[155]	1089	case "labeled-response":
	1090	uc.labelsSupported = ok
[95]	1091	}
	1092	return nil
	1093	}
	1094
[103]	1095	func (uc *upstreamConn) readMessages(ch chan<- upstreamIncomingMessage) error {
[13]	1096	for {
[55]	1097	msg, err := uc.irc.ReadMessage()
[13]	1098	if err == io.EOF {
	1099	break
	1100	} else if err != nil {
	1101	return fmt.Errorf("failed to read IRC command: %v", err)
	1102	}
	1103
[64]	1104	if uc.srv.Debug {
	1105	uc.logger.Printf("received: %v", msg)
	1106	}
	1107
[103]	1108	ch <- upstreamIncomingMessage{msg, uc}
[13]	1109	}
	1110
[45]	1111	return nil
[13]	1112	}
[60]	1113
	1114	func (uc upstreamConn) SendMessage(msg irc.Message) {
[102]	1115	uc.outgoing <- msg
[60]	1116	}
[155]	1117
	1118	func (uc upstreamConn) SendMessageLabeled(dc downstreamConn, msg *irc.Message) {
	1119	if uc.labelsSupported {
	1120	if msg.Tags == nil {
	1121	msg.Tags = make(map[string]irc.TagValue)
	1122	}
	1123	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", dc.id, uc.nextLabelId))
	1124	uc.nextLabelId++
	1125	}
	1126	uc.SendMessage(msg)
	1127	}

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

Download in other formats: