source: code/trunk/downstream.go@ 360

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

Implement CHATHISTORY AFTER

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