Context Navigation

source: code/trunk/downstream.go@ 227

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

Remove per-network ring buffer goroutines

Just dispatch from the user goroutine. This allows removes a lot of complexity.

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

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

Download in other formats: