Context Navigation

source: code/trunk/downstream.go@ 113

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

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

Download in other formats: