source: code/trunk/upstream.go@ 447

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

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