source: code/trunk/downstream.go@ 153

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

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