source: code/trunk/downstream.go@ 228

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

Remove channel from ring buffer consumers

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