Context Navigation

source: code/trunk/downstream.go@ 135

Last change on this file since 135 was 135, checked in by contact, 5 years ago
Fix typo
File size: 23.6 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
	74	password string // empty after authentication
	75	network *network // can be nil
[105]	76
[108]	77	negociatingCaps bool
	78	capVersion int
	79	caps map[string]bool
	80
[112]	81	saslServer sasl.Server
	82
[105]	83	lock sync.Mutex
	84	ourMessages map[*irc.Message]struct{}
[13]	85	}
	86
[22]	87	func newDownstreamConn(srv Server, netConn net.Conn) downstreamConn {
[55]	88	dc := &downstreamConn{
[69]	89	net: netConn,
	90	irc: irc.NewConn(netConn),
	91	srv: srv,
	92	logger: &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())},
[102]	93	outgoing: make(chan *irc.Message, 64),
[104]	94	ringMessages: make(chan ringMessage),
[69]	95	closed: make(chan struct{}),
[108]	96	caps: make(map[string]bool),
[105]	97	ourMessages: make(map[*irc.Message]struct{}),
[22]	98	}
[26]	99
	100	go func() {
[56]	101	if err := dc.writeMessages(); err != nil {
	102	dc.logger.Printf("failed to write message: %v", err)
[26]	103	}
[55]	104	if err := dc.net.Close(); err != nil {
	105	dc.logger.Printf("failed to close connection: %v", err)
[45]	106	} else {
[55]	107	dc.logger.Printf("connection closed")
[45]	108	}
[26]	109	}()
	110
[130]	111	dc.logger.Printf("new connection")
[55]	112	return dc
[22]	113	}
	114
[55]	115	func (dc downstreamConn) prefix() irc.Prefix {
[27]	116	return &irc.Prefix{
[55]	117	Name: dc.nick,
	118	User: dc.username,
[27]	119	// TODO: fill the host?
	120	}
	121	}
	122
[90]	123	func (dc downstreamConn) forEachNetwork(f func(network)) {
	124	if dc.network != nil {
	125	f(dc.network)
	126	} else {
	127	dc.user.forEachNetwork(f)
	128	}
	129	}
	130
[73]	131	func (dc downstreamConn) forEachUpstream(f func(upstreamConn)) {
	132	dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]	133	if dc.network != nil && uc.network != dc.network {
[73]	134	return
	135	}
	136	f(uc)
	137	})
	138	}
	139
[89]	140	// upstream returns the upstream connection, if any. If there are zero or if
	141	// there are multiple upstream connections, it returns nil.
	142	func (dc downstreamConn) upstream() upstreamConn {
	143	if dc.network == nil {
	144	return nil
	145	}
	146
	147	var upstream *upstreamConn
	148	dc.forEachUpstream(func(uc *upstreamConn) {
	149	upstream = uc
	150	})
	151	return upstream
	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 {
[40]	312	u.lock.Lock()
	313	for i := range u.downstreamConns {
[55]	314	if u.downstreamConns[i] == dc {
[40]	315	u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
[63]	316	break
[40]	317	}
	318	}
	319	u.lock.Unlock()
[13]	320	}
[40]	321
[57]	322	close(dc.closed)
[45]	323	return nil
[13]	324	}
	325
[55]	326	func (dc downstreamConn) SendMessage(msg irc.Message) {
[102]	327	dc.outgoing <- msg
[54]	328	}
	329
[55]	330	func (dc downstreamConn) handleMessage(msg irc.Message) error {
[13]	331	switch msg.Command {
[28]	332	case "QUIT":
[55]	333	return dc.Close()
[13]	334	default:
[55]	335	if dc.registered {
	336	return dc.handleMessageRegistered(msg)
[13]	337	} else {
[55]	338	return dc.handleMessageUnregistered(msg)
[13]	339	}
	340	}
	341	}
	342
[55]	343	func (dc downstreamConn) handleMessageUnregistered(msg irc.Message) error {
[13]	344	switch msg.Command {
	345	case "NICK":
[117]	346	var nick string
	347	if err := parseMessageParams(msg, &nick); err != nil {
[43]	348	return err
[13]	349	}
[117]	350	if nick == serviceNick {
	351	return ircError{&irc.Message{
	352	Command: irc.ERR_NICKNAMEINUSE,
	353	Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
	354	}}
	355	}
	356	dc.nick = nick
[13]	357	case "USER":
[117]	358	if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]	359	return err
[13]	360	}
[85]	361	case "PASS":
	362	if err := parseMessageParams(msg, &dc.password); err != nil {
	363	return err
	364	}
[108]	365	case "CAP":
	366	var subCmd string
	367	if err := parseMessageParams(msg, &subCmd); err != nil {
	368	return err
	369	}
	370	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	371	return err
	372	}
[112]	373	case "AUTHENTICATE":
	374	if !dc.caps["sasl"] {
	375	return ircError{&irc.Message{
[125]	376	Command: irc.ERR_SASLFAIL,
[112]	377	Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
	378	}}
	379	}
	380	if len(msg.Params) == 0 {
	381	return ircError{&irc.Message{
[125]	382	Command: irc.ERR_SASLFAIL,
[112]	383	Params: []string{"*", "Missing AUTHENTICATE argument"},
	384	}}
	385	}
	386	if dc.nick == "" {
	387	return ircError{&irc.Message{
[125]	388	Command: irc.ERR_SASLFAIL,
[112]	389	Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
	390	}}
	391	}
	392
	393	var resp []byte
	394	if dc.saslServer == nil {
	395	mech := strings.ToUpper(msg.Params[0])
	396	switch mech {
	397	case "PLAIN":
	398	dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
	399	return dc.authenticate(username, password)
	400	}))
	401	default:
	402	return ircError{&irc.Message{
[125]	403	Command: irc.ERR_SASLFAIL,
[112]	404	Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
	405	}}
	406	}
	407	} else if msg.Params[0] == "*" {
	408	dc.saslServer = nil
	409	return ircError{&irc.Message{
[125]	410	Command: irc.ERR_SASLABORTED,
[112]	411	Params: []string{"*", "SASL authentication aborted"},
	412	}}
	413	} else if msg.Params[0] == "+" {
	414	resp = nil
	415	} else {
	416	// TODO: multi-line messages
	417	var err error
	418	resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
	419	if err != nil {
	420	dc.saslServer = nil
	421	return ircError{&irc.Message{
[125]	422	Command: irc.ERR_SASLFAIL,
[112]	423	Params: []string{"*", "Invalid base64-encoded response"},
	424	}}
	425	}
	426	}
	427
	428	challenge, done, err := dc.saslServer.Next(resp)
	429	if err != nil {
	430	dc.saslServer = nil
	431	if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
	432	return ircError{&irc.Message{
[125]	433	Command: irc.ERR_SASLFAIL,
[112]	434	Params: []string{"*", ircErr.Message.Params[1]},
	435	}}
	436	}
	437	dc.SendMessage(&irc.Message{
	438	Prefix: dc.srv.prefix(),
[125]	439	Command: irc.ERR_SASLFAIL,
[112]	440	Params: []string{"*", "SASL error"},
	441	})
	442	return fmt.Errorf("SASL authentication failed: %v", err)
	443	} else if done {
	444	dc.saslServer = nil
	445	dc.SendMessage(&irc.Message{
	446	Prefix: dc.srv.prefix(),
[125]	447	Command: irc.RPL_LOGGEDIN,
[112]	448	Params: []string{dc.nick, dc.nick, dc.user.Username, "You are now logged in"},
	449	})
	450	dc.SendMessage(&irc.Message{
	451	Prefix: dc.srv.prefix(),
[125]	452	Command: irc.RPL_SASLSUCCESS,
[112]	453	Params: []string{dc.nick, "SASL authentication successful"},
	454	})
	455	} else {
	456	challengeStr := "+"
[135]	457	if len(challenge) > 0 {
[112]	458	challengeStr = base64.StdEncoding.EncodeToString(challenge)
	459	}
	460
	461	// TODO: multi-line messages
	462	dc.SendMessage(&irc.Message{
	463	Prefix: dc.srv.prefix(),
	464	Command: "AUTHENTICATE",
	465	Params: []string{challengeStr},
	466	})
	467	}
[13]	468	default:
[55]	469	dc.logger.Printf("unhandled message: %v", msg)
[13]	470	return newUnknownCommandError(msg.Command)
	471	}
[108]	472	if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
[55]	473	return dc.register()
[13]	474	}
	475	return nil
	476	}
	477
[108]	478	func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]	479	cmd = strings.ToUpper(cmd)
	480
[108]	481	replyTo := dc.nick
	482	if !dc.registered {
	483	replyTo = "*"
	484	}
	485
	486	switch cmd {
	487	case "LS":
	488	if len(args) > 0 {
	489	var err error
	490	if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
	491	return err
	492	}
	493	}
	494
	495	var caps []string
[112]	496	if dc.capVersion >= 302 {
[108]	497	caps = append(caps, "sasl=PLAIN")
	498	} else {
	499	caps = append(caps, "sasl")
[112]	500	}
[108]	501
	502	// TODO: multi-line replies
	503	dc.SendMessage(&irc.Message{
	504	Prefix: dc.srv.prefix(),
	505	Command: "CAP",
	506	Params: []string{replyTo, "LS", strings.Join(caps, " ")},
	507	})
	508
	509	if !dc.registered {
	510	dc.negociatingCaps = true
	511	}
	512	case "LIST":
	513	var caps []string
	514	for name := range dc.caps {
	515	caps = append(caps, name)
	516	}
	517
	518	// TODO: multi-line replies
	519	dc.SendMessage(&irc.Message{
	520	Prefix: dc.srv.prefix(),
	521	Command: "CAP",
	522	Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
	523	})
	524	case "REQ":
	525	if len(args) == 0 {
	526	return ircError{&irc.Message{
	527	Command: err_invalidcapcmd,
	528	Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
	529	}}
	530	}
	531
	532	caps := strings.Fields(args[0])
	533	ack := true
	534	for _, name := range caps {
	535	name = strings.ToLower(name)
	536	enable := !strings.HasPrefix(name, "-")
	537	if !enable {
	538	name = strings.TrimPrefix(name, "-")
	539	}
	540
	541	enabled := dc.caps[name]
	542	if enable == enabled {
	543	continue
	544	}
	545
	546	switch name {
[112]	547	case "sasl":
	548	dc.caps[name] = enable
[108]	549	default:
	550	ack = false
	551	}
	552	}
	553
	554	reply := "NAK"
	555	if ack {
	556	reply = "ACK"
	557	}
	558	dc.SendMessage(&irc.Message{
	559	Prefix: dc.srv.prefix(),
	560	Command: "CAP",
	561	Params: []string{replyTo, reply, args[0]},
	562	})
	563	case "END":
	564	dc.negociatingCaps = false
	565	default:
	566	return ircError{&irc.Message{
	567	Command: err_invalidcapcmd,
	568	Params: []string{replyTo, cmd, "Unknown CAP command"},
	569	}}
	570	}
	571	return nil
	572	}
	573
[91]	574	func sanityCheckServer(addr string) error {
	575	dialer := net.Dialer{Timeout: 30 * time.Second}
	576	conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
	577	if err != nil {
	578	return err
	579	}
	580	return conn.Close()
	581	}
	582
[112]	583	func unmarshalUsername(rawUsername string) (username, network string) {
	584	username = rawUsername
[73]	585	if i := strings.LastIndexAny(username, "/@"); i >= 0 {
[112]	586	network = username[i+1:]
[73]	587	}
	588	if i := strings.IndexAny(username, "/@"); i >= 0 {
	589	username = username[:i]
	590	}
[112]	591	return username, network
	592	}
[73]	593
[112]	594	func (dc *downstreamConn) setNetwork(networkName string) error {
	595	if networkName == "" {
	596	return nil
	597	}
[85]	598
[112]	599	network := dc.user.getNetwork(networkName)
	600	if network == nil {
	601	addr := networkName
	602	if !strings.ContainsRune(addr, ':') {
	603	addr = addr + ":6697"
	604	}
	605
	606	dc.logger.Printf("trying to connect to new network %q", addr)
	607	if err := sanityCheckServer(addr); err != nil {
	608	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	609	return ircError{&irc.Message{
	610	Command: irc.ERR_PASSWDMISMATCH,
	611	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", networkName)},
	612	}}
	613	}
	614
	615	dc.logger.Printf("auto-saving network %q", networkName)
	616	var err error
[120]	617	network, err = dc.user.createNetwork(&Network{
	618	Addr: networkName,
	619	Nick: dc.nick,
	620	})
[112]	621	if err != nil {
	622	return err
	623	}
	624	}
	625
	626	dc.network = network
	627	return nil
	628	}
	629
	630	func (dc *downstreamConn) authenticate(username, password string) error {
	631	username, networkName := unmarshalUsername(username)
	632
[73]	633	u := dc.srv.getUser(username)
[38]	634	if u == nil {
[85]	635	dc.logger.Printf("failed authentication for %q: unknown username", username)
	636	return errAuthFailed
[37]	637	}
	638
[85]	639	err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
	640	if err != nil {
	641	dc.logger.Printf("failed authentication for %q: %v", username, err)
	642	return errAuthFailed
	643	}
	644
[112]	645	dc.user = u
[91]	646
[112]	647	return dc.setNetwork(networkName)
	648	}
[91]	649
[112]	650	func (dc *downstreamConn) register() error {
	651	password := dc.password
	652	dc.password = ""
	653	if dc.user == nil {
	654	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	655	return err
[73]	656	}
[112]	657	} else if dc.network == nil {
	658	_, networkName := unmarshalUsername(dc.rawUsername)
	659	if err := dc.setNetwork(networkName); err != nil {
	660	return err
	661	}
[73]	662	}
	663
[55]	664	dc.registered = true
[112]	665	dc.username = dc.user.Username
[130]	666	dc.logger.Printf("registration complete for user %q", dc.username)
[13]	667
[112]	668	dc.user.lock.Lock()
	669	firstDownstream := len(dc.user.downstreamConns) == 0
	670	dc.user.downstreamConns = append(dc.user.downstreamConns, dc)
	671	dc.user.lock.Unlock()
[40]	672
[55]	673	dc.SendMessage(&irc.Message{
	674	Prefix: dc.srv.prefix(),
[13]	675	Command: irc.RPL_WELCOME,
[98]	676	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	677	})
[55]	678	dc.SendMessage(&irc.Message{
	679	Prefix: dc.srv.prefix(),
[13]	680	Command: irc.RPL_YOURHOST,
[55]	681	Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]	682	})
[55]	683	dc.SendMessage(&irc.Message{
	684	Prefix: dc.srv.prefix(),
[13]	685	Command: irc.RPL_CREATED,
[55]	686	Params: []string{dc.nick, "Who cares when the server was created?"},
[54]	687	})
[55]	688	dc.SendMessage(&irc.Message{
	689	Prefix: dc.srv.prefix(),
[13]	690	Command: irc.RPL_MYINFO,
[98]	691	Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	692	})
[93]	693	// TODO: RPL_ISUPPORT
[55]	694	dc.SendMessage(&irc.Message{
	695	Prefix: dc.srv.prefix(),
[13]	696	Command: irc.ERR_NOMOTD,
[55]	697	Params: []string{dc.nick, "No MOTD"},
[54]	698	})
[13]	699
[73]	700	dc.forEachUpstream(func(uc *upstreamConn) {
[30]	701	for _, ch := range uc.channels {
	702	if ch.complete {
[132]	703	dc.SendMessage(&irc.Message{
	704	Prefix: dc.prefix(),
	705	Command: "JOIN",
	706	Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
	707	})
	708
[55]	709	forwardChannel(dc, ch)
[30]	710	}
	711	}
[50]	712
[124]	713	historyName := dc.rawUsername
[57]	714
	715	var seqPtr *uint64
	716	if firstDownstream {
[131]	717	uc.network.lock.Lock()
	718	seq, ok := uc.network.history[historyName]
	719	uc.network.lock.Unlock()
[57]	720	if ok {
	721	seqPtr = &seq
[50]	722	}
	723	}
[57]	724
[59]	725	consumer, ch := uc.ring.NewConsumer(seqPtr)
[57]	726	go func() {
	727	for {
	728	var closed bool
	729	select {
	730	case <-ch:
[104]	731	dc.ringMessages <- ringMessage{consumer, uc}
[57]	732	case <-dc.closed:
	733	closed = true
	734	}
	735	if closed {
	736	break
	737	}
	738	}
	739
	740	seq := consumer.Close()
	741
	742	dc.user.lock.Lock()
	743	lastDownstream := len(dc.user.downstreamConns) == 0
	744	dc.user.lock.Unlock()
	745
	746	if lastDownstream {
[131]	747	uc.network.lock.Lock()
	748	uc.network.history[historyName] = seq
	749	uc.network.lock.Unlock()
[57]	750	}
	751	}()
[39]	752	})
[50]	753
[13]	754	return nil
	755	}
	756
[103]	757	func (dc *downstreamConn) runUntilRegistered() error {
	758	for !dc.registered {
	759	msg, err := dc.irc.ReadMessage()
[106]	760	if err != nil {
[103]	761	return fmt.Errorf("failed to read IRC command: %v", err)
	762	}
	763
[110]	764	if dc.srv.Debug {
	765	dc.logger.Printf("received: %v", msg)
	766	}
	767
[103]	768	err = dc.handleMessage(msg)
	769	if ircErr, ok := err.(ircError); ok {
	770	ircErr.Message.Prefix = dc.srv.prefix()
	771	dc.SendMessage(ircErr.Message)
	772	} else if err != nil {
	773	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	774	}
	775	}
	776
	777	return nil
	778	}
	779
[55]	780	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	781	switch msg.Command {
[111]	782	case "CAP":
	783	var subCmd string
	784	if err := parseMessageParams(msg, &subCmd); err != nil {
	785	return err
	786	}
	787	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	788	return err
	789	}
[107]	790	case "PING":
	791	dc.SendMessage(&irc.Message{
	792	Prefix: dc.srv.prefix(),
	793	Command: "PONG",
	794	Params: msg.Params,
	795	})
	796	return nil
[42]	797	case "USER":
[13]	798	return ircError{&irc.Message{
	799	Command: irc.ERR_ALREADYREGISTERED,
[55]	800	Params: []string{dc.nick, "You may not reregister"},
[13]	801	}}
[42]	802	case "NICK":
[90]	803	var nick string
	804	if err := parseMessageParams(msg, &nick); err != nil {
	805	return err
	806	}
	807
	808	var err error
	809	dc.forEachNetwork(func(n *network) {
	810	if err != nil {
	811	return
	812	}
	813	n.Nick = nick
	814	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	815	})
	816	if err != nil {
	817	return err
	818	}
	819
[73]	820	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	821	uc.SendMessage(msg)
[42]	822	})
[69]	823	case "JOIN", "PART":
[48]	824	var name string
	825	if err := parseMessageParams(msg, &name); err != nil {
	826	return err
	827	}
	828
[127]	829	uc, upstreamName, err := dc.unmarshalEntity(name)
[69]	830	if err != nil {
	831	return ircError{&irc.Message{
	832	Command: irc.ERR_NOSUCHCHANNEL,
	833	Params: []string{name, err.Error()},
	834	}}
[48]	835	}
	836
[69]	837	uc.SendMessage(&irc.Message{
	838	Command: msg.Command,
	839	Params: []string{upstreamName},
	840	})
[89]	841
	842	switch msg.Command {
	843	case "JOIN":
	844	err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
	845	Name: upstreamName,
	846	})
	847	if err != nil {
	848	dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
	849	}
	850	case "PART":
	851	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	852	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	853	}
	854	}
[69]	855	case "MODE":
[46]	856	var name string
	857	if err := parseMessageParams(msg, &name); err != nil {
	858	return err
	859	}
	860
	861	var modeStr string
	862	if len(msg.Params) > 1 {
	863	modeStr = msg.Params[1]
	864	}
	865
[129]	866	uc, upstreamName, err := dc.unmarshalEntity(name)
	867	if err != nil {
	868	return err
	869	}
[46]	870
[129]	871	if uc.isChannel(upstreamName) {
	872	// TODO: handle MODE channel mode arguments
[46]	873	if modeStr != "" {
[69]	874	uc.SendMessage(&irc.Message{
	875	Command: "MODE",
	876	Params: []string{upstreamName, modeStr},
	877	})
[46]	878	} else {
[69]	879	ch, ok := uc.channels[upstreamName]
	880	if !ok {
	881	return ircError{&irc.Message{
	882	Command: irc.ERR_NOSUCHCHANNEL,
[129]	883	Params: []string{dc.nick, name, "No such channel"},
[69]	884	}}
	885	}
	886
[55]	887	dc.SendMessage(&irc.Message{
	888	Prefix: dc.srv.prefix(),
[46]	889	Command: irc.RPL_CHANNELMODEIS,
[129]	890	Params: []string{dc.nick, name, string(ch.modes)},
[54]	891	})
[46]	892	}
	893	} else {
[55]	894	if name != dc.nick {
[46]	895	return ircError{&irc.Message{
	896	Command: irc.ERR_USERSDONTMATCH,
[55]	897	Params: []string{dc.nick, "Cannot change mode for other users"},
[46]	898	}}
	899	}
	900
	901	if modeStr != "" {
[73]	902	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	903	uc.SendMessage(&irc.Message{
	904	Command: "MODE",
	905	Params: []string{uc.nick, modeStr},
	906	})
[46]	907	})
	908	} else {
[55]	909	dc.SendMessage(&irc.Message{
	910	Prefix: dc.srv.prefix(),
[46]	911	Command: irc.RPL_UMODEIS,
[129]	912	Params: []string{dc.nick, ""}, // TODO
[54]	913	})
[46]	914	}
	915	}
[127]	916	case "WHO":
	917	if len(msg.Params) == 0 {
	918	// TODO: support WHO without parameters
	919	dc.SendMessage(&irc.Message{
	920	Prefix: dc.srv.prefix(),
	921	Command: irc.RPL_ENDOFWHO,
	922	Params: []string{dc.nick, "*", "End of /WHO list."},
	923	})
	924	return nil
	925	}
	926
	927	// TODO: support WHO masks
	928	entity := msg.Params[0]
	929
	930	uc, upstreamName, err := dc.unmarshalEntity(entity)
	931	if err != nil {
	932	return err
	933	}
	934
	935	var params []string
	936	if len(msg.Params) == 2 {
	937	params = []string{upstreamName, msg.Params[1]}
	938	} else {
	939	params = []string{upstreamName}
	940	}
	941
	942	uc.SendMessage(&irc.Message{
	943	Command: "WHO",
	944	Params: params,
	945	})
[128]	946	case "WHOIS":
	947	if len(msg.Params) == 0 {
	948	return ircError{&irc.Message{
	949	Command: irc.ERR_NONICKNAMEGIVEN,
	950	Params: []string{dc.nick, "No nickname given"},
	951	}}
	952	}
	953
	954	var target, mask string
	955	if len(msg.Params) == 1 {
	956	target = ""
	957	mask = msg.Params[0]
	958	} else {
	959	target = msg.Params[0]
	960	mask = msg.Params[1]
	961	}
	962	// TODO: support multiple WHOIS users
	963	if i := strings.IndexByte(mask, ','); i >= 0 {
	964	mask = mask[:i]
	965	}
	966
	967	// TODO: support WHOIS masks
	968	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	969	if err != nil {
	970	return err
	971	}
	972
	973	var params []string
	974	if target != "" {
	975	params = []string{target, upstreamNick}
	976	} else {
	977	params = []string{upstreamNick}
	978	}
	979
	980	uc.SendMessage(&irc.Message{
	981	Command: "WHOIS",
	982	Params: params,
	983	})
[58]	984	case "PRIVMSG":
	985	var targetsStr, text string
	986	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	987	return err
	988	}
	989
	990	for _, name := range strings.Split(targetsStr, ",") {
[117]	991	if name == serviceNick {
	992	handleServicePRIVMSG(dc, text)
	993	continue
	994	}
	995
[127]	996	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	997	if err != nil {
	998	return err
	999	}
	1000
[95]	1001	if upstreamName == "NickServ" {
	1002	dc.handleNickServPRIVMSG(uc, text)
	1003	}
	1004
[69]	1005	uc.SendMessage(&irc.Message{
[58]	1006	Command: "PRIVMSG",
[69]	1007	Params: []string{upstreamName, text},
[60]	1008	})
[105]	1009
[113]	1010	echoMsg := &irc.Message{
	1011	Prefix: &irc.Prefix{
	1012	Name: uc.nick,
	1013	User: uc.username,
	1014	},
[114]	1015	Command: "PRIVMSG",
[113]	1016	Params: []string{upstreamName, text},
	1017	}
[105]	1018	dc.lock.Lock()
[113]	1019	dc.ourMessages[echoMsg] = struct{}{}
[105]	1020	dc.lock.Unlock()
	1021
[113]	1022	uc.ring.Produce(echoMsg)
[58]	1023	}
[13]	1024	default:
[55]	1025	dc.logger.Printf("unhandled message: %v", msg)
[13]	1026	return newUnknownCommandError(msg.Command)
	1027	}
[42]	1028	return nil
[13]	1029	}
[95]	1030
	1031	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1032	username, password, ok := parseNickServCredentials(text, uc.nick)
	1033	if !ok {
	1034	return
	1035	}
	1036
	1037	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1038	n := uc.network
	1039	n.SASL.Mechanism = "PLAIN"
	1040	n.SASL.Plain.Username = username
	1041	n.SASL.Plain.Password = password
	1042	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1043	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1044	}
	1045	}
	1046
	1047	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1048	fields := strings.Fields(text)
	1049	if len(fields) < 2 {
	1050	return "", "", false
	1051	}
	1052	cmd := strings.ToUpper(fields[0])
	1053	params := fields[1:]
	1054	switch cmd {
	1055	case "REGISTER":
	1056	username = nick
	1057	password = params[0]
	1058	case "IDENTIFY":
	1059	if len(params) == 1 {
	1060	username = nick
	1061	} else {
	1062	username = params[0]
	1063	}
	1064	password = params[1]
	1065	}
	1066	return username, password, true
	1067	}

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

Download in other formats: