source: code/trunk/downstream.go@ 136

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

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