Context Navigation

source: code/trunk/downstream.go@ 236

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

Remove downstreamConn.ourMessages

We can just do the filtering when dispatching the message.

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

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

Download in other formats: