Context Navigation

source: code/trunk/downstream.go@ 259

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

Kill downstreamConn.marshal{Nick,Channel}

We can just use downstreamConn.marshalEntity instead.

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

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

Download in other formats: