source: code/trunk/downstream.go@ 145

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

Handle downstream JOIN/PART with multiple channel names

Closes: ​https://todo.sr.ht/~emersion/soju/19
File size: 26.1 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", "PART":
836 var names string
837 if err := parseMessageParams(msg, &names); err != nil {
838 return err
839 }
840
841 for _, name := range strings.Split(names, ",") {
842 uc, upstreamName, err := dc.unmarshalEntity(name)
843 if err != nil {
844 return ircError{&irc.Message{
845 Command: irc.ERR_NOSUCHCHANNEL,
846 Params: []string{name, err.Error()},
847 }}
848 }
849
850 uc.SendMessage(&irc.Message{
851 Command: msg.Command,
852 Params: []string{upstreamName},
853 })
854
855 switch msg.Command {
856 case "JOIN":
857 err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
858 Name: upstreamName,
859 })
860 if err != nil {
861 dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
862 }
863 case "PART":
864 if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
865 dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
866 }
867 }
868 }
869 case "MODE":
870 var name string
871 if err := parseMessageParams(msg, &name); err != nil {
872 return err
873 }
874
875 var modeStr string
876 if len(msg.Params) > 1 {
877 modeStr = msg.Params[1]
878 }
879
880 if name == dc.nick {
881 if modeStr != "" {
882 dc.forEachUpstream(func(uc *upstreamConn) {
883 uc.SendMessage(&irc.Message{
884 Command: "MODE",
885 Params: []string{uc.nick, modeStr},
886 })
887 })
888 } else {
889 dc.SendMessage(&irc.Message{
890 Prefix: dc.srv.prefix(),
891 Command: irc.RPL_UMODEIS,
892 Params: []string{dc.nick, ""}, // TODO
893 })
894 }
895 return nil
896 }
897
898 uc, upstreamName, err := dc.unmarshalEntity(name)
899 if err != nil {
900 return err
901 }
902
903 if !uc.isChannel(upstreamName) {
904 return ircError{&irc.Message{
905 Command: irc.ERR_USERSDONTMATCH,
906 Params: []string{dc.nick, "Cannot change mode for other users"},
907 }}
908 }
909
910 if modeStr != "" {
911 params := []string{upstreamName, modeStr}
912 params = append(params, msg.Params[2:]...)
913 uc.SendMessage(&irc.Message{
914 Command: "MODE",
915 Params: params,
916 })
917 } else {
918 ch, ok := uc.channels[upstreamName]
919 if !ok {
920 return ircError{&irc.Message{
921 Command: irc.ERR_NOSUCHCHANNEL,
922 Params: []string{dc.nick, name, "No such channel"},
923 }}
924 }
925
926 if ch.modes == nil {
927 // we haven't received the initial RPL_CHANNELMODEIS yet
928 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
929 return nil
930 }
931
932 modeStr, modeParams := ch.modes.Format()
933 params := []string{dc.nick, name, modeStr}
934 params = append(params, modeParams...)
935
936 dc.SendMessage(&irc.Message{
937 Prefix: dc.srv.prefix(),
938 Command: irc.RPL_CHANNELMODEIS,
939 Params: params,
940 })
941 }
942 case "NAMES":
943 if len(msg.Params) == 0 {
944 dc.SendMessage(&irc.Message{
945 Prefix: dc.srv.prefix(),
946 Command: irc.RPL_ENDOFNAMES,
947 Params: []string{dc.nick, "*", "End of /NAMES list"},
948 })
949 return nil
950 }
951
952 channels := strings.Split(msg.Params[0], ",")
953 for _, channel := range channels {
954 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
955 if err != nil {
956 return err
957 }
958
959 ch, ok := uc.channels[upstreamChannel]
960 if ok {
961 sendNames(dc, ch)
962 } else {
963 // NAMES on a channel we have not joined, ask upstream
964 uc.SendMessage(&irc.Message{
965 Command: "NAMES",
966 Params: []string{upstreamChannel},
967 })
968 }
969 }
970 case "WHO":
971 if len(msg.Params) == 0 {
972 // TODO: support WHO without parameters
973 dc.SendMessage(&irc.Message{
974 Prefix: dc.srv.prefix(),
975 Command: irc.RPL_ENDOFWHO,
976 Params: []string{dc.nick, "*", "End of /WHO list"},
977 })
978 return nil
979 }
980
981 // TODO: support WHO masks
982 entity := msg.Params[0]
983
984 if entity == dc.nick {
985 // TODO: support AWAY (H/G) in self WHO reply
986 dc.SendMessage(&irc.Message{
987 Prefix: dc.srv.prefix(),
988 Command: irc.RPL_WHOREPLY,
989 Params: []string{dc.nick, "*", dc.username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
990 })
991 dc.SendMessage(&irc.Message{
992 Prefix: dc.srv.prefix(),
993 Command: irc.RPL_ENDOFWHO,
994 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
995 })
996 return nil
997 }
998
999 uc, upstreamName, err := dc.unmarshalEntity(entity)
1000 if err != nil {
1001 return err
1002 }
1003
1004 var params []string
1005 if len(msg.Params) == 2 {
1006 params = []string{upstreamName, msg.Params[1]}
1007 } else {
1008 params = []string{upstreamName}
1009 }
1010
1011 uc.SendMessage(&irc.Message{
1012 Command: "WHO",
1013 Params: params,
1014 })
1015 case "WHOIS":
1016 if len(msg.Params) == 0 {
1017 return ircError{&irc.Message{
1018 Command: irc.ERR_NONICKNAMEGIVEN,
1019 Params: []string{dc.nick, "No nickname given"},
1020 }}
1021 }
1022
1023 var target, mask string
1024 if len(msg.Params) == 1 {
1025 target = ""
1026 mask = msg.Params[0]
1027 } else {
1028 target = msg.Params[0]
1029 mask = msg.Params[1]
1030 }
1031 // TODO: support multiple WHOIS users
1032 if i := strings.IndexByte(mask, ','); i >= 0 {
1033 mask = mask[:i]
1034 }
1035
1036 if mask == dc.nick {
1037 dc.SendMessage(&irc.Message{
1038 Prefix: dc.srv.prefix(),
1039 Command: irc.RPL_WHOISUSER,
1040 Params: []string{dc.nick, dc.nick, dc.username, dc.hostname, "*", dc.realname},
1041 })
1042 dc.SendMessage(&irc.Message{
1043 Prefix: dc.srv.prefix(),
1044 Command: irc.RPL_WHOISSERVER,
1045 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1046 })
1047 dc.SendMessage(&irc.Message{
1048 Prefix: dc.srv.prefix(),
1049 Command: irc.RPL_ENDOFWHOIS,
1050 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1051 })
1052 return nil
1053 }
1054
1055 // TODO: support WHOIS masks
1056 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1057 if err != nil {
1058 return err
1059 }
1060
1061 var params []string
1062 if target != "" {
1063 params = []string{target, upstreamNick}
1064 } else {
1065 params = []string{upstreamNick}
1066 }
1067
1068 uc.SendMessage(&irc.Message{
1069 Command: "WHOIS",
1070 Params: params,
1071 })
1072 case "PRIVMSG":
1073 var targetsStr, text string
1074 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1075 return err
1076 }
1077
1078 for _, name := range strings.Split(targetsStr, ",") {
1079 if name == serviceNick {
1080 handleServicePRIVMSG(dc, text)
1081 continue
1082 }
1083
1084 uc, upstreamName, err := dc.unmarshalEntity(name)
1085 if err != nil {
1086 return err
1087 }
1088
1089 if upstreamName == "NickServ" {
1090 dc.handleNickServPRIVMSG(uc, text)
1091 }
1092
1093 uc.SendMessage(&irc.Message{
1094 Command: "PRIVMSG",
1095 Params: []string{upstreamName, text},
1096 })
1097
1098 echoMsg := &irc.Message{
1099 Prefix: &irc.Prefix{
1100 Name: uc.nick,
1101 User: uc.username,
1102 },
1103 Command: "PRIVMSG",
1104 Params: []string{upstreamName, text},
1105 }
1106 dc.lock.Lock()
1107 dc.ourMessages[echoMsg] = struct{}{}
1108 dc.lock.Unlock()
1109
1110 uc.network.ring.Produce(echoMsg)
1111 }
1112 default:
1113 dc.logger.Printf("unhandled message: %v", msg)
1114 return newUnknownCommandError(msg.Command)
1115 }
1116 return nil
1117}
1118
1119func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1120 username, password, ok := parseNickServCredentials(text, uc.nick)
1121 if !ok {
1122 return
1123 }
1124
1125 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1126 n := uc.network
1127 n.SASL.Mechanism = "PLAIN"
1128 n.SASL.Plain.Username = username
1129 n.SASL.Plain.Password = password
1130 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1131 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1132 }
1133}
1134
1135func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1136 fields := strings.Fields(text)
1137 if len(fields) < 2 {
1138 return "", "", false
1139 }
1140 cmd := strings.ToUpper(fields[0])
1141 params := fields[1:]
1142 switch cmd {
1143 case "REGISTER":
1144 username = nick
1145 password = params[0]
1146 case "IDENTIFY":
1147 if len(params) == 1 {
1148 username = nick
1149 } else {
1150 username = params[0]
1151 }
1152 password = params[1]
1153 }
1154 return username, password, true
1155}
Note: See TracBrowser for help on using the repository browser.