Context Navigation

source: code/trunk/downstream.go@ 185

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

Use clientName to decide whether or not history should be sent

Closes: https://todo.sr.ht/~emersion/soju/31

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
[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	rawUsername string
[168]	73	networkName string
[183]	74	clientName 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,
[184]	126	User: dc.user.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
[183]	577	func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]	578	username = rawUsername
[183]	579
	580	i := strings.IndexAny(username, "/@")
	581	j := strings.LastIndexAny(username, "/@")
	582	if i >= 0 {
	583	username = rawUsername[:i]
[73]	584	}
[183]	585	if j >= 0 {
	586	network = rawUsername[j+1:]
[73]	587	}
[183]	588	if i >= 0 && j >= 0 && i < j {
	589	client = rawUsername[i+1 : j]
	590	}
	591
	592	return username, client, network
[112]	593	}
[73]	594
[168]	595	func (dc *downstreamConn) authenticate(username, password string) error {
[183]	596	username, clientName, networkName := unmarshalUsername(username)
[168]	597
[173]	598	u, err := dc.srv.db.GetUser(username)
	599	if err != nil {
	600	dc.logger.Printf("failed authentication for %q: %v", username, err)
[168]	601	return errAuthFailed
	602	}
	603
[173]	604	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]	605	if err != nil {
	606	dc.logger.Printf("failed authentication for %q: %v", username, err)
	607	return errAuthFailed
	608	}
	609
[173]	610	dc.user = dc.srv.getUser(username)
	611	if dc.user == nil {
	612	dc.logger.Printf("failed authentication for %q: user not active", username)
	613	return errAuthFailed
	614	}
[183]	615	dc.clientName = clientName
[168]	616	dc.networkName = networkName
	617	return nil
	618	}
	619
	620	func (dc *downstreamConn) register() error {
	621	if dc.registered {
	622	return fmt.Errorf("tried to register twice")
	623	}
	624
	625	password := dc.password
	626	dc.password = ""
	627	if dc.user == nil {
	628	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	629	return err
	630	}
	631	}
	632
[183]	633	if dc.clientName == "" && dc.networkName == "" {
	634	_, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]	635	}
	636
	637	dc.registered = true
[184]	638	dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]	639	return nil
	640	}
	641
	642	func (dc *downstreamConn) loadNetwork() error {
	643	if dc.networkName == "" {
[112]	644	return nil
	645	}
[85]	646
[168]	647	network := dc.user.getNetwork(dc.networkName)
[112]	648	if network == nil {
[168]	649	addr := dc.networkName
[112]	650	if !strings.ContainsRune(addr, ':') {
	651	addr = addr + ":6697"
	652	}
	653
	654	dc.logger.Printf("trying to connect to new network %q", addr)
	655	if err := sanityCheckServer(addr); err != nil {
	656	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	657	return ircError{&irc.Message{
	658	Command: irc.ERR_PASSWDMISMATCH,
[168]	659	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]	660	}}
	661	}
	662
[168]	663	dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]	664	var err error
[120]	665	network, err = dc.user.createNetwork(&Network{
[168]	666	Addr: dc.networkName,
[120]	667	Nick: dc.nick,
	668	})
[112]	669	if err != nil {
	670	return err
	671	}
	672	}
	673
	674	dc.network = network
	675	return nil
	676	}
	677
[168]	678	func (dc *downstreamConn) welcome() error {
	679	if dc.user == nil \|\| !dc.registered {
	680	panic("tried to welcome an unregistered connection")
[37]	681	}
	682
[168]	683	// TODO: doing this might take some time. We should do it in dc.register
	684	// instead, but we'll potentially be adding a new network and this must be
	685	// done in the user goroutine.
	686	if err := dc.loadNetwork(); err != nil {
	687	return err
[85]	688	}
	689
[185]	690	// Only send history if we're the first connected client with that name and
	691	// network
	692	sendHistory := true
	693	dc.user.forEachDownstream(func(conn *downstreamConn) {
	694	if dc.clientName == conn.clientName && dc.network == conn.network {
	695	sendHistory = false
	696	}
	697	})
[40]	698
[55]	699	dc.SendMessage(&irc.Message{
	700	Prefix: dc.srv.prefix(),
[13]	701	Command: irc.RPL_WELCOME,
[98]	702	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	703	})
[55]	704	dc.SendMessage(&irc.Message{
	705	Prefix: dc.srv.prefix(),
[13]	706	Command: irc.RPL_YOURHOST,
[55]	707	Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]	708	})
[55]	709	dc.SendMessage(&irc.Message{
	710	Prefix: dc.srv.prefix(),
[13]	711	Command: irc.RPL_CREATED,
[55]	712	Params: []string{dc.nick, "Who cares when the server was created?"},
[54]	713	})
[55]	714	dc.SendMessage(&irc.Message{
	715	Prefix: dc.srv.prefix(),
[13]	716	Command: irc.RPL_MYINFO,
[98]	717	Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	718	})
[93]	719	// TODO: RPL_ISUPPORT
[55]	720	dc.SendMessage(&irc.Message{
	721	Prefix: dc.srv.prefix(),
[13]	722	Command: irc.ERR_NOMOTD,
[55]	723	Params: []string{dc.nick, "No MOTD"},
[54]	724	})
[13]	725
[73]	726	dc.forEachUpstream(func(uc *upstreamConn) {
[30]	727	for _, ch := range uc.channels {
	728	if ch.complete {
[132]	729	dc.SendMessage(&irc.Message{
	730	Prefix: dc.prefix(),
	731	Command: "JOIN",
	732	Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
	733	})
	734
[55]	735	forwardChannel(dc, ch)
[30]	736	}
	737	}
[143]	738	})
[50]	739
[143]	740	dc.forEachNetwork(func(net *network) {
[185]	741	dc.runNetwork(net, sendHistory)
[144]	742	})
[57]	743
[144]	744	return nil
	745	}
	746
	747	// runNetwork starts listening for messages coming from the network's ring
	748	// buffer.
	749	//
	750	// It panics if the network is not suitable for the downstream connection.
	751	func (dc downstreamConn) runNetwork(net network, loadHistory bool) {
	752	if dc.network != nil && net != dc.network {
	753	panic("network not suitable for downstream connection")
	754	}
	755
	756	var seqPtr *uint64
	757	if loadHistory {
	758	net.lock.Lock()
[185]	759	seq, ok := net.history[dc.clientName]
[144]	760	net.lock.Unlock()
	761	if ok {
	762	seqPtr = &seq
[50]	763	}
[144]	764	}
[57]	765
[144]	766	consumer, ch := net.ring.NewConsumer(seqPtr)
	767	go func() {
	768	for {
	769	var closed bool
	770	select {
	771	case <-ch:
	772	uc := net.upstream()
	773	if uc == nil {
	774	dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
[57]	775	break
	776	}
[144]	777	dc.ringMessages <- ringMessage{consumer, uc}
	778	case <-dc.closed:
	779	closed = true
[57]	780	}
[144]	781	if closed {
	782	break
	783	}
	784	}
[57]	785
[185]	786	// TODO: close the consumer from the user goroutine, so we don't need
	787	// that net.history lock
[144]	788	seq := consumer.Close()
[57]	789
[167]	790	net.lock.Lock()
[185]	791	net.history[dc.clientName] = seq
[167]	792	net.lock.Unlock()
[144]	793	}()
[13]	794	}
	795
[103]	796	func (dc *downstreamConn) runUntilRegistered() error {
	797	for !dc.registered {
	798	msg, err := dc.irc.ReadMessage()
[106]	799	if err != nil {
[103]	800	return fmt.Errorf("failed to read IRC command: %v", err)
	801	}
	802
[110]	803	if dc.srv.Debug {
	804	dc.logger.Printf("received: %v", msg)
	805	}
	806
[103]	807	err = dc.handleMessage(msg)
	808	if ircErr, ok := err.(ircError); ok {
	809	ircErr.Message.Prefix = dc.srv.prefix()
	810	dc.SendMessage(ircErr.Message)
	811	} else if err != nil {
	812	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	813	}
	814	}
	815
	816	return nil
	817	}
	818
[55]	819	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	820	switch msg.Command {
[111]	821	case "CAP":
	822	var subCmd string
	823	if err := parseMessageParams(msg, &subCmd); err != nil {
	824	return err
	825	}
	826	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	827	return err
	828	}
[107]	829	case "PING":
	830	dc.SendMessage(&irc.Message{
	831	Prefix: dc.srv.prefix(),
	832	Command: "PONG",
	833	Params: msg.Params,
	834	})
	835	return nil
[42]	836	case "USER":
[13]	837	return ircError{&irc.Message{
	838	Command: irc.ERR_ALREADYREGISTERED,
[55]	839	Params: []string{dc.nick, "You may not reregister"},
[13]	840	}}
[42]	841	case "NICK":
[90]	842	var nick string
	843	if err := parseMessageParams(msg, &nick); err != nil {
	844	return err
	845	}
	846
	847	var err error
	848	dc.forEachNetwork(func(n *network) {
	849	if err != nil {
	850	return
	851	}
	852	n.Nick = nick
	853	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	854	})
	855	if err != nil {
	856	return err
	857	}
	858
[73]	859	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	860	uc.SendMessage(msg)
[42]	861	})
[146]	862	case "JOIN":
	863	var namesStr string
	864	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	865	return err
	866	}
	867
[146]	868	var keys []string
	869	if len(msg.Params) > 1 {
	870	keys = strings.Split(msg.Params[1], ",")
	871	}
	872
	873	for i, name := range strings.Split(namesStr, ",") {
[145]	874	uc, upstreamName, err := dc.unmarshalEntity(name)
	875	if err != nil {
[158]	876	return err
[145]	877	}
[48]	878
[146]	879	var key string
	880	if len(keys) > i {
	881	key = keys[i]
	882	}
	883
	884	params := []string{upstreamName}
	885	if key != "" {
	886	params = append(params, key)
	887	}
[145]	888	uc.SendMessage(&irc.Message{
[146]	889	Command: "JOIN",
	890	Params: params,
[145]	891	})
[89]	892
[146]	893	err = dc.srv.db.StoreChannel(uc.network.ID, &Channel{
	894	Name: upstreamName,
	895	Key: key,
	896	})
	897	if err != nil {
	898	dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
[89]	899	}
	900	}
[146]	901	case "PART":
	902	var namesStr string
	903	if err := parseMessageParams(msg, &namesStr); err != nil {
	904	return err
	905	}
	906
	907	var reason string
	908	if len(msg.Params) > 1 {
	909	reason = msg.Params[1]
	910	}
	911
	912	for _, name := range strings.Split(namesStr, ",") {
	913	uc, upstreamName, err := dc.unmarshalEntity(name)
	914	if err != nil {
[158]	915	return err
[146]	916	}
	917
	918	params := []string{upstreamName}
	919	if reason != "" {
	920	params = append(params, reason)
	921	}
	922	uc.SendMessage(&irc.Message{
	923	Command: "PART",
	924	Params: params,
	925	})
	926
	927	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	928	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	929	}
	930	}
[159]	931	case "KICK":
	932	var channelStr, userStr string
	933	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	934	return err
	935	}
	936
	937	channels := strings.Split(channelStr, ",")
	938	users := strings.Split(userStr, ",")
	939
	940	var reason string
	941	if len(msg.Params) > 2 {
	942	reason = msg.Params[2]
	943	}
	944
	945	if len(channels) != 1 && len(channels) != len(users) {
	946	return ircError{&irc.Message{
	947	Command: irc.ERR_BADCHANMASK,
	948	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	949	}}
	950	}
	951
	952	for i, user := range users {
	953	var channel string
	954	if len(channels) == 1 {
	955	channel = channels[0]
	956	} else {
	957	channel = channels[i]
	958	}
	959
	960	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	961	if err != nil {
	962	return err
	963	}
	964
	965	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	966	if err != nil {
	967	return err
	968	}
	969
	970	if ucChannel != ucUser {
	971	return ircError{&irc.Message{
	972	Command: irc.ERR_USERNOTINCHANNEL,
	973	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	974	}}
	975	}
	976	uc := ucChannel
	977
	978	params := []string{upstreamChannel, upstreamUser}
	979	if reason != "" {
	980	params = append(params, reason)
	981	}
	982	uc.SendMessage(&irc.Message{
	983	Command: "KICK",
	984	Params: params,
	985	})
	986	}
[69]	987	case "MODE":
[46]	988	var name string
	989	if err := parseMessageParams(msg, &name); err != nil {
	990	return err
	991	}
	992
	993	var modeStr string
	994	if len(msg.Params) > 1 {
	995	modeStr = msg.Params[1]
	996	}
	997
[139]	998	if name == dc.nick {
[46]	999	if modeStr != "" {
[73]	1000	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	1001	uc.SendMessage(&irc.Message{
	1002	Command: "MODE",
	1003	Params: []string{uc.nick, modeStr},
	1004	})
[46]	1005	})
	1006	} else {
[55]	1007	dc.SendMessage(&irc.Message{
	1008	Prefix: dc.srv.prefix(),
[46]	1009	Command: irc.RPL_UMODEIS,
[129]	1010	Params: []string{dc.nick, ""}, // TODO
[54]	1011	})
[46]	1012	}
[139]	1013	return nil
[46]	1014	}
[139]	1015
	1016	uc, upstreamName, err := dc.unmarshalEntity(name)
	1017	if err != nil {
	1018	return err
	1019	}
	1020
	1021	if !uc.isChannel(upstreamName) {
	1022	return ircError{&irc.Message{
	1023	Command: irc.ERR_USERSDONTMATCH,
	1024	Params: []string{dc.nick, "Cannot change mode for other users"},
	1025	}}
	1026	}
	1027
	1028	if modeStr != "" {
	1029	params := []string{upstreamName, modeStr}
	1030	params = append(params, msg.Params[2:]...)
	1031	uc.SendMessage(&irc.Message{
	1032	Command: "MODE",
	1033	Params: params,
	1034	})
	1035	} else {
	1036	ch, ok := uc.channels[upstreamName]
	1037	if !ok {
	1038	return ircError{&irc.Message{
	1039	Command: irc.ERR_NOSUCHCHANNEL,
	1040	Params: []string{dc.nick, name, "No such channel"},
	1041	}}
	1042	}
	1043
	1044	if ch.modes == nil {
	1045	// we haven't received the initial RPL_CHANNELMODEIS yet
	1046	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	1047	return nil
	1048	}
	1049
	1050	modeStr, modeParams := ch.modes.Format()
	1051	params := []string{dc.nick, name, modeStr}
	1052	params = append(params, modeParams...)
	1053
	1054	dc.SendMessage(&irc.Message{
	1055	Prefix: dc.srv.prefix(),
	1056	Command: irc.RPL_CHANNELMODEIS,
	1057	Params: params,
	1058	})
[162]	1059	if ch.creationTime != "" {
	1060	dc.SendMessage(&irc.Message{
	1061	Prefix: dc.srv.prefix(),
	1062	Command: rpl_creationtime,
	1063	Params: []string{dc.nick, name, ch.creationTime},
	1064	})
	1065	}
[139]	1066	}
[160]	1067	case "TOPIC":
	1068	var channel string
	1069	if err := parseMessageParams(msg, &channel); err != nil {
	1070	return err
	1071	}
	1072
	1073	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1074	if err != nil {
	1075	return err
	1076	}
	1077
	1078	if len(msg.Params) > 1 { // setting topic
	1079	topic := msg.Params[1]
	1080	uc.SendMessage(&irc.Message{
	1081	Command: "TOPIC",
	1082	Params: []string{upstreamChannel, topic},
	1083	})
	1084	} else { // getting topic
	1085	ch, ok := uc.channels[upstreamChannel]
	1086	if !ok {
	1087	return ircError{&irc.Message{
	1088	Command: irc.ERR_NOSUCHCHANNEL,
	1089	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1090	}}
	1091	}
	1092	sendTopic(dc, ch)
	1093	}
[177]	1094	case "LIST":
	1095	// TODO: support ELIST when supported by all upstreams
	1096
	1097	pl := pendingLIST{
	1098	downstreamID: dc.id,
	1099	pendingCommands: make(map[int64]*irc.Message),
	1100	}
	1101	var upstreamChannels map[int64][]string
	1102	if len(msg.Params) > 0 {
	1103	upstreamChannels = make(map[int64][]string)
	1104	channels := strings.Split(msg.Params[0], ",")
	1105	for _, channel := range channels {
	1106	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1107	if err != nil {
	1108	return err
	1109	}
	1110	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1111	}
	1112	}
	1113
	1114	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1115	dc.forEachUpstream(func(uc *upstreamConn) {
	1116	var params []string
	1117	if upstreamChannels != nil {
	1118	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1119	params = []string{strings.Join(channels, ",")}
	1120	} else {
	1121	return
	1122	}
	1123	}
	1124	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1125	Command: "LIST",
	1126	Params: params,
	1127	}
[181]	1128	uc.trySendLIST(dc.id)
[177]	1129	})
[140]	1130	case "NAMES":
	1131	if len(msg.Params) == 0 {
	1132	dc.SendMessage(&irc.Message{
	1133	Prefix: dc.srv.prefix(),
	1134	Command: irc.RPL_ENDOFNAMES,
	1135	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1136	})
	1137	return nil
	1138	}
	1139
	1140	channels := strings.Split(msg.Params[0], ",")
	1141	for _, channel := range channels {
	1142	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1143	if err != nil {
	1144	return err
	1145	}
	1146
	1147	ch, ok := uc.channels[upstreamChannel]
	1148	if ok {
	1149	sendNames(dc, ch)
	1150	} else {
	1151	// NAMES on a channel we have not joined, ask upstream
[176]	1152	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1153	Command: "NAMES",
	1154	Params: []string{upstreamChannel},
	1155	})
	1156	}
	1157	}
[127]	1158	case "WHO":
	1159	if len(msg.Params) == 0 {
	1160	// TODO: support WHO without parameters
	1161	dc.SendMessage(&irc.Message{
	1162	Prefix: dc.srv.prefix(),
	1163	Command: irc.RPL_ENDOFWHO,
[140]	1164	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1165	})
	1166	return nil
	1167	}
	1168
	1169	// TODO: support WHO masks
	1170	entity := msg.Params[0]
	1171
[142]	1172	if entity == dc.nick {
	1173	// TODO: support AWAY (H/G) in self WHO reply
	1174	dc.SendMessage(&irc.Message{
	1175	Prefix: dc.srv.prefix(),
	1176	Command: irc.RPL_WHOREPLY,
[184]	1177	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1178	})
	1179	dc.SendMessage(&irc.Message{
	1180	Prefix: dc.srv.prefix(),
	1181	Command: irc.RPL_ENDOFWHO,
	1182	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1183	})
	1184	return nil
	1185	}
	1186
[127]	1187	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1188	if err != nil {
	1189	return err
	1190	}
	1191
	1192	var params []string
	1193	if len(msg.Params) == 2 {
	1194	params = []string{upstreamName, msg.Params[1]}
	1195	} else {
	1196	params = []string{upstreamName}
	1197	}
	1198
[176]	1199	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1200	Command: "WHO",
	1201	Params: params,
	1202	})
[128]	1203	case "WHOIS":
	1204	if len(msg.Params) == 0 {
	1205	return ircError{&irc.Message{
	1206	Command: irc.ERR_NONICKNAMEGIVEN,
	1207	Params: []string{dc.nick, "No nickname given"},
	1208	}}
	1209	}
	1210
	1211	var target, mask string
	1212	if len(msg.Params) == 1 {
	1213	target = ""
	1214	mask = msg.Params[0]
	1215	} else {
	1216	target = msg.Params[0]
	1217	mask = msg.Params[1]
	1218	}
	1219	// TODO: support multiple WHOIS users
	1220	if i := strings.IndexByte(mask, ','); i >= 0 {
	1221	mask = mask[:i]
	1222	}
	1223
[142]	1224	if mask == dc.nick {
	1225	dc.SendMessage(&irc.Message{
	1226	Prefix: dc.srv.prefix(),
	1227	Command: irc.RPL_WHOISUSER,
[184]	1228	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1229	})
	1230	dc.SendMessage(&irc.Message{
	1231	Prefix: dc.srv.prefix(),
	1232	Command: irc.RPL_WHOISSERVER,
	1233	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1234	})
	1235	dc.SendMessage(&irc.Message{
	1236	Prefix: dc.srv.prefix(),
	1237	Command: irc.RPL_ENDOFWHOIS,
	1238	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1239	})
	1240	return nil
	1241	}
	1242
[128]	1243	// TODO: support WHOIS masks
	1244	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1245	if err != nil {
	1246	return err
	1247	}
	1248
	1249	var params []string
	1250	if target != "" {
	1251	params = []string{target, upstreamNick}
	1252	} else {
	1253	params = []string{upstreamNick}
	1254	}
	1255
[176]	1256	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1257	Command: "WHOIS",
	1258	Params: params,
	1259	})
[58]	1260	case "PRIVMSG":
	1261	var targetsStr, text string
	1262	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1263	return err
	1264	}
	1265
	1266	for _, name := range strings.Split(targetsStr, ",") {
[117]	1267	if name == serviceNick {
	1268	handleServicePRIVMSG(dc, text)
	1269	continue
	1270	}
	1271
[127]	1272	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1273	if err != nil {
	1274	return err
	1275	}
	1276
[95]	1277	if upstreamName == "NickServ" {
	1278	dc.handleNickServPRIVMSG(uc, text)
	1279	}
	1280
[69]	1281	uc.SendMessage(&irc.Message{
[58]	1282	Command: "PRIVMSG",
[69]	1283	Params: []string{upstreamName, text},
[60]	1284	})
[105]	1285
[113]	1286	echoMsg := &irc.Message{
	1287	Prefix: &irc.Prefix{
	1288	Name: uc.nick,
	1289	User: uc.username,
	1290	},
[114]	1291	Command: "PRIVMSG",
[113]	1292	Params: []string{upstreamName, text},
	1293	}
[105]	1294	dc.lock.Lock()
[113]	1295	dc.ourMessages[echoMsg] = struct{}{}
[105]	1296	dc.lock.Unlock()
	1297
[143]	1298	uc.network.ring.Produce(echoMsg)
[58]	1299	}
[164]	1300	case "NOTICE":
	1301	var targetsStr, text string
	1302	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1303	return err
	1304	}
	1305
	1306	for _, name := range strings.Split(targetsStr, ",") {
	1307	uc, upstreamName, err := dc.unmarshalEntity(name)
	1308	if err != nil {
	1309	return err
	1310	}
	1311
	1312	uc.SendMessage(&irc.Message{
	1313	Command: "NOTICE",
	1314	Params: []string{upstreamName, text},
	1315	})
	1316	}
[163]	1317	case "INVITE":
	1318	var user, channel string
	1319	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1320	return err
	1321	}
	1322
	1323	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1324	if err != nil {
	1325	return err
	1326	}
	1327
	1328	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1329	if err != nil {
	1330	return err
	1331	}
	1332
	1333	if ucChannel != ucUser {
	1334	return ircError{&irc.Message{
	1335	Command: irc.ERR_USERNOTINCHANNEL,
	1336	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1337	}}
	1338	}
	1339	uc := ucChannel
	1340
[176]	1341	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1342	Command: "INVITE",
	1343	Params: []string{upstreamUser, upstreamChannel},
	1344	})
[13]	1345	default:
[55]	1346	dc.logger.Printf("unhandled message: %v", msg)
[13]	1347	return newUnknownCommandError(msg.Command)
	1348	}
[42]	1349	return nil
[13]	1350	}
[95]	1351
	1352	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1353	username, password, ok := parseNickServCredentials(text, uc.nick)
	1354	if !ok {
	1355	return
	1356	}
	1357
	1358	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1359	n := uc.network
	1360	n.SASL.Mechanism = "PLAIN"
	1361	n.SASL.Plain.Username = username
	1362	n.SASL.Plain.Password = password
	1363	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1364	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1365	}
	1366	}
	1367
	1368	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1369	fields := strings.Fields(text)
	1370	if len(fields) < 2 {
	1371	return "", "", false
	1372	}
	1373	cmd := strings.ToUpper(fields[0])
	1374	params := fields[1:]
	1375	switch cmd {
	1376	case "REGISTER":
	1377	username = nick
	1378	password = params[0]
	1379	case "IDENTIFY":
	1380	if len(params) == 1 {
	1381	username = nick
[182]	1382	password = params[0]
[95]	1383	} else {
	1384	username = params[0]
[182]	1385	password = params[1]
[95]	1386	}
[182]	1387	case "SET":
	1388	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1389	username = nick
	1390	password = params[1]
	1391	}
[95]	1392	}
	1393	return username, password, true
	1394	}

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

Download in other formats: