source: code/trunk/upstream.go@ 168

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

Introduce a user.events channel

This allows to easily add new events, and also guarantees ordering
between different event types.
File size: 29.2 KB
Line 
1package soju
2
3import (
4 "crypto/tls"
5 "encoding/base64"
6 "errors"
7 "fmt"
8 "io"
9 "net"
10 "strconv"
11 "strings"
12 "time"
13
14 "github.com/emersion/go-sasl"
15 "gopkg.in/irc.v3"
16)
17
18type upstreamChannel struct {
19 Name string
20 conn *upstreamConn
21 Topic string
22 TopicWho string
23 TopicTime time.Time
24 Status channelStatus
25 modes channelModes
26 creationTime string
27 Members map[string]*membership
28 complete bool
29}
30
31type upstreamConn struct {
32 network *network
33 logger Logger
34 net net.Conn
35 irc *irc.Conn
36 srv *Server
37 user *user
38 outgoing chan<- *irc.Message
39
40 serverName string
41 availableUserModes string
42 availableChannelModes map[byte]channelModeType
43 availableChannelTypes string
44 availableMemberships []membership
45
46 registered bool
47 nick string
48 username string
49 realname string
50 closed bool
51 modes userModes
52 channels map[string]*upstreamChannel
53 caps map[string]string
54 batches map[string]batch
55
56 tagsSupported bool
57 labelsSupported bool
58 nextLabelID uint64
59
60 saslClient sasl.Client
61 saslStarted bool
62}
63
64func connectToUpstream(network *network) (*upstreamConn, error) {
65 logger := &prefixLogger{network.user.srv.Logger, fmt.Sprintf("upstream %q: ", network.Addr)}
66
67 addr := network.Addr
68 if !strings.ContainsRune(addr, ':') {
69 addr = addr + ":6697"
70 }
71
72 logger.Printf("connecting to TLS server at address %q", addr)
73 netConn, err := tls.Dial("tcp", addr, nil)
74 if err != nil {
75 return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
76 }
77
78 setKeepAlive(netConn)
79
80 outgoing := make(chan *irc.Message, 64)
81 uc := &upstreamConn{
82 network: network,
83 logger: logger,
84 net: netConn,
85 irc: irc.NewConn(netConn),
86 srv: network.user.srv,
87 user: network.user,
88 outgoing: outgoing,
89 channels: make(map[string]*upstreamChannel),
90 caps: make(map[string]string),
91 batches: make(map[string]batch),
92 availableChannelTypes: stdChannelTypes,
93 availableChannelModes: stdChannelModes,
94 availableMemberships: stdMemberships,
95 }
96
97 go func() {
98 for msg := range outgoing {
99 if uc.srv.Debug {
100 uc.logger.Printf("sent: %v", msg)
101 }
102 if err := uc.irc.WriteMessage(msg); err != nil {
103 uc.logger.Printf("failed to write message: %v", err)
104 }
105 }
106 if err := uc.net.Close(); err != nil {
107 uc.logger.Printf("failed to close connection: %v", err)
108 } else {
109 uc.logger.Printf("connection closed")
110 }
111 }()
112
113 return uc, nil
114}
115
116func (uc *upstreamConn) Close() error {
117 if uc.closed {
118 return fmt.Errorf("upstream connection already closed")
119 }
120 close(uc.outgoing)
121 uc.closed = true
122 return nil
123}
124
125func (uc *upstreamConn) forEachDownstream(f func(*downstreamConn)) {
126 uc.user.forEachDownstream(func(dc *downstreamConn) {
127 if dc.network != nil && dc.network != uc.network {
128 return
129 }
130 f(dc)
131 })
132}
133
134func (uc *upstreamConn) forEachDownstreamByID(id uint64, f func(*downstreamConn)) {
135 uc.forEachDownstream(func(dc *downstreamConn) {
136 if id != 0 && id != dc.id {
137 return
138 }
139 f(dc)
140 })
141}
142
143func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
144 ch, ok := uc.channels[name]
145 if !ok {
146 return nil, fmt.Errorf("unknown channel %q", name)
147 }
148 return ch, nil
149}
150
151func (uc *upstreamConn) isChannel(entity string) bool {
152 if i := strings.IndexByte(uc.availableChannelTypes, entity[0]); i >= 0 {
153 return true
154 }
155 return false
156}
157
158func (uc *upstreamConn) parseMembershipPrefix(s string) (membership *membership, nick string) {
159 for _, m := range uc.availableMemberships {
160 if m.Prefix == s[0] {
161 return &m, s[1:]
162 }
163 }
164 return nil, s
165}
166
167func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
168 var label string
169 if l, ok := msg.GetTag("label"); ok {
170 label = l
171 }
172
173 var msgBatch *batch
174 if batchName, ok := msg.GetTag("batch"); ok {
175 b, ok := uc.batches[batchName]
176 if !ok {
177 return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
178 }
179 msgBatch = &b
180 if label == "" {
181 label = msgBatch.Label
182 }
183 }
184
185 var downstreamID uint64 = 0
186 if label != "" {
187 var labelOffset uint64
188 n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
189 if err == nil && n < 2 {
190 err = errors.New("not enough arguments")
191 }
192 if err != nil {
193 return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
194 }
195 }
196
197 switch msg.Command {
198 case "PING":
199 uc.SendMessage(&irc.Message{
200 Command: "PONG",
201 Params: msg.Params,
202 })
203 return nil
204 case "NOTICE":
205 uc.logger.Print(msg)
206
207 uc.forEachDownstream(func(dc *downstreamConn) {
208 dc.SendMessage(msg)
209 })
210 case "CAP":
211 var subCmd string
212 if err := parseMessageParams(msg, nil, &subCmd); err != nil {
213 return err
214 }
215 subCmd = strings.ToUpper(subCmd)
216 subParams := msg.Params[2:]
217 switch subCmd {
218 case "LS":
219 if len(subParams) < 1 {
220 return newNeedMoreParamsError(msg.Command)
221 }
222 caps := strings.Fields(subParams[len(subParams)-1])
223 more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
224
225 for _, s := range caps {
226 kv := strings.SplitN(s, "=", 2)
227 k := strings.ToLower(kv[0])
228 var v string
229 if len(kv) == 2 {
230 v = kv[1]
231 }
232 uc.caps[k] = v
233 }
234
235 if more {
236 break // wait to receive all capabilities
237 }
238
239 requestCaps := make([]string, 0, 16)
240 for _, c := range []string{"message-tags", "batch", "labeled-response"} {
241 if _, ok := uc.caps[c]; ok {
242 requestCaps = append(requestCaps, c)
243 }
244 }
245
246 if uc.requestSASL() {
247 requestCaps = append(requestCaps, "sasl")
248 }
249
250 if len(requestCaps) > 0 {
251 uc.SendMessage(&irc.Message{
252 Command: "CAP",
253 Params: []string{"REQ", strings.Join(requestCaps, " ")},
254 })
255 }
256
257 if uc.requestSASL() {
258 break // we'll send CAP END after authentication is completed
259 }
260
261 uc.SendMessage(&irc.Message{
262 Command: "CAP",
263 Params: []string{"END"},
264 })
265 case "ACK", "NAK":
266 if len(subParams) < 1 {
267 return newNeedMoreParamsError(msg.Command)
268 }
269 caps := strings.Fields(subParams[0])
270
271 for _, name := range caps {
272 if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
273 return err
274 }
275 }
276
277 if uc.saslClient == nil {
278 uc.SendMessage(&irc.Message{
279 Command: "CAP",
280 Params: []string{"END"},
281 })
282 }
283 default:
284 uc.logger.Printf("unhandled message: %v", msg)
285 }
286 case "AUTHENTICATE":
287 if uc.saslClient == nil {
288 return fmt.Errorf("received unexpected AUTHENTICATE message")
289 }
290
291 // TODO: if a challenge is 400 bytes long, buffer it
292 var challengeStr string
293 if err := parseMessageParams(msg, &challengeStr); err != nil {
294 uc.SendMessage(&irc.Message{
295 Command: "AUTHENTICATE",
296 Params: []string{"*"},
297 })
298 return err
299 }
300
301 var challenge []byte
302 if challengeStr != "+" {
303 var err error
304 challenge, err = base64.StdEncoding.DecodeString(challengeStr)
305 if err != nil {
306 uc.SendMessage(&irc.Message{
307 Command: "AUTHENTICATE",
308 Params: []string{"*"},
309 })
310 return err
311 }
312 }
313
314 var resp []byte
315 var err error
316 if !uc.saslStarted {
317 _, resp, err = uc.saslClient.Start()
318 uc.saslStarted = true
319 } else {
320 resp, err = uc.saslClient.Next(challenge)
321 }
322 if err != nil {
323 uc.SendMessage(&irc.Message{
324 Command: "AUTHENTICATE",
325 Params: []string{"*"},
326 })
327 return err
328 }
329
330 // TODO: send response in multiple chunks if >= 400 bytes
331 var respStr = "+"
332 if resp != nil {
333 respStr = base64.StdEncoding.EncodeToString(resp)
334 }
335
336 uc.SendMessage(&irc.Message{
337 Command: "AUTHENTICATE",
338 Params: []string{respStr},
339 })
340 case irc.RPL_LOGGEDIN:
341 var account string
342 if err := parseMessageParams(msg, nil, nil, &account); err != nil {
343 return err
344 }
345 uc.logger.Printf("logged in with account %q", account)
346 case irc.RPL_LOGGEDOUT:
347 uc.logger.Printf("logged out")
348 case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
349 var info string
350 if err := parseMessageParams(msg, nil, &info); err != nil {
351 return err
352 }
353 switch msg.Command {
354 case irc.ERR_NICKLOCKED:
355 uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
356 case irc.ERR_SASLFAIL:
357 uc.logger.Printf("SASL authentication failed: %v", info)
358 case irc.ERR_SASLTOOLONG:
359 uc.logger.Printf("SASL message too long: %v", info)
360 }
361
362 uc.saslClient = nil
363 uc.saslStarted = false
364
365 uc.SendMessage(&irc.Message{
366 Command: "CAP",
367 Params: []string{"END"},
368 })
369 case irc.RPL_WELCOME:
370 uc.registered = true
371 uc.logger.Printf("connection registered")
372
373 channels, err := uc.srv.db.ListChannels(uc.network.ID)
374 if err != nil {
375 uc.logger.Printf("failed to list channels from database: %v", err)
376 break
377 }
378
379 for _, ch := range channels {
380 params := []string{ch.Name}
381 if ch.Key != "" {
382 params = append(params, ch.Key)
383 }
384 uc.SendMessage(&irc.Message{
385 Command: "JOIN",
386 Params: params,
387 })
388 }
389 case irc.RPL_MYINFO:
390 if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
391 return err
392 }
393 case irc.RPL_ISUPPORT:
394 if err := parseMessageParams(msg, nil, nil); err != nil {
395 return err
396 }
397 for _, token := range msg.Params[1 : len(msg.Params)-1] {
398 negate := false
399 parameter := token
400 value := ""
401 if strings.HasPrefix(token, "-") {
402 negate = true
403 token = token[1:]
404 } else {
405 if i := strings.IndexByte(token, '='); i >= 0 {
406 parameter = token[:i]
407 value = token[i+1:]
408 }
409 }
410 if !negate {
411 switch parameter {
412 case "CHANMODES":
413 parts := strings.SplitN(value, ",", 5)
414 if len(parts) < 4 {
415 return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
416 }
417 modes := make(map[byte]channelModeType)
418 for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
419 for j := 0; j < len(parts[i]); j++ {
420 mode := parts[i][j]
421 modes[mode] = mt
422 }
423 }
424 uc.availableChannelModes = modes
425 case "CHANTYPES":
426 uc.availableChannelTypes = value
427 case "PREFIX":
428 if value == "" {
429 uc.availableMemberships = nil
430 } else {
431 if value[0] != '(' {
432 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
433 }
434 sep := strings.IndexByte(value, ')')
435 if sep < 0 || len(value) != sep*2 {
436 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
437 }
438 memberships := make([]membership, len(value)/2-1)
439 for i := range memberships {
440 memberships[i] = membership{
441 Mode: value[i+1],
442 Prefix: value[sep+i+1],
443 }
444 }
445 uc.availableMemberships = memberships
446 }
447 }
448 } else {
449 // TODO: handle ISUPPORT negations
450 }
451 }
452 case "BATCH":
453 var tag string
454 if err := parseMessageParams(msg, &tag); err != nil {
455 return err
456 }
457
458 if strings.HasPrefix(tag, "+") {
459 tag = tag[1:]
460 if _, ok := uc.batches[tag]; ok {
461 return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
462 }
463 var batchType string
464 if err := parseMessageParams(msg, nil, &batchType); err != nil {
465 return err
466 }
467 label := label
468 if label == "" && msgBatch != nil {
469 label = msgBatch.Label
470 }
471 uc.batches[tag] = batch{
472 Type: batchType,
473 Params: msg.Params[2:],
474 Outer: msgBatch,
475 Label: label,
476 }
477 } else if strings.HasPrefix(tag, "-") {
478 tag = tag[1:]
479 if _, ok := uc.batches[tag]; !ok {
480 return fmt.Errorf("unknown BATCH reference tag: %q", tag)
481 }
482 delete(uc.batches, tag)
483 } else {
484 return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
485 }
486 case "NICK":
487 if msg.Prefix == nil {
488 return fmt.Errorf("expected a prefix")
489 }
490
491 var newNick string
492 if err := parseMessageParams(msg, &newNick); err != nil {
493 return err
494 }
495
496 if msg.Prefix.Name == uc.nick {
497 uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
498 uc.nick = newNick
499 }
500
501 for _, ch := range uc.channels {
502 if membership, ok := ch.Members[msg.Prefix.Name]; ok {
503 delete(ch.Members, msg.Prefix.Name)
504 ch.Members[newNick] = membership
505 }
506 }
507
508 if msg.Prefix.Name != uc.nick {
509 uc.forEachDownstream(func(dc *downstreamConn) {
510 dc.SendMessage(&irc.Message{
511 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
512 Command: "NICK",
513 Params: []string{newNick},
514 })
515 })
516 }
517 case "JOIN":
518 if msg.Prefix == nil {
519 return fmt.Errorf("expected a prefix")
520 }
521
522 var channels string
523 if err := parseMessageParams(msg, &channels); err != nil {
524 return err
525 }
526
527 for _, ch := range strings.Split(channels, ",") {
528 if msg.Prefix.Name == uc.nick {
529 uc.logger.Printf("joined channel %q", ch)
530 uc.channels[ch] = &upstreamChannel{
531 Name: ch,
532 conn: uc,
533 Members: make(map[string]*membership),
534 }
535
536 uc.SendMessage(&irc.Message{
537 Command: "MODE",
538 Params: []string{ch},
539 })
540 } else {
541 ch, err := uc.getChannel(ch)
542 if err != nil {
543 return err
544 }
545 ch.Members[msg.Prefix.Name] = nil
546 }
547
548 uc.forEachDownstream(func(dc *downstreamConn) {
549 dc.SendMessage(&irc.Message{
550 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
551 Command: "JOIN",
552 Params: []string{dc.marshalChannel(uc, ch)},
553 })
554 })
555 }
556 case "PART":
557 if msg.Prefix == nil {
558 return fmt.Errorf("expected a prefix")
559 }
560
561 var channels string
562 if err := parseMessageParams(msg, &channels); err != nil {
563 return err
564 }
565
566 for _, ch := range strings.Split(channels, ",") {
567 if msg.Prefix.Name == uc.nick {
568 uc.logger.Printf("parted channel %q", ch)
569 delete(uc.channels, ch)
570 } else {
571 ch, err := uc.getChannel(ch)
572 if err != nil {
573 return err
574 }
575 delete(ch.Members, msg.Prefix.Name)
576 }
577
578 uc.forEachDownstream(func(dc *downstreamConn) {
579 dc.SendMessage(&irc.Message{
580 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
581 Command: "PART",
582 Params: []string{dc.marshalChannel(uc, ch)},
583 })
584 })
585 }
586 case "KICK":
587 if msg.Prefix == nil {
588 return fmt.Errorf("expected a prefix")
589 }
590
591 var channel, user string
592 if err := parseMessageParams(msg, &channel, &user); err != nil {
593 return err
594 }
595
596 var reason string
597 if len(msg.Params) > 2 {
598 reason = msg.Params[1]
599 }
600
601 if user == uc.nick {
602 uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
603 delete(uc.channels, channel)
604 } else {
605 ch, err := uc.getChannel(channel)
606 if err != nil {
607 return err
608 }
609 delete(ch.Members, user)
610 }
611
612 uc.forEachDownstream(func(dc *downstreamConn) {
613 params := []string{dc.marshalChannel(uc, channel), dc.marshalNick(uc, user)}
614 if reason != "" {
615 params = append(params, reason)
616 }
617 dc.SendMessage(&irc.Message{
618 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
619 Command: "KICK",
620 Params: params,
621 })
622 })
623 case "QUIT":
624 if msg.Prefix == nil {
625 return fmt.Errorf("expected a prefix")
626 }
627
628 if msg.Prefix.Name == uc.nick {
629 uc.logger.Printf("quit")
630 }
631
632 for _, ch := range uc.channels {
633 delete(ch.Members, msg.Prefix.Name)
634 }
635
636 if msg.Prefix.Name != uc.nick {
637 uc.forEachDownstream(func(dc *downstreamConn) {
638 dc.SendMessage(&irc.Message{
639 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
640 Command: "QUIT",
641 Params: msg.Params,
642 })
643 })
644 }
645 case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
646 var name, topic string
647 if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
648 return err
649 }
650 ch, err := uc.getChannel(name)
651 if err != nil {
652 return err
653 }
654 if msg.Command == irc.RPL_TOPIC {
655 ch.Topic = topic
656 } else {
657 ch.Topic = ""
658 }
659 case "TOPIC":
660 var name string
661 if err := parseMessageParams(msg, &name); err != nil {
662 return err
663 }
664 ch, err := uc.getChannel(name)
665 if err != nil {
666 return err
667 }
668 if len(msg.Params) > 1 {
669 ch.Topic = msg.Params[1]
670 } else {
671 ch.Topic = ""
672 }
673 uc.forEachDownstream(func(dc *downstreamConn) {
674 params := []string{dc.marshalChannel(uc, name)}
675 if ch.Topic != "" {
676 params = append(params, ch.Topic)
677 }
678 dc.SendMessage(&irc.Message{
679 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
680 Command: "TOPIC",
681 Params: params,
682 })
683 })
684 case "MODE":
685 var name, modeStr string
686 if err := parseMessageParams(msg, &name, &modeStr); err != nil {
687 return err
688 }
689
690 if !uc.isChannel(name) { // user mode change
691 if name != uc.nick {
692 return fmt.Errorf("received MODE message for unknown nick %q", name)
693 }
694 return uc.modes.Apply(modeStr)
695 // TODO: notify downstreams about user mode change?
696 } else { // channel mode change
697 ch, err := uc.getChannel(name)
698 if err != nil {
699 return err
700 }
701
702 if ch.modes != nil {
703 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
704 return err
705 }
706 }
707
708 uc.forEachDownstream(func(dc *downstreamConn) {
709 params := []string{dc.marshalChannel(uc, name), modeStr}
710 params = append(params, msg.Params[2:]...)
711
712 dc.SendMessage(&irc.Message{
713 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
714 Command: "MODE",
715 Params: params,
716 })
717 })
718 }
719 case irc.RPL_UMODEIS:
720 if err := parseMessageParams(msg, nil); err != nil {
721 return err
722 }
723 modeStr := ""
724 if len(msg.Params) > 1 {
725 modeStr = msg.Params[1]
726 }
727
728 uc.modes = ""
729 if err := uc.modes.Apply(modeStr); err != nil {
730 return err
731 }
732 // TODO: send RPL_UMODEIS to downstream connections when applicable
733 case irc.RPL_CHANNELMODEIS:
734 var channel string
735 if err := parseMessageParams(msg, nil, &channel); err != nil {
736 return err
737 }
738 modeStr := ""
739 if len(msg.Params) > 2 {
740 modeStr = msg.Params[2]
741 }
742
743 ch, err := uc.getChannel(channel)
744 if err != nil {
745 return err
746 }
747
748 firstMode := ch.modes == nil
749 ch.modes = make(map[byte]string)
750 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
751 return err
752 }
753 if firstMode {
754 modeStr, modeParams := ch.modes.Format()
755
756 uc.forEachDownstream(func(dc *downstreamConn) {
757 params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
758 params = append(params, modeParams...)
759
760 dc.SendMessage(&irc.Message{
761 Prefix: dc.srv.prefix(),
762 Command: irc.RPL_CHANNELMODEIS,
763 Params: params,
764 })
765 })
766 }
767 case rpl_creationtime:
768 var channel, creationTime string
769 if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
770 return err
771 }
772
773 ch, err := uc.getChannel(channel)
774 if err != nil {
775 return err
776 }
777
778 firstCreationTime := ch.creationTime == ""
779 ch.creationTime = creationTime
780 if firstCreationTime {
781 uc.forEachDownstream(func(dc *downstreamConn) {
782 dc.SendMessage(&irc.Message{
783 Prefix: dc.srv.prefix(),
784 Command: rpl_creationtime,
785 Params: []string{dc.nick, channel, creationTime},
786 })
787 })
788 }
789 case rpl_topicwhotime:
790 var name, who, timeStr string
791 if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
792 return err
793 }
794 ch, err := uc.getChannel(name)
795 if err != nil {
796 return err
797 }
798 ch.TopicWho = who
799 sec, err := strconv.ParseInt(timeStr, 10, 64)
800 if err != nil {
801 return fmt.Errorf("failed to parse topic time: %v", err)
802 }
803 ch.TopicTime = time.Unix(sec, 0)
804 case irc.RPL_NAMREPLY:
805 var name, statusStr, members string
806 if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
807 return err
808 }
809 members = strings.TrimRight(members, " ")
810
811 ch, ok := uc.channels[name]
812 if !ok {
813 // NAMES on a channel we have not joined, forward to downstream
814 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
815 channel := dc.marshalChannel(uc, name)
816 members := strings.Split(members, " ")
817 for i, member := range members {
818 membership, nick := uc.parseMembershipPrefix(member)
819 members[i] = membership.String() + dc.marshalNick(uc, nick)
820 }
821 memberStr := strings.Join(members, " ")
822
823 dc.SendMessage(&irc.Message{
824 Prefix: dc.srv.prefix(),
825 Command: irc.RPL_NAMREPLY,
826 Params: []string{dc.nick, statusStr, channel, memberStr},
827 })
828 })
829 return nil
830 }
831
832 status, err := parseChannelStatus(statusStr)
833 if err != nil {
834 return err
835 }
836 ch.Status = status
837
838 for _, s := range strings.Split(members, " ") {
839 membership, nick := uc.parseMembershipPrefix(s)
840 ch.Members[nick] = membership
841 }
842 case irc.RPL_ENDOFNAMES:
843 var name string
844 if err := parseMessageParams(msg, nil, &name); err != nil {
845 return err
846 }
847
848 ch, ok := uc.channels[name]
849 if !ok {
850 // NAMES on a channel we have not joined, forward to downstream
851 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
852 channel := dc.marshalChannel(uc, name)
853
854 dc.SendMessage(&irc.Message{
855 Prefix: dc.srv.prefix(),
856 Command: irc.RPL_ENDOFNAMES,
857 Params: []string{dc.nick, channel, "End of /NAMES list"},
858 })
859 })
860 return nil
861 }
862
863 if ch.complete {
864 return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
865 }
866 ch.complete = true
867
868 uc.forEachDownstream(func(dc *downstreamConn) {
869 forwardChannel(dc, ch)
870 })
871 case irc.RPL_WHOREPLY:
872 var channel, username, host, server, nick, mode, trailing string
873 if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
874 return err
875 }
876
877 parts := strings.SplitN(trailing, " ", 2)
878 if len(parts) != 2 {
879 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
880 }
881 realname := parts[1]
882 hops, err := strconv.Atoi(parts[0])
883 if err != nil {
884 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
885 }
886 hops++
887
888 trailing = strconv.Itoa(hops) + " " + realname
889
890 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
891 channel := channel
892 if channel != "*" {
893 channel = dc.marshalChannel(uc, channel)
894 }
895 nick := dc.marshalNick(uc, nick)
896 dc.SendMessage(&irc.Message{
897 Prefix: dc.srv.prefix(),
898 Command: irc.RPL_WHOREPLY,
899 Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
900 })
901 })
902 case irc.RPL_ENDOFWHO:
903 var name string
904 if err := parseMessageParams(msg, nil, &name); err != nil {
905 return err
906 }
907
908 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
909 name := name
910 if name != "*" {
911 // TODO: support WHO masks
912 name = dc.marshalEntity(uc, name)
913 }
914 dc.SendMessage(&irc.Message{
915 Prefix: dc.srv.prefix(),
916 Command: irc.RPL_ENDOFWHO,
917 Params: []string{dc.nick, name, "End of /WHO list"},
918 })
919 })
920 case irc.RPL_WHOISUSER:
921 var nick, username, host, realname string
922 if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
923 return err
924 }
925
926 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
927 nick := dc.marshalNick(uc, nick)
928 dc.SendMessage(&irc.Message{
929 Prefix: dc.srv.prefix(),
930 Command: irc.RPL_WHOISUSER,
931 Params: []string{dc.nick, nick, username, host, "*", realname},
932 })
933 })
934 case irc.RPL_WHOISSERVER:
935 var nick, server, serverInfo string
936 if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
937 return err
938 }
939
940 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
941 nick := dc.marshalNick(uc, nick)
942 dc.SendMessage(&irc.Message{
943 Prefix: dc.srv.prefix(),
944 Command: irc.RPL_WHOISSERVER,
945 Params: []string{dc.nick, nick, server, serverInfo},
946 })
947 })
948 case irc.RPL_WHOISOPERATOR:
949 var nick string
950 if err := parseMessageParams(msg, nil, &nick); err != nil {
951 return err
952 }
953
954 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
955 nick := dc.marshalNick(uc, nick)
956 dc.SendMessage(&irc.Message{
957 Prefix: dc.srv.prefix(),
958 Command: irc.RPL_WHOISOPERATOR,
959 Params: []string{dc.nick, nick, "is an IRC operator"},
960 })
961 })
962 case irc.RPL_WHOISIDLE:
963 var nick string
964 if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
965 return err
966 }
967
968 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
969 nick := dc.marshalNick(uc, nick)
970 params := []string{dc.nick, nick}
971 params = append(params, msg.Params[2:]...)
972 dc.SendMessage(&irc.Message{
973 Prefix: dc.srv.prefix(),
974 Command: irc.RPL_WHOISIDLE,
975 Params: params,
976 })
977 })
978 case irc.RPL_WHOISCHANNELS:
979 var nick, channelList string
980 if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
981 return err
982 }
983 channels := strings.Split(channelList, " ")
984
985 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
986 nick := dc.marshalNick(uc, nick)
987 channelList := make([]string, len(channels))
988 for i, channel := range channels {
989 prefix, channel := uc.parseMembershipPrefix(channel)
990 channel = dc.marshalChannel(uc, channel)
991 channelList[i] = prefix.String() + channel
992 }
993 channels := strings.Join(channelList, " ")
994 dc.SendMessage(&irc.Message{
995 Prefix: dc.srv.prefix(),
996 Command: irc.RPL_WHOISCHANNELS,
997 Params: []string{dc.nick, nick, channels},
998 })
999 })
1000 case irc.RPL_ENDOFWHOIS:
1001 var nick string
1002 if err := parseMessageParams(msg, nil, &nick); err != nil {
1003 return err
1004 }
1005
1006 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1007 nick := dc.marshalNick(uc, nick)
1008 dc.SendMessage(&irc.Message{
1009 Prefix: dc.srv.prefix(),
1010 Command: irc.RPL_ENDOFWHOIS,
1011 Params: []string{dc.nick, nick, "End of /WHOIS list"},
1012 })
1013 })
1014 case "PRIVMSG":
1015 if msg.Prefix == nil {
1016 return fmt.Errorf("expected a prefix")
1017 }
1018
1019 var nick string
1020 if err := parseMessageParams(msg, &nick, nil); err != nil {
1021 return err
1022 }
1023
1024 if msg.Prefix.Name == serviceNick {
1025 uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
1026 break
1027 }
1028 if nick == serviceNick {
1029 uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
1030 break
1031 }
1032
1033 uc.network.ring.Produce(msg)
1034 case "INVITE":
1035 var nick string
1036 var channel string
1037 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1038 return err
1039 }
1040
1041 uc.forEachDownstream(func(dc *downstreamConn) {
1042 dc.SendMessage(&irc.Message{
1043 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
1044 Command: "INVITE",
1045 Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1046 })
1047 })
1048 case irc.RPL_INVITING:
1049 var nick string
1050 var channel string
1051 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1052 return err
1053 }
1054
1055 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1056 dc.SendMessage(&irc.Message{
1057 Prefix: dc.srv.prefix(),
1058 Command: irc.RPL_INVITING,
1059 Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1060 })
1061 })
1062 case "TAGMSG":
1063 // TODO: relay to downstream connections that accept message-tags
1064 case "ACK":
1065 // Ignore
1066 case irc.RPL_YOURHOST, irc.RPL_CREATED:
1067 // Ignore
1068 case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
1069 // Ignore
1070 case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
1071 // Ignore
1072 case rpl_localusers, rpl_globalusers:
1073 // Ignore
1074 case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
1075 // Ignore
1076 default:
1077 uc.logger.Printf("unhandled message: %v", msg)
1078 }
1079 return nil
1080}
1081
1082func (uc *upstreamConn) register() {
1083 uc.nick = uc.network.Nick
1084 uc.username = uc.network.Username
1085 if uc.username == "" {
1086 uc.username = uc.nick
1087 }
1088 uc.realname = uc.network.Realname
1089 if uc.realname == "" {
1090 uc.realname = uc.nick
1091 }
1092
1093 uc.SendMessage(&irc.Message{
1094 Command: "CAP",
1095 Params: []string{"LS", "302"},
1096 })
1097
1098 if uc.network.Pass != "" {
1099 uc.SendMessage(&irc.Message{
1100 Command: "PASS",
1101 Params: []string{uc.network.Pass},
1102 })
1103 }
1104
1105 uc.SendMessage(&irc.Message{
1106 Command: "NICK",
1107 Params: []string{uc.nick},
1108 })
1109 uc.SendMessage(&irc.Message{
1110 Command: "USER",
1111 Params: []string{uc.username, "0", "*", uc.realname},
1112 })
1113}
1114
1115func (uc *upstreamConn) requestSASL() bool {
1116 if uc.network.SASL.Mechanism == "" {
1117 return false
1118 }
1119
1120 v, ok := uc.caps["sasl"]
1121 if !ok {
1122 return false
1123 }
1124 if v != "" {
1125 mechanisms := strings.Split(v, ",")
1126 found := false
1127 for _, mech := range mechanisms {
1128 if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
1129 found = true
1130 break
1131 }
1132 }
1133 if !found {
1134 return false
1135 }
1136 }
1137
1138 return true
1139}
1140
1141func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
1142 auth := &uc.network.SASL
1143 switch name {
1144 case "sasl":
1145 if !ok {
1146 uc.logger.Printf("server refused to acknowledge the SASL capability")
1147 return nil
1148 }
1149
1150 switch auth.Mechanism {
1151 case "PLAIN":
1152 uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
1153 uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
1154 default:
1155 return fmt.Errorf("unsupported SASL mechanism %q", name)
1156 }
1157
1158 uc.SendMessage(&irc.Message{
1159 Command: "AUTHENTICATE",
1160 Params: []string{auth.Mechanism},
1161 })
1162 case "message-tags":
1163 uc.tagsSupported = ok
1164 case "labeled-response":
1165 uc.labelsSupported = ok
1166 }
1167 return nil
1168}
1169
1170func (uc *upstreamConn) readMessages(ch chan<- event) error {
1171 for {
1172 msg, err := uc.irc.ReadMessage()
1173 if err == io.EOF {
1174 break
1175 } else if err != nil {
1176 return fmt.Errorf("failed to read IRC command: %v", err)
1177 }
1178
1179 if uc.srv.Debug {
1180 uc.logger.Printf("received: %v", msg)
1181 }
1182
1183 ch <- eventUpstreamMessage{msg, uc}
1184 }
1185
1186 return nil
1187}
1188
1189func (uc *upstreamConn) SendMessage(msg *irc.Message) {
1190 uc.outgoing <- msg
1191}
1192
1193func (uc *upstreamConn) SendMessageLabeled(dc *downstreamConn, msg *irc.Message) {
1194 if uc.labelsSupported {
1195 if msg.Tags == nil {
1196 msg.Tags = make(map[string]irc.TagValue)
1197 }
1198 msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", dc.id, uc.nextLabelID))
1199 uc.nextLabelID++
1200 }
1201 uc.SendMessage(msg)
1202}
Note: See TracBrowser for help on using the repository browser.