Context Navigation

source: code/trunk/downstream.go@ 219

Last change on this file since 219 was 217, checked in by contact, 5 years ago

Add NOTICE messages to ring buffer

References: https://todo.sr.ht/~emersion/soju/33

File size: 30.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
	54	type downstreamConn struct {
[210]	55	conn
[22]	56
[210]	57	id uint64
	58
[100]	59	registered bool
	60	user *user
	61	nick string
	62	rawUsername string
[168]	63	networkName string
[183]	64	clientName string
[100]	65	realname string
[141]	66	hostname string
[100]	67	password string // empty after authentication
	68	network *network // can be nil
[105]	69
[204]	70	ringConsumers map[network]RingConsumer
	71
[108]	72	negociatingCaps bool
	73	capVersion int
	74
[112]	75	saslServer sasl.Server
	76
[105]	77	lock sync.Mutex
	78	ourMessages map[*irc.Message]struct{}
[216]	79	caps map[string]bool
[13]	80	}
	81
[154]	82	func newDownstreamConn(srv Server, netConn net.Conn, id uint64) downstreamConn {
[210]	83	logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())}
[55]	84	dc := &downstreamConn{
[210]	85	conn: *newConn(srv, netConn, logger),
[204]	86	id: id,
	87	ringConsumers: make(map[network]RingConsumer),
[216]	88	ourMessages: make(map[*irc.Message]struct{}),
[204]	89	caps: make(map[string]bool),
[22]	90	}
[141]	91	dc.hostname = netConn.RemoteAddr().String()
	92	if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
	93	dc.hostname = host
	94	}
[55]	95	return dc
[22]	96	}
	97
[55]	98	func (dc downstreamConn) prefix() irc.Prefix {
[27]	99	return &irc.Prefix{
[55]	100	Name: dc.nick,
[184]	101	User: dc.user.Username,
[141]	102	Host: dc.hostname,
[27]	103	}
	104	}
	105
[90]	106	func (dc downstreamConn) forEachNetwork(f func(network)) {
	107	if dc.network != nil {
	108	f(dc.network)
	109	} else {
	110	dc.user.forEachNetwork(f)
	111	}
	112	}
	113
[73]	114	func (dc downstreamConn) forEachUpstream(f func(upstreamConn)) {
	115	dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]	116	if dc.network != nil && uc.network != dc.network {
[73]	117	return
	118	}
	119	f(uc)
	120	})
	121	}
	122
[89]	123	// upstream returns the upstream connection, if any. If there are zero or if
	124	// there are multiple upstream connections, it returns nil.
	125	func (dc downstreamConn) upstream() upstreamConn {
	126	if dc.network == nil {
	127	return nil
	128	}
[136]	129	return dc.network.upstream()
[89]	130	}
	131
[129]	132	func (dc downstreamConn) marshalEntity(uc upstreamConn, entity string) string {
	133	if uc.isChannel(entity) {
	134	return dc.marshalChannel(uc, entity)
[119]	135	}
[129]	136	return dc.marshalNick(uc, entity)
[119]	137	}
	138
	139	func (dc downstreamConn) marshalChannel(uc upstreamConn, name string) string {
[130]	140	if dc.network != nil {
[119]	141	return name
	142	}
	143	return name + "/" + uc.network.GetName()
	144	}
	145
[127]	146	func (dc downstreamConn) unmarshalEntity(name string) (upstreamConn, string, error) {
[89]	147	if uc := dc.upstream(); uc != nil {
	148	return uc, name, nil
	149	}
	150
[127]	151	var conn *upstreamConn
[119]	152	if i := strings.LastIndexByte(name, '/'); i >= 0 {
[127]	153	network := name[i+1:]
[119]	154	name = name[:i]
	155
	156	dc.forEachUpstream(func(uc *upstreamConn) {
	157	if network != uc.network.GetName() {
	158	return
	159	}
	160	conn = uc
	161	})
	162	}
	163
[127]	164	if conn == nil {
[73]	165	return nil, "", ircError{&irc.Message{
	166	Command: irc.ERR_NOSUCHCHANNEL,
	167	Params: []string{name, "No such channel"},
	168	}}
[69]	169	}
[127]	170	return conn, name, nil
[69]	171	}
	172
	173	func (dc downstreamConn) marshalNick(uc upstreamConn, nick string) string {
	174	if nick == uc.nick {
	175	return dc.nick
	176	}
[130]	177	if dc.network != nil {
[119]	178	return nick
	179	}
	180	return nick + "/" + uc.network.GetName()
[69]	181	}
	182
	183	func (dc downstreamConn) marshalUserPrefix(uc upstreamConn, prefix irc.Prefix) irc.Prefix {
	184	if prefix.Name == uc.nick {
	185	return dc.prefix()
	186	}
[130]	187	if dc.network != nil {
[119]	188	return prefix
	189	}
	190	return &irc.Prefix{
	191	Name: prefix.Name + "/" + uc.network.GetName(),
	192	User: prefix.User,
	193	Host: prefix.Host,
	194	}
[69]	195	}
	196
[165]	197	func (dc *downstreamConn) readMessages(ch chan<- event) error {
[22]	198	for {
[210]	199	msg, err := dc.ReadMessage()
[22]	200	if err == io.EOF {
	201	break
	202	} else if err != nil {
	203	return fmt.Errorf("failed to read IRC command: %v", err)
	204	}
	205
[165]	206	ch <- eventDownstreamMessage{msg, dc}
[22]	207	}
	208
[45]	209	return nil
[22]	210	}
	211
[216]	212	func (dc *downstreamConn) getCap(name string) bool {
	213	dc.lock.Lock()
	214	defer dc.lock.Unlock()
	215	return dc.caps[name]
	216	}
	217
[55]	218	func (dc downstreamConn) SendMessage(msg irc.Message) {
[216]	219	if !dc.getCap("message-tags") {
	220	msg = msg.Copy()
	221	for name := range msg.Tags {
	222	supported := false
	223	switch name {
	224	case "time":
	225	supported = dc.getCap("server-time")
	226	}
	227	if !supported {
	228	delete(msg.Tags, name)
	229	}
	230	}
	231	}
	232
[210]	233	dc.conn.SendMessage(msg)
[54]	234	}
	235
[55]	236	func (dc downstreamConn) handleMessage(msg irc.Message) error {
[13]	237	switch msg.Command {
[28]	238	case "QUIT":
[55]	239	return dc.Close()
[13]	240	default:
[55]	241	if dc.registered {
	242	return dc.handleMessageRegistered(msg)
[13]	243	} else {
[55]	244	return dc.handleMessageUnregistered(msg)
[13]	245	}
	246	}
	247	}
	248
[55]	249	func (dc downstreamConn) handleMessageUnregistered(msg irc.Message) error {
[13]	250	switch msg.Command {
	251	case "NICK":
[117]	252	var nick string
	253	if err := parseMessageParams(msg, &nick); err != nil {
[43]	254	return err
[13]	255	}
[117]	256	if nick == serviceNick {
	257	return ircError{&irc.Message{
	258	Command: irc.ERR_NICKNAMEINUSE,
	259	Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
	260	}}
	261	}
	262	dc.nick = nick
[13]	263	case "USER":
[117]	264	if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]	265	return err
[13]	266	}
[85]	267	case "PASS":
	268	if err := parseMessageParams(msg, &dc.password); err != nil {
	269	return err
	270	}
[108]	271	case "CAP":
	272	var subCmd string
	273	if err := parseMessageParams(msg, &subCmd); err != nil {
	274	return err
	275	}
	276	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	277	return err
	278	}
[112]	279	case "AUTHENTICATE":
[216]	280	if !dc.getCap("sasl") {
[112]	281	return ircError{&irc.Message{
[125]	282	Command: irc.ERR_SASLFAIL,
[112]	283	Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
	284	}}
	285	}
	286	if len(msg.Params) == 0 {
	287	return ircError{&irc.Message{
[125]	288	Command: irc.ERR_SASLFAIL,
[112]	289	Params: []string{"*", "Missing AUTHENTICATE argument"},
	290	}}
	291	}
	292	if dc.nick == "" {
	293	return ircError{&irc.Message{
[125]	294	Command: irc.ERR_SASLFAIL,
[112]	295	Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
	296	}}
	297	}
	298
	299	var resp []byte
	300	if dc.saslServer == nil {
	301	mech := strings.ToUpper(msg.Params[0])
	302	switch mech {
	303	case "PLAIN":
	304	dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
	305	return dc.authenticate(username, password)
	306	}))
	307	default:
	308	return ircError{&irc.Message{
[125]	309	Command: irc.ERR_SASLFAIL,
[112]	310	Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
	311	}}
	312	}
	313	} else if msg.Params[0] == "*" {
	314	dc.saslServer = nil
	315	return ircError{&irc.Message{
[125]	316	Command: irc.ERR_SASLABORTED,
[112]	317	Params: []string{"*", "SASL authentication aborted"},
	318	}}
	319	} else if msg.Params[0] == "+" {
	320	resp = nil
	321	} else {
	322	// TODO: multi-line messages
	323	var err error
	324	resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
	325	if err != nil {
	326	dc.saslServer = nil
	327	return ircError{&irc.Message{
[125]	328	Command: irc.ERR_SASLFAIL,
[112]	329	Params: []string{"*", "Invalid base64-encoded response"},
	330	}}
	331	}
	332	}
	333
	334	challenge, done, err := dc.saslServer.Next(resp)
	335	if err != nil {
	336	dc.saslServer = nil
	337	if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
	338	return ircError{&irc.Message{
[125]	339	Command: irc.ERR_SASLFAIL,
[112]	340	Params: []string{"*", ircErr.Message.Params[1]},
	341	}}
	342	}
	343	dc.SendMessage(&irc.Message{
	344	Prefix: dc.srv.prefix(),
[125]	345	Command: irc.ERR_SASLFAIL,
[112]	346	Params: []string{"*", "SASL error"},
	347	})
	348	return fmt.Errorf("SASL authentication failed: %v", err)
	349	} else if done {
	350	dc.saslServer = nil
	351	dc.SendMessage(&irc.Message{
	352	Prefix: dc.srv.prefix(),
[125]	353	Command: irc.RPL_LOGGEDIN,
[112]	354	Params: []string{dc.nick, dc.nick, dc.user.Username, "You are now logged in"},
	355	})
	356	dc.SendMessage(&irc.Message{
	357	Prefix: dc.srv.prefix(),
[125]	358	Command: irc.RPL_SASLSUCCESS,
[112]	359	Params: []string{dc.nick, "SASL authentication successful"},
	360	})
	361	} else {
	362	challengeStr := "+"
[135]	363	if len(challenge) > 0 {
[112]	364	challengeStr = base64.StdEncoding.EncodeToString(challenge)
	365	}
	366
	367	// TODO: multi-line messages
	368	dc.SendMessage(&irc.Message{
	369	Prefix: dc.srv.prefix(),
	370	Command: "AUTHENTICATE",
	371	Params: []string{challengeStr},
	372	})
	373	}
