Context Navigation

source: code/trunk/downstream.go@ 211

Last change on this file since 211 was 211, checked in by contact, 5 years ago
Add support for downstream echo-message extension
File size: 30.6 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
[91]	4	"crypto/tls"
[112]	5	"encoding/base64"
[13]	6	"fmt"
	7	"io"
	8	"net"
[108]	9	"strconv"
[39]	10	"strings"
[105]	11	"sync"
[91]	12	"time"
[13]	13
[112]	14	"github.com/emersion/go-sasl"
[85]	15	"golang.org/x/crypto/bcrypt"
[13]	16	"gopkg.in/irc.v3"
	17	)
	18
	19	type ircError struct {
	20	Message *irc.Message
	21	}
	22
[85]	23	func (err ircError) Error() string {
	24	return err.Message.String()
	25	}
	26
[13]	27	func newUnknownCommandError(cmd string) ircError {
	28	return ircError{&irc.Message{
	29	Command: irc.ERR_UNKNOWNCOMMAND,
	30	Params: []string{
	31	"*",
	32	cmd,
	33	"Unknown command",
	34	},
	35	}}
	36	}
	37
	38	func newNeedMoreParamsError(cmd string) ircError {
	39	return ircError{&irc.Message{
	40	Command: irc.ERR_NEEDMOREPARAMS,
	41	Params: []string{
	42	"*",
	43	cmd,
	44	"Not enough parameters",
	45	},
	46	}}
	47	}
	48
[85]	49	var errAuthFailed = ircError{&irc.Message{
	50	Command: irc.ERR_PASSWDMISMATCH,
	51	Params: []string{"*", "Invalid username or password"},
	52	}}
[13]	53
	54	type downstreamConn struct {
[210]	55	conn
[22]	56
[210]	57	id uint64
	58
[100]	59	registered bool
	60	user *user
	61	nick string
	62	rawUsername string
[168]	63	networkName string
[183]	64	clientName string
[100]	65	realname string
[141]	66	hostname string
[100]	67	password string // empty after authentication
	68	network *network // can be nil
[105]	69
[204]	70	ringConsumers map[network]RingConsumer
	71
[108]	72	negociatingCaps bool
	73	capVersion int
	74	caps map[string]bool
	75
[112]	76	saslServer sasl.Server
	77
[105]	78	lock sync.Mutex
	79	ourMessages map[*irc.Message]struct{}
[13]	80	}
	81
[154]	82	func newDownstreamConn(srv Server, netConn net.Conn, id uint64) downstreamConn {
[210]	83	logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())}
[55]	84	dc := &downstreamConn{
[210]	85	conn: *newConn(srv, netConn, logger),
[204]	86	id: id,
	87	ringConsumers: make(map[network]RingConsumer),
	88	caps: make(map[string]bool),
	89	ourMessages: make(map[*irc.Message]struct{}),
[22]	90	}
[141]	91	dc.hostname = netConn.RemoteAddr().String()
	92	if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
	93	dc.hostname = host
	94	}
[55]	95	return dc
[22]	96	}
	97
[55]	98	func (dc downstreamConn) prefix() irc.Prefix {
[27]	99	return &irc.Prefix{
[55]	100	Name: dc.nick,
[184]	101	User: dc.user.Username,
[141]	102	Host: dc.hostname,
[27]	103	}
	104	}
	105
[90]	106	func (dc downstreamConn) forEachNetwork(f func(network)) {
	107	if dc.network != nil {
	108	f(dc.network)
	109	} else {
	110	dc.user.forEachNetwork(f)
	111	}
	112	}
	113
[73]	114	func (dc downstreamConn) forEachUpstream(f func(upstreamConn)) {
	115	dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]	116	if dc.network != nil && uc.network != dc.network {
[73]	117	return
	118	}
	119	f(uc)
	120	})
	121	}
	122
[89]	123	// upstream returns the upstream connection, if any. If there are zero or if
	124	// there are multiple upstream connections, it returns nil.
	125	func (dc downstreamConn) upstream() upstreamConn {
	126	if dc.network == nil {
	127	return nil
	128	}
[136]	129	return dc.network.upstream()
[89]	130	}
	131
[129]	132	func (dc downstreamConn) marshalEntity(uc upstreamConn, entity string) string {
	133	if uc.isChannel(entity) {
	134	return dc.marshalChannel(uc, entity)
[119]	135	}
[129]	136	return dc.marshalNick(uc, entity)
[119]	137	}
	138
	139	func (dc downstreamConn) marshalChannel(uc upstreamConn, name string) string {
[130]	140	if dc.network != nil {
[119]	141	return name
	142	}
	143	return name + "/" + uc.network.GetName()
	144	}
	145
[127]	146	func (dc downstreamConn) unmarshalEntity(name string) (upstreamConn, string, error) {
[89]	147	if uc := dc.upstream(); uc != nil {
	148	return uc, name, nil
	149	}
	150
[127]	151	var conn *upstreamConn
[119]	152	if i := strings.LastIndexByte(name, '/'); i >= 0 {
[127]	153	network := name[i+1:]
[119]	154	name = name[:i]
	155
	156	dc.forEachUpstream(func(uc *upstreamConn) {
	157	if network != uc.network.GetName() {
	158	return
	159	}
	160	conn = uc
	161	})
	162	}
	163
[127]	164	if conn == nil {
[73]	165	return nil, "", ircError{&irc.Message{
	166	Command: irc.ERR_NOSUCHCHANNEL,
	167	Params: []string{name, "No such channel"},
	168	}}
[69]	169	}
[127]	170	return conn, name, nil
[69]	171	}
	172
	173	func (dc downstreamConn) marshalNick(uc upstreamConn, nick string) string {
	174	if nick == uc.nick {
	175	return dc.nick
	176	}
[130]	177	if dc.network != nil {
[119]	178	return nick
	179	}
	180	return nick + "/" + uc.network.GetName()
[69]	181	}
	182
	183	func (dc downstreamConn) marshalUserPrefix(uc upstreamConn, prefix irc.Prefix) irc.Prefix {
	184	if prefix.Name == uc.nick {
	185	return dc.prefix()
	186	}
[130]	187	if dc.network != nil {
[119]	188	return prefix
	189	}
	190	return &irc.Prefix{
	191	Name: prefix.Name + "/" + uc.network.GetName(),
	192	User: prefix.User,
	193	Host: prefix.Host,
	194	}
[69]	195	}
	196
[165]	197	func (dc *downstreamConn) readMessages(ch chan<- event) error {
[22]	198	for {
[210]	199	msg, err := dc.ReadMessage()
[22]	200	if err == io.EOF {
	201	break
	202	} else if err != nil {
	203	return fmt.Errorf("failed to read IRC command: %v", err)
	204	}
	205
[165]	206	ch <- eventDownstreamMessage{msg, dc}
[22]	207	}
	208
[45]	209	return nil
[22]	210	}
	211
[55]	212	func (dc downstreamConn) SendMessage(msg irc.Message) {
[191]	213	// TODO: strip tags if the client doesn't support them (see runNetwork)
[210]	214	dc.conn.SendMessage(msg)
[54]	215	}
	216
[55]	217	func (dc downstreamConn) handleMessage(msg irc.Message) error {
[13]	218	switch msg.Command {
[28]	219	case "QUIT":
[55]	220	return dc.Close()
[13]	221	default:
[55]	222	if dc.registered {
	223	return dc.handleMessageRegistered(msg)
[13]	224	} else {
[55]	225	return dc.handleMessageUnregistered(msg)
[13]	226	}
	227	}
	228	}
	229
[55]	230	func (dc downstreamConn) handleMessageUnregistered(msg irc.Message) error {
[13]	231	switch msg.Command {
	232	case "NICK":
[117]	233	var nick string
	234	if err := parseMessageParams(msg, &nick); err != nil {
[43]	235	return err
[13]	236	}
[117]	237	if nick == serviceNick {
	238	return ircError{&irc.Message{
	239	Command: irc.ERR_NICKNAMEINUSE,
	240	Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
	241	}}
	242	}
	243	dc.nick = nick
[13]	244	case "USER":
[117]	245	if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]	246	return err
[13]	247	}
[85]	248	case "PASS":
	249	if err := parseMessageParams(msg, &dc.password); err != nil {
	250	return err
	251	}
[108]	252	case "CAP":
	253	var subCmd string
	254	if err := parseMessageParams(msg, &subCmd); err != nil {
	255	return err
	256	}
	257	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	258	return err
	259	}
[112]	260	case "AUTHENTICATE":
	261	if !dc.caps["sasl"] {
	262	return ircError{&irc.Message{
[125]	263	Command: irc.ERR_SASLFAIL,
[112]	264	Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
	265	}}
	266	}
	267	if len(msg.Params) == 0 {
	268	return ircError{&irc.Message{
[125]	269	Command: irc.ERR_SASLFAIL,
[112]	270	Params: []string{"*", "Missing AUTHENTICATE argument"},
	271	}}
	272	}
	273	if dc.nick == "" {
	274	return ircError{&irc.Message{
[125]	275	Command: irc.ERR_SASLFAIL,
[112]	276	Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
	277	}}
	278	}
	279
	280	var resp []byte
	281	if dc.saslServer == nil {
	282	mech := strings.ToUpper(msg.Params[0])
	283	switch mech {
	284	case "PLAIN":
	285	dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
	286	return dc.authenticate(username, password)
	287	}))
	288	default:
	289	return ircError{&irc.Message{
[125]	290	Command: irc.ERR_SASLFAIL,
[112]	291	Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
	292	}}
	293	}
	294	} else if msg.Params[0] == "*" {
	295	dc.saslServer = nil
	296	return ircError{&irc.Message{
[125]	297	Command: irc.ERR_SASLABORTED,
[112]	298	Params: []string{"*", "SASL authentication aborted"},
	299	}}
	300	} else if msg.Params[0] == "+" {
	301	resp = nil
	302	} else {
	303	// TODO: multi-line messages
	304	var err error
	305	resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
	306	if err != nil {
	307	dc.saslServer = nil
	308	return ircError{&irc.Message{
[125]	309	Command: irc.ERR_SASLFAIL,
[112]	310	Params: []string{"*", "Invalid base64-encoded response"},
	311	}}
	312	}
	313	}
	314
	315	challenge, done, err := dc.saslServer.Next(resp)
	316	if err != nil {
	317	dc.saslServer = nil
	318	if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
	319	return ircError{&irc.Message{
[125]	320	Command: irc.ERR_SASLFAIL,
[112]	321	Params: []string{"*", ircErr.Message.Params[1]},
	322	}}
	323	}
	324	dc.SendMessage(&irc.Message{
	325	Prefix: dc.srv.prefix(),
[125]	326	Command: irc.ERR_SASLFAIL,
[112]	327	Params: []string{"*", "SASL error"},
	328	})
	329	return fmt.Errorf("SASL authentication failed: %v", err)
	330	} else if done {
	331	dc.saslServer = nil
	332	dc.SendMessage(&irc.Message{
	333	Prefix: dc.srv.prefix(),
[125]	334	Command: irc.RPL_LOGGEDIN,
[112]	335	Params: []string{dc.nick, dc.nick, dc.user.Username, "You are now logged in"},
	336	})
	337	dc.SendMessage(&irc.Message{
	338	Prefix: dc.srv.prefix(),
[125]	339	Command: irc.RPL_SASLSUCCESS,
[112]	340	Params: []string{dc.nick, "SASL authentication successful"},
	341	})
	342	} else {
	343	challengeStr := "+"
[135]	344	if len(challenge) > 0 {
[112]	345	challengeStr = base64.StdEncoding.EncodeToString(challenge)
	346	}
	347
	348	// TODO: multi-line messages
	349	dc.SendMessage(&irc.Message{
	350	Prefix: dc.srv.prefix(),
	351	Command: "AUTHENTICATE",
	352	Params: []string{challengeStr},
	353	})
	354	}
