source: code/trunk/downstream.go@ 244

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

Make Ring.NewConsumer seq argument mandatory

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