source: code/trunk/downstream.go@ 248

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

Centralize logged messages marshaling

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