source: code/trunk/downstream.go@ 129

Last change on this file since 129 was 129, checked in by delthas, 5 years ago

Fix MODE downstream support

  • Fix replies without client as first argument
  • Replace wrong prefix check with a proper entity type check
File size: 23.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 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 return dc
112}
113
114func (dc *downstreamConn) prefix() *irc.Prefix {
115 return &irc.Prefix{
116 Name: dc.nick,
117 User: dc.username,
118 // TODO: fill the host?
119 }
120}
121
122func (dc *downstreamConn) forEachNetwork(f func(*network)) {
123 if dc.network != nil {
124 f(dc.network)
125 } else {
126 dc.user.forEachNetwork(f)
127 }
128}
129
130func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
131 dc.user.forEachUpstream(func(uc *upstreamConn) {
132 if dc.network != nil && uc.network != dc.network {
133 return
134 }
135 f(uc)
136 })
137}
138
139// upstream returns the upstream connection, if any. If there are zero or if
140// there are multiple upstream connections, it returns nil.
141func (dc *downstreamConn) upstream() *upstreamConn {
142 if dc.network == nil {
143 return nil
144 }
145
146 var upstream *upstreamConn
147 dc.forEachUpstream(func(uc *upstreamConn) {
148 upstream = uc
149 })
150 return upstream
151}
152
153func (dc *downstreamConn) marshalEntity(uc *upstreamConn, entity string) string {
154 if uc.isChannel(entity) {
155 return dc.marshalChannel(uc, entity)
156 }
157 return dc.marshalNick(uc, entity)
158}
159
160func (dc *downstreamConn) marshalChannel(uc *upstreamConn, name string) string {
161 if dc.upstream() != nil {
162 return name
163 }
164 return name + "/" + uc.network.GetName()
165}
166
167func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
168 if uc := dc.upstream(); uc != nil {
169 return uc, name, nil
170 }
171
172 var conn *upstreamConn
173 if i := strings.LastIndexByte(name, '/'); i >= 0 {
174 network := name[i+1:]
175 name = name[:i]
176
177 dc.forEachUpstream(func(uc *upstreamConn) {
178 if network != uc.network.GetName() {
179 return
180 }
181 conn = uc
182 })
183 }
184
185 if conn == nil {
186 return nil, "", ircError{&irc.Message{
187 Command: irc.ERR_NOSUCHCHANNEL,
188 Params: []string{name, "No such channel"},
189 }}
190 }
191 return conn, name, nil
192}
193
194func (dc *downstreamConn) marshalNick(uc *upstreamConn, nick string) string {
195 if nick == uc.nick {
196 return dc.nick
197 }
198 if dc.upstream() != nil {
199 return nick
200 }
201 return nick + "/" + uc.network.GetName()
202}
203
204func (dc *downstreamConn) marshalUserPrefix(uc *upstreamConn, prefix *irc.Prefix) *irc.Prefix {
205 if prefix.Name == uc.nick {
206 return dc.prefix()
207 }
208 if dc.upstream() != nil {
209 return prefix
210 }
211 return &irc.Prefix{
212 Name: prefix.Name + "/" + uc.network.GetName(),
213 User: prefix.User,
214 Host: prefix.Host,
215 }
216}
217
218func (dc *downstreamConn) isClosed() bool {
219 select {
220 case <-dc.closed:
221 return true
222 default:
223 return false
224 }
225}
226
227func (dc *downstreamConn) readMessages(ch chan<- downstreamIncomingMessage) error {
228 dc.logger.Printf("new connection")
229
230 for {
231 msg, err := dc.irc.ReadMessage()
232 if err == io.EOF {
233 break
234 } else if err != nil {
235 return fmt.Errorf("failed to read IRC command: %v", err)
236 }
237
238 if dc.srv.Debug {
239 dc.logger.Printf("received: %v", msg)
240 }
241
242 ch <- downstreamIncomingMessage{msg, dc}
243 }
244
245 return nil
246}
247
248func (dc *downstreamConn) writeMessages() error {
249 for {
250 var err error
251 var closed bool
252 select {
253 case msg := <-dc.outgoing:
254 if dc.srv.Debug {
255 dc.logger.Printf("sent: %v", msg)
256 }
257 err = dc.irc.WriteMessage(msg)
258 case ringMessage := <-dc.ringMessages:
259 consumer, uc := ringMessage.consumer, ringMessage.upstreamConn
260 for {
261 msg := consumer.Peek()
262 if msg == nil {
263 break
264 }
265
266 dc.lock.Lock()
267 _, ours := dc.ourMessages[msg]
268 delete(dc.ourMessages, msg)
269 dc.lock.Unlock()
270 if ours {
271 // The message comes from our connection, don't echo it
272 // back
273 consumer.Consume()
274 continue
275 }
276
277 msg = msg.Copy()
278 switch msg.Command {
279 case "PRIVMSG":
280 msg.Prefix = dc.marshalUserPrefix(uc, msg.Prefix)
281 msg.Params[0] = dc.marshalEntity(uc, msg.Params[0])
282 default:
283 panic("expected to consume a PRIVMSG message")
284 }
285 if dc.srv.Debug {
286 dc.logger.Printf("sent: %v", msg)
287 }
288 err = dc.irc.WriteMessage(msg)
289 if err != nil {
290 break
291 }
292 consumer.Consume()
293 }
294 case <-dc.closed:
295 closed = true
296 }
297 if err != nil {
298 return err
299 }
300 if closed {
301 break
302 }
303 }
304 return nil
305}
306
307func (dc *downstreamConn) Close() error {
308 if dc.isClosed() {
309 return fmt.Errorf("downstream connection already closed")
310 }
311
312 if u := dc.user; u != nil {
313 u.lock.Lock()
314 for i := range u.downstreamConns {
315 if u.downstreamConns[i] == dc {
316 u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
317 break
318 }
319 }
320 u.lock.Unlock()
321 }
322
323 close(dc.closed)
324 return nil
325}
326
327func (dc *downstreamConn) SendMessage(msg *irc.Message) {
328 dc.outgoing <- msg
329}
330
331func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
332 switch msg.Command {
333 case "QUIT":
334 return dc.Close()
335 default:
336 if dc.registered {
337 return dc.handleMessageRegistered(msg)
338 } else {
339 return dc.handleMessageUnregistered(msg)
340 }
341 }
342}
343
344func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
345 switch msg.Command {
346 case "NICK":
347 var nick string
348 if err := parseMessageParams(msg, &nick); err != nil {
349 return err
350 }
351 if nick == serviceNick {
352 return ircError{&irc.Message{
353 Command: irc.ERR_NICKNAMEINUSE,
354 Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
355 }}
356 }
357 dc.nick = nick
358 case "USER":
359 if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
360 return err
361 }
362 case "PASS":
363 if err := parseMessageParams(msg, &dc.password); err != nil {
364 return err
365 }
366 case "CAP":
367 var subCmd string
368 if err := parseMessageParams(msg, &subCmd); err != nil {
369 return err
370 }
371 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
372 return err
373 }
374 case "AUTHENTICATE":
375 if !dc.caps["sasl"] {
376 return ircError{&irc.Message{
377 Command: irc.ERR_SASLFAIL,
378 Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
379 }}
380 }
381 if len(msg.Params) == 0 {
382 return ircError{&irc.Message{
383 Command: irc.ERR_SASLFAIL,
384 Params: []string{"*", "Missing AUTHENTICATE argument"},
385 }}
386 }
387 if dc.nick == "" {
388 return ircError{&irc.Message{
389 Command: irc.ERR_SASLFAIL,
390 Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
391 }}
392 }
393
394 var resp []byte
395 if dc.saslServer == nil {
396 mech := strings.ToUpper(msg.Params[0])
397 switch mech {
398 case "PLAIN":
399 dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
400 return dc.authenticate(username, password)
401 }))
402 default:
403 return ircError{&irc.Message{
404 Command: irc.ERR_SASLFAIL,
405 Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
406 }}
407 }
408 } else if msg.Params[0] == "*" {
409 dc.saslServer = nil
410 return ircError{&irc.Message{
411 Command: irc.ERR_SASLABORTED,
412 Params: []string{"*", "SASL authentication aborted"},
413 }}
414 } else if msg.Params[0] == "+" {
415 resp = nil
416 } else {
417 // TODO: multi-line messages
418 var err error
419 resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
420 if err != nil {
421 dc.saslServer = nil
422 return ircError{&irc.Message{
423 Command: irc.ERR_SASLFAIL,
424 Params: []string{"*", "Invalid base64-encoded response"},
425 }}
426 }
427 }
428
429 challenge, done, err := dc.saslServer.Next(resp)
430 if err != nil {
431 dc.saslServer = nil
432 if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
433 return ircError{&irc.Message{
434 Command: irc.ERR_SASLFAIL,
435 Params: []string{"*", ircErr.Message.Params[1]},
436 }}
437 }
438 dc.SendMessage(&irc.Message{
439 Prefix: dc.srv.prefix(),
440 Command: irc.ERR_SASLFAIL,
441 Params: []string{"*", "SASL error"},
442 })
443 return fmt.Errorf("SASL authentication failed: %v", err)
444 } else if done {
445 dc.saslServer = nil
446 dc.SendMessage(&irc.Message{
447 Prefix: dc.srv.prefix(),
448 Command: irc.RPL_LOGGEDIN,
449 Params: []string{dc.nick, dc.nick, dc.user.Username, "You are now logged in"},
450 })
451 dc.SendMessage(&irc.Message{
452 Prefix: dc.srv.prefix(),
453 Command: irc.RPL_SASLSUCCESS,
454 Params: []string{dc.nick, "SASL authentication successful"},
455 })
456 } else {
457 challengeStr := "+"
458 if challenge != nil {
459 challengeStr = base64.StdEncoding.EncodeToString(challenge)
460 }
461
462 // TODO: multi-line messages
463 dc.SendMessage(&irc.Message{
464 Prefix: dc.srv.prefix(),
465 Command: "AUTHENTICATE",
466 Params: []string{challengeStr},
467 })
468 }
469 default:
470 dc.logger.Printf("unhandled message: %v", msg)
471 return newUnknownCommandError(msg.Command)
472 }
473 if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
474 return dc.register()
475 }
476 return nil
477}
478
479func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
480 cmd = strings.ToUpper(cmd)
481
482 replyTo := dc.nick
483 if !dc.registered {
484 replyTo = "*"
485 }
486
487 switch cmd {
488 case "LS":
489 if len(args) > 0 {
490 var err error
491 if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
492 return err
493 }
494 }
495
496 var caps []string
497 if dc.capVersion >= 302 {
498 caps = append(caps, "sasl=PLAIN")
499 } else {
500 caps = append(caps, "sasl")
501 }
502
503 // TODO: multi-line replies
504 dc.SendMessage(&irc.Message{
505 Prefix: dc.srv.prefix(),
506 Command: "CAP",
507 Params: []string{replyTo, "LS", strings.Join(caps, " ")},
508 })
509
510 if !dc.registered {
511 dc.negociatingCaps = true
512 }
513 case "LIST":
514 var caps []string
515 for name := range dc.caps {
516 caps = append(caps, name)
517 }
518
519 // TODO: multi-line replies
520 dc.SendMessage(&irc.Message{
521 Prefix: dc.srv.prefix(),
522 Command: "CAP",
523 Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
524 })
525 case "REQ":
526 if len(args) == 0 {
527 return ircError{&irc.Message{
528 Command: err_invalidcapcmd,
529 Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
530 }}
531 }
532
533 caps := strings.Fields(args[0])
534 ack := true
535 for _, name := range caps {
536 name = strings.ToLower(name)
537 enable := !strings.HasPrefix(name, "-")
538 if !enable {
539 name = strings.TrimPrefix(name, "-")
540 }
541
542 enabled := dc.caps[name]
543 if enable == enabled {
544 continue
545 }
546
547 switch name {
548 case "sasl":
549 dc.caps[name] = enable
550 default:
551 ack = false
552 }
553 }
554
555 reply := "NAK"
556 if ack {
557 reply = "ACK"
558 }
559 dc.SendMessage(&irc.Message{
560 Prefix: dc.srv.prefix(),
561 Command: "CAP",
562 Params: []string{replyTo, reply, args[0]},
563 })
564 case "END":
565 dc.negociatingCaps = false
566 default:
567 return ircError{&irc.Message{
568 Command: err_invalidcapcmd,
569 Params: []string{replyTo, cmd, "Unknown CAP command"},
570 }}
571 }
572 return nil
573}
574
575func sanityCheckServer(addr string) error {
576 dialer := net.Dialer{Timeout: 30 * time.Second}
577 conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
578 if err != nil {
579 return err
580 }
581 return conn.Close()
582}
583
584func unmarshalUsername(rawUsername string) (username, network string) {
585 username = rawUsername
586 if i := strings.LastIndexAny(username, "/@"); i >= 0 {
587 network = username[i+1:]
588 }
589 if i := strings.IndexAny(username, "/@"); i >= 0 {
590 username = username[:i]
591 }
592 return username, network
593}
594
595func (dc *downstreamConn) setNetwork(networkName string) error {
596 if networkName == "" {
597 return nil
598 }
599
600 network := dc.user.getNetwork(networkName)
601 if network == nil {
602 addr := networkName
603 if !strings.ContainsRune(addr, ':') {
604 addr = addr + ":6697"
605 }
606
607 dc.logger.Printf("trying to connect to new network %q", addr)
608 if err := sanityCheckServer(addr); err != nil {
609 dc.logger.Printf("failed to connect to %q: %v", addr, err)
610 return ircError{&irc.Message{
611 Command: irc.ERR_PASSWDMISMATCH,
612 Params: []string{"*", fmt.Sprintf("Failed to connect to %q", networkName)},
613 }}
614 }
615
616 dc.logger.Printf("auto-saving network %q", networkName)
617 var err error
618 network, err = dc.user.createNetwork(&Network{
619 Addr: networkName,
620 Nick: dc.nick,
621 })
622 if err != nil {
623 return err
624 }
625 }
626
627 dc.network = network
628 return nil
629}
630
631func (dc *downstreamConn) authenticate(username, password string) error {
632 username, networkName := unmarshalUsername(username)
633
634 u := dc.srv.getUser(username)
635 if u == nil {
636 dc.logger.Printf("failed authentication for %q: unknown username", username)
637 return errAuthFailed
638 }
639
640 err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
641 if err != nil {
642 dc.logger.Printf("failed authentication for %q: %v", username, err)
643 return errAuthFailed
644 }
645
646 dc.user = u
647
648 return dc.setNetwork(networkName)
649}
650
651func (dc *downstreamConn) register() error {
652 password := dc.password
653 dc.password = ""
654 if dc.user == nil {
655 if err := dc.authenticate(dc.rawUsername, password); err != nil {
656 return err
657 }
658 } else if dc.network == nil {
659 _, networkName := unmarshalUsername(dc.rawUsername)
660 if err := dc.setNetwork(networkName); err != nil {
661 return err
662 }
663 }
664
665 dc.registered = true
666 dc.username = dc.user.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.lock.Lock()
712 seq, ok := uc.history[historyName]
713 uc.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.lock.Lock()
742 uc.history[historyName] = seq
743 uc.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.