Context Navigation

source: code/trunk/downstream.go@ 232

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

Remove downstreamConn.ringConsumers

We no longer need long-lived ring buffer consumers now that
upstreamConn.produce dispatches messages to downstream connections.

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

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

Download in other formats: