Context Navigation

source: code/trunk/downstream.go@ 213

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

Log self-messages too

Closes: https://todo.sr.ht/~emersion/soju/44

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

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

Download in other formats: