source: code/trunk/upstream.go@ 155

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

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