Context Navigation

source: code/trunk/downstream.go@ 224

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

Add network.{createUpdate,delete}Channel

These are about to get more complicated as we move towards per-entity
ring buffers.

File size: 30.4 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
[91]	4	"crypto/tls"
[112]	5	"encoding/base64"
[13]	6	"fmt"
	7	"io"
	8	"net"
[108]	9	"strconv"
[39]	10	"strings"
[105]	11	"sync"
[91]	12	"time"
[13]	13
[112]	14	"github.com/emersion/go-sasl"
[85]	15	"golang.org/x/crypto/bcrypt"
[13]	16	"gopkg.in/irc.v3"
	17	)
	18
	19	type ircError struct {
	20	Message *irc.Message
	21	}
	22
[85]	23	func (err ircError) Error() string {
	24	return err.Message.String()
	25	}
	26
[13]	27	func newUnknownCommandError(cmd string) ircError {
	28	return ircError{&irc.Message{
	29	Command: irc.ERR_UNKNOWNCOMMAND,
	30	Params: []string{
	31	"*",
	32	cmd,
	33	"Unknown command",
	34	},
	35	}}
	36	}
	37
	38	func newNeedMoreParamsError(cmd string) ircError {
	39	return ircError{&irc.Message{
	40	Command: irc.ERR_NEEDMOREPARAMS,
	41	Params: []string{
	42	"*",
	43	cmd,
	44	"Not enough parameters",
	45	},
	46	}}
	47	}
	48
[85]	49	var errAuthFailed = ircError{&irc.Message{
	50	Command: irc.ERR_PASSWDMISMATCH,
	51	Params: []string{"*", "Invalid username or password"},
	52	}}
[13]	53
	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
[222]	830	ch := &Channel{Name: upstreamName, Key: key}
	831	if err := uc.network.createUpdateChannel(ch); err != nil {
	832	dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
[89]	833	}
	834	}
[146]	835	case "PART":
	836	var namesStr string
	837	if err := parseMessageParams(msg, &namesStr); err != nil {
	838	return err
	839	}
	840
	841	var reason string
	842	if len(msg.Params) > 1 {
	843	reason = msg.Params[1]
	844	}
	845
	846	for _, name := range strings.Split(namesStr, ",") {
	847	uc, upstreamName, err := dc.unmarshalEntity(name)
	848	if err != nil {
[158]	849	return err
[146]	850	}
	851
	852	params := []string{upstreamName}
	853	if reason != "" {
	854	params = append(params, reason)
	855	}
	856	uc.SendMessage(&irc.Message{
	857	Command: "PART",
	858	Params: params,
	859	})
	860
[222]	861	if err := uc.network.deleteChannel(upstreamName); err != nil {
	862	dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
[146]	863	}
	864	}
[159]	865	case "KICK":
	866	var channelStr, userStr string
	867	if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
	868	return err
	869	}
	870
	871	channels := strings.Split(channelStr, ",")
	872	users := strings.Split(userStr, ",")
	873
	874	var reason string
	875	if len(msg.Params) > 2 {
	876	reason = msg.Params[2]
	877	}
	878
	879	if len(channels) != 1 && len(channels) != len(users) {
	880	return ircError{&irc.Message{
	881	Command: irc.ERR_BADCHANMASK,
	882	Params: []string{dc.nick, channelStr, "Bad channel mask"},
	883	}}
	884	}
	885
	886	for i, user := range users {
	887	var channel string
	888	if len(channels) == 1 {
	889	channel = channels[0]
	890	} else {
	891	channel = channels[i]
	892	}
	893
	894	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	895	if err != nil {
	896	return err
	897	}
	898
	899	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	900	if err != nil {
	901	return err
	902	}
	903
	904	if ucChannel != ucUser {
	905	return ircError{&irc.Message{
	906	Command: irc.ERR_USERNOTINCHANNEL,
	907	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	908	}}
	909	}
	910	uc := ucChannel
	911
	912	params := []string{upstreamChannel, upstreamUser}
	913	if reason != "" {
	914	params = append(params, reason)
	915	}
	916	uc.SendMessage(&irc.Message{
	917	Command: "KICK",
	918	Params: params,
	919	})
	920	}
[69]	921	case "MODE":
[46]	922	var name string
	923	if err := parseMessageParams(msg, &name); err != nil {
	924	return err
	925	}
	926
	927	var modeStr string
	928	if len(msg.Params) > 1 {
	929	modeStr = msg.Params[1]
	930	}
	931
[139]	932	if name == dc.nick {
[46]	933	if modeStr != "" {
[73]	934	dc.forEachUpstream(func(uc *upstreamConn) {
[69]	935	uc.SendMessage(&irc.Message{
	936	Command: "MODE",
	937	Params: []string{uc.nick, modeStr},
	938	})
[46]	939	})
	940	} else {
[55]	941	dc.SendMessage(&irc.Message{
	942	Prefix: dc.srv.prefix(),
[46]	943	Command: irc.RPL_UMODEIS,
[129]	944	Params: []string{dc.nick, ""}, // TODO
[54]	945	})
[46]	946	}
[139]	947	return nil
[46]	948	}
[139]	949
	950	uc, upstreamName, err := dc.unmarshalEntity(name)
	951	if err != nil {
	952	return err
	953	}
	954
	955	if !uc.isChannel(upstreamName) {
	956	return ircError{&irc.Message{
	957	Command: irc.ERR_USERSDONTMATCH,
	958	Params: []string{dc.nick, "Cannot change mode for other users"},
	959	}}
	960	}
	961
	962	if modeStr != "" {
	963	params := []string{upstreamName, modeStr}
	964	params = append(params, msg.Params[2:]...)
	965	uc.SendMessage(&irc.Message{
	966	Command: "MODE",
	967	Params: params,
	968	})
	969	} else {
	970	ch, ok := uc.channels[upstreamName]
	971	if !ok {
	972	return ircError{&irc.Message{
	973	Command: irc.ERR_NOSUCHCHANNEL,
	974	Params: []string{dc.nick, name, "No such channel"},
	975	}}
	976	}
	977
	978	if ch.modes == nil {
	979	// we haven't received the initial RPL_CHANNELMODEIS yet
	980	// ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
	981	return nil
	982	}
	983
	984	modeStr, modeParams := ch.modes.Format()
	985	params := []string{dc.nick, name, modeStr}
	986	params = append(params, modeParams...)
	987
	988	dc.SendMessage(&irc.Message{
	989	Prefix: dc.srv.prefix(),
	990	Command: irc.RPL_CHANNELMODEIS,
	991	Params: params,
	992	})
[162]	993	if ch.creationTime != "" {
	994	dc.SendMessage(&irc.Message{
	995	Prefix: dc.srv.prefix(),
	996	Command: rpl_creationtime,
	997	Params: []string{dc.nick, name, ch.creationTime},
	998	})
	999	}
[139]	1000	}
[160]	1001	case "TOPIC":
	1002	var channel string
	1003	if err := parseMessageParams(msg, &channel); err != nil {
	1004	return err
	1005	}
	1006
	1007	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1008	if err != nil {
	1009	return err
	1010	}
	1011
	1012	if len(msg.Params) > 1 { // setting topic
	1013	topic := msg.Params[1]
	1014	uc.SendMessage(&irc.Message{
	1015	Command: "TOPIC",
	1016	Params: []string{upstreamChannel, topic},
	1017	})
	1018	} else { // getting topic
	1019	ch, ok := uc.channels[upstreamChannel]
	1020	if !ok {
	1021	return ircError{&irc.Message{
	1022	Command: irc.ERR_NOSUCHCHANNEL,
	1023	Params: []string{dc.nick, upstreamChannel, "No such channel"},
	1024	}}
	1025	}
	1026	sendTopic(dc, ch)
	1027	}
[177]	1028	case "LIST":
	1029	// TODO: support ELIST when supported by all upstreams
	1030
	1031	pl := pendingLIST{
	1032	downstreamID: dc.id,
	1033	pendingCommands: make(map[int64]*irc.Message),
	1034	}
	1035	var upstreamChannels map[int64][]string
	1036	if len(msg.Params) > 0 {
	1037	upstreamChannels = make(map[int64][]string)
	1038	channels := strings.Split(msg.Params[0], ",")
	1039	for _, channel := range channels {
	1040	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1041	if err != nil {
	1042	return err
	1043	}
	1044	upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
	1045	}
	1046	}
	1047
	1048	dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
	1049	dc.forEachUpstream(func(uc *upstreamConn) {
	1050	var params []string
	1051	if upstreamChannels != nil {
	1052	if channels, ok := upstreamChannels[uc.network.ID]; ok {
	1053	params = []string{strings.Join(channels, ",")}
	1054	} else {
	1055	return
	1056	}
	1057	}
	1058	pl.pendingCommands[uc.network.ID] = &irc.Message{
	1059	Command: "LIST",
	1060	Params: params,
	1061	}
[181]	1062	uc.trySendLIST(dc.id)
[177]	1063	})
[140]	1064	case "NAMES":
	1065	if len(msg.Params) == 0 {
	1066	dc.SendMessage(&irc.Message{
	1067	Prefix: dc.srv.prefix(),
	1068	Command: irc.RPL_ENDOFNAMES,
	1069	Params: []string{dc.nick, "*", "End of /NAMES list"},
	1070	})
	1071	return nil
	1072	}
	1073
	1074	channels := strings.Split(msg.Params[0], ",")
	1075	for _, channel := range channels {
	1076	uc, upstreamChannel, err := dc.unmarshalEntity(channel)
	1077	if err != nil {
	1078	return err
	1079	}
	1080
	1081	ch, ok := uc.channels[upstreamChannel]
	1082	if ok {
	1083	sendNames(dc, ch)
	1084	} else {
	1085	// NAMES on a channel we have not joined, ask upstream
[176]	1086	uc.SendMessageLabeled(dc.id, &irc.Message{
[140]	1087	Command: "NAMES",
	1088	Params: []string{upstreamChannel},
	1089	})
	1090	}
	1091	}
[127]	1092	case "WHO":
	1093	if len(msg.Params) == 0 {
	1094	// TODO: support WHO without parameters
	1095	dc.SendMessage(&irc.Message{
	1096	Prefix: dc.srv.prefix(),
	1097	Command: irc.RPL_ENDOFWHO,
[140]	1098	Params: []string{dc.nick, "*", "End of /WHO list"},
[127]	1099	})
	1100	return nil
	1101	}
	1102
	1103	// TODO: support WHO masks
	1104	entity := msg.Params[0]
	1105
[142]	1106	if entity == dc.nick {
	1107	// TODO: support AWAY (H/G) in self WHO reply
	1108	dc.SendMessage(&irc.Message{
	1109	Prefix: dc.srv.prefix(),
	1110	Command: irc.RPL_WHOREPLY,
[184]	1111	Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]	1112	})
	1113	dc.SendMessage(&irc.Message{
	1114	Prefix: dc.srv.prefix(),
	1115	Command: irc.RPL_ENDOFWHO,
	1116	Params: []string{dc.nick, dc.nick, "End of /WHO list"},
	1117	})
	1118	return nil
	1119	}
	1120
[127]	1121	uc, upstreamName, err := dc.unmarshalEntity(entity)
	1122	if err != nil {
	1123	return err
	1124	}
	1125
	1126	var params []string
	1127	if len(msg.Params) == 2 {
	1128	params = []string{upstreamName, msg.Params[1]}
	1129	} else {
	1130	params = []string{upstreamName}
	1131	}
	1132
[176]	1133	uc.SendMessageLabeled(dc.id, &irc.Message{
[127]	1134	Command: "WHO",
	1135	Params: params,
	1136	})
[128]	1137	case "WHOIS":
	1138	if len(msg.Params) == 0 {
	1139	return ircError{&irc.Message{
	1140	Command: irc.ERR_NONICKNAMEGIVEN,
	1141	Params: []string{dc.nick, "No nickname given"},
	1142	}}
	1143	}
	1144
	1145	var target, mask string
	1146	if len(msg.Params) == 1 {
	1147	target = ""
	1148	mask = msg.Params[0]
	1149	} else {
	1150	target = msg.Params[0]
	1151	mask = msg.Params[1]
	1152	}
	1153	// TODO: support multiple WHOIS users
	1154	if i := strings.IndexByte(mask, ','); i >= 0 {
	1155	mask = mask[:i]
	1156	}
	1157
[142]	1158	if mask == dc.nick {
	1159	dc.SendMessage(&irc.Message{
	1160	Prefix: dc.srv.prefix(),
	1161	Command: irc.RPL_WHOISUSER,
[184]	1162	Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]	1163	})
	1164	dc.SendMessage(&irc.Message{
	1165	Prefix: dc.srv.prefix(),
	1166	Command: irc.RPL_WHOISSERVER,
	1167	Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
	1168	})
	1169	dc.SendMessage(&irc.Message{
	1170	Prefix: dc.srv.prefix(),
	1171	Command: irc.RPL_ENDOFWHOIS,
	1172	Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
	1173	})
	1174	return nil
	1175	}
	1176
[128]	1177	// TODO: support WHOIS masks
	1178	uc, upstreamNick, err := dc.unmarshalEntity(mask)
	1179	if err != nil {
	1180	return err
	1181	}
	1182
	1183	var params []string
	1184	if target != "" {
	1185	params = []string{target, upstreamNick}
	1186	} else {
	1187	params = []string{upstreamNick}
	1188	}
	1189
[176]	1190	uc.SendMessageLabeled(dc.id, &irc.Message{
[128]	1191	Command: "WHOIS",
	1192	Params: params,
	1193	})
[58]	1194	case "PRIVMSG":
	1195	var targetsStr, text string
	1196	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1197	return err
	1198	}
	1199
	1200	for _, name := range strings.Split(targetsStr, ",") {
[117]	1201	if name == serviceNick {
	1202	handleServicePRIVMSG(dc, text)
	1203	continue
	1204	}
	1205
[127]	1206	uc, upstreamName, err := dc.unmarshalEntity(name)
[58]	1207	if err != nil {
	1208	return err
	1209	}
	1210
[95]	1211	if upstreamName == "NickServ" {
	1212	dc.handleNickServPRIVMSG(uc, text)
	1213	}
	1214
[69]	1215	uc.SendMessage(&irc.Message{
[58]	1216	Command: "PRIVMSG",
[69]	1217	Params: []string{upstreamName, text},
[60]	1218	})
[105]	1219
[113]	1220	echoMsg := &irc.Message{
	1221	Prefix: &irc.Prefix{
	1222	Name: uc.nick,
	1223	User: uc.username,
	1224	},
[114]	1225	Command: "PRIVMSG",
[113]	1226	Params: []string{upstreamName, text},
	1227	}
[105]	1228	dc.lock.Lock()
[113]	1229	dc.ourMessages[echoMsg] = struct{}{}
[105]	1230	dc.lock.Unlock()
	1231
[215]	1232	uc.appendLog(upstreamName, echoMsg)
[213]	1233
[143]	1234	uc.network.ring.Produce(echoMsg)
[58]	1235	}
[164]	1236	case "NOTICE":
	1237	var targetsStr, text string
	1238	if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
	1239	return err
	1240	}
	1241
	1242	for _, name := range strings.Split(targetsStr, ",") {
	1243	uc, upstreamName, err := dc.unmarshalEntity(name)
	1244	if err != nil {
	1245	return err
	1246	}
	1247
	1248	uc.SendMessage(&irc.Message{
	1249	Command: "NOTICE",
	1250	Params: []string{upstreamName, text},
	1251	})
	1252	}
[163]	1253	case "INVITE":
	1254	var user, channel string
	1255	if err := parseMessageParams(msg, &user, &channel); err != nil {
	1256	return err
	1257	}
	1258
	1259	ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
	1260	if err != nil {
	1261	return err
	1262	}
	1263
	1264	ucUser, upstreamUser, err := dc.unmarshalEntity(user)
	1265	if err != nil {
	1266	return err
	1267	}
	1268
	1269	if ucChannel != ucUser {
	1270	return ircError{&irc.Message{
	1271	Command: irc.ERR_USERNOTINCHANNEL,
	1272	Params: []string{dc.nick, user, channel, "They aren't on that channel"},
	1273	}}
	1274	}
	1275	uc := ucChannel
	1276
[176]	1277	uc.SendMessageLabeled(dc.id, &irc.Message{
[163]	1278	Command: "INVITE",
	1279	Params: []string{upstreamUser, upstreamChannel},
	1280	})
[13]	1281	default:
[55]	1282	dc.logger.Printf("unhandled message: %v", msg)
[13]	1283	return newUnknownCommandError(msg.Command)
	1284	}
[42]	1285	return nil
[13]	1286	}
[95]	1287
	1288	func (dc downstreamConn) handleNickServPRIVMSG(uc upstreamConn, text string) {
	1289	username, password, ok := parseNickServCredentials(text, uc.nick)
	1290	if !ok {
	1291	return
	1292	}
	1293
	1294	dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
	1295	n := uc.network
	1296	n.SASL.Mechanism = "PLAIN"
	1297	n.SASL.Plain.Username = username
	1298	n.SASL.Plain.Password = password
	1299	if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
	1300	dc.logger.Printf("failed to save NickServ credentials: %v", err)
	1301	}
	1302	}
	1303
	1304	func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
	1305	fields := strings.Fields(text)
	1306	if len(fields) < 2 {
	1307	return "", "", false
	1308	}
	1309	cmd := strings.ToUpper(fields[0])
	1310	params := fields[1:]
	1311	switch cmd {
	1312	case "REGISTER":
	1313	username = nick
	1314	password = params[0]
	1315	case "IDENTIFY":
	1316	if len(params) == 1 {
	1317	username = nick
[182]	1318	password = params[0]
[95]	1319	} else {
	1320	username = params[0]
[182]	1321	password = params[1]
[95]	1322	}
[182]	1323	case "SET":
	1324	if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
	1325	username = nick
	1326	password = params[1]
	1327	}
[95]	1328	}
	1329	return username, password, true
	1330	}

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

Download in other formats: