Context Navigation

source: code/trunk/downstream.go@ 245

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

Centralize logged messages marshaling

This allows messages added to logs to be handled just like messages
added to the ring buffer.

File size: 30.5 KB

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

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

Download in other formats: