source: code/trunk/downstream.go@ 459

Last change on this file since 459 was 456, checked in by hubert, 4 years ago

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