Context Navigation

source: code/trunk/upstream.go@ 143

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

Move upstreamConn.ring to network

This handles upstream disconnection and re-connection better.

File size: 24.4 KB

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

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

Download in other formats: