source: code/trunk/upstream.go@ 419

Last change on this file since 419 was 419, checked in by delthas, 5 years ago

Add support for the extended-join capability

This simple implementation only advertises extended-join to downstreams
when all upstreams support it.

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