source: code/trunk/upstream.go@ 459

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

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