source: code/trunk/downstream.go@ 306

Last change on this file since 306 was 306, checked in by hubert.hirtz, 5 years ago

Send the full user mask in RPL_LOGGEDIN

As per the spec [1]:

:server 900 <nick> <nick>!<ident>@<host> <account> :Now logged in

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