source: code/trunk/downstream.go@ 216

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

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