source: code/trunk/downstream.go@ 240

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

Make upstreamConn.produce log messages
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 var seqPtr *uint64
665 if sendHistory {
666 seq, ok := net.history[dc.clientName]
667 if ok {
668 seqPtr = &seq
669 }
670 }
671
672 consumer := net.ring.NewConsumer(seqPtr)
673
674 // TODO: this means all history is lost when trying to send it while the
675 // upstream is disconnected. We need to store history differently so that
676 // we don't need access to upstreamConn to forward it to a downstream
677 // client.
678 uc := net.upstream()
679 if uc == nil {
680 dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
681 return
682 }
683
684 for {
685 msg := consumer.Consume()
686 if msg == nil {
687 break
688 }
689
690 dc.sendFromUpstream(msg, uc)
691 }
692 })
693
694 return nil
695}
696
697func (dc *downstreamConn) runUntilRegistered() error {
698 for !dc.registered {
699 msg, err := dc.ReadMessage()
700 if err != nil {
701 return fmt.Errorf("failed to read IRC command: %v", err)
702 }
703
704 err = dc.handleMessage(msg)
705 if ircErr, ok := err.(ircError); ok {
706 ircErr.Message.Prefix = dc.srv.prefix()
707 dc.SendMessage(ircErr.Message)
708 } else if err != nil {
709 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
710 }
711 }
712
713 return nil
714}
715
716func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
717 switch msg.Command {
718 case "CAP":
719 var subCmd string
720 if err := parseMessageParams(msg, &subCmd); err != nil {
721 return err
722 }
723 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
724 return err
725 }
726 case "PING":
727 dc.SendMessage(&irc.Message{
728 Prefix: dc.srv.prefix(),
729 Command: "PONG",
730 Params: msg.Params,
731 })
732 return nil
733 case "USER":
734 return ircError{&irc.Message{
735 Command: irc.ERR_ALREADYREGISTERED,
736 Params: []string{dc.nick, "You may not reregister"},
737 }}
738 case "NICK":
739 var nick string
740 if err := parseMessageParams(msg, &nick); err != nil {
741 return err
742 }
743
744 var err error
745 dc.forEachNetwork(func(n *network) {
746 if err != nil {
747 return
748 }
749 n.Nick = nick
750 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
751 })
752 if err != nil {
753 return err
754 }
755
756 dc.forEachUpstream(func(uc *upstreamConn) {
757 uc.SendMessage(msg)
758 })
759 case "JOIN":
760 var namesStr string
761 if err := parseMessageParams(msg, &namesStr); err != nil {
762 return err
763 }
764
765 var keys []string
766 if len(msg.Params) > 1 {
767 keys = strings.Split(msg.Params[1], ",")
768 }
769
770 for i, name := range strings.Split(namesStr, ",") {
771 uc, upstreamName, err := dc.unmarshalEntity(name)
772 if err != nil {
773 return err
774 }
775
776 var key string
777 if len(keys) > i {
778 key = keys[i]
779 }
780
781 params := []string{upstreamName}
782 if key != "" {
783 params = append(params, key)
784 }
785 uc.SendMessage(&irc.Message{
786 Command: "JOIN",
787 Params: params,
788 })
789
790 ch := &Channel{Name: upstreamName, Key: key}
791 if err := uc.network.createUpdateChannel(ch); err != nil {
792 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
793 }
794 }
795 case "PART":
796 var namesStr string
797 if err := parseMessageParams(msg, &namesStr); err != nil {
798 return err
799 }
800
801 var reason string
802 if len(msg.Params) > 1 {
803 reason = msg.Params[1]
804 }
805
806 for _, name := range strings.Split(namesStr, ",") {
807 uc, upstreamName, err := dc.unmarshalEntity(name)
808 if err != nil {
809 return err
810 }
811
812 params := []string{upstreamName}
813 if reason != "" {
814 params = append(params, reason)
815 }
816 uc.SendMessage(&irc.Message{
817 Command: "PART",
818 Params: params,
819 })
820
821 if err := uc.network.deleteChannel(upstreamName); err != nil {
822 dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
823 }
824 }
825 case "KICK":
826 var channelStr, userStr string
827 if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
828 return err
829 }
830
831 channels := strings.Split(channelStr, ",")
832 users := strings.Split(userStr, ",")
833
834 var reason string
835 if len(msg.Params) > 2 {
836 reason = msg.Params[2]
837 }
838
839 if len(channels) != 1 && len(channels) != len(users) {
840 return ircError{&irc.Message{
841 Command: irc.ERR_BADCHANMASK,
842 Params: []string{dc.nick, channelStr, "Bad channel mask"},
843 }}
844 }
845
846 for i, user := range users {
847 var channel string
848 if len(channels) == 1 {
849 channel = channels[0]
850 } else {
851 channel = channels[i]
852 }
853
854 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
855 if err != nil {
856 return err
857 }
858
859 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
860 if err != nil {
861 return err
862 }
863
864 if ucChannel != ucUser {
865 return ircError{&irc.Message{
866 Command: irc.ERR_USERNOTINCHANNEL,
867 Params: []string{dc.nick, user, channel, "They aren't on that channel"},
868 }}
869 }
870 uc := ucChannel
871
872 params := []string{upstreamChannel, upstreamUser}
873 if reason != "" {
874 params = append(params, reason)
875 }
876 uc.SendMessage(&irc.Message{
877 Command: "KICK",
878 Params: params,
879 })
880 }
881 case "MODE":
882 var name string
883 if err := parseMessageParams(msg, &name); err != nil {
884 return err
885 }
886
887 var modeStr string
888 if len(msg.Params) > 1 {
889 modeStr = msg.Params[1]
890 }
891
892 if name == dc.nick {
893 if modeStr != "" {
894 dc.forEachUpstream(func(uc *upstreamConn) {
895 uc.SendMessage(&irc.Message{
896 Command: "MODE",
897 Params: []string{uc.nick, modeStr},
898 })
899 })
900 } else {
901 dc.SendMessage(&irc.Message{
902 Prefix: dc.srv.prefix(),
903 Command: irc.RPL_UMODEIS,
904 Params: []string{dc.nick, ""}, // TODO
905 })
906 }
907 return nil
908 }
909
910 uc, upstreamName, err := dc.unmarshalEntity(name)
911 if err != nil {
912 return err
913 }
914
915 if !uc.isChannel(upstreamName) {
916 return ircError{&irc.Message{
917 Command: irc.ERR_USERSDONTMATCH,
918 Params: []string{dc.nick, "Cannot change mode for other users"},
919 }}
920 }
921
922 if modeStr != "" {
923 params := []string{upstreamName, modeStr}
924 params = append(params, msg.Params[2:]...)
925 uc.SendMessage(&irc.Message{
926 Command: "MODE",
927 Params: params,
928 })
929 } else {
930 ch, ok := uc.channels[upstreamName]
931 if !ok {
932 return ircError{&irc.Message{
933 Command: irc.ERR_NOSUCHCHANNEL,
934 Params: []string{dc.nick, name, "No such channel"},
935 }}
936 }
937
938 if ch.modes == nil {
939 // we haven't received the initial RPL_CHANNELMODEIS yet
940 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
941 return nil
942 }
943
944 modeStr, modeParams := ch.modes.Format()
945 params := []string{dc.nick, name, modeStr}
946 params = append(params, modeParams...)
947
948 dc.SendMessage(&irc.Message{
949 Prefix: dc.srv.prefix(),
950 Command: irc.RPL_CHANNELMODEIS,
951 Params: params,
952 })
953 if ch.creationTime != "" {
954 dc.SendMessage(&irc.Message{
955 Prefix: dc.srv.prefix(),
956 Command: rpl_creationtime,
957 Params: []string{dc.nick, name, ch.creationTime},
958 })
959 }
960 }
961 case "TOPIC":
962 var channel string
963 if err := parseMessageParams(msg, &channel); err != nil {
964 return err
965 }
966
967 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
968 if err != nil {
969 return err
970 }
971
972 if len(msg.Params) > 1 { // setting topic
973 topic := msg.Params[1]
974 uc.SendMessage(&irc.Message{
975 Command: "TOPIC",
976 Params: []string{upstreamChannel, topic},
977 })
978 } else { // getting topic
979 ch, ok := uc.channels[upstreamChannel]
980 if !ok {
981 return ircError{&irc.Message{
982 Command: irc.ERR_NOSUCHCHANNEL,
983 Params: []string{dc.nick, upstreamChannel, "No such channel"},
984 }}
985 }
986 sendTopic(dc, ch)
987 }
988 case "LIST":
989 // TODO: support ELIST when supported by all upstreams
990
991 pl := pendingLIST{
992 downstreamID: dc.id,
993 pendingCommands: make(map[int64]*irc.Message),
994 }
995 var upstreamChannels map[int64][]string
996 if len(msg.Params) > 0 {
997 upstreamChannels = make(map[int64][]string)
998 channels := strings.Split(msg.Params[0], ",")
999 for _, channel := range channels {
1000 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1001 if err != nil {
1002 return err
1003 }
1004 upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
1005 }
1006 }
1007
1008 dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
1009 dc.forEachUpstream(func(uc *upstreamConn) {
1010 var params []string
1011 if upstreamChannels != nil {
1012 if channels, ok := upstreamChannels[uc.network.ID]; ok {
1013 params = []string{strings.Join(channels, ",")}
1014 } else {
1015 return
1016 }
1017 }
1018 pl.pendingCommands[uc.network.ID] = &irc.Message{
1019 Command: "LIST",
1020 Params: params,
1021 }
1022 uc.trySendLIST(dc.id)
1023 })
1024 case "NAMES":
1025 if len(msg.Params) == 0 {
1026 dc.SendMessage(&irc.Message{
1027 Prefix: dc.srv.prefix(),
1028 Command: irc.RPL_ENDOFNAMES,
1029 Params: []string{dc.nick, "*", "End of /NAMES list"},
1030 })
1031 return nil
1032 }
1033
1034 channels := strings.Split(msg.Params[0], ",")
1035 for _, channel := range channels {
1036 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1037 if err != nil {
1038 return err
1039 }
1040
1041 ch, ok := uc.channels[upstreamChannel]
1042 if ok {
1043 sendNames(dc, ch)
1044 } else {
1045 // NAMES on a channel we have not joined, ask upstream
1046 uc.SendMessageLabeled(dc.id, &irc.Message{
1047 Command: "NAMES",
1048 Params: []string{upstreamChannel},
1049 })
1050 }
1051 }
1052 case "WHO":
1053 if len(msg.Params) == 0 {
1054 // TODO: support WHO without parameters
1055 dc.SendMessage(&irc.Message{
1056 Prefix: dc.srv.prefix(),
1057 Command: irc.RPL_ENDOFWHO,
1058 Params: []string{dc.nick, "*", "End of /WHO list"},
1059 })
1060 return nil
1061 }
1062
1063 // TODO: support WHO masks
1064 entity := msg.Params[0]
1065
1066 if entity == dc.nick {
1067 // TODO: support AWAY (H/G) in self WHO reply
1068 dc.SendMessage(&irc.Message{
1069 Prefix: dc.srv.prefix(),
1070 Command: irc.RPL_WHOREPLY,
1071 Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
1072 })
1073 dc.SendMessage(&irc.Message{
1074 Prefix: dc.srv.prefix(),
1075 Command: irc.RPL_ENDOFWHO,
1076 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
1077 })
1078 return nil
1079 }
1080
1081 uc, upstreamName, err := dc.unmarshalEntity(entity)
1082 if err != nil {
1083 return err
1084 }
1085
1086 var params []string
1087 if len(msg.Params) == 2 {
1088 params = []string{upstreamName, msg.Params[1]}
1089 } else {
1090 params = []string{upstreamName}
1091 }
1092
1093 uc.SendMessageLabeled(dc.id, &irc.Message{
1094 Command: "WHO",
1095 Params: params,
1096 })
1097 case "WHOIS":
1098 if len(msg.Params) == 0 {
1099 return ircError{&irc.Message{
1100 Command: irc.ERR_NONICKNAMEGIVEN,
1101 Params: []string{dc.nick, "No nickname given"},
1102 }}
1103 }
1104
1105 var target, mask string
1106 if len(msg.Params) == 1 {
1107 target = ""
1108 mask = msg.Params[0]
1109 } else {
1110 target = msg.Params[0]
1111 mask = msg.Params[1]
1112 }
1113 // TODO: support multiple WHOIS users
1114 if i := strings.IndexByte(mask, ','); i >= 0 {
1115 mask = mask[:i]
1116 }
1117
1118 if mask == dc.nick {
1119 dc.SendMessage(&irc.Message{
1120 Prefix: dc.srv.prefix(),
1121 Command: irc.RPL_WHOISUSER,
1122 Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
1123 })
1124 dc.SendMessage(&irc.Message{
1125 Prefix: dc.srv.prefix(),
1126 Command: irc.RPL_WHOISSERVER,
1127 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1128 })
1129 dc.SendMessage(&irc.Message{
1130 Prefix: dc.srv.prefix(),
1131 Command: irc.RPL_ENDOFWHOIS,
1132 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1133 })
1134 return nil
1135 }
1136
1137 // TODO: support WHOIS masks
1138 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1139 if err != nil {
1140 return err
1141 }
1142
1143 var params []string
1144 if target != "" {
1145 params = []string{target, upstreamNick}
1146 } else {
1147 params = []string{upstreamNick}
1148 }
1149
1150 uc.SendMessageLabeled(dc.id, &irc.Message{
1151 Command: "WHOIS",
1152 Params: params,
1153 })
1154 case "PRIVMSG":
1155 var targetsStr, text string
1156 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1157 return err
1158 }
1159
1160 for _, name := range strings.Split(targetsStr, ",") {
1161 if name == serviceNick {
1162 handleServicePRIVMSG(dc, text)
1163 continue
1164 }
1165
1166 uc, upstreamName, err := dc.unmarshalEntity(name)
1167 if err != nil {
1168 return err
1169 }
1170
1171 if upstreamName == "NickServ" {
1172 dc.handleNickServPRIVMSG(uc, text)
1173 }
1174
1175 uc.SendMessage(&irc.Message{
1176 Command: "PRIVMSG",
1177 Params: []string{upstreamName, text},
1178 })
1179
1180 echoMsg := &irc.Message{
1181 Prefix: &irc.Prefix{
1182 Name: uc.nick,
1183 User: uc.username,
1184 },
1185 Command: "PRIVMSG",
1186 Params: []string{upstreamName, text},
1187 }
1188
1189 uc.produce(upstreamName, echoMsg, dc)
1190 }
1191 case "NOTICE":
1192 var targetsStr, text string
1193 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1194 return err
1195 }
1196
1197 for _, name := range strings.Split(targetsStr, ",") {
1198 uc, upstreamName, err := dc.unmarshalEntity(name)
1199 if err != nil {
1200 return err
1201 }
1202
1203 uc.SendMessage(&irc.Message{
1204 Command: "NOTICE",
1205 Params: []string{upstreamName, text},
1206 })
1207 }
1208 case "INVITE":
1209 var user, channel string
1210 if err := parseMessageParams(msg, &user, &channel); err != nil {
1211 return err
1212 }
1213
1214 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1215 if err != nil {
1216 return err
1217 }
1218
1219 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1220 if err != nil {
1221 return err
1222 }
1223
1224 if ucChannel != ucUser {
1225 return ircError{&irc.Message{
1226 Command: irc.ERR_USERNOTINCHANNEL,
1227 Params: []string{dc.nick, user, channel, "They aren't on that channel"},
1228 }}
1229 }
1230 uc := ucChannel
1231
1232 uc.SendMessageLabeled(dc.id, &irc.Message{
1233 Command: "INVITE",
1234 Params: []string{upstreamUser, upstreamChannel},
1235 })
1236 default:
1237 dc.logger.Printf("unhandled message: %v", msg)
1238 return newUnknownCommandError(msg.Command)
1239 }
1240 return nil
1241}
1242
1243func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1244 username, password, ok := parseNickServCredentials(text, uc.nick)
1245 if !ok {
1246 return
1247 }
1248
1249 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1250 n := uc.network
1251 n.SASL.Mechanism = "PLAIN"
1252 n.SASL.Plain.Username = username
1253 n.SASL.Plain.Password = password
1254 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1255 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1256 }
1257}
1258
1259func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1260 fields := strings.Fields(text)
1261 if len(fields) < 2 {
1262 return "", "", false
1263 }
1264 cmd := strings.ToUpper(fields[0])
1265 params := fields[1:]
1266 switch cmd {
1267 case "REGISTER":
1268 username = nick
1269 password = params[0]
1270 case "IDENTIFY":
1271 if len(params) == 1 {
1272 username = nick
1273 password = params[0]
1274 } else {
1275 username = params[0]
1276 password = params[1]
1277 }
1278 case "SET":
1279 if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
1280 username = nick
1281 password = params[1]
1282 }
1283 }
1284 return username, password, true
1285}
Note: See TracBrowser for help on using the repository browser.