source: code/trunk/downstream.go@ 562

Last change on this file since 562 was 562, checked in by contact, 4 years ago

Unify downstream PRIVMSG and NOTICE handling

We were doing some things wrong here, e.g. not sending echo messages
for NOTICE.
File size: 59.1 KB
Line 
1package soju
2
3import (
4 "crypto/tls"
5 "encoding/base64"
6 "fmt"
7 "io"
8 "net"
9 "strconv"
10 "strings"
11 "time"
12
13 "github.com/emersion/go-sasl"
14 "golang.org/x/crypto/bcrypt"
15 "gopkg.in/irc.v3"
16)
17
18type ircError struct {
19 Message *irc.Message
20}
21
22func (err ircError) Error() string {
23 return err.Message.String()
24}
25
26func 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
37func 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
48func newChatHistoryError(subcommand string, target string) ircError {
49 return ircError{&irc.Message{
50 Command: "FAIL",
51 Params: []string{"CHATHISTORY", "MESSAGE_ERROR", subcommand, target, "Messages could not be retrieved"},
52 }}
53}
54
55var errAuthFailed = ircError{&irc.Message{
56 Command: irc.ERR_PASSWDMISMATCH,
57 Params: []string{"*", "Invalid username or password"},
58}}
59
60func parseBouncerNetID(subcommand, s string) (int64, error) {
61 id, err := strconv.ParseInt(s, 10, 64)
62 if err != nil {
63 return 0, ircError{&irc.Message{
64 Command: "FAIL",
65 Params: []string{"BOUNCER", "INVALID_NETID", subcommand, s, "Invalid network ID"},
66 }}
67 }
68 return id, nil
69}
70
71func getNetworkAttrs(network *network) irc.Tags {
72 state := "disconnected"
73 if uc := network.conn; uc != nil {
74 state = "connected"
75 }
76
77 attrs := irc.Tags{
78 "name": irc.TagValue(network.GetName()),
79 "state": irc.TagValue(state),
80 "nickname": irc.TagValue(network.Nick),
81 }
82
83 if network.Username != "" {
84 attrs["username"] = irc.TagValue(network.Username)
85 }
86 if network.Realname != "" {
87 attrs["realname"] = irc.TagValue(network.Realname)
88 }
89
90 if u, err := network.URL(); err == nil {
91 hasHostPort := true
92 switch u.Scheme {
93 case "ircs":
94 attrs["tls"] = irc.TagValue("1")
95 case "irc+insecure":
96 attrs["tls"] = irc.TagValue("0")
97 default:
98 hasHostPort = false
99 }
100 if host, port, err := net.SplitHostPort(u.Host); err == nil && hasHostPort {
101 attrs["host"] = irc.TagValue(host)
102 attrs["port"] = irc.TagValue(port)
103 } else if hasHostPort {
104 attrs["host"] = irc.TagValue(u.Host)
105 }
106 }
107
108 return attrs
109}
110
111// ' ' and ':' break the IRC message wire format, '@' and '!' break prefixes,
112// '*' and '?' break masks
113const illegalNickChars = " :@!*?"
114
115// permanentDownstreamCaps is the list of always-supported downstream
116// capabilities.
117var permanentDownstreamCaps = map[string]string{
118 "batch": "",
119 "cap-notify": "",
120 "echo-message": "",
121 "invite-notify": "",
122 "message-tags": "",
123 "sasl": "PLAIN",
124 "server-time": "",
125 "setname": "",
126
127 "soju.im/bouncer-networks": "",
128 "soju.im/bouncer-networks-notify": "",
129}
130
131// needAllDownstreamCaps is the list of downstream capabilities that
132// require support from all upstreams to be enabled
133var needAllDownstreamCaps = map[string]string{
134 "account-tag": "",
135 "away-notify": "",
136 "extended-join": "",
137 "multi-prefix": "",
138}
139
140// passthroughIsupport is the set of ISUPPORT tokens that are directly passed
141// through from the upstream server to downstream clients.
142//
143// This is only effective in single-upstream mode.
144var passthroughIsupport = map[string]bool{
145 "AWAYLEN": true,
146 "BOT": true,
147 "CHANLIMIT": true,
148 "CHANMODES": true,
149 "CHANNELLEN": true,
150 "CHANTYPES": true,
151 "EXCEPTS": true,
152 "EXTBAN": true,
153 "HOSTLEN": true,
154 "INVEX": true,
155 "KICKLEN": true,
156 "MAXLIST": true,
157 "MAXTARGETS": true,
158 "MODES": true,
159 "NAMELEN": true,
160 "NETWORK": true,
161 "NICKLEN": true,
162 "PREFIX": true,
163 "SAFELIST": true,
164 "TARGMAX": true,
165 "TOPICLEN": true,
166 "USERLEN": true,
167 "UTF8ONLY": true,
168}
169
170type downstreamConn struct {
171 conn
172
173 id uint64
174
175 registered bool
176 user *user
177 nick string
178 nickCM string
179 rawUsername string
180 networkName string
181 clientName string
182 realname string
183 hostname string
184 password string // empty after authentication
185 network *network // can be nil
186
187 negociatingCaps bool
188 capVersion int
189 supportedCaps map[string]string
190 caps map[string]bool
191
192 lastBatchRef uint64
193
194 saslServer sasl.Server
195}
196
197func newDownstreamConn(srv *Server, ic ircConn, id uint64) *downstreamConn {
198 remoteAddr := ic.RemoteAddr().String()
199 logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", remoteAddr)}
200 options := connOptions{Logger: logger}
201 dc := &downstreamConn{
202 conn: *newConn(srv, ic, &options),
203 id: id,
204 supportedCaps: make(map[string]string),
205 caps: make(map[string]bool),
206 }
207 dc.hostname = remoteAddr
208 if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
209 dc.hostname = host
210 }
211 for k, v := range permanentDownstreamCaps {
212 dc.supportedCaps[k] = v
213 }
214 if srv.LogPath != "" {
215 dc.supportedCaps["draft/chathistory"] = ""
216 }
217 return dc
218}
219
220func (dc *downstreamConn) prefix() *irc.Prefix {
221 return &irc.Prefix{
222 Name: dc.nick,
223 User: dc.user.Username,
224 Host: dc.hostname,
225 }
226}
227
228func (dc *downstreamConn) forEachNetwork(f func(*network)) {
229 if dc.network != nil {
230 f(dc.network)
231 } else if !dc.caps["soju.im/bouncer-networks"] {
232 dc.user.forEachNetwork(f)
233 }
234}
235
236func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
237 if dc.network == nil && dc.caps["soju.im/bouncer-networks"] {
238 return
239 }
240 dc.user.forEachUpstream(func(uc *upstreamConn) {
241 if dc.network != nil && uc.network != dc.network {
242 return
243 }
244 f(uc)
245 })
246}
247
248// upstream returns the upstream connection, if any. If there are zero or if
249// there are multiple upstream connections, it returns nil.
250func (dc *downstreamConn) upstream() *upstreamConn {
251 if dc.network == nil {
252 return nil
253 }
254 return dc.network.conn
255}
256
257func isOurNick(net *network, nick string) bool {
258 // TODO: this doesn't account for nick changes
259 if net.conn != nil {
260 return net.casemap(nick) == net.conn.nickCM
261 }
262 // We're not currently connected to the upstream connection, so we don't
263 // know whether this name is our nickname. Best-effort: use the network's
264 // configured nickname and hope it was the one being used when we were
265 // connected.
266 return net.casemap(nick) == net.casemap(net.Nick)
267}
268
269// marshalEntity converts an upstream entity name (ie. channel or nick) into a
270// downstream entity name.
271//
272// This involves adding a "/<network>" suffix if the entity isn't the current
273// user.
274func (dc *downstreamConn) marshalEntity(net *network, name string) string {
275 if isOurNick(net, name) {
276 return dc.nick
277 }
278 name = partialCasemap(net.casemap, name)
279 if dc.network != nil {
280 if dc.network != net {
281 panic("soju: tried to marshal an entity for another network")
282 }
283 return name
284 }
285 return name + "/" + net.GetName()
286}
287
288func (dc *downstreamConn) marshalUserPrefix(net *network, prefix *irc.Prefix) *irc.Prefix {
289 if isOurNick(net, prefix.Name) {
290 return dc.prefix()
291 }
292 prefix.Name = partialCasemap(net.casemap, prefix.Name)
293 if dc.network != nil {
294 if dc.network != net {
295 panic("soju: tried to marshal a user prefix for another network")
296 }
297 return prefix
298 }
299 return &irc.Prefix{
300 Name: prefix.Name + "/" + net.GetName(),
301 User: prefix.User,
302 Host: prefix.Host,
303 }
304}
305
306// unmarshalEntity converts a downstream entity name (ie. channel or nick) into
307// an upstream entity name.
308//
309// This involves removing the "/<network>" suffix.
310func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
311 if uc := dc.upstream(); uc != nil {
312 return uc, name, nil
313 }
314 if dc.network != nil {
315 return nil, "", ircError{&irc.Message{
316 Command: irc.ERR_NOSUCHCHANNEL,
317 Params: []string{name, "Disconnected from upstream network"},
318 }}
319 }
320
321 var conn *upstreamConn
322 if i := strings.LastIndexByte(name, '/'); i >= 0 {
323 network := name[i+1:]
324 name = name[:i]
325
326 dc.forEachUpstream(func(uc *upstreamConn) {
327 if network != uc.network.GetName() {
328 return
329 }
330 conn = uc
331 })
332 }
333
334 if conn == nil {
335 return nil, "", ircError{&irc.Message{
336 Command: irc.ERR_NOSUCHCHANNEL,
337 Params: []string{name, "Missing network suffix in channel name"},
338 }}
339 }
340 return conn, name, nil
341}
342
343func (dc *downstreamConn) unmarshalText(uc *upstreamConn, text string) string {
344 if dc.upstream() != nil {
345 return text
346 }
347 // TODO: smarter parsing that ignores URLs
348 return strings.ReplaceAll(text, "/"+uc.network.GetName(), "")
349}
350
351func (dc *downstreamConn) readMessages(ch chan<- event) error {
352 for {
353 msg, err := dc.ReadMessage()
354 if err == io.EOF {
355 break
356 } else if err != nil {
357 return fmt.Errorf("failed to read IRC command: %v", err)
358 }
359
360 ch <- eventDownstreamMessage{msg, dc}
361 }
362
363 return nil
364}
365
366// SendMessage sends an outgoing message.
367//
368// This can only called from the user goroutine.
369func (dc *downstreamConn) SendMessage(msg *irc.Message) {
370 if !dc.caps["message-tags"] {
371 if msg.Command == "TAGMSG" {
372 return
373 }
374 msg = msg.Copy()
375 for name := range msg.Tags {
376 supported := false
377 switch name {
378 case "time":
379 supported = dc.caps["server-time"]
380 case "account":
381 supported = dc.caps["account"]
382 }
383 if !supported {
384 delete(msg.Tags, name)
385 }
386 }
387 }
388 if !dc.caps["batch"] && msg.Tags["batch"] != "" {
389 msg = msg.Copy()
390 delete(msg.Tags, "batch")
391 }
392 if msg.Command == "JOIN" && !dc.caps["extended-join"] {
393 msg.Params = msg.Params[:1]
394 }
395 if msg.Command == "SETNAME" && !dc.caps["setname"] {
396 return
397 }
398
399 dc.conn.SendMessage(msg)
400}
401
402func (dc *downstreamConn) SendBatch(typ string, params []string, tags irc.Tags, f func(batchRef irc.TagValue)) {
403 dc.lastBatchRef++
404 ref := fmt.Sprintf("%v", dc.lastBatchRef)
405
406 if dc.caps["batch"] {
407 dc.SendMessage(&irc.Message{
408 Tags: tags,
409 Prefix: dc.srv.prefix(),
410 Command: "BATCH",
411 Params: append([]string{"+" + ref, typ}, params...),
412 })
413 }
414
415 f(irc.TagValue(ref))
416
417 if dc.caps["batch"] {
418 dc.SendMessage(&irc.Message{
419 Prefix: dc.srv.prefix(),
420 Command: "BATCH",
421 Params: []string{"-" + ref},
422 })
423 }
424}
425
426// sendMessageWithID sends an outgoing message with the specified internal ID.
427func (dc *downstreamConn) sendMessageWithID(msg *irc.Message, id string) {
428 dc.SendMessage(msg)
429
430 if id == "" || !dc.messageSupportsHistory(msg) {
431 return
432 }
433
434 dc.sendPing(id)
435}
436
437// advanceMessageWithID advances history to the specified message ID without
438// sending a message. This is useful e.g. for self-messages when echo-message
439// isn't enabled.
440func (dc *downstreamConn) advanceMessageWithID(msg *irc.Message, id string) {
441 if id == "" || !dc.messageSupportsHistory(msg) {
442 return
443 }
444
445 dc.sendPing(id)
446}
447
448// ackMsgID acknowledges that a message has been received.
449func (dc *downstreamConn) ackMsgID(id string) {
450 netID, entity, err := parseMsgID(id, nil)
451 if err != nil {
452 dc.logger.Printf("failed to ACK message ID %q: %v", id, err)
453 return
454 }
455
456 network := dc.user.getNetworkByID(netID)
457 if network == nil {
458 return
459 }
460
461 network.delivered.StoreID(entity, dc.clientName, id)
462}
463
464func (dc *downstreamConn) sendPing(msgID string) {
465 token := "soju-msgid-" + msgID
466 dc.SendMessage(&irc.Message{
467 Command: "PING",
468 Params: []string{token},
469 })
470}
471
472func (dc *downstreamConn) handlePong(token string) {
473 if !strings.HasPrefix(token, "soju-msgid-") {
474 dc.logger.Printf("received unrecognized PONG token %q", token)
475 return
476 }
477 msgID := strings.TrimPrefix(token, "soju-msgid-")
478 dc.ackMsgID(msgID)
479}
480
481// marshalMessage re-formats a message coming from an upstream connection so
482// that it's suitable for being sent on this downstream connection. Only
483// messages that may appear in logs are supported, except MODE.
484func (dc *downstreamConn) marshalMessage(msg *irc.Message, net *network) *irc.Message {
485 msg = msg.Copy()
486 msg.Prefix = dc.marshalUserPrefix(net, msg.Prefix)
487
488 switch msg.Command {
489 case "PRIVMSG", "NOTICE", "TAGMSG":
490 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
491 case "NICK":
492 // Nick change for another user
493 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
494 case "JOIN", "PART":
495 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
496 case "KICK":
497 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
498 msg.Params[1] = dc.marshalEntity(net, msg.Params[1])
499 case "TOPIC":
500 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
501 case "QUIT", "SETNAME":
502 // This space is intentionally left blank
503 default:
504 panic(fmt.Sprintf("unexpected %q message", msg.Command))
505 }
506
507 return msg
508}
509
510func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
511 switch msg.Command {
512 case "QUIT":
513 return dc.Close()
514 default:
515 if dc.registered {
516 return dc.handleMessageRegistered(msg)
517 } else {
518 return dc.handleMessageUnregistered(msg)
519 }
520 }
521}
522
523func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
524 switch msg.Command {
525 case "NICK":
526 var nick string
527 if err := parseMessageParams(msg, &nick); err != nil {
528 return err
529 }
530 if strings.ContainsAny(nick, illegalNickChars) {
531 return ircError{&irc.Message{
532 Command: irc.ERR_ERRONEUSNICKNAME,
533 Params: []string{dc.nick, nick, "contains illegal characters"},
534 }}
535 }
536 nickCM := casemapASCII(nick)
537 if nickCM == serviceNickCM {
538 return ircError{&irc.Message{
539 Command: irc.ERR_NICKNAMEINUSE,
540 Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
541 }}
542 }
543 dc.nick = nick
544 dc.nickCM = nickCM
545 case "USER":
546 if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
547 return err
548 }
549 case "PASS":
550 if err := parseMessageParams(msg, &dc.password); err != nil {
551 return err
552 }
553 case "CAP":
554 var subCmd string
555 if err := parseMessageParams(msg, &subCmd); err != nil {
556 return err
557 }
558 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
559 return err
560 }
561 case "AUTHENTICATE":
562 if !dc.caps["sasl"] {
563 return ircError{&irc.Message{
564 Command: irc.ERR_SASLFAIL,
565 Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
566 }}
567 }
568 if len(msg.Params) == 0 {
569 return ircError{&irc.Message{
570 Command: irc.ERR_SASLFAIL,
571 Params: []string{"*", "Missing AUTHENTICATE argument"},
572 }}
573 }
574 if dc.nick == "" {
575 return ircError{&irc.Message{
576 Command: irc.ERR_SASLFAIL,
577 Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
578 }}
579 }
580
581 var resp []byte
582 if dc.saslServer == nil {
583 mech := strings.ToUpper(msg.Params[0])
584 switch mech {
585 case "PLAIN":
586 dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
587 return dc.authenticate(username, password)
588 }))
589 default:
590 return ircError{&irc.Message{
591 Command: irc.ERR_SASLFAIL,
592 Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
593 }}
594 }
595 } else if msg.Params[0] == "*" {
596 dc.saslServer = nil
597 return ircError{&irc.Message{
598 Command: irc.ERR_SASLABORTED,
599 Params: []string{"*", "SASL authentication aborted"},
600 }}
601 } else if msg.Params[0] == "+" {
602 resp = nil
603 } else {
604 // TODO: multi-line messages
605 var err error
606 resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
607 if err != nil {
608 dc.saslServer = nil
609 return ircError{&irc.Message{
610 Command: irc.ERR_SASLFAIL,
611 Params: []string{"*", "Invalid base64-encoded response"},
612 }}
613 }
614 }
615
616 challenge, done, err := dc.saslServer.Next(resp)
617 if err != nil {
618 dc.saslServer = nil
619 if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
620 return ircError{&irc.Message{
621 Command: irc.ERR_SASLFAIL,
622 Params: []string{"*", ircErr.Message.Params[1]},
623 }}
624 }
625 dc.SendMessage(&irc.Message{
626 Prefix: dc.srv.prefix(),
627 Command: irc.ERR_SASLFAIL,
628 Params: []string{"*", "SASL error"},
629 })
630 return fmt.Errorf("SASL authentication failed: %v", err)
631 } else if done {
632 dc.saslServer = nil
633 dc.SendMessage(&irc.Message{
634 Prefix: dc.srv.prefix(),
635 Command: irc.RPL_LOGGEDIN,
636 Params: []string{dc.nick, dc.prefix().String(), dc.user.Username, "You are now logged in"},
637 })
638 dc.SendMessage(&irc.Message{
639 Prefix: dc.srv.prefix(),
640 Command: irc.RPL_SASLSUCCESS,
641 Params: []string{dc.nick, "SASL authentication successful"},
642 })
643 } else {
644 challengeStr := "+"
645 if len(challenge) > 0 {
646 challengeStr = base64.StdEncoding.EncodeToString(challenge)
647 }
648
649 // TODO: multi-line messages
650 dc.SendMessage(&irc.Message{
651 Prefix: dc.srv.prefix(),
652 Command: "AUTHENTICATE",
653 Params: []string{challengeStr},
654 })
655 }
656 case "BOUNCER":
657 var subcommand string
658 if err := parseMessageParams(msg, &subcommand); err != nil {
659 return err
660 }
661
662 switch strings.ToUpper(subcommand) {
663 case "BIND":
664 var idStr string
665 if err := parseMessageParams(msg, nil, &idStr); err != nil {
666 return err
667 }
668
669 if dc.registered {
670 return ircError{&irc.Message{
671 Command: "FAIL",
672 Params: []string{"BOUNCER", "REGISTRATION_IS_COMPLETED", "BIND", "Cannot bind bouncer network after registration"},
673 }}
674 }
675 if dc.user == nil {
676 return ircError{&irc.Message{
677 Command: "FAIL",
678 Params: []string{"BOUNCER", "ACCOUNT_REQUIRED", "BIND", "Authentication needed to bind to bouncer network"},
679 }}
680 }
681
682 id, err := parseBouncerNetID(subcommand, idStr)
683 if err != nil {
684 return err
685 }
686
687 var match *network
688 dc.user.forEachNetwork(func(net *network) {
689 if net.ID == id {
690 match = net
691 }
692 })
693 if match == nil {
694 return ircError{&irc.Message{
695 Command: "FAIL",
696 Params: []string{"BOUNCER", "INVALID_NETID", idStr, "Unknown network ID"},
697 }}
698 }
699
700 dc.networkName = match.GetName()
701 }
702 default:
703 dc.logger.Printf("unhandled message: %v", msg)
704 return newUnknownCommandError(msg.Command)
705 }
706 if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
707 return dc.register()
708 }
709 return nil
710}
711
712func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
713 cmd = strings.ToUpper(cmd)
714
715 replyTo := dc.nick
716 if !dc.registered {
717 replyTo = "*"
718 }
719
720 switch cmd {
721 case "LS":
722 if len(args) > 0 {
723 var err error
724 if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
725 return err
726 }
727 }
728 if !dc.registered && dc.capVersion >= 302 {
729 // Let downstream show everything it supports, and trim
730 // down the available capabilities when upstreams are
731 // known.
732 for k, v := range needAllDownstreamCaps {
733 dc.supportedCaps[k] = v
734 }
735 }
736
737 caps := make([]string, 0, len(dc.supportedCaps))
738 for k, v := range dc.supportedCaps {
739 if dc.capVersion >= 302 && v != "" {
740 caps = append(caps, k+"="+v)
741 } else {
742 caps = append(caps, k)
743 }
744 }
745
746 // TODO: multi-line replies
747 dc.SendMessage(&irc.Message{
748 Prefix: dc.srv.prefix(),
749 Command: "CAP",
750 Params: []string{replyTo, "LS", strings.Join(caps, " ")},
751 })
752
753 if dc.capVersion >= 302 {
754 // CAP version 302 implicitly enables cap-notify
755 dc.caps["cap-notify"] = true
756 }
757
758 if !dc.registered {
759 dc.negociatingCaps = true
760 }
761 case "LIST":
762 var caps []string
763 for name, enabled := range dc.caps {
764 if enabled {
765 caps = append(caps, name)
766 }
767 }
768
769 // TODO: multi-line replies
770 dc.SendMessage(&irc.Message{
771 Prefix: dc.srv.prefix(),
772 Command: "CAP",
773 Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
774 })
775 case "REQ":
776 if len(args) == 0 {
777 return ircError{&irc.Message{
778 Command: err_invalidcapcmd,
779 Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
780 }}
781 }
782
783 // TODO: atomically ack/nak the whole capability set
784 caps := strings.Fields(args[0])
785 ack := true
786 for _, name := range caps {
787 name = strings.ToLower(name)
788 enable := !strings.HasPrefix(name, "-")
789 if !enable {
790 name = strings.TrimPrefix(name, "-")
791 }
792
793 if enable == dc.caps[name] {
794 continue
795 }
796
797 _, ok := dc.supportedCaps[name]
798 if !ok {
799 ack = false
800 break
801 }
802
803 if name == "cap-notify" && dc.capVersion >= 302 && !enable {
804 // cap-notify cannot be disabled with CAP version 302
805 ack = false
806 break
807 }
808
809 dc.caps[name] = enable
810 }
811
812 reply := "NAK"
813 if ack {
814 reply = "ACK"
815 }
816 dc.SendMessage(&irc.Message{
817 Prefix: dc.srv.prefix(),
818 Command: "CAP",
819 Params: []string{replyTo, reply, args[0]},
820 })
821 case "END":
822 dc.negociatingCaps = false
823 default:
824 return ircError{&irc.Message{
825 Command: err_invalidcapcmd,
826 Params: []string{replyTo, cmd, "Unknown CAP command"},
827 }}
828 }
829 return nil
830}
831
832func (dc *downstreamConn) setSupportedCap(name, value string) {
833 prevValue, hasPrev := dc.supportedCaps[name]
834 changed := !hasPrev || prevValue != value
835 dc.supportedCaps[name] = value
836
837 if !dc.caps["cap-notify"] || !changed {
838 return
839 }
840
841 replyTo := dc.nick
842 if !dc.registered {
843 replyTo = "*"
844 }
845
846 cap := name
847 if value != "" && dc.capVersion >= 302 {
848 cap = name + "=" + value
849 }
850
851 dc.SendMessage(&irc.Message{
852 Prefix: dc.srv.prefix(),
853 Command: "CAP",
854 Params: []string{replyTo, "NEW", cap},
855 })
856}
857
858func (dc *downstreamConn) unsetSupportedCap(name string) {
859 _, hasPrev := dc.supportedCaps[name]
860 delete(dc.supportedCaps, name)
861 delete(dc.caps, name)
862
863 if !dc.caps["cap-notify"] || !hasPrev {
864 return
865 }
866
867 replyTo := dc.nick
868 if !dc.registered {
869 replyTo = "*"
870 }
871
872 dc.SendMessage(&irc.Message{
873 Prefix: dc.srv.prefix(),
874 Command: "CAP",
875 Params: []string{replyTo, "DEL", name},
876 })
877}
878
879func (dc *downstreamConn) updateSupportedCaps() {
880 supportedCaps := make(map[string]bool)
881 for cap := range needAllDownstreamCaps {
882 supportedCaps[cap] = true
883 }
884 dc.forEachUpstream(func(uc *upstreamConn) {
885 for cap, supported := range supportedCaps {
886 supportedCaps[cap] = supported && uc.caps[cap]
887 }
888 })
889
890 for cap, supported := range supportedCaps {
891 if supported {
892 dc.setSupportedCap(cap, needAllDownstreamCaps[cap])
893 } else {
894 dc.unsetSupportedCap(cap)
895 }
896 }
897}
898
899func (dc *downstreamConn) updateNick() {
900 if uc := dc.upstream(); uc != nil && uc.nick != dc.nick {
901 dc.SendMessage(&irc.Message{
902 Prefix: dc.prefix(),
903 Command: "NICK",
904 Params: []string{uc.nick},
905 })
906 dc.nick = uc.nick
907 dc.nickCM = casemapASCII(dc.nick)
908 }
909}
910
911func (dc *downstreamConn) updateRealname() {
912 if uc := dc.upstream(); uc != nil && uc.realname != dc.realname && dc.caps["setname"] {
913 dc.SendMessage(&irc.Message{
914 Prefix: dc.prefix(),
915 Command: "SETNAME",
916 Params: []string{uc.realname},
917 })
918 dc.realname = uc.realname
919 }
920}
921
922func sanityCheckServer(addr string) error {
923 dialer := net.Dialer{Timeout: 30 * time.Second}
924 conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
925 if err != nil {
926 return err
927 }
928 return conn.Close()
929}
930
931func unmarshalUsername(rawUsername string) (username, client, network string) {
932 username = rawUsername
933
934 i := strings.IndexAny(username, "/@")
935 j := strings.LastIndexAny(username, "/@")
936 if i >= 0 {
937 username = rawUsername[:i]
938 }
939 if j >= 0 {
940 if rawUsername[j] == '@' {
941 client = rawUsername[j+1:]
942 } else {
943 network = rawUsername[j+1:]
944 }
945 }
946 if i >= 0 && j >= 0 && i < j {
947 if rawUsername[i] == '@' {
948 client = rawUsername[i+1 : j]
949 } else {
950 network = rawUsername[i+1 : j]
951 }
952 }
953
954 return username, client, network
955}
956
957func (dc *downstreamConn) authenticate(username, password string) error {
958 username, clientName, networkName := unmarshalUsername(username)
959
960 u, err := dc.srv.db.GetUser(username)
961 if err != nil {
962 dc.logger.Printf("failed authentication for %q: user not found: %v", username, err)
963 return errAuthFailed
964 }
965
966 // Password auth disabled
967 if u.Password == "" {
968 return errAuthFailed
969 }
970
971 err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
972 if err != nil {
973 dc.logger.Printf("failed authentication for %q: wrong password: %v", username, err)
974 return errAuthFailed
975 }
976
977 dc.user = dc.srv.getUser(username)
978 if dc.user == nil {
979 dc.logger.Printf("failed authentication for %q: user not active", username)
980 return errAuthFailed
981 }
982 dc.clientName = clientName
983 dc.networkName = networkName
984 return nil
985}
986
987func (dc *downstreamConn) register() error {
988 if dc.registered {
989 return fmt.Errorf("tried to register twice")
990 }
991
992 password := dc.password
993 dc.password = ""
994 if dc.user == nil {
995 if err := dc.authenticate(dc.rawUsername, password); err != nil {
996 return err
997 }
998 }
999
1000 if dc.clientName == "" && dc.networkName == "" {
1001 _, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
1002 }
1003
1004 dc.registered = true
1005 dc.logger.Printf("registration complete for user %q", dc.user.Username)
1006 return nil
1007}
1008
1009func (dc *downstreamConn) loadNetwork() error {
1010 if dc.networkName == "" {
1011 return nil
1012 }
1013
1014 network := dc.user.getNetwork(dc.networkName)
1015 if network == nil {
1016 addr := dc.networkName
1017 if !strings.ContainsRune(addr, ':') {
1018 addr = addr + ":6697"
1019 }
1020
1021 dc.logger.Printf("trying to connect to new network %q", addr)
1022 if err := sanityCheckServer(addr); err != nil {
1023 dc.logger.Printf("failed to connect to %q: %v", addr, err)
1024 return ircError{&irc.Message{
1025 Command: irc.ERR_PASSWDMISMATCH,
1026 Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
1027 }}
1028 }
1029
1030 // Some clients only allow specifying the nickname (and use the
1031 // nickname as a username too). Strip the network name from the
1032 // nickname when auto-saving networks.
1033 nick, _, _ := unmarshalUsername(dc.nick)
1034
1035 dc.logger.Printf("auto-saving network %q", dc.networkName)
1036 var err error
1037 network, err = dc.user.createNetwork(&Network{
1038 Addr: dc.networkName,
1039 Nick: nick,
1040 Enabled: true,
1041 })
1042 if err != nil {
1043 return err
1044 }
1045 }
1046
1047 dc.network = network
1048 return nil
1049}
1050
1051func (dc *downstreamConn) welcome() error {
1052 if dc.user == nil || !dc.registered {
1053 panic("tried to welcome an unregistered connection")
1054 }
1055
1056 // TODO: doing this might take some time. We should do it in dc.register
1057 // instead, but we'll potentially be adding a new network and this must be
1058 // done in the user goroutine.
1059 if err := dc.loadNetwork(); err != nil {
1060 return err
1061 }
1062
1063 isupport := []string{
1064 fmt.Sprintf("CHATHISTORY=%v", dc.srv.HistoryLimit),
1065 "CASEMAPPING=ascii",
1066 }
1067
1068 if dc.network != nil {
1069 isupport = append(isupport, fmt.Sprintf("BOUNCER_NETID=%v", dc.network.ID))
1070 }
1071
1072 if uc := dc.upstream(); uc != nil {
1073 for k := range passthroughIsupport {
1074 v, ok := uc.isupport[k]
1075 if !ok {
1076 continue
1077 }
1078 if v != nil {
1079 isupport = append(isupport, fmt.Sprintf("%v=%v", k, *v))
1080 } else {
1081 isupport = append(isupport, k)
1082 }
1083 }
1084 }
1085
1086 dc.SendMessage(&irc.Message{
1087 Prefix: dc.srv.prefix(),
1088 Command: irc.RPL_WELCOME,
1089 Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
1090 })
1091 dc.SendMessage(&irc.Message{
1092 Prefix: dc.srv.prefix(),
1093 Command: irc.RPL_YOURHOST,
1094 Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
1095 })
1096 dc.SendMessage(&irc.Message{
1097 Prefix: dc.srv.prefix(),
1098 Command: irc.RPL_CREATED,
1099 Params: []string{dc.nick, "Who cares when the server was created?"},
1100 })
1101 dc.SendMessage(&irc.Message{
1102 Prefix: dc.srv.prefix(),
1103 Command: irc.RPL_MYINFO,
1104 Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
1105 })
1106 for _, msg := range generateIsupport(dc.srv.prefix(), dc.nick, isupport) {
1107 dc.SendMessage(msg)
1108 }
1109 motdHint := "No MOTD"
1110 if uc := dc.upstream(); uc != nil {
1111 motdHint = "Use /motd to read the message of the day"
1112 dc.SendMessage(&irc.Message{
1113 Prefix: dc.srv.prefix(),
1114 Command: irc.RPL_UMODEIS,
1115 Params: []string{dc.nick, string(uc.modes)},
1116 })
1117 }
1118 dc.SendMessage(&irc.Message{
1119 Prefix: dc.srv.prefix(),
1120 Command: irc.ERR_NOMOTD,
1121 Params: []string{dc.nick, motdHint},
1122 })
1123
1124 dc.updateNick()
1125 dc.updateRealname()
1126 dc.updateSupportedCaps()
1127
1128 if dc.caps["soju.im/bouncer-networks-notify"] {
1129 dc.SendBatch("soju.im/bouncer-networks", nil, nil, func(batchRef irc.TagValue) {
1130 dc.user.forEachNetwork(func(network *network) {
1131 idStr := fmt.Sprintf("%v", network.ID)
1132 attrs := getNetworkAttrs(network)
1133 dc.SendMessage(&irc.Message{
1134 Tags: irc.Tags{"batch": batchRef},
1135 Prefix: dc.srv.prefix(),
1136 Command: "BOUNCER",
1137 Params: []string{"NETWORK", idStr, attrs.String()},
1138 })
1139 })
1140 })
1141 }
1142
1143 dc.forEachUpstream(func(uc *upstreamConn) {
1144 for _, entry := range uc.channels.innerMap {
1145 ch := entry.value.(*upstreamChannel)
1146 if !ch.complete {
1147 continue
1148 }
1149 record := uc.network.channels.Value(ch.Name)
1150 if record != nil && record.Detached {
1151 continue
1152 }
1153
1154 dc.SendMessage(&irc.Message{
1155 Prefix: dc.prefix(),
1156 Command: "JOIN",
1157 Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
1158 })
1159
1160 forwardChannel(dc, ch)
1161 }
1162 })
1163
1164 dc.forEachNetwork(func(net *network) {
1165 if dc.caps["draft/chathistory"] || dc.user.msgStore == nil {
1166 return
1167 }
1168
1169 // Only send history if we're the first connected client with that name
1170 // for the network
1171 firstClient := true
1172 dc.user.forEachDownstream(func(c *downstreamConn) {
1173 if c != dc && c.clientName == dc.clientName && c.network == dc.network {
1174 firstClient = false
1175 }
1176 })
1177 if firstClient {
1178 net.delivered.ForEachTarget(func(target string) {
1179 lastDelivered := net.delivered.LoadID(target, dc.clientName)
1180 if lastDelivered == "" {
1181 return
1182 }
1183
1184 dc.sendTargetBacklog(net, target, lastDelivered)
1185
1186 // Fast-forward history to last message
1187 targetCM := net.casemap(target)
1188 lastID, err := dc.user.msgStore.LastMsgID(net, targetCM, time.Now())
1189 if err != nil {
1190 dc.logger.Printf("failed to get last message ID: %v", err)
1191 return
1192 }
1193 net.delivered.StoreID(target, dc.clientName, lastID)
1194 })
1195 }
1196 })
1197
1198 return nil
1199}
1200
1201// messageSupportsHistory checks whether the provided message can be sent as
1202// part of an history batch.
1203func (dc *downstreamConn) messageSupportsHistory(msg *irc.Message) bool {
1204 // Don't replay all messages, because that would mess up client
1205 // state. For instance we just sent the list of users, sending
1206 // PART messages for one of these users would be incorrect.
1207 // TODO: add support for draft/event-playback
1208 switch msg.Command {
1209 case "PRIVMSG", "NOTICE":
1210 return true
1211 }
1212 return false
1213}
1214
1215func (dc *downstreamConn) sendTargetBacklog(net *network, target, msgID string) {
1216 if dc.caps["draft/chathistory"] || dc.user.msgStore == nil {
1217 return
1218 }
1219
1220 ch := net.channels.Value(target)
1221
1222 limit := 4000
1223 targetCM := net.casemap(target)
1224 history, err := dc.user.msgStore.LoadLatestID(net, targetCM, msgID, limit)
1225 if err != nil {
1226 dc.logger.Printf("failed to send backlog for %q: %v", target, err)
1227 return
1228 }
1229
1230 dc.SendBatch("chathistory", []string{dc.marshalEntity(net, target)}, nil, func(batchRef irc.TagValue) {
1231 for _, msg := range history {
1232 if !dc.messageSupportsHistory(msg) {
1233 continue
1234 }
1235
1236 if ch != nil && ch.Detached {
1237 if net.detachedMessageNeedsRelay(ch, msg) {
1238 dc.relayDetachedMessage(net, msg)
1239 }
1240 } else {
1241 if dc.caps["batch"] {
1242 msg.Tags["batch"] = irc.TagValue(batchRef)
1243 }
1244 dc.SendMessage(dc.marshalMessage(msg, net))
1245 }
1246 }
1247 })
1248}
1249
1250func (dc *downstreamConn) relayDetachedMessage(net *network, msg *irc.Message) {
1251 if msg.Command != "PRIVMSG" && msg.Command != "NOTICE" {
1252 return
1253 }
1254
1255 sender := msg.Prefix.Name
1256 target, text := msg.Params[0], msg.Params[1]
1257 if net.isHighlight(msg) {
1258 sendServiceNOTICE(dc, fmt.Sprintf("highlight in %v: <%v> %v", dc.marshalEntity(net, target), sender, text))
1259 } else {
1260 sendServiceNOTICE(dc, fmt.Sprintf("message in %v: <%v> %v", dc.marshalEntity(net, target), sender, text))
1261 }
1262}
1263
1264func (dc *downstreamConn) runUntilRegistered() error {
1265 for !dc.registered {
1266 msg, err := dc.ReadMessage()
1267 if err != nil {
1268 return fmt.Errorf("failed to read IRC command: %v", err)
1269 }
1270
1271 err = dc.handleMessage(msg)
1272 if ircErr, ok := err.(ircError); ok {
1273 ircErr.Message.Prefix = dc.srv.prefix()
1274 dc.SendMessage(ircErr.Message)
1275 } else if err != nil {
1276 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
1277 }
1278 }
1279
1280 return nil
1281}
1282
1283func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
1284 switch msg.Command {
1285 case "CAP":
1286 var subCmd string
1287 if err := parseMessageParams(msg, &subCmd); err != nil {
1288 return err
1289 }
1290 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
1291 return err
1292 }
1293 case "PING":
1294 var source, destination string
1295 if err := parseMessageParams(msg, &source); err != nil {
1296 return err
1297 }
1298 if len(msg.Params) > 1 {
1299 destination = msg.Params[1]
1300 }
1301 if destination != "" && destination != dc.srv.Hostname {
1302 return ircError{&irc.Message{
1303 Command: irc.ERR_NOSUCHSERVER,
1304 Params: []string{dc.nick, destination, "No such server"},
1305 }}
1306 }
1307 dc.SendMessage(&irc.Message{
1308 Prefix: dc.srv.prefix(),
1309 Command: "PONG",
1310 Params: []string{dc.srv.Hostname, source},
1311 })
1312 return nil
1313 case "PONG":
1314 if len(msg.Params) == 0 {
1315 return newNeedMoreParamsError(msg.Command)
1316 }
1317 token := msg.Params[len(msg.Params)-1]
1318 dc.handlePong(token)
1319 case "USER":
1320 return ircError{&irc.Message{
1321 Command: irc.ERR_ALREADYREGISTERED,
1322 Params: []string{dc.nick, "You may not reregister"},
1323 }}
1324 case "NICK":
1325 var rawNick string
1326 if err := parseMessageParams(msg, &rawNick); err != nil {
1327 return err
1328 }
1329
1330 nick := rawNick
1331 var upstream *upstreamConn
1332 if dc.upstream() == nil {
1333 uc, unmarshaledNick, err := dc.unmarshalEntity(nick)
1334 if err == nil { // NICK nick/network: NICK only on a specific upstream
1335 upstream = uc
1336 nick = unmarshaledNick
1337 }
1338 }
1339
1340 if strings.ContainsAny(nick, illegalNickChars) {
1341 return ircError{&irc.Message{
1342 Command: irc.ERR_ERRONEUSNICKNAME,
1343 Params: []string{dc.nick, rawNick, "contains illegal characters"},
1344 }}
1345 }
1346 if casemapASCII(nick) == serviceNickCM {
1347 return ircError{&irc.Message{
1348 Command: irc.ERR_NICKNAMEINUSE,
1349 Params: []string{dc.nick, rawNick, "Nickname reserved for bouncer service"},
1350 }}
1351 }
1352
1353 var err error
1354 dc.forEachNetwork(func(n *network) {
1355 if err != nil || (upstream != nil && upstream.network != n) {
1356 return
1357 }
1358 n.Nick = nick
1359 err = dc.srv.db.StoreNetwork(dc.user.ID, &n.Network)
1360 })
1361 if err != nil {
1362 return err
1363 }
1364
1365 dc.forEachUpstream(func(uc *upstreamConn) {
1366 if upstream != nil && upstream != uc {
1367 return
1368 }
1369 uc.SendMessageLabeled(dc.id, &irc.Message{
1370 Command: "NICK",
1371 Params: []string{nick},
1372 })
1373 })
1374
1375 if dc.upstream() == nil && upstream == nil && dc.nick != nick {
1376 dc.SendMessage(&irc.Message{
1377 Prefix: dc.prefix(),
1378 Command: "NICK",
1379 Params: []string{nick},
1380 })
1381 dc.nick = nick
1382 dc.nickCM = casemapASCII(dc.nick)
1383 }
1384 case "SETNAME":
1385 var realname string
1386 if err := parseMessageParams(msg, &realname); err != nil {
1387 return err
1388 }
1389
1390 var storeErr error
1391 var needUpdate []Network
1392 dc.forEachNetwork(func(n *network) {
1393 // We only need to call updateNetwork for upstreams that don't
1394 // support setname
1395 if uc := n.conn; uc != nil && uc.caps["setname"] {
1396 uc.SendMessageLabeled(dc.id, &irc.Message{
1397 Command: "SETNAME",
1398 Params: []string{realname},
1399 })
1400
1401 n.Realname = realname
1402 if err := dc.srv.db.StoreNetwork(dc.user.ID, &n.Network); err != nil {
1403 dc.logger.Printf("failed to store network realname: %v", err)
1404 storeErr = err
1405 }
1406 return
1407 }
1408
1409 record := n.Network // copy network record because we'll mutate it
1410 record.Realname = realname
1411 needUpdate = append(needUpdate, record)
1412 })
1413
1414 // Walk the network list as a second step, because updateNetwork
1415 // mutates the original list
1416 for _, record := range needUpdate {
1417 if _, err := dc.user.updateNetwork(&record); err != nil {
1418 dc.logger.Printf("failed to update network realname: %v", err)
1419 storeErr = err
1420 }
1421 }
1422 if storeErr != nil {
1423 return ircError{&irc.Message{
1424 Command: "FAIL",
1425 Params: []string{"SETNAME", "CANNOT_CHANGE_REALNAME", "Failed to update realname"},
1426 }}
1427 }
1428
1429 if dc.upstream() == nil && dc.caps["setname"] {
1430 dc.SendMessage(&irc.Message{
1431 Prefix: dc.prefix(),
1432 Command: "SETNAME",
1433 Params: []string{realname},
1434 })
1435 }
1436 case "JOIN":
1437 var namesStr string
1438 if err := parseMessageParams(msg, &namesStr); err != nil {
1439 return err
1440 }
1441
1442 var keys []string
1443 if len(msg.Params) > 1 {
1444 keys = strings.Split(msg.Params[1], ",")
1445 }
1446
1447 for i, name := range strings.Split(namesStr, ",") {
1448 uc, upstreamName, err := dc.unmarshalEntity(name)
1449 if err != nil {
1450 return err
1451 }
1452
1453 var key string
1454 if len(keys) > i {
1455 key = keys[i]
1456 }
1457
1458 if !uc.isChannel(upstreamName) {
1459 dc.SendMessage(&irc.Message{
1460 Prefix: dc.srv.prefix(),
1461 Command: irc.ERR_NOSUCHCHANNEL,
1462 Params: []string{name, "Not a channel name"},
1463 })
1464 continue
1465 }
1466
1467 params := []string{upstreamName}
1468 if key != "" {
1469 params = append(params, key)
1470 }
1471 uc.SendMessageLabeled(dc.id, &irc.Message{
1472 Command: "JOIN",
1473 Params: params,
1474 })
1475
1476 ch := uc.network.channels.Value(upstreamName)
1477 if ch != nil {
1478 // Don't clear the channel key if there's one set
1479 // TODO: add a way to unset the channel key
1480 if key != "" {
1481 ch.Key = key
1482 }
1483 uc.network.attach(ch)
1484 } else {
1485 ch = &Channel{
1486 Name: upstreamName,
1487 Key: key,
1488 }
1489 uc.network.channels.SetValue(upstreamName, ch)
1490 }
1491 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
1492 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
1493 }
1494 }
1495 case "PART":
1496 var namesStr string
1497 if err := parseMessageParams(msg, &namesStr); err != nil {
1498 return err
1499 }
1500
1501 var reason string
1502 if len(msg.Params) > 1 {
1503 reason = msg.Params[1]
1504 }
1505
1506 for _, name := range strings.Split(namesStr, ",") {
1507 uc, upstreamName, err := dc.unmarshalEntity(name)
1508 if err != nil {
1509 return err
1510 }
1511
1512 if strings.EqualFold(reason, "detach") {
1513 ch := uc.network.channels.Value(upstreamName)
1514 if ch != nil {
1515 uc.network.detach(ch)
1516 } else {
1517 ch = &Channel{
1518 Name: name,
1519 Detached: true,
1520 }
1521 uc.network.channels.SetValue(upstreamName, ch)
1522 }
1523 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
1524 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
1525 }
1526 } else {
1527 params := []string{upstreamName}
1528 if reason != "" {
1529 params = append(params, reason)
1530 }
1531 uc.SendMessageLabeled(dc.id, &irc.Message{
1532 Command: "PART",
1533 Params: params,
1534 })
1535
1536 if err := uc.network.deleteChannel(upstreamName); err != nil {
1537 dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
1538 }
1539 }
1540 }
1541 case "KICK":
1542 var channelStr, userStr string
1543 if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
1544 return err
1545 }
1546
1547 channels := strings.Split(channelStr, ",")
1548 users := strings.Split(userStr, ",")
1549
1550 var reason string
1551 if len(msg.Params) > 2 {
1552 reason = msg.Params[2]
1553 }
1554
1555 if len(channels) != 1 && len(channels) != len(users) {
1556 return ircError{&irc.Message{
1557 Command: irc.ERR_BADCHANMASK,
1558 Params: []string{dc.nick, channelStr, "Bad channel mask"},
1559 }}
1560 }
1561
1562 for i, user := range users {
1563 var channel string
1564 if len(channels) == 1 {
1565 channel = channels[0]
1566 } else {
1567 channel = channels[i]
1568 }
1569
1570 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1571 if err != nil {
1572 return err
1573 }
1574
1575 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1576 if err != nil {
1577 return err
1578 }
1579
1580 if ucChannel != ucUser {
1581 return ircError{&irc.Message{
1582 Command: irc.ERR_USERNOTINCHANNEL,
1583 Params: []string{dc.nick, user, channel, "They are on another network"},
1584 }}
1585 }
1586 uc := ucChannel
1587
1588 params := []string{upstreamChannel, upstreamUser}
1589 if reason != "" {
1590 params = append(params, reason)
1591 }
1592 uc.SendMessageLabeled(dc.id, &irc.Message{
1593 Command: "KICK",
1594 Params: params,
1595 })
1596 }
1597 case "MODE":
1598 var name string
1599 if err := parseMessageParams(msg, &name); err != nil {
1600 return err
1601 }
1602
1603 var modeStr string
1604 if len(msg.Params) > 1 {
1605 modeStr = msg.Params[1]
1606 }
1607
1608 if casemapASCII(name) == dc.nickCM {
1609 if modeStr != "" {
1610 if uc := dc.upstream(); uc != nil {
1611 uc.SendMessageLabeled(dc.id, &irc.Message{
1612 Command: "MODE",
1613 Params: []string{uc.nick, modeStr},
1614 })
1615 } else {
1616 dc.SendMessage(&irc.Message{
1617 Prefix: dc.srv.prefix(),
1618 Command: irc.ERR_UMODEUNKNOWNFLAG,
1619 Params: []string{dc.nick, "Cannot change user mode in multi-upstream mode"},
1620 })
1621 }
1622 } else {
1623 var userMode string
1624 if uc := dc.upstream(); uc != nil {
1625 userMode = string(uc.modes)
1626 }
1627
1628 dc.SendMessage(&irc.Message{
1629 Prefix: dc.srv.prefix(),
1630 Command: irc.RPL_UMODEIS,
1631 Params: []string{dc.nick, userMode},
1632 })
1633 }
1634 return nil
1635 }
1636
1637 uc, upstreamName, err := dc.unmarshalEntity(name)
1638 if err != nil {
1639 return err
1640 }
1641
1642 if !uc.isChannel(upstreamName) {
1643 return ircError{&irc.Message{
1644 Command: irc.ERR_USERSDONTMATCH,
1645 Params: []string{dc.nick, "Cannot change mode for other users"},
1646 }}
1647 }
1648
1649 if modeStr != "" {
1650 params := []string{upstreamName, modeStr}
1651 params = append(params, msg.Params[2:]...)
1652 uc.SendMessageLabeled(dc.id, &irc.Message{
1653 Command: "MODE",
1654 Params: params,
1655 })
1656 } else {
1657 ch := uc.channels.Value(upstreamName)
1658 if ch == nil {
1659 return ircError{&irc.Message{
1660 Command: irc.ERR_NOSUCHCHANNEL,
1661 Params: []string{dc.nick, name, "No such channel"},
1662 }}
1663 }
1664
1665 if ch.modes == nil {
1666 // we haven't received the initial RPL_CHANNELMODEIS yet
1667 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
1668 return nil
1669 }
1670
1671 modeStr, modeParams := ch.modes.Format()
1672 params := []string{dc.nick, name, modeStr}
1673 params = append(params, modeParams...)
1674
1675 dc.SendMessage(&irc.Message{
1676 Prefix: dc.srv.prefix(),
1677 Command: irc.RPL_CHANNELMODEIS,
1678 Params: params,
1679 })
1680 if ch.creationTime != "" {
1681 dc.SendMessage(&irc.Message{
1682 Prefix: dc.srv.prefix(),
1683 Command: rpl_creationtime,
1684 Params: []string{dc.nick, name, ch.creationTime},
1685 })
1686 }
1687 }
1688 case "TOPIC":
1689 var channel string
1690 if err := parseMessageParams(msg, &channel); err != nil {
1691 return err
1692 }
1693
1694 uc, upstreamName, err := dc.unmarshalEntity(channel)
1695 if err != nil {
1696 return err
1697 }
1698
1699 if len(msg.Params) > 1 { // setting topic
1700 topic := msg.Params[1]
1701 uc.SendMessageLabeled(dc.id, &irc.Message{
1702 Command: "TOPIC",
1703 Params: []string{upstreamName, topic},
1704 })
1705 } else { // getting topic
1706 ch := uc.channels.Value(upstreamName)
1707 if ch == nil {
1708 return ircError{&irc.Message{
1709 Command: irc.ERR_NOSUCHCHANNEL,
1710 Params: []string{dc.nick, upstreamName, "No such channel"},
1711 }}
1712 }
1713 sendTopic(dc, ch)
1714 }
1715 case "LIST":
1716 // TODO: support ELIST when supported by all upstreams
1717
1718 pl := pendingLIST{
1719 downstreamID: dc.id,
1720 pendingCommands: make(map[int64]*irc.Message),
1721 }
1722 var upstream *upstreamConn
1723 var upstreamChannels map[int64][]string
1724 if len(msg.Params) > 0 {
1725 uc, upstreamMask, err := dc.unmarshalEntity(msg.Params[0])
1726 if err == nil && upstreamMask == "*" { // LIST */network: send LIST only to one network
1727 upstream = uc
1728 } else {
1729 upstreamChannels = make(map[int64][]string)
1730 channels := strings.Split(msg.Params[0], ",")
1731 for _, channel := range channels {
1732 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1733 if err != nil {
1734 return err
1735 }
1736 upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
1737 }
1738 }
1739 }
1740
1741 dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
1742 dc.forEachUpstream(func(uc *upstreamConn) {
1743 if upstream != nil && upstream != uc {
1744 return
1745 }
1746 var params []string
1747 if upstreamChannels != nil {
1748 if channels, ok := upstreamChannels[uc.network.ID]; ok {
1749 params = []string{strings.Join(channels, ",")}
1750 } else {
1751 return
1752 }
1753 }
1754 pl.pendingCommands[uc.network.ID] = &irc.Message{
1755 Command: "LIST",
1756 Params: params,
1757 }
1758 uc.trySendLIST(dc.id)
1759 })
1760 case "NAMES":
1761 if len(msg.Params) == 0 {
1762 dc.SendMessage(&irc.Message{
1763 Prefix: dc.srv.prefix(),
1764 Command: irc.RPL_ENDOFNAMES,
1765 Params: []string{dc.nick, "*", "End of /NAMES list"},
1766 })
1767 return nil
1768 }
1769
1770 channels := strings.Split(msg.Params[0], ",")
1771 for _, channel := range channels {
1772 uc, upstreamName, err := dc.unmarshalEntity(channel)
1773 if err != nil {
1774 return err
1775 }
1776
1777 ch := uc.channels.Value(upstreamName)
1778 if ch != nil {
1779 sendNames(dc, ch)
1780 } else {
1781 // NAMES on a channel we have not joined, ask upstream
1782 uc.SendMessageLabeled(dc.id, &irc.Message{
1783 Command: "NAMES",
1784 Params: []string{upstreamName},
1785 })
1786 }
1787 }
1788 case "WHO":
1789 if len(msg.Params) == 0 {
1790 // TODO: support WHO without parameters
1791 dc.SendMessage(&irc.Message{
1792 Prefix: dc.srv.prefix(),
1793 Command: irc.RPL_ENDOFWHO,
1794 Params: []string{dc.nick, "*", "End of /WHO list"},
1795 })
1796 return nil
1797 }
1798
1799 // TODO: support WHO masks
1800 entity := msg.Params[0]
1801 entityCM := casemapASCII(entity)
1802
1803 if dc.network == nil && entityCM == dc.nickCM {
1804 // TODO: support AWAY (H/G) in self WHO reply
1805 dc.SendMessage(&irc.Message{
1806 Prefix: dc.srv.prefix(),
1807 Command: irc.RPL_WHOREPLY,
1808 Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
1809 })
1810 dc.SendMessage(&irc.Message{
1811 Prefix: dc.srv.prefix(),
1812 Command: irc.RPL_ENDOFWHO,
1813 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
1814 })
1815 return nil
1816 }
1817 if entityCM == serviceNickCM {
1818 dc.SendMessage(&irc.Message{
1819 Prefix: dc.srv.prefix(),
1820 Command: irc.RPL_WHOREPLY,
1821 Params: []string{serviceNick, "*", servicePrefix.User, servicePrefix.Host, dc.srv.Hostname, serviceNick, "H", "0 " + serviceRealname},
1822 })
1823 dc.SendMessage(&irc.Message{
1824 Prefix: dc.srv.prefix(),
1825 Command: irc.RPL_ENDOFWHO,
1826 Params: []string{dc.nick, serviceNick, "End of /WHO list"},
1827 })
1828 return nil
1829 }
1830
1831 uc, upstreamName, err := dc.unmarshalEntity(entity)
1832 if err != nil {
1833 return err
1834 }
1835
1836 var params []string
1837 if len(msg.Params) == 2 {
1838 params = []string{upstreamName, msg.Params[1]}
1839 } else {
1840 params = []string{upstreamName}
1841 }
1842
1843 uc.SendMessageLabeled(dc.id, &irc.Message{
1844 Command: "WHO",
1845 Params: params,
1846 })
1847 case "WHOIS":
1848 if len(msg.Params) == 0 {
1849 return ircError{&irc.Message{
1850 Command: irc.ERR_NONICKNAMEGIVEN,
1851 Params: []string{dc.nick, "No nickname given"},
1852 }}
1853 }
1854
1855 var target, mask string
1856 if len(msg.Params) == 1 {
1857 target = ""
1858 mask = msg.Params[0]
1859 } else {
1860 target = msg.Params[0]
1861 mask = msg.Params[1]
1862 }
1863 // TODO: support multiple WHOIS users
1864 if i := strings.IndexByte(mask, ','); i >= 0 {
1865 mask = mask[:i]
1866 }
1867
1868 if dc.network == nil && casemapASCII(mask) == dc.nickCM {
1869 dc.SendMessage(&irc.Message{
1870 Prefix: dc.srv.prefix(),
1871 Command: irc.RPL_WHOISUSER,
1872 Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
1873 })
1874 dc.SendMessage(&irc.Message{
1875 Prefix: dc.srv.prefix(),
1876 Command: irc.RPL_WHOISSERVER,
1877 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1878 })
1879 dc.SendMessage(&irc.Message{
1880 Prefix: dc.srv.prefix(),
1881 Command: irc.RPL_ENDOFWHOIS,
1882 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1883 })
1884 return nil
1885 }
1886
1887 // TODO: support WHOIS masks
1888 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1889 if err != nil {
1890 return err
1891 }
1892
1893 var params []string
1894 if target != "" {
1895 if target == mask { // WHOIS nick nick
1896 params = []string{upstreamNick, upstreamNick}
1897 } else {
1898 params = []string{target, upstreamNick}
1899 }
1900 } else {
1901 params = []string{upstreamNick}
1902 }
1903
1904 uc.SendMessageLabeled(dc.id, &irc.Message{
1905 Command: "WHOIS",
1906 Params: params,
1907 })
1908 case "PRIVMSG", "NOTICE":
1909 var targetsStr, text string
1910 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1911 return err
1912 }
1913 tags := copyClientTags(msg.Tags)
1914
1915 for _, name := range strings.Split(targetsStr, ",") {
1916 if dc.network == nil && casemapASCII(name) == dc.nickCM {
1917 dc.SendMessage(msg)
1918 continue
1919 }
1920
1921 if msg.Command == "PRIVMSG" && casemapASCII(name) == serviceNickCM {
1922 if dc.caps["echo-message"] {
1923 echoTags := tags.Copy()
1924 echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
1925 dc.SendMessage(&irc.Message{
1926 Tags: echoTags,
1927 Prefix: dc.prefix(),
1928 Command: msg.Command,
1929 Params: []string{name, text},
1930 })
1931 }
1932 handleServicePRIVMSG(dc, text)
1933 continue
1934 }
1935
1936 uc, upstreamName, err := dc.unmarshalEntity(name)
1937 if err != nil {
1938 return err
1939 }
1940
1941 if msg.Command == "PRIVMSG" && uc.network.casemap(upstreamName) == "nickserv" {
1942 dc.handleNickServPRIVMSG(uc, text)
1943 }
1944
1945 unmarshaledText := text
1946 if uc.isChannel(upstreamName) {
1947 unmarshaledText = dc.unmarshalText(uc, text)
1948 }
1949 uc.SendMessageLabeled(dc.id, &irc.Message{
1950 Tags: tags,
1951 Command: msg.Command,
1952 Params: []string{upstreamName, unmarshaledText},
1953 })
1954
1955 echoTags := tags.Copy()
1956 echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
1957 if uc.account != "" {
1958 echoTags["account"] = irc.TagValue(uc.account)
1959 }
1960 echoMsg := &irc.Message{
1961 Tags: echoTags,
1962 Prefix: &irc.Prefix{
1963 Name: uc.nick,
1964 User: uc.username,
1965 },
1966 Command: msg.Command,
1967 Params: []string{upstreamName, text},
1968 }
1969 uc.produce(upstreamName, echoMsg, dc)
1970
1971 uc.updateChannelAutoDetach(upstreamName)
1972 }
1973 case "TAGMSG":
1974 var targetsStr string
1975 if err := parseMessageParams(msg, &targetsStr); err != nil {
1976 return err
1977 }
1978 tags := copyClientTags(msg.Tags)
1979
1980 for _, name := range strings.Split(targetsStr, ",") {
1981 uc, upstreamName, err := dc.unmarshalEntity(name)
1982 if err != nil {
1983 return err
1984 }
1985 if _, ok := uc.caps["message-tags"]; !ok {
1986 continue
1987 }
1988
1989 uc.SendMessageLabeled(dc.id, &irc.Message{
1990 Tags: tags,
1991 Command: "TAGMSG",
1992 Params: []string{upstreamName},
1993 })
1994
1995 uc.updateChannelAutoDetach(upstreamName)
1996 }
1997 case "INVITE":
1998 var user, channel string
1999 if err := parseMessageParams(msg, &user, &channel); err != nil {
2000 return err
2001 }
2002
2003 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
2004 if err != nil {
2005 return err
2006 }
2007
2008 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
2009 if err != nil {
2010 return err
2011 }
2012
2013 if ucChannel != ucUser {
2014 return ircError{&irc.Message{
2015 Command: irc.ERR_USERNOTINCHANNEL,
2016 Params: []string{dc.nick, user, channel, "They are on another network"},
2017 }}
2018 }
2019 uc := ucChannel
2020
2021 uc.SendMessageLabeled(dc.id, &irc.Message{
2022 Command: "INVITE",
2023 Params: []string{upstreamUser, upstreamChannel},
2024 })
2025 case "CHATHISTORY":
2026 var subcommand string
2027 if err := parseMessageParams(msg, &subcommand); err != nil {
2028 return err
2029 }
2030 var target, limitStr string
2031 var boundsStr [2]string
2032 switch subcommand {
2033 case "AFTER", "BEFORE":
2034 if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &limitStr); err != nil {
2035 return err
2036 }
2037 case "BETWEEN":
2038 if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &boundsStr[1], &limitStr); err != nil {
2039 return err
2040 }
2041 case "TARGETS":
2042 if err := parseMessageParams(msg, nil, &boundsStr[0], &boundsStr[1], &limitStr); err != nil {
2043 return err
2044 }
2045 default:
2046 // TODO: support LATEST, AROUND
2047 return ircError{&irc.Message{
2048 Command: "FAIL",
2049 Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, "Unknown command"},
2050 }}
2051 }
2052
2053 store, ok := dc.user.msgStore.(chatHistoryMessageStore)
2054 if !ok {
2055 return ircError{&irc.Message{
2056 Command: irc.ERR_UNKNOWNCOMMAND,
2057 Params: []string{dc.nick, "CHATHISTORY", "Unknown command"},
2058 }}
2059 }
2060
2061 uc, entity, err := dc.unmarshalEntity(target)
2062 if err != nil {
2063 return err
2064 }
2065 entity = uc.network.casemap(entity)
2066
2067 // TODO: support msgid criteria
2068 var bounds [2]time.Time
2069 bounds[0] = parseChatHistoryBound(boundsStr[0])
2070 if bounds[0].IsZero() {
2071 return ircError{&irc.Message{
2072 Command: "FAIL",
2073 Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[0], "Invalid first bound"},
2074 }}
2075 }
2076
2077 if boundsStr[1] != "" {
2078 bounds[1] = parseChatHistoryBound(boundsStr[1])
2079 if bounds[1].IsZero() {
2080 return ircError{&irc.Message{
2081 Command: "FAIL",
2082 Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[1], "Invalid second bound"},
2083 }}
2084 }
2085 }
2086
2087 limit, err := strconv.Atoi(limitStr)
2088 if err != nil || limit < 0 || limit > dc.srv.HistoryLimit {
2089 return ircError{&irc.Message{
2090 Command: "FAIL",
2091 Params: []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, limitStr, "Invalid limit"},
2092 }}
2093 }
2094
2095 var history []*irc.Message
2096 switch subcommand {
2097 case "BEFORE":
2098 history, err = store.LoadBeforeTime(uc.network, entity, bounds[0], time.Time{}, limit)
2099 case "AFTER":
2100 history, err = store.LoadAfterTime(uc.network, entity, bounds[0], time.Now(), limit)
2101 case "BETWEEN":
2102 if bounds[0].Before(bounds[1]) {
2103 history, err = store.LoadAfterTime(uc.network, entity, bounds[0], bounds[1], limit)
2104 } else {
2105 history, err = store.LoadBeforeTime(uc.network, entity, bounds[0], bounds[1], limit)
2106 }
2107 case "TARGETS":
2108 // TODO: support TARGETS in multi-upstream mode
2109 targets, err := store.ListTargets(uc.network, bounds[0], bounds[1], limit)
2110 if err != nil {
2111 dc.logger.Printf("failed fetching targets for chathistory: %v", target, err)
2112 return ircError{&irc.Message{
2113 Command: "FAIL",
2114 Params: []string{"CHATHISTORY", "MESSAGE_ERROR", subcommand, "Failed to retrieve targets"},
2115 }}
2116 }
2117
2118 dc.SendBatch("draft/chathistory-targets", nil, nil, func(batchRef irc.TagValue) {
2119 for _, target := range targets {
2120 if ch := uc.network.channels.Value(target.Name); ch != nil && ch.Detached {
2121 continue
2122 }
2123
2124 dc.SendMessage(&irc.Message{
2125 Tags: irc.Tags{"batch": batchRef},
2126 Prefix: dc.srv.prefix(),
2127 Command: "CHATHISTORY",
2128 Params: []string{"TARGETS", target.Name, target.LatestMessage.UTC().Format(serverTimeLayout)},
2129 })
2130 }
2131 })
2132
2133 return nil
2134 }
2135 if err != nil {
2136 dc.logger.Printf("failed fetching %q messages for chathistory: %v", target, err)
2137 return newChatHistoryError(subcommand, target)
2138 }
2139
2140 dc.SendBatch("chathistory", []string{target}, nil, func(batchRef irc.TagValue) {
2141 for _, msg := range history {
2142 msg.Tags["batch"] = batchRef
2143 dc.SendMessage(dc.marshalMessage(msg, uc.network))
2144 }
2145 })
2146 case "BOUNCER":
2147 var subcommand string
2148 if err := parseMessageParams(msg, &subcommand); err != nil {
2149 return err
2150 }
2151
2152 switch strings.ToUpper(subcommand) {
2153 case "LISTNETWORKS":
2154 dc.SendBatch("soju.im/bouncer-networks", nil, nil, func(batchRef irc.TagValue) {
2155 dc.user.forEachNetwork(func(network *network) {
2156 idStr := fmt.Sprintf("%v", network.ID)
2157 attrs := getNetworkAttrs(network)
2158 dc.SendMessage(&irc.Message{
2159 Tags: irc.Tags{"batch": batchRef},
2160 Prefix: dc.srv.prefix(),
2161 Command: "BOUNCER",
2162 Params: []string{"NETWORK", idStr, attrs.String()},
2163 })
2164 })
2165 })
2166 case "ADDNETWORK":
2167 var attrsStr string
2168 if err := parseMessageParams(msg, nil, &attrsStr); err != nil {
2169 return err
2170 }
2171 attrs := irc.ParseTags(attrsStr)
2172
2173 host, ok := attrs.GetTag("host")
2174 if !ok {
2175 return ircError{&irc.Message{
2176 Command: "FAIL",
2177 Params: []string{"BOUNCER", "NEED_ATTRIBUTE", subcommand, "host", "Missing required host attribute"},
2178 }}
2179 }
2180
2181 addr := host
2182 if port, ok := attrs.GetTag("port"); ok {
2183 addr += ":" + port
2184 }
2185
2186 if tlsStr, ok := attrs.GetTag("tls"); ok && tlsStr == "0" {
2187 addr = "irc+insecure://" + tlsStr
2188 }
2189
2190 nick, ok := attrs.GetTag("nickname")
2191 if !ok {
2192 nick = dc.nick
2193 }
2194
2195 username, _ := attrs.GetTag("username")
2196 realname, _ := attrs.GetTag("realname")
2197 pass, _ := attrs.GetTag("pass")
2198
2199 // TODO: reject unknown attributes
2200
2201 record := &Network{
2202 Addr: addr,
2203 Nick: nick,
2204 Username: username,
2205 Realname: realname,
2206 Pass: pass,
2207 Enabled: true,
2208 }
2209 network, err := dc.user.createNetwork(record)
2210 if err != nil {
2211 return ircError{&irc.Message{
2212 Command: "FAIL",
2213 Params: []string{"BOUNCER", "UNKNOWN_ERROR", subcommand, fmt.Sprintf("Failed to create network: %v", err)},
2214 }}
2215 }
2216
2217 dc.SendMessage(&irc.Message{
2218 Prefix: dc.srv.prefix(),
2219 Command: "BOUNCER",
2220 Params: []string{"ADDNETWORK", fmt.Sprintf("%v", network.ID)},
2221 })
2222 case "CHANGENETWORK":
2223 var idStr, attrsStr string
2224 if err := parseMessageParams(msg, nil, &idStr, &attrsStr); err != nil {
2225 return err
2226 }
2227 id, err := parseBouncerNetID(subcommand, idStr)
2228 if err != nil {
2229 return err
2230 }
2231 attrs := irc.ParseTags(attrsStr)
2232
2233 net := dc.user.getNetworkByID(id)
2234 if net == nil {
2235 return ircError{&irc.Message{
2236 Command: "FAIL",
2237 Params: []string{"BOUNCER", "INVALID_NETID", subcommand, idStr, "Invalid network ID"},
2238 }}
2239 }
2240
2241 record := net.Network // copy network record because we'll mutate it
2242 for k, v := range attrs {
2243 s := string(v)
2244 switch k {
2245 // TODO: host, port, tls
2246 case "nickname":
2247 record.Nick = s
2248 case "username":
2249 record.Username = s
2250 case "realname":
2251 record.Realname = s
2252 case "pass":
2253 record.Pass = s
2254 default:
2255 return ircError{&irc.Message{
2256 Command: "FAIL",
2257 Params: []string{"BOUNCER", "UNKNOWN_ATTRIBUTE", subcommand, k, "Unknown attribute"},
2258 }}
2259 }
2260 }
2261
2262 _, err = dc.user.updateNetwork(&record)
2263 if err != nil {
2264 return ircError{&irc.Message{
2265 Command: "FAIL",
2266 Params: []string{"BOUNCER", "UNKNOWN_ERROR", subcommand, fmt.Sprintf("Failed to update network: %v", err)},
2267 }}
2268 }
2269
2270 dc.SendMessage(&irc.Message{
2271 Prefix: dc.srv.prefix(),
2272 Command: "BOUNCER",
2273 Params: []string{"CHANGENETWORK", idStr},
2274 })
2275 case "DELNETWORK":
2276 var idStr string
2277 if err := parseMessageParams(msg, nil, &idStr); err != nil {
2278 return err
2279 }
2280 id, err := parseBouncerNetID(subcommand, idStr)
2281 if err != nil {
2282 return err
2283 }
2284
2285 net := dc.user.getNetworkByID(id)
2286 if net == nil {
2287 return ircError{&irc.Message{
2288 Command: "FAIL",
2289 Params: []string{"BOUNCER", "INVALID_NETID", subcommand, idStr, "Invalid network ID"},
2290 }}
2291 }
2292
2293 if err := dc.user.deleteNetwork(net.ID); err != nil {
2294 return err
2295 }
2296
2297 dc.SendMessage(&irc.Message{
2298 Prefix: dc.srv.prefix(),
2299 Command: "BOUNCER",
2300 Params: []string{"DELNETWORK", idStr},
2301 })
2302 default:
2303 return ircError{&irc.Message{
2304 Command: "FAIL",
2305 Params: []string{"BOUNCER", "UNKNOWN_COMMAND", subcommand, "Unknown subcommand"},
2306 }}
2307 }
2308 default:
2309 dc.logger.Printf("unhandled message: %v", msg)
2310
2311 // Only forward unknown commands in single-upstream mode
2312 uc := dc.upstream()
2313 if uc == nil {
2314 return newUnknownCommandError(msg.Command)
2315 }
2316
2317 uc.SendMessageLabeled(dc.id, msg)
2318 }
2319 return nil
2320}
2321
2322func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
2323 username, password, ok := parseNickServCredentials(text, uc.nick)
2324 if !ok {
2325 return
2326 }
2327
2328 // User may have e.g. EXTERNAL mechanism configured. We do not want to
2329 // automatically erase the key pair or any other credentials.
2330 if uc.network.SASL.Mechanism != "" && uc.network.SASL.Mechanism != "PLAIN" {
2331 return
2332 }
2333
2334 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
2335 n := uc.network
2336 n.SASL.Mechanism = "PLAIN"
2337 n.SASL.Plain.Username = username
2338 n.SASL.Plain.Password = password
2339 if err := dc.srv.db.StoreNetwork(dc.user.ID, &n.Network); err != nil {
2340 dc.logger.Printf("failed to save NickServ credentials: %v", err)
2341 }
2342}
2343
2344func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
2345 fields := strings.Fields(text)
2346 if len(fields) < 2 {
2347 return "", "", false
2348 }
2349 cmd := strings.ToUpper(fields[0])
2350 params := fields[1:]
2351 switch cmd {
2352 case "REGISTER":
2353 username = nick
2354 password = params[0]
2355 case "IDENTIFY":
2356 if len(params) == 1 {
2357 username = nick
2358 password = params[0]
2359 } else {
2360 username = params[0]
2361 password = params[1]
2362 }
2363 case "SET":
2364 if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
2365 username = nick
2366 password = params[1]
2367 }
2368 default:
2369 return "", "", false
2370 }
2371 return username, password, true
2372}
Note: See TracBrowser for help on using the repository browser.