Context Navigation

source: code/trunk/downstream.go@ 210

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

Introduce conn for common connection logic

This centralizes the common upstream & downstream bits.

File size: 30.5 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
[194]	382	caps := []string{"message-tags", "server-time"}
	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 {
[194]	435	case "sasl", "message-tags", "server-time":
[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"]
[191]	669
[144]	670	consumer, ch := net.ring.NewConsumer(seqPtr)
[204]	671
	672	if _, ok := dc.ringConsumers[net]; ok {
	673	panic("network has been added twice")
	674	}
	675	dc.ringConsumers[net] = consumer
	676
[144]	677	go func() {
[204]	678	for range ch {
	679	uc := net.upstream()
	680	if uc == nil {
	681	dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
	682	continue
	683	}
	684
	685	for {
	686	msg := consumer.Peek()
	687	if msg == nil {
[203]	688	break
	689	}
	690
[204]	691	dc.lock.Lock()
	692	_, ours := dc.ourMessages[msg]
	693	delete(dc.ourMessages, msg)
	694	dc.lock.Unlock()
	695	if ours {
	696	// The message comes from our connection, don't echo it
	697	// back
	698	consumer.Consume()
	699	continue
[57]	700	}
[188]	701
[204]	702	msg = msg.Copy()
	703	switch msg.Command {
	704	case "PRIVMSG":
	705	msg.Prefix = dc.marshalUserPrefix(uc, msg.Prefix)
	706	msg.Params[0] = dc.marshalEntity(uc, msg.Params[0])
	707	default:
	708	panic("expected to consume a PRIVMSG message")
	709	}
[188]	710
[204]	711	if !msgTagsEnabled {
	712	for name := range msg.Tags {
	713	supported := false
	714	switch name {
	715	case "time":
	716	supported = serverTimeEnabled
[194]	717	}
[204]	718	if !supported {
	719	delete(msg.Tags, name)
	720	}
[191]	721	}
[204]	722	}
[191]	723
[204]	724	dc.SendMessage(msg)
	725	consumer.Consume()
[57]	726	}
[144]	727	}
	728	}()
[13]	729	}
	730
[103]	731	func (dc *downstreamConn) runUntilRegistered() error {
	732	for !dc.registered {
	733	msg, err := dc.irc.ReadMessage()
[106]	734	if err != nil {
[103]	735	return fmt.Errorf("failed to read IRC command: %v", err)
	736	}
	737
[110]	738	if dc.srv.Debug {
	739	dc.logger.Printf("received: %v", msg)
	740	}
	741
[103]	742	err = dc.handleMessage(msg)
	743	if ircErr, ok := err.(ircError); ok {
	744	ircErr.Message.Prefix = dc.srv.prefix()
	745	dc.SendMessage(ircErr.Message)
	746	} else if err != nil {
	747	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	748	}
	749	}
	750
	751	return nil
	752	}
	753
[55]	754	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	755	switch msg.Command {
[111]	756	case "CAP":
	757	var subCmd string
	758	if err := parseMessageParams(msg, &subCmd); err != nil {
	759	return err
	760	}
	761	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	762	return err
	763	}
[107]	764	case "PING":
	765	dc.SendMessage(&irc.Message{
	766	Prefix: dc.srv.prefix(),
	767	Command: "PONG",
	768	Params: msg.Params,
	769	})
	770	return nil
[42]	771	case "USER":
[13]	772	return ircError{&irc.Message{
	773	Command: irc.ERR_ALREADYREGISTERED,
[55]	774	Params: []string{dc.nick, "You may not reregister"},
[13]	775	}}
[42]	776	case "NICK":
[90]	777	var nick string
	778	if err := parseMessageParams(msg, &nick); err != nil {
	779	return err
	780	}
	781
	782	var err error
	783	dc.forEachNetwork(func(n *network) {
	784	if err != nil {
	785	return
	786	}
	787	n.Nick = nick
	788	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	789	})
	790	if err != nil {
	791	return err
	792	}
	793
[73]	794	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	795	uc.SendMessage(msg)
[42]	796	})
[146]	797	case "JOIN":
	798	var namesStr string
	799	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	800	return err
	801	}
	802
[146]	803	var keys []string
	804	if len(msg.Params) > 1 {
	805	keys = strings.Split(msg.Params[1], ",")
	806	}
	807
	808	for i, name := range strings.Split(namesStr, ",") {
[145]	809	uc, upstreamName, err := dc.unmarshalEntity(name)
	810	if err != nil {
[158]	811	return err
[145]	812	}
[48]	813
[146]	814	var key string
	815	if len(keys) > i {
	816	key = keys[i]
	817	}
	818
	819	params := []string{upstreamName}
	820	if key != "" {
	821	params = append(params, key)
	822	}
[145]	823	uc.SendMessage(&irc.Message{
[146]	824	Command: "JOIN",
	825	Params: params,
[145]	826	})
[89]	827
[207]	828	ch, err := dc.srv.db.GetChannel(uc.network.ID, upstreamName)
	829	if err == ErrNoSuchChannel {
	830	ch = &Channel{Name: upstreamName}
	831	} else if err != nil {
	832	return err
[89]	833	}
[207]	834
	835	ch.Key = key
	836
	837	if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
	838	return err
	839	}
[89]	840	}
[146]	841	case "PART":
	842	var namesStr string
	843	if err := parseMessageParams(msg, &namesStr); err != nil {
	844	return err
	845	}
	846
	847	var reason string
	848	if len(msg.Params) > 1 {
	849	reason = msg.Params[1]
	850	}
	851
	852	for _, name := range strings.Split(namesStr, ",") {
	853	uc, upstreamName, err := dc.unmarshalEntity(name)
	854	if err != nil {
[158]	855	return err
[146]	856	}
	857
	858	params := []string{upstreamName}
	859	if reason != "" {
	860	params = append(params, reason)
	861	}
	862	uc.SendMessage(&irc.Message{
	863	Command: "PART",
	864	Params: params,
	865	})
	866
	867	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	868	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	869	}
	870	}
[159]	871	case "KICK":
	872	var channelStr, userStr string
	873	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	874	return err
	875	}
	876
	877	channels := strings.Split(channelStr, ",")
	878	users := strings.Split(userStr, ",")
	879
	880	var reason string
	881	if len(msg.Params) > 2 {
	882	reason = msg.Params[2]
	883	}
	884
	885	if len(channels) != 1 && len(channels) != len(users) {
	886	return ircError{&irc.Message{
	887	Command: irc.ERR_BADCHANMASK,
	888	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	889	}}
	890	}
	891
	892	for i, user := range users {
	893	var channel string
	894	if len(channels) == 1 {
	895	channel = channels[0]
	896	} else {
	897	channel = channels[i]
	898	}
	899
	900	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	901	if err != nil {
	902	return err
	903	}
	904
	905	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	906	if err != nil {
	907	return err
	908	}
	909
	910	if ucChannel != ucUser {
	911	return ircError{&irc.Message{
	912	Command: irc.ERR_USERNOTINCHANNEL,
	913	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	914	}}
	915	}
	916	uc := ucChannel
	917
	918	params := []string{upstreamChannel, upstreamUser}
	919	if reason != "" {
	920	params = append(params, reason)
	921	}
	922	uc.SendMessage(&irc.Message{
	923	Command: "KICK",
	924	Params: params,
	925	})
	926	}
[69]	927	case "MODE":
[46]	928	var name string
	929	if err := parseMessageParams(msg, &name); err != nil {
	930	return err
	931	}
	932
	933	var modeStr string
	934	if len(msg.Params) > 1 {
	935	modeStr = msg.Params[1]
	936	}
	937
[139]	938	if name == dc.nick {
[46]	939	if modeStr != "" {
[73]	940	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	941	uc.SendMessage(&irc.Message{
	942	Command: "MODE",
	943	Params: []string{uc.nick, modeStr},
	944	})
[46]	945	})
	946	} else {
[55]	947	dc.SendMessage(&irc.Message{
	948	Prefix: dc.srv.prefix(),
[46]	949	Command: irc.RPL_UMODEIS,
[129]	950	Params: []string{dc.nick, ""}, // TODO
[54]	951	})
[46]	952	}
[139]	953	return nil
[46]	954	}
[139]	955
	956	uc, upstreamName, err := dc.unmarshalEntity(name)
	957	if err != nil {
	958	return err
	959	}
	960
	961	if !uc.isChannel(upstreamName) {
	962	return ircError{&irc.Message{
	963	Command: irc.ERR_USERSDONTMATCH,
	964	Params: []string{dc.nick, "Cannot change mode for other users"},
	965	}}
	966	}
	967
	968	if modeStr != "" {
	969	params := []string{upstreamName, modeStr}
	970	params = append(params, msg.Params[2:]...)
	971	uc.SendMessage(&irc.Message{
	972	Command: "MODE",
	973	Params: params,
	974	})
	975	} else {
	976	ch, ok := uc.channels[upstreamName]
	977	if !ok {
	978	return ircError{&irc.Message{
	979	Command: irc.ERR_NOSUCHCHANNEL,
	980	Params: []string{dc.nick, name, "No such channel"},
	981	}}
	982	}
	983
	984	if ch.modes == nil {
	985	// we haven't received the initial RPL_CHANNELMODEIS yet
	986	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	987	return nil
	988	}
	989
	990	modeStr, modeParams := ch.modes.Format()
	991	params := []string{dc.nick, name, modeStr}
	992	params = append(params, modeParams...)
	993
	994	dc.SendMessage(&irc.Message{
	995	Prefix: dc.srv.prefix(),
	996	Command: irc.RPL_CHANNELMODEIS,
	997	Params: params,
	998	})
[162]	999	if ch.creationTime != "" {
	1000	dc.SendMessage(&irc.Message{
	1001	Prefix: dc.srv.prefix(),
	1002	Command: rpl_creationtime,
	1003	Params: []string{dc.nick, name, ch.creationTime},
	1004	})
	1005	}
[139]	1006	}
[160]	1007	case "TOPIC":
	1008	var channel string
	1009	if err := parseMessageParams(msg, &channel); err != nil {
	1010	return err
	1011	}
	1012
	1013	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1014	if err != nil {
	1015	return err
	1016	}
	1017
	1018	if len(msg.Params) > 1 { // setting topic
	1019	topic := msg.Params[1]
	1020	uc.SendMessage(&irc.Message{
	1021	Command: "TOPIC",
	1022	Params: []string{upstreamChannel, topic},
	1023	})
	1024	} else { // getting topic
	1025	ch, ok := uc.channels[upstreamChannel]
	1026	if !ok {
	1027	return ircError{&irc.Message{
	1028	Command: irc.ERR_NOSUCHCHANNEL,
	1029	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1030	}}
	1031	}
	1032	sendTopic(dc, ch)
	1033	}
[177]	1034	case "LIST":
	1035	// TODO: support ELIST when supported by all upstreams
	1036
	1037	pl := pendingLIST{
	1038	downstreamID: dc.id,
	1039	pendingCommands: make(map[int64]*irc.Message),
	1040	}
	1041	var upstreamChannels map[int64][]string
	1042	if len(msg.Params) > 0 {
	1043	upstreamChannels = make(map[int64][]string)
	1044	channels := strings.Split(msg.Params[0], ",")
	1045	for _, channel := range channels {
	1046	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1047	if err != nil {
	1048	return err
	1049	}
	1050	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1051	}
	1052	}
	1053
	1054	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1055	dc.forEachUpstream(func(uc *upstreamConn) {
	1056	var params []string
	1057	if upstreamChannels != nil {
	1058	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1059	params = []string{strings.Join(channels, ",")}
	1060	} else {
	1061	return
	1062	}
	1063	}
	1064	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1065	Command: "LIST",
	1066	Params: params,
	1067	}
[181]	1068	uc.trySendLIST(dc.id)
[177]	1069	})
[140]	1070	case "NAMES":
	1071	if len(msg.Params) == 0 {
	1072	dc.SendMessage(&irc.Message{
	1073	Prefix: dc.srv.prefix(),
	1074	Command: irc.RPL_ENDOFNAMES,
	1075	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1076	})
	1077	return nil
	1078	}
	1079
	1080	channels := strings.Split(msg.Params[0], ",")
	1081	for _, channel := range channels {
	1082	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1083	if err != nil {
	1084	return err
	1085	}
	1086
	1087	ch, ok := uc.channels[upstreamChannel]
	1088	if ok {
	1089	sendNames(dc, ch)
	1090	} else {
	1091	// NAMES on a channel we have not joined, ask upstream
[176]	1092	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1093	Command: "NAMES",
	1094	Params: []string{upstreamChannel},
	1095	})
	1096	}
	1097	}
[127]	1098	case "WHO":
	1099	if len(msg.Params) == 0 {
	1100	// TODO: support WHO without parameters
	1101	dc.SendMessage(&irc.Message{
	1102	Prefix: dc.srv.prefix(),
	1103	Command: irc.RPL_ENDOFWHO,
[140]	1104	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1105	})
	1106	return nil
	1107	}
	1108
	1109	// TODO: support WHO masks
	1110	entity := msg.Params[0]
	1111
[142]	1112	if entity == dc.nick {
	1113	// TODO: support AWAY (H/G) in self WHO reply
	1114	dc.SendMessage(&irc.Message{
	1115	Prefix: dc.srv.prefix(),
	1116	Command: irc.RPL_WHOREPLY,
[184]	1117	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1118	})
	1119	dc.SendMessage(&irc.Message{
	1120	Prefix: dc.srv.prefix(),
	1121	Command: irc.RPL_ENDOFWHO,
	1122	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1123	})
	1124	return nil
	1125	}
	1126
[127]	1127	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1128	if err != nil {
	1129	return err
	1130	}
	1131
	1132	var params []string
	1133	if len(msg.Params) == 2 {
	1134	params = []string{upstreamName, msg.Params[1]}
	1135	} else {
	1136	params = []string{upstreamName}
	1137	}
	1138
[176]	1139	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1140	Command: "WHO",
	1141	Params: params,
	1142	})
[128]	1143	case "WHOIS":
	1144	if len(msg.Params) == 0 {
	1145	return ircError{&irc.Message{
	1146	Command: irc.ERR_NONICKNAMEGIVEN,
	1147	Params: []string{dc.nick, "No nickname given"},
	1148	}}
	1149	}
	1150
	1151	var target, mask string
	1152	if len(msg.Params) == 1 {
	1153	target = ""
	1154	mask = msg.Params[0]
	1155	} else {
	1156	target = msg.Params[0]
	1157	mask = msg.Params[1]
	1158	}
	1159	// TODO: support multiple WHOIS users
	1160	if i := strings.IndexByte(mask, ','); i >= 0 {
	1161	mask = mask[:i]
	1162	}
	1163
[142]	1164	if mask == dc.nick {
	1165	dc.SendMessage(&irc.Message{
	1166	Prefix: dc.srv.prefix(),
	1167	Command: irc.RPL_WHOISUSER,
[184]	1168	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1169	})
	1170	dc.SendMessage(&irc.Message{
	1171	Prefix: dc.srv.prefix(),
	1172	Command: irc.RPL_WHOISSERVER,
	1173	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1174	})
	1175	dc.SendMessage(&irc.Message{
	1176	Prefix: dc.srv.prefix(),
	1177	Command: irc.RPL_ENDOFWHOIS,
	1178	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1179	})
	1180	return nil
	1181	}
	1182
[128]	1183	// TODO: support WHOIS masks
	1184	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1185	if err != nil {
	1186	return err
	1187	}
	1188
	1189	var params []string
	1190	if target != "" {
	1191	params = []string{target, upstreamNick}
	1192	} else {
	1193	params = []string{upstreamNick}
	1194	}
	1195
