Context Navigation

source: code/trunk/downstream.go@ 150

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

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

Download in other formats: