source: code/trunk/downstream.go@ 203

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

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