[13]	355	default:
[55]	356	dc.logger.Printf("unhandled message: %v", msg)
[13]	357	return newUnknownCommandError(msg.Command)
	358	}
[108]	359	if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
[55]	360	return dc.register()
[13]	361	}
	362	return nil
	363	}
	364
[108]	365	func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]	366	cmd = strings.ToUpper(cmd)
	367
[108]	368	replyTo := dc.nick
	369	if !dc.registered {
	370	replyTo = "*"
	371	}
	372
	373	switch cmd {
	374	case "LS":
	375	if len(args) > 0 {
	376	var err error
	377	if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
	378	return err
	379	}
	380	}
	381
[211]	382	caps := []string{"message-tags", "server-time", "echo-message"}
[194]	383
[112]	384	if dc.capVersion >= 302 {
[108]	385	caps = append(caps, "sasl=PLAIN")
	386	} else {
	387	caps = append(caps, "sasl")
[112]	388	}
[108]	389
	390	// TODO: multi-line replies
	391	dc.SendMessage(&irc.Message{
	392	Prefix: dc.srv.prefix(),
	393	Command: "CAP",
	394	Params: []string{replyTo, "LS", strings.Join(caps, " ")},
	395	})
	396
	397	if !dc.registered {
	398	dc.negociatingCaps = true
	399	}
	400	case "LIST":
	401	var caps []string
	402	for name := range dc.caps {
	403	caps = append(caps, name)
	404	}
	405
	406	// TODO: multi-line replies
	407	dc.SendMessage(&irc.Message{
	408	Prefix: dc.srv.prefix(),
	409	Command: "CAP",
	410	Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
	411	})
	412	case "REQ":
	413	if len(args) == 0 {
	414	return ircError{&irc.Message{
	415	Command: err_invalidcapcmd,
	416	Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
	417	}}
	418	}
	419
	420	caps := strings.Fields(args[0])
	421	ack := true
	422	for _, name := range caps {
	423	name = strings.ToLower(name)
	424	enable := !strings.HasPrefix(name, "-")
	425	if !enable {
	426	name = strings.TrimPrefix(name, "-")
	427	}
	428
	429	enabled := dc.caps[name]
	430	if enable == enabled {
	431	continue
	432	}
	433
	434	switch name {
[211]	435	case "sasl", "message-tags", "server-time", "echo-message":
[112]	436	dc.caps[name] = enable
[108]	437	default:
	438	ack = false
	439	}
	440	}
	441
	442	reply := "NAK"
	443	if ack {
	444	reply = "ACK"
	445	}
	446	dc.SendMessage(&irc.Message{
	447	Prefix: dc.srv.prefix(),
	448	Command: "CAP",
	449	Params: []string{replyTo, reply, args[0]},
	450	})
	451	case "END":
	452	dc.negociatingCaps = false
	453	default:
	454	return ircError{&irc.Message{
	455	Command: err_invalidcapcmd,
	456	Params: []string{replyTo, cmd, "Unknown CAP command"},
	457	}}
	458	}
	459	return nil
	460	}
	461
[91]	462	func sanityCheckServer(addr string) error {
	463	dialer := net.Dialer{Timeout: 30 * time.Second}
	464	conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
	465	if err != nil {
	466	return err
	467	}
	468	return conn.Close()
	469	}
	470
