source: code/trunk/downstream.go@ 227

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

Remove per-network ring buffer goroutines

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