[13]	374	default:
[55]	375	dc.logger.Printf("unhandled message: %v", msg)
[13]	376	return newUnknownCommandError(msg.Command)
	377	}
[108]	378	if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
[55]	379	return dc.register()
[13]	380	}
	381	return nil
	382	}
	383
[108]	384	func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]	385	cmd = strings.ToUpper(cmd)
	386
[108]	387	replyTo := dc.nick
	388	if !dc.registered {
	389	replyTo = "*"
	390	}
	391
	392	switch cmd {
	393	case "LS":
	394	if len(args) > 0 {
	395	var err error
	396	if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
	397	return err
	398	}
	399	}
	400
[211]	401	caps := []string{"message-tags", "server-time", "echo-message"}
[194]	402
[112]	403	if dc.capVersion >= 302 {
[108]	404	caps = append(caps, "sasl=PLAIN")
	405	} else {
	406	caps = append(caps, "sasl")
[112]	407	}
[108]	408
	409	// TODO: multi-line replies
	410	dc.SendMessage(&irc.Message{
	411	Prefix: dc.srv.prefix(),
	412	Command: "CAP",
	413	Params: []string{replyTo, "LS", strings.Join(caps, " ")},
	414	})
	415
	416	if !dc.registered {
	417	dc.negociatingCaps = true
	418	}
	419	case "LIST":
	420	var caps []string
[216]	421	dc.lock.Lock()
[108]	422	for name := range dc.caps {
	423	caps = append(caps, name)
	424	}
[216]	425	dc.lock.Unlock()
[108]	426
	427	// TODO: multi-line replies
	428	dc.SendMessage(&irc.Message{
	429	Prefix: dc.srv.prefix(),
	430	Command: "CAP",
	431	Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
	432	})
	433	case "REQ":
	434	if len(args) == 0 {
	435	return ircError{&irc.Message{
	436	Command: err_invalidcapcmd,
	437	Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
	438	}}
	439	}
	440
	441	caps := strings.Fields(args[0])
	442	ack := true
[216]	443	dc.lock.Lock()
[108]	444	for _, name := range caps {
	445	name = strings.ToLower(name)
	446	enable := !strings.HasPrefix(name, "-")
	447	if !enable {
	448	name = strings.TrimPrefix(name, "-")
	449	}
	450
	451	enabled := dc.caps[name]
	452	if enable == enabled {
	453	continue
	454	}
	455
	456	switch name {
[211]	457	case "sasl", "message-tags", "server-time", "echo-message":
[112]	458	dc.caps[name] = enable
[108]	459	default:
	460	ack = false
	461	}
	462	}
[216]	463	dc.lock.Unlock()
[108]	464
	465	reply := "NAK"
	466	if ack {
	467	reply = "ACK"
	468	}
	469	dc.SendMessage(&irc.Message{
	470	Prefix: dc.srv.prefix(),
	471	Command: "CAP",
	472	Params: []string{replyTo, reply, args[0]},
	473	})
	474	case "END":
	475	dc.negociatingCaps = false
	476	default:
	477	return ircError{&irc.Message{
	478	Command: err_invalidcapcmd,
	479	Params: []string{replyTo, cmd, "Unknown CAP command"},
	480	}}
	481	}
	482	return nil
	483	}
	484
[91]	485	func sanityCheckServer(addr string) error {
	486	dialer := net.Dialer{Timeout: 30 * time.Second}
	487	conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
	488	if err != nil {
	489	return err
	490	}
	491	return conn.Close()
	492	}
	493
[183]	494	func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]	495	username = rawUsername
[183]	496
	497	i := strings.IndexAny(username, "/@")
	498	j := strings.LastIndexAny(username, "/@")
	499	if i >= 0 {
	500	username = rawUsername[:i]
[73]	501	}
[183]	502	if j >= 0 {
[190]	503	if rawUsername[j] == '@' {
	504	client = rawUsername[j+1:]
	505	} else {
	506	network = rawUsername[j+1:]
	507	}
[73]	508	}
[183]	509	if i >= 0 && j >= 0 && i < j {
[190]	510	if rawUsername[i] == '@' {
	511	client = rawUsername[i+1 : j]
	512	} else {
	513	network = rawUsername[i+1 : j]
	514	}
[183]	515	}
	516
	517	return username, client, network
[112]	518	}
[73]	519
[168]	520	func (dc *downstreamConn) authenticate(username, password string) error {
[183]	521	username, clientName, networkName := unmarshalUsername(username)
[168]	522
[173]	523	u, err := dc.srv.db.GetUser(username)
	524	if err != nil {
	525	dc.logger.Printf("failed authentication for %q: %v", username, err)
[168]	526	return errAuthFailed
	527	}
	528
[173]	529	err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]	530	if err != nil {
	531	dc.logger.Printf("failed authentication for %q: %v", username, err)
	532	return errAuthFailed
	533	}
	534
[173]	535	dc.user = dc.srv.getUser(username)
	536	if dc.user == nil {
	537	dc.logger.Printf("failed authentication for %q: user not active", username)
	538	return errAuthFailed
	539	}
[183]	540	dc.clientName = clientName
[168]	541	dc.networkName = networkName
	542	return nil
	543	}
	544
	545	func (dc *downstreamConn) register() error {
	546	if dc.registered {
	547	return fmt.Errorf("tried to register twice")
	548	}
	549
	550	password := dc.password
	551	dc.password = ""
	552	if dc.user == nil {
	553	if err := dc.authenticate(dc.rawUsername, password); err != nil {
	554	return err
	555	}
	556	}
	557
[183]	558	if dc.clientName == "" && dc.networkName == "" {
	559	_, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]	560	}
	561
	562	dc.registered = true
[184]	563	dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]	564	return nil
	565	}
	566
	567	func (dc *downstreamConn) loadNetwork() error {
	568	if dc.networkName == "" {
[112]	569	return nil
	570	}
[85]	571
[168]	572	network := dc.user.getNetwork(dc.networkName)
[112]	573	if network == nil {
[168]	574	addr := dc.networkName
[112]	575	if !strings.ContainsRune(addr, ':') {
	576	addr = addr + ":6697"
	577	}
	578
	579	dc.logger.Printf("trying to connect to new network %q", addr)
	580	if err := sanityCheckServer(addr); err != nil {
	581	dc.logger.Printf("failed to connect to %q: %v", addr, err)
	582	return ircError{&irc.Message{
	583	Command: irc.ERR_PASSWDMISMATCH,
[168]	584	Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]	585	}}
	586	}
	587
[168]	588	dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]	589	var err error
[120]	590	network, err = dc.user.createNetwork(&Network{
[168]	591	Addr: dc.networkName,
[120]	592	Nick: dc.nick,
	593	})
[112]	594	if err != nil {
	595	return err
	596	}
	597	}
	598
	599	dc.network = network
	600	return nil
	601	}
	602
[168]	603	func (dc *downstreamConn) welcome() error {
	604	if dc.user == nil \|\| !dc.registered {
	605	panic("tried to welcome an unregistered connection")
[37]	606	}
	607
[168]	608	// TODO: doing this might take some time. We should do it in dc.register
	609	// instead, but we'll potentially be adding a new network and this must be
	610	// done in the user goroutine.
	611	if err := dc.loadNetwork(); err != nil {
	612	return err
[85]	613	}
	614
[185]	615	// Only send history if we're the first connected client with that name and
	616	// network
	617	sendHistory := true
	618	dc.user.forEachDownstream(func(conn *downstreamConn) {
	619	if dc.clientName == conn.clientName && dc.network == conn.network {
	620	sendHistory = false
	621	}
	622	})
[40]	623
[55]	624	dc.SendMessage(&irc.Message{
	625	Prefix: dc.srv.prefix(),
[13]	626	Command: irc.RPL_WELCOME,
[98]	627	Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]	628	})
[55]	629	dc.SendMessage(&irc.Message{
	630	Prefix: dc.srv.prefix(),
[13]	631	Command: irc.RPL_YOURHOST,
[55]	632	Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]	633	})
[55]	634	dc.SendMessage(&irc.Message{
	635	Prefix: dc.srv.prefix(),
[13]	636	Command: irc.RPL_CREATED,
[55]	637	Params: []string{dc.nick, "Who cares when the server was created?"},
[54]	638	})
[55]	639	dc.SendMessage(&irc.Message{
	640	Prefix: dc.srv.prefix(),
[13]	641	Command: irc.RPL_MYINFO,
[98]	642	Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]	643	})
[93]	644	// TODO: RPL_ISUPPORT
[55]	645	dc.SendMessage(&irc.Message{
	646	Prefix: dc.srv.prefix(),
[13]	647	Command: irc.ERR_NOMOTD,
[55]	648	Params: []string{dc.nick, "No MOTD"},
[54]	649	})
[13]	650
[73]	651	dc.forEachUpstream(func(uc *upstreamConn) {
[30]	652	for _, ch := range uc.channels {
	653	if ch.complete {
[132]	654	dc.SendMessage(&irc.Message{
	655	Prefix: dc.prefix(),
	656	Command: "JOIN",
	657	Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
	658	})
	659
[55]	660	forwardChannel(dc, ch)
[30]	661	}
	662	}
[143]	663	})
[50]	664
[143]	665	dc.forEachNetwork(func(net *network) {
[185]	666	dc.runNetwork(net, sendHistory)
[144]	667	})
[57]	668
[144]	669	return nil
	670	}
	671
	672	// runNetwork starts listening for messages coming from the network's ring
	673	// buffer.
	674	//
	675	// It panics if the network is not suitable for the downstream connection.
	676	func (dc downstreamConn) runNetwork(net network, loadHistory bool) {
	677	if dc.network != nil && net != dc.network {
	678	panic("network not suitable for downstream connection")
	679	}
	680
	681	var seqPtr *uint64
	682	if loadHistory {
[185]	683	seq, ok := net.history[dc.clientName]
[144]	684	if ok {
	685	seqPtr = &seq
[50]	686	}
[144]	687	}
[57]	688
[144]	689	consumer, ch := net.ring.NewConsumer(seqPtr)
[204]	690
	691	if _, ok := dc.ringConsumers[net]; ok {
	692	panic("network has been added twice")
	693	}
	694	dc.ringConsumers[net] = consumer
	695
[144]	696	go func() {
[204]	697	for range ch {
	698	uc := net.upstream()
	699	if uc == nil {
	700	dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
	701	continue
	702	}
	703
	704	for {
	705	msg := consumer.Peek()
	706	if msg == nil {
[203]	707	break
	708	}
	709
[204]	710	dc.lock.Lock()
	711	_, ours := dc.ourMessages[msg]
	712	delete(dc.ourMessages, msg)
	713	dc.lock.Unlock()
[216]	714	if ours && !dc.getCap("echo-message") {
[204]	715	// The message comes from our connection, don't echo it
	716	// back
	717	consumer.Consume()
	718	continue
[57]	719	}
[188]	720
[204]	721	msg = msg.Copy()
	722	switch msg.Command {
[217]	723	case "PRIVMSG", "NOTICE":
[204]	724	msg.Prefix = dc.marshalUserPrefix(uc, msg.Prefix)
	725	msg.Params[0] = dc.marshalEntity(uc, msg.Params[0])
	726	default:
[217]	727	panic(fmt.Sprintf("unexpected %q message", msg.Command))
[204]	728	}
[188]	729
[204]	730	dc.SendMessage(msg)
	731	consumer.Consume()
[57]	732	}
[144]	733	}
	734	}()
[13]	735	}
	736
[103]	737	func (dc *downstreamConn) runUntilRegistered() error {
	738	for !dc.registered {
[212]	739	msg, err := dc.ReadMessage()
[106]	740	if err != nil {
[103]	741	return fmt.Errorf("failed to read IRC command: %v", err)
	742	}
	743
	744	err = dc.handleMessage(msg)
	745	if ircErr, ok := err.(ircError); ok {
	746	ircErr.Message.Prefix = dc.srv.prefix()
	747	dc.SendMessage(ircErr.Message)
	748	} else if err != nil {
	749	return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
	750	}
	751	}
	752
	753	return nil
	754	}
	755
[55]	756	func (dc downstreamConn) handleMessageRegistered(msg irc.Message) error {
[13]	757	switch msg.Command {
[111]	758	case "CAP":
	759	var subCmd string
	760	if err := parseMessageParams(msg, &subCmd); err != nil {
	761	return err
	762	}
	763	if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
	764	return err
	765	}
[107]	766	case "PING":
	767	dc.SendMessage(&irc.Message{
	768	Prefix: dc.srv.prefix(),
	769	Command: "PONG",
	770	Params: msg.Params,
	771	})
	772	return nil
[42]	773	case "USER":
[13]	774	return ircError{&irc.Message{
	775	Command: irc.ERR_ALREADYREGISTERED,
[55]	776	Params: []string{dc.nick, "You may not reregister"},
[13]	777	}}
[42]	778	case "NICK":
[90]	779	var nick string
	780	if err := parseMessageParams(msg, &nick); err != nil {
	781	return err
	782	}
	783
	784	var err error
	785	dc.forEachNetwork(func(n *network) {
	786	if err != nil {
	787	return
	788	}
	789	n.Nick = nick
	790	err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
	791	})
	792	if err != nil {
	793	return err
	794	}
	795
[73]	796	dc.forEachUpstream(func(uc *upstreamConn) {
[60]	797	uc.SendMessage(msg)
[42]	798	})
[146]	799	case "JOIN":
	800	var namesStr string
	801	if err := parseMessageParams(msg, &namesStr); err != nil {
[48]	802	return err
	803	}
	804
[146]	805	var keys []string
	806	if len(msg.Params) > 1 {
	807	keys = strings.Split(msg.Params[1], ",")
	808	}
	809
	810	for i, name := range strings.Split(namesStr, ",") {
[145]	811	uc, upstreamName, err := dc.unmarshalEntity(name)
	812	if err != nil {
[158]	813	return err
[145]	814	}
[48]	815
[146]	816	var key string
	817	if len(keys) > i {
	818	key = keys[i]
	819	}
	820
	821	params := []string{upstreamName}
	822	if key != "" {
	823	params = append(params, key)
	824	}
[145]	825	uc.SendMessage(&irc.Message{
[146]	826	Command: "JOIN",
	827	Params: params,
[145]	828	})
[89]	829
[207]	830	ch, err := dc.srv.db.GetChannel(uc.network.ID, upstreamName)
	831	if err == ErrNoSuchChannel {
	832	ch = &Channel{Name: upstreamName}
	833	} else if err != nil {
	834	return err
[89]	835	}
[207]	836
	837	ch.Key = key
	838
	839	if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
	840	return err
	841	}
[89]	842	}
[146]	843	case "PART":
	844	var namesStr string
	845	if err := parseMessageParams(msg, &namesStr); err != nil {
	846	return err
	847	}
	848
	849	var reason string
	850	if len(msg.Params) > 1 {
	851	reason = msg.Params[1]
	852	}
	853
	854	for _, name := range strings.Split(namesStr, ",") {
	855	uc, upstreamName, err := dc.unmarshalEntity(name)
	856	if err != nil {
[158]	857	return err
[146]	858	}
	859
	860	params := []string{upstreamName}
	861	if reason != "" {
	862	params = append(params, reason)
	863	}
	864	uc.SendMessage(&irc.Message{
	865	Command: "PART",
	866	Params: params,
	867	})
	868
	869	if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
	870	dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
	871	}
	872	}
[159]	873	case "KICK":
	874	var channelStr, userStr string
	875	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	876	return err
	877	}
	878
	879	channels := strings.Split(channelStr, ",")
	880	users := strings.Split(userStr, ",")
	881
	882	var reason string
	883	if len(msg.Params) > 2 {
	884	reason = msg.Params[2]
	885	}
	886
	887	if len(channels) != 1 && len(channels) != len(users) {
	888	return ircError{&irc.Message{
	889	Command: irc.ERR_BADCHANMASK,
	890	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	891	}}
	892	}
	893
	894	for i, user := range users {
	895	var channel string
	896	if len(channels) == 1 {
	897	channel = channels[0]
	898	} else {
	899	channel = channels[i]
	900	}
	901
	902	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	903	if err != nil {
	904	return err
	905	}
	906
	907	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	908	if err != nil {
	909	return err
	910	}
	911
	912	if ucChannel != ucUser {
	913	return ircError{&irc.Message{
	914	Command: irc.ERR_USERNOTINCHANNEL,
	915	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	916	}}
	917	}
	918	uc := ucChannel
	919
	920	params := []string{upstreamChannel, upstreamUser}
	921	if reason != "" {
	922	params = append(params, reason)
	923	}
	924	uc.SendMessage(&irc.Message{
	925	Command: "KICK",
	926	Params: params,
	927	})
	928	}
[69]	929	case "MODE":
[46]	930	var name string
	931	if err := parseMessageParams(msg, &name); err != nil {
	932	return err
	933	}
	934
	935	var modeStr string
	936	if len(msg.Params) > 1 {
	937	modeStr = msg.Params[1]
	938	}
	939
[139]	940	if name == dc.nick {
[46]	941	if modeStr != "" {
[73]	942	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	943	uc.SendMessage(&irc.Message{
	944	Command: "MODE",
	945	Params: []string{uc.nick, modeStr},
	946	})
[46]	947	})
	948	} else {
[55]	949	dc.SendMessage(&irc.Message{
	950	Prefix: dc.srv.prefix(),
[46]	951	Command: irc.RPL_UMODEIS,
[129]	952	Params: []string{dc.nick, ""}, // TODO
[54]	953	})
[46]	954	}
[139]	955	return nil
[46]	956	}
[139]	957
	958	uc, upstreamName, err := dc.unmarshalEntity(name)
	959	if err != nil {
	960	return err
	961	}
	962
	963	if !uc.isChannel(upstreamName) {
	964	return ircError{&irc.Message{
	965	Command: irc.ERR_USERSDONTMATCH,
	966	Params: []string{dc.nick, "Cannot change mode for other users"},
	967	}}
	968	}
	969
	970	if modeStr != "" {
	971	params := []string{upstreamName, modeStr}
	972	params = append(params, msg.Params[2:]...)
	973	uc.SendMessage(&irc.Message{
	974	Command: "MODE",
	975	Params: params,
	976	})
	977	} else {
	978	ch, ok := uc.channels[upstreamName]
	979	if !ok {
	980	return ircError{&irc.Message{
	981	Command: irc.ERR_NOSUCHCHANNEL,
	982	Params: []string{dc.nick, name, "No such channel"},
	983	}}
	984	}
	985
	986	if ch.modes == nil {
	987	// we haven't received the initial RPL_CHANNELMODEIS yet
	988	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	989	return nil
	990	}
	991
	992	modeStr, modeParams := ch.modes.Format()
	993	params := []string{dc.nick, name, modeStr}
	994	params = append(params, modeParams...)
	995
	996	dc.SendMessage(&irc.Message{
	997	Prefix: dc.srv.prefix(),
	998	Command: irc.RPL_CHANNELMODEIS,
	999	Params: params,
	1000	})
[162]	1001	if ch.creationTime != "" {
	1002	dc.SendMessage(&irc.Message{
	1003	Prefix: dc.srv.prefix(),
	1004	Command: rpl_creationtime,
	1005	Params: []string{dc.nick, name, ch.creationTime},
	1006	})
	1007	}
[139]	1008	}
[160]	1009	case "TOPIC":
	1010	var channel string
	1011	if err := parseMessageParams(msg, &channel); err != nil {
	1012	return err
	1013	}
	1014
	1015	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1016	if err != nil {
	1017	return err
	1018	}
	1019
	1020	if len(msg.Params) > 1 { // setting topic
	1021	topic := msg.Params[1]
	1022	uc.SendMessage(&irc.Message{
	1023	Command: "TOPIC",
	1024	Params: []string{upstreamChannel, topic},
	1025	})
	1026	} else { // getting topic
	1027	ch, ok := uc.channels[upstreamChannel]
	1028	if !ok {
	1029	return ircError{&irc.Message{
	1030	Command: irc.ERR_NOSUCHCHANNEL,
	1031	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1032	}}
	1033	}
	1034	sendTopic(dc, ch)
	1035	}
[177]	1036	case "LIST":
	1037	// TODO: support ELIST when supported by all upstreams
	1038
	1039	pl := pendingLIST{
	1040	downstreamID: dc.id,
	1041	pendingCommands: make(map[int64]*irc.Message),
	1042	}
	1043	var upstreamChannels map[int64][]string
	1044	if len(msg.Params) > 0 {
	1045	upstreamChannels = make(map[int64][]string)
	1046	channels := strings.Split(msg.Params[0], ",")
	1047	for _, channel := range channels {
	1048	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1049	if err != nil {
	1050	return err
	1051	}
	1052	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1053	}
	1054	}
	1055
	1056	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1057	dc.forEachUpstream(func(uc *upstreamConn) {
	1058	var params []string
	1059	if upstreamChannels != nil {
	1060	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1061	params = []string{strings.Join(channels, ",")}
	1062	} else {
	1063	return
	1064	}
	1065	}
	1066	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1067	Command: "LIST",
	1068	Params: params,
	1069	}
[181]	1070	uc.trySendLIST(dc.id)
[177]	1071	})
[140]	1072	case "NAMES":
	1073	if len(msg.Params) == 0 {
	1074	dc.SendMessage(&irc.Message{
	1075	Prefix: dc.srv.prefix(),
	1076	Command: irc.RPL_ENDOFNAMES,
	1077	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1078	})
	1079	return nil
	1080	}
	1081
	1082	channels := strings.Split(msg.Params[0], ",")
	1083	for _, channel := range channels {
	1084	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1085	if err != nil {
	1086	return err
	1087	}
	1088
	1089	ch, ok := uc.channels[upstreamChannel]
	1090	if ok {
	1091	sendNames(dc, ch)
	1092	} else {
	1093	// NAMES on a channel we have not joined, ask upstream
[176]	1094	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1095	Command: "NAMES",
	1096	Params: []string{upstreamChannel},
	1097	})
	1098	}
	1099	}
[127]	1100	case "WHO":
	1101	if len(msg.Params) == 0 {
	1102	// TODO: support WHO without parameters
	1103	dc.SendMessage(&irc.Message{
	1104	Prefix: dc.srv.prefix(),
	1105	Command: irc.RPL_ENDOFWHO,
[140]	1106	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1107	})
	1108	return nil
	1109	}
	1110
	1111	// TODO: support WHO masks
	1112	entity := msg.Params[0]
	1113
[142]	1114	if entity == dc.nick {
	1115	// TODO: support AWAY (H/G) in self WHO reply
	1116	dc.SendMessage(&irc.Message{
	1117	Prefix: dc.srv.prefix(),
	1118	Command: irc.RPL_WHOREPLY,
[184]	1119	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1120	})
	1121	dc.SendMessage(&irc.Message{
	1122	Prefix: dc.srv.prefix(),
	1123	Command: irc.RPL_ENDOFWHO,
	1124	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1125	})
	1126	return nil
	1127	}
	1128
[127]	1129	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1130	if err != nil {
	1131	return err
	1132	}
	1133
	1134	var params []string
	1135	if len(msg.Params) == 2 {
	1136	params = []string{upstreamName, msg.Params[1]}
	1137	} else {
	1138	params = []string{upstreamName}
	1139	}
	1140
[176]	1141	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1142	Command: "WHO",
	1143	Params: params,
	1144	})
[128]	1145	case "WHOIS":
	1146	if len(msg.Params) == 0 {
	1147	return ircError{&irc.Message{
	1148	Command: irc.ERR_NONICKNAMEGIVEN,
	1149	Params: []string{dc.nick, "No nickname given"},
	1150	}}
	1151	}
	1152
	1153	var target, mask string
	1154	if len(msg.Params) == 1 {
	1155	target = ""
	1156	mask = msg.Params[0]
	1157	} else {
	1158	target = msg.Params[0]
	1159	mask = msg.Params[1]
	1160	}
	1161	// TODO: support multiple WHOIS users
	1162	if i := strings.IndexByte(mask, ','); i >= 0 {
	1163	mask = mask[:i]
	1164	}
	1165
[142]	1166	if mask == dc.nick {
	1167	dc.SendMessage(&irc.Message{
	1168	Prefix: dc.srv.prefix(),
	1169	Command: irc.RPL_WHOISUSER,
[184]	1170	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1171	})
	1172	dc.SendMessage(&irc.Message{
	1173	Prefix: dc.srv.prefix(),
	1174	Command: irc.RPL_WHOISSERVER,
	1175	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1176	})
	1177	dc.SendMessage(&irc.Message{
	1178	Prefix: dc.srv.prefix(),
	1179	Command: irc.RPL_ENDOFWHOIS,
	1180	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1181	})
	1182	return nil
	1183	}
	1184
[128]	1185	// TODO: support WHOIS masks
	1186	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1187	if err != nil {
	1188	return err
	1189	}
	1190
	1191	var params []string
	1192	if target != "" {
	1193	params = []string{target, upstreamNick}
	1194	} else {
	1195	params = []string{upstreamNick}
	1196	}
	1197
[176]	1198	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1199	Command: "WHOIS",
	1200	Params: params,
	1201	})
[58]	1202	case "PRIVMSG":
	1203	var targetsStr, text string
	1204	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1205	return err
	1206	}
	1207
	1208	for _, name := range strings.Split(targetsStr, ",") {
[117]	1209	if name == serviceNick {
	1210	handleServicePRIVMSG(dc, text)
	1211	continue
	1212	}
	1213
[127]	1214	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1215	if err != nil {
	1216	return err
	1217	}
	1218
[95]	1219	if upstreamName == "NickServ" {
	1220	dc.handleNickServPRIVMSG(uc, text)
	1221	}
	1222
[69]	1223	uc.SendMessage(&irc.Message{
[58]	1224	Command: "PRIVMSG",
[69]	1225	Params: []string{upstreamName, text},
[60]	1226	})
[105]	1227
[113]	1228	echoMsg := &irc.Message{
	1229	Prefix: &irc.Prefix{
	1230	Name: uc.nick,
	1231	User: uc.username,
	1232	},
[114]	1233	Command: "PRIVMSG",
[113]	1234	Params: []string{upstreamName, text},
	1235	}
[105]	1236	dc.lock.Lock()
[113]	1237	dc.ourMessages[echoMsg] = struct{}{}
[105]	1238	dc.lock.Unlock()
	1239
[215]	1240	uc.appendLog(upstreamName, echoMsg)
[213]	1241
[143]	1242	uc.network.ring.Produce(echoMsg)
[58]	1243	}
[164]	1244	case "NOTICE":
	1245	var targetsStr, text string
	1246	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1247	return err
	1248	}
	1249
	1250	for _, name := range strings.Split(targetsStr, ",") {
	1251	uc, upstreamName, err := dc.unmarshalEntity(name)
	1252	if err != nil {
	1253	return err
	1254	}
	1255
	1256	uc.SendMessage(&irc.Message{
	1257	Command: "NOTICE",
	1258	Params: []string{upstreamName, text},
	1259	})
	1260	}
[163]	1261	case "INVITE":
	1262	var user, channel string
	1263	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1264	return err
	1265	}
	1266
	1267	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1268	if err != nil {
	1269	return err
	1270	}
	1271
	1272	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1273	if err != nil {
	1274	return err
	1275	}
	1276
	1277	if ucChannel != ucUser {
	1278	return ircError{&irc.Message{
	1279	Command: irc.ERR_USERNOTINCHANNEL,
	1280	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1281	}}
	1282	}
	1283	uc := ucChannel
	1284
[176]	1285	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1286	Command: "INVITE",
	1287	Params: []string{upstreamUser, upstreamChannel},
	1288	})
[13]	1289	default:
[55]	1290	dc.logger.Printf("unhandled message: %v", msg)
[13]	1291	return newUnknownCommandError(msg.Command)
	1292	}
[42]	1293	return nil
[13]	1294	}
[95]	1295
	1296	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1297	username, password, ok := parseNickServCredentials(text, uc.nick)
	1298	if !ok {
	1299	return
	1300	}
	1301
	1302	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1303	n := uc.network
	1304	n.SASL.Mechanism = "PLAIN"
	1305	n.SASL.Plain.Username = username
	1306	n.SASL.Plain.Password = password
	1307	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1308	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1309	}
	1310	}
	1311
	1312	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1313	fields := strings.Fields(text)
	1314	if len(fields) < 2 {
	1315	return "", "", false
	1316	}
	1317	cmd := strings.ToUpper(fields[0])
	1318	params := fields[1:]
	1319	switch cmd {
	1320	case "REGISTER":
	1321	username = nick
	1322	password = params[0]
	1323	case "IDENTIFY":
	1324	if len(params) == 1 {
	1325	username = nick
[182]	1326	password = params[0]
[95]	1327	} else {
	1328	username = params[0]
[182]	1329	password = params[1]
[95]	1330	}
[182]	1331	case "SET":
	1332	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1333	username = nick
	1334	password = params[1]
	1335	}
[95]	1336	}
	1337	return username, password, true
	1338	}

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

Download in other formats: