Context Navigation

downstream.go@ 168

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

Nuke user.lock

Split user.register into two functions, one to make sure the user is
authenticated, the other to send our current state. This allows to get
rid of data races by doing the second part in the user goroutine.

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

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

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

Context Navigation

source: code/trunk/downstream.go@ 168

Download in other formats: