source: code/trunk/downstream.go@ 131

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

Move upstreamConn.history to network
File size: 23.5 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 net net.Conn
61 irc *irc.Conn
62 srv *Server
63 logger Logger
64 outgoing chan *irc.Message
65 ringMessages chan ringMessage
66 closed chan struct{}
67
68 registered bool
69 user *user
70 nick string
71 username string
72 rawUsername string
73 realname string
74 password string // empty after authentication
75 network *network // can be nil
76
77 negociatingCaps bool
78 capVersion int
79 caps map[string]bool
80
81 saslServer sasl.Server
82
83 lock sync.Mutex
84 ourMessages map[*irc.Message]struct{}
85}
86
87func newDownstreamConn(srv *Server, netConn net.Conn) *downstreamConn {
88 dc := &downstreamConn{
89 net: netConn,
90 irc: irc.NewConn(netConn),
91 srv: srv,
92 logger: &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())},
93 outgoing: make(chan *irc.Message, 64),
94 ringMessages: make(chan ringMessage),
95 closed: make(chan struct{}),
96 caps: make(map[string]bool),
97 ourMessages: make(map[*irc.Message]struct{}),
98 }
99
100 go func() {
101 if err := dc.writeMessages(); err != nil {
102 dc.logger.Printf("failed to write message: %v", err)
103 }
104 if err := dc.net.Close(); err != nil {
105 dc.logger.Printf("failed to close connection: %v", err)
106 } else {
107 dc.logger.Printf("connection closed")
108 }
109 }()
110
111 dc.logger.Printf("new connection")
112 return dc
113}
114
115func (dc *downstreamConn) prefix() *irc.Prefix {
116 return &irc.Prefix{
117 Name: dc.nick,
118 User: dc.username,
119 // TODO: fill the host?
120 }
121}
122
123func (dc *downstreamConn) forEachNetwork(f func(*network)) {
124 if dc.network != nil {
125 f(dc.network)
126 } else {
127 dc.user.forEachNetwork(f)
128 }
129}
130
131func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
132 dc.user.forEachUpstream(func(uc *upstreamConn) {
133 if dc.network != nil && uc.network != dc.network {
134 return
135 }
136 f(uc)
137 })
138}
139
140// upstream returns the upstream connection, if any. If there are zero or if
141// there are multiple upstream connections, it returns nil.
142func (dc *downstreamConn) upstream() *upstreamConn {
143 if dc.network == nil {
144 return nil
145 }
146
147 var upstream *upstreamConn
148 dc.forEachUpstream(func(uc *upstreamConn) {
149 upstream = uc
150 })
151 return upstream
152}
153
154func (dc *downstreamConn) marshalEntity(uc *upstreamConn, entity string) string {
155 if uc.isChannel(entity) {
156 return dc.marshalChannel(uc, entity)
157 }
158 return dc.marshalNick(uc, entity)
159}
160
161func (dc *downstreamConn) marshalChannel(uc *upstreamConn, name string) string {
162 if dc.network != nil {
163 return name
164 }
165 return name + "/" + uc.network.GetName()
166}
167
168func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
169 if uc := dc.upstream(); uc != nil {
170 return uc, name, nil
171 }
172
173 var conn *upstreamConn
174 if i := strings.LastIndexByte(name, '/'); i >= 0 {
175 network := name[i+1:]
176 name = name[:i]
177
178 dc.forEachUpstream(func(uc *upstreamConn) {
179 if network != uc.network.GetName() {
180 return
181 }
182 conn = uc
183 })
184 }
185
186 if conn == nil {
187 return nil, "", ircError{&irc.Message{
188 Command: irc.ERR_NOSUCHCHANNEL,
189 Params: []string{name, "No such channel"},
190 }}
191 }
192 return conn, name, nil
193}
194
195func (dc *downstreamConn) marshalNick(uc *upstreamConn, nick string) string {
196 if nick == uc.nick {
197 return dc.nick
198 }
199 if dc.network != nil {
200 return nick
201 }
202 return nick + "/" + uc.network.GetName()
203}
204
205func (dc *downstreamConn) marshalUserPrefix(uc *upstreamConn, prefix *irc.Prefix) *irc.Prefix {
206 if prefix.Name == uc.nick {
207 return dc.prefix()
208 }
209 if dc.network != nil {
210 return prefix
211 }
212 return &irc.Prefix{
213 Name: prefix.Name + "/" + uc.network.GetName(),
214 User: prefix.User,
215 Host: prefix.Host,
216 }
217}
218
219func (dc *downstreamConn) isClosed() bool {
220 select {
221 case <-dc.closed:
222 return true
223 default:
224 return false
225 }
226}
227
228func (dc *downstreamConn) readMessages(ch chan<- downstreamIncomingMessage) error {
229 for {
230 msg, err := dc.irc.ReadMessage()
231 if err == io.EOF {
232 break
233 } else if err != nil {
234 return fmt.Errorf("failed to read IRC command: %v", err)
235 }
236
237 if dc.srv.Debug {
238 dc.logger.Printf("received: %v", msg)
239 }
240
241 ch <- downstreamIncomingMessage{msg, dc}
242 }
243
244 return nil
245}
246
247func (dc *downstreamConn) writeMessages() error {
248 for {
249 var err error
250 var closed bool
251 select {
252 case msg := <-dc.outgoing:
253 if dc.srv.Debug {
254 dc.logger.Printf("sent: %v", msg)
255 }
256 err = dc.irc.WriteMessage(msg)
257 case ringMessage := <-dc.ringMessages:
258 consumer, uc := ringMessage.consumer, ringMessage.upstreamConn
259 for {
260 msg := consumer.Peek()
261 if msg == nil {
262 break
263 }
264
265 dc.lock.Lock()
266 _, ours := dc.ourMessages[msg]
267 delete(dc.ourMessages, msg)
268 dc.lock.Unlock()
269 if ours {
270 // The message comes from our connection, don't echo it
271 // back
272 consumer.Consume()
273 continue
274 }
275
276 msg = msg.Copy()
277 switch msg.Command {
278 case "PRIVMSG":
279 msg.Prefix = dc.marshalUserPrefix(uc, msg.Prefix)
280 msg.Params[0] = dc.marshalEntity(uc, msg.Params[0])
281 default:
282 panic("expected to consume a PRIVMSG message")
283 }
284 if dc.srv.Debug {
285 dc.logger.Printf("sent: %v", msg)
286 }
287 err = dc.irc.WriteMessage(msg)
288 if err != nil {
289 break
290 }
291 consumer.Consume()
292 }
293 case <-dc.closed:
294 closed = true
295 }
296 if err != nil {
297 return err
298 }
299 if closed {
300 break
301 }
302 }
303 return nil
304}
305
306func (dc *downstreamConn) Close() error {
307 if dc.isClosed() {
308 return fmt.Errorf("downstream connection already closed")
309 }
310
311 if u := dc.user; u != nil {
312 u.lock.Lock()
313 for i := range u.downstreamConns {
314 if u.downstreamConns[i] == dc {
315 u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
316 break
317 }
318 }
319 u.lock.Unlock()
320 }
321
322 close(dc.closed)
323 return nil
324}
325
326func (dc *downstreamConn) SendMessage(msg *irc.Message) {
327 dc.outgoing <- msg
328}
329
330func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
331 switch msg.Command {
332 case "QUIT":
333 return dc.Close()
334 default:
335 if dc.registered {
336 return dc.handleMessageRegistered(msg)
337 } else {
338 return dc.handleMessageUnregistered(msg)
339 }
340 }
341}
342
343func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
344 switch msg.Command {
345 case "NICK":
346 var nick string
347 if err := parseMessageParams(msg, &nick); err != nil {
348 return err
349 }
350 if nick == serviceNick {
351 return ircError{&irc.Message{
352 Command: irc.ERR_NICKNAMEINUSE,
353 Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
354 }}
355 }
356 dc.nick = nick
357 case "USER":
358 if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
359 return err
360 }
361 case "PASS":
362 if err := parseMessageParams(msg, &dc.password); err != nil {
363 return err
364 }
365 case "CAP":
366 var subCmd string
367 if err := parseMessageParams(msg, &subCmd); err != nil {
368 return err
369 }
370 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
371 return err
372 }
373 case "AUTHENTICATE":
374 if !dc.caps["sasl"] {
375 return ircError{&irc.Message{
376 Command: irc.ERR_SASLFAIL,
377 Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
378 }}
379 }
380 if len(msg.Params) == 0 {
381 return ircError{&irc.Message{
382 Command: irc.ERR_SASLFAIL,
383 Params: []string{"*", "Missing AUTHENTICATE argument"},
384 }}
385 }
386 if dc.nick == "" {
387 return ircError{&irc.Message{
388 Command: irc.ERR_SASLFAIL,
389 Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
390 }}
391 }
392
393 var resp []byte
394 if dc.saslServer == nil {
395 mech := strings.ToUpper(msg.Params[0])
396 switch mech {
397 case "PLAIN":
398 dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
399 return dc.authenticate(username, password)
400 }))
401 default:
402 return ircError{&irc.Message{
403 Command: irc.ERR_SASLFAIL,
404 Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
405 }}
406 }
407 } else if msg.Params[0] == "*" {
408 dc.saslServer = nil
409 return ircError{&irc.Message{
410 Command: irc.ERR_SASLABORTED,
411 Params: []string{"*", "SASL authentication aborted"},
412 }}
413 } else if msg.Params[0] == "+" {
414 resp = nil
415 } else {
416 // TODO: multi-line messages
417 var err error
418 resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
419 if err != nil {
420 dc.saslServer = nil
421 return ircError{&irc.Message{
422 Command: irc.ERR_SASLFAIL,
423 Params: []string{"*", "Invalid base64-encoded response"},
424 }}
425 }
426 }
427
428 challenge, done, err := dc.saslServer.Next(resp)
429 if err != nil {
430 dc.saslServer = nil
431 if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
432 return ircError{&irc.Message{
433 Command: irc.ERR_SASLFAIL,
434 Params: []string{"*", ircErr.Message.Params[1]},
435 }}
436 }
437 dc.SendMessage(&irc.Message{
438 Prefix: dc.srv.prefix(),
439 Command: irc.ERR_SASLFAIL,
440 Params: []string{"*", "SASL error"},
441 })
442 return fmt.Errorf("SASL authentication failed: %v", err)
443 } else if done {
444 dc.saslServer = nil
445 dc.SendMessage(&irc.Message{
446 Prefix: dc.srv.prefix(),
447 Command: irc.RPL_LOGGEDIN,
448 Params: []string{dc.nick, dc.nick, dc.user.Username, "You are now logged in"},
449 })
450 dc.SendMessage(&irc.Message{
451 Prefix: dc.srv.prefix(),
452 Command: irc.RPL_SASLSUCCESS,
453 Params: []string{dc.nick, "SASL authentication successful"},
454 })
455 } else {
456 challengeStr := "+"
457 if challenge != nil {
458 challengeStr = base64.StdEncoding.EncodeToString(challenge)
459 }
460
461 // TODO: multi-line messages
462 dc.SendMessage(&irc.Message{
463 Prefix: dc.srv.prefix(),
464 Command: "AUTHENTICATE",
465 Params: []string{challengeStr},
466 })
467 }
468 default:
469 dc.logger.Printf("unhandled message: %v", msg)
470 return newUnknownCommandError(msg.Command)
471 }
472 if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
473 return dc.register()
474 }
475 return nil
476}
477
478func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
479 cmd = strings.ToUpper(cmd)
480
481 replyTo := dc.nick
482 if !dc.registered {
483 replyTo = "*"
484 }
485
486 switch cmd {
487 case "LS":
488 if len(args) > 0 {
489 var err error
490 if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
491 return err
492 }
493 }
494
495 var caps []string
496 if dc.capVersion >= 302 {
497 caps = append(caps, "sasl=PLAIN")
498 } else {
499 caps = append(caps, "sasl")
500 }
501
502 // TODO: multi-line replies
503 dc.SendMessage(&irc.Message{
504 Prefix: dc.srv.prefix(),
505 Command: "CAP",
506 Params: []string{replyTo, "LS", strings.Join(caps, " ")},
507 })
508
509 if !dc.registered {
510 dc.negociatingCaps = true
511 }
512 case "LIST":
513 var caps []string
514 for name := range dc.caps {
515 caps = append(caps, name)
516 }
517
518 // TODO: multi-line replies
519 dc.SendMessage(&irc.Message{
520 Prefix: dc.srv.prefix(),
521 Command: "CAP",
522 Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
523 })
524 case "REQ":
525 if len(args) == 0 {
526 return ircError{&irc.Message{
527 Command: err_invalidcapcmd,
528 Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
529 }}
530 }
531
532 caps := strings.Fields(args[0])
533 ack := true
534 for _, name := range caps {
535 name = strings.ToLower(name)
536 enable := !strings.HasPrefix(name, "-")
537 if !enable {
538 name = strings.TrimPrefix(name, "-")
539 }
540
541 enabled := dc.caps[name]
542 if enable == enabled {
543 continue
544 }
545
546 switch name {
547 case "sasl":
548 dc.caps[name] = enable
549 default:
550 ack = false
551 }
552 }
553
554 reply := "NAK"
555 if ack {
556 reply = "ACK"
557 }
558 dc.SendMessage(&irc.Message{
559 Prefix: dc.srv.prefix(),
560 Command: "CAP",
561 Params: []string{replyTo, reply, args[0]},
562 })
563 case "END":
564 dc.negociatingCaps = false
565 default:
566 return ircError{&irc.Message{
567 Command: err_invalidcapcmd,
568 Params: []string{replyTo, cmd, "Unknown CAP command"},
569 }}
570 }
571 return nil
572}
573
574func sanityCheckServer(addr string) error {
575 dialer := net.Dialer{Timeout: 30 * time.Second}
576 conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
577 if err != nil {
578 return err
579 }
580 return conn.Close()
581}
582
583func unmarshalUsername(rawUsername string) (username, network string) {
584 username = rawUsername
585 if i := strings.LastIndexAny(username, "/@"); i >= 0 {
586 network = username[i+1:]
587 }
588 if i := strings.IndexAny(username, "/@"); i >= 0 {
589 username = username[:i]
590 }
591 return username, network
592}
593
594func (dc *downstreamConn) setNetwork(networkName string) error {
595 if networkName == "" {
596 return nil
597 }
598
599 network := dc.user.getNetwork(networkName)
600 if network == nil {
601 addr := networkName
602 if !strings.ContainsRune(addr, ':') {
603 addr = addr + ":6697"
604 }
605
606 dc.logger.Printf("trying to connect to new network %q", addr)
607 if err := sanityCheckServer(addr); err != nil {
608 dc.logger.Printf("failed to connect to %q: %v", addr, err)
609 return ircError{&irc.Message{
610 Command: irc.ERR_PASSWDMISMATCH,
611 Params: []string{"*", fmt.Sprintf("Failed to connect to %q", networkName)},
612 }}
613 }
614
615 dc.logger.Printf("auto-saving network %q", networkName)
616 var err error
617 network, err = dc.user.createNetwork(&Network{
618 Addr: networkName,
619 Nick: dc.nick,
620 })
621 if err != nil {
622 return err
623 }
624 }
625
626 dc.network = network
627 return nil
628}
629
630func (dc *downstreamConn) authenticate(username, password string) error {
631 username, networkName := unmarshalUsername(username)
632
633 u := dc.srv.getUser(username)
634 if u == nil {
635 dc.logger.Printf("failed authentication for %q: unknown username", username)
636 return errAuthFailed
637 }
638
639 err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
640 if err != nil {
641 dc.logger.Printf("failed authentication for %q: %v", username, err)
642 return errAuthFailed
643 }
644
645 dc.user = u
646
647 return dc.setNetwork(networkName)
648}
649
650func (dc *downstreamConn) register() error {
651 password := dc.password
652 dc.password = ""
653 if dc.user == nil {
654 if err := dc.authenticate(dc.rawUsername, password); err != nil {
655 return err
656 }
657 } else if dc.network == nil {
658 _, networkName := unmarshalUsername(dc.rawUsername)
659 if err := dc.setNetwork(networkName); err != nil {
660 return err
661 }
662 }
663
664 dc.registered = true
665 dc.username = dc.user.Username
666 dc.logger.Printf("registration complete for user %q", dc.username)
667
668 dc.user.lock.Lock()
669 firstDownstream := len(dc.user.downstreamConns) == 0
670 dc.user.downstreamConns = append(dc.user.downstreamConns, dc)
671 dc.user.lock.Unlock()
672
673 dc.SendMessage(&irc.Message{
674 Prefix: dc.srv.prefix(),
675 Command: irc.RPL_WELCOME,
676 Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
677 })
678 dc.SendMessage(&irc.Message{
679 Prefix: dc.srv.prefix(),
680 Command: irc.RPL_YOURHOST,
681 Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
682 })
683 dc.SendMessage(&irc.Message{
684 Prefix: dc.srv.prefix(),
685 Command: irc.RPL_CREATED,
686 Params: []string{dc.nick, "Who cares when the server was created?"},
687 })
688 dc.SendMessage(&irc.Message{
689 Prefix: dc.srv.prefix(),
690 Command: irc.RPL_MYINFO,
691 Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
692 })
693 // TODO: RPL_ISUPPORT
694 dc.SendMessage(&irc.Message{
695 Prefix: dc.srv.prefix(),
696 Command: irc.ERR_NOMOTD,
697 Params: []string{dc.nick, "No MOTD"},
698 })
699
700 dc.forEachUpstream(func(uc *upstreamConn) {
701 for _, ch := range uc.channels {
702 if ch.complete {
703 forwardChannel(dc, ch)
704 }
705 }
706
707 historyName := dc.rawUsername
708
709 var seqPtr *uint64
710 if firstDownstream {
711 uc.network.lock.Lock()
712 seq, ok := uc.network.history[historyName]
713 uc.network.lock.Unlock()
714 if ok {
715 seqPtr = &seq
716 }
717 }
718
719 consumer, ch := uc.ring.NewConsumer(seqPtr)
720 go func() {
721 for {
722 var closed bool
723 select {
724 case <-ch:
725 dc.ringMessages <- ringMessage{consumer, uc}
726 case <-dc.closed:
727 closed = true
728 }
729 if closed {
730 break
731 }
732 }
733
734 seq := consumer.Close()
735
736 dc.user.lock.Lock()
737 lastDownstream := len(dc.user.downstreamConns) == 0
738 dc.user.lock.Unlock()
739
740 if lastDownstream {
741 uc.network.lock.Lock()
742 uc.network.history[historyName] = seq
743 uc.network.lock.Unlock()
744 }
745 }()
746 })
747
748 return nil
749}
750
751func (dc *downstreamConn) runUntilRegistered() error {
752 for !dc.registered {
753 msg, err := dc.irc.ReadMessage()
754 if err != nil {
755 return fmt.Errorf("failed to read IRC command: %v", err)
756 }
757
758 if dc.srv.Debug {
759 dc.logger.Printf("received: %v", msg)
760 }
761
762 err = dc.handleMessage(msg)
763 if ircErr, ok := err.(ircError); ok {
764 ircErr.Message.Prefix = dc.srv.prefix()
765 dc.SendMessage(ircErr.Message)
766 } else if err != nil {
767 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
768 }
769 }
770
771 return nil
772}
773
774func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
775 switch msg.Command {
776 case "CAP":
777 var subCmd string
778 if err := parseMessageParams(msg, &subCmd); err != nil {
779 return err
780 }
781 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
782 return err
783 }
784 case "PING":
785 dc.SendMessage(&irc.Message{
786 Prefix: dc.srv.prefix(),
787 Command: "PONG",
788 Params: msg.Params,
789 })
790 return nil
791 case "USER":
792 return ircError{&irc.Message{
793 Command: irc.ERR_ALREADYREGISTERED,
794 Params: []string{dc.nick, "You may not reregister"},
795 }}
796 case "NICK":
797 var nick string
798 if err := parseMessageParams(msg, &nick); err != nil {
799 return err
800 }
801
802 var err error
803 dc.forEachNetwork(func(n *network) {
804 if err != nil {
805 return
806 }
807 n.Nick = nick
808 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
809 })
810 if err != nil {
811 return err
812 }
813
814 dc.forEachUpstream(func(uc *upstreamConn) {
815 uc.SendMessage(msg)
816 })
817 case "JOIN", "PART":
818 var name string
819 if err := parseMessageParams(msg, &name); err != nil {
820 return err
821 }
822
823 uc, upstreamName, err := dc.unmarshalEntity(name)
824 if err != nil {
825 return ircError{&irc.Message{
826 Command: irc.ERR_NOSUCHCHANNEL,
827 Params: []string{name, err.Error()},
828 }}
829 }
830
831 uc.SendMessage(&irc.Message{
832 Command: msg.Command,
833 Params: []string{upstreamName},
834 })
835
836 switch msg.Command {
837 case "JOIN":
838 err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
839 Name: upstreamName,
840 })
841 if err != nil {
842 dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
843 }
844 case "PART":
845 if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
846 dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
847 }
848 }
849 case "MODE":
850 var name string
851 if err := parseMessageParams(msg, &name); err != nil {
852 return err
853 }
854
855 var modeStr string
856 if len(msg.Params) > 1 {
857 modeStr = msg.Params[1]
858 }
859
860 uc, upstreamName, err := dc.unmarshalEntity(name)
861 if err != nil {
862 return err
863 }
864
865 if uc.isChannel(upstreamName) {
866 // TODO: handle MODE channel mode arguments
867 if modeStr != "" {
868 uc.SendMessage(&irc.Message{
869 Command: "MODE",
870 Params: []string{upstreamName, modeStr},
871 })
872 } else {
873 ch, ok := uc.channels[upstreamName]
874 if !ok {
875 return ircError{&irc.Message{
876 Command: irc.ERR_NOSUCHCHANNEL,
877 Params: []string{dc.nick, name, "No such channel"},
878 }}
879 }
880
881 dc.SendMessage(&irc.Message{
882 Prefix: dc.srv.prefix(),
883 Command: irc.RPL_CHANNELMODEIS,
884 Params: []string{dc.nick, name, string(ch.modes)},
885 })
886 }
887 } else {
888 if name != dc.nick {
889 return ircError{&irc.Message{
890 Command: irc.ERR_USERSDONTMATCH,
891 Params: []string{dc.nick, "Cannot change mode for other users"},
892 }}
893 }
894
895 if modeStr != "" {
896 dc.forEachUpstream(func(uc *upstreamConn) {
897 uc.SendMessage(&irc.Message{
898 Command: "MODE",
899 Params: []string{uc.nick, modeStr},
900 })
901 })
902 } else {
903 dc.SendMessage(&irc.Message{
904 Prefix: dc.srv.prefix(),
905 Command: irc.RPL_UMODEIS,
906 Params: []string{dc.nick, ""}, // TODO
907 })
908 }
909 }
910 case "WHO":
911 if len(msg.Params) == 0 {
912 // TODO: support WHO without parameters
913 dc.SendMessage(&irc.Message{
914 Prefix: dc.srv.prefix(),
915 Command: irc.RPL_ENDOFWHO,
916 Params: []string{dc.nick, "*", "End of /WHO list."},
917 })
918 return nil
919 }
920
921 // TODO: support WHO masks
922 entity := msg.Params[0]
923
924 uc, upstreamName, err := dc.unmarshalEntity(entity)
925 if err != nil {
926 return err
927 }
928
929 var params []string
930 if len(msg.Params) == 2 {
931 params = []string{upstreamName, msg.Params[1]}
932 } else {
933 params = []string{upstreamName}
934 }
935
936 uc.SendMessage(&irc.Message{
937 Command: "WHO",
938 Params: params,
939 })
940 case "WHOIS":
941 if len(msg.Params) == 0 {
942 return ircError{&irc.Message{
943 Command: irc.ERR_NONICKNAMEGIVEN,
944 Params: []string{dc.nick, "No nickname given"},
945 }}
946 }
947
948 var target, mask string
949 if len(msg.Params) == 1 {
950 target = ""
951 mask = msg.Params[0]
952 } else {
953 target = msg.Params[0]
954 mask = msg.Params[1]
955 }
956 // TODO: support multiple WHOIS users
957 if i := strings.IndexByte(mask, ','); i >= 0 {
958 mask = mask[:i]
959 }
960
961 // TODO: support WHOIS masks
962 uc, upstreamNick, err := dc.unmarshalEntity(mask)
963 if err != nil {
964 return err
965 }
966
967 var params []string
968 if target != "" {
969 params = []string{target, upstreamNick}
970 } else {
971 params = []string{upstreamNick}
972 }
973
974 uc.SendMessage(&irc.Message{
975 Command: "WHOIS",
976 Params: params,
977 })
978 case "PRIVMSG":
979 var targetsStr, text string
980 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
981 return err
982 }
983
984 for _, name := range strings.Split(targetsStr, ",") {
985 if name == serviceNick {
986 handleServicePRIVMSG(dc, text)
987 continue
988 }
989
990 uc, upstreamName, err := dc.unmarshalEntity(name)
991 if err != nil {
992 return err
993 }
994
995 if upstreamName == "NickServ" {
996 dc.handleNickServPRIVMSG(uc, text)
997 }
998
999 uc.SendMessage(&irc.Message{
1000 Command: "PRIVMSG",
1001 Params: []string{upstreamName, text},
1002 })
1003
1004 echoMsg := &irc.Message{
1005 Prefix: &irc.Prefix{
1006 Name: uc.nick,
1007 User: uc.username,
1008 },
1009 Command: "PRIVMSG",
1010 Params: []string{upstreamName, text},
1011 }
1012 dc.lock.Lock()
1013 dc.ourMessages[echoMsg] = struct{}{}
1014 dc.lock.Unlock()
1015
1016 uc.ring.Produce(echoMsg)
1017 }
1018 default:
1019 dc.logger.Printf("unhandled message: %v", msg)
1020 return newUnknownCommandError(msg.Command)
1021 }
1022 return nil
1023}
1024
1025func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1026 username, password, ok := parseNickServCredentials(text, uc.nick)
1027 if !ok {
1028 return
1029 }
1030
1031 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1032 n := uc.network
1033 n.SASL.Mechanism = "PLAIN"
1034 n.SASL.Plain.Username = username
1035 n.SASL.Plain.Password = password
1036 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1037 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1038 }
1039}
1040
1041func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1042 fields := strings.Fields(text)
1043 if len(fields) < 2 {
1044 return "", "", false
1045 }
1046 cmd := strings.ToUpper(fields[0])
1047 params := fields[1:]
1048 switch cmd {
1049 case "REGISTER":
1050 username = nick
1051 password = params[0]
1052 case "IDENTIFY":
1053 if len(params) == 1 {
1054 username = nick
1055 } else {
1056 username = params[0]
1057 }
1058 password = params[1]
1059 }
1060 return username, password, true
1061}
Note: See TracBrowser for help on using the repository browser.