Context Navigation

source: code/trunk/downstream.go@ 181

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

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

Download in other formats: