source: code/trunk/upstream.go@ 174

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

Fix parsing wrong empty element in RPL_WHOISCHANNELS channel list

Some servers add a trailing space to the channel list in
RPL_WHOISCHANNELS. This commit works around this issue by removing any
empty trailing element after splitting.

Since RPL_WHOISCHANNELS could send an empty channel parameter, we can't
just use strings.TrimRight(s, " "), because splitting on an empty string
would still return an empty element.

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