source: code/trunk/upstream.go@ 690

Last change on this file since 690 was 685, checked in by delthas, 4 years ago

Add support for draft/extended-monitor

References: ​https://github.com/ircv3/ircv3-specifications/pull/466
File size: 50.5 KB
Line 
1package soju
2
3import (
4 "context"
5 "crypto"
6 "crypto/sha256"
7 "crypto/tls"
8 "crypto/x509"
9 "encoding/base64"
10 "errors"
11 "fmt"
12 "io"
13 "net"
14 "strconv"
15 "strings"
16 "time"
17
18 "github.com/emersion/go-sasl"
19 "gopkg.in/irc.v3"
20)
21
22// permanentUpstreamCaps is the static list of upstream capabilities always
23// requested when supported.
24var permanentUpstreamCaps = map[string]bool{
25 "account-tag": true,
26 "away-notify": true,
27 "batch": true,
28 "extended-join": true,
29 "invite-notify": true,
30 "labeled-response": true,
31 "message-tags": true,
32 "multi-prefix": true,
33 "server-time": true,
34 "setname": true,
35
36 "draft/extended-monitor": true,
37}
38
39type registrationError string
40
41func (err registrationError) Error() string {
42 return fmt.Sprintf("registration error: %v", string(err))
43}
44
45type upstreamChannel struct {
46 Name string
47 conn *upstreamConn
48 Topic string
49 TopicWho *irc.Prefix
50 TopicTime time.Time
51 Status channelStatus
52 modes channelModes
53 creationTime string
54 Members membershipsCasemapMap
55 complete bool
56 detachTimer *time.Timer
57}
58
59func (uc *upstreamChannel) updateAutoDetach(dur time.Duration) {
60 if uc.detachTimer != nil {
61 uc.detachTimer.Stop()
62 uc.detachTimer = nil
63 }
64
65 if dur == 0 {
66 return
67 }
68
69 uc.detachTimer = time.AfterFunc(dur, func() {
70 uc.conn.network.user.events <- eventChannelDetach{
71 uc: uc.conn,
72 name: uc.Name,
73 }
74 })
75}
76
77type pendingUpstreamCommand struct {
78 downstreamID uint64
79 msg *irc.Message
80}
81
82type upstreamConn struct {
83 conn
84
85 network *network
86 user *user
87
88 serverName string
89 availableUserModes string
90 availableChannelModes map[byte]channelModeType
91 availableChannelTypes string
92 availableMemberships []membership
93 isupport map[string]*string
94
95 registered bool
96 nick string
97 nickCM string
98 username string
99 realname string
100 modes userModes
101 channels upstreamChannelCasemapMap
102 supportedCaps map[string]string
103 caps map[string]bool
104 batches map[string]batch
105 away bool
106 account string
107 nextLabelID uint64
108 monitored monitorCasemapMap
109
110 saslClient sasl.Client
111 saslStarted bool
112
113 casemapIsSet bool
114
115 // Queue of commands in progress, indexed by type. The first entry has been
116 // sent to the server and is awaiting reply. The following entries have not
117 // been sent yet.
118 pendingCmds map[string][]pendingUpstreamCommand
119
120 gotMotd bool
121}
122
123func connectToUpstream(network *network) (*upstreamConn, error) {
124 logger := &prefixLogger{network.user.logger, fmt.Sprintf("upstream %q: ", network.GetName())}
125
126 dialer := net.Dialer{Timeout: connectTimeout}
127
128 u, err := network.URL()
129 if err != nil {
130 return nil, err
131 }
132
133 var netConn net.Conn
134 switch u.Scheme {
135 case "ircs":
136 addr := u.Host
137 host, _, err := net.SplitHostPort(u.Host)
138 if err != nil {
139 host = u.Host
140 addr = u.Host + ":6697"
141 }
142
143 logger.Printf("connecting to TLS server at address %q", addr)
144
145 tlsConfig := &tls.Config{ServerName: host, NextProtos: []string{"irc"}}
146 if network.SASL.Mechanism == "EXTERNAL" {
147 if network.SASL.External.CertBlob == nil {
148 return nil, fmt.Errorf("missing certificate for authentication")
149 }
150 if network.SASL.External.PrivKeyBlob == nil {
151 return nil, fmt.Errorf("missing private key for authentication")
152 }
153 key, err := x509.ParsePKCS8PrivateKey(network.SASL.External.PrivKeyBlob)
154 if err != nil {
155 return nil, fmt.Errorf("failed to parse private key: %v", err)
156 }
157 tlsConfig.Certificates = []tls.Certificate{
158 {
159 Certificate: [][]byte{network.SASL.External.CertBlob},
160 PrivateKey: key.(crypto.PrivateKey),
161 },
162 }
163 logger.Printf("using TLS client certificate %x", sha256.Sum256(network.SASL.External.CertBlob))
164 }
165
166 netConn, err = dialer.Dial("tcp", addr)
167 if err != nil {
168 return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
169 }
170
171 // Don't do the TLS handshake immediately, because we need to register
172 // the new connection with identd ASAP. See:
173 // https://todo.sr.ht/~emersion/soju/69#event-41859
174 netConn = tls.Client(netConn, tlsConfig)
175 case "irc+insecure":
176 addr := u.Host
177 if _, _, err := net.SplitHostPort(addr); err != nil {
178 addr = addr + ":6667"
179 }
180
181 logger.Printf("connecting to plain-text server at address %q", addr)
182 netConn, err = dialer.Dial("tcp", addr)
183 if err != nil {
184 return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
185 }
186 case "irc+unix", "unix":
187 logger.Printf("connecting to Unix socket at path %q", u.Path)
188 netConn, err = dialer.Dial("unix", u.Path)
189 if err != nil {
190 return nil, fmt.Errorf("failed to connect to Unix socket %q: %v", u.Path, err)
191 }
192 default:
193 return nil, fmt.Errorf("failed to dial %q: unknown scheme: %v", network.Addr, u.Scheme)
194 }
195
196 options := connOptions{
197 Logger: logger,
198 RateLimitDelay: upstreamMessageDelay,
199 RateLimitBurst: upstreamMessageBurst,
200 }
201
202 uc := &upstreamConn{
203 conn: *newConn(network.user.srv, newNetIRCConn(netConn), &options),
204 network: network,
205 user: network.user,
206 channels: upstreamChannelCasemapMap{newCasemapMap(0)},
207 supportedCaps: make(map[string]string),
208 caps: make(map[string]bool),
209 batches: make(map[string]batch),
210 availableChannelTypes: stdChannelTypes,
211 availableChannelModes: stdChannelModes,
212 availableMemberships: stdMemberships,
213 isupport: make(map[string]*string),
214 pendingCmds: make(map[string][]pendingUpstreamCommand),
215 monitored: monitorCasemapMap{newCasemapMap(0)},
216 }
217 return uc, nil
218}
219
220func (uc *upstreamConn) forEachDownstream(f func(*downstreamConn)) {
221 uc.network.forEachDownstream(f)
222}
223
224func (uc *upstreamConn) forEachDownstreamByID(id uint64, f func(*downstreamConn)) {
225 uc.forEachDownstream(func(dc *downstreamConn) {
226 if id != 0 && id != dc.id {
227 return
228 }
229 f(dc)
230 })
231}
232
233func (uc *upstreamConn) downstreamByID(id uint64) *downstreamConn {
234 for _, dc := range uc.user.downstreamConns {
235 if dc.id == id {
236 return dc
237 }
238 }
239 return nil
240}
241
242func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
243 ch := uc.channels.Value(name)
244 if ch == nil {
245 return nil, fmt.Errorf("unknown channel %q", name)
246 }
247 return ch, nil
248}
249
250func (uc *upstreamConn) isChannel(entity string) bool {
251 return strings.ContainsRune(uc.availableChannelTypes, rune(entity[0]))
252}
253
254func (uc *upstreamConn) isOurNick(nick string) bool {
255 return uc.nickCM == uc.network.casemap(nick)
256}
257
258func (uc *upstreamConn) endPendingCommands() {
259 for _, l := range uc.pendingCmds {
260 for _, pendingCmd := range l {
261 dc := uc.downstreamByID(pendingCmd.downstreamID)
262 if dc == nil {
263 continue
264 }
265
266 switch pendingCmd.msg.Command {
267 case "LIST":
268 dc.SendMessage(&irc.Message{
269 Prefix: dc.srv.prefix(),
270 Command: irc.RPL_LISTEND,
271 Params: []string{dc.nick, "End of /LIST"},
272 })
273 case "WHO":
274 mask := "*"
275 if len(pendingCmd.msg.Params) > 0 {
276 mask = pendingCmd.msg.Params[0]
277 }
278 dc.SendMessage(&irc.Message{
279 Prefix: dc.srv.prefix(),
280 Command: irc.RPL_ENDOFWHO,
281 Params: []string{dc.nick, mask, "End of /WHO"},
282 })
283 default:
284 panic(fmt.Errorf("Unsupported pending command %q", pendingCmd.msg.Command))
285 }
286 }
287 }
288
289 uc.pendingCmds = make(map[string][]pendingUpstreamCommand)
290}
291
292func (uc *upstreamConn) sendNextPendingCommand(cmd string) {
293 if len(uc.pendingCmds[cmd]) == 0 {
294 return
295 }
296 uc.SendMessage(uc.pendingCmds[cmd][0].msg)
297}
298
299func (uc *upstreamConn) enqueueCommand(dc *downstreamConn, msg *irc.Message) {
300 switch msg.Command {
301 case "LIST", "WHO":
302 // Supported
303 default:
304 panic(fmt.Errorf("Unsupported pending command %q", msg.Command))
305 }
306
307 uc.pendingCmds[msg.Command] = append(uc.pendingCmds[msg.Command], pendingUpstreamCommand{
308 downstreamID: dc.id,
309 msg: msg,
310 })
311
312 if len(uc.pendingCmds[msg.Command]) == 1 {
313 uc.sendNextPendingCommand(msg.Command)
314 }
315}
316
317func (uc *upstreamConn) currentPendingCommand(cmd string) (*downstreamConn, *irc.Message) {
318 if len(uc.pendingCmds[cmd]) == 0 {
319 return nil, nil
320 }
321
322 pendingCmd := uc.pendingCmds[cmd][0]
323 return uc.downstreamByID(pendingCmd.downstreamID), pendingCmd.msg
324}
325
326func (uc *upstreamConn) dequeueCommand(cmd string) (*downstreamConn, *irc.Message) {
327 dc, msg := uc.currentPendingCommand(cmd)
328
329 if len(uc.pendingCmds[cmd]) > 0 {
330 copy(uc.pendingCmds[cmd], uc.pendingCmds[cmd][1:])
331 uc.pendingCmds[cmd] = uc.pendingCmds[cmd][:len(uc.pendingCmds[cmd])-1]
332 }
333
334 uc.sendNextPendingCommand(cmd)
335
336 return dc, msg
337}
338
339func (uc *upstreamConn) parseMembershipPrefix(s string) (ms *memberships, nick string) {
340 memberships := make(memberships, 0, 4)
341 i := 0
342 for _, m := range uc.availableMemberships {
343 if i >= len(s) {
344 break
345 }
346 if s[i] == m.Prefix {
347 memberships = append(memberships, m)
348 i++
349 }
350 }
351 return &memberships, s[i:]
352}
353
354func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
355 var label string
356 if l, ok := msg.GetTag("label"); ok {
357 label = l
358 delete(msg.Tags, "label")
359 }
360
361 var msgBatch *batch
362 if batchName, ok := msg.GetTag("batch"); ok {
363 b, ok := uc.batches[batchName]
364 if !ok {
365 return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
366 }
367 msgBatch = &b
368 if label == "" {
369 label = msgBatch.Label
370 }
371 delete(msg.Tags, "batch")
372 }
373
374 var downstreamID uint64 = 0
375 if label != "" {
376 var labelOffset uint64
377 n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
378 if err == nil && n < 2 {
379 err = errors.New("not enough arguments")
380 }
381 if err != nil {
382 return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
383 }
384 }
385
386 if _, ok := msg.Tags["time"]; !ok {
387 msg.Tags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
388 }
389
390 switch msg.Command {
391 case "PING":
392 uc.SendMessage(&irc.Message{
393 Command: "PONG",
394 Params: msg.Params,
395 })
396 return nil
397 case "NOTICE", "PRIVMSG", "TAGMSG":
398 if msg.Prefix == nil {
399 return fmt.Errorf("expected a prefix")
400 }
401
402 var entity, text string
403 if msg.Command != "TAGMSG" {
404 if err := parseMessageParams(msg, &entity, &text); err != nil {
405 return err
406 }
407 } else {
408 if err := parseMessageParams(msg, &entity); err != nil {
409 return err
410 }
411 }
412
413 if msg.Prefix.Name == serviceNick {
414 uc.logger.Printf("skipping %v from soju's service: %v", msg.Command, msg)
415 break
416 }
417 if entity == serviceNick {
418 uc.logger.Printf("skipping %v to soju's service: %v", msg.Command, msg)
419 break
420 }
421
422 if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
423 uc.produce("", msg, nil)
424 } else { // regular user message
425 target := entity
426 if uc.isOurNick(target) {
427 target = msg.Prefix.Name
428 }
429
430 ch := uc.network.channels.Value(target)
431 if ch != nil && msg.Command != "TAGMSG" {
432 if ch.Detached {
433 uc.handleDetachedMessage(ch, msg)
434 }
435
436 highlight := uc.network.isHighlight(msg)
437 if ch.DetachOn == FilterMessage || ch.DetachOn == FilterDefault || (ch.DetachOn == FilterHighlight && highlight) {
438 uc.updateChannelAutoDetach(target)
439 }
440 }
441
442 uc.produce(target, msg, nil)
443 }
444 case "CAP":
445 var subCmd string
446 if err := parseMessageParams(msg, nil, &subCmd); err != nil {
447 return err
448 }
449 subCmd = strings.ToUpper(subCmd)
450 subParams := msg.Params[2:]
451 switch subCmd {
452 case "LS":
453 if len(subParams) < 1 {
454 return newNeedMoreParamsError(msg.Command)
455 }
456 caps := subParams[len(subParams)-1]
457 more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
458
459 uc.handleSupportedCaps(caps)
460
461 if more {
462 break // wait to receive all capabilities
463 }
464
465 uc.requestCaps()
466
467 if uc.requestSASL() {
468 break // we'll send CAP END after authentication is completed
469 }
470
471 uc.SendMessage(&irc.Message{
472 Command: "CAP",
473 Params: []string{"END"},
474 })
475 case "ACK", "NAK":
476 if len(subParams) < 1 {
477 return newNeedMoreParamsError(msg.Command)
478 }
479 caps := strings.Fields(subParams[0])
480
481 for _, name := range caps {
482 if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
483 return err
484 }
485 }
486
487 if uc.registered {
488 uc.forEachDownstream(func(dc *downstreamConn) {
489 dc.updateSupportedCaps()
490 })
491 }
492 case "NEW":
493 if len(subParams) < 1 {
494 return newNeedMoreParamsError(msg.Command)
495 }
496 uc.handleSupportedCaps(subParams[0])
497 uc.requestCaps()
498 case "DEL":
499 if len(subParams) < 1 {
500 return newNeedMoreParamsError(msg.Command)
501 }
502 caps := strings.Fields(subParams[0])
503
504 for _, c := range caps {
505 delete(uc.supportedCaps, c)
506 delete(uc.caps, c)
507 }
508
509 if uc.registered {
510 uc.forEachDownstream(func(dc *downstreamConn) {
511 dc.updateSupportedCaps()
512 })
513 }
514 default:
515 uc.logger.Printf("unhandled message: %v", msg)
516 }
517 case "AUTHENTICATE":
518 if uc.saslClient == nil {
519 return fmt.Errorf("received unexpected AUTHENTICATE message")
520 }
521
522 // TODO: if a challenge is 400 bytes long, buffer it
523 var challengeStr string
524 if err := parseMessageParams(msg, &challengeStr); err != nil {
525 uc.SendMessage(&irc.Message{
526 Command: "AUTHENTICATE",
527 Params: []string{"*"},
528 })
529 return err
530 }
531
532 var challenge []byte
533 if challengeStr != "+" {
534 var err error
535 challenge, err = base64.StdEncoding.DecodeString(challengeStr)
536 if err != nil {
537 uc.SendMessage(&irc.Message{
538 Command: "AUTHENTICATE",
539 Params: []string{"*"},
540 })
541 return err
542 }
543 }
544
545 var resp []byte
546 var err error
547 if !uc.saslStarted {
548 _, resp, err = uc.saslClient.Start()
549 uc.saslStarted = true
550 } else {
551 resp, err = uc.saslClient.Next(challenge)
552 }
553 if err != nil {
554 uc.SendMessage(&irc.Message{
555 Command: "AUTHENTICATE",
556 Params: []string{"*"},
557 })
558 return err
559 }
560
561 // TODO: send response in multiple chunks if >= 400 bytes
562 var respStr = "+"
563 if len(resp) != 0 {
564 respStr = base64.StdEncoding.EncodeToString(resp)
565 }
566
567 uc.SendMessage(&irc.Message{
568 Command: "AUTHENTICATE",
569 Params: []string{respStr},
570 })
571 case irc.RPL_LOGGEDIN:
572 if err := parseMessageParams(msg, nil, nil, &uc.account); err != nil {
573 return err
574 }
575 uc.logger.Printf("logged in with account %q", uc.account)
576 case irc.RPL_LOGGEDOUT:
577 uc.account = ""
578 uc.logger.Printf("logged out")
579 case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
580 var info string
581 if err := parseMessageParams(msg, nil, &info); err != nil {
582 return err
583 }
584 switch msg.Command {
585 case irc.ERR_NICKLOCKED:
586 uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
587 case irc.ERR_SASLFAIL:
588 uc.logger.Printf("SASL authentication failed: %v", info)
589 case irc.ERR_SASLTOOLONG:
590 uc.logger.Printf("SASL message too long: %v", info)
591 }
592
593 uc.saslClient = nil
594 uc.saslStarted = false
595
596 uc.SendMessage(&irc.Message{
597 Command: "CAP",
598 Params: []string{"END"},
599 })
600 case irc.RPL_WELCOME:
601 uc.registered = true
602 uc.logger.Printf("connection registered")
603
604 if uc.network.channels.Len() > 0 {
605 var channels, keys []string
606 for _, entry := range uc.network.channels.innerMap {
607 ch := entry.value.(*Channel)
608 channels = append(channels, ch.Name)
609 keys = append(keys, ch.Key)
610 }
611
612 for _, msg := range join(channels, keys) {
613 uc.SendMessage(msg)
614 }
615 }
616 case irc.RPL_MYINFO:
617 if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
618 return err
619 }
620 case irc.RPL_ISUPPORT:
621 if err := parseMessageParams(msg, nil, nil); err != nil {
622 return err
623 }
624
625 var downstreamIsupport []string
626 for _, token := range msg.Params[1 : len(msg.Params)-1] {
627 parameter := token
628 var negate, hasValue bool
629 var value string
630 if strings.HasPrefix(token, "-") {
631 negate = true
632 token = token[1:]
633 } else if i := strings.IndexByte(token, '='); i >= 0 {
634 parameter = token[:i]
635 value = token[i+1:]
636 hasValue = true
637 }
638
639 if hasValue {
640 uc.isupport[parameter] = &value
641 } else if !negate {
642 uc.isupport[parameter] = nil
643 } else {
644 delete(uc.isupport, parameter)
645 }
646
647 var err error
648 switch parameter {
649 case "CASEMAPPING":
650 casemap, ok := parseCasemappingToken(value)
651 if !ok {
652 casemap = casemapRFC1459
653 }
654 uc.network.updateCasemapping(casemap)
655 uc.nickCM = uc.network.casemap(uc.nick)
656 uc.casemapIsSet = true
657 case "CHANMODES":
658 if !negate {
659 err = uc.handleChanModes(value)
660 } else {
661 uc.availableChannelModes = stdChannelModes
662 }
663 case "CHANTYPES":
664 if !negate {
665 uc.availableChannelTypes = value
666 } else {
667 uc.availableChannelTypes = stdChannelTypes
668 }
669 case "PREFIX":
670 if !negate {
671 err = uc.handleMemberships(value)
672 } else {
673 uc.availableMemberships = stdMemberships
674 }
675 }
676 if err != nil {
677 return err
678 }
679
680 if passthroughIsupport[parameter] {
681 downstreamIsupport = append(downstreamIsupport, token)
682 }
683 }
684
685 uc.forEachDownstream(func(dc *downstreamConn) {
686 if dc.network == nil {
687 return
688 }
689 msgs := generateIsupport(dc.srv.prefix(), dc.nick, downstreamIsupport)
690 for _, msg := range msgs {
691 dc.SendMessage(msg)
692 }
693 })
694 case irc.ERR_NOMOTD, irc.RPL_ENDOFMOTD:
695 if !uc.casemapIsSet {
696 // upstream did not send any CASEMAPPING token, thus
697 // we assume it implements the old RFCs with rfc1459.
698 uc.casemapIsSet = true
699 uc.network.updateCasemapping(casemapRFC1459)
700 uc.nickCM = uc.network.casemap(uc.nick)
701 }
702
703 if !uc.gotMotd {
704 // Ignore the initial MOTD upon connection, but forward
705 // subsequent MOTD messages downstream
706 uc.gotMotd = true
707 return nil
708 }
709
710 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
711 dc.SendMessage(&irc.Message{
712 Prefix: uc.srv.prefix(),
713 Command: msg.Command,
714 Params: msg.Params,
715 })
716 })
717 case "BATCH":
718 var tag string
719 if err := parseMessageParams(msg, &tag); err != nil {
720 return err
721 }
722
723 if strings.HasPrefix(tag, "+") {
724 tag = tag[1:]
725 if _, ok := uc.batches[tag]; ok {
726 return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
727 }
728 var batchType string
729 if err := parseMessageParams(msg, nil, &batchType); err != nil {
730 return err
731 }
732 label := label
733 if label == "" && msgBatch != nil {
734 label = msgBatch.Label
735 }
736 uc.batches[tag] = batch{
737 Type: batchType,
738 Params: msg.Params[2:],
739 Outer: msgBatch,
740 Label: label,
741 }
742 } else if strings.HasPrefix(tag, "-") {
743 tag = tag[1:]
744 if _, ok := uc.batches[tag]; !ok {
745 return fmt.Errorf("unknown BATCH reference tag: %q", tag)
746 }
747 delete(uc.batches, tag)
748 } else {
749 return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
750 }
751 case "NICK":
752 if msg.Prefix == nil {
753 return fmt.Errorf("expected a prefix")
754 }
755
756 var newNick string
757 if err := parseMessageParams(msg, &newNick); err != nil {
758 return err
759 }
760
761 me := false
762 if uc.isOurNick(msg.Prefix.Name) {
763 uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
764 me = true
765 uc.nick = newNick
766 uc.nickCM = uc.network.casemap(uc.nick)
767 }
768
769 for _, entry := range uc.channels.innerMap {
770 ch := entry.value.(*upstreamChannel)
771 memberships := ch.Members.Value(msg.Prefix.Name)
772 if memberships != nil {
773 ch.Members.Delete(msg.Prefix.Name)
774 ch.Members.SetValue(newNick, memberships)
775 uc.appendLog(ch.Name, msg)
776 }
777 }
778
779 if !me {
780 uc.forEachDownstream(func(dc *downstreamConn) {
781 dc.SendMessage(dc.marshalMessage(msg, uc.network))
782 })
783 } else {
784 uc.forEachDownstream(func(dc *downstreamConn) {
785 dc.updateNick()
786 })
787 }
788 case "SETNAME":
789 if msg.Prefix == nil {
790 return fmt.Errorf("expected a prefix")
791 }
792
793 var newRealname string
794 if err := parseMessageParams(msg, &newRealname); err != nil {
795 return err
796 }
797
798 // TODO: consider appending this message to logs
799
800 if uc.isOurNick(msg.Prefix.Name) {
801 uc.logger.Printf("changed realname from %q to %q", uc.realname, newRealname)
802 uc.realname = newRealname
803
804 uc.forEachDownstream(func(dc *downstreamConn) {
805 dc.updateRealname()
806 })
807 } else {
808 uc.forEachDownstream(func(dc *downstreamConn) {
809 dc.SendMessage(dc.marshalMessage(msg, uc.network))
810 })
811 }
812 case "JOIN":
813 if msg.Prefix == nil {
814 return fmt.Errorf("expected a prefix")
815 }
816
817 var channels string
818 if err := parseMessageParams(msg, &channels); err != nil {
819 return err
820 }
821
822 for _, ch := range strings.Split(channels, ",") {
823 if uc.isOurNick(msg.Prefix.Name) {
824 uc.logger.Printf("joined channel %q", ch)
825 members := membershipsCasemapMap{newCasemapMap(0)}
826 members.casemap = uc.network.casemap
827 uc.channels.SetValue(ch, &upstreamChannel{
828 Name: ch,
829 conn: uc,
830 Members: members,
831 })
832 uc.updateChannelAutoDetach(ch)
833
834 uc.SendMessage(&irc.Message{
835 Command: "MODE",
836 Params: []string{ch},
837 })
838 } else {
839 ch, err := uc.getChannel(ch)
840 if err != nil {
841 return err
842 }
843 ch.Members.SetValue(msg.Prefix.Name, &memberships{})
844 }
845
846 chMsg := msg.Copy()
847 chMsg.Params[0] = ch
848 uc.produce(ch, chMsg, nil)
849 }
850 case "PART":
851 if msg.Prefix == nil {
852 return fmt.Errorf("expected a prefix")
853 }
854
855 var channels string
856 if err := parseMessageParams(msg, &channels); err != nil {
857 return err
858 }
859
860 for _, ch := range strings.Split(channels, ",") {
861 if uc.isOurNick(msg.Prefix.Name) {
862 uc.logger.Printf("parted channel %q", ch)
863 uch := uc.channels.Value(ch)
864 if uch != nil {
865 uc.channels.Delete(ch)
866 uch.updateAutoDetach(0)
867 }
868 } else {
869 ch, err := uc.getChannel(ch)
870 if err != nil {
871 return err
872 }
873 ch.Members.Delete(msg.Prefix.Name)
874 }
875
876 chMsg := msg.Copy()
877 chMsg.Params[0] = ch
878 uc.produce(ch, chMsg, nil)
879 }
880 case "KICK":
881 if msg.Prefix == nil {
882 return fmt.Errorf("expected a prefix")
883 }
884
885 var channel, user string
886 if err := parseMessageParams(msg, &channel, &user); err != nil {
887 return err
888 }
889
890 if uc.isOurNick(user) {
891 uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
892 uc.channels.Delete(channel)
893 } else {
894 ch, err := uc.getChannel(channel)
895 if err != nil {
896 return err
897 }
898 ch.Members.Delete(user)
899 }
900
901 uc.produce(channel, msg, nil)
902 case "QUIT":
903 if msg.Prefix == nil {
904 return fmt.Errorf("expected a prefix")
905 }
906
907 if uc.isOurNick(msg.Prefix.Name) {
908 uc.logger.Printf("quit")
909 }
910
911 for _, entry := range uc.channels.innerMap {
912 ch := entry.value.(*upstreamChannel)
913 if ch.Members.Has(msg.Prefix.Name) {
914 ch.Members.Delete(msg.Prefix.Name)
915
916 uc.appendLog(ch.Name, msg)
917 }
918 }
919
920 if msg.Prefix.Name != uc.nick {
921 uc.forEachDownstream(func(dc *downstreamConn) {
922 dc.SendMessage(dc.marshalMessage(msg, uc.network))
923 })
924 }
925 case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
926 var name, topic string
927 if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
928 return err
929 }
930 ch, err := uc.getChannel(name)
931 if err != nil {
932 return err
933 }
934 if msg.Command == irc.RPL_TOPIC {
935 ch.Topic = topic
936 } else {
937 ch.Topic = ""
938 }
939 case "TOPIC":
940 if msg.Prefix == nil {
941 return fmt.Errorf("expected a prefix")
942 }
943
944 var name string
945 if err := parseMessageParams(msg, &name); err != nil {
946 return err
947 }
948 ch, err := uc.getChannel(name)
949 if err != nil {
950 return err
951 }
952 if len(msg.Params) > 1 {
953 ch.Topic = msg.Params[1]
954 ch.TopicWho = msg.Prefix.Copy()
955 ch.TopicTime = time.Now() // TODO use msg.Tags["time"]
956 } else {
957 ch.Topic = ""
958 }
959 uc.produce(ch.Name, msg, nil)
960 case "MODE":
961 var name, modeStr string
962 if err := parseMessageParams(msg, &name, &modeStr); err != nil {
963 return err
964 }
965
966 if !uc.isChannel(name) { // user mode change
967 if name != uc.nick {
968 return fmt.Errorf("received MODE message for unknown nick %q", name)
969 }
970
971 if err := uc.modes.Apply(modeStr); err != nil {
972 return err
973 }
974
975 uc.forEachDownstream(func(dc *downstreamConn) {
976 if dc.upstream() == nil {
977 return
978 }
979
980 dc.SendMessage(msg)
981 })
982 } else { // channel mode change
983 ch, err := uc.getChannel(name)
984 if err != nil {
985 return err
986 }
987
988 needMarshaling, err := applyChannelModes(ch, modeStr, msg.Params[2:])
989 if err != nil {
990 return err
991 }
992
993 uc.appendLog(ch.Name, msg)
994
995 c := uc.network.channels.Value(name)
996 if c == nil || !c.Detached {
997 uc.forEachDownstream(func(dc *downstreamConn) {
998 params := make([]string, len(msg.Params))
999 params[0] = dc.marshalEntity(uc.network, name)
1000 params[1] = modeStr
1001
1002 copy(params[2:], msg.Params[2:])
1003 for i, modeParam := range params[2:] {
1004 if _, ok := needMarshaling[i]; ok {
1005 params[2+i] = dc.marshalEntity(uc.network, modeParam)
1006 }
1007 }
1008
1009 dc.SendMessage(&irc.Message{
1010 Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
1011 Command: "MODE",
1012 Params: params,
1013 })
1014 })
1015 }
1016 }
1017 case irc.RPL_UMODEIS:
1018 if err := parseMessageParams(msg, nil); err != nil {
1019 return err
1020 }
1021 modeStr := ""
1022 if len(msg.Params) > 1 {
1023 modeStr = msg.Params[1]
1024 }
1025
1026 uc.modes = ""
1027 if err := uc.modes.Apply(modeStr); err != nil {
1028 return err
1029 }
1030
1031 uc.forEachDownstream(func(dc *downstreamConn) {
1032 if dc.upstream() == nil {
1033 return
1034 }
1035
1036 dc.SendMessage(msg)
1037 })
1038 case irc.RPL_CHANNELMODEIS:
1039 var channel string
1040 if err := parseMessageParams(msg, nil, &channel); err != nil {
1041 return err
1042 }
1043 modeStr := ""
1044 if len(msg.Params) > 2 {
1045 modeStr = msg.Params[2]
1046 }
1047
1048 ch, err := uc.getChannel(channel)
1049 if err != nil {
1050 return err
1051 }
1052
1053 firstMode := ch.modes == nil
1054 ch.modes = make(map[byte]string)
1055 if _, err := applyChannelModes(ch, modeStr, msg.Params[3:]); err != nil {
1056 return err
1057 }
1058 if firstMode {
1059 c := uc.network.channels.Value(channel)
1060 if c == nil || !c.Detached {
1061 modeStr, modeParams := ch.modes.Format()
1062
1063 uc.forEachDownstream(func(dc *downstreamConn) {
1064 params := []string{dc.nick, dc.marshalEntity(uc.network, channel), modeStr}
1065 params = append(params, modeParams...)
1066
1067 dc.SendMessage(&irc.Message{
1068 Prefix: dc.srv.prefix(),
1069 Command: irc.RPL_CHANNELMODEIS,
1070 Params: params,
1071 })
1072 })
1073 }
1074 }
1075 case rpl_creationtime:
1076 var channel, creationTime string
1077 if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
1078 return err
1079 }
1080
1081 ch, err := uc.getChannel(channel)
1082 if err != nil {
1083 return err
1084 }
1085
1086 firstCreationTime := ch.creationTime == ""
1087 ch.creationTime = creationTime
1088 if firstCreationTime {
1089 uc.forEachDownstream(func(dc *downstreamConn) {
1090 dc.SendMessage(&irc.Message{
1091 Prefix: dc.srv.prefix(),
1092 Command: rpl_creationtime,
1093 Params: []string{dc.nick, dc.marshalEntity(uc.network, ch.Name), creationTime},
1094 })
1095 })
1096 }
1097 case rpl_topicwhotime:
1098 var name, who, timeStr string
1099 if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
1100 return err
1101 }
1102 ch, err := uc.getChannel(name)
1103 if err != nil {
1104 return err
1105 }
1106 firstTopicWhoTime := ch.TopicWho == nil
1107 ch.TopicWho = irc.ParsePrefix(who)
1108 sec, err := strconv.ParseInt(timeStr, 10, 64)
1109 if err != nil {
1110 return fmt.Errorf("failed to parse topic time: %v", err)
1111 }
1112 ch.TopicTime = time.Unix(sec, 0)
1113 if firstTopicWhoTime {
1114 uc.forEachDownstream(func(dc *downstreamConn) {
1115 topicWho := dc.marshalUserPrefix(uc.network, ch.TopicWho)
1116 dc.SendMessage(&irc.Message{
1117 Prefix: dc.srv.prefix(),
1118 Command: rpl_topicwhotime,
1119 Params: []string{
1120 dc.nick,
1121 dc.marshalEntity(uc.network, ch.Name),
1122 topicWho.String(),
1123 timeStr,
1124 },
1125 })
1126 })
1127 }
1128 case irc.RPL_LIST:
1129 var channel, clients, topic string
1130 if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
1131 return err
1132 }
1133
1134 dc, cmd := uc.currentPendingCommand("LIST")
1135 if cmd == nil {
1136 return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
1137 } else if dc == nil {
1138 return nil
1139 }
1140
1141 dc.SendMessage(&irc.Message{
1142 Prefix: dc.srv.prefix(),
1143 Command: irc.RPL_LIST,
1144 Params: []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
1145 })
1146 case irc.RPL_LISTEND:
1147 dc, cmd := uc.dequeueCommand("LIST")
1148 if cmd == nil {
1149 return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
1150 } else if dc == nil {
1151 return nil
1152 }
1153
1154 dc.SendMessage(&irc.Message{
1155 Prefix: dc.srv.prefix(),
1156 Command: irc.RPL_LISTEND,
1157 Params: []string{dc.nick, "End of /LIST"},
1158 })
1159 case irc.RPL_NAMREPLY:
1160 var name, statusStr, members string
1161 if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
1162 return err
1163 }
1164
1165 ch := uc.channels.Value(name)
1166 if ch == nil {
1167 // NAMES on a channel we have not joined, forward to downstream
1168 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1169 channel := dc.marshalEntity(uc.network, name)
1170 members := splitSpace(members)
1171 for i, member := range members {
1172 memberships, nick := uc.parseMembershipPrefix(member)
1173 members[i] = memberships.Format(dc) + dc.marshalEntity(uc.network, nick)
1174 }
1175 memberStr := strings.Join(members, " ")
1176
1177 dc.SendMessage(&irc.Message{
1178 Prefix: dc.srv.prefix(),
1179 Command: irc.RPL_NAMREPLY,
1180 Params: []string{dc.nick, statusStr, channel, memberStr},
1181 })
1182 })
1183 return nil
1184 }
1185
1186 status, err := parseChannelStatus(statusStr)
1187 if err != nil {
1188 return err
1189 }
1190 ch.Status = status
1191
1192 for _, s := range splitSpace(members) {
1193 memberships, nick := uc.parseMembershipPrefix(s)
1194 ch.Members.SetValue(nick, memberships)
1195 }
1196 case irc.RPL_ENDOFNAMES:
1197 var name string
1198 if err := parseMessageParams(msg, nil, &name); err != nil {
1199 return err
1200 }
1201
1202 ch := uc.channels.Value(name)
1203 if ch == nil {
1204 // NAMES on a channel we have not joined, forward to downstream
1205 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1206 channel := dc.marshalEntity(uc.network, name)
1207
1208 dc.SendMessage(&irc.Message{
1209 Prefix: dc.srv.prefix(),
1210 Command: irc.RPL_ENDOFNAMES,
1211 Params: []string{dc.nick, channel, "End of /NAMES list"},
1212 })
1213 })
1214 return nil
1215 }
1216
1217 if ch.complete {
1218 return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
1219 }
1220 ch.complete = true
1221
1222 c := uc.network.channels.Value(name)
1223 if c == nil || !c.Detached {
1224 uc.forEachDownstream(func(dc *downstreamConn) {
1225 forwardChannel(dc, ch)
1226 })
1227 }
1228 case irc.RPL_WHOREPLY:
1229 var channel, username, host, server, nick, mode, trailing string
1230 if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
1231 return err
1232 }
1233
1234 dc, cmd := uc.currentPendingCommand("WHO")
1235 if cmd == nil {
1236 return fmt.Errorf("unexpected RPL_WHOREPLY: no matching pending WHO")
1237 } else if dc == nil {
1238 return nil
1239 }
1240
1241 parts := strings.SplitN(trailing, " ", 2)
1242 if len(parts) != 2 {
1243 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
1244 }
1245 realname := parts[1]
1246 hops, err := strconv.Atoi(parts[0])
1247 if err != nil {
1248 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
1249 }
1250 hops++
1251
1252 trailing = strconv.Itoa(hops) + " " + realname
1253
1254 if channel != "*" {
1255 channel = dc.marshalEntity(uc.network, channel)
1256 }
1257 nick = dc.marshalEntity(uc.network, nick)
1258 dc.SendMessage(&irc.Message{
1259 Prefix: dc.srv.prefix(),
1260 Command: irc.RPL_WHOREPLY,
1261 Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
1262 })
1263 case rpl_whospcrpl:
1264 dc, cmd := uc.currentPendingCommand("WHO")
1265 if cmd == nil {
1266 return fmt.Errorf("unexpected RPL_WHOSPCRPL: no matching pending WHO")
1267 } else if dc == nil {
1268 return nil
1269 }
1270
1271 // Only supported in single-upstream mode, so forward as-is
1272 dc.SendMessage(msg)
1273 case irc.RPL_ENDOFWHO:
1274 var name string
1275 if err := parseMessageParams(msg, nil, &name); err != nil {
1276 return err
1277 }
1278
1279 dc, cmd := uc.dequeueCommand("WHO")
1280 if cmd == nil {
1281 return fmt.Errorf("unexpected RPL_ENDOFWHO: no matching pending WHO")
1282 } else if dc == nil {
1283 return nil
1284 }
1285
1286 mask := "*"
1287 if len(cmd.Params) > 0 {
1288 mask = cmd.Params[0]
1289 }
1290 dc.SendMessage(&irc.Message{
1291 Prefix: dc.srv.prefix(),
1292 Command: irc.RPL_ENDOFWHO,
1293 Params: []string{dc.nick, mask, "End of /WHO list"},
1294 })
1295 case irc.RPL_WHOISUSER:
1296 var nick, username, host, realname string
1297 if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
1298 return err
1299 }
1300
1301 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1302 nick := dc.marshalEntity(uc.network, nick)
1303 dc.SendMessage(&irc.Message{
1304 Prefix: dc.srv.prefix(),
1305 Command: irc.RPL_WHOISUSER,
1306 Params: []string{dc.nick, nick, username, host, "*", realname},
1307 })
1308 })
1309 case irc.RPL_WHOISSERVER:
1310 var nick, server, serverInfo string
1311 if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
1312 return err
1313 }
1314
1315 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1316 nick := dc.marshalEntity(uc.network, nick)
1317 dc.SendMessage(&irc.Message{
1318 Prefix: dc.srv.prefix(),
1319 Command: irc.RPL_WHOISSERVER,
1320 Params: []string{dc.nick, nick, server, serverInfo},
1321 })
1322 })
1323 case irc.RPL_WHOISOPERATOR:
1324 var nick string
1325 if err := parseMessageParams(msg, nil, &nick); err != nil {
1326 return err
1327 }
1328
1329 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1330 nick := dc.marshalEntity(uc.network, nick)
1331 dc.SendMessage(&irc.Message{
1332 Prefix: dc.srv.prefix(),
1333 Command: irc.RPL_WHOISOPERATOR,
1334 Params: []string{dc.nick, nick, "is an IRC operator"},
1335 })
1336 })
1337 case irc.RPL_WHOISIDLE:
1338 var nick string
1339 if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
1340 return err
1341 }
1342
1343 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1344 nick := dc.marshalEntity(uc.network, nick)
1345 params := []string{dc.nick, nick}
1346 params = append(params, msg.Params[2:]...)
1347 dc.SendMessage(&irc.Message{
1348 Prefix: dc.srv.prefix(),
1349 Command: irc.RPL_WHOISIDLE,
1350 Params: params,
1351 })
1352 })
1353 case irc.RPL_WHOISCHANNELS:
1354 var nick, channelList string
1355 if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
1356 return err
1357 }
1358 channels := splitSpace(channelList)
1359
1360 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1361 nick := dc.marshalEntity(uc.network, nick)
1362 channelList := make([]string, len(channels))
1363 for i, channel := range channels {
1364 prefix, channel := uc.parseMembershipPrefix(channel)
1365 channel = dc.marshalEntity(uc.network, channel)
1366 channelList[i] = prefix.Format(dc) + channel
1367 }
1368 channels := strings.Join(channelList, " ")
1369 dc.SendMessage(&irc.Message{
1370 Prefix: dc.srv.prefix(),
1371 Command: irc.RPL_WHOISCHANNELS,
1372 Params: []string{dc.nick, nick, channels},
1373 })
1374 })
1375 case irc.RPL_ENDOFWHOIS:
1376 var nick string
1377 if err := parseMessageParams(msg, nil, &nick); err != nil {
1378 return err
1379 }
1380
1381 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1382 nick := dc.marshalEntity(uc.network, nick)
1383 dc.SendMessage(&irc.Message{
1384 Prefix: dc.srv.prefix(),
1385 Command: irc.RPL_ENDOFWHOIS,
1386 Params: []string{dc.nick, nick, "End of /WHOIS list"},
1387 })
1388 })
1389 case "INVITE":
1390 var nick, channel string
1391 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1392 return err
1393 }
1394
1395 weAreInvited := uc.isOurNick(nick)
1396
1397 uc.forEachDownstream(func(dc *downstreamConn) {
1398 if !weAreInvited && !dc.caps["invite-notify"] {
1399 return
1400 }
1401 dc.SendMessage(&irc.Message{
1402 Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
1403 Command: "INVITE",
1404 Params: []string{dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
1405 })
1406 })
1407 case irc.RPL_INVITING:
1408 var nick, channel string
1409 if err := parseMessageParams(msg, nil, &nick, &channel); err != nil {
1410 return err
1411 }
1412
1413 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1414 dc.SendMessage(&irc.Message{
1415 Prefix: dc.srv.prefix(),
1416 Command: irc.RPL_INVITING,
1417 Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), dc.marshalEntity(uc.network, channel)},
1418 })
1419 })
1420 case irc.RPL_MONONLINE, irc.RPL_MONOFFLINE:
1421 var targetsStr string
1422 if err := parseMessageParams(msg, nil, &targetsStr); err != nil {
1423 return err
1424 }
1425 targets := strings.Split(targetsStr, ",")
1426
1427 online := msg.Command == irc.RPL_MONONLINE
1428 for _, target := range targets {
1429 prefix := irc.ParsePrefix(target)
1430 uc.monitored.SetValue(prefix.Name, online)
1431 }
1432
1433 uc.forEachDownstream(func(dc *downstreamConn) {
1434 for _, target := range targets {
1435 prefix := irc.ParsePrefix(target)
1436 if dc.monitored.Has(prefix.Name) {
1437 dc.SendMessage(&irc.Message{
1438 Prefix: dc.srv.prefix(),
1439 Command: msg.Command,
1440 Params: []string{dc.nick, target},
1441 })
1442 }
1443 }
1444 })
1445 case irc.ERR_MONLISTFULL:
1446 var limit, targetsStr string
1447 if err := parseMessageParams(msg, nil, &limit, &targetsStr); err != nil {
1448 return err
1449 }
1450
1451 targets := strings.Split(targetsStr, ",")
1452 uc.forEachDownstream(func(dc *downstreamConn) {
1453 for _, target := range targets {
1454 if dc.monitored.Has(target) {
1455 dc.SendMessage(&irc.Message{
1456 Prefix: dc.srv.prefix(),
1457 Command: msg.Command,
1458 Params: []string{dc.nick, limit, target},
1459 })
1460 }
1461 }
1462 })
1463 case irc.RPL_AWAY:
1464 var nick, reason string
1465 if err := parseMessageParams(msg, nil, &nick, &reason); err != nil {
1466 return err
1467 }
1468
1469 uc.forEachDownstream(func(dc *downstreamConn) {
1470 dc.SendMessage(&irc.Message{
1471 Prefix: dc.srv.prefix(),
1472 Command: irc.RPL_AWAY,
1473 Params: []string{dc.nick, dc.marshalEntity(uc.network, nick), reason},
1474 })
1475 })
1476 case "AWAY", "ACCOUNT":
1477 if msg.Prefix == nil {
1478 return fmt.Errorf("expected a prefix")
1479 }
1480
1481 uc.forEachDownstream(func(dc *downstreamConn) {
1482 dc.SendMessage(&irc.Message{
1483 Prefix: dc.marshalUserPrefix(uc.network, msg.Prefix),
1484 Command: msg.Command,
1485 Params: msg.Params,
1486 })
1487 })
1488 case irc.RPL_BANLIST, irc.RPL_INVITELIST, irc.RPL_EXCEPTLIST:
1489 var channel, mask string
1490 if err := parseMessageParams(msg, nil, &channel, &mask); err != nil {
1491 return err
1492 }
1493 var addNick, addTime string
1494 if len(msg.Params) >= 5 {
1495 addNick = msg.Params[3]
1496 addTime = msg.Params[4]
1497 }
1498
1499 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1500 channel := dc.marshalEntity(uc.network, channel)
1501
1502 var params []string
1503 if addNick != "" && addTime != "" {
1504 addNick := dc.marshalEntity(uc.network, addNick)
1505 params = []string{dc.nick, channel, mask, addNick, addTime}
1506 } else {
1507 params = []string{dc.nick, channel, mask}
1508 }
1509
1510 dc.SendMessage(&irc.Message{
1511 Prefix: dc.srv.prefix(),
1512 Command: msg.Command,
1513 Params: params,
1514 })
1515 })
1516 case irc.RPL_ENDOFBANLIST, irc.RPL_ENDOFINVITELIST, irc.RPL_ENDOFEXCEPTLIST:
1517 var channel, trailing string
1518 if err := parseMessageParams(msg, nil, &channel, &trailing); err != nil {
1519 return err
1520 }
1521
1522 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1523 upstreamChannel := dc.marshalEntity(uc.network, channel)
1524 dc.SendMessage(&irc.Message{
1525 Prefix: dc.srv.prefix(),
1526 Command: msg.Command,
1527 Params: []string{dc.nick, upstreamChannel, trailing},
1528 })
1529 })
1530 case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
1531 var command, reason string
1532 if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
1533 return err
1534 }
1535
1536 if command == "LIST" || command == "WHO" {
1537 dc, _ := uc.dequeueCommand(command)
1538 if dc != nil && downstreamID == 0 {
1539 downstreamID = dc.id
1540 }
1541 }
1542
1543 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1544 dc.SendMessage(&irc.Message{
1545 Prefix: uc.srv.prefix(),
1546 Command: msg.Command,
1547 Params: []string{dc.nick, command, reason},
1548 })
1549 })
1550 case "ACK":
1551 // Ignore
1552 case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
1553 // Ignore
1554 case irc.RPL_YOURHOST, irc.RPL_CREATED:
1555 // Ignore
1556 case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
1557 fallthrough
1558 case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
1559 fallthrough
1560 case rpl_localusers, rpl_globalusers:
1561 fallthrough
1562 case irc.RPL_MOTDSTART, irc.RPL_MOTD:
1563 // Ignore these messages if they're part of the initial registration
1564 // message burst. Forward them if the user explicitly asked for them.
1565 if !uc.gotMotd {
1566 return nil
1567 }
1568
1569 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1570 dc.SendMessage(&irc.Message{
1571 Prefix: uc.srv.prefix(),
1572 Command: msg.Command,
1573 Params: msg.Params,
1574 })
1575 })
1576 case irc.RPL_LISTSTART:
1577 // Ignore
1578 case "ERROR":
1579 var text string
1580 if err := parseMessageParams(msg, &text); err != nil {
1581 return err
1582 }
1583 return fmt.Errorf("fatal server error: %v", text)
1584 case irc.ERR_PASSWDMISMATCH, irc.ERR_ERRONEUSNICKNAME, irc.ERR_NICKNAMEINUSE, irc.ERR_NICKCOLLISION, irc.ERR_UNAVAILRESOURCE, irc.ERR_NOPERMFORHOST, irc.ERR_YOUREBANNEDCREEP:
1585 if !uc.registered {
1586 text := msg.Params[len(msg.Params)-1]
1587 return registrationError(text)
1588 }
1589 fallthrough
1590 default:
1591 uc.logger.Printf("unhandled message: %v", msg)
1592
1593 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1594 // best effort marshaling for unknown messages, replies and errors:
1595 // most numerics start with the user nick, marshal it if that's the case
1596 // otherwise, conservately keep the params without marshaling
1597 params := msg.Params
1598 if _, err := strconv.Atoi(msg.Command); err == nil { // numeric
1599 if len(msg.Params) > 0 && isOurNick(uc.network, msg.Params[0]) {
1600 params[0] = dc.nick
1601 }
1602 }
1603 dc.SendMessage(&irc.Message{
1604 Prefix: uc.srv.prefix(),
1605 Command: msg.Command,
1606 Params: params,
1607 })
1608 })
1609 }
1610 return nil
1611}
1612
1613func (uc *upstreamConn) handleDetachedMessage(ch *Channel, msg *irc.Message) {
1614 if uc.network.detachedMessageNeedsRelay(ch, msg) {
1615 uc.forEachDownstream(func(dc *downstreamConn) {
1616 dc.relayDetachedMessage(uc.network, msg)
1617 })
1618 }
1619 if ch.ReattachOn == FilterMessage || (ch.ReattachOn == FilterHighlight && uc.network.isHighlight(msg)) {
1620 uc.network.attach(ch)
1621 if err := uc.srv.db.StoreChannel(context.TODO(), uc.network.ID, ch); err != nil {
1622 uc.logger.Printf("failed to update channel %q: %v", ch.Name, err)
1623 }
1624 }
1625}
1626
1627func (uc *upstreamConn) handleChanModes(s string) error {
1628 parts := strings.SplitN(s, ",", 5)
1629 if len(parts) < 4 {
1630 return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", s)
1631 }
1632 modes := make(map[byte]channelModeType)
1633 for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
1634 for j := 0; j < len(parts[i]); j++ {
1635 mode := parts[i][j]
1636 modes[mode] = mt
1637 }
1638 }
1639 uc.availableChannelModes = modes
1640 return nil
1641}
1642
1643func (uc *upstreamConn) handleMemberships(s string) error {
1644 if s == "" {
1645 uc.availableMemberships = nil
1646 return nil
1647 }
1648
1649 if s[0] != '(' {
1650 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
1651 }
1652 sep := strings.IndexByte(s, ')')
1653 if sep < 0 || len(s) != sep*2 {
1654 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", s)
1655 }
1656 memberships := make([]membership, len(s)/2-1)
1657 for i := range memberships {
1658 memberships[i] = membership{
1659 Mode: s[i+1],
1660 Prefix: s[sep+i+1],
1661 }
1662 }
1663 uc.availableMemberships = memberships
1664 return nil
1665}
1666
1667func (uc *upstreamConn) handleSupportedCaps(capsStr string) {
1668 caps := strings.Fields(capsStr)
1669 for _, s := range caps {
1670 kv := strings.SplitN(s, "=", 2)
1671 k := strings.ToLower(kv[0])
1672 var v string
1673 if len(kv) == 2 {
1674 v = kv[1]
1675 }
1676 uc.supportedCaps[k] = v
1677 }
1678}
1679
1680func (uc *upstreamConn) requestCaps() {
1681 var requestCaps []string
1682 for c := range permanentUpstreamCaps {
1683 if _, ok := uc.supportedCaps[c]; ok && !uc.caps[c] {
1684 requestCaps = append(requestCaps, c)
1685 }
1686 }
1687
1688 if uc.requestSASL() && !uc.caps["sasl"] {
1689 requestCaps = append(requestCaps, "sasl")
1690 }
1691
1692 if len(requestCaps) == 0 {
1693 return
1694 }
1695
1696 uc.SendMessage(&irc.Message{
1697 Command: "CAP",
1698 Params: []string{"REQ", strings.Join(requestCaps, " ")},
1699 })
1700}
1701
1702func (uc *upstreamConn) requestSASL() bool {
1703 if uc.network.SASL.Mechanism == "" {
1704 return false
1705 }
1706
1707 v, ok := uc.supportedCaps["sasl"]
1708 if !ok {
1709 return false
1710 }
1711 if v != "" {
1712 mechanisms := strings.Split(v, ",")
1713 found := false
1714 for _, mech := range mechanisms {
1715 if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
1716 found = true
1717 break
1718 }
1719 }
1720 if !found {
1721 return false
1722 }
1723 }
1724
1725 return true
1726}
1727
1728func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
1729 uc.caps[name] = ok
1730
1731 switch name {
1732 case "sasl":
1733 if !ok {
1734 uc.logger.Printf("server refused to acknowledge the SASL capability")
1735 return nil
1736 }
1737
1738 auth := &uc.network.SASL
1739 switch auth.Mechanism {
1740 case "PLAIN":
1741 uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
1742 uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
1743 case "EXTERNAL":
1744 uc.logger.Printf("starting SASL EXTERNAL authentication")
1745 uc.saslClient = sasl.NewExternalClient("")
1746 default:
1747 return fmt.Errorf("unsupported SASL mechanism %q", name)
1748 }
1749
1750 uc.SendMessage(&irc.Message{
1751 Command: "AUTHENTICATE",
1752 Params: []string{auth.Mechanism},
1753 })
1754 default:
1755 if permanentUpstreamCaps[name] {
1756 break
1757 }
1758 uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
1759 }
1760 return nil
1761}
1762
1763func splitSpace(s string) []string {
1764 return strings.FieldsFunc(s, func(r rune) bool {
1765 return r == ' '
1766 })
1767}
1768
1769func (uc *upstreamConn) register() {
1770 uc.nick = GetNick(&uc.user.User, &uc.network.Network)
1771 uc.nickCM = uc.network.casemap(uc.nick)
1772 uc.username = GetUsername(&uc.user.User, &uc.network.Network)
1773 uc.realname = GetRealname(&uc.user.User, &uc.network.Network)
1774
1775 uc.SendMessage(&irc.Message{
1776 Command: "CAP",
1777 Params: []string{"LS", "302"},
1778 })
1779
1780 if uc.network.Pass != "" {
1781 uc.SendMessage(&irc.Message{
1782 Command: "PASS",
1783 Params: []string{uc.network.Pass},
1784 })
1785 }
1786
1787 uc.SendMessage(&irc.Message{
1788 Command: "NICK",
1789 Params: []string{uc.nick},
1790 })
1791 uc.SendMessage(&irc.Message{
1792 Command: "USER",
1793 Params: []string{uc.username, "0", "*", uc.realname},
1794 })
1795}
1796
1797func (uc *upstreamConn) runUntilRegistered() error {
1798 for !uc.registered {
1799 msg, err := uc.ReadMessage()
1800 if err != nil {
1801 return fmt.Errorf("failed to read message: %v", err)
1802 }
1803
1804 if err := uc.handleMessage(msg); err != nil {
1805 if _, ok := err.(registrationError); ok {
1806 return err
1807 } else {
1808 msg.Tags = nil // prevent message tags from cluttering logs
1809 return fmt.Errorf("failed to handle message %q: %v", msg, err)
1810 }
1811 }
1812 }
1813
1814 for _, command := range uc.network.ConnectCommands {
1815 m, err := irc.ParseMessage(command)
1816 if err != nil {
1817 uc.logger.Printf("failed to parse connect command %q: %v", command, err)
1818 } else {
1819 uc.SendMessage(m)
1820 }
1821 }
1822
1823 return nil
1824}
1825
1826func (uc *upstreamConn) readMessages(ch chan<- event) error {
1827 for {
1828 msg, err := uc.ReadMessage()
1829 if errors.Is(err, io.EOF) {
1830 break
1831 } else if err != nil {
1832 return fmt.Errorf("failed to read IRC command: %v", err)
1833 }
1834
1835 ch <- eventUpstreamMessage{msg, uc}
1836 }
1837
1838 return nil
1839}
1840
1841func (uc *upstreamConn) SendMessage(msg *irc.Message) {
1842 if !uc.caps["message-tags"] {
1843 msg = msg.Copy()
1844 msg.Tags = nil
1845 }
1846
1847 uc.conn.SendMessage(msg)
1848}
1849
1850func (uc *upstreamConn) SendMessageLabeled(downstreamID uint64, msg *irc.Message) {
1851 if uc.caps["labeled-response"] {
1852 if msg.Tags == nil {
1853 msg.Tags = make(map[string]irc.TagValue)
1854 }
1855 msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
1856 uc.nextLabelID++
1857 }
1858 uc.SendMessage(msg)
1859}
1860
1861// appendLog appends a message to the log file.
1862//
1863// The internal message ID is returned. If the message isn't recorded in the
1864// log file, an empty string is returned.
1865func (uc *upstreamConn) appendLog(entity string, msg *irc.Message) (msgID string) {
1866 if uc.user.msgStore == nil {
1867 return ""
1868 }
1869
1870 // Don't store messages with a server mask target
1871 if strings.HasPrefix(entity, "$") {
1872 return ""
1873 }
1874
1875 entityCM := uc.network.casemap(entity)
1876 if entityCM == "nickserv" {
1877 // The messages sent/received from NickServ may contain
1878 // security-related information (like passwords). Don't store these.
1879 return ""
1880 }
1881
1882 if !uc.network.delivered.HasTarget(entity) {
1883 // This is the first message we receive from this target. Save the last
1884 // message ID in delivery receipts, so that we can send the new message
1885 // in the backlog if an offline client reconnects.
1886 lastID, err := uc.user.msgStore.LastMsgID(&uc.network.Network, entityCM, time.Now())
1887 if err != nil {
1888 uc.logger.Printf("failed to log message: failed to get last message ID: %v", err)
1889 return ""
1890 }
1891
1892 uc.network.delivered.ForEachClient(func(clientName string) {
1893 uc.network.delivered.StoreID(entity, clientName, lastID)
1894 })
1895 }
1896
1897 msgID, err := uc.user.msgStore.Append(&uc.network.Network, entityCM, msg)
1898 if err != nil {
1899 uc.logger.Printf("failed to log message: %v", err)
1900 return ""
1901 }
1902
1903 return msgID
1904}
1905
1906// produce appends a message to the logs and forwards it to connected downstream
1907// connections.
1908//
1909// If origin is not nil and origin doesn't support echo-message, the message is
1910// forwarded to all connections except origin.
1911func (uc *upstreamConn) produce(target string, msg *irc.Message, origin *downstreamConn) {
1912 var msgID string
1913 if target != "" {
1914 msgID = uc.appendLog(target, msg)
1915 }
1916
1917 // Don't forward messages if it's a detached channel
1918 ch := uc.network.channels.Value(target)
1919 detached := ch != nil && ch.Detached
1920
1921 uc.forEachDownstream(func(dc *downstreamConn) {
1922 if !detached && (dc != origin || dc.caps["echo-message"]) {
1923 dc.sendMessageWithID(dc.marshalMessage(msg, uc.network), msgID)
1924 } else {
1925 dc.advanceMessageWithID(msg, msgID)
1926 }
1927 })
1928}
1929
1930func (uc *upstreamConn) updateAway() {
1931 away := true
1932 uc.forEachDownstream(func(*downstreamConn) {
1933 away = false
1934 })
1935 if away == uc.away {
1936 return
1937 }
1938 if away {
1939 uc.SendMessage(&irc.Message{
1940 Command: "AWAY",
1941 Params: []string{"Auto away"},
1942 })
1943 } else {
1944 uc.SendMessage(&irc.Message{
1945 Command: "AWAY",
1946 })
1947 }
1948 uc.away = away
1949}
1950
1951func (uc *upstreamConn) updateChannelAutoDetach(name string) {
1952 uch := uc.channels.Value(name)
1953 if uch == nil {
1954 return
1955 }
1956 ch := uc.network.channels.Value(name)
1957 if ch == nil || ch.Detached {
1958 return
1959 }
1960 uch.updateAutoDetach(ch.DetachAfter)
1961}
1962
1963func (uc *upstreamConn) updateMonitor() {
1964 add := make(map[string]struct{})
1965 var addList []string
1966 seen := make(map[string]struct{})
1967 uc.forEachDownstream(func(dc *downstreamConn) {
1968 for targetCM := range dc.monitored.innerMap {
1969 if !uc.monitored.Has(targetCM) {
1970 if _, ok := add[targetCM]; !ok {
1971 addList = append(addList, targetCM)
1972 }
1973 add[targetCM] = struct{}{}
1974 } else {
1975 seen[targetCM] = struct{}{}
1976 }
1977 }
1978 })
1979
1980 removeAll := true
1981 var removeList []string
1982 for targetCM, entry := range uc.monitored.innerMap {
1983 if _, ok := seen[targetCM]; ok {
1984 removeAll = false
1985 } else {
1986 removeList = append(removeList, entry.originalKey)
1987 }
1988 }
1989
1990 // TODO: better handle the case where len(uc.monitored) + len(addList)
1991 // exceeds the limit, probably by immediately sending ERR_MONLISTFULL?
1992
1993 if removeAll && len(addList) == 0 && len(removeList) > 0 {
1994 // Optimization when the last MONITOR-aware downstream disconnects
1995 uc.SendMessage(&irc.Message{
1996 Command: "MONITOR",
1997 Params: []string{"C"},
1998 })
1999 } else {
2000 msgs := generateMonitor("-", removeList)
2001 msgs = append(msgs, generateMonitor("+", addList)...)
2002 for _, msg := range msgs {
2003 uc.SendMessage(msg)
2004 }
2005 }
2006
2007 for _, target := range removeList {
2008 uc.monitored.Delete(target)
2009 }
2010}
Note: See TracBrowser for help on using the repository browser.