Context Navigation

source: code/trunk/downstream.go@ 230

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

Remove downstreamConn.lock

Everything is now accessed from the user goroutine now that the
per-network ring buffer goroutine is gone.

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

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

Download in other formats: