source: code/trunk/upstream.go@ 219

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

Send one NOTICE on new upstream disconnect/connect errors

In order to notify the user when we are disconnected from a network
(either due to an error, or due a QUIT), and when we fail reconnecting,
this commit adds support for sending a short NOTICE message from the
service user to all relevant downstreams.

The last error is stored, and cleared on successful connection, to
ensure that the user is *not* flooded with identical connection error
messages, which can often happen when a server is down.

No lock is needed on lastError because it is only read and modified from
the user goroutine.

Closes: ​https://todo.sr.ht/~emersion/soju/27
File size: 33.9 KB
Line 
1package soju
2
3import (
4 "crypto/tls"
5 "encoding/base64"
6 "errors"
7 "fmt"
8 "io"
9 "net"
10 "os"
11 "strconv"
12 "strings"
13 "time"
14
15 "github.com/emersion/go-sasl"
16 "gopkg.in/irc.v3"
17)
18
19type upstreamChannel struct {
20 Name string
21 conn *upstreamConn
22 Topic string
23 TopicWho string
24 TopicTime time.Time
25 Status channelStatus
26 modes channelModes
27 creationTime string
28 Members map[string]*membership
29 complete bool
30}
31
32type upstreamConn struct {
33 conn
34
35 network *network
36 user *user
37
38 serverName string
39 availableUserModes string
40 availableChannelModes map[byte]channelModeType
41 availableChannelTypes string
42 availableMemberships []membership
43
44 registered bool
45 nick string
46 username string
47 realname string
48 modes userModes
49 channels map[string]*upstreamChannel
50 caps map[string]string
51 batches map[string]batch
52 away bool
53
54 tagsSupported bool
55 labelsSupported bool
56 nextLabelID uint64
57
58 saslClient sasl.Client
59 saslStarted bool
60
61 // set of LIST commands in progress, per downstream
62 pendingLISTDownstreamSet map[uint64]struct{}
63
64 messageLoggers map[string]*messageLogger
65}
66
67type entityLog struct {
68 name string
69 file *os.File
70}
71
72func connectToUpstream(network *network) (*upstreamConn, error) {
73 logger := &prefixLogger{network.user.srv.Logger, fmt.Sprintf("upstream %q: ", network.Addr)}
74
75 addr := network.Addr
76 if !strings.ContainsRune(addr, ':') {
77 addr = addr + ":6697"
78 }
79
80 dialer := net.Dialer{Timeout: connectTimeout}
81
82 logger.Printf("connecting to TLS server at address %q", addr)
83 netConn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
84 if err != nil {
85 return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
86 }
87
88 uc := &upstreamConn{
89 conn: *newConn(network.user.srv, netConn, logger),
90 network: network,
91 user: network.user,
92 channels: make(map[string]*upstreamChannel),
93 caps: make(map[string]string),
94 batches: make(map[string]batch),
95 availableChannelTypes: stdChannelTypes,
96 availableChannelModes: stdChannelModes,
97 availableMemberships: stdMemberships,
98 pendingLISTDownstreamSet: make(map[uint64]struct{}),
99 messageLoggers: make(map[string]*messageLogger),
100 }
101
102 return uc, nil
103}
104
105func (uc *upstreamConn) forEachDownstream(f func(*downstreamConn)) {
106 uc.network.forEachDownstream(f)
107}
108
109func (uc *upstreamConn) forEachDownstreamByID(id uint64, f func(*downstreamConn)) {
110 uc.forEachDownstream(func(dc *downstreamConn) {
111 if id != 0 && id != dc.id {
112 return
113 }
114 f(dc)
115 })
116}
117
118func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
119 ch, ok := uc.channels[name]
120 if !ok {
121 return nil, fmt.Errorf("unknown channel %q", name)
122 }
123 return ch, nil
124}
125
126func (uc *upstreamConn) isChannel(entity string) bool {
127 if i := strings.IndexByte(uc.availableChannelTypes, entity[0]); i >= 0 {
128 return true
129 }
130 return false
131}
132
133func (uc *upstreamConn) getPendingLIST() *pendingLIST {
134 for _, pl := range uc.user.pendingLISTs {
135 if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
136 continue
137 }
138 return &pl
139 }
140 return nil
141}
142
143func (uc *upstreamConn) endPendingLISTs(all bool) (found bool) {
144 found = false
145 for i := 0; i < len(uc.user.pendingLISTs); i++ {
146 pl := uc.user.pendingLISTs[i]
147 if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
148 continue
149 }
150 delete(pl.pendingCommands, uc.network.ID)
151 if len(pl.pendingCommands) == 0 {
152 uc.user.pendingLISTs = append(uc.user.pendingLISTs[:i], uc.user.pendingLISTs[i+1:]...)
153 i--
154 uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
155 dc.SendMessage(&irc.Message{
156 Prefix: dc.srv.prefix(),
157 Command: irc.RPL_LISTEND,
158 Params: []string{dc.nick, "End of /LIST"},
159 })
160 })
161 }
162 found = true
163 if !all {
164 delete(uc.pendingLISTDownstreamSet, pl.downstreamID)
165 uc.user.forEachUpstream(func(uc *upstreamConn) {
166 uc.trySendLIST(pl.downstreamID)
167 })
168 return
169 }
170 }
171 return
172}
173
174func (uc *upstreamConn) trySendLIST(downstreamID uint64) {
175 // must be called with a lock in uc.user.pendingLISTsLock
176
177 if _, ok := uc.pendingLISTDownstreamSet[downstreamID]; ok {
178 // a LIST command is already pending
179 // we will try again when that command is completed
180 return
181 }
182
183 for _, pl := range uc.user.pendingLISTs {
184 if pl.downstreamID != downstreamID {
185 continue
186 }
187 // this is the first pending LIST command list of the downstream
188 listCommand, ok := pl.pendingCommands[uc.network.ID]
189 if !ok {
190 // there is no command for this upstream in these LIST commands
191 // do not send anything
192 continue
193 }
194 // there is a command for this upstream in these LIST commands
195 // send it now
196
197 uc.SendMessageLabeled(downstreamID, listCommand)
198
199 uc.pendingLISTDownstreamSet[downstreamID] = struct{}{}
200 return
201 }
202}
203
204func (uc *upstreamConn) parseMembershipPrefix(s string) (membership *membership, nick string) {
205 for _, m := range uc.availableMemberships {
206 if m.Prefix == s[0] {
207 return &m, s[1:]
208 }
209 }
210 return nil, s
211}
212
213func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
214 var label string
215 if l, ok := msg.GetTag("label"); ok {
216 label = l
217 }
218
219 var msgBatch *batch
220 if batchName, ok := msg.GetTag("batch"); ok {
221 b, ok := uc.batches[batchName]
222 if !ok {
223 return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
224 }
225 msgBatch = &b
226 if label == "" {
227 label = msgBatch.Label
228 }
229 }
230
231 var downstreamID uint64 = 0
232 if label != "" {
233 var labelOffset uint64
234 n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
235 if err == nil && n < 2 {
236 err = errors.New("not enough arguments")
237 }
238 if err != nil {
239 return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
240 }
241 }
242
243 if _, ok := msg.Tags["time"]; !ok {
244 msg.Tags["time"] = irc.TagValue(time.Now().Format(serverTimeLayout))
245 }
246
247 switch msg.Command {
248 case "PING":
249 uc.SendMessage(&irc.Message{
250 Command: "PONG",
251 Params: msg.Params,
252 })
253 return nil
254 case "NOTICE":
255 if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
256 uc.network.ring.Produce(msg)
257 } else { // regular user NOTICE
258 var entity, text string
259 if err := parseMessageParams(msg, &entity, &text); err != nil {
260 return err
261 }
262
263 target := entity
264 if target == uc.nick {
265 target = msg.Prefix.Name
266 }
267 uc.appendLog(target, msg)
268
269 uc.network.ring.Produce(msg)
270 }
271 case "CAP":
272 var subCmd string
273 if err := parseMessageParams(msg, nil, &subCmd); err != nil {
274 return err
275 }
276 subCmd = strings.ToUpper(subCmd)
277 subParams := msg.Params[2:]
278 switch subCmd {
279 case "LS":
280 if len(subParams) < 1 {
281 return newNeedMoreParamsError(msg.Command)
282 }
283 caps := strings.Fields(subParams[len(subParams)-1])
284 more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
285
286 for _, s := range caps {
287 kv := strings.SplitN(s, "=", 2)
288 k := strings.ToLower(kv[0])
289 var v string
290 if len(kv) == 2 {
291 v = kv[1]
292 }
293 uc.caps[k] = v
294 }
295
296 if more {
297 break // wait to receive all capabilities
298 }
299
300 requestCaps := make([]string, 0, 16)
301 for _, c := range []string{"message-tags", "batch", "labeled-response", "server-time"} {
302 if _, ok := uc.caps[c]; ok {
303 requestCaps = append(requestCaps, c)
304 }
305 }
306
307 if uc.requestSASL() {
308 requestCaps = append(requestCaps, "sasl")
309 }
310
311 if len(requestCaps) > 0 {
312 uc.SendMessage(&irc.Message{
313 Command: "CAP",
314 Params: []string{"REQ", strings.Join(requestCaps, " ")},
315 })
316 }
317
318 if uc.requestSASL() {
319 break // we'll send CAP END after authentication is completed
320 }
321
322 uc.SendMessage(&irc.Message{
323 Command: "CAP",
324 Params: []string{"END"},
325 })
326 case "ACK", "NAK":
327 if len(subParams) < 1 {
328 return newNeedMoreParamsError(msg.Command)
329 }
330 caps := strings.Fields(subParams[0])
331
332 for _, name := range caps {
333 if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
334 return err
335 }
336 }
337
338 if uc.saslClient == nil {
339 uc.SendMessage(&irc.Message{
340 Command: "CAP",
341 Params: []string{"END"},
342 })
343 }
344 default:
345 uc.logger.Printf("unhandled message: %v", msg)
346 }
347 case "AUTHENTICATE":
348 if uc.saslClient == nil {
349 return fmt.Errorf("received unexpected AUTHENTICATE message")
350 }
351
352 // TODO: if a challenge is 400 bytes long, buffer it
353 var challengeStr string
354 if err := parseMessageParams(msg, &challengeStr); err != nil {
355 uc.SendMessage(&irc.Message{
356 Command: "AUTHENTICATE",
357 Params: []string{"*"},
358 })
359 return err
360 }
361
362 var challenge []byte
363 if challengeStr != "+" {
364 var err error
365 challenge, err = base64.StdEncoding.DecodeString(challengeStr)
366 if err != nil {
367 uc.SendMessage(&irc.Message{
368 Command: "AUTHENTICATE",
369 Params: []string{"*"},
370 })
371 return err
372 }
373 }
374
375 var resp []byte
376 var err error
377 if !uc.saslStarted {
378 _, resp, err = uc.saslClient.Start()
379 uc.saslStarted = true
380 } else {
381 resp, err = uc.saslClient.Next(challenge)
382 }
383 if err != nil {
384 uc.SendMessage(&irc.Message{
385 Command: "AUTHENTICATE",
386 Params: []string{"*"},
387 })
388 return err
389 }
390
391 // TODO: send response in multiple chunks if >= 400 bytes
392 var respStr = "+"
393 if resp != nil {
394 respStr = base64.StdEncoding.EncodeToString(resp)
395 }
396
397 uc.SendMessage(&irc.Message{
398 Command: "AUTHENTICATE",
399 Params: []string{respStr},
400 })
401 case irc.RPL_LOGGEDIN:
402 var account string
403 if err := parseMessageParams(msg, nil, nil, &account); err != nil {
404 return err
405 }
406 uc.logger.Printf("logged in with account %q", account)
407 case irc.RPL_LOGGEDOUT:
408 uc.logger.Printf("logged out")
409 case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
410 var info string
411 if err := parseMessageParams(msg, nil, &info); err != nil {
412 return err
413 }
414 switch msg.Command {
415 case irc.ERR_NICKLOCKED:
416 uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
417 case irc.ERR_SASLFAIL:
418 uc.logger.Printf("SASL authentication failed: %v", info)
419 case irc.ERR_SASLTOOLONG:
420 uc.logger.Printf("SASL message too long: %v", info)
421 }
422
423 uc.saslClient = nil
424 uc.saslStarted = false
425
426 uc.SendMessage(&irc.Message{
427 Command: "CAP",
428 Params: []string{"END"},
429 })
430 case irc.RPL_WELCOME:
431 uc.registered = true
432 uc.logger.Printf("connection registered")
433
434 channels, err := uc.srv.db.ListChannels(uc.network.ID)
435 if err != nil {
436 uc.logger.Printf("failed to list channels from database: %v", err)
437 break
438 }
439
440 for _, ch := range channels {
441 params := []string{ch.Name}
442 if ch.Key != "" {
443 params = append(params, ch.Key)
444 }
445 uc.SendMessage(&irc.Message{
446 Command: "JOIN",
447 Params: params,
448 })
449 }
450 case irc.RPL_MYINFO:
451 if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
452 return err
453 }
454 case irc.RPL_ISUPPORT:
455 if err := parseMessageParams(msg, nil, nil); err != nil {
456 return err
457 }
458 for _, token := range msg.Params[1 : len(msg.Params)-1] {
459 negate := false
460 parameter := token
461 value := ""
462 if strings.HasPrefix(token, "-") {
463 negate = true
464 token = token[1:]
465 } else {
466 if i := strings.IndexByte(token, '='); i >= 0 {
467 parameter = token[:i]
468 value = token[i+1:]
469 }
470 }
471 if !negate {
472 switch parameter {
473 case "CHANMODES":
474 parts := strings.SplitN(value, ",", 5)
475 if len(parts) < 4 {
476 return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
477 }
478 modes := make(map[byte]channelModeType)
479 for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
480 for j := 0; j < len(parts[i]); j++ {
481 mode := parts[i][j]
482 modes[mode] = mt
483 }
484 }
485 uc.availableChannelModes = modes
486 case "CHANTYPES":
487 uc.availableChannelTypes = value
488 case "PREFIX":
489 if value == "" {
490 uc.availableMemberships = nil
491 } else {
492 if value[0] != '(' {
493 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
494 }
495 sep := strings.IndexByte(value, ')')
496 if sep < 0 || len(value) != sep*2 {
497 return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
498 }
499 memberships := make([]membership, len(value)/2-1)
500 for i := range memberships {
501 memberships[i] = membership{
502 Mode: value[i+1],
503 Prefix: value[sep+i+1],
504 }
505 }
506 uc.availableMemberships = memberships
507 }
508 }
509 } else {
510 // TODO: handle ISUPPORT negations
511 }
512 }
513 case "BATCH":
514 var tag string
515 if err := parseMessageParams(msg, &tag); err != nil {
516 return err
517 }
518
519 if strings.HasPrefix(tag, "+") {
520 tag = tag[1:]
521 if _, ok := uc.batches[tag]; ok {
522 return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
523 }
524 var batchType string
525 if err := parseMessageParams(msg, nil, &batchType); err != nil {
526 return err
527 }
528 label := label
529 if label == "" && msgBatch != nil {
530 label = msgBatch.Label
531 }
532 uc.batches[tag] = batch{
533 Type: batchType,
534 Params: msg.Params[2:],
535 Outer: msgBatch,
536 Label: label,
537 }
538 } else if strings.HasPrefix(tag, "-") {
539 tag = tag[1:]
540 if _, ok := uc.batches[tag]; !ok {
541 return fmt.Errorf("unknown BATCH reference tag: %q", tag)
542 }
543 delete(uc.batches, tag)
544 } else {
545 return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
546 }
547 case "NICK":
548 if msg.Prefix == nil {
549 return fmt.Errorf("expected a prefix")
550 }
551
552 var newNick string
553 if err := parseMessageParams(msg, &newNick); err != nil {
554 return err
555 }
556
557 if msg.Prefix.Name == uc.nick {
558 uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
559 uc.nick = newNick
560 }
561
562 for _, ch := range uc.channels {
563 if membership, ok := ch.Members[msg.Prefix.Name]; ok {
564 delete(ch.Members, msg.Prefix.Name)
565 ch.Members[newNick] = membership
566 uc.appendLog(ch.Name, msg)
567 }
568 }
569
570 if msg.Prefix.Name != uc.nick {
571 uc.forEachDownstream(func(dc *downstreamConn) {
572 dc.SendMessage(&irc.Message{
573 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
574 Command: "NICK",
575 Params: []string{newNick},
576 })
577 })
578 }
579 case "JOIN":
580 if msg.Prefix == nil {
581 return fmt.Errorf("expected a prefix")
582 }
583
584 var channels string
585 if err := parseMessageParams(msg, &channels); err != nil {
586 return err
587 }
588
589 for _, ch := range strings.Split(channels, ",") {
590 if msg.Prefix.Name == uc.nick {
591 uc.logger.Printf("joined channel %q", ch)
592 uc.channels[ch] = &upstreamChannel{
593 Name: ch,
594 conn: uc,
595 Members: make(map[string]*membership),
596 }
597
598 uc.SendMessage(&irc.Message{
599 Command: "MODE",
600 Params: []string{ch},
601 })
602 } else {
603 ch, err := uc.getChannel(ch)
604 if err != nil {
605 return err
606 }
607 ch.Members[msg.Prefix.Name] = nil
608 }
609
610 uc.appendLog(ch, msg)
611
612 uc.forEachDownstream(func(dc *downstreamConn) {
613 dc.SendMessage(&irc.Message{
614 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
615 Command: "JOIN",
616 Params: []string{dc.marshalChannel(uc, ch)},
617 })
618 })
619 }
620 case "PART":
621 if msg.Prefix == nil {
622 return fmt.Errorf("expected a prefix")
623 }
624
625 var channels string
626 if err := parseMessageParams(msg, &channels); err != nil {
627 return err
628 }
629
630 var reason string
631 if len(msg.Params) > 1 {
632 reason = msg.Params[1]
633 }
634
635 for _, ch := range strings.Split(channels, ",") {
636 if msg.Prefix.Name == uc.nick {
637 uc.logger.Printf("parted channel %q", ch)
638 delete(uc.channels, ch)
639 } else {
640 ch, err := uc.getChannel(ch)
641 if err != nil {
642 return err
643 }
644 delete(ch.Members, msg.Prefix.Name)
645 }
646
647 uc.appendLog(ch, msg)
648
649 uc.forEachDownstream(func(dc *downstreamConn) {
650 params := []string{dc.marshalChannel(uc, ch)}
651 if reason != "" {
652 params = append(params, reason)
653 }
654 dc.SendMessage(&irc.Message{
655 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
656 Command: "PART",
657 Params: params,
658 })
659 })
660 }
661 case "KICK":
662 if msg.Prefix == nil {
663 return fmt.Errorf("expected a prefix")
664 }
665
666 var channel, user string
667 if err := parseMessageParams(msg, &channel, &user); err != nil {
668 return err
669 }
670
671 var reason string
672 if len(msg.Params) > 2 {
673 reason = msg.Params[2]
674 }
675
676 if user == uc.nick {
677 uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
678 delete(uc.channels, channel)
679 } else {
680 ch, err := uc.getChannel(channel)
681 if err != nil {
682 return err
683 }
684 delete(ch.Members, user)
685 }
686
687 uc.appendLog(channel, msg)
688
689 uc.forEachDownstream(func(dc *downstreamConn) {
690 params := []string{dc.marshalChannel(uc, channel), dc.marshalNick(uc, user)}
691 if reason != "" {
692 params = append(params, reason)
693 }
694 dc.SendMessage(&irc.Message{
695 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
696 Command: "KICK",
697 Params: params,
698 })
699 })
700 case "QUIT":
701 if msg.Prefix == nil {
702 return fmt.Errorf("expected a prefix")
703 }
704
705 if msg.Prefix.Name == uc.nick {
706 uc.logger.Printf("quit")
707 }
708
709 for _, ch := range uc.channels {
710 if _, ok := ch.Members[msg.Prefix.Name]; ok {
711 delete(ch.Members, msg.Prefix.Name)
712
713 uc.appendLog(ch.Name, msg)
714 }
715 }
716
717 if msg.Prefix.Name != uc.nick {
718 uc.forEachDownstream(func(dc *downstreamConn) {
719 dc.SendMessage(&irc.Message{
720 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
721 Command: "QUIT",
722 Params: msg.Params,
723 })
724 })
725 }
726 case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
727 var name, topic string
728 if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
729 return err
730 }
731 ch, err := uc.getChannel(name)
732 if err != nil {
733 return err
734 }
735 if msg.Command == irc.RPL_TOPIC {
736 ch.Topic = topic
737 } else {
738 ch.Topic = ""
739 }
740 case "TOPIC":
741 var name string
742 if err := parseMessageParams(msg, &name); err != nil {
743 return err
744 }
745 ch, err := uc.getChannel(name)
746 if err != nil {
747 return err
748 }
749 if len(msg.Params) > 1 {
750 ch.Topic = msg.Params[1]
751 } else {
752 ch.Topic = ""
753 }
754 uc.forEachDownstream(func(dc *downstreamConn) {
755 params := []string{dc.marshalChannel(uc, name)}
756 if ch.Topic != "" {
757 params = append(params, ch.Topic)
758 }
759 dc.SendMessage(&irc.Message{
760 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
761 Command: "TOPIC",
762 Params: params,
763 })
764 })
765 case "MODE":
766 var name, modeStr string
767 if err := parseMessageParams(msg, &name, &modeStr); err != nil {
768 return err
769 }
770
771 if !uc.isChannel(name) { // user mode change
772 if name != uc.nick {
773 return fmt.Errorf("received MODE message for unknown nick %q", name)
774 }
775 return uc.modes.Apply(modeStr)
776 // TODO: notify downstreams about user mode change?
777 } else { // channel mode change
778 ch, err := uc.getChannel(name)
779 if err != nil {
780 return err
781 }
782
783 if ch.modes != nil {
784 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
785 return err
786 }
787 }
788
789 uc.appendLog(ch.Name, msg)
790
791 uc.forEachDownstream(func(dc *downstreamConn) {
792 params := []string{dc.marshalChannel(uc, name), modeStr}
793 params = append(params, msg.Params[2:]...)
794
795 dc.SendMessage(&irc.Message{
796 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
797 Command: "MODE",
798 Params: params,
799 })
800 })
801 }
802 case irc.RPL_UMODEIS:
803 if err := parseMessageParams(msg, nil); err != nil {
804 return err
805 }
806 modeStr := ""
807 if len(msg.Params) > 1 {
808 modeStr = msg.Params[1]
809 }
810
811 uc.modes = ""
812 if err := uc.modes.Apply(modeStr); err != nil {
813 return err
814 }
815 // TODO: send RPL_UMODEIS to downstream connections when applicable
816 case irc.RPL_CHANNELMODEIS:
817 var channel string
818 if err := parseMessageParams(msg, nil, &channel); err != nil {
819 return err
820 }
821 modeStr := ""
822 if len(msg.Params) > 2 {
823 modeStr = msg.Params[2]
824 }
825
826 ch, err := uc.getChannel(channel)
827 if err != nil {
828 return err
829 }
830
831 firstMode := ch.modes == nil
832 ch.modes = make(map[byte]string)
833 if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
834 return err
835 }
836 if firstMode {
837 modeStr, modeParams := ch.modes.Format()
838
839 uc.forEachDownstream(func(dc *downstreamConn) {
840 params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
841 params = append(params, modeParams...)
842
843 dc.SendMessage(&irc.Message{
844 Prefix: dc.srv.prefix(),
845 Command: irc.RPL_CHANNELMODEIS,
846 Params: params,
847 })
848 })
849 }
850 case rpl_creationtime:
851 var channel, creationTime string
852 if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
853 return err
854 }
855
856 ch, err := uc.getChannel(channel)
857 if err != nil {
858 return err
859 }
860
861 firstCreationTime := ch.creationTime == ""
862 ch.creationTime = creationTime
863 if firstCreationTime {
864 uc.forEachDownstream(func(dc *downstreamConn) {
865 dc.SendMessage(&irc.Message{
866 Prefix: dc.srv.prefix(),
867 Command: rpl_creationtime,
868 Params: []string{dc.nick, channel, creationTime},
869 })
870 })
871 }
872 case rpl_topicwhotime:
873 var name, who, timeStr string
874 if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
875 return err
876 }
877 ch, err := uc.getChannel(name)
878 if err != nil {
879 return err
880 }
881 ch.TopicWho = who
882 sec, err := strconv.ParseInt(timeStr, 10, 64)
883 if err != nil {
884 return fmt.Errorf("failed to parse topic time: %v", err)
885 }
886 ch.TopicTime = time.Unix(sec, 0)
887 case irc.RPL_LIST:
888 var channel, clients, topic string
889 if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
890 return err
891 }
892
893 pl := uc.getPendingLIST()
894 if pl == nil {
895 return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
896 }
897
898 uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
899 dc.SendMessage(&irc.Message{
900 Prefix: dc.srv.prefix(),
901 Command: irc.RPL_LIST,
902 Params: []string{dc.nick, dc.marshalChannel(uc, channel), clients, topic},
903 })
904 })
905 case irc.RPL_LISTEND:
906 ok := uc.endPendingLISTs(false)
907 if !ok {
908 return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
909 }
910 case irc.RPL_NAMREPLY:
911 var name, statusStr, members string
912 if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
913 return err
914 }
915
916 ch, ok := uc.channels[name]
917 if !ok {
918 // NAMES on a channel we have not joined, forward to downstream
919 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
920 channel := dc.marshalChannel(uc, name)
921 members := splitSpace(members)
922 for i, member := range members {
923 membership, nick := uc.parseMembershipPrefix(member)
924 members[i] = membership.String() + dc.marshalNick(uc, nick)
925 }
926 memberStr := strings.Join(members, " ")
927
928 dc.SendMessage(&irc.Message{
929 Prefix: dc.srv.prefix(),
930 Command: irc.RPL_NAMREPLY,
931 Params: []string{dc.nick, statusStr, channel, memberStr},
932 })
933 })
934 return nil
935 }
936
937 status, err := parseChannelStatus(statusStr)
938 if err != nil {
939 return err
940 }
941 ch.Status = status
942
943 for _, s := range splitSpace(members) {
944 membership, nick := uc.parseMembershipPrefix(s)
945 ch.Members[nick] = membership
946 }
947 case irc.RPL_ENDOFNAMES:
948 var name string
949 if err := parseMessageParams(msg, nil, &name); err != nil {
950 return err
951 }
952
953 ch, ok := uc.channels[name]
954 if !ok {
955 // NAMES on a channel we have not joined, forward to downstream
956 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
957 channel := dc.marshalChannel(uc, name)
958
959 dc.SendMessage(&irc.Message{
960 Prefix: dc.srv.prefix(),
961 Command: irc.RPL_ENDOFNAMES,
962 Params: []string{dc.nick, channel, "End of /NAMES list"},
963 })
964 })
965 return nil
966 }
967
968 if ch.complete {
969 return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
970 }
971 ch.complete = true
972
973 uc.forEachDownstream(func(dc *downstreamConn) {
974 forwardChannel(dc, ch)
975 })
976 case irc.RPL_WHOREPLY:
977 var channel, username, host, server, nick, mode, trailing string
978 if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
979 return err
980 }
981
982 parts := strings.SplitN(trailing, " ", 2)
983 if len(parts) != 2 {
984 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
985 }
986 realname := parts[1]
987 hops, err := strconv.Atoi(parts[0])
988 if err != nil {
989 return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
990 }
991 hops++
992
993 trailing = strconv.Itoa(hops) + " " + realname
994
995 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
996 channel := channel
997 if channel != "*" {
998 channel = dc.marshalChannel(uc, channel)
999 }
1000 nick := dc.marshalNick(uc, nick)
1001 dc.SendMessage(&irc.Message{
1002 Prefix: dc.srv.prefix(),
1003 Command: irc.RPL_WHOREPLY,
1004 Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
1005 })
1006 })
1007 case irc.RPL_ENDOFWHO:
1008 var name string
1009 if err := parseMessageParams(msg, nil, &name); err != nil {
1010 return err
1011 }
1012
1013 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1014 name := name
1015 if name != "*" {
1016 // TODO: support WHO masks
1017 name = dc.marshalEntity(uc, name)
1018 }
1019 dc.SendMessage(&irc.Message{
1020 Prefix: dc.srv.prefix(),
1021 Command: irc.RPL_ENDOFWHO,
1022 Params: []string{dc.nick, name, "End of /WHO list"},
1023 })
1024 })
1025 case irc.RPL_WHOISUSER:
1026 var nick, username, host, realname string
1027 if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
1028 return err
1029 }
1030
1031 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1032 nick := dc.marshalNick(uc, nick)
1033 dc.SendMessage(&irc.Message{
1034 Prefix: dc.srv.prefix(),
1035 Command: irc.RPL_WHOISUSER,
1036 Params: []string{dc.nick, nick, username, host, "*", realname},
1037 })
1038 })
1039 case irc.RPL_WHOISSERVER:
1040 var nick, server, serverInfo string
1041 if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
1042 return err
1043 }
1044
1045 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1046 nick := dc.marshalNick(uc, nick)
1047 dc.SendMessage(&irc.Message{
1048 Prefix: dc.srv.prefix(),
1049 Command: irc.RPL_WHOISSERVER,
1050 Params: []string{dc.nick, nick, server, serverInfo},
1051 })
1052 })
1053 case irc.RPL_WHOISOPERATOR:
1054 var nick string
1055 if err := parseMessageParams(msg, nil, &nick); err != nil {
1056 return err
1057 }
1058
1059 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1060 nick := dc.marshalNick(uc, nick)
1061 dc.SendMessage(&irc.Message{
1062 Prefix: dc.srv.prefix(),
1063 Command: irc.RPL_WHOISOPERATOR,
1064 Params: []string{dc.nick, nick, "is an IRC operator"},
1065 })
1066 })
1067 case irc.RPL_WHOISIDLE:
1068 var nick string
1069 if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
1070 return err
1071 }
1072
1073 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1074 nick := dc.marshalNick(uc, nick)
1075 params := []string{dc.nick, nick}
1076 params = append(params, msg.Params[2:]...)
1077 dc.SendMessage(&irc.Message{
1078 Prefix: dc.srv.prefix(),
1079 Command: irc.RPL_WHOISIDLE,
1080 Params: params,
1081 })
1082 })
1083 case irc.RPL_WHOISCHANNELS:
1084 var nick, channelList string
1085 if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
1086 return err
1087 }
1088 channels := splitSpace(channelList)
1089
1090 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1091 nick := dc.marshalNick(uc, nick)
1092 channelList := make([]string, len(channels))
1093 for i, channel := range channels {
1094 prefix, channel := uc.parseMembershipPrefix(channel)
1095 channel = dc.marshalChannel(uc, channel)
1096 channelList[i] = prefix.String() + channel
1097 }
1098 channels := strings.Join(channelList, " ")
1099 dc.SendMessage(&irc.Message{
1100 Prefix: dc.srv.prefix(),
1101 Command: irc.RPL_WHOISCHANNELS,
1102 Params: []string{dc.nick, nick, channels},
1103 })
1104 })
1105 case irc.RPL_ENDOFWHOIS:
1106 var nick string
1107 if err := parseMessageParams(msg, nil, &nick); err != nil {
1108 return err
1109 }
1110
1111 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1112 nick := dc.marshalNick(uc, nick)
1113 dc.SendMessage(&irc.Message{
1114 Prefix: dc.srv.prefix(),
1115 Command: irc.RPL_ENDOFWHOIS,
1116 Params: []string{dc.nick, nick, "End of /WHOIS list"},
1117 })
1118 })
1119 case "PRIVMSG":
1120 if msg.Prefix == nil {
1121 return fmt.Errorf("expected a prefix")
1122 }
1123
1124 var entity, text string
1125 if err := parseMessageParams(msg, &entity, &text); err != nil {
1126 return err
1127 }
1128
1129 if msg.Prefix.Name == serviceNick {
1130 uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
1131 break
1132 }
1133 if entity == serviceNick {
1134 uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
1135 break
1136 }
1137
1138 target := entity
1139 if target == uc.nick {
1140 target = msg.Prefix.Name
1141 }
1142 uc.appendLog(target, msg)
1143
1144 uc.network.ring.Produce(msg)
1145 case "INVITE":
1146 var nick string
1147 var channel string
1148 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1149 return err
1150 }
1151
1152 uc.forEachDownstream(func(dc *downstreamConn) {
1153 dc.SendMessage(&irc.Message{
1154 Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
1155 Command: "INVITE",
1156 Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1157 })
1158 })
1159 case irc.RPL_INVITING:
1160 var nick string
1161 var channel string
1162 if err := parseMessageParams(msg, &nick, &channel); err != nil {
1163 return err
1164 }
1165
1166 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1167 dc.SendMessage(&irc.Message{
1168 Prefix: dc.srv.prefix(),
1169 Command: irc.RPL_INVITING,
1170 Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
1171 })
1172 })
1173 case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
1174 var command, reason string
1175 if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
1176 return err
1177 }
1178
1179 if command == "LIST" {
1180 ok := uc.endPendingLISTs(false)
1181 if !ok {
1182 return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
1183 }
1184 uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
1185 dc.SendMessage(&irc.Message{
1186 Prefix: uc.srv.prefix(),
1187 Command: msg.Command,
1188 Params: []string{dc.nick, "LIST", reason},
1189 })
1190 })
1191 }
1192 case "TAGMSG":
1193 // TODO: relay to downstream connections that accept message-tags
1194 case "ACK":
1195 // Ignore
1196 case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
1197 // Ignore
1198 case irc.RPL_YOURHOST, irc.RPL_CREATED:
1199 // Ignore
1200 case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
1201 // Ignore
1202 case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
1203 // Ignore
1204 case irc.RPL_LISTSTART:
1205 // Ignore
1206 case rpl_localusers, rpl_globalusers:
1207 // Ignore
1208 case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
1209 // Ignore
1210 default:
1211 uc.logger.Printf("unhandled message: %v", msg)
1212 }
1213 return nil
1214}
1215
1216func splitSpace(s string) []string {
1217 return strings.FieldsFunc(s, func(r rune) bool {
1218 return r == ' '
1219 })
1220}
1221
1222func (uc *upstreamConn) register() {
1223 uc.nick = uc.network.Nick
1224 uc.username = uc.network.Username
1225 if uc.username == "" {
1226 uc.username = uc.nick
1227 }
1228 uc.realname = uc.network.Realname
1229 if uc.realname == "" {
1230 uc.realname = uc.nick
1231 }
1232
1233 uc.SendMessage(&irc.Message{
1234 Command: "CAP",
1235 Params: []string{"LS", "302"},
1236 })
1237
1238 if uc.network.Pass != "" {
1239 uc.SendMessage(&irc.Message{
1240 Command: "PASS",
1241 Params: []string{uc.network.Pass},
1242 })
1243 }
1244
1245 uc.SendMessage(&irc.Message{
1246 Command: "NICK",
1247 Params: []string{uc.nick},
1248 })
1249 uc.SendMessage(&irc.Message{
1250 Command: "USER",
1251 Params: []string{uc.username, "0", "*", uc.realname},
1252 })
1253}
1254
1255func (uc *upstreamConn) runUntilRegistered() error {
1256 for !uc.registered {
1257 msg, err := uc.ReadMessage()
1258 if err != nil {
1259 return fmt.Errorf("failed to read message: %v", err)
1260 }
1261
1262 if err := uc.handleMessage(msg); err != nil {
1263 return fmt.Errorf("failed to handle message %q: %v", msg, err)
1264 }
1265 }
1266
1267 return nil
1268}
1269
1270func (uc *upstreamConn) requestSASL() bool {
1271 if uc.network.SASL.Mechanism == "" {
1272 return false
1273 }
1274
1275 v, ok := uc.caps["sasl"]
1276 if !ok {
1277 return false
1278 }
1279 if v != "" {
1280 mechanisms := strings.Split(v, ",")
1281 found := false
1282 for _, mech := range mechanisms {
1283 if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
1284 found = true
1285 break
1286 }
1287 }
1288 if !found {
1289 return false
1290 }
1291 }
1292
1293 return true
1294}
1295
1296func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
1297 auth := &uc.network.SASL
1298 switch name {
1299 case "sasl":
1300 if !ok {
1301 uc.logger.Printf("server refused to acknowledge the SASL capability")
1302 return nil
1303 }
1304
1305 switch auth.Mechanism {
1306 case "PLAIN":
1307 uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
1308 uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
1309 default:
1310 return fmt.Errorf("unsupported SASL mechanism %q", name)
1311 }
1312
1313 uc.SendMessage(&irc.Message{
1314 Command: "AUTHENTICATE",
1315 Params: []string{auth.Mechanism},
1316 })
1317 case "message-tags":
1318 uc.tagsSupported = ok
1319 case "labeled-response":
1320 uc.labelsSupported = ok
1321 case "batch", "server-time":
1322 // Nothing to do
1323 default:
1324 uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
1325 }
1326 return nil
1327}
1328
1329func (uc *upstreamConn) readMessages(ch chan<- event) error {
1330 for {
1331 msg, err := uc.ReadMessage()
1332 if err == io.EOF {
1333 break
1334 } else if err != nil {
1335 return fmt.Errorf("failed to read IRC command: %v", err)
1336 }
1337
1338 ch <- eventUpstreamMessage{msg, uc}
1339 }
1340
1341 return nil
1342}
1343
1344func (uc *upstreamConn) SendMessageLabeled(downstreamID uint64, msg *irc.Message) {
1345 if uc.labelsSupported {
1346 if msg.Tags == nil {
1347 msg.Tags = make(map[string]irc.TagValue)
1348 }
1349 msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
1350 uc.nextLabelID++
1351 }
1352 uc.SendMessage(msg)
1353}
1354
1355// TODO: handle moving logs when a network name changes, when support for this is added
1356func (uc *upstreamConn) appendLog(entity string, msg *irc.Message) {
1357 if uc.srv.LogPath == "" {
1358 return
1359 }
1360
1361 ml, ok := uc.messageLoggers[entity]
1362 if !ok {
1363 ml = newMessageLogger(uc, entity)
1364 uc.messageLoggers[entity] = ml
1365 }
1366
1367 if err := ml.Append(msg); err != nil {
1368 uc.logger.Printf("failed to log message: %v", err)
1369 }
1370}
1371
1372func (uc *upstreamConn) updateAway() {
1373 away := true
1374 uc.forEachDownstream(func(*downstreamConn) {
1375 away = false
1376 })
1377 if away == uc.away {
1378 return
1379 }
1380 if away {
1381 uc.SendMessage(&irc.Message{
1382 Command: "AWAY",
1383 Params: []string{"Auto away"},
1384 })
1385 } else {
1386 uc.SendMessage(&irc.Message{
1387 Command: "AWAY",
1388 })
1389 }
1390 uc.away = away
1391}
Note: See TracBrowser for help on using the repository browser.