source: code/trunk/downstream.go@ 186

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

Use clientName to decide whether or not history should be sent

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