Context Navigation

source: code/trunk/downstream.go@ 144

Last change on this file since 144 was 144, checked in by contact, 5 years ago
Consume ring buffer for networks added on-the-fly
File size: 26.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 {
[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	})
[69]	835	case "JOIN", "PART":
[48]	836	var name string
	837	if err := parseMessageParams(msg, &name); err != nil {
	838	return err
	839	}
	840
[127]	841	uc, upstreamName, err := dc.unmarshalEntity(name)
[69]	842	if err != nil {
	843	return ircError{&irc.Message{
	844	Command: irc.ERR_NOSUCHCHANNEL,
	845	Params: []string{name, err.Error()},
	846	}}
[48]	847	}
	848
[69]	849	uc.SendMessage(&irc.Message{
	850	Command: msg.Command,
	851	Params: []string{upstreamName},
	852	})
[89]	853
	854	switch msg.Command {
	855	case "JOIN":
	856	err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
	857	Name: upstreamName,
	858	})
	859	if err != nil {
	860	dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
	861	}
	862	case "PART":
	863	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	864	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	865	}
	866	}
[69]	867	case "MODE":
[46]	868	var name string
	869	if err := parseMessageParams(msg, &name); err != nil {
	870	return err
	871	}
	872
	873	var modeStr string
	874	if len(msg.Params) > 1 {
	875	modeStr = msg.Params[1]
	876	}
	877
[139]	878	if name == dc.nick {
[46]	879	if modeStr != "" {
[73]	880	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	881	uc.SendMessage(&irc.Message{
	882	Command: "MODE",
	883	Params: []string{uc.nick, modeStr},
	884	})
[46]	885	})
	886	} else {
[55]	887	dc.SendMessage(&irc.Message{
	888	Prefix: dc.srv.prefix(),
[46]	889	Command: irc.RPL_UMODEIS,
[129]	890	Params: []string{dc.nick, ""}, // TODO
[54]	891	})
[46]	892	}
[139]	893	return nil
[46]	894	}
[139]	895
	896	uc, upstreamName, err := dc.unmarshalEntity(name)
	897	if err != nil {
	898	return err
	899	}
	900
	901	if !uc.isChannel(upstreamName) {
	902	return ircError{&irc.Message{
	903	Command: irc.ERR_USERSDONTMATCH,
	904	Params: []string{dc.nick, "Cannot change mode for other users"},
	905	}}
	906	}
	907
	908	if modeStr != "" {
	909	params := []string{upstreamName, modeStr}
	910	params = append(params, msg.Params[2:]...)
	911	uc.SendMessage(&irc.Message{
	912	Command: "MODE",
	913	Params: params,
	914	})
	915	} else {
	916	ch, ok := uc.channels[upstreamName]
	917	if !ok {
	918	return ircError{&irc.Message{
	919	Command: irc.ERR_NOSUCHCHANNEL,
	920	Params: []string{dc.nick, name, "No such channel"},
	921	}}
	922	}
	923
	924	if ch.modes == nil {
	925	// we haven't received the initial RPL_CHANNELMODEIS yet
	926	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	927	return nil
	928	}
	929
	930	modeStr, modeParams := ch.modes.Format()
	931	params := []string{dc.nick, name, modeStr}
	932	params = append(params, modeParams...)
	933
	934	dc.SendMessage(&irc.Message{
	935	Prefix: dc.srv.prefix(),
	936	Command: irc.RPL_CHANNELMODEIS,
	937	Params: params,
	938	})
	939	}
[140]	940	case "NAMES":
	941	if len(msg.Params) == 0 {
	942	dc.SendMessage(&irc.Message{
	943	Prefix: dc.srv.prefix(),
	944	Command: irc.RPL_ENDOFNAMES,
	945	Params: []string{dc.nick, "*", "End of /NAMES list"},
	946	})
	947	return nil
	948	}
	949
	950	channels := strings.Split(msg.Params[0], ",")
	951	for _, channel := range channels {
	952	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	953	if err != nil {
	954	return err
	955	}
	956
	957	ch, ok := uc.channels[upstreamChannel]
	958	if ok {
	959	sendNames(dc, ch)
	960	} else {
	961	// NAMES on a channel we have not joined, ask upstream
	962	uc.SendMessage(&irc.Message{
	963	Command: "NAMES",
	964	Params: []string{upstreamChannel},
	965	})
	966	}
	967	}
[127]	968	case "WHO":
	969	if len(msg.Params) == 0 {
	970	// TODO: support WHO without parameters
	971	dc.SendMessage(&irc.Message{
	972	Prefix: dc.srv.prefix(),
	973	Command: irc.RPL_ENDOFWHO,
[140]	974	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	975	})
	976	return nil
	977	}
	978
	979	// TODO: support WHO masks
	980	entity := msg.Params[0]
	981
[142]	982	if entity == dc.nick {
	983	// TODO: support AWAY (H/G) in self WHO reply
	984	dc.SendMessage(&irc.Message{
	985	Prefix: dc.srv.prefix(),
	986	Command: irc.RPL_WHOREPLY,
	987	Params: []string{dc.nick, "*", dc.username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
	988	})
	989	dc.SendMessage(&irc.Message{
	990	Prefix: dc.srv.prefix(),
	991	Command: irc.RPL_ENDOFWHO,
	992	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	993	})
	994	return nil
	995	}
	996
[127]	997	uc, upstreamName, err := dc.unmarshalEntity(entity)
	998	if err != nil {
	999	return err
	1000	}
	1001
	1002	var params []string
	1003	if len(msg.Params) == 2 {
	1004	params = []string{upstreamName, msg.Params[1]}
	1005	} else {
	1006	params = []string{upstreamName}
	1007	}
	1008
	1009	uc.SendMessage(&irc.Message{
	1010	Command: "WHO",
	1011	Params: params,
	1012	})
[128]	1013	case "WHOIS":
	1014	if len(msg.Params) == 0 {
	1015	return ircError{&irc.Message{
	1016	Command: irc.ERR_NONICKNAMEGIVEN,
	1017	Params: []string{dc.nick, "No nickname given"},
	1018	}}
	1019	}
	1020
	1021	var target, mask string
	1022	if len(msg.Params) == 1 {
	1023	target = ""
	1024	mask = msg.Params[0]
	1025	} else {
	1026	target = msg.Params[0]
	1027	mask = msg.Params[1]
	1028	}
	1029	// TODO: support multiple WHOIS users
	1030	if i := strings.IndexByte(mask, ','); i >= 0 {
	1031	mask = mask[:i]
	1032	}
	1033
[142]	1034	if mask == dc.nick {
	1035	dc.SendMessage(&irc.Message{
	1036	Prefix: dc.srv.prefix(),
	1037	Command: irc.RPL_WHOISUSER,
	1038	Params: []string{dc.nick, dc.nick, dc.username, dc.hostname, "*", dc.realname},
	1039	})
	1040	dc.SendMessage(&irc.Message{
	1041	Prefix: dc.srv.prefix(),
	1042	Command: irc.RPL_WHOISSERVER,
	1043	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1044	})
	1045	dc.SendMessage(&irc.Message{
	1046	Prefix: dc.srv.prefix(),
	1047	Command: irc.RPL_ENDOFWHOIS,
	1048	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1049	})
	1050	return nil
	1051	}
	1052
[128]	1053	// TODO: support WHOIS masks
	1054	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1055	if err != nil {
	1056	return err
	1057	}
	1058
	1059	var params []string
	1060	if target != "" {
	1061	params = []string{target, upstreamNick}
	1062	} else {
	1063	params = []string{upstreamNick}
	1064	}
	1065
	1066	uc.SendMessage(&irc.Message{
	1067	Command: "WHOIS",
	1068	Params: params,
	1069	})
[58]	1070	case "PRIVMSG":
	1071	var targetsStr, text string
	1072	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1073	return err
	1074	}
	1075
	1076	for _, name := range strings.Split(targetsStr, ",") {
[117]	1077	if name == serviceNick {
	1078	handleServicePRIVMSG(dc, text)
	1079	continue
	1080	}
	1081
[127]	1082	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1083	if err != nil {
	1084	return err
	1085	}
	1086
[95]	1087	if upstreamName == "NickServ" {
	1088	dc.handleNickServPRIVMSG(uc, text)
	1089	}
	1090
[69]	1091	uc.SendMessage(&irc.Message{
[58]	1092	Command: "PRIVMSG",
[69]	1093	Params: []string{upstreamName, text},
[60]	1094	})
[105]	1095
[113]	1096	echoMsg := &irc.Message{
	1097	Prefix: &irc.Prefix{
	1098	Name: uc.nick,
	1099	User: uc.username,
	1100	},
[114]	1101	Command: "PRIVMSG",
[113]	1102	Params: []string{upstreamName, text},
	1103	}
[105]	1104	dc.lock.Lock()
[113]	1105	dc.ourMessages[echoMsg] = struct{}{}
[105]	1106	dc.lock.Unlock()
	1107
[143]	1108	uc.network.ring.Produce(echoMsg)
[58]	1109	}
[13]	1110	default:
[55]	1111	dc.logger.Printf("unhandled message: %v", msg)
[13]	1112	return newUnknownCommandError(msg.Command)
	1113	}
[42]	1114	return nil
[13]	1115	}
[95]	1116
	1117	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1118	username, password, ok := parseNickServCredentials(text, uc.nick)
	1119	if !ok {
	1120	return
	1121	}
	1122
	1123	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1124	n := uc.network
	1125	n.SASL.Mechanism = "PLAIN"
	1126	n.SASL.Plain.Username = username
	1127	n.SASL.Plain.Password = password
	1128	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1129	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1130	}
	1131	}
	1132
	1133	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1134	fields := strings.Fields(text)
	1135	if len(fields) < 2 {
	1136	return "", "", false
	1137	}
	1138	cmd := strings.ToUpper(fields[0])
	1139	params := fields[1:]
	1140	switch cmd {
	1141	case "REGISTER":
	1142	username = nick
	1143	password = params[0]
	1144	case "IDENTIFY":
	1145	if len(params) == 1 {
	1146	username = nick
	1147	} else {
	1148	username = params[0]
	1149	}
	1150	password = params[1]
	1151	}
	1152	return username, password, true
	1153	}

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

Download in other formats: