source: code/trunk/downstream.go@ 193

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

Expose message-tags capability downstream

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