Context Navigation

source: code/trunk/downstream.go@ 256

Last change on this file since 256 was 256, checked in by contact, 5 years ago
Add support for downstream batch & chathistory
File size: 31.6 KB

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

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

Download in other formats: