source: code/trunk/upstream.go@ 241

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

Fix server-time tags timezone

We need to use UTC time.
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 if msg.Prefix.Name == uc.nick {
550 uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
551 uc.nick = newNick
552 }
553
554 for _, ch := range uc.channels {
555 if membership, ok := ch.Members[msg.Prefix.Name]; ok {
556 delete(ch.Members, msg.Prefix.Name)
557 ch.Members[newNick] = membership
558 uc.appendLog(ch.Name, msg)
559 }
560 }
561
562 if msg.Prefix.Name != uc.nick {
563 uc.forEachDownstream(func(dc *downstreamConn) {
564 dc.SendMessage(&irc.Message{
565 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
566 Command: "NICK",
567 Params: []string{newNick},
568 })
569 })
570 }
571 case "JOIN":
572 if msg.Prefix == nil {
573 return fmt.Errorf("expected a prefix")
574 }
575
576 var channels string
577 if err := parseMessageParams(msg, &channels); err != nil {
578 return err
579 }
580
581 for _, ch := range strings.Split(channels, ",") {
582 if msg.Prefix.Name == uc.nick {
583 uc.logger.Printf("joined channel %q", ch)
584 uc.channels[ch] = &upstreamChannel{
585 Name: ch,
586 conn: uc,
587 Members: make(map[string]*membership),
588 }
589
590 uc.SendMessage(&irc.Message{
591 Command: "MODE",
592 Params: []string{ch},
593 })
594 } else {
595 ch, err := uc.getChannel(ch)
596 if err != nil {
597 return err
598 }
599 ch.Members[msg.Prefix.Name] = nil
600 }
601
602 uc.appendLog(ch, msg)
603
604 uc.forEachDownstream(func(dc *downstreamConn) {
605 dc.SendMessage(&irc.Message{
606 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
607 Command: "JOIN",
608 Params: []string{dc.marshalChannel(uc, ch)},
609 })
610 })
611 }
612 case "PART":
613 if msg.Prefix == nil {
614 return fmt.Errorf("expected a prefix")
615 }
616
617 var channels string
618 if err := parseMessageParams(msg, &channels); err != nil {
619 return err
620 }
621
622 var reason string
623 if len(msg.Params) > 1 {
624 reason = msg.Params[1]
625 }
626
627 for _, ch := range strings.Split(channels, ",") {
628 if msg.Prefix.Name == uc.nick {
629 uc.logger.Printf("parted channel %q", ch)
630 delete(uc.channels, ch)
631 } else {
632 ch, err := uc.getChannel(ch)
633 if err != nil {
634 return err
635 }
636 delete(ch.Members, msg.Prefix.Name)
637 }
638
639 uc.appendLog(ch, msg)
640
641 uc.forEachDownstream(func(dc *downstreamConn) {
642 params := []string{dc.marshalChannel(uc, ch)}
643 if reason != "" {
644 params = append(params, reason)
645 }
646 dc.SendMessage(&irc.Message{
647 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
648 Command: "PART",
649 Params: params,
650 })
651 })
652 }
653 case "KICK":
654 if msg.Prefix == nil {
655 return fmt.Errorf("expected a prefix")
656 }
657
658 var channel, user string
659 if err := parseMessageParams(msg, &channel, &user); err != nil {
660 return err
661 }
662
663 var reason string
664 if len(msg.Params) > 2 {
665 reason = msg.Params[2]
666 }
667
668 if user == uc.nick {
669 uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
670 delete(uc.channels, channel)
671 } else {
672 ch, err := uc.getChannel(channel)
673 if err != nil {
674 return err
675 }
676 delete(ch.Members, user)
677 }
678
679 uc.appendLog(channel, msg)
680
681 uc.forEachDownstream(func(dc *downstreamConn) {
682 params := []string{dc.marshalChannel(uc, channel), dc.marshalNick(uc, user)}
683 if reason != "" {
684 params = append(params, reason)
685 }
686 dc.SendMessage(&irc.Message{
687 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
688 Command: "KICK",
689 Params: params,
690 })
691 })
692 case "QUIT":
693 if msg.Prefix == nil {
694 return fmt.Errorf("expected a prefix")
695 }
696
697 if msg.Prefix.Name == uc.nick {
698 uc.logger.Printf("quit")
699 }
700
701 for _, ch := range uc.channels {
702 if _, ok := ch.Members[msg.Prefix.Name]; ok {
703 delete(ch.Members, msg.Prefix.Name)
704
705 uc.appendLog(ch.Name, msg)
706 }
707 }
708
709 if msg.Prefix.Name != uc.nick {
710 uc.forEachDownstream(func(dc *downstreamConn) {
711 dc.SendMessage(&irc.Message{
712 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
713 Command: "QUIT",
714 Params: msg.Params,
715 })
716 })
717 }
718 case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
719 var name, topic string
720 if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
721 return err
722 }
723 ch, err := uc.getChannel(name)
724 if err != nil {
725 return err
726 }
727 if msg.Command == irc.RPL_TOPIC {
728 ch.Topic = topic
729 } else {
730 ch.Topic = ""
731 }
732 case "TOPIC":
733 var name string
734 if err := parseMessageParams(msg, &name); err != nil {
735 return err
736 }
737 ch, err := uc.getChannel(name)
738 if err != nil {
739 return err
740 }
741 if len(msg.Params) > 1 {
742 ch.Topic = msg.Params[1]
743 } else {
744 ch.Topic = ""
745 }
746 uc.appendLog(ch.Name, msg)
747 uc.forEachDownstream(func(dc *downstreamConn) {
748 params := []string{dc.marshalChannel(uc, name)}
749 if ch.Topic != "" {
750 params = append(params, ch.Topic)
751 }
752 dc.SendMessage(&irc.Message{
753 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
754 Command: "TOPIC",
755 Params: params,
756 })
757 })
758 case "MODE":
759 var name, modeStr string
760 if err := parseMessageParams(msg, &name, &modeStr); err != nil {
761 return err
762 }
763
764 if !uc.isChannel(name) { // user mode change
765 if name != uc.nick {
766 return fmt.Errorf("received MODE message for unknown nick %q", name)
767 }
768 return uc.modes.Apply(modeStr)
769 // TODO: notify downstreams about user mode change?
770 } else { // channel mode change
771 ch, err := uc.getChannel(name)
772 if err != nil {
773 return err
774 }
775
776 if ch.modes != nil {
777 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
778 return err
779 }
780 }
781
782 uc.appendLog(ch.Name, msg)
783
784 uc.forEachDownstream(func(dc *downstreamConn) {
785 params := []string{dc.marshalChannel(uc, name), modeStr}
786 params = append(params, msg.Params[2:]...)
787
788 dc.SendMessage(&irc.Message{
789 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
790 Command: "MODE",
791 Params: params,
792 })
793 })
794 }
795 case irc.RPL_UMODEIS:
796 if err := parseMessageParams(msg, nil); err != nil {
797 return err
798 }
799 modeStr := ""
800 if len(msg.Params) > 1 {
801 modeStr = msg.Params[1]
802 }
803
804 uc.modes = ""
805 if err := uc.modes.Apply(modeStr); err != nil {
806 return err
807 }
808 // TODO: send RPL_UMODEIS to downstream connections when applicable
809 case irc.RPL_CHANNELMODEIS:
810 var channel string
811 if err := parseMessageParams(msg, nil, &channel); err != nil {
812 return err
813 }
814 modeStr := ""
815 if len(msg.Params) > 2 {
816 modeStr = msg.Params[2]
817 }
818
819 ch, err := uc.getChannel(channel)
820 if err != nil {
821 return err
822 }
823
824 firstMode := ch.modes == nil
825 ch.modes = make(map[byte]string)
826 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
827 return err
828 }
829 if firstMode {
830 modeStr, modeParams := ch.modes.Format()
831
832 uc.forEachDownstream(func(dc *downstreamConn) {
833 params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
834 params = append(params, modeParams...)
835
836 dc.SendMessage(&irc.Message{
837 Prefix: dc.srv.prefix(),
838 Command: irc.RPL_CHANNELMODEIS,
839 Params: params,
840 })
841 })
842 }
843 case rpl_creationtime:
844 var channel, creationTime string
845 if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
846 return err
847 }
848
849 ch, err := uc.getChannel(channel)
850 if err != nil {
851 return err
852 }
853
854 firstCreationTime := ch.creationTime == ""
855 ch.creationTime = creationTime
856 if firstCreationTime {
857 uc.forEachDownstream(func(dc *downstreamConn) {
858 dc.SendMessage(&irc.Message{
859 Prefix: dc.srv.prefix(),
860 Command: rpl_creationtime,
861 Params: []string{dc.nick, channel, creationTime},
862 })
863 })
864 }
865 case rpl_topicwhotime:
866 var name, who, timeStr string
867 if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
868 return err
869 }
870 ch, err := uc.getChannel(name)
871 if err != nil {
872 return err
873 }
874 ch.TopicWho = who
875 sec, err := strconv.ParseInt(timeStr, 10, 64)
876 if err != nil {
877 return fmt.Errorf("failed to parse topic time: %v", err)
878 }
879 ch.TopicTime = time.Unix(sec, 0)
880 case irc.RPL_LIST:
881 var channel, clients, topic string
882 if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
883 return err
884 }
885
886 pl := uc.getPendingLIST()
887 if pl == nil {
888 return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
889 }
890
891 uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
892 dc.SendMessage(&irc.Message{
893 Prefix: dc.srv.prefix(),
894 Command: irc.RPL_LIST,
895 Params: []string{dc.nick, dc.marshalChannel(uc, channel), clients, topic},
896 })
897 })
898 case irc.RPL_LISTEND:
899 ok := uc.endPendingLISTs(false)
900 if !ok {
901 return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
902 }
903 case irc.RPL_NAMREPLY:
904 var name, statusStr, members string
905 if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
906 return err
907 }
908
909 ch, ok := uc.channels[name]
910 if !ok {
911 // NAMES on a channel we have not joined, forward to downstream
912 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
913 channel := dc.marshalChannel(uc, name)
914 members := splitSpace(members)
915 for i, member := range members {
916 membership, nick := uc.parseMembershipPrefix(member)
917 members[i] = membership.String() + dc.marshalNick(uc, nick)
918 }
919 memberStr := strings.Join(members, " ")
920
921 dc.SendMessage(&irc.Message{
922 Prefix: dc.srv.prefix(),
923 Command: irc.RPL_NAMREPLY,
924 Params: []string{dc.nick, statusStr, channel, memberStr},
925 })
926 })
927 return nil
928 }
929
930 status, err := parseChannelStatus(statusStr)
931 if err != nil {
932 return err
933 }
934 ch.Status = status
935
936 for _, s := range splitSpace(members) {
937 membership, nick := uc.parseMembershipPrefix(s)
938 ch.Members[nick] = membership
939 }
940 case irc.RPL_ENDOFNAMES:
941 var name string
942 if err := parseMessageParams(msg, nil, &name); err != nil {
943 return err
944 }
945
946 ch, ok := uc.channels[name]
947 if !ok {
948 // NAMES on a channel we have not joined, forward to downstream
949 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
950 channel := dc.marshalChannel(uc, name)
951
952 dc.SendMessage(&irc.Message{
953 Prefix: dc.srv.prefix(),
954 Command: irc.RPL_ENDOFNAMES,
955 Params: []string{dc.nick, channel, "End of /NAMES list"},
956 })
957 })
958 return nil
959 }
960
961 if ch.complete {
962 return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
963 }
964 ch.complete = true
965
966 uc.forEachDownstream(func(dc *downstreamConn) {
967 forwardChannel(dc, ch)
968 })
969 case irc.RPL_WHOREPLY:
970 var channel, username, host, server, nick, mode, trailing string
971 if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
972 return err
973 }
974
975 parts := strings.SplitN(trailing, " ", 2)
976 if len(parts) != 2 {
977 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
978 }
979 realname := parts[1]
980 hops, err := strconv.Atoi(parts[0])
981 if err != nil {
982 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
983 }
984 hops++
985
986 trailing = strconv.Itoa(hops) + " " + realname
987
988 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
989 channel := channel
990 if channel != "*" {
991 channel = dc.marshalChannel(uc, channel)
992 }
993 nick := dc.marshalNick(uc, nick)
994 dc.SendMessage(&irc.Message{
995 Prefix: dc.srv.prefix(),
996 Command: irc.RPL_WHOREPLY,
997 Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
998 })
999 })
1000 case irc.RPL_ENDOFWHO:
1001 var name string
1002 if err := parseMessageParams(msg, nil, &name); err != nil {
1003 return err
1004 }
1005
1006 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1007 name := name
1008 if name != "*" {
1009 // TODO: support WHO masks
1010 name = dc.marshalEntity(uc, name)
1011 }
1012 dc.SendMessage(&irc.Message{
1013 Prefix: dc.srv.prefix(),
1014 Command: irc.RPL_ENDOFWHO,
1015 Params: []string{dc.nick, name, "End of /WHO list"},
1016 })
1017 })
1018 case irc.RPL_WHOISUSER:
1019 var nick, username, host, realname string
1020 if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
1021 return err
1022 }
1023
1024 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1025 nick := dc.marshalNick(uc, nick)
1026 dc.SendMessage(&irc.Message{
1027 Prefix: dc.srv.prefix(),
1028 Command: irc.RPL_WHOISUSER,
1029 Params: []string{dc.nick, nick, username, host, "*", realname},
1030 })
1031 })
1032 case irc.RPL_WHOISSERVER:
1033 var nick, server, serverInfo string
1034 if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
1035 return err
1036 }
1037
1038 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1039 nick := dc.marshalNick(uc, nick)
1040 dc.SendMessage(&irc.Message{
1041 Prefix: dc.srv.prefix(),
1042 Command: irc.RPL_WHOISSERVER,
1043 Params: []string{dc.nick, nick, server, serverInfo},
1044 })
1045 })
1046 case irc.RPL_WHOISOPERATOR:
1047 var nick string
1048 if err := parseMessageParams(msg, nil, &nick); err != nil {
1049 return err
1050 }
1051
1052 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1053 nick := dc.marshalNick(uc, nick)
1054 dc.SendMessage(&irc.Message{
1055 Prefix: dc.srv.prefix(),
1056 Command: irc.RPL_WHOISOPERATOR,
1057 Params: []string{dc.nick, nick, "is an IRC operator"},
1058 })
1059 })
1060 case irc.RPL_WHOISIDLE:
1061 var nick string
1062 if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
1063 return err
1064 }
1065
1066 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1067 nick := dc.marshalNick(uc, nick)
1068 params := []string{dc.nick, nick}
1069 params = append(params, msg.Params[2:]...)
1070 dc.SendMessage(&irc.Message{
1071 Prefix: dc.srv.prefix(),
1072 Command: irc.RPL_WHOISIDLE,
1073 Params: params,
1074 })
1075 })
1076 case irc.RPL_WHOISCHANNELS:
1077 var nick, channelList string
1078 if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
1079 return err
1080 }
1081 channels := splitSpace(channelList)
1082
1083 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1084 nick := dc.marshalNick(uc, nick)
1085 channelList := make([]string, len(channels))
1086 for i, channel := range channels {
1087 prefix, channel := uc.parseMembershipPrefix(channel)
1088 channel = dc.marshalChannel(uc, channel)
1089 channelList[i] = prefix.String() + channel
1090 }
1091 channels := strings.Join(channelList, " ")
1092 dc.SendMessage(&irc.Message{
1093 Prefix: dc.srv.prefix(),
1094 Command: irc.RPL_WHOISCHANNELS,
1095 Params: []string{dc.nick, nick, channels},
1096 })
1097 })
1098 case irc.RPL_ENDOFWHOIS:
1099 var nick string
1100 if err := parseMessageParams(msg, nil, &nick); err != nil {
1101 return err
1102 }
1103
1104 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1105 nick := dc.marshalNick(uc, nick)
1106 dc.SendMessage(&irc.Message{
1107 Prefix: dc.srv.prefix(),
1108 Command: irc.RPL_ENDOFWHOIS,
1109 Params: []string{dc.nick, nick, "End of /WHOIS list"},
1110 })
1111 })
1112 case "PRIVMSG":
1113 if msg.Prefix == nil {
1114 return fmt.Errorf("expected a prefix")
1115 }
1116
1117 var entity, text string
1118 if err := parseMessageParams(msg, &entity, &text); err != nil {
1119 return err
1120 }
1121
1122 if msg.Prefix.Name == serviceNick {
1123 uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
1124 break
1125 }
1126 if entity == serviceNick {
1127 uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
1128 break
1129 }
1130
1131 target := entity
1132 if target == uc.nick {
1133 target = msg.Prefix.Name
1134 }
1135 uc.produce(target, msg, nil)
1136 case "INVITE":
1137 var nick string
1138 var channel string
1139 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1140 return err
1141 }
1142
1143 uc.forEachDownstream(func(dc *downstreamConn) {
1144 dc.SendMessage(&irc.Message{
1145 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
1146 Command: "INVITE",
1147 Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1148 })
1149 })
1150 case irc.RPL_INVITING:
1151 var nick string
1152 var channel string
1153 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1154 return err
1155 }
1156
1157 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1158 dc.SendMessage(&irc.Message{
1159 Prefix: dc.srv.prefix(),
1160 Command: irc.RPL_INVITING,
1161 Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1162 })
1163 })
1164 case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
1165 var command, reason string
1166 if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
1167 return err
1168 }
1169
1170 if command == "LIST" {
1171 ok := uc.endPendingLISTs(false)
1172 if !ok {
1173 return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
1174 }
1175 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1176 dc.SendMessage(&irc.Message{
1177 Prefix: uc.srv.prefix(),
1178 Command: msg.Command,
1179 Params: []string{dc.nick, "LIST", reason},
1180 })
1181 })
1182 }
1183 case "TAGMSG":
1184 // TODO: relay to downstream connections that accept message-tags
1185 case "ACK":
1186 // Ignore
1187 case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
1188 // Ignore
1189 case irc.RPL_YOURHOST, irc.RPL_CREATED:
1190 // Ignore
1191 case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
1192 // Ignore
1193 case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
1194 // Ignore
1195 case irc.RPL_LISTSTART:
1196 // Ignore
1197 case rpl_localusers, rpl_globalusers:
1198 // Ignore
1199 case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
1200 // Ignore
1201 default:
1202 uc.logger.Printf("unhandled message: %v", msg)
1203 }
1204 return nil
1205}
1206
1207func splitSpace(s string) []string {
1208 return strings.FieldsFunc(s, func(r rune) bool {
1209 return r == ' '
1210 })
1211}
1212
1213func (uc *upstreamConn) register() {
1214 uc.nick = uc.network.Nick
1215 uc.username = uc.network.Username
1216 if uc.username == "" {
1217 uc.username = uc.nick
1218 }
1219 uc.realname = uc.network.Realname
1220 if uc.realname == "" {
1221 uc.realname = uc.nick
1222 }
1223
1224 uc.SendMessage(&irc.Message{
1225 Command: "CAP",
1226 Params: []string{"LS", "302"},
1227 })
1228
1229 if uc.network.Pass != "" {
1230 uc.SendMessage(&irc.Message{
1231 Command: "PASS",
1232 Params: []string{uc.network.Pass},
1233 })
1234 }
1235
1236 uc.SendMessage(&irc.Message{
1237 Command: "NICK",
1238 Params: []string{uc.nick},
1239 })
1240 uc.SendMessage(&irc.Message{
1241 Command: "USER",
1242 Params: []string{uc.username, "0", "*", uc.realname},
1243 })
1244}
1245
1246func (uc *upstreamConn) runUntilRegistered() error {
1247 for !uc.registered {
1248 msg, err := uc.ReadMessage()
1249 if err != nil {
1250 return fmt.Errorf("failed to read message: %v", err)
1251 }
1252
1253 if err := uc.handleMessage(msg); err != nil {
1254 return fmt.Errorf("failed to handle message %q: %v", msg, err)
1255 }
1256 }
1257
1258 return nil
1259}
1260
1261func (uc *upstreamConn) requestSASL() bool {
1262 if uc.network.SASL.Mechanism == "" {
1263 return false
1264 }
1265
1266 v, ok := uc.caps["sasl"]
1267 if !ok {
1268 return false
1269 }
1270 if v != "" {
1271 mechanisms := strings.Split(v, ",")
1272 found := false
1273 for _, mech := range mechanisms {
1274 if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
1275 found = true
1276 break
1277 }
1278 }
1279 if !found {
1280 return false
1281 }
1282 }
1283
1284 return true
1285}
1286
1287func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
1288 auth := &uc.network.SASL
1289 switch name {
1290 case "sasl":
1291 if !ok {
1292 uc.logger.Printf("server refused to acknowledge the SASL capability")
1293 return nil
1294 }
1295
1296 switch auth.Mechanism {
1297 case "PLAIN":
1298 uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
1299 uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
1300 default:
1301 return fmt.Errorf("unsupported SASL mechanism %q", name)
1302 }
1303
1304 uc.SendMessage(&irc.Message{
1305 Command: "AUTHENTICATE",
1306 Params: []string{auth.Mechanism},
1307 })
1308 case "message-tags":
1309 uc.tagsSupported = ok
1310 case "labeled-response":
1311 uc.labelsSupported = ok
1312 case "batch", "server-time":
1313 // Nothing to do
1314 default:
1315 uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
1316 }
1317 return nil
1318}
1319
1320func (uc *upstreamConn) readMessages(ch chan<- event) error {
1321 for {
1322 msg, err := uc.ReadMessage()
1323 if err == io.EOF {
1324 break
1325 } else if err != nil {
1326 return fmt.Errorf("failed to read IRC command: %v", err)
1327 }
1328
1329 ch <- eventUpstreamMessage{msg, uc}
1330 }
1331
1332 return nil
1333}
1334
1335func (uc *upstreamConn) SendMessageLabeled(downstreamID uint64, msg *irc.Message) {
1336 if uc.labelsSupported {
1337 if msg.Tags == nil {
1338 msg.Tags = make(map[string]irc.TagValue)
1339 }
1340 msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
1341 uc.nextLabelID++
1342 }
1343 uc.SendMessage(msg)
1344}
1345
1346// TODO: handle moving logs when a network name changes, when support for this is added
1347func (uc *upstreamConn) appendLog(entity string, msg *irc.Message) {
1348 if uc.srv.LogPath == "" {
1349 return
1350 }
1351
1352 ml, ok := uc.messageLoggers[entity]
1353 if !ok {
1354 ml = newMessageLogger(uc, entity)
1355 uc.messageLoggers[entity] = ml
1356 }
1357
1358 if err := ml.Append(msg); err != nil {
1359 uc.logger.Printf("failed to log message: %v", err)
1360 }
1361}
1362
1363func (uc *upstreamConn) produce(target string, msg *irc.Message, origin *downstreamConn) {
1364 if target != "" {
1365 uc.appendLog(target, msg)
1366 }
1367
1368 uc.network.ring.Produce(msg)
1369
1370 uc.forEachDownstream(func(dc *downstreamConn) {
1371 if dc != origin || dc.caps["echo-message"] {
1372 dc.sendFromUpstream(msg, uc)
1373 }
1374 })
1375}
1376
1377func (uc *upstreamConn) updateAway() {
1378 away := true
1379 uc.forEachDownstream(func(*downstreamConn) {
1380 away = false
1381 })
1382 if away == uc.away {
1383 return
1384 }
1385 if away {
1386 uc.SendMessage(&irc.Message{
1387 Command: "AWAY",
1388 Params: []string{"Auto away"},
1389 })
1390 } else {
1391 uc.SendMessage(&irc.Message{
1392 Command: "AWAY",
1393 })
1394 }
1395 uc.away = away
1396}
Note: See TracBrowser for help on using the repository browser.