Context Navigation

source: code/trunk/downstream.go@ 119

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

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

Download in other formats: