source: code/trunk/downstream.go@ 142

Last change on this file since 142 was 142, checked in by delthas, 5 years ago

Add downstream self WHO and WHOIS support
File size: 25.5 KB
Line 
1package soju
2
3import (
4 "crypto/tls"
5 "encoding/base64"
6 "fmt"
7 "io"
8 "net"
9 "strconv"
10 "strings"
11 "sync"
12 "time"
13
14 "github.com/emersion/go-sasl"
15 "golang.org/x/crypto/bcrypt"
16 "gopkg.in/irc.v3"
17)
18
19type ircError struct {
20 Message *irc.Message
21}
22
23func (err ircError) Error() string {
24 return err.Message.String()
25}
26
27func newUnknownCommandError(cmd string) ircError {
28 return ircError{&irc.Message{
29 Command: irc.ERR_UNKNOWNCOMMAND,
30 Params: []string{
31 "*",
32 cmd,
33 "Unknown command",
34 },
35 }}
36}
37
38func newNeedMoreParamsError(cmd string) ircError {
39 return ircError{&irc.Message{
40 Command: irc.ERR_NEEDMOREPARAMS,
41 Params: []string{
42 "*",
43 cmd,
44 "Not enough parameters",
45 },
46 }}
47}
48
49var errAuthFailed = ircError{&irc.Message{
50 Command: irc.ERR_PASSWDMISMATCH,
51 Params: []string{"*", "Invalid username or password"},
52}}
53
54type 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 historyName := dc.rawUsername
704
705 // TODO: need to take dc.network into account here
706 var seqPtr *uint64
707 if firstDownstream {
708 uc.network.lock.Lock()
709 seq, ok := uc.network.history[historyName]
710 uc.network.lock.Unlock()
711 if ok {
712 seqPtr = &seq
713 }
714 }
715
716 // TODO: we need to create a consumer when adding networks on-the-fly
717 consumer, ch := uc.ring.NewConsumer(seqPtr)
718 go func() {
719 for {
720 var closed bool
721 select {
722 case <-ch:
723 dc.ringMessages <- ringMessage{consumer, uc}
724 case <-dc.closed:
725 closed = true
726 }
727 if closed {
728 break
729 }
730 }
731
732 seq := consumer.Close()
733
734 // TODO: need to take dc.network into account here
735 dc.user.lock.Lock()
736 lastDownstream := len(dc.user.downstreamConns) == 0
737 dc.user.lock.Unlock()
738
739 if lastDownstream {
740 uc.network.lock.Lock()
741 uc.network.history[historyName] = seq
742 uc.network.lock.Unlock()
743 }
744 }()
745 })
746
747 return nil
748}
749
750func (dc *downstreamConn) runUntilRegistered() error {
751 for !dc.registered {
752 msg, err := dc.irc.ReadMessage()
753 if err != nil {
754 return fmt.Errorf("failed to read IRC command: %v", err)
755 }
756
757 if dc.srv.Debug {
758 dc.logger.Printf("received: %v", msg)
759 }
760
761 err = dc.handleMessage(msg)
762 if ircErr, ok := err.(ircError); ok {
763 ircErr.Message.Prefix = dc.srv.prefix()
764 dc.SendMessage(ircErr.Message)
765 } else if err != nil {
766 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
767 }
768 }
769
770 return nil
771}
772
773func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
774 switch msg.Command {
775 case "CAP":
776 var subCmd string
777 if err := parseMessageParams(msg, &subCmd); err != nil {
778 return err
779 }
780 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
781 return err
782 }
783 case "PING":
784 dc.SendMessage(&irc.Message{
785 Prefix: dc.srv.prefix(),
786 Command: "PONG",
787 Params: msg.Params,
788 })
789 return nil
790 case "USER":
791 return ircError{&irc.Message{
792 Command: irc.ERR_ALREADYREGISTERED,
793 Params: []string{dc.nick, "You may not reregister"},
794 }}
795 case "NICK":
796 var nick string
797 if err := parseMessageParams(msg, &nick); err != nil {
798 return err
799 }
800
801 var err error
802 dc.forEachNetwork(func(n *network) {
803 if err != nil {
804 return
805 }
806 n.Nick = nick
807 err = dc.srv.db.StoreNetwork(dc.user.Username, &n.Network)
808 })
809 if err != nil {
810 return err
811 }
812
813 dc.forEachUpstream(func(uc *upstreamConn) {
814 uc.SendMessage(msg)
815 })
816 case "JOIN", "PART":
817 var name string
818 if err := parseMessageParams(msg, &name); err != nil {
819 return err
820 }
821
822 uc, upstreamName, err := dc.unmarshalEntity(name)
823 if err != nil {
824 return ircError{&irc.Message{
825 Command: irc.ERR_NOSUCHCHANNEL,
826 Params: []string{name, err.Error()},
827 }}
828 }
829
830 uc.SendMessage(&irc.Message{
831 Command: msg.Command,
832 Params: []string{upstreamName},
833 })
834
835 switch msg.Command {
836 case "JOIN":
837 err := dc.srv.db.StoreChannel(uc.network.ID, &Channel{
838 Name: upstreamName,
839 })
840 if err != nil {
841 dc.logger.Printf("failed to create channel %q in DB: %v", upstreamName, err)
842 }
843 case "PART":
844 if err := dc.srv.db.DeleteChannel(uc.network.ID, upstreamName); err != nil {
845 dc.logger.Printf("failed to delete channel %q in DB: %v", upstreamName, err)
846 }
847 }
848 case "MODE":
849 var name string
850 if err := parseMessageParams(msg, &name); err != nil {
851 return err
852 }
853
854 var modeStr string
855 if len(msg.Params) > 1 {
856 modeStr = msg.Params[1]
857 }
858
859 if name == dc.nick {
860 if modeStr != "" {
861 dc.forEachUpstream(func(uc *upstreamConn) {
862 uc.SendMessage(&irc.Message{
863 Command: "MODE",
864 Params: []string{uc.nick, modeStr},
865 })
866 })
867 } else {
868 dc.SendMessage(&irc.Message{
869 Prefix: dc.srv.prefix(),
870 Command: irc.RPL_UMODEIS,
871 Params: []string{dc.nick, ""}, // TODO
872 })
873 }
874 return nil
875 }
876
877 uc, upstreamName, err := dc.unmarshalEntity(name)
878 if err != nil {
879 return err
880 }
881
882 if !uc.isChannel(upstreamName) {
883 return ircError{&irc.Message{
884 Command: irc.ERR_USERSDONTMATCH,
885 Params: []string{dc.nick, "Cannot change mode for other users"},
886 }}
887 }
888
889 if modeStr != "" {
890 params := []string{upstreamName, modeStr}
891 params = append(params, msg.Params[2:]...)
892 uc.SendMessage(&irc.Message{
893 Command: "MODE",
894 Params: params,
895 })
896 } else {
897 ch, ok := uc.channels[upstreamName]
898 if !ok {
899 return ircError{&irc.Message{
900 Command: irc.ERR_NOSUCHCHANNEL,
901 Params: []string{dc.nick, name, "No such channel"},
902 }}
903 }
904
905 if ch.modes == nil {
906 // we haven't received the initial RPL_CHANNELMODEIS yet
907 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
908 return nil
909 }
910
911 modeStr, modeParams := ch.modes.Format()
912 params := []string{dc.nick, name, modeStr}
913 params = append(params, modeParams...)
914
915 dc.SendMessage(&irc.Message{
916 Prefix: dc.srv.prefix(),
917 Command: irc.RPL_CHANNELMODEIS,
918 Params: params,
919 })
920 }
921 case "NAMES":
922 if len(msg.Params) == 0 {
923 dc.SendMessage(&irc.Message{
924 Prefix: dc.srv.prefix(),
925 Command: irc.RPL_ENDOFNAMES,
926 Params: []string{dc.nick, "*", "End of /NAMES list"},
927 })
928 return nil
929 }
930
931 channels := strings.Split(msg.Params[0], ",")
932 for _, channel := range channels {
933 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
934 if err != nil {
935 return err
936 }
937
938 ch, ok := uc.channels[upstreamChannel]
939 if ok {
940 sendNames(dc, ch)
941 } else {
942 // NAMES on a channel we have not joined, ask upstream
943 uc.SendMessage(&irc.Message{
944 Command: "NAMES",
945 Params: []string{upstreamChannel},
946 })
947 }
948 }
949 case "WHO":
950 if len(msg.Params) == 0 {
951 // TODO: support WHO without parameters
952 dc.SendMessage(&irc.Message{
953 Prefix: dc.srv.prefix(),
954 Command: irc.RPL_ENDOFWHO,
955 Params: []string{dc.nick, "*", "End of /WHO list"},
956 })
957 return nil
958 }
959
960 // TODO: support WHO masks
961 entity := msg.Params[0]
962
963 if entity == dc.nick {
964 // TODO: support AWAY (H/G) in self WHO reply
965 dc.SendMessage(&irc.Message{
966 Prefix: dc.srv.prefix(),
967 Command: irc.RPL_WHOREPLY,
968 Params: []string{dc.nick, "*", dc.username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
969 })
970 dc.SendMessage(&irc.Message{
971 Prefix: dc.srv.prefix(),
972 Command: irc.RPL_ENDOFWHO,
973 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
974 })
975 return nil
976 }
977
978 uc, upstreamName, err := dc.unmarshalEntity(entity)
979 if err != nil {
980 return err
981 }
982
983 var params []string
984 if len(msg.Params) == 2 {
985 params = []string{upstreamName, msg.Params[1]}
986 } else {
987 params = []string{upstreamName}
988 }
989
990 uc.SendMessage(&irc.Message{
991 Command: "WHO",
992 Params: params,
993 })
994 case "WHOIS":
995 if len(msg.Params) == 0 {
996 return ircError{&irc.Message{
997 Command: irc.ERR_NONICKNAMEGIVEN,
998 Params: []string{dc.nick, "No nickname given"},
999 }}
1000 }
1001
1002 var target, mask string
1003 if len(msg.Params) == 1 {
1004 target = ""
1005 mask = msg.Params[0]
1006 } else {
1007 target = msg.Params[0]
1008 mask = msg.Params[1]
1009 }
1010 // TODO: support multiple WHOIS users
1011 if i := strings.IndexByte(mask, ','); i >= 0 {
1012 mask = mask[:i]
1013 }
1014
1015 if mask == dc.nick {
1016 dc.SendMessage(&irc.Message{
1017 Prefix: dc.srv.prefix(),
1018 Command: irc.RPL_WHOISUSER,
1019 Params: []string{dc.nick, dc.nick, dc.username, dc.hostname, "*", dc.realname},
1020 })
1021 dc.SendMessage(&irc.Message{
1022 Prefix: dc.srv.prefix(),
1023 Command: irc.RPL_WHOISSERVER,
1024 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1025 })
1026 dc.SendMessage(&irc.Message{
1027 Prefix: dc.srv.prefix(),
1028 Command: irc.RPL_ENDOFWHOIS,
1029 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1030 })
1031 return nil
1032 }
1033
1034 // TODO: support WHOIS masks
1035 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1036 if err != nil {
1037 return err
1038 }
1039
1040 var params []string
1041 if target != "" {
1042 params = []string{target, upstreamNick}
1043 } else {
1044 params = []string{upstreamNick}
1045 }
1046
1047 uc.SendMessage(&irc.Message{
1048 Command: "WHOIS",
1049 Params: params,
1050 })
1051 case "PRIVMSG":
1052 var targetsStr, text string
1053 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1054 return err
1055 }
1056
1057 for _, name := range strings.Split(targetsStr, ",") {
1058 if name == serviceNick {
1059 handleServicePRIVMSG(dc, text)
1060 continue
1061 }
1062
1063 uc, upstreamName, err := dc.unmarshalEntity(name)
1064 if err != nil {
1065 return err
1066 }
1067
1068 if upstreamName == "NickServ" {
1069 dc.handleNickServPRIVMSG(uc, text)
1070 }
1071
1072 uc.SendMessage(&irc.Message{
1073 Command: "PRIVMSG",
1074 Params: []string{upstreamName, text},
1075 })
1076
1077 echoMsg := &irc.Message{
1078 Prefix: &irc.Prefix{
1079 Name: uc.nick,
1080 User: uc.username,
1081 },
1082 Command: "PRIVMSG",
1083 Params: []string{upstreamName, text},
1084 }
1085 dc.lock.Lock()
1086 dc.ourMessages[echoMsg] = struct{}{}
1087 dc.lock.Unlock()
1088
1089 uc.ring.Produce(echoMsg)
1090 }
1091 default:
1092 dc.logger.Printf("unhandled message: %v", msg)
1093 return newUnknownCommandError(msg.Command)
1094 }
1095 return nil
1096}
1097
1098func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1099 username, password, ok := parseNickServCredentials(text, uc.nick)
1100 if !ok {
1101 return
1102 }
1103
1104 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1105 n := uc.network
1106 n.SASL.Mechanism = "PLAIN"
1107 n.SASL.Plain.Username = username
1108 n.SASL.Plain.Password = password
1109 if err := dc.srv.db.StoreNetwork(dc.user.Username, &n.Network); err != nil {
1110 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1111 }
1112}
1113
1114func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1115 fields := strings.Fields(text)
1116 if len(fields) < 2 {
1117 return "", "", false
1118 }
1119 cmd := strings.ToUpper(fields[0])
1120 params := fields[1:]
1121 switch cmd {
1122 case "REGISTER":
1123 username = nick
1124 password = params[0]
1125 case "IDENTIFY":
1126 if len(params) == 1 {
1127 username = nick
1128 } else {
1129 username = params[0]
1130 }
1131 password = params[1]
1132 }
1133 return username, password, true
1134}
Note: See TracBrowser for help on using the repository browser.