Context Navigation

source: code/trunk/downstream.go@ 129

Last change on this file since 129 was 129, checked in by delthas, 5 years ago

Fix MODE downstream support

Fix replies without client as first argument
Replace wrong prefix check with a proper entity type check

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

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

Download in other formats: