source: code/trunk/downstream.go@ 189

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

Consume ring messages outside of writer goroutine

This fixes out-of-order JOIN and PRIVMSG messages.

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