[183]	471	func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]	472	username = rawUsername
[183]	473
	474	i := strings.IndexAny(username, "/@")
	475	j := strings.LastIndexAny(username, "/@")
	476	if i >= 0 {
	477	username = rawUsername[:i]
[73]	478	}
[183]	479	if j >= 0 {
[190]	480	if rawUsername[j] == '@' {
	481	client = rawUsername[j+1:]
	482	} else {
	483	network = rawUsername[j+1:]
	484	}
[73]	485	}
[183]	486	if i >= 0 && j >= 0 && i < j {
[190]	487	if rawUsername[i] == '@' {
	488	client = rawUsername[i+1 : j]
	489	} else {
	490	network = rawUsername[i+1 : j]
	491	}
[183]	492	}
	493
	494	return username, client, network
[112]	495	}
[73]	496
[168]	497	func (dc *downstreamConn) authenticate(username, password string) error {
[183]	498	username, clientName, networkName := unmarshalUsername(username)
[168]	499
[173]	500	u, err := dc.srv.db.GetUser(username)
	501	if err != nil {
	502	dc.logger.Printf("failed authentication for %q: %v", username, err)
[168]	503	return errAuthFailed
	504	}
	505
[173]	506	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]	507	if err != nil {
	508	dc.logger.Printf("failed authentication for %q: %v", username, err)
	509	return errAuthFailed
	510	}
	511
[173]	512	dc.user = dc.srv.getUser(username)
	513	if dc.user == nil {
	514	dc.logger.Printf("failed authentication for %q: user not active", username)
	515	return errAuthFailed
	516	}
[183]	517	dc.clientName = clientName
[168]	518	dc.networkName = networkName
	519	return nil
	520	}
	521
	522	func (dc *downstreamConn) register() error {
	523	if dc.registered {
	524	return fmt.Errorf("tried to register twice")
	525	}
	526
	527	password := dc.password
	528	dc.password = ""
	529	if dc.user == nil {
	530	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	531	return err
	532	}
	533	}
	534
[183]	535	if dc.clientName == "" && dc.networkName == "" {
	536	_, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]	537	}
	538
	539	dc.registered = true
[184]	540	dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]	541	return nil
	542	}
	543
	544	func (dc *downstreamConn) loadNetwork() error {
	545	if dc.networkName == "" {
[112]	546	return nil
	547	}
[85]	548
[168]	549	network := dc.user.getNetwork(dc.networkName)
[112]	550	if network == nil {
[168]	551	addr := dc.networkName
[112]	552	if !strings.ContainsRune(addr, ':') {
	553	addr = addr + ":6697"
	554	}
	555
	556	dc.logger.Printf("trying to connect to new network %q", addr)
	557	if err := sanityCheckServer(addr); err != nil {
	558	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	559	return ircError{&irc.Message{
	560	Command: irc.ERR_PASSWDMISMATCH,
[168]	561	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]	562	}}
	563	}
	564
[168]	565	dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]	566	var err error
[120]	567	network, err = dc.user.createNetwork(&Network{
[168]	568	Addr: dc.networkName,
[120]	569	Nick: dc.nick,
	570	})
[112]	571	if err != nil {
	572	return err
	573	}
	574	}
	575
	576	dc.network = network
	577	return nil
	578	}
	579
[168]	580	func (dc *downstreamConn) welcome() error {
	581	if dc.user == nil \|\| !dc.registered {
	582	panic("tried to welcome an unregistered connection")
[37]	583	}
	584
[168]	585	// TODO: doing this might take some time. We should do it in dc.register
	586	// instead, but we'll potentially be adding a new network and this must be
	587	// done in the user goroutine.
	588	if err := dc.loadNetwork(); err != nil {
	589	return err
[85]	590	}
	591
[185]	592	// Only send history if we're the first connected client with that name and
	593	// network
	594	sendHistory := true
	595	dc.user.forEachDownstream(func(conn *downstreamConn) {
	596	if dc.clientName == conn.clientName && dc.network == conn.network {
	597	sendHistory = false
	598	}
	599	})
[40]	600
[55]	601	dc.SendMessage(&irc.Message{
	602	Prefix: dc.srv.prefix(),
[13]	603	Command: irc.RPL_WELCOME,
[98]	604	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	605	})
[55]	606	dc.SendMessage(&irc.Message{
	607	Prefix: dc.srv.prefix(),
[13]	608	Command: irc.RPL_YOURHOST,
[55]	609	Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]	610	})
[55]	611	dc.SendMessage(&irc.Message{
	612	Prefix: dc.srv.prefix(),
[13]	613	Command: irc.RPL_CREATED,
[55]	614	Params: []string{dc.nick, "Who cares when the server was created?"},
[54]	615	})
[55]	616	dc.SendMessage(&irc.Message{
	617	Prefix: dc.srv.prefix(),
[13]	618	Command: irc.RPL_MYINFO,
[98]	619	Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	620	})
[93]	621	// TODO: RPL_ISUPPORT
[55]	622	dc.SendMessage(&irc.Message{
	623	Prefix: dc.srv.prefix(),
[13]	624	Command: irc.ERR_NOMOTD,
[55]	625	Params: []string{dc.nick, "No MOTD"},
[54]	626	})
[13]	627
[73]	628	dc.forEachUpstream(func(uc *upstreamConn) {
[30]	629	for _, ch := range uc.channels {
	630	if ch.complete {
[132]	631	dc.SendMessage(&irc.Message{
	632	Prefix: dc.prefix(),
	633	Command: "JOIN",
	634	Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
	635	})
	636
[55]	637	forwardChannel(dc, ch)
[30]	638	}
	639	}
[143]	640	})
[50]	641
[143]	642	dc.forEachNetwork(func(net *network) {
[185]	643	dc.runNetwork(net, sendHistory)
[144]	644	})
[57]	645
[144]	646	return nil
	647	}
	648
	649	// runNetwork starts listening for messages coming from the network's ring
	650	// buffer.
	651	//
	652	// It panics if the network is not suitable for the downstream connection.
	653	func (dc downstreamConn) runNetwork(net network, loadHistory bool) {
	654	if dc.network != nil && net != dc.network {
	655	panic("network not suitable for downstream connection")
	656	}
	657
	658	var seqPtr *uint64
	659	if loadHistory {
[185]	660	seq, ok := net.history[dc.clientName]
[144]	661	if ok {
	662	seqPtr = &seq
[50]	663	}
[144]	664	}
[57]	665
[191]	666	// TODO: can't be enabled/disabled on-the-fly
	667	msgTagsEnabled := dc.caps["message-tags"]
[194]	668	serverTimeEnabled := dc.caps["server-time"]
[211]	669	echoMessageEnabled := dc.caps["echo-message"]
[191]	670
[144]	671	consumer, ch := net.ring.NewConsumer(seqPtr)
[204]	672
	673	if _, ok := dc.ringConsumers[net]; ok {
	674	panic("network has been added twice")
	675	}
	676	dc.ringConsumers[net] = consumer
	677
[144]	678	go func() {
[204]	679	for range ch {
	680	uc := net.upstream()
	681	if uc == nil {
	682	dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
	683	continue
	684	}
	685
	686	for {
	687	msg := consumer.Peek()
	688	if msg == nil {
[203]	689	break
	690	}
	691
[204]	692	dc.lock.Lock()
	693	_, ours := dc.ourMessages[msg]
	694	delete(dc.ourMessages, msg)
	695	dc.lock.Unlock()
[211]	696	if ours && !echoMessageEnabled {
[204]	697	// The message comes from our connection, don't echo it
	698	// back
	699	consumer.Consume()
	700	continue
[57]	701	}
[188]	702
[204]	703	msg = msg.Copy()
	704	switch msg.Command {
	705	case "PRIVMSG":
	706	msg.Prefix = dc.marshalUserPrefix(uc, msg.Prefix)
	707	msg.Params[0] = dc.marshalEntity(uc, msg.Params[0])
	708	default:
	709	panic("expected to consume a PRIVMSG message")
	710	}
[188]	711
[204]	712	if !msgTagsEnabled {
	713	for name := range msg.Tags {
	714	supported := false
	715	switch name {
	716	case "time":
	717	supported = serverTimeEnabled
[194]	718	}
[204]	719	if !supported {
	720	delete(msg.Tags, name)
	721	}
[191]	722	}
[204]	723	}
[191]	724
[204]	725	dc.SendMessage(msg)
	726	consumer.Consume()
[57]	727	}
[144]	728	}
	729	}()
[13]	730	}
	731
[103]	732	func (dc *downstreamConn) runUntilRegistered() error {
	733	for !dc.registered {
	734	msg, err := dc.irc.ReadMessage()
[106]	735	if err != nil {
[103]	736	return fmt.Errorf("failed to read IRC command: %v", err)
	737	}
	738
[110]	739	if dc.srv.Debug {
	740	dc.logger.Printf("received: %v", msg)
	741	}
	742
[103]	743	err = dc.handleMessage(msg)
	744	if ircErr, ok := err.(ircError); ok {
	745	ircErr.Message.Prefix = dc.srv.prefix()
	746	dc.SendMessage(ircErr.Message)
	747	} else if err != nil {
	748	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	749	}
	750	}
	751
	752	return nil
	753	}
	754
[55]	755	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	756	switch msg.Command {
[111]	757	case "CAP":
	758	var subCmd string
	759	if err := parseMessageParams(msg, &subCmd); err != nil {
	760	return err
	761	}
	762	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	763	return err
	764	}
[107]	765	case "PING":
	766	dc.SendMessage(&irc.Message{
	767	Prefix: dc.srv.prefix(),
	768	Command: "PONG",
	769	Params: msg.Params,
	770	})
	771	return nil
[42]	772	case "USER":
[13]	773	return ircError{&irc.Message{
	774	Command: irc.ERR_ALREADYREGISTERED,
[55]	775	Params: []string{dc.nick, "You may not reregister"},
[13]	776	}}
[42]	777	case "NICK":
[90]	778	var nick string
	779	if err := parseMessageParams(msg, &nick); err != nil {
	780	return err
	781	}
	782
	783	var err error
	784	dc.forEachNetwork(func(n *network) {
	785	if err != nil {
	786	return
	787	}
	788	n.Nick = nick
	789	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	790	})
	791	if err != nil {
	792	return err
	793	}
	794
[73]	795	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	796	uc.SendMessage(msg)
[42]	797	})
[146]	798	case "JOIN":
	799	var namesStr string
	800	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	801	return err
	802	}
	803
[146]	804	var keys []string
	805	if len(msg.Params) > 1 {
	806	keys = strings.Split(msg.Params[1], ",")
	807	}
	808
	809	for i, name := range strings.Split(namesStr, ",") {
[145]	810	uc, upstreamName, err := dc.unmarshalEntity(name)
	811	if err != nil {
[158]	812	return err
[145]	813	}
[48]	814
[146]	815	var key string
	816	if len(keys) > i {
	817	key = keys[i]
	818	}
	819
	820	params := []string{upstreamName}
	821	if key != "" {
	822	params = append(params, key)
	823	}
[145]	824	uc.SendMessage(&irc.Message{
[146]	825	Command: "JOIN",
	826	Params: params,
[145]	827	})
[89]	828
[207]	829	ch, err := dc.srv.db.GetChannel(uc.network.ID, upstreamName)
	830	if err == ErrNoSuchChannel {
	831	ch = &Channel{Name: upstreamName}
	832	} else if err != nil {
	833	return err
[89]	834	}
[207]	835
	836	ch.Key = key
	837
	838	if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
	839	return err
	840	}
[89]	841	}
[146]	842	case "PART":
	843	var namesStr string
	844	if err := parseMessageParams(msg, &namesStr); err != nil {
	845	return err
	846	}
	847
	848	var reason string
	849	if len(msg.Params) > 1 {
	850	reason = msg.Params[1]
	851	}
	852
	853	for _, name := range strings.Split(namesStr, ",") {
	854	uc, upstreamName, err := dc.unmarshalEntity(name)
	855	if err != nil {
[158]	856	return err
[146]	857	}
	858
	859	params := []string{upstreamName}
	860	if reason != "" {
	861	params = append(params, reason)
	862	}
	863	uc.SendMessage(&irc.Message{
	864	Command: "PART",
	865	Params: params,
	866	})
	867
	868	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	869	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	870	}
	871	}
[159]	872	case "KICK":
	873	var channelStr, userStr string
	874	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	875	return err
	876	}
	877
	878	channels := strings.Split(channelStr, ",")
	879	users := strings.Split(userStr, ",")
	880
	881	var reason string
	882	if len(msg.Params) > 2 {
	883	reason = msg.Params[2]
	884	}
	885
	886	if len(channels) != 1 && len(channels) != len(users) {
	887	return ircError{&irc.Message{
	888	Command: irc.ERR_BADCHANMASK,
	889	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	890	}}
	891	}
	892
	893	for i, user := range users {
	894	var channel string
	895	if len(channels) == 1 {
	896	channel = channels[0]
	897	} else {
	898	channel = channels[i]
	899	}
	900
	901	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	902	if err != nil {
	903	return err
	904	}
	905
	906	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	907	if err != nil {
	908	return err
	909	}
	910
	911	if ucChannel != ucUser {
	912	return ircError{&irc.Message{
	913	Command: irc.ERR_USERNOTINCHANNEL,
	914	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	915	}}
	916	}
	917	uc := ucChannel
	918
	919	params := []string{upstreamChannel, upstreamUser}
	920	if reason != "" {
	921	params = append(params, reason)
	922	}
	923	uc.SendMessage(&irc.Message{
	924	Command: "KICK",
	925	Params: params,
	926	})
	927	}
[69]	928	case "MODE":
[46]	929	var name string
	930	if err := parseMessageParams(msg, &name); err != nil {
	931	return err
	932	}
	933
	934	var modeStr string
	935	if len(msg.Params) > 1 {
	936	modeStr = msg.Params[1]
	937	}
	938
[139]	939	if name == dc.nick {
[46]	940	if modeStr != "" {
[73]	941	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	942	uc.SendMessage(&irc.Message{
	943	Command: "MODE",
	944	Params: []string{uc.nick, modeStr},
	945	})
[46]	946	})
	947	} else {
[55]	948	dc.SendMessage(&irc.Message{
	949	Prefix: dc.srv.prefix(),
[46]	950	Command: irc.RPL_UMODEIS,
[129]	951	Params: []string{dc.nick, ""}, // TODO
[54]	952	})
[46]	953	}
[139]	954	return nil
[46]	955	}
[139]	956
	957	uc, upstreamName, err := dc.unmarshalEntity(name)
	958	if err != nil {
	959	return err
	960	}
	961
	962	if !uc.isChannel(upstreamName) {
	963	return ircError{&irc.Message{
	964	Command: irc.ERR_USERSDONTMATCH,
	965	Params: []string{dc.nick, "Cannot change mode for other users"},
	966	}}
	967	}
	968
	969	if modeStr != "" {
	970	params := []string{upstreamName, modeStr}
	971	params = append(params, msg.Params[2:]...)
	972	uc.SendMessage(&irc.Message{
	973	Command: "MODE",
	974	Params: params,
	975	})
	976	} else {
	977	ch, ok := uc.channels[upstreamName]
	978	if !ok {
	979	return ircError{&irc.Message{
	980	Command: irc.ERR_NOSUCHCHANNEL,
	981	Params: []string{dc.nick, name, "No such channel"},
	982	}}
	983	}
	984
	985	if ch.modes == nil {
	986	// we haven't received the initial RPL_CHANNELMODEIS yet
	987	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	988	return nil
	989	}
	990
	991	modeStr, modeParams := ch.modes.Format()
	992	params := []string{dc.nick, name, modeStr}
	993	params = append(params, modeParams...)
	994
	995	dc.SendMessage(&irc.Message{
	996	Prefix: dc.srv.prefix(),
	997	Command: irc.RPL_CHANNELMODEIS,
	998	Params: params,
	999	})
[162]	1000	if ch.creationTime != "" {
	1001	dc.SendMessage(&irc.Message{
	1002	Prefix: dc.srv.prefix(),
	1003	Command: rpl_creationtime,
	1004	Params: []string{dc.nick, name, ch.creationTime},
	1005	})
	1006	}
[139]	1007	}
[160]	1008	case "TOPIC":
	1009	var channel string
	1010	if err := parseMessageParams(msg, &channel); err != nil {
	1011	return err
	1012	}
	1013
	1014	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1015	if err != nil {
	1016	return err
	1017	}
	1018
	1019	if len(msg.Params) > 1 { // setting topic
	1020	topic := msg.Params[1]
	1021	uc.SendMessage(&irc.Message{
	1022	Command: "TOPIC",
	1023	Params: []string{upstreamChannel, topic},
	1024	})
	1025	} else { // getting topic
	1026	ch, ok := uc.channels[upstreamChannel]
	1027	if !ok {
	1028	return ircError{&irc.Message{
	1029	Command: irc.ERR_NOSUCHCHANNEL,
	1030	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1031	}}
	1032	}
	1033	sendTopic(dc, ch)
	1034	}
[177]	1035	case "LIST":
	1036	// TODO: support ELIST when supported by all upstreams
	1037
	1038	pl := pendingLIST{
	1039	downstreamID: dc.id,
	1040	pendingCommands: make(map[int64]*irc.Message),
	1041	}
	1042	var upstreamChannels map[int64][]string
	1043	if len(msg.Params) > 0 {
	1044	upstreamChannels = make(map[int64][]string)
	1045	channels := strings.Split(msg.Params[0], ",")
	1046	for _, channel := range channels {
	1047	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1048	if err != nil {
	1049	return err
	1050	}
	1051	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1052	}
	1053	}
	1054
	1055	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1056	dc.forEachUpstream(func(uc *upstreamConn) {
	1057	var params []string
	1058	if upstreamChannels != nil {
	1059	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1060	params = []string{strings.Join(channels, ",")}
	1061	} else {
	1062	return
	1063	}
	1064	}
	1065	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1066	Command: "LIST",
	1067	Params: params,
	1068	}
[181]	1069	uc.trySendLIST(dc.id)
[177]	1070	})
[140]	1071	case "NAMES":
	1072	if len(msg.Params) == 0 {
	1073	dc.SendMessage(&irc.Message{
	1074	Prefix: dc.srv.prefix(),
	1075	Command: irc.RPL_ENDOFNAMES,
	1076	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1077	})
	1078	return nil
	1079	}
	1080
	1081	channels := strings.Split(msg.Params[0], ",")
	1082	for _, channel := range channels {
	1083	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1084	if err != nil {
	1085	return err
	1086	}
	1087
	1088	ch, ok := uc.channels[upstreamChannel]
	1089	if ok {
	1090	sendNames(dc, ch)
	1091	} else {
	1092	// NAMES on a channel we have not joined, ask upstream
[176]	1093	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1094	Command: "NAMES",
	1095	Params: []string{upstreamChannel},
	1096	})
	1097	}
	1098	}
[127]	1099	case "WHO":
	1100	if len(msg.Params) == 0 {
	1101	// TODO: support WHO without parameters
	1102	dc.SendMessage(&irc.Message{
	1103	Prefix: dc.srv.prefix(),
	1104	Command: irc.RPL_ENDOFWHO,
[140]	1105	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1106	})
	1107	return nil
	1108	}
	1109
	1110	// TODO: support WHO masks
	1111	entity := msg.Params[0]
	1112
[142]	1113	if entity == dc.nick {
	1114	// TODO: support AWAY (H/G) in self WHO reply
	1115	dc.SendMessage(&irc.Message{
	1116	Prefix: dc.srv.prefix(),
	1117	Command: irc.RPL_WHOREPLY,
[184]	1118	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1119	})
	1120	dc.SendMessage(&irc.Message{
	1121	Prefix: dc.srv.prefix(),
	1122	Command: irc.RPL_ENDOFWHO,
	1123	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1124	})
	1125	return nil
	1126	}
	1127
[127]	1128	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1129	if err != nil {
	1130	return err
	1131	}
	1132
	1133	var params []string
	1134	if len(msg.Params) == 2 {
	1135	params = []string{upstreamName, msg.Params[1]}
	1136	} else {
	1137	params = []string{upstreamName}
	1138	}
	1139
[176]	1140	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1141	Command: "WHO",
	1142	Params: params,
	1143	})
[128]	1144	case "WHOIS":
	1145	if len(msg.Params) == 0 {
	1146	return ircError{&irc.Message{
	1147	Command: irc.ERR_NONICKNAMEGIVEN,
	1148	Params: []string{dc.nick, "No nickname given"},
	1149	}}
	1150	}
	1151
	1152	var target, mask string
	1153	if len(msg.Params) == 1 {
	1154	target = ""
	1155	mask = msg.Params[0]
	1156	} else {
	1157	target = msg.Params[0]
	1158	mask = msg.Params[1]
	1159	}
	1160	// TODO: support multiple WHOIS users
	1161	if i := strings.IndexByte(mask, ','); i >= 0 {
	1162	mask = mask[:i]
	1163	}
	1164
