source: code/trunk/downstream.go@ 258

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

Disallow marshalling for anotehr network
File size: 31.7 KB
Line 
1package soju
2
3import (
4 "crypto/tls"
5 "encoding/base64"
6 "fmt"
7 "io"
8 "net"
9 "strconv"
10 "strings"
11 "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, name string) string {
130 if dc.network != nil {
131 if dc.network != uc.network {
132 panic("soju: tried to marshal an entity for another network")
133 }
134 return name
135 }
136 if name == uc.nick {
137 return dc.nick
138 }
139 return name + "/" + uc.network.GetName()
140}
141
142func (dc *downstreamConn) marshalChannel(uc *upstreamConn, name string) string {
143 return dc.marshalEntity(uc, name)
144}
145
146func (dc *downstreamConn) marshalNick(uc *upstreamConn, name string) string {
147 return dc.marshalEntity(uc, name)
148}
149
150func (dc *downstreamConn) marshalUserPrefix(uc *upstreamConn, prefix *irc.Prefix) *irc.Prefix {
151 if prefix.Name == uc.nick {
152 return dc.prefix()
153 }
154 if dc.network != nil {
155 if dc.network != uc.network {
156 panic("soju: tried to marshal a user prefix for another network")
157 }
158 return prefix
159 }
160 return &irc.Prefix{
161 Name: prefix.Name + "/" + uc.network.GetName(),
162 User: prefix.User,
163 Host: prefix.Host,
164 }
165}
166
167// unmarshalEntity converts a downstream entity name (ie. channel or nick) into
168// an upstream entity name.
169//
170// This involves removing the "/<network>" suffix.
171func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
172 if uc := dc.upstream(); uc != nil {
173 return uc, name, nil
174 }
175
176 var conn *upstreamConn
177 if i := strings.LastIndexByte(name, '/'); i >= 0 {
178 network := name[i+1:]
179 name = name[:i]
180
181 dc.forEachUpstream(func(uc *upstreamConn) {
182 if network != uc.network.GetName() {
183 return
184 }
185 conn = uc
186 })
187 }
188
189 if conn == nil {
190 return nil, "", ircError{&irc.Message{
191 Command: irc.ERR_NOSUCHCHANNEL,
192 Params: []string{name, "No such channel"},
193 }}
194 }
195 return conn, name, nil
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", "batch"}
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", "batch":
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 dc.SendMessage(&irc.Message{
641 Prefix: dc.srv.prefix(),
642 Command: irc.RPL_WELCOME,
643 Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
644 })
645 dc.SendMessage(&irc.Message{
646 Prefix: dc.srv.prefix(),
647 Command: irc.RPL_YOURHOST,
648 Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
649 })
650 dc.SendMessage(&irc.Message{
651 Prefix: dc.srv.prefix(),
652 Command: irc.RPL_CREATED,
653 Params: []string{dc.nick, "Who cares when the server was created?"},
654 })
655 dc.SendMessage(&irc.Message{
656 Prefix: dc.srv.prefix(),
657 Command: irc.RPL_MYINFO,
658 Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
659 })
660 // TODO: RPL_ISUPPORT
661 dc.SendMessage(&irc.Message{
662 Prefix: dc.srv.prefix(),
663 Command: irc.ERR_NOMOTD,
664 Params: []string{dc.nick, "No MOTD"},
665 })
666
667 dc.forEachUpstream(func(uc *upstreamConn) {
668 for _, ch := range uc.channels {
669 if ch.complete {
670 dc.SendMessage(&irc.Message{
671 Prefix: dc.prefix(),
672 Command: "JOIN",
673 Params: []string{dc.marshalChannel(ch.conn, ch.Name)},
674 })
675
676 forwardChannel(dc, ch)
677 }
678 }
679 })
680
681 dc.forEachNetwork(func(net *network) {
682 // Only send history if we're the first connected client with that name
683 // for the network
684 if _, ok := net.offlineClients[dc.clientName]; ok {
685 dc.sendNetworkHistory(net)
686 delete(net.offlineClients, dc.clientName)
687 }
688 })
689
690 return nil
691}
692
693func (dc *downstreamConn) sendNetworkHistory(net *network) {
694 for target, history := range net.history {
695 seq, ok := history.offlineClients[dc.clientName]
696 if !ok {
697 continue
698 }
699 delete(history.offlineClients, dc.clientName)
700
701 // If all clients have received history, no need to keep the
702 // ring buffer around
703 if len(history.offlineClients) == 0 {
704 delete(net.history, target)
705 }
706
707 consumer := history.ring.NewConsumer(seq)
708
709 // TODO: this means all history is lost when trying to send it while the
710 // upstream is disconnected. We need to store history differently so that
711 // we don't need access to upstreamConn to forward it to a downstream
712 // client.
713 uc := net.upstream()
714 if uc == nil {
715 dc.logger.Printf("ignoring messages for upstream %q: upstream is disconnected", net.Addr)
716 return
717 }
718
719 batchRef := "history"
720 if dc.caps["batch"] {
721 dc.SendMessage(&irc.Message{
722 Prefix: dc.srv.prefix(),
723 Command: "BATCH",
724 Params: []string{"+" + batchRef, "chathistory", dc.marshalEntity(uc, target)},
725 })
726 }
727
728 for {
729 msg := consumer.Consume()
730 if msg == nil {
731 break
732 }
733
734 // Don't replay all messages, because that would mess up client
735 // state. For instance we just sent the list of users, sending
736 // PART messages for one of these users would be incorrect.
737 ignore := true
738 switch msg.Command {
739 case "PRIVMSG", "NOTICE":
740 ignore = false
741 }
742 if ignore {
743 continue
744 }
745
746 if dc.caps["batch"] {
747 msg = msg.Copy()
748 msg.Tags["batch"] = irc.TagValue(batchRef)
749 }
750
751 dc.SendMessage(dc.marshalMessage(msg, uc))
752 }
753
754 if dc.caps["batch"] {
755 dc.SendMessage(&irc.Message{
756 Prefix: dc.srv.prefix(),
757 Command: "BATCH",
758 Params: []string{"-" + batchRef},
759 })
760 }
761 }
762}
763
764func (dc *downstreamConn) runUntilRegistered() error {
765 for !dc.registered {
766 msg, err := dc.ReadMessage()
767 if err != nil {
768 return fmt.Errorf("failed to read IRC command: %v", err)
769 }
770
771 err = dc.handleMessage(msg)
772 if ircErr, ok := err.(ircError); ok {
773 ircErr.Message.Prefix = dc.srv.prefix()
774 dc.SendMessage(ircErr.Message)
775 } else if err != nil {
776 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
777 }
778 }
779
780 return nil
781}
782
783func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
784 switch msg.Command {
785 case "CAP":
786 var subCmd string
787 if err := parseMessageParams(msg, &subCmd); err != nil {
788 return err
789 }
790 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
791 return err
792 }
793 case "PING":
794 dc.SendMessage(&irc.Message{
795 Prefix: dc.srv.prefix(),
796 Command: "PONG",
797 Params: msg.Params,
798 })
799 return nil
800 case "USER":
801 return ircError{&irc.Message{
802 Command: irc.ERR_ALREADYREGISTERED,
803 Params: []string{dc.nick, "You may not reregister"},
804 }}
805 case "NICK":
806 var nick string
807 if err := parseMessageParams(msg, &nick); err != nil {
808 return err
809 }
810
811 var err error
812 dc.forEachNetwork(func(n *network) {
813 if err != nil {
814 return
815 }
816 n.Nick = nick
817 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
818 })
819 if err != nil {
820 return err
821 }
822
823 dc.forEachUpstream(func(uc *upstreamConn) {
824 uc.SendMessage(msg)
825 })
826 case "JOIN":
827 var namesStr string
828 if err := parseMessageParams(msg, &namesStr); err != nil {
829 return err
830 }
831
832 var keys []string
833 if len(msg.Params) > 1 {
834 keys = strings.Split(msg.Params[1], ",")
835 }
836
837 for i, name := range strings.Split(namesStr, ",") {
838 uc, upstreamName, err := dc.unmarshalEntity(name)
839 if err != nil {
840 return err
841 }
842
843 var key string
844 if len(keys) > i {
845 key = keys[i]
846 }
847
848 params := []string{upstreamName}
849 if key != "" {
850 params = append(params, key)
851 }
852 uc.SendMessage(&irc.Message{
853 Command: "JOIN",
854 Params: params,
855 })
856
857 ch := &Channel{Name: upstreamName, Key: key}
858 if err := uc.network.createUpdateChannel(ch); err != nil {
859 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
860 }
861 }
862 case "PART":
863 var namesStr string
864 if err := parseMessageParams(msg, &namesStr); err != nil {
865 return err
866 }
867
868 var reason string
869 if len(msg.Params) > 1 {
870 reason = msg.Params[1]
871 }
872
873 for _, name := range strings.Split(namesStr, ",") {
874 uc, upstreamName, err := dc.unmarshalEntity(name)
875 if err != nil {
876 return err
877 }
878
879 params := []string{upstreamName}
880 if reason != "" {
881 params = append(params, reason)
882 }
883 uc.SendMessage(&irc.Message{
884 Command: "PART",
885 Params: params,
886 })
887
888 if err := uc.network.deleteChannel(upstreamName); err != nil {
889 dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
890 }
891 }
892 case "KICK":
893 var channelStr, userStr string
894 if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
895 return err
896 }
897
898 channels := strings.Split(channelStr, ",")
899 users := strings.Split(userStr, ",")
900
901 var reason string
902 if len(msg.Params) > 2 {
903 reason = msg.Params[2]
904 }
905
906 if len(channels) != 1 && len(channels) != len(users) {
907 return ircError{&irc.Message{
908 Command: irc.ERR_BADCHANMASK,
909 Params: []string{dc.nick, channelStr, "Bad channel mask"},
910 }}
911 }
912
913 for i, user := range users {
914 var channel string
915 if len(channels) == 1 {
916 channel = channels[0]
917 } else {
918 channel = channels[i]
919 }
920
921 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
922 if err != nil {
923 return err
924 }
925
926 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
927 if err != nil {
928 return err
929 }
930
931 if ucChannel != ucUser {
932 return ircError{&irc.Message{
933 Command: irc.ERR_USERNOTINCHANNEL,
934 Params: []string{dc.nick, user, channel, "They aren't on that channel"},
935 }}
936 }
937 uc := ucChannel
938
939 params := []string{upstreamChannel, upstreamUser}
940 if reason != "" {
941 params = append(params, reason)
942 }
943 uc.SendMessage(&irc.Message{
944 Command: "KICK",
945 Params: params,
946 })
947 }
948 case "MODE":
949 var name string
950 if err := parseMessageParams(msg, &name); err != nil {
951 return err
952 }
953
954 var modeStr string
955 if len(msg.Params) > 1 {
956 modeStr = msg.Params[1]
957 }
958
959 if name == dc.nick {
960 if modeStr != "" {
961 dc.forEachUpstream(func(uc *upstreamConn) {
962 uc.SendMessage(&irc.Message{
963 Command: "MODE",
964 Params: []string{uc.nick, modeStr},
965 })
966 })
967 } else {
968 dc.SendMessage(&irc.Message{
969 Prefix: dc.srv.prefix(),
970 Command: irc.RPL_UMODEIS,
971 Params: []string{dc.nick, ""}, // TODO
972 })
973 }
974 return nil
975 }
976
977 uc, upstreamName, err := dc.unmarshalEntity(name)
978 if err != nil {
979 return err
980 }
981
982 if !uc.isChannel(upstreamName) {
983 return ircError{&irc.Message{
984 Command: irc.ERR_USERSDONTMATCH,
985 Params: []string{dc.nick, "Cannot change mode for other users"},
986 }}
987 }
988
989 if modeStr != "" {
990 params := []string{upstreamName, modeStr}
991 params = append(params, msg.Params[2:]...)
992 uc.SendMessage(&irc.Message{
993 Command: "MODE",
994 Params: params,
995 })
996 } else {
997 ch, ok := uc.channels[upstreamName]
998 if !ok {
999 return ircError{&irc.Message{
1000 Command: irc.ERR_NOSUCHCHANNEL,
1001 Params: []string{dc.nick, name, "No such channel"},
1002 }}
1003 }
1004
1005 if ch.modes == nil {
1006 // we haven't received the initial RPL_CHANNELMODEIS yet
1007 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
1008 return nil
1009 }
1010
1011 modeStr, modeParams := ch.modes.Format()
1012 params := []string{dc.nick, name, modeStr}
1013 params = append(params, modeParams...)
1014
1015 dc.SendMessage(&irc.Message{
1016 Prefix: dc.srv.prefix(),
1017 Command: irc.RPL_CHANNELMODEIS,
1018 Params: params,
1019 })
1020 if ch.creationTime != "" {
1021 dc.SendMessage(&irc.Message{
1022 Prefix: dc.srv.prefix(),
1023 Command: rpl_creationtime,
1024 Params: []string{dc.nick, name, ch.creationTime},
1025 })
1026 }
1027 }
1028 case "TOPIC":
1029 var channel string
1030 if err := parseMessageParams(msg, &channel); err != nil {
1031 return err
1032 }
1033
1034 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1035 if err != nil {
1036 return err
1037 }
1038
1039 if len(msg.Params) > 1 { // setting topic
1040 topic := msg.Params[1]
1041 uc.SendMessage(&irc.Message{
1042 Command: "TOPIC",
1043 Params: []string{upstreamChannel, topic},
1044 })
1045 } else { // getting topic
1046 ch, ok := uc.channels[upstreamChannel]
1047 if !ok {
1048 return ircError{&irc.Message{
1049 Command: irc.ERR_NOSUCHCHANNEL,
1050 Params: []string{dc.nick, upstreamChannel, "No such channel"},
1051 }}
1052 }
1053 sendTopic(dc, ch)
1054 }
1055 case "LIST":
1056 // TODO: support ELIST when supported by all upstreams
1057
1058 pl := pendingLIST{
1059 downstreamID: dc.id,
1060 pendingCommands: make(map[int64]*irc.Message),
1061 }
1062 var upstreamChannels map[int64][]string
1063 if len(msg.Params) > 0 {
1064 upstreamChannels = make(map[int64][]string)
1065 channels := strings.Split(msg.Params[0], ",")
1066 for _, channel := range channels {
1067 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1068 if err != nil {
1069 return err
1070 }
1071 upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
1072 }
1073 }
1074
1075 dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
1076 dc.forEachUpstream(func(uc *upstreamConn) {
1077 var params []string
1078 if upstreamChannels != nil {
1079 if channels, ok := upstreamChannels[uc.network.ID]; ok {
1080 params = []string{strings.Join(channels, ",")}
1081 } else {
1082 return
1083 }
1084 }
1085 pl.pendingCommands[uc.network.ID] = &irc.Message{
1086 Command: "LIST",
1087 Params: params,
1088 }
1089 uc.trySendLIST(dc.id)
1090 })
1091 case "NAMES":
1092 if len(msg.Params) == 0 {
1093 dc.SendMessage(&irc.Message{
1094 Prefix: dc.srv.prefix(),
1095 Command: irc.RPL_ENDOFNAMES,
1096 Params: []string{dc.nick, "*", "End of /NAMES list"},
1097 })
1098 return nil
1099 }
1100
1101 channels := strings.Split(msg.Params[0], ",")
1102 for _, channel := range channels {
1103 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1104 if err != nil {
1105 return err
1106 }
1107
1108 ch, ok := uc.channels[upstreamChannel]
1109 if ok {
1110 sendNames(dc, ch)
1111 } else {
1112 // NAMES on a channel we have not joined, ask upstream
1113 uc.SendMessageLabeled(dc.id, &irc.Message{
1114 Command: "NAMES",
1115 Params: []string{upstreamChannel},
1116 })
1117 }
1118 }
1119 case "WHO":
1120 if len(msg.Params) == 0 {
1121 // TODO: support WHO without parameters
1122 dc.SendMessage(&irc.Message{
1123 Prefix: dc.srv.prefix(),
1124 Command: irc.RPL_ENDOFWHO,
1125 Params: []string{dc.nick, "*", "End of /WHO list"},
1126 })
1127 return nil
1128 }
1129
1130 // TODO: support WHO masks
1131 entity := msg.Params[0]
1132
1133 if entity == dc.nick {
1134 // TODO: support AWAY (H/G) in self WHO reply
1135 dc.SendMessage(&irc.Message{
1136 Prefix: dc.srv.prefix(),
1137 Command: irc.RPL_WHOREPLY,
1138 Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
1139 })
1140 dc.SendMessage(&irc.Message{
1141 Prefix: dc.srv.prefix(),
1142 Command: irc.RPL_ENDOFWHO,
1143 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
1144 })
1145 return nil
1146 }
1147
1148 uc, upstreamName, err := dc.unmarshalEntity(entity)
1149 if err != nil {
1150 return err
1151 }
1152
1153 var params []string
1154 if len(msg.Params) == 2 {
1155 params = []string{upstreamName, msg.Params[1]}
1156 } else {
1157 params = []string{upstreamName}
1158 }
1159
1160 uc.SendMessageLabeled(dc.id, &irc.Message{
1161 Command: "WHO",
1162 Params: params,
1163 })
1164 case "WHOIS":
1165 if len(msg.Params) == 0 {
1166 return ircError{&irc.Message{
1167 Command: irc.ERR_NONICKNAMEGIVEN,
1168 Params: []string{dc.nick, "No nickname given"},
1169 }}
1170 }
1171
1172 var target, mask string
1173 if len(msg.Params) == 1 {
1174 target = ""
1175 mask = msg.Params[0]
1176 } else {
1177 target = msg.Params[0]
1178 mask = msg.Params[1]
1179 }
1180 // TODO: support multiple WHOIS users
1181 if i := strings.IndexByte(mask, ','); i >= 0 {
1182 mask = mask[:i]
1183 }
1184
1185 if mask == dc.nick {
1186 dc.SendMessage(&irc.Message{
1187 Prefix: dc.srv.prefix(),
1188 Command: irc.RPL_WHOISUSER,
1189 Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
1190 })
1191 dc.SendMessage(&irc.Message{
1192 Prefix: dc.srv.prefix(),
1193 Command: irc.RPL_WHOISSERVER,
1194 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1195 })
1196 dc.SendMessage(&irc.Message{
1197 Prefix: dc.srv.prefix(),
1198 Command: irc.RPL_ENDOFWHOIS,
1199 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1200 })
1201 return nil
1202 }
1203
1204 // TODO: support WHOIS masks
1205 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1206 if err != nil {
1207 return err
1208 }
1209
1210 var params []string
1211 if target != "" {
1212 params = []string{target, upstreamNick}
1213 } else {
1214 params = []string{upstreamNick}
1215 }
1216
1217 uc.SendMessageLabeled(dc.id, &irc.Message{
1218 Command: "WHOIS",
1219 Params: params,
1220 })
1221 case "PRIVMSG":
1222 var targetsStr, text string
1223 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1224 return err
1225 }
1226
1227 for _, name := range strings.Split(targetsStr, ",") {
1228 if name == serviceNick {
1229 handleServicePRIVMSG(dc, text)
1230 continue
1231 }
1232
1233 uc, upstreamName, err := dc.unmarshalEntity(name)
1234 if err != nil {
1235 return err
1236 }
1237
1238 if upstreamName == "NickServ" {
1239 dc.handleNickServPRIVMSG(uc, text)
1240 }
1241
1242 uc.SendMessage(&irc.Message{
1243 Command: "PRIVMSG",
1244 Params: []string{upstreamName, text},
1245 })
1246
1247 echoMsg := &irc.Message{
1248 Prefix: &irc.Prefix{
1249 Name: uc.nick,
1250 User: uc.username,
1251 },
1252 Command: "PRIVMSG",
1253 Params: []string{upstreamName, text},
1254 }
1255
1256 uc.produce(upstreamName, echoMsg, dc)
1257 }
1258 case "NOTICE":
1259 var targetsStr, text string
1260 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1261 return err
1262 }
1263
1264 for _, name := range strings.Split(targetsStr, ",") {
1265 uc, upstreamName, err := dc.unmarshalEntity(name)
1266 if err != nil {
1267 return err
1268 }
1269
1270 uc.SendMessage(&irc.Message{
1271 Command: "NOTICE",
1272 Params: []string{upstreamName, text},
1273 })
1274 }
1275 case "INVITE":
1276 var user, channel string
1277 if err := parseMessageParams(msg, &user, &channel); err != nil {
1278 return err
1279 }
1280
1281 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1282 if err != nil {
1283 return err
1284 }
1285
1286 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1287 if err != nil {
1288 return err
1289 }
1290
1291 if ucChannel != ucUser {
1292 return ircError{&irc.Message{
1293 Command: irc.ERR_USERNOTINCHANNEL,
1294 Params: []string{dc.nick, user, channel, "They aren't on that channel"},
1295 }}
1296 }
1297 uc := ucChannel
1298
1299 uc.SendMessageLabeled(dc.id, &irc.Message{
1300 Command: "INVITE",
1301 Params: []string{upstreamUser, upstreamChannel},
1302 })
1303 default:
1304 dc.logger.Printf("unhandled message: %v", msg)
1305 return newUnknownCommandError(msg.Command)
1306 }
1307 return nil
1308}
1309
1310func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1311 username, password, ok := parseNickServCredentials(text, uc.nick)
1312 if !ok {
1313 return
1314 }
1315
1316 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1317 n := uc.network
1318 n.SASL.Mechanism = "PLAIN"
1319 n.SASL.Plain.Username = username
1320 n.SASL.Plain.Password = password
1321 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1322 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1323 }
1324}
1325
1326func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1327 fields := strings.Fields(text)
1328 if len(fields) < 2 {
1329 return "", "", false
1330 }
1331 cmd := strings.ToUpper(fields[0])
1332 params := fields[1:]
1333 switch cmd {
1334 case "REGISTER":
1335 username = nick
1336 password = params[0]
1337 case "IDENTIFY":
1338 if len(params) == 1 {
1339 username = nick
1340 password = params[0]
1341 } else {
1342 username = params[0]
1343 password = params[1]
1344 }
1345 case "SET":
1346 if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
1347 username = nick
1348 password = params[1]
1349 }
1350 }
1351 return username, password, true
1352}
Note: See TracBrowser for help on using the repository browser.