source: code/trunk/downstream.go@ 214

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

Log self-messages too

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