source: code/trunk/downstream.go@ 184

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

Remove downstreamConn.username

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