source: code/trunk/downstream.go@ 252

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

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