source: code/trunk/irc.go@ 686

Last change on this file since 686 was 684, checked in by contact, 4 years ago

Add support for MONITOR

Add support for MONITOR in single-upstream mode.

Each downstream has its own set of monitored targets. These sets
are merged together to compute the MONITOR commands to send to
upstream.

Each upstream has a set of monitored targets accepted by the server
alongside with their status (online/offline). This is used to
directly send replies to downstreams adding a target another
downstream has already added, and send MONITOR S[TATUS] replies.

Co-authored-by: delthas <delthas@…>
File size: 18.2 KB
Line 
1package soju
2
3import (
4 "fmt"
5 "sort"
6 "strings"
7 "time"
8 "unicode"
9 "unicode/utf8"
10
11 "gopkg.in/irc.v3"
12)
13
14const (
15 rpl_statsping = "246"
16 rpl_localusers = "265"
17 rpl_globalusers = "266"
18 rpl_creationtime = "329"
19 rpl_topicwhotime = "333"
20 rpl_whospcrpl = "354"
21 rpl_whoisaccount = "330"
22 err_invalidcapcmd = "410"
23)
24
25const (
26 maxMessageLength = 512
27 maxMessageParams = 15
28)
29
30// The server-time layout, as defined in the IRCv3 spec.
31const serverTimeLayout = "2006-01-02T15:04:05.000Z"
32
33type userModes string
34
35func (ms userModes) Has(c byte) bool {
36 return strings.IndexByte(string(ms), c) >= 0
37}
38
39func (ms *userModes) Add(c byte) {
40 if !ms.Has(c) {
41 *ms += userModes(c)
42 }
43}
44
45func (ms *userModes) Del(c byte) {
46 i := strings.IndexByte(string(*ms), c)
47 if i >= 0 {
48 *ms = (*ms)[:i] + (*ms)[i+1:]
49 }
50}
51
52func (ms *userModes) Apply(s string) error {
53 var plusMinus byte
54 for i := 0; i < len(s); i++ {
55 switch c := s[i]; c {
56 case '+', '-':
57 plusMinus = c
58 default:
59 switch plusMinus {
60 case '+':
61 ms.Add(c)
62 case '-':
63 ms.Del(c)
64 default:
65 return fmt.Errorf("malformed modestring %q: missing plus/minus", s)
66 }
67 }
68 }
69 return nil
70}
71
72type channelModeType byte
73
74// standard channel mode types, as explained in https://modern.ircdocs.horse/#mode-message
75const (
76 // modes that add or remove an address to or from a list
77 modeTypeA channelModeType = iota
78 // modes that change a setting on a channel, and must always have a parameter
79 modeTypeB
80 // modes that change a setting on a channel, and must have a parameter when being set, and no parameter when being unset
81 modeTypeC
82 // modes that change a setting on a channel, and must not have a parameter
83 modeTypeD
84)
85
86var stdChannelModes = map[byte]channelModeType{
87 'b': modeTypeA, // ban list
88 'e': modeTypeA, // ban exception list
89 'I': modeTypeA, // invite exception list
90 'k': modeTypeB, // channel key
91 'l': modeTypeC, // channel user limit
92 'i': modeTypeD, // channel is invite-only
93 'm': modeTypeD, // channel is moderated
94 'n': modeTypeD, // channel has no external messages
95 's': modeTypeD, // channel is secret
96 't': modeTypeD, // channel has protected topic
97}
98
99type channelModes map[byte]string
100
101// applyChannelModes parses a mode string and mode arguments from a MODE message,
102// and applies the corresponding channel mode and user membership changes on that channel.
103//
104// If ch.modes is nil, channel modes are not updated.
105//
106// needMarshaling is a list of indexes of mode arguments that represent entities
107// that must be marshaled when sent downstream.
108func applyChannelModes(ch *upstreamChannel, modeStr string, arguments []string) (needMarshaling map[int]struct{}, err error) {
109 needMarshaling = make(map[int]struct{}, len(arguments))
110 nextArgument := 0
111 var plusMinus byte
112outer:
113 for i := 0; i < len(modeStr); i++ {
114 mode := modeStr[i]
115 if mode == '+' || mode == '-' {
116 plusMinus = mode
117 continue
118 }
119 if plusMinus != '+' && plusMinus != '-' {
120 return nil, fmt.Errorf("malformed modestring %q: missing plus/minus", modeStr)
121 }
122
123 for _, membership := range ch.conn.availableMemberships {
124 if membership.Mode == mode {
125 if nextArgument >= len(arguments) {
126 return nil, fmt.Errorf("malformed modestring %q: missing mode argument for %c%c", modeStr, plusMinus, mode)
127 }
128 member := arguments[nextArgument]
129 m := ch.Members.Value(member)
130 if m != nil {
131 if plusMinus == '+' {
132 m.Add(ch.conn.availableMemberships, membership)
133 } else {
134 // TODO: for upstreams without multi-prefix, query the user modes again
135 m.Remove(membership)
136 }
137 }
138 needMarshaling[nextArgument] = struct{}{}
139 nextArgument++
140 continue outer
141 }
142 }
143
144 mt, ok := ch.conn.availableChannelModes[mode]
145 if !ok {
146 continue
147 }
148 if mt == modeTypeA {
149 nextArgument++
150 } else if mt == modeTypeB || (mt == modeTypeC && plusMinus == '+') {
151 if plusMinus == '+' {
152 var argument string
153 // some sentitive arguments (such as channel keys) can be omitted for privacy
154 // (this will only happen for RPL_CHANNELMODEIS, never for MODE messages)
155 if nextArgument < len(arguments) {
156 argument = arguments[nextArgument]
157 }
158 if ch.modes != nil {
159 ch.modes[mode] = argument
160 }
161 } else {
162 delete(ch.modes, mode)
163 }
164 nextArgument++
165 } else if mt == modeTypeC || mt == modeTypeD {
166 if plusMinus == '+' {
167 if ch.modes != nil {
168 ch.modes[mode] = ""
169 }
170 } else {
171 delete(ch.modes, mode)
172 }
173 }
174 }
175 return needMarshaling, nil
176}
177
178func (cm channelModes) Format() (modeString string, parameters []string) {
179 var modesWithValues strings.Builder
180 var modesWithoutValues strings.Builder
181 parameters = make([]string, 0, 16)
182 for mode, value := range cm {
183 if value != "" {
184 modesWithValues.WriteString(string(mode))
185 parameters = append(parameters, value)
186 } else {
187 modesWithoutValues.WriteString(string(mode))
188 }
189 }
190 modeString = "+" + modesWithValues.String() + modesWithoutValues.String()
191 return
192}
193
194const stdChannelTypes = "#&+!"
195
196type channelStatus byte
197
198const (
199 channelPublic channelStatus = '='
200 channelSecret channelStatus = '@'
201 channelPrivate channelStatus = '*'
202)
203
204func parseChannelStatus(s string) (channelStatus, error) {
205 if len(s) > 1 {
206 return 0, fmt.Errorf("invalid channel status %q: more than one character", s)
207 }
208 switch cs := channelStatus(s[0]); cs {
209 case channelPublic, channelSecret, channelPrivate:
210 return cs, nil
211 default:
212 return 0, fmt.Errorf("invalid channel status %q: unknown status", s)
213 }
214}
215
216type membership struct {
217 Mode byte
218 Prefix byte
219}
220
221var stdMemberships = []membership{
222 {'q', '~'}, // founder
223 {'a', '&'}, // protected
224 {'o', '@'}, // operator
225 {'h', '%'}, // halfop
226 {'v', '+'}, // voice
227}
228
229// memberships always sorted by descending membership rank
230type memberships []membership
231
232func (m *memberships) Add(availableMemberships []membership, newMembership membership) {
233 l := *m
234 i := 0
235 for _, availableMembership := range availableMemberships {
236 if i >= len(l) {
237 break
238 }
239 if l[i] == availableMembership {
240 if availableMembership == newMembership {
241 // we already have this membership
242 return
243 }
244 i++
245 continue
246 }
247 if availableMembership == newMembership {
248 break
249 }
250 }
251 // insert newMembership at i
252 l = append(l, membership{})
253 copy(l[i+1:], l[i:])
254 l[i] = newMembership
255 *m = l
256}
257
258func (m *memberships) Remove(oldMembership membership) {
259 l := *m
260 for i, currentMembership := range l {
261 if currentMembership == oldMembership {
262 *m = append(l[:i], l[i+1:]...)
263 return
264 }
265 }
266}
267
268func (m memberships) Format(dc *downstreamConn) string {
269 if !dc.caps["multi-prefix"] {
270 if len(m) == 0 {
271 return ""
272 }
273 return string(m[0].Prefix)
274 }
275 prefixes := make([]byte, len(m))
276 for i, membership := range m {
277 prefixes[i] = membership.Prefix
278 }
279 return string(prefixes)
280}
281
282func parseMessageParams(msg *irc.Message, out ...*string) error {
283 if len(msg.Params) < len(out) {
284 return newNeedMoreParamsError(msg.Command)
285 }
286 for i := range out {
287 if out[i] != nil {
288 *out[i] = msg.Params[i]
289 }
290 }
291 return nil
292}
293
294func copyClientTags(tags irc.Tags) irc.Tags {
295 t := make(irc.Tags, len(tags))
296 for k, v := range tags {
297 if strings.HasPrefix(k, "+") {
298 t[k] = v
299 }
300 }
301 return t
302}
303
304type batch struct {
305 Type string
306 Params []string
307 Outer *batch // if not-nil, this batch is nested in Outer
308 Label string
309}
310
311func join(channels, keys []string) []*irc.Message {
312 // Put channels with a key first
313 js := joinSorter{channels, keys}
314 sort.Sort(&js)
315
316 // Two spaces because there are three words (JOIN, channels and keys)
317 maxLength := maxMessageLength - (len("JOIN") + 2)
318
319 var msgs []*irc.Message
320 var channelsBuf, keysBuf strings.Builder
321 for i, channel := range channels {
322 key := keys[i]
323
324 n := channelsBuf.Len() + keysBuf.Len() + 1 + len(channel)
325 if key != "" {
326 n += 1 + len(key)
327 }
328
329 if channelsBuf.Len() > 0 && n > maxLength {
330 // No room for the new channel in this message
331 params := []string{channelsBuf.String()}
332 if keysBuf.Len() > 0 {
333 params = append(params, keysBuf.String())
334 }
335 msgs = append(msgs, &irc.Message{Command: "JOIN", Params: params})
336 channelsBuf.Reset()
337 keysBuf.Reset()
338 }
339
340 if channelsBuf.Len() > 0 {
341 channelsBuf.WriteByte(',')
342 }
343 channelsBuf.WriteString(channel)
344 if key != "" {
345 if keysBuf.Len() > 0 {
346 keysBuf.WriteByte(',')
347 }
348 keysBuf.WriteString(key)
349 }
350 }
351 if channelsBuf.Len() > 0 {
352 params := []string{channelsBuf.String()}
353 if keysBuf.Len() > 0 {
354 params = append(params, keysBuf.String())
355 }
356 msgs = append(msgs, &irc.Message{Command: "JOIN", Params: params})
357 }
358
359 return msgs
360}
361
362func generateIsupport(prefix *irc.Prefix, nick string, tokens []string) []*irc.Message {
363 maxTokens := maxMessageParams - 2 // 2 reserved params: nick + text
364
365 var msgs []*irc.Message
366 for len(tokens) > 0 {
367 var msgTokens []string
368 if len(tokens) > maxTokens {
369 msgTokens = tokens[:maxTokens]
370 tokens = tokens[maxTokens:]
371 } else {
372 msgTokens = tokens
373 tokens = nil
374 }
375
376 msgs = append(msgs, &irc.Message{
377 Prefix: prefix,
378 Command: irc.RPL_ISUPPORT,
379 Params: append(append([]string{nick}, msgTokens...), "are supported"),
380 })
381 }
382
383 return msgs
384}
385
386func generateMOTD(prefix *irc.Prefix, nick string, motd string) []*irc.Message {
387 var msgs []*irc.Message
388 msgs = append(msgs, &irc.Message{
389 Prefix: prefix,
390 Command: irc.RPL_MOTDSTART,
391 Params: []string{nick, fmt.Sprintf("- Message of the Day -")},
392 })
393
394 for _, l := range strings.Split(motd, "\n") {
395 msgs = append(msgs, &irc.Message{
396 Prefix: prefix,
397 Command: irc.RPL_MOTD,
398 Params: []string{nick, l},
399 })
400 }
401
402 msgs = append(msgs, &irc.Message{
403 Prefix: prefix,
404 Command: irc.RPL_ENDOFMOTD,
405 Params: []string{nick, "End of /MOTD command."},
406 })
407
408 return msgs
409}
410
411func generateMonitor(subcmd string, targets []string) []*irc.Message {
412 maxLength := maxMessageLength - len("MONITOR "+subcmd+" ")
413
414 var msgs []*irc.Message
415 var buf []string
416 n := 0
417 for _, target := range targets {
418 if n+len(target)+1 > maxLength {
419 msgs = append(msgs, &irc.Message{
420 Command: "MONITOR",
421 Params: []string{subcmd, strings.Join(buf, ",")},
422 })
423 buf = buf[:0]
424 n = 0
425 }
426
427 buf = append(buf, target)
428 n += len(target) + 1
429 }
430
431 if len(buf) > 0 {
432 msgs = append(msgs, &irc.Message{
433 Command: "MONITOR",
434 Params: []string{subcmd, strings.Join(buf, ",")},
435 })
436 }
437
438 return msgs
439}
440
441type joinSorter struct {
442 channels []string
443 keys []string
444}
445
446func (js *joinSorter) Len() int {
447 return len(js.channels)
448}
449
450func (js *joinSorter) Less(i, j int) bool {
451 if (js.keys[i] != "") != (js.keys[j] != "") {
452 // Only one of the channels has a key
453 return js.keys[i] != ""
454 }
455 return js.channels[i] < js.channels[j]
456}
457
458func (js *joinSorter) Swap(i, j int) {
459 js.channels[i], js.channels[j] = js.channels[j], js.channels[i]
460 js.keys[i], js.keys[j] = js.keys[j], js.keys[i]
461}
462
463// parseCTCPMessage parses a CTCP message. CTCP is defined in
464// https://tools.ietf.org/html/draft-oakley-irc-ctcp-02
465func parseCTCPMessage(msg *irc.Message) (cmd string, params string, ok bool) {
466 if (msg.Command != "PRIVMSG" && msg.Command != "NOTICE") || len(msg.Params) < 2 {
467 return "", "", false
468 }
469 text := msg.Params[1]
470
471 if !strings.HasPrefix(text, "\x01") {
472 return "", "", false
473 }
474 text = strings.Trim(text, "\x01")
475
476 words := strings.SplitN(text, " ", 2)
477 cmd = strings.ToUpper(words[0])
478 if len(words) > 1 {
479 params = words[1]
480 }
481
482 return cmd, params, true
483}
484
485type casemapping func(string) string
486
487func casemapNone(name string) string {
488 return name
489}
490
491// CasemapASCII of name is the canonical representation of name according to the
492// ascii casemapping.
493func casemapASCII(name string) string {
494 nameBytes := []byte(name)
495 for i, r := range nameBytes {
496 if 'A' <= r && r <= 'Z' {
497 nameBytes[i] = r + 'a' - 'A'
498 }
499 }
500 return string(nameBytes)
501}
502
503// casemapRFC1459 of name is the canonical representation of name according to the
504// rfc1459 casemapping.
505func casemapRFC1459(name string) string {
506 nameBytes := []byte(name)
507 for i, r := range nameBytes {
508 if 'A' <= r && r <= 'Z' {
509 nameBytes[i] = r + 'a' - 'A'
510 } else if r == '{' {
511 nameBytes[i] = '['
512 } else if r == '}' {
513 nameBytes[i] = ']'
514 } else if r == '\\' {
515 nameBytes[i] = '|'
516 } else if r == '~' {
517 nameBytes[i] = '^'
518 }
519 }
520 return string(nameBytes)
521}
522
523// casemapRFC1459Strict of name is the canonical representation of name
524// according to the rfc1459-strict casemapping.
525func casemapRFC1459Strict(name string) string {
526 nameBytes := []byte(name)
527 for i, r := range nameBytes {
528 if 'A' <= r && r <= 'Z' {
529 nameBytes[i] = r + 'a' - 'A'
530 } else if r == '{' {
531 nameBytes[i] = '['
532 } else if r == '}' {
533 nameBytes[i] = ']'
534 } else if r == '\\' {
535 nameBytes[i] = '|'
536 }
537 }
538 return string(nameBytes)
539}
540
541func parseCasemappingToken(tokenValue string) (casemap casemapping, ok bool) {
542 switch tokenValue {
543 case "ascii":
544 casemap = casemapASCII
545 case "rfc1459":
546 casemap = casemapRFC1459
547 case "rfc1459-strict":
548 casemap = casemapRFC1459Strict
549 default:
550 return nil, false
551 }
552 return casemap, true
553}
554
555func partialCasemap(higher casemapping, name string) string {
556 nameFullyCM := []byte(higher(name))
557 nameBytes := []byte(name)
558 for i, r := range nameBytes {
559 if !('A' <= r && r <= 'Z') && !('a' <= r && r <= 'z') {
560 nameBytes[i] = nameFullyCM[i]
561 }
562 }
563 return string(nameBytes)
564}
565
566type casemapMap struct {
567 innerMap map[string]casemapEntry
568 casemap casemapping
569}
570
571type casemapEntry struct {
572 originalKey string
573 value interface{}
574}
575
576func newCasemapMap(size int) casemapMap {
577 return casemapMap{
578 innerMap: make(map[string]casemapEntry, size),
579 casemap: casemapNone,
580 }
581}
582
583func (cm *casemapMap) OriginalKey(name string) (key string, ok bool) {
584 entry, ok := cm.innerMap[cm.casemap(name)]
585 if !ok {
586 return "", false
587 }
588 return entry.originalKey, true
589}
590
591func (cm *casemapMap) Has(name string) bool {
592 _, ok := cm.innerMap[cm.casemap(name)]
593 return ok
594}
595
596func (cm *casemapMap) Len() int {
597 return len(cm.innerMap)
598}
599
600func (cm *casemapMap) SetValue(name string, value interface{}) {
601 nameCM := cm.casemap(name)
602 entry, ok := cm.innerMap[nameCM]
603 if !ok {
604 cm.innerMap[nameCM] = casemapEntry{
605 originalKey: name,
606 value: value,
607 }
608 return
609 }
610 entry.value = value
611 cm.innerMap[nameCM] = entry
612}
613
614func (cm *casemapMap) Delete(name string) {
615 delete(cm.innerMap, cm.casemap(name))
616}
617
618func (cm *casemapMap) SetCasemapping(newCasemap casemapping) {
619 cm.casemap = newCasemap
620 newInnerMap := make(map[string]casemapEntry, len(cm.innerMap))
621 for _, entry := range cm.innerMap {
622 newInnerMap[cm.casemap(entry.originalKey)] = entry
623 }
624 cm.innerMap = newInnerMap
625}
626
627type upstreamChannelCasemapMap struct{ casemapMap }
628
629func (cm *upstreamChannelCasemapMap) Value(name string) *upstreamChannel {
630 entry, ok := cm.innerMap[cm.casemap(name)]
631 if !ok {
632 return nil
633 }
634 return entry.value.(*upstreamChannel)
635}
636
637type channelCasemapMap struct{ casemapMap }
638
639func (cm *channelCasemapMap) Value(name string) *Channel {
640 entry, ok := cm.innerMap[cm.casemap(name)]
641 if !ok {
642 return nil
643 }
644 return entry.value.(*Channel)
645}
646
647type membershipsCasemapMap struct{ casemapMap }
648
649func (cm *membershipsCasemapMap) Value(name string) *memberships {
650 entry, ok := cm.innerMap[cm.casemap(name)]
651 if !ok {
652 return nil
653 }
654 return entry.value.(*memberships)
655}
656
657type deliveredCasemapMap struct{ casemapMap }
658
659func (cm *deliveredCasemapMap) Value(name string) deliveredClientMap {
660 entry, ok := cm.innerMap[cm.casemap(name)]
661 if !ok {
662 return nil
663 }
664 return entry.value.(deliveredClientMap)
665}
666
667type monitorCasemapMap struct{ casemapMap }
668
669func (cm *monitorCasemapMap) Value(name string) (online bool) {
670 entry, ok := cm.innerMap[cm.casemap(name)]
671 if !ok {
672 return false
673 }
674 return entry.value.(bool)
675}
676
677func isWordBoundary(r rune) bool {
678 switch r {
679 case '-', '_', '|':
680 return false
681 case '\u00A0':
682 return true
683 default:
684 return !unicode.IsLetter(r) && !unicode.IsNumber(r)
685 }
686}
687
688func isHighlight(text, nick string) bool {
689 for {
690 i := strings.Index(text, nick)
691 if i < 0 {
692 return false
693 }
694
695 // Detect word boundaries
696 var left, right rune
697 if i > 0 {
698 left, _ = utf8.DecodeLastRuneInString(text[:i])
699 }
700 if i < len(text) {
701 right, _ = utf8.DecodeRuneInString(text[i+len(nick):])
702 }
703 if isWordBoundary(left) && isWordBoundary(right) {
704 return true
705 }
706
707 text = text[i+len(nick):]
708 }
709}
710
711// parseChatHistoryBound parses the given CHATHISTORY parameter as a bound.
712// The zero time is returned on error.
713func parseChatHistoryBound(param string) time.Time {
714 parts := strings.SplitN(param, "=", 2)
715 if len(parts) != 2 {
716 return time.Time{}
717 }
718 switch parts[0] {
719 case "timestamp":
720 timestamp, err := time.Parse(serverTimeLayout, parts[1])
721 if err != nil {
722 return time.Time{}
723 }
724 return timestamp
725 default:
726 return time.Time{}
727 }
728}
729
730type whoxInfo struct {
731 Token string
732 Username string
733 Hostname string
734 Server string
735 Nickname string
736 Flags string
737 Account string
738 Realname string
739}
740
741func generateWHOXReply(prefix *irc.Prefix, nick, fields string, info *whoxInfo) *irc.Message {
742 if fields == "" {
743 return &irc.Message{
744 Prefix: prefix,
745 Command: irc.RPL_WHOREPLY,
746 Params: []string{nick, "*", info.Username, info.Hostname, info.Server, info.Nickname, info.Flags, "0 " + info.Realname},
747 }
748 }
749
750 fieldSet := make(map[byte]bool)
751 for i := 0; i < len(fields); i++ {
752 fieldSet[fields[i]] = true
753 }
754
755 var params []string
756 if fieldSet['t'] {
757 params = append(params, info.Token)
758 }
759 if fieldSet['c'] {
760 params = append(params, "*")
761 }
762 if fieldSet['u'] {
763 params = append(params, info.Username)
764 }
765 if fieldSet['i'] {
766 params = append(params, "255.255.255.255")
767 }
768 if fieldSet['h'] {
769 params = append(params, info.Hostname)
770 }
771 if fieldSet['s'] {
772 params = append(params, info.Server)
773 }
774 if fieldSet['n'] {
775 params = append(params, info.Nickname)
776 }
777 if fieldSet['f'] {
778 params = append(params, info.Flags)
779 }
780 if fieldSet['d'] {
781 params = append(params, "0")
782 }
783 if fieldSet['l'] { // idle time
784 params = append(params, "0")
785 }
786 if fieldSet['a'] {
787 account := "0" // WHOX uses "0" to mean "no account"
788 if info.Account != "" && info.Account != "*" {
789 account = info.Account
790 }
791 params = append(params, account)
792 }
793 if fieldSet['o'] {
794 params = append(params, "0")
795 }
796 if fieldSet['r'] {
797 params = append(params, info.Realname)
798 }
799
800 return &irc.Message{
801 Prefix: prefix,
802 Command: rpl_whospcrpl,
803 Params: append([]string{nick}, params...),
804 }
805}
806
807var isupportEncoder = strings.NewReplacer(" ", "\\x20", "\\", "\\x5C")
808
809func encodeISUPPORT(s string) string {
810 return isupportEncoder.Replace(s)
811}
Note: See TracBrowser for help on using the repository browser.