source: code/trunk/downstream.go@ 133

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

Avoid sending JOIN twice for the same channel
File size: 23.6 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 dc.SendMessage(&irc.Message{
704 Prefix: dc.prefix(),
705 Command: "JOIN",
706 Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
707 })
708
709 forwardChannel(dc, ch)
710 }
711 }
712
713 historyName := dc.rawUsername
714
715 var seqPtr *uint64
716 if firstDownstream {
717 uc.network.lock.Lock()
718 seq, ok := uc.network.history[historyName]
719 uc.network.lock.Unlock()
720 if ok {
721 seqPtr = &seq
722 }
723 }
724
725 consumer, ch := uc.ring.NewConsumer(seqPtr)
726 go func() {
727 for {
728 var closed bool
729 select {
730 case <-ch:
731 dc.ringMessages <- ringMessage{consumer, uc}
732 case <-dc.closed:
733 closed = true
734 }
735 if closed {
736 break
737 }
738 }
739
740 seq := consumer.Close()
741
742 dc.user.lock.Lock()
743 lastDownstream := len(dc.user.downstreamConns) == 0
744 dc.user.lock.Unlock()
745
746 if lastDownstream {
747 uc.network.lock.Lock()
748 uc.network.history[historyName] = seq
749 uc.network.lock.Unlock()
750 }
751 }()
752 })
753
754 return nil
755}
756
757func (dc *downstreamConn) runUntilRegistered() error {
758 for !dc.registered {
759 msg, err := dc.irc.ReadMessage()
760 if err != nil {
761 return fmt.Errorf("failed to read IRC command: %v", err)
762 }
763
764 if dc.srv.Debug {
765 dc.logger.Printf("received: %v", msg)
766 }
767
768 err = dc.handleMessage(msg)
769 if ircErr, ok := err.(ircError); ok {
770 ircErr.Message.Prefix = dc.srv.prefix()
771 dc.SendMessage(ircErr.Message)
772 } else if err != nil {
773 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
774 }
775 }
776
777 return nil
778}
779
780func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
781 switch msg.Command {
782 case "CAP":
783 var subCmd string
784 if err := parseMessageParams(msg, &subCmd); err != nil {
785 return err
786 }
787 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
788 return err
789 }
790 case "PING":
791 dc.SendMessage(&irc.Message{
792 Prefix: dc.srv.prefix(),
793 Command: "PONG",
794 Params: msg.Params,
795 })
796 return nil
797 case "USER":
798 return ircError{&irc.Message{
799 Command: irc.ERR_ALREADYREGISTERED,
800 Params: []string{dc.nick, "You may not reregister"},
801 }}
802 case "NICK":
803 var nick string
804 if err := parseMessageParams(msg, &nick); err != nil {
805 return err
806 }
807
808 var err error
809 dc.forEachNetwork(func(n *network) {
810 if err != nil {
811 return
812 }
813 n.Nick = nick
814 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
815 })
816 if err != nil {
817 return err
818 }
819
820 dc.forEachUpstream(func(uc *upstreamConn) {
821 uc.SendMessage(msg)
822 })
823 case "JOIN", "PART":
824 var name string
825 if err := parseMessageParams(msg, &name); err != nil {
826 return err
827 }
828
829 uc, upstreamName, err := dc.unmarshalEntity(name)
830 if err != nil {
831 return ircError{&irc.Message{
832 Command: irc.ERR_NOSUCHCHANNEL,
833 Params: []string{name, err.Error()},
834 }}
835 }
836
837 uc.SendMessage(&irc.Message{
838 Command: msg.Command,
839 Params: []string{upstreamName},
840 })
841
842 switch msg.Command {
843 case "JOIN":
844 err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
845 Name: upstreamName,
846 })
847 if err != nil {
848 dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
849 }
850 case "PART":
851 if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
852 dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
853 }
854 }
855 case "MODE":
856 var name string
857 if err := parseMessageParams(msg, &name); err != nil {
858 return err
859 }
860
861 var modeStr string
862 if len(msg.Params) > 1 {
863 modeStr = msg.Params[1]
864 }
865
866 uc, upstreamName, err := dc.unmarshalEntity(name)
867 if err != nil {
868 return err
869 }
870
871 if uc.isChannel(upstreamName) {
872 // TODO: handle MODE channel mode arguments
873 if modeStr != "" {
874 uc.SendMessage(&irc.Message{
875 Command: "MODE",
876 Params: []string{upstreamName, modeStr},
877 })
878 } else {
879 ch, ok := uc.channels[upstreamName]
880 if !ok {
881 return ircError{&irc.Message{
882 Command: irc.ERR_NOSUCHCHANNEL,
883 Params: []string{dc.nick, name, "No such channel"},
884 }}
885 }
886
887 dc.SendMessage(&irc.Message{
888 Prefix: dc.srv.prefix(),
889 Command: irc.RPL_CHANNELMODEIS,
890 Params: []string{dc.nick, name, string(ch.modes)},
891 })
892 }
893 } else {
894 if name != dc.nick {
895 return ircError{&irc.Message{
896 Command: irc.ERR_USERSDONTMATCH,
897 Params: []string{dc.nick, "Cannot change mode for other users"},
898 }}
899 }
900
901 if modeStr != "" {
902 dc.forEachUpstream(func(uc *upstreamConn) {
903 uc.SendMessage(&irc.Message{
904 Command: "MODE",
905 Params: []string{uc.nick, modeStr},
906 })
907 })
908 } else {
909 dc.SendMessage(&irc.Message{
910 Prefix: dc.srv.prefix(),
911 Command: irc.RPL_UMODEIS,
912 Params: []string{dc.nick, ""}, // TODO
913 })
914 }
915 }
916 case "WHO":
917 if len(msg.Params) == 0 {
918 // TODO: support WHO without parameters
919 dc.SendMessage(&irc.Message{
920 Prefix: dc.srv.prefix(),
921 Command: irc.RPL_ENDOFWHO,
922 Params: []string{dc.nick, "*", "End of /WHO list."},
923 })
924 return nil
925 }
926
927 // TODO: support WHO masks
928 entity := msg.Params[0]
929
930 uc, upstreamName, err := dc.unmarshalEntity(entity)
931 if err != nil {
932 return err
933 }
934
935 var params []string
936 if len(msg.Params) == 2 {
937 params = []string{upstreamName, msg.Params[1]}
938 } else {
939 params = []string{upstreamName}
940 }
941
942 uc.SendMessage(&irc.Message{
943 Command: "WHO",
944 Params: params,
945 })
946 case "WHOIS":
947 if len(msg.Params) == 0 {
948 return ircError{&irc.Message{
949 Command: irc.ERR_NONICKNAMEGIVEN,
950 Params: []string{dc.nick, "No nickname given"},
951 }}
952 }
953
954 var target, mask string
955 if len(msg.Params) == 1 {
956 target = ""
957 mask = msg.Params[0]
958 } else {
959 target = msg.Params[0]
960 mask = msg.Params[1]
961 }
962 // TODO: support multiple WHOIS users
963 if i := strings.IndexByte(mask, ','); i >= 0 {
964 mask = mask[:i]
965 }
966
967 // TODO: support WHOIS masks
968 uc, upstreamNick, err := dc.unmarshalEntity(mask)
969 if err != nil {
970 return err
971 }
972
973 var params []string
974 if target != "" {
975 params = []string{target, upstreamNick}
976 } else {
977 params = []string{upstreamNick}
978 }
979
980 uc.SendMessage(&irc.Message{
981 Command: "WHOIS",
982 Params: params,
983 })
984 case "PRIVMSG":
985 var targetsStr, text string
986 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
987 return err
988 }
989
990 for _, name := range strings.Split(targetsStr, ",") {
991 if name == serviceNick {
992 handleServicePRIVMSG(dc, text)
993 continue
994 }
995
996 uc, upstreamName, err := dc.unmarshalEntity(name)
997 if err != nil {
998 return err
999 }
1000
1001 if upstreamName == "NickServ" {
1002 dc.handleNickServPRIVMSG(uc, text)
1003 }
1004
1005 uc.SendMessage(&irc.Message{
1006 Command: "PRIVMSG",
1007 Params: []string{upstreamName, text},
1008 })
1009
1010 echoMsg := &irc.Message{
1011 Prefix: &irc.Prefix{
1012 Name: uc.nick,
1013 User: uc.username,
1014 },
1015 Command: "PRIVMSG",
1016 Params: []string{upstreamName, text},
1017 }
1018 dc.lock.Lock()
1019 dc.ourMessages[echoMsg] = struct{}{}
1020 dc.lock.Unlock()
1021
1022 uc.ring.Produce(echoMsg)
1023 }
1024 default:
1025 dc.logger.Printf("unhandled message: %v", msg)
1026 return newUnknownCommandError(msg.Command)
1027 }
1028 return nil
1029}
1030
1031func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1032 username, password, ok := parseNickServCredentials(text, uc.nick)
1033 if !ok {
1034 return
1035 }
1036
1037 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1038 n := uc.network
1039 n.SASL.Mechanism = "PLAIN"
1040 n.SASL.Plain.Username = username
1041 n.SASL.Plain.Password = password
1042 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1043 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1044 }
1045}
1046
1047func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1048 fields := strings.Fields(text)
1049 if len(fields) < 2 {
1050 return "", "", false
1051 }
1052 cmd := strings.ToUpper(fields[0])
1053 params := fields[1:]
1054 switch cmd {
1055 case "REGISTER":
1056 username = nick
1057 password = params[0]
1058 case "IDENTIFY":
1059 if len(params) == 1 {
1060 username = nick
1061 } else {
1062 username = params[0]
1063 }
1064 password = params[1]
1065 }
1066 return username, password, true
1067}
Note: See TracBrowser for help on using the repository browser.