[142]	1165	if mask == dc.nick {
	1166	dc.SendMessage(&irc.Message{
	1167	Prefix: dc.srv.prefix(),
	1168	Command: irc.RPL_WHOISUSER,
[184]	1169	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1170	})
	1171	dc.SendMessage(&irc.Message{
	1172	Prefix: dc.srv.prefix(),
	1173	Command: irc.RPL_WHOISSERVER,
	1174	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1175	})
	1176	dc.SendMessage(&irc.Message{
	1177	Prefix: dc.srv.prefix(),
	1178	Command: irc.RPL_ENDOFWHOIS,
	1179	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1180	})
	1181	return nil
	1182	}
	1183
[128]	1184	// TODO: support WHOIS masks
	1185	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1186	if err != nil {
	1187	return err
	1188	}
	1189
	1190	var params []string
	1191	if target != "" {
	1192	params = []string{target, upstreamNick}
	1193	} else {
	1194	params = []string{upstreamNick}
	1195	}
	1196
[176]	1197	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1198	Command: "WHOIS",
	1199	Params: params,
	1200	})
[58]	1201	case "PRIVMSG":
	1202	var targetsStr, text string
	1203	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1204	return err
	1205	}
	1206
	1207	for _, name := range strings.Split(targetsStr, ",") {
[117]	1208	if name == serviceNick {
	1209	handleServicePRIVMSG(dc, text)
	1210	continue
	1211	}
	1212
[127]	1213	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1214	if err != nil {
	1215	return err
	1216	}
	1217
[95]	1218	if upstreamName == "NickServ" {
	1219	dc.handleNickServPRIVMSG(uc, text)
	1220	}
	1221
[69]	1222	uc.SendMessage(&irc.Message{
[58]	1223	Command: "PRIVMSG",
[69]	1224	Params: []string{upstreamName, text},
[60]	1225	})
[105]	1226
[113]	1227	echoMsg := &irc.Message{
	1228	Prefix: &irc.Prefix{
	1229	Name: uc.nick,
	1230	User: uc.username,
	1231	},
[114]	1232	Command: "PRIVMSG",
[113]	1233	Params: []string{upstreamName, text},
	1234	}
[105]	1235	dc.lock.Lock()
[113]	1236	dc.ourMessages[echoMsg] = struct{}{}
[105]	1237	dc.lock.Unlock()
	1238
[143]	1239	uc.network.ring.Produce(echoMsg)
[58]	1240	}
[164]	1241	case "NOTICE":
	1242	var targetsStr, text string
	1243	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1244	return err
	1245	}
	1246
	1247	for _, name := range strings.Split(targetsStr, ",") {
	1248	uc, upstreamName, err := dc.unmarshalEntity(name)
	1249	if err != nil {
	1250	return err
	1251	}
	1252
	1253	uc.SendMessage(&irc.Message{
	1254	Command: "NOTICE",
	1255	Params: []string{upstreamName, text},
	1256	})
	1257	}
[163]	1258	case "INVITE":
	1259	var user, channel string
	1260	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1261	return err
	1262	}
	1263
	1264	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1265	if err != nil {
	1266	return err
	1267	}
	1268
	1269	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1270	if err != nil {
	1271	return err
	1272	}
	1273
	1274	if ucChannel != ucUser {
	1275	return ircError{&irc.Message{
	1276	Command: irc.ERR_USERNOTINCHANNEL,
	1277	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1278	}}
	1279	}
	1280	uc := ucChannel
	1281
[176]	1282	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1283	Command: "INVITE",
	1284	Params: []string{upstreamUser, upstreamChannel},
	1285	})
[13]	1286	default:
[55]	1287	dc.logger.Printf("unhandled message: %v", msg)
[13]	1288	return newUnknownCommandError(msg.Command)
	1289	}
[42]	1290	return nil
[13]	1291	}
[95]	1292
	1293	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1294	username, password, ok := parseNickServCredentials(text, uc.nick)
	1295	if !ok {
	1296	return
	1297	}
	1298
	1299	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1300	n := uc.network
	1301	n.SASL.Mechanism = "PLAIN"
	1302	n.SASL.Plain.Username = username
	1303	n.SASL.Plain.Password = password
	1304	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1305	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1306	}
	1307	}
	1308
	1309	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1310	fields := strings.Fields(text)
	1311	if len(fields) < 2 {
	1312	return "", "", false
	1313	}
	1314	cmd := strings.ToUpper(fields[0])
	1315	params := fields[1:]
	1316	switch cmd {
	1317	case "REGISTER":
	1318	username = nick
	1319	password = params[0]
	1320	case "IDENTIFY":
	1321	if len(params) == 1 {
	1322	username = nick
[182]	1323	password = params[0]
[95]	1324	} else {
	1325	username = params[0]
[182]	1326	password = params[1]
[95]	1327	}
[182]	1328	case "SET":
	1329	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1330	username = nick
	1331	password = params[1]
	1332	}
[95]	1333	}
	1334	return username, password, true
	1335	}

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

Download in other formats: