Context Navigation

source: code/trunk/downstream.go@ 193

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

Expose message-tags capability downstream

Strip tags if the client doesn't support them.

File size: 31.7 KB

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

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

Download in other formats: