source: code/trunk/downstream.go@ 182

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

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