source: code/trunk/downstream.go@ 143

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

Move upstreamConn.ring to network

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