source: code/trunk/downstream.go@ 230

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

Remove downstreamConn.lock

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