source: code/trunk/downstream.go@ 288

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

Don't clear channel key on JOIN

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