Context Navigation

source: code/trunk/downstream.go@ 190

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

Make "@" and "/" indicate client name and network, respectively

This allows both kinds "<username>@<client>/<network>" and
"<username>/<network>@<client>".

File size: 31.5 KB

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

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

Download in other formats: