source: code/trunk/downstream.go@ 117

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

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