source: code/trunk/downstream.go@ 650

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

Remove incorrect AWAY TODO in downstreamConn.SendMessage

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