source: code/trunk/downstream.go@ 119

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

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