source: code/trunk/downstream.go@ 403

Last change on this file since 403 was 401, checked in by hubert, 5 years ago

More explicit error message on INVITE with the wrong network
File size: 40.7 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
60// permanentDownstreamCaps is the list of always-supported downstream
61// capabilities.
62var permanentDownstreamCaps = map[string]string{
63 "batch": "",
64 "cap-notify": "",
65 "echo-message": "",
66 "message-tags": "",
67 "sasl": "PLAIN",
68 "server-time": "",
69}
70
71// needAllDownstreamCaps is the list of downstream capabilities that
72// require support from all upstreams to be enabled
73var needAllDownstreamCaps = map[string]string{
74 "away-notify": "",
75 "multi-prefix": "",
76}
77
78type downstreamConn struct {
79 conn
80
81 id uint64
82
83 registered bool
84 user *user
85 nick string
86 rawUsername string
87 networkName string
88 clientName string
89 realname string
90 hostname string
91 password string // empty after authentication
92 network *network // can be nil
93
94 negociatingCaps bool
95 capVersion int
96 supportedCaps map[string]string
97 caps map[string]bool
98
99 saslServer sasl.Server
100}
101
102func newDownstreamConn(srv *Server, ic ircConn, id uint64) *downstreamConn {
103 remoteAddr := ic.RemoteAddr().String()
104 logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", remoteAddr)}
105 options := connOptions{Logger: logger}
106 dc := &downstreamConn{
107 conn: *newConn(srv, ic, &options),
108 id: id,
109 supportedCaps: make(map[string]string),
110 caps: make(map[string]bool),
111 }
112 dc.hostname = remoteAddr
113 if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
114 dc.hostname = host
115 }
116 for k, v := range permanentDownstreamCaps {
117 dc.supportedCaps[k] = v
118 }
119 if srv.LogPath != "" {
120 dc.supportedCaps["draft/chathistory"] = ""
121 }
122 return dc
123}
124
125func (dc *downstreamConn) prefix() *irc.Prefix {
126 return &irc.Prefix{
127 Name: dc.nick,
128 User: dc.user.Username,
129 Host: dc.hostname,
130 }
131}
132
133func (dc *downstreamConn) forEachNetwork(f func(*network)) {
134 if dc.network != nil {
135 f(dc.network)
136 } else {
137 dc.user.forEachNetwork(f)
138 }
139}
140
141func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
142 dc.user.forEachUpstream(func(uc *upstreamConn) {
143 if dc.network != nil && uc.network != dc.network {
144 return
145 }
146 f(uc)
147 })
148}
149
150// upstream returns the upstream connection, if any. If there are zero or if
151// there are multiple upstream connections, it returns nil.
152func (dc *downstreamConn) upstream() *upstreamConn {
153 if dc.network == nil {
154 return nil
155 }
156 return dc.network.conn
157}
158
159func isOurNick(net *network, nick string) bool {
160 // TODO: this doesn't account for nick changes
161 if net.conn != nil {
162 return nick == net.conn.nick
163 }
164 // We're not currently connected to the upstream connection, so we don't
165 // know whether this name is our nickname. Best-effort: use the network's
166 // configured nickname and hope it was the one being used when we were
167 // connected.
168 return nick == net.Nick
169}
170
171// marshalEntity converts an upstream entity name (ie. channel or nick) into a
172// downstream entity name.
173//
174// This involves adding a "/<network>" suffix if the entity isn't the current
175// user.
176func (dc *downstreamConn) marshalEntity(net *network, name string) string {
177 if isOurNick(net, name) {
178 return dc.nick
179 }
180 if dc.network != nil {
181 if dc.network != net {
182 panic("soju: tried to marshal an entity for another network")
183 }
184 return name
185 }
186 return name + "/" + net.GetName()
187}
188
189func (dc *downstreamConn) marshalUserPrefix(net *network, prefix *irc.Prefix) *irc.Prefix {
190 if isOurNick(net, prefix.Name) {
191 return dc.prefix()
192 }
193 if dc.network != nil {
194 if dc.network != net {
195 panic("soju: tried to marshal a user prefix for another network")
196 }
197 return prefix
198 }
199 return &irc.Prefix{
200 Name: prefix.Name + "/" + net.GetName(),
201 User: prefix.User,
202 Host: prefix.Host,
203 }
204}
205
206// unmarshalEntity converts a downstream entity name (ie. channel or nick) into
207// an upstream entity name.
208//
209// This involves removing the "/<network>" suffix.
210func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
211 if uc := dc.upstream(); uc != nil {
212 return uc, name, nil
213 }
214
215 var conn *upstreamConn
216 if i := strings.LastIndexByte(name, '/'); i >= 0 {
217 network := name[i+1:]
218 name = name[:i]
219
220 dc.forEachUpstream(func(uc *upstreamConn) {
221 if network != uc.network.GetName() {
222 return
223 }
224 conn = uc
225 })
226 }
227
228 if conn == nil {
229 return nil, "", ircError{&irc.Message{
230 Command: irc.ERR_NOSUCHCHANNEL,
231 Params: []string{name, "No such channel"},
232 }}
233 }
234 return conn, name, nil
235}
236
237func (dc *downstreamConn) unmarshalText(uc *upstreamConn, text string) string {
238 if dc.upstream() != nil {
239 return text
240 }
241 // TODO: smarter parsing that ignores URLs
242 return strings.ReplaceAll(text, "/"+uc.network.GetName(), "")
243}
244
245func (dc *downstreamConn) readMessages(ch chan<- event) error {
246 for {
247 msg, err := dc.ReadMessage()
248 if err == io.EOF {
249 break
250 } else if err != nil {
251 return fmt.Errorf("failed to read IRC command: %v", err)
252 }
253
254 ch <- eventDownstreamMessage{msg, dc}
255 }
256
257 return nil
258}
259
260// SendMessage sends an outgoing message.
261//
262// This can only called from the user goroutine.
263func (dc *downstreamConn) SendMessage(msg *irc.Message) {
264 if !dc.caps["message-tags"] {
265 if msg.Command == "TAGMSG" {
266 return
267 }
268 msg = msg.Copy()
269 for name := range msg.Tags {
270 supported := false
271 switch name {
272 case "time":
273 supported = dc.caps["server-time"]
274 }
275 if !supported {
276 delete(msg.Tags, name)
277 }
278 }
279 }
280
281 dc.conn.SendMessage(msg)
282}
283
284// marshalMessage re-formats a message coming from an upstream connection so
285// that it's suitable for being sent on this downstream connection. Only
286// messages that may appear in logs are supported, except MODE.
287func (dc *downstreamConn) marshalMessage(msg *irc.Message, net *network) *irc.Message {
288 msg = msg.Copy()
289 msg.Prefix = dc.marshalUserPrefix(net, msg.Prefix)
290
291 switch msg.Command {
292 case "PRIVMSG", "NOTICE", "TAGMSG":
293 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
294 case "NICK":
295 // Nick change for another user
296 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
297 case "JOIN", "PART":
298 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
299 case "KICK":
300 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
301 msg.Params[1] = dc.marshalEntity(net, msg.Params[1])
302 case "TOPIC":
303 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
304 case "QUIT":
305 // This space is intentionally left blank
306 default:
307 panic(fmt.Sprintf("unexpected %q message", msg.Command))
308 }
309
310 return msg
311}
312
313func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
314 switch msg.Command {
315 case "QUIT":
316 return dc.Close()
317 default:
318 if dc.registered {
319 return dc.handleMessageRegistered(msg)
320 } else {
321 return dc.handleMessageUnregistered(msg)
322 }
323 }
324}
325
326func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
327 switch msg.Command {
328 case "NICK":
329 var nick string
330 if err := parseMessageParams(msg, &nick); err != nil {
331 return err
332 }
333 if nick == serviceNick {
334 return ircError{&irc.Message{
335 Command: irc.ERR_NICKNAMEINUSE,
336 Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
337 }}
338 }
339 dc.nick = nick
340 case "USER":
341 if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
342 return err
343 }
344 case "PASS":
345 if err := parseMessageParams(msg, &dc.password); err != nil {
346 return err
347 }
348 case "CAP":
349 var subCmd string
350 if err := parseMessageParams(msg, &subCmd); err != nil {
351 return err
352 }
353 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
354 return err
355 }
356 case "AUTHENTICATE":
357 if !dc.caps["sasl"] {
358 return ircError{&irc.Message{
359 Command: irc.ERR_SASLFAIL,
360 Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
361 }}
362 }
363 if len(msg.Params) == 0 {
364 return ircError{&irc.Message{
365 Command: irc.ERR_SASLFAIL,
366 Params: []string{"*", "Missing AUTHENTICATE argument"},
367 }}
368 }
369 if dc.nick == "" {
370 return ircError{&irc.Message{
371 Command: irc.ERR_SASLFAIL,
372 Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
373 }}
374 }
375
376 var resp []byte
377 if dc.saslServer == nil {
378 mech := strings.ToUpper(msg.Params[0])
379 switch mech {
380 case "PLAIN":
381 dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
382 return dc.authenticate(username, password)
383 }))
384 default:
385 return ircError{&irc.Message{
386 Command: irc.ERR_SASLFAIL,
387 Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
388 }}
389 }
390 } else if msg.Params[0] == "*" {
391 dc.saslServer = nil
392 return ircError{&irc.Message{
393 Command: irc.ERR_SASLABORTED,
394 Params: []string{"*", "SASL authentication aborted"},
395 }}
396 } else if msg.Params[0] == "+" {
397 resp = nil
398 } else {
399 // TODO: multi-line messages
400 var err error
401 resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
402 if err != nil {
403 dc.saslServer = nil
404 return ircError{&irc.Message{
405 Command: irc.ERR_SASLFAIL,
406 Params: []string{"*", "Invalid base64-encoded response"},
407 }}
408 }
409 }
410
411 challenge, done, err := dc.saslServer.Next(resp)
412 if err != nil {
413 dc.saslServer = nil
414 if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
415 return ircError{&irc.Message{
416 Command: irc.ERR_SASLFAIL,
417 Params: []string{"*", ircErr.Message.Params[1]},
418 }}
419 }
420 dc.SendMessage(&irc.Message{
421 Prefix: dc.srv.prefix(),
422 Command: irc.ERR_SASLFAIL,
423 Params: []string{"*", "SASL error"},
424 })
425 return fmt.Errorf("SASL authentication failed: %v", err)
426 } else if done {
427 dc.saslServer = nil
428 dc.SendMessage(&irc.Message{
429 Prefix: dc.srv.prefix(),
430 Command: irc.RPL_LOGGEDIN,
431 Params: []string{dc.nick, dc.prefix().String(), dc.user.Username, "You are now logged in"},
432 })
433 dc.SendMessage(&irc.Message{
434 Prefix: dc.srv.prefix(),
435 Command: irc.RPL_SASLSUCCESS,
436 Params: []string{dc.nick, "SASL authentication successful"},
437 })
438 } else {
439 challengeStr := "+"
440 if len(challenge) > 0 {
441 challengeStr = base64.StdEncoding.EncodeToString(challenge)
442 }
443
444 // TODO: multi-line messages
445 dc.SendMessage(&irc.Message{
446 Prefix: dc.srv.prefix(),
447 Command: "AUTHENTICATE",
448 Params: []string{challengeStr},
449 })
450 }
451 default:
452 dc.logger.Printf("unhandled message: %v", msg)
453 return newUnknownCommandError(msg.Command)
454 }
455 if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
456 return dc.register()
457 }
458 return nil
459}
460
461func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
462 cmd = strings.ToUpper(cmd)
463
464 replyTo := dc.nick
465 if !dc.registered {
466 replyTo = "*"
467 }
468
469 switch cmd {
470 case "LS":
471 if len(args) > 0 {
472 var err error
473 if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
474 return err
475 }
476 }
477
478 caps := make([]string, 0, len(dc.supportedCaps))
479 for k, v := range dc.supportedCaps {
480 if dc.capVersion >= 302 && v != "" {
481 caps = append(caps, k+"="+v)
482 } else {
483 caps = append(caps, k)
484 }
485 }
486
487 // TODO: multi-line replies
488 dc.SendMessage(&irc.Message{
489 Prefix: dc.srv.prefix(),
490 Command: "CAP",
491 Params: []string{replyTo, "LS", strings.Join(caps, " ")},
492 })
493
494 if dc.capVersion >= 302 {
495 // CAP version 302 implicitly enables cap-notify
496 dc.caps["cap-notify"] = true
497 }
498
499 if !dc.registered {
500 dc.negociatingCaps = true
501 }
502 case "LIST":
503 var caps []string
504 for name := range dc.caps {
505 caps = append(caps, name)
506 }
507
508 // TODO: multi-line replies
509 dc.SendMessage(&irc.Message{
510 Prefix: dc.srv.prefix(),
511 Command: "CAP",
512 Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
513 })
514 case "REQ":
515 if len(args) == 0 {
516 return ircError{&irc.Message{
517 Command: err_invalidcapcmd,
518 Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
519 }}
520 }
521
522 // TODO: atomically ack/nak the whole capability set
523 caps := strings.Fields(args[0])
524 ack := true
525 for _, name := range caps {
526 name = strings.ToLower(name)
527 enable := !strings.HasPrefix(name, "-")
528 if !enable {
529 name = strings.TrimPrefix(name, "-")
530 }
531
532 if enable == dc.caps[name] {
533 continue
534 }
535
536 _, ok := dc.supportedCaps[name]
537 if !ok {
538 ack = false
539 break
540 }
541
542 if name == "cap-notify" && dc.capVersion >= 302 && !enable {
543 // cap-notify cannot be disabled with CAP version 302
544 ack = false
545 break
546 }
547
548 dc.caps[name] = enable
549 }
550
551 reply := "NAK"
552 if ack {
553 reply = "ACK"
554 }
555 dc.SendMessage(&irc.Message{
556 Prefix: dc.srv.prefix(),
557 Command: "CAP",
558 Params: []string{replyTo, reply, args[0]},
559 })
560 case "END":
561 dc.negociatingCaps = false
562 default:
563 return ircError{&irc.Message{
564 Command: err_invalidcapcmd,
565 Params: []string{replyTo, cmd, "Unknown CAP command"},
566 }}
567 }
568 return nil
569}
570
571func (dc *downstreamConn) setSupportedCap(name, value string) {
572 prevValue, hasPrev := dc.supportedCaps[name]
573 changed := !hasPrev || prevValue != value
574 dc.supportedCaps[name] = value
575
576 if !dc.caps["cap-notify"] || !changed {
577 return
578 }
579
580 replyTo := dc.nick
581 if !dc.registered {
582 replyTo = "*"
583 }
584
585 cap := name
586 if value != "" && dc.capVersion >= 302 {
587 cap = name + "=" + value
588 }
589
590 dc.SendMessage(&irc.Message{
591 Prefix: dc.srv.prefix(),
592 Command: "CAP",
593 Params: []string{replyTo, "NEW", cap},
594 })
595}
596
597func (dc *downstreamConn) unsetSupportedCap(name string) {
598 _, hasPrev := dc.supportedCaps[name]
599 delete(dc.supportedCaps, name)
600 delete(dc.caps, name)
601
602 if !dc.caps["cap-notify"] || !hasPrev {
603 return
604 }
605
606 replyTo := dc.nick
607 if !dc.registered {
608 replyTo = "*"
609 }
610
611 dc.SendMessage(&irc.Message{
612 Prefix: dc.srv.prefix(),
613 Command: "CAP",
614 Params: []string{replyTo, "DEL", name},
615 })
616}
617
618func (dc *downstreamConn) updateSupportedCaps() {
619 supportedCaps := make(map[string]bool)
620 for cap := range needAllDownstreamCaps {
621 supportedCaps[cap] = true
622 }
623 dc.forEachUpstream(func(uc *upstreamConn) {
624 for cap, supported := range supportedCaps {
625 supportedCaps[cap] = supported && uc.caps[cap]
626 }
627 })
628
629 for cap, supported := range supportedCaps {
630 if supported {
631 dc.setSupportedCap(cap, needAllDownstreamCaps[cap])
632 } else {
633 dc.unsetSupportedCap(cap)
634 }
635 }
636}
637
638func (dc *downstreamConn) updateNick() {
639 if uc := dc.upstream(); uc != nil && uc.nick != dc.nick {
640 dc.SendMessage(&irc.Message{
641 Prefix: dc.prefix(),
642 Command: "NICK",
643 Params: []string{uc.nick},
644 })
645 dc.nick = uc.nick
646 }
647}
648
649func sanityCheckServer(addr string) error {
650 dialer := net.Dialer{Timeout: 30 * time.Second}
651 conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
652 if err != nil {
653 return err
654 }
655 return conn.Close()
656}
657
658func unmarshalUsername(rawUsername string) (username, client, network string) {
659 username = rawUsername
660
661 i := strings.IndexAny(username, "/@")
662 j := strings.LastIndexAny(username, "/@")
663 if i >= 0 {
664 username = rawUsername[:i]
665 }
666 if j >= 0 {
667 if rawUsername[j] == '@' {
668 client = rawUsername[j+1:]
669 } else {
670 network = rawUsername[j+1:]
671 }
672 }
673 if i >= 0 && j >= 0 && i < j {
674 if rawUsername[i] == '@' {
675 client = rawUsername[i+1 : j]
676 } else {
677 network = rawUsername[i+1 : j]
678 }
679 }
680
681 return username, client, network
682}
683
684func (dc *downstreamConn) authenticate(username, password string) error {
685 username, clientName, networkName := unmarshalUsername(username)
686
687 u, err := dc.srv.db.GetUser(username)
688 if err != nil {
689 dc.logger.Printf("failed authentication for %q: %v", username, err)
690 return errAuthFailed
691 }
692
693 // Password auth disabled
694 if u.Password == "" {
695 return errAuthFailed
696 }
697
698 err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
699 if err != nil {
700 dc.logger.Printf("failed authentication for %q: %v", username, err)
701 return errAuthFailed
702 }
703
704 dc.user = dc.srv.getUser(username)
705 if dc.user == nil {
706 dc.logger.Printf("failed authentication for %q: user not active", username)
707 return errAuthFailed
708 }
709 dc.clientName = clientName
710 dc.networkName = networkName
711 return nil
712}
713
714func (dc *downstreamConn) register() error {
715 if dc.registered {
716 return fmt.Errorf("tried to register twice")
717 }
718
719 password := dc.password
720 dc.password = ""
721 if dc.user == nil {
722 if err := dc.authenticate(dc.rawUsername, password); err != nil {
723 return err
724 }
725 }
726
727 if dc.clientName == "" && dc.networkName == "" {
728 _, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
729 }
730
731 dc.registered = true
732 dc.logger.Printf("registration complete for user %q", dc.user.Username)
733 return nil
734}
735
736func (dc *downstreamConn) loadNetwork() error {
737 if dc.networkName == "" {
738 return nil
739 }
740
741 network := dc.user.getNetwork(dc.networkName)
742 if network == nil {
743 addr := dc.networkName
744 if !strings.ContainsRune(addr, ':') {
745 addr = addr + ":6697"
746 }
747
748 dc.logger.Printf("trying to connect to new network %q", addr)
749 if err := sanityCheckServer(addr); err != nil {
750 dc.logger.Printf("failed to connect to %q: %v", addr, err)
751 return ircError{&irc.Message{
752 Command: irc.ERR_PASSWDMISMATCH,
753 Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
754 }}
755 }
756
757 // Some clients only allow specifying the nickname (and use the
758 // nickname as a username too). Strip the network name from the
759 // nickname when auto-saving networks.
760 nick, _, _ := unmarshalUsername(dc.nick)
761
762 dc.logger.Printf("auto-saving network %q", dc.networkName)
763 var err error
764 network, err = dc.user.createNetwork(&Network{
765 Addr: dc.networkName,
766 Nick: nick,
767 })
768 if err != nil {
769 return err
770 }
771 }
772
773 dc.network = network
774 return nil
775}
776
777func (dc *downstreamConn) welcome() error {
778 if dc.user == nil || !dc.registered {
779 panic("tried to welcome an unregistered connection")
780 }
781
782 // TODO: doing this might take some time. We should do it in dc.register
783 // instead, but we'll potentially be adding a new network and this must be
784 // done in the user goroutine.
785 if err := dc.loadNetwork(); err != nil {
786 return err
787 }
788
789 dc.SendMessage(&irc.Message{
790 Prefix: dc.srv.prefix(),
791 Command: irc.RPL_WELCOME,
792 Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
793 })
794 dc.SendMessage(&irc.Message{
795 Prefix: dc.srv.prefix(),
796 Command: irc.RPL_YOURHOST,
797 Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
798 })
799 dc.SendMessage(&irc.Message{
800 Prefix: dc.srv.prefix(),
801 Command: irc.RPL_CREATED,
802 Params: []string{dc.nick, "Who cares when the server was created?"},
803 })
804 dc.SendMessage(&irc.Message{
805 Prefix: dc.srv.prefix(),
806 Command: irc.RPL_MYINFO,
807 Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
808 })
809 // TODO: RPL_ISUPPORT
810 // TODO: send CHATHISTORY in RPL_ISUPPORT when implemented
811 dc.SendMessage(&irc.Message{
812 Prefix: dc.srv.prefix(),
813 Command: irc.ERR_NOMOTD,
814 Params: []string{dc.nick, "No MOTD"},
815 })
816
817 dc.updateNick()
818
819 dc.forEachUpstream(func(uc *upstreamConn) {
820 for _, ch := range uc.channels {
821 if !ch.complete {
822 continue
823 }
824 if record, ok := uc.network.channels[ch.Name]; ok && record.Detached {
825 continue
826 }
827
828 dc.SendMessage(&irc.Message{
829 Prefix: dc.prefix(),
830 Command: "JOIN",
831 Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
832 })
833
834 forwardChannel(dc, ch)
835 }
836 })
837
838 dc.forEachNetwork(func(net *network) {
839 // Only send history if we're the first connected client with that name
840 // for the network
841 if _, ok := net.offlineClients[dc.clientName]; ok {
842 dc.sendNetworkHistory(net)
843 delete(net.offlineClients, dc.clientName)
844 }
845 })
846
847 return nil
848}
849
850func (dc *downstreamConn) sendNetworkHistory(net *network) {
851 if dc.caps["draft/chathistory"] {
852 return
853 }
854 for target, history := range net.history {
855 if ch, ok := net.channels[target]; ok && ch.Detached {
856 continue
857 }
858
859 seq, ok := history.offlineClients[dc.clientName]
860 if !ok {
861 continue
862 }
863 delete(history.offlineClients, dc.clientName)
864
865 // If all clients have received history, no need to keep the
866 // ring buffer around
867 if len(history.offlineClients) == 0 {
868 delete(net.history, target)
869 }
870
871 consumer := history.ring.NewConsumer(seq)
872
873 batchRef := "history"
874 if dc.caps["batch"] {
875 dc.SendMessage(&irc.Message{
876 Prefix: dc.srv.prefix(),
877 Command: "BATCH",
878 Params: []string{"+" + batchRef, "chathistory", dc.marshalEntity(net, target)},
879 })
880 }
881
882 for {
883 msg := consumer.Consume()
884 if msg == nil {
885 break
886 }
887
888 // Don't replay all messages, because that would mess up client
889 // state. For instance we just sent the list of users, sending
890 // PART messages for one of these users would be incorrect.
891 ignore := true
892 switch msg.Command {
893 case "PRIVMSG", "NOTICE":
894 ignore = false
895 }
896 if ignore {
897 continue
898 }
899
900 if dc.caps["batch"] {
901 msg = msg.Copy()
902 msg.Tags["batch"] = irc.TagValue(batchRef)
903 }
904
905 dc.SendMessage(dc.marshalMessage(msg, net))
906 }
907
908 if dc.caps["batch"] {
909 dc.SendMessage(&irc.Message{
910 Prefix: dc.srv.prefix(),
911 Command: "BATCH",
912 Params: []string{"-" + batchRef},
913 })
914 }
915 }
916}
917
918func (dc *downstreamConn) runUntilRegistered() error {
919 for !dc.registered {
920 msg, err := dc.ReadMessage()
921 if err != nil {
922 return fmt.Errorf("failed to read IRC command: %v", err)
923 }
924
925 err = dc.handleMessage(msg)
926 if ircErr, ok := err.(ircError); ok {
927 ircErr.Message.Prefix = dc.srv.prefix()
928 dc.SendMessage(ircErr.Message)
929 } else if err != nil {
930 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
931 }
932 }
933
934 return nil
935}
936
937func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
938 switch msg.Command {
939 case "CAP":
940 var subCmd string
941 if err := parseMessageParams(msg, &subCmd); err != nil {
942 return err
943 }
944 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
945 return err
946 }
947 case "PING":
948 dc.SendMessage(&irc.Message{
949 Prefix: dc.srv.prefix(),
950 Command: "PONG",
951 Params: msg.Params,
952 })
953 return nil
954 case "USER":
955 return ircError{&irc.Message{
956 Command: irc.ERR_ALREADYREGISTERED,
957 Params: []string{dc.nick, "You may not reregister"},
958 }}
959 case "NICK":
960 var nick string
961 if err := parseMessageParams(msg, &nick); err != nil {
962 return err
963 }
964
965 var upstream *upstreamConn
966 if dc.upstream() == nil {
967 uc, unmarshaledNick, err := dc.unmarshalEntity(nick)
968 if err == nil { // NICK nick/network: NICK only on a specific upstream
969 upstream = uc
970 nick = unmarshaledNick
971 }
972 }
973
974 var err error
975 dc.forEachNetwork(func(n *network) {
976 if err != nil || (upstream != nil && upstream.network != n) {
977 return
978 }
979 n.Nick = nick
980 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
981 })
982 if err != nil {
983 return err
984 }
985
986 dc.forEachUpstream(func(uc *upstreamConn) {
987 if upstream != nil && upstream != uc {
988 return
989 }
990 uc.SendMessageLabeled(dc.id, &irc.Message{
991 Command: "NICK",
992 Params: []string{nick},
993 })
994 })
995
996 if dc.upstream() == nil && dc.nick != nick {
997 dc.SendMessage(&irc.Message{
998 Prefix: dc.prefix(),
999 Command: "NICK",
1000 Params: []string{nick},
1001 })
1002 dc.nick = nick
1003 }
1004 case "JOIN":
1005 var namesStr string
1006 if err := parseMessageParams(msg, &namesStr); err != nil {
1007 return err
1008 }
1009
1010 var keys []string
1011 if len(msg.Params) > 1 {
1012 keys = strings.Split(msg.Params[1], ",")
1013 }
1014
1015 for i, name := range strings.Split(namesStr, ",") {
1016 uc, upstreamName, err := dc.unmarshalEntity(name)
1017 if err != nil {
1018 return err
1019 }
1020
1021 var key string
1022 if len(keys) > i {
1023 key = keys[i]
1024 }
1025
1026 params := []string{upstreamName}
1027 if key != "" {
1028 params = append(params, key)
1029 }
1030 uc.SendMessageLabeled(dc.id, &irc.Message{
1031 Command: "JOIN",
1032 Params: params,
1033 })
1034
1035 ch := &Channel{Name: upstreamName, Key: key, Detached: false}
1036 if current, ok := uc.network.channels[ch.Name]; ok && key == "" {
1037 // Don't clear the channel key if there's one set
1038 // TODO: add a way to unset the channel key
1039 ch.Key = current.Key
1040 }
1041 if err := uc.network.createUpdateChannel(ch); err != nil {
1042 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
1043 }
1044 }
1045 case "PART":
1046 var namesStr string
1047 if err := parseMessageParams(msg, &namesStr); err != nil {
1048 return err
1049 }
1050
1051 var reason string
1052 if len(msg.Params) > 1 {
1053 reason = msg.Params[1]
1054 }
1055
1056 for _, name := range strings.Split(namesStr, ",") {
1057 uc, upstreamName, err := dc.unmarshalEntity(name)
1058 if err != nil {
1059 return err
1060 }
1061
1062 if strings.EqualFold(reason, "detach") {
1063 ch := &Channel{Name: upstreamName, Detached: true}
1064 if err := uc.network.createUpdateChannel(ch); err != nil {
1065 dc.logger.Printf("failed to detach channel %q: %v", upstreamName, err)
1066 }
1067 } else {
1068 params := []string{upstreamName}
1069 if reason != "" {
1070 params = append(params, reason)
1071 }
1072 uc.SendMessageLabeled(dc.id, &irc.Message{
1073 Command: "PART",
1074 Params: params,
1075 })
1076
1077 if err := uc.network.deleteChannel(upstreamName); err != nil {
1078 dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
1079 }
1080 }
1081 }
1082 case "KICK":
1083 var channelStr, userStr string
1084 if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
1085 return err
1086 }
1087
1088 channels := strings.Split(channelStr, ",")
1089 users := strings.Split(userStr, ",")
1090
1091 var reason string
1092 if len(msg.Params) > 2 {
1093 reason = msg.Params[2]
1094 }
1095
1096 if len(channels) != 1 && len(channels) != len(users) {
1097 return ircError{&irc.Message{
1098 Command: irc.ERR_BADCHANMASK,
1099 Params: []string{dc.nick, channelStr, "Bad channel mask"},
1100 }}
1101 }
1102
1103 for i, user := range users {
1104 var channel string
1105 if len(channels) == 1 {
1106 channel = channels[0]
1107 } else {
1108 channel = channels[i]
1109 }
1110
1111 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1112 if err != nil {
1113 return err
1114 }
1115
1116 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1117 if err != nil {
1118 return err
1119 }
1120
1121 if ucChannel != ucUser {
1122 return ircError{&irc.Message{
1123 Command: irc.ERR_USERNOTINCHANNEL,
1124 Params: []string{dc.nick, user, channel, "They are on another network"},
1125 }}
1126 }
1127 uc := ucChannel
1128
1129 params := []string{upstreamChannel, upstreamUser}
1130 if reason != "" {
1131 params = append(params, reason)
1132 }
1133 uc.SendMessageLabeled(dc.id, &irc.Message{
1134 Command: "KICK",
1135 Params: params,
1136 })
1137 }
1138 case "MODE":
1139 var name string
1140 if err := parseMessageParams(msg, &name); err != nil {
1141 return err
1142 }
1143
1144 var modeStr string
1145 if len(msg.Params) > 1 {
1146 modeStr = msg.Params[1]
1147 }
1148
1149 if name == dc.nick {
1150 if modeStr != "" {
1151 dc.forEachUpstream(func(uc *upstreamConn) {
1152 uc.SendMessageLabeled(dc.id, &irc.Message{
1153 Command: "MODE",
1154 Params: []string{uc.nick, modeStr},
1155 })
1156 })
1157 } else {
1158 dc.SendMessage(&irc.Message{
1159 Prefix: dc.srv.prefix(),
1160 Command: irc.RPL_UMODEIS,
1161 Params: []string{dc.nick, ""}, // TODO
1162 })
1163 }
1164 return nil
1165 }
1166
1167 uc, upstreamName, err := dc.unmarshalEntity(name)
1168 if err != nil {
1169 return err
1170 }
1171
1172 if !uc.isChannel(upstreamName) {
1173 return ircError{&irc.Message{
1174 Command: irc.ERR_USERSDONTMATCH,
1175 Params: []string{dc.nick, "Cannot change mode for other users"},
1176 }}
1177 }
1178
1179 if modeStr != "" {
1180 params := []string{upstreamName, modeStr}
1181 params = append(params, msg.Params[2:]...)
1182 uc.SendMessageLabeled(dc.id, &irc.Message{
1183 Command: "MODE",
1184 Params: params,
1185 })
1186 } else {
1187 ch, ok := uc.channels[upstreamName]
1188 if !ok {
1189 return ircError{&irc.Message{
1190 Command: irc.ERR_NOSUCHCHANNEL,
1191 Params: []string{dc.nick, name, "No such channel"},
1192 }}
1193 }
1194
1195 if ch.modes == nil {
1196 // we haven't received the initial RPL_CHANNELMODEIS yet
1197 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
1198 return nil
1199 }
1200
1201 modeStr, modeParams := ch.modes.Format()
1202 params := []string{dc.nick, name, modeStr}
1203 params = append(params, modeParams...)
1204
1205 dc.SendMessage(&irc.Message{
1206 Prefix: dc.srv.prefix(),
1207 Command: irc.RPL_CHANNELMODEIS,
1208 Params: params,
1209 })
1210 if ch.creationTime != "" {
1211 dc.SendMessage(&irc.Message{
1212 Prefix: dc.srv.prefix(),
1213 Command: rpl_creationtime,
1214 Params: []string{dc.nick, name, ch.creationTime},
1215 })
1216 }
1217 }
1218 case "TOPIC":
1219 var channel string
1220 if err := parseMessageParams(msg, &channel); err != nil {
1221 return err
1222 }
1223
1224 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1225 if err != nil {
1226 return err
1227 }
1228
1229 if len(msg.Params) > 1 { // setting topic
1230 topic := msg.Params[1]
1231 uc.SendMessageLabeled(dc.id, &irc.Message{
1232 Command: "TOPIC",
1233 Params: []string{upstreamChannel, topic},
1234 })
1235 } else { // getting topic
1236 ch, ok := uc.channels[upstreamChannel]
1237 if !ok {
1238 return ircError{&irc.Message{
1239 Command: irc.ERR_NOSUCHCHANNEL,
1240 Params: []string{dc.nick, upstreamChannel, "No such channel"},
1241 }}
1242 }
1243 sendTopic(dc, ch)
1244 }
1245 case "LIST":
1246 // TODO: support ELIST when supported by all upstreams
1247
1248 pl := pendingLIST{
1249 downstreamID: dc.id,
1250 pendingCommands: make(map[int64]*irc.Message),
1251 }
1252 var upstream *upstreamConn
1253 var upstreamChannels map[int64][]string
1254 if len(msg.Params) > 0 {
1255 uc, upstreamMask, err := dc.unmarshalEntity(msg.Params[0])
1256 if err == nil && upstreamMask == "*" { // LIST */network: send LIST only to one network
1257 upstream = uc
1258 } else {
1259 upstreamChannels = make(map[int64][]string)
1260 channels := strings.Split(msg.Params[0], ",")
1261 for _, channel := range channels {
1262 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1263 if err != nil {
1264 return err
1265 }
1266 upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
1267 }
1268 }
1269 }
1270
1271 dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
1272 dc.forEachUpstream(func(uc *upstreamConn) {
1273 if upstream != nil && upstream != uc {
1274 return
1275 }
1276 var params []string
1277 if upstreamChannels != nil {
1278 if channels, ok := upstreamChannels[uc.network.ID]; ok {
1279 params = []string{strings.Join(channels, ",")}
1280 } else {
1281 return
1282 }
1283 }
1284 pl.pendingCommands[uc.network.ID] = &irc.Message{
1285 Command: "LIST",
1286 Params: params,
1287 }
1288 uc.trySendLIST(dc.id)
1289 })
1290 case "NAMES":
1291 if len(msg.Params) == 0 {
1292 dc.SendMessage(&irc.Message{
1293 Prefix: dc.srv.prefix(),
1294 Command: irc.RPL_ENDOFNAMES,
1295 Params: []string{dc.nick, "*", "End of /NAMES list"},
1296 })
1297 return nil
1298 }
1299
1300 channels := strings.Split(msg.Params[0], ",")
1301 for _, channel := range channels {
1302 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1303 if err != nil {
1304 return err
1305 }
1306
1307 ch, ok := uc.channels[upstreamChannel]
1308 if ok {
1309 sendNames(dc, ch)
1310 } else {
1311 // NAMES on a channel we have not joined, ask upstream
1312 uc.SendMessageLabeled(dc.id, &irc.Message{
1313 Command: "NAMES",
1314 Params: []string{upstreamChannel},
1315 })
1316 }
1317 }
1318 case "WHO":
1319 if len(msg.Params) == 0 {
1320 // TODO: support WHO without parameters
1321 dc.SendMessage(&irc.Message{
1322 Prefix: dc.srv.prefix(),
1323 Command: irc.RPL_ENDOFWHO,
1324 Params: []string{dc.nick, "*", "End of /WHO list"},
1325 })
1326 return nil
1327 }
1328
1329 // TODO: support WHO masks
1330 entity := msg.Params[0]
1331
1332 if entity == dc.nick {
1333 // TODO: support AWAY (H/G) in self WHO reply
1334 dc.SendMessage(&irc.Message{
1335 Prefix: dc.srv.prefix(),
1336 Command: irc.RPL_WHOREPLY,
1337 Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
1338 })
1339 dc.SendMessage(&irc.Message{
1340 Prefix: dc.srv.prefix(),
1341 Command: irc.RPL_ENDOFWHO,
1342 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
1343 })
1344 return nil
1345 }
1346 if entity == serviceNick {
1347 dc.SendMessage(&irc.Message{
1348 Prefix: dc.srv.prefix(),
1349 Command: irc.RPL_WHOREPLY,
1350 Params: []string{serviceNick, "*", servicePrefix.User, servicePrefix.Host, dc.srv.Hostname, serviceNick, "H", "0 " + serviceRealname},
1351 })
1352 dc.SendMessage(&irc.Message{
1353 Prefix: dc.srv.prefix(),
1354 Command: irc.RPL_ENDOFWHO,
1355 Params: []string{dc.nick, serviceNick, "End of /WHO list"},
1356 })
1357 return nil
1358 }
1359
1360 uc, upstreamName, err := dc.unmarshalEntity(entity)
1361 if err != nil {
1362 return err
1363 }
1364
1365 var params []string
1366 if len(msg.Params) == 2 {
1367 params = []string{upstreamName, msg.Params[1]}
1368 } else {
1369 params = []string{upstreamName}
1370 }
1371
1372 uc.SendMessageLabeled(dc.id, &irc.Message{
1373 Command: "WHO",
1374 Params: params,
1375 })
1376 case "WHOIS":
1377 if len(msg.Params) == 0 {
1378 return ircError{&irc.Message{
1379 Command: irc.ERR_NONICKNAMEGIVEN,
1380 Params: []string{dc.nick, "No nickname given"},
1381 }}
1382 }
1383
1384 var target, mask string
1385 if len(msg.Params) == 1 {
1386 target = ""
1387 mask = msg.Params[0]
1388 } else {
1389 target = msg.Params[0]
1390 mask = msg.Params[1]
1391 }
1392 // TODO: support multiple WHOIS users
1393 if i := strings.IndexByte(mask, ','); i >= 0 {
1394 mask = mask[:i]
1395 }
1396
1397 if mask == dc.nick {
1398 dc.SendMessage(&irc.Message{
1399 Prefix: dc.srv.prefix(),
1400 Command: irc.RPL_WHOISUSER,
1401 Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
1402 })
1403 dc.SendMessage(&irc.Message{
1404 Prefix: dc.srv.prefix(),
1405 Command: irc.RPL_WHOISSERVER,
1406 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1407 })
1408 dc.SendMessage(&irc.Message{
1409 Prefix: dc.srv.prefix(),
1410 Command: irc.RPL_ENDOFWHOIS,
1411 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1412 })
1413 return nil
1414 }
1415
1416 // TODO: support WHOIS masks
1417 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1418 if err != nil {
1419 return err
1420 }
1421
1422 var params []string
1423 if target != "" {
1424 if target == mask { // WHOIS nick nick
1425 params = []string{upstreamNick, upstreamNick}
1426 } else {
1427 params = []string{target, upstreamNick}
1428 }
1429 } else {
1430 params = []string{upstreamNick}
1431 }
1432
1433 uc.SendMessageLabeled(dc.id, &irc.Message{
1434 Command: "WHOIS",
1435 Params: params,
1436 })
1437 case "PRIVMSG":
1438 var targetsStr, text string
1439 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1440 return err
1441 }
1442 tags := copyClientTags(msg.Tags)
1443
1444 for _, name := range strings.Split(targetsStr, ",") {
1445 if name == serviceNick {
1446 handleServicePRIVMSG(dc, text)
1447 continue
1448 }
1449
1450 uc, upstreamName, err := dc.unmarshalEntity(name)
1451 if err != nil {
1452 return err
1453 }
1454
1455 if upstreamName == "NickServ" {
1456 dc.handleNickServPRIVMSG(uc, text)
1457 }
1458
1459 unmarshaledText := text
1460 if uc.isChannel(upstreamName) {
1461 unmarshaledText = dc.unmarshalText(uc, text)
1462 }
1463 uc.SendMessageLabeled(dc.id, &irc.Message{
1464 Tags: tags,
1465 Command: "PRIVMSG",
1466 Params: []string{upstreamName, unmarshaledText},
1467 })
1468
1469 echoTags := tags.Copy()
1470 echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
1471 echoMsg := &irc.Message{
1472 Tags: echoTags,
1473 Prefix: &irc.Prefix{
1474 Name: uc.nick,
1475 User: uc.username,
1476 },
1477 Command: "PRIVMSG",
1478 Params: []string{upstreamName, text},
1479 }
1480 uc.produce(upstreamName, echoMsg, dc)
1481 }
1482 case "NOTICE":
1483 var targetsStr, text string
1484 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1485 return err
1486 }
1487 tags := copyClientTags(msg.Tags)
1488
1489 for _, name := range strings.Split(targetsStr, ",") {
1490 uc, upstreamName, err := dc.unmarshalEntity(name)
1491 if err != nil {
1492 return err
1493 }
1494
1495 unmarshaledText := text
1496 if uc.isChannel(upstreamName) {
1497 unmarshaledText = dc.unmarshalText(uc, text)
1498 }
1499 uc.SendMessageLabeled(dc.id, &irc.Message{
1500 Tags: tags,
1501 Command: "NOTICE",
1502 Params: []string{upstreamName, unmarshaledText},
1503 })
1504 }
1505 case "TAGMSG":
1506 var targetsStr string
1507 if err := parseMessageParams(msg, &targetsStr); err != nil {
1508 return err
1509 }
1510 tags := copyClientTags(msg.Tags)
1511
1512 for _, name := range strings.Split(targetsStr, ",") {
1513 uc, upstreamName, err := dc.unmarshalEntity(name)
1514 if err != nil {
1515 return err
1516 }
1517
1518 uc.SendMessageLabeled(dc.id, &irc.Message{
1519 Tags: tags,
1520 Command: "TAGMSG",
1521 Params: []string{upstreamName},
1522 })
1523 }
1524 case "INVITE":
1525 var user, channel string
1526 if err := parseMessageParams(msg, &user, &channel); err != nil {
1527 return err
1528 }
1529
1530 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1531 if err != nil {
1532 return err
1533 }
1534
1535 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1536 if err != nil {
1537 return err
1538 }
1539
1540 if ucChannel != ucUser {
1541 return ircError{&irc.Message{
1542 Command: irc.ERR_USERNOTINCHANNEL,
1543 Params: []string{dc.nick, user, channel, "They are on another network"},
1544 }}
1545 }
1546 uc := ucChannel
1547
1548 uc.SendMessageLabeled(dc.id, &irc.Message{
1549 Command: "INVITE",
1550 Params: []string{upstreamUser, upstreamChannel},
1551 })
1552 case "CHATHISTORY":
1553 var subcommand string
1554 if err := parseMessageParams(msg, &subcommand); err != nil {
1555 return err
1556 }
1557 var target, criteria, limitStr string
1558 if err := parseMessageParams(msg, nil, &target, &criteria, &limitStr); err != nil {
1559 return ircError{&irc.Message{
1560 Command: "FAIL",
1561 Params: []string{"CHATHISTORY", "NEED_MORE_PARAMS", subcommand, "Missing parameters"},
1562 }}
1563 }
1564
1565 if dc.srv.LogPath == "" {
1566 return ircError{&irc.Message{
1567 Command: irc.ERR_UNKNOWNCOMMAND,
1568 Params: []string{dc.nick, subcommand, "Unknown command"},
1569 }}
1570 }
1571
1572 uc, entity, err := dc.unmarshalEntity(target)
1573 if err != nil {
1574 return err
1575 }
1576
1577 // TODO: support msgid criteria
1578 criteriaParts := strings.SplitN(criteria, "=", 2)
1579 if len(criteriaParts) != 2 || criteriaParts[0] != "timestamp" {
1580 return ircError{&irc.Message{
1581 Command: "FAIL",
1582 Params: []string{"CHATHISTORY", "UNKNOWN_CRITERIA", criteria, "Unknown criteria"},
1583 }}
1584 }
1585
1586 timestamp, err := time.Parse(serverTimeLayout, criteriaParts[1])
1587 if err != nil {
1588 return ircError{&irc.Message{
1589 Command: "FAIL",
1590 Params: []string{"CHATHISTORY", "INVALID_CRITERIA", criteria, "Invalid criteria"},
1591 }}
1592 }
1593
1594 limit, err := strconv.Atoi(limitStr)
1595 if err != nil || limit < 0 || limit > dc.srv.HistoryLimit {
1596 return ircError{&irc.Message{
1597 Command: "FAIL",
1598 Params: []string{"CHATHISTORY", "INVALID_LIMIT", limitStr, "Invalid limit"},
1599 }}
1600 }
1601
1602 var history []*irc.Message
1603 switch subcommand {
1604 case "BEFORE":
1605 history, err = loadHistoryBeforeTime(uc.network, entity, timestamp, limit)
1606 case "AFTER":
1607 history, err = loadHistoryAfterTime(uc.network, entity, timestamp, limit)
1608 default:
1609 // TODO: support LATEST, BETWEEN
1610 return ircError{&irc.Message{
1611 Command: "FAIL",
1612 Params: []string{"CHATHISTORY", "UNKNOWN_COMMAND", subcommand, "Unknown command"},
1613 }}
1614 }
1615 if err != nil {
1616 dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
1617 return newChatHistoryError(subcommand, target)
1618 }
1619
1620 batchRef := "history"
1621 dc.SendMessage(&irc.Message{
1622 Prefix: dc.srv.prefix(),
1623 Command: "BATCH",
1624 Params: []string{"+" + batchRef, "chathistory", target},
1625 })
1626
1627 for _, msg := range history {
1628 msg.Tags["batch"] = irc.TagValue(batchRef)
1629 dc.SendMessage(dc.marshalMessage(msg, uc.network))
1630 }
1631
1632 dc.SendMessage(&irc.Message{
1633 Prefix: dc.srv.prefix(),
1634 Command: "BATCH",
1635 Params: []string{"-" + batchRef},
1636 })
1637 default:
1638 dc.logger.Printf("unhandled message: %v", msg)
1639 return newUnknownCommandError(msg.Command)
1640 }
1641 return nil
1642}
1643
1644func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1645 username, password, ok := parseNickServCredentials(text, uc.nick)
1646 if !ok {
1647 return
1648 }
1649
1650 // User may have e.g. EXTERNAL mechanism configured. We do not want to
1651 // automatically erase the key pair or any other credentials.
1652 if uc.network.SASL.Mechanism != "" && uc.network.SASL.Mechanism != "PLAIN" {
1653 return
1654 }
1655
1656 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1657 n := uc.network
1658 n.SASL.Mechanism = "PLAIN"
1659 n.SASL.Plain.Username = username
1660 n.SASL.Plain.Password = password
1661 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1662 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1663 }
1664}
1665
1666func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1667 fields := strings.Fields(text)
1668 if len(fields) < 2 {
1669 return "", "", false
1670 }
1671 cmd := strings.ToUpper(fields[0])
1672 params := fields[1:]
1673 switch cmd {
1674 case "REGISTER":
1675 username = nick
1676 password = params[0]
1677 case "IDENTIFY":
1678 if len(params) == 1 {
1679 username = nick
1680 password = params[0]
1681 } else {
1682 username = params[0]
1683 password = params[1]
1684 }
1685 case "SET":
1686 if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
1687 username = nick
1688 password = params[1]
1689 }
1690 default:
1691 return "", "", false
1692 }
1693 return username, password, true
1694}
Note: See TracBrowser for help on using the repository browser.