source: code/trunk/downstream.go@ 648

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

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