source: code/trunk/upstream.go@ 244

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

Fix upstream NICK handling

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