source: code/trunk/downstream.go@ 231

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

Remove downstreamConn.ringConsumers

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