source: code/trunk/upstream.go@ 139

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

Add MODE arguments support

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