[176]	1196	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1197	Command: "WHOIS",
	1198	Params: params,
	1199	})
[58]	1200	case "PRIVMSG":
	1201	var targetsStr, text string
	1202	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1203	return err
	1204	}
	1205
	1206	for _, name := range strings.Split(targetsStr, ",") {
[117]	1207	if name == serviceNick {
	1208	handleServicePRIVMSG(dc, text)
	1209	continue
	1210	}
	1211
[127]	1212	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1213	if err != nil {
	1214	return err
	1215	}
	1216
[95]	1217	if upstreamName == "NickServ" {
	1218	dc.handleNickServPRIVMSG(uc, text)
	1219	}
	1220
[69]	1221	uc.SendMessage(&irc.Message{
[58]	1222	Command: "PRIVMSG",
[69]	1223	Params: []string{upstreamName, text},
[60]	1224	})
[105]	1225
[113]	1226	echoMsg := &irc.Message{
	1227	Prefix: &irc.Prefix{
	1228	Name: uc.nick,
	1229	User: uc.username,
	1230	},
[114]	1231	Command: "PRIVMSG",
[113]	1232	Params: []string{upstreamName, text},
	1233	}
[105]	1234	dc.lock.Lock()
[113]	1235	dc.ourMessages[echoMsg] = struct{}{}
[105]	1236	dc.lock.Unlock()
	1237
[143]	1238	uc.network.ring.Produce(echoMsg)
[58]	1239	}
[164]	1240	case "NOTICE":
	1241	var targetsStr, text string
	1242	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1243	return err
	1244	}
	1245
	1246	for _, name := range strings.Split(targetsStr, ",") {
	1247	uc, upstreamName, err := dc.unmarshalEntity(name)
	1248	if err != nil {
	1249	return err
	1250	}
	1251
	1252	uc.SendMessage(&irc.Message{
	1253	Command: "NOTICE",
	1254	Params: []string{upstreamName, text},
	1255	})
	1256	}
[163]	1257	case "INVITE":
	1258	var user, channel string
	1259	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1260	return err
	1261	}
	1262
	1263	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1264	if err != nil {
	1265	return err
	1266	}
	1267
	1268	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1269	if err != nil {
	1270	return err
	1271	}
	1272
	1273	if ucChannel != ucUser {
	1274	return ircError{&irc.Message{
	1275	Command: irc.ERR_USERNOTINCHANNEL,
	1276	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1277	}}
	1278	}
	1279	uc := ucChannel
	1280
[176]	1281	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1282	Command: "INVITE",
	1283	Params: []string{upstreamUser, upstreamChannel},
	1284	})
[13]	1285	default:
[55]	1286	dc.logger.Printf("unhandled message: %v", msg)
[13]	1287	return newUnknownCommandError(msg.Command)
	1288	}
[42]	1289	return nil
[13]	1290	}
[95]	1291
	1292	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1293	username, password, ok := parseNickServCredentials(text, uc.nick)
	1294	if !ok {
	1295	return
	1296	}
	1297
	1298	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1299	n := uc.network
	1300	n.SASL.Mechanism = "PLAIN"
	1301	n.SASL.Plain.Username = username
	1302	n.SASL.Plain.Password = password
	1303	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1304	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1305	}
	1306	}
	1307
	1308	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1309	fields := strings.Fields(text)
	1310	if len(fields) < 2 {
	1311	return "", "", false
	1312	}
	1313	cmd := strings.ToUpper(fields[0])
	1314	params := fields[1:]
	1315	switch cmd {
	1316	case "REGISTER":
	1317	username = nick
	1318	password = params[0]
	1319	case "IDENTIFY":
	1320	if len(params) == 1 {
	1321	username = nick
[182]	1322	password = params[0]
[95]	1323	} else {
	1324	username = params[0]
[182]	1325	password = params[1]
[95]	1326	}
[182]	1327	case "SET":
	1328	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1329	username = nick
	1330	password = params[1]
	1331	}
[95]	1332	}
	1333	return username, password, true
	1334	}

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

Download in other formats: