source: code/trunk/downstream.go@ 226

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

Introduce upstreamConn.produce

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