source: code/trunk/service.go@ 818

Last change on this file since 818 was 818, checked in by yakumo.izuru, 2 years ago

Do some tidying

Signed-off-by: Izuru Yakumo <yakumo.izuru@…>
File size: 27.8 KB
Line 
1package suika
2
3import (
4 "context"
5 "crypto/sha1"
6 "crypto/sha256"
7 "crypto/sha512"
8 "encoding/hex"
9 "flag"
10 "fmt"
11 "io/ioutil"
12 "sort"
13 "strconv"
14 "strings"
15 "time"
16 "unicode"
17
18 "golang.org/x/crypto/bcrypt"
19 "gopkg.in/irc.v3"
20)
21
22const (
23 serviceNick = "BouncerServ"
24 serviceNickCM = "bouncerserv"
25 serviceRealname = "suika bouncer service"
26)
27
28// maxRSABits is the maximum number of RSA key bits used when generating a new
29// private key.
30const maxRSABits = 8192
31
32var servicePrefix = &irc.Prefix{
33 Name: serviceNick,
34 User: serviceNick,
35 Host: serviceNick,
36}
37
38type serviceCommandSet map[string]*serviceCommand
39
40type serviceCommand struct {
41 usage string
42 desc string
43 handle func(ctx context.Context, dc *downstreamConn, params []string) error
44 children serviceCommandSet
45 admin bool
46}
47
48func sendServiceNOTICE(dc *downstreamConn, text string) {
49 dc.SendMessage(&irc.Message{
50 Prefix: servicePrefix,
51 Command: "NOTICE",
52 Params: []string{dc.nick, text},
53 })
54}
55
56func sendServicePRIVMSG(dc *downstreamConn, text string) {
57 dc.SendMessage(&irc.Message{
58 Prefix: servicePrefix,
59 Command: "PRIVMSG",
60 Params: []string{dc.nick, text},
61 })
62}
63
64func splitWords(s string) ([]string, error) {
65 var words []string
66 var lastWord strings.Builder
67 escape := false
68 prev := ' '
69 wordDelim := ' '
70
71 for _, r := range s {
72 if escape {
73 // last char was a backslash, write the byte as-is.
74 lastWord.WriteRune(r)
75 escape = false
76 } else if r == '\\' {
77 escape = true
78 } else if wordDelim == ' ' && unicode.IsSpace(r) {
79 // end of last word
80 if !unicode.IsSpace(prev) {
81 words = append(words, lastWord.String())
82 lastWord.Reset()
83 }
84 } else if r == wordDelim {
85 // wordDelim is either " or ', switch back to
86 // space-delimited words.
87 wordDelim = ' '
88 } else if r == '"' || r == '\'' {
89 if wordDelim == ' ' {
90 // start of (double-)quoted word
91 wordDelim = r
92 } else {
93 // either wordDelim is " and r is ' or vice-versa
94 lastWord.WriteRune(r)
95 }
96 } else {
97 lastWord.WriteRune(r)
98 }
99
100 prev = r
101 }
102
103 if !unicode.IsSpace(prev) {
104 words = append(words, lastWord.String())
105 }
106
107 if wordDelim != ' ' {
108 return nil, fmt.Errorf("unterminated quoted string")
109 }
110 if escape {
111 return nil, fmt.Errorf("unterminated backslash sequence")
112 }
113
114 return words, nil
115}
116
117func handleServicePRIVMSG(ctx context.Context, dc *downstreamConn, text string) {
118 words, err := splitWords(text)
119 if err != nil {
120 sendServicePRIVMSG(dc, fmt.Sprintf(`error: failed to parse command: %v`, err))
121 return
122 }
123
124 cmd, params, err := serviceCommands.Get(words)
125 if err != nil {
126 sendServicePRIVMSG(dc, fmt.Sprintf(`error: %v (type "help" for a list of commands)`, err))
127 return
128 }
129 if cmd.admin && !dc.user.Admin {
130 sendServicePRIVMSG(dc, "error: you must be an admin to use this command")
131 return
132 }
133
134 if cmd.handle == nil {
135 if len(cmd.children) > 0 {
136 var l []string
137 appendServiceCommandSetHelp(cmd.children, words, dc.user.Admin, &l)
138 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
139 } else {
140 // Pretend the command does not exist if it has neither children nor handler.
141 // This is obviously a bug but it is better to not die anyway.
142 dc.logger.Printf("command without handler and subcommands invoked:", words[0])
143 sendServicePRIVMSG(dc, fmt.Sprintf("command %q not found", words[0]))
144 }
145 return
146 }
147
148 if err := cmd.handle(ctx, dc, params); err != nil {
149 sendServicePRIVMSG(dc, fmt.Sprintf("error: %v", err))
150 }
151}
152
153func (cmds serviceCommandSet) Get(params []string) (*serviceCommand, []string, error) {
154 if len(params) == 0 {
155 return nil, nil, fmt.Errorf("no command specified")
156 }
157
158 name := params[0]
159 params = params[1:]
160
161 cmd, ok := cmds[name]
162 if !ok {
163 for k := range cmds {
164 if !strings.HasPrefix(k, name) {
165 continue
166 }
167 if cmd != nil {
168 return nil, params, fmt.Errorf("command %q is ambiguous", name)
169 }
170 cmd = cmds[k]
171 }
172 }
173 if cmd == nil {
174 return nil, params, fmt.Errorf("command %q not found", name)
175 }
176
177 if len(params) == 0 || len(cmd.children) == 0 {
178 return cmd, params, nil
179 }
180 return cmd.children.Get(params)
181}
182
183func (cmds serviceCommandSet) Names() []string {
184 l := make([]string, 0, len(cmds))
185 for name := range cmds {
186 l = append(l, name)
187 }
188 sort.Strings(l)
189 return l
190}
191
192var serviceCommands serviceCommandSet
193
194func init() {
195 serviceCommands = serviceCommandSet{
196 "help": {
197 usage: "[command]",
198 desc: "print help message",
199 handle: handleServiceHelp,
200 },
201 "network": {
202 children: serviceCommandSet{
203 "create": {
204 usage: "-addr <addr> [-name name] [-username username] [-pass pass] [-realname realname] [-nick nick] [-enabled enabled] [-connect-command command]...",
205 desc: "add a new network",
206 handle: handleServiceNetworkCreate,
207 },
208 "status": {
209 desc: "show a list of saved networks and their current status",
210 handle: handleServiceNetworkStatus,
211 },
212 "update": {
213 usage: "[name] [-addr addr] [-name name] [-username username] [-pass pass] [-realname realname] [-nick nick] [-enabled enabled] [-connect-command command]...",
214 desc: "update a network",
215 handle: handleServiceNetworkUpdate,
216 },
217 "delete": {
218 usage: "[name]",
219 desc: "delete a network",
220 handle: handleServiceNetworkDelete,
221 },
222 "quote": {
223 usage: "[name] <command>",
224 desc: "send a raw line to a network",
225 handle: handleServiceNetworkQuote,
226 },
227 },
228 },
229 "certfp": {
230 children: serviceCommandSet{
231 "generate": {
232 usage: "[-key-type rsa|ecdsa|ed25519] [-bits N] [-network name]",
233 desc: "generate a new self-signed certificate, defaults to using RSA-3072 key",
234 handle: handleServiceCertFPGenerate,
235 },
236 "fingerprint": {
237 usage: "[-network name]",
238 desc: "show fingerprints of certificate",
239 handle: handleServiceCertFPFingerprints,
240 },
241 },
242 },
243 "sasl": {
244 children: serviceCommandSet{
245 "status": {
246 usage: "[-network name]",
247 desc: "show SASL status",
248 handle: handleServiceSASLStatus,
249 },
250 "set-plain": {
251 usage: "[-network name] <username> <password>",
252 desc: "set SASL PLAIN credentials",
253 handle: handleServiceSASLSetPlain,
254 },
255 "reset": {
256 usage: "[-network name]",
257 desc: "disable SASL authentication and remove stored credentials",
258 handle: handleServiceSASLReset,
259 },
260 },
261 },
262 "user": {
263 children: serviceCommandSet{
264 "create": {
265 usage: "-username <username> -password <password> [-realname <realname>] [-admin]",
266 desc: "create a new suika user",
267 handle: handleUserCreate,
268 admin: true,
269 },
270 "update": {
271 usage: "[-password <password>] [-realname <realname>]",
272 desc: "update the current user",
273 handle: handleUserUpdate,
274 },
275 "delete": {
276 usage: "<username>",
277 desc: "delete a user",
278 handle: handleUserDelete,
279 admin: true,
280 },
281 },
282 },
283 "channel": {
284 children: serviceCommandSet{
285 "status": {
286 usage: "[-network name]",
287 desc: "show a list of saved channels and their current status",
288 handle: handleServiceChannelStatus,
289 },
290 "update": {
291 usage: "<name> [-relay-detached <default|none|highlight|message>] [-reattach-on <default|none|highlight|message>] [-detach-after <duration>] [-detach-on <default|none|highlight|message>]",
292 desc: "update a channel",
293 handle: handleServiceChannelUpdate,
294 },
295 },
296 },
297 "server": {
298 children: serviceCommandSet{
299 "status": {
300 desc: "show server statistics",
301 handle: handleServiceServerStatus,
302 admin: true,
303 },
304 "notice": {
305 desc: "broadcast a notice to all connected bouncer users",
306 handle: handleServiceServerNotice,
307 admin: true,
308 },
309 },
310 admin: true,
311 },
312 }
313}
314
315func appendServiceCommandSetHelp(cmds serviceCommandSet, prefix []string, admin bool, l *[]string) {
316 for _, name := range cmds.Names() {
317 cmd := cmds[name]
318 if cmd.admin && !admin {
319 continue
320 }
321 words := append(prefix, name)
322 if len(cmd.children) == 0 {
323 s := strings.Join(words, " ")
324 *l = append(*l, s)
325 } else {
326 appendServiceCommandSetHelp(cmd.children, words, admin, l)
327 }
328 }
329}
330
331func handleServiceHelp(ctx context.Context, dc *downstreamConn, params []string) error {
332 if len(params) > 0 {
333 cmd, rest, err := serviceCommands.Get(params)
334 if err != nil {
335 return err
336 }
337 words := params[:len(params)-len(rest)]
338
339 if len(cmd.children) > 0 {
340 var l []string
341 appendServiceCommandSetHelp(cmd.children, words, dc.user.Admin, &l)
342 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
343 } else {
344 text := strings.Join(words, " ")
345 if cmd.usage != "" {
346 text += " " + cmd.usage
347 }
348 text += ": " + cmd.desc
349
350 sendServicePRIVMSG(dc, text)
351 }
352 } else {
353 var l []string
354 appendServiceCommandSetHelp(serviceCommands, nil, dc.user.Admin, &l)
355 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
356 }
357 return nil
358}
359
360func newFlagSet() *flag.FlagSet {
361 fs := flag.NewFlagSet("", flag.ContinueOnError)
362 fs.SetOutput(ioutil.Discard)
363 return fs
364}
365
366type stringSliceFlag []string
367
368func (v *stringSliceFlag) String() string {
369 return fmt.Sprint([]string(*v))
370}
371
372func (v *stringSliceFlag) Set(s string) error {
373 *v = append(*v, s)
374 return nil
375}
376
377// stringPtrFlag is a flag value populating a string pointer. This allows to
378// disambiguate between a flag that hasn't been set and a flag that has been
379// set to an empty string.
380type stringPtrFlag struct {
381 ptr **string
382}
383
384func (f stringPtrFlag) String() string {
385 if f.ptr == nil || *f.ptr == nil {
386 return ""
387 }
388 return **f.ptr
389}
390
391func (f stringPtrFlag) Set(s string) error {
392 *f.ptr = &s
393 return nil
394}
395
396type boolPtrFlag struct {
397 ptr **bool
398}
399
400func (f boolPtrFlag) String() string {
401 if f.ptr == nil || *f.ptr == nil {
402 return "<nil>"
403 }
404 return strconv.FormatBool(**f.ptr)
405}
406
407func (f boolPtrFlag) Set(s string) error {
408 v, err := strconv.ParseBool(s)
409 if err != nil {
410 return err
411 }
412 *f.ptr = &v
413 return nil
414}
415
416func getNetworkFromArg(dc *downstreamConn, params []string) (*network, []string, error) {
417 name, params := popArg(params)
418 if name == "" {
419 if dc.network == nil {
420 return nil, params, fmt.Errorf("no network selected, a name argument is required")
421 }
422 return dc.network, params, nil
423 } else {
424 net := dc.user.getNetwork(name)
425 if net == nil {
426 return nil, params, fmt.Errorf("unknown network %q", name)
427 }
428 return net, params, nil
429 }
430}
431
432type networkFlagSet struct {
433 *flag.FlagSet
434 Addr, Name, Nick, Username, Pass, Realname *string
435 Enabled *bool
436 ConnectCommands []string
437}
438
439func newNetworkFlagSet() *networkFlagSet {
440 fs := &networkFlagSet{FlagSet: newFlagSet()}
441 fs.Var(stringPtrFlag{&fs.Addr}, "addr", "")
442 fs.Var(stringPtrFlag{&fs.Name}, "name", "")
443 fs.Var(stringPtrFlag{&fs.Nick}, "nick", "")
444 fs.Var(stringPtrFlag{&fs.Username}, "username", "")
445 fs.Var(stringPtrFlag{&fs.Pass}, "pass", "")
446 fs.Var(stringPtrFlag{&fs.Realname}, "realname", "")
447 fs.Var(boolPtrFlag{&fs.Enabled}, "enabled", "")
448 fs.Var((*stringSliceFlag)(&fs.ConnectCommands), "connect-command", "")
449 return fs
450}
451
452func (fs *networkFlagSet) update(network *Network) error {
453 if fs.Addr != nil {
454 if addrParts := strings.SplitN(*fs.Addr, "://", 2); len(addrParts) == 2 {
455 scheme := addrParts[0]
456 switch scheme {
457 case "ircs", "irc+insecure", "unix":
458 default:
459 return fmt.Errorf("unknown scheme %q (supported schemes: ircs, irc+insecure, unix)", scheme)
460 }
461 }
462 network.Addr = *fs.Addr
463 }
464 if fs.Name != nil {
465 network.Name = *fs.Name
466 }
467 if fs.Nick != nil {
468 network.Nick = *fs.Nick
469 }
470 if fs.Username != nil {
471 network.Username = *fs.Username
472 }
473 if fs.Pass != nil {
474 network.Pass = *fs.Pass
475 }
476 if fs.Realname != nil {
477 network.Realname = *fs.Realname
478 }
479 if fs.Enabled != nil {
480 network.Enabled = *fs.Enabled
481 }
482 if fs.ConnectCommands != nil {
483 if len(fs.ConnectCommands) == 1 && fs.ConnectCommands[0] == "" {
484 network.ConnectCommands = nil
485 } else {
486 for _, command := range fs.ConnectCommands {
487 _, err := irc.ParseMessage(command)
488 if err != nil {
489 return fmt.Errorf("flag -connect-command must be a valid raw irc command string: %q: %v", command, err)
490 }
491 }
492 network.ConnectCommands = fs.ConnectCommands
493 }
494 }
495 return nil
496}
497
498func handleServiceNetworkCreate(ctx context.Context, dc *downstreamConn, params []string) error {
499 fs := newNetworkFlagSet()
500 if err := fs.Parse(params); err != nil {
501 return err
502 }
503 if fs.Addr == nil {
504 return fmt.Errorf("flag -addr is required")
505 }
506
507 record := &Network{
508 Addr: *fs.Addr,
509 Enabled: true,
510 }
511 if err := fs.update(record); err != nil {
512 return err
513 }
514
515 network, err := dc.user.createNetwork(ctx, record)
516 if err != nil {
517 return fmt.Errorf("could not create network: %v", err)
518 }
519
520 sendServicePRIVMSG(dc, fmt.Sprintf("created network %q", network.GetName()))
521 return nil
522}
523
524func handleServiceNetworkStatus(ctx context.Context, dc *downstreamConn, params []string) error {
525 n := 0
526 for _, net := range dc.user.networks {
527 var statuses []string
528 var details string
529 if uc := net.conn; uc != nil {
530 if dc.nick != uc.nick {
531 statuses = append(statuses, "connected as "+uc.nick)
532 } else {
533 statuses = append(statuses, "connected")
534 }
535 details = fmt.Sprintf("%v channels", uc.channels.Len())
536 } else if !net.Enabled {
537 statuses = append(statuses, "disabled")
538 } else {
539 statuses = append(statuses, "disconnected")
540 if net.lastError != nil {
541 details = net.lastError.Error()
542 }
543 }
544
545 if net == dc.network {
546 statuses = append(statuses, "current")
547 }
548
549 name := net.GetName()
550 if name != net.Addr {
551 name = fmt.Sprintf("%v (%v)", name, net.Addr)
552 }
553
554 s := fmt.Sprintf("%v [%v]", name, strings.Join(statuses, ", "))
555 if details != "" {
556 s += ": " + details
557 }
558 sendServicePRIVMSG(dc, s)
559
560 n++
561 }
562
563 if n == 0 {
564 sendServicePRIVMSG(dc, `No network configured, add one with "network create".`)
565 }
566
567 return nil
568}
569
570func handleServiceNetworkUpdate(ctx context.Context, dc *downstreamConn, params []string) error {
571 net, params, err := getNetworkFromArg(dc, params)
572 if err != nil {
573 return err
574 }
575
576 fs := newNetworkFlagSet()
577 if err := fs.Parse(params); err != nil {
578 return err
579 }
580
581 record := net.Network // copy network record because we'll mutate it
582 if err := fs.update(&record); err != nil {
583 return err
584 }
585
586 network, err := dc.user.updateNetwork(ctx, &record)
587 if err != nil {
588 return fmt.Errorf("could not update network: %v", err)
589 }
590
591 sendServicePRIVMSG(dc, fmt.Sprintf("updated network %q", network.GetName()))
592 return nil
593}
594
595func handleServiceNetworkDelete(ctx context.Context, dc *downstreamConn, params []string) error {
596 net, params, err := getNetworkFromArg(dc, params)
597 if err != nil {
598 return err
599 }
600
601 if err := dc.user.deleteNetwork(ctx, net.ID); err != nil {
602 return err
603 }
604
605 sendServicePRIVMSG(dc, fmt.Sprintf("deleted network %q", net.GetName()))
606 return nil
607}
608
609func handleServiceNetworkQuote(ctx context.Context, dc *downstreamConn, params []string) error {
610 if len(params) != 1 && len(params) != 2 {
611 return fmt.Errorf("expected one or two arguments")
612 }
613
614 raw := params[len(params)-1]
615 params = params[:len(params)-1]
616
617 net, params, err := getNetworkFromArg(dc, params)
618 if err != nil {
619 return err
620 }
621
622 uc := net.conn
623 if uc == nil {
624 return fmt.Errorf("network %q is not currently connected", net.GetName())
625 }
626
627 m, err := irc.ParseMessage(raw)
628 if err != nil {
629 return fmt.Errorf("failed to parse command %q: %v", raw, err)
630 }
631 uc.SendMessage(ctx, m)
632
633 sendServicePRIVMSG(dc, fmt.Sprintf("sent command to %q", net.GetName()))
634 return nil
635}
636
637func sendCertfpFingerprints(dc *downstreamConn, cert []byte) {
638 sha1Sum := sha1.Sum(cert)
639 sendServicePRIVMSG(dc, "SHA-1 fingerprint: "+hex.EncodeToString(sha1Sum[:]))
640 sha256Sum := sha256.Sum256(cert)
641 sendServicePRIVMSG(dc, "SHA-256 fingerprint: "+hex.EncodeToString(sha256Sum[:]))
642 sha512Sum := sha512.Sum512(cert)
643 sendServicePRIVMSG(dc, "SHA-512 fingerprint: "+hex.EncodeToString(sha512Sum[:]))
644}
645
646func getNetworkFromFlag(dc *downstreamConn, name string) (*network, error) {
647 if name == "" {
648 if dc.network == nil {
649 return nil, fmt.Errorf("no network selected, -network is required")
650 }
651 return dc.network, nil
652 } else {
653 net := dc.user.getNetwork(name)
654 if net == nil {
655 return nil, fmt.Errorf("unknown network %q", name)
656 }
657 return net, nil
658 }
659}
660
661func handleServiceCertFPGenerate(ctx context.Context, dc *downstreamConn, params []string) error {
662 fs := newFlagSet()
663 netName := fs.String("network", "", "select a network")
664 keyType := fs.String("key-type", "rsa", "key type to generate (rsa, ecdsa, ed25519)")
665 bits := fs.Int("bits", 3072, "size of key to generate, meaningful only for RSA")
666
667 if err := fs.Parse(params); err != nil {
668 return err
669 }
670
671 if *bits <= 0 || *bits > maxRSABits {
672 return fmt.Errorf("invalid value for -bits")
673 }
674
675 net, err := getNetworkFromFlag(dc, *netName)
676 if err != nil {
677 return err
678 }
679
680 privKey, cert, err := generateCertFP(*keyType, *bits)
681 if err != nil {
682 return err
683 }
684
685 net.SASL.External.CertBlob = cert
686 net.SASL.External.PrivKeyBlob = privKey
687 net.SASL.Mechanism = "EXTERNAL"
688
689 if err := dc.srv.db.StoreNetwork(ctx, dc.user.ID, &net.Network); err != nil {
690 return err
691 }
692
693 sendServicePRIVMSG(dc, "certificate generated")
694 sendCertfpFingerprints(dc, cert)
695 return nil
696}
697
698func handleServiceCertFPFingerprints(ctx context.Context, dc *downstreamConn, params []string) error {
699 fs := newFlagSet()
700 netName := fs.String("network", "", "select a network")
701
702 if err := fs.Parse(params); err != nil {
703 return err
704 }
705
706 net, err := getNetworkFromFlag(dc, *netName)
707 if err != nil {
708 return err
709 }
710
711 if net.SASL.Mechanism != "EXTERNAL" {
712 return fmt.Errorf("CertFP not set up")
713 }
714
715 sendCertfpFingerprints(dc, net.SASL.External.CertBlob)
716 return nil
717}
718
719func handleServiceSASLStatus(ctx context.Context, dc *downstreamConn, params []string) error {
720 fs := newFlagSet()
721 netName := fs.String("network", "", "select a network")
722
723 if err := fs.Parse(params); err != nil {
724 return err
725 }
726
727 net, err := getNetworkFromFlag(dc, *netName)
728 if err != nil {
729 return err
730 }
731
732 switch net.SASL.Mechanism {
733 case "PLAIN":
734 sendServicePRIVMSG(dc, fmt.Sprintf("SASL PLAIN enabled with username %q", net.SASL.Plain.Username))
735 case "EXTERNAL":
736 sendServicePRIVMSG(dc, "SASL EXTERNAL (CertFP) enabled")
737 case "":
738 sendServicePRIVMSG(dc, "SASL is disabled")
739 }
740
741 if uc := net.conn; uc != nil {
742 if uc.account != "" {
743 sendServicePRIVMSG(dc, fmt.Sprintf("Authenticated on upstream network with account %q", uc.account))
744 } else {
745 sendServicePRIVMSG(dc, "Unauthenticated on upstream network")
746 }
747 } else {
748 sendServicePRIVMSG(dc, "Disconnected from upstream network")
749 }
750
751 return nil
752}
753
754func handleServiceSASLSetPlain(ctx context.Context, dc *downstreamConn, params []string) error {
755 fs := newFlagSet()
756 netName := fs.String("network", "", "select a network")
757
758 if err := fs.Parse(params); err != nil {
759 return err
760 }
761
762 if len(fs.Args()) != 2 {
763 return fmt.Errorf("expected exactly 2 arguments")
764 }
765
766 net, err := getNetworkFromFlag(dc, *netName)
767 if err != nil {
768 return err
769 }
770
771 net.SASL.Plain.Username = fs.Arg(0)
772 net.SASL.Plain.Password = fs.Arg(1)
773 net.SASL.Mechanism = "PLAIN"
774
775 if err := dc.srv.db.StoreNetwork(ctx, dc.user.ID, &net.Network); err != nil {
776 return err
777 }
778
779 sendServicePRIVMSG(dc, "credentials saved")
780 return nil
781}
782
783func handleServiceSASLReset(ctx context.Context, dc *downstreamConn, params []string) error {
784 fs := newFlagSet()
785 netName := fs.String("network", "", "select a network")
786
787 if err := fs.Parse(params); err != nil {
788 return err
789 }
790
791 net, err := getNetworkFromFlag(dc, *netName)
792 if err != nil {
793 return err
794 }
795
796 net.SASL.Plain.Username = ""
797 net.SASL.Plain.Password = ""
798 net.SASL.External.CertBlob = nil
799 net.SASL.External.PrivKeyBlob = nil
800 net.SASL.Mechanism = ""
801
802 if err := dc.srv.db.StoreNetwork(ctx, dc.user.ID, &net.Network); err != nil {
803 return err
804 }
805
806 sendServicePRIVMSG(dc, "credentials reset")
807 return nil
808}
809
810func handleUserCreate(ctx context.Context, dc *downstreamConn, params []string) error {
811 fs := newFlagSet()
812 username := fs.String("username", "", "")
813 password := fs.String("password", "", "")
814 realname := fs.String("realname", "", "")
815 admin := fs.Bool("admin", false, "")
816
817 if err := fs.Parse(params); err != nil {
818 return err
819 }
820 if *username == "" {
821 return fmt.Errorf("flag -username is required")
822 }
823 if *password == "" {
824 return fmt.Errorf("flag -password is required")
825 }
826
827 hashed, err := bcrypt.GenerateFromPassword([]byte(*password), bcrypt.DefaultCost)
828 if err != nil {
829 return fmt.Errorf("failed to hash password: %v", err)
830 }
831
832 user := &User{
833 Username: *username,
834 Password: string(hashed),
835 Realname: *realname,
836 Admin: *admin,
837 }
838 if _, err := dc.srv.createUser(ctx, user); err != nil {
839 return fmt.Errorf("could not create user: %v", err)
840 }
841
842 sendServicePRIVMSG(dc, fmt.Sprintf("created user %q", *username))
843 return nil
844}
845
846func popArg(params []string) (string, []string) {
847 if len(params) > 0 && !strings.HasPrefix(params[0], "-") {
848 return params[0], params[1:]
849 }
850 return "", params
851}
852
853func handleUserUpdate(ctx context.Context, dc *downstreamConn, params []string) error {
854 var password, realname *string
855 var admin *bool
856 fs := newFlagSet()
857 fs.Var(stringPtrFlag{&password}, "password", "")
858 fs.Var(stringPtrFlag{&realname}, "realname", "")
859 fs.Var(boolPtrFlag{&admin}, "admin", "")
860
861 username, params := popArg(params)
862 if err := fs.Parse(params); err != nil {
863 return err
864 }
865 if len(fs.Args()) > 0 {
866 return fmt.Errorf("unexpected argument")
867 }
868
869 var hashed *string
870 if password != nil {
871 hashedBytes, err := bcrypt.GenerateFromPassword([]byte(*password), bcrypt.DefaultCost)
872 if err != nil {
873 return fmt.Errorf("failed to hash password: %v", err)
874 }
875 hashedStr := string(hashedBytes)
876 hashed = &hashedStr
877 }
878
879 if username != "" && username != dc.user.Username {
880 if !dc.user.Admin {
881 return fmt.Errorf("you must be an admin to update other users")
882 }
883 if realname != nil {
884 return fmt.Errorf("cannot update -realname of other user")
885 }
886
887 u := dc.srv.getUser(username)
888 if u == nil {
889 return fmt.Errorf("unknown username %q", username)
890 }
891
892 done := make(chan error, 1)
893 event := eventUserUpdate{
894 password: hashed,
895 admin: admin,
896 done: done,
897 }
898 select {
899 case <-ctx.Done():
900 return ctx.Err()
901 case u.events <- event:
902 }
903 // TODO: send context to the other side
904 if err := <-done; err != nil {
905 return err
906 }
907
908 sendServicePRIVMSG(dc, fmt.Sprintf("updated user %q", username))
909 } else {
910 // copy the user record because we'll mutate it
911 record := dc.user.User
912
913 if hashed != nil {
914 record.Password = *hashed
915 }
916 if realname != nil {
917 record.Realname = *realname
918 }
919 if admin != nil {
920 return fmt.Errorf("cannot update -admin of own user")
921 }
922
923 if err := dc.user.updateUser(ctx, &record); err != nil {
924 return err
925 }
926
927 sendServicePRIVMSG(dc, fmt.Sprintf("updated user %q", dc.user.Username))
928 }
929
930 return nil
931}
932
933func handleUserDelete(ctx context.Context, dc *downstreamConn, params []string) error {
934 if len(params) != 1 {
935 return fmt.Errorf("expected exactly one argument")
936 }
937 username := params[0]
938
939 u := dc.srv.getUser(username)
940 if u == nil {
941 return fmt.Errorf("unknown username %q", username)
942 }
943
944 u.stop()
945
946 if err := dc.srv.db.DeleteUser(ctx, u.ID); err != nil {
947 return fmt.Errorf("failed to delete user: %v", err)
948 }
949
950 sendServicePRIVMSG(dc, fmt.Sprintf("deleted user %q", username))
951 return nil
952}
953
954func handleServiceChannelStatus(ctx context.Context, dc *downstreamConn, params []string) error {
955 var defaultNetworkName string
956 if dc.network != nil {
957 defaultNetworkName = dc.network.GetName()
958 }
959
960 fs := newFlagSet()
961 networkName := fs.String("network", defaultNetworkName, "")
962
963 if err := fs.Parse(params); err != nil {
964 return err
965 }
966
967 n := 0
968
969 sendNetwork := func(net *network) {
970 var channels []*Channel
971 for _, entry := range net.channels.innerMap {
972 channels = append(channels, entry.value.(*Channel))
973 }
974
975 sort.Slice(channels, func(i, j int) bool {
976 return strings.ReplaceAll(channels[i].Name, "#", "") <
977 strings.ReplaceAll(channels[j].Name, "#", "")
978 })
979
980 for _, ch := range channels {
981 var uch *upstreamChannel
982 if net.conn != nil {
983 uch = net.conn.channels.Value(ch.Name)
984 }
985
986 name := ch.Name
987 if *networkName == "" {
988 name += "/" + net.GetName()
989 }
990
991 var status string
992 if uch != nil {
993 status = "joined"
994 } else if net.conn != nil {
995 status = "parted"
996 } else {
997 status = "disconnected"
998 }
999
1000 if ch.Detached {
1001 status += ", detached"
1002 }
1003
1004 s := fmt.Sprintf("%v [%v]", name, status)
1005 sendServicePRIVMSG(dc, s)
1006
1007 n++
1008 }
1009 }
1010
1011 if *networkName == "" {
1012 for _, net := range dc.user.networks {
1013 sendNetwork(net)
1014 }
1015 } else {
1016 net := dc.user.getNetwork(*networkName)
1017 if net == nil {
1018 return fmt.Errorf("unknown network %q", *networkName)
1019 }
1020 sendNetwork(net)
1021 }
1022
1023 if n == 0 {
1024 sendServicePRIVMSG(dc, "No channel configured.")
1025 }
1026
1027 return nil
1028}
1029
1030type channelFlagSet struct {
1031 *flag.FlagSet
1032 RelayDetached, ReattachOn, DetachAfter, DetachOn *string
1033}
1034
1035func newChannelFlagSet() *channelFlagSet {
1036 fs := &channelFlagSet{FlagSet: newFlagSet()}
1037 fs.Var(stringPtrFlag{&fs.RelayDetached}, "relay-detached", "")
1038 fs.Var(stringPtrFlag{&fs.ReattachOn}, "reattach-on", "")
1039 fs.Var(stringPtrFlag{&fs.DetachAfter}, "detach-after", "")
1040 fs.Var(stringPtrFlag{&fs.DetachOn}, "detach-on", "")
1041 return fs
1042}
1043
1044func (fs *channelFlagSet) update(channel *Channel) error {
1045 if fs.RelayDetached != nil {
1046 filter, err := parseFilter(*fs.RelayDetached)
1047 if err != nil {
1048 return err
1049 }
1050 channel.RelayDetached = filter
1051 }
1052 if fs.ReattachOn != nil {
1053 filter, err := parseFilter(*fs.ReattachOn)
1054 if err != nil {
1055 return err
1056 }
1057 channel.ReattachOn = filter
1058 }
1059 if fs.DetachAfter != nil {
1060 dur, err := time.ParseDuration(*fs.DetachAfter)
1061 if err != nil || dur < 0 {
1062 return fmt.Errorf("unknown duration for -detach-after %q (duration format: 0, 300s, 22h30m, ...)", *fs.DetachAfter)
1063 }
1064 channel.DetachAfter = dur
1065 }
1066 if fs.DetachOn != nil {
1067 filter, err := parseFilter(*fs.DetachOn)
1068 if err != nil {
1069 return err
1070 }
1071 channel.DetachOn = filter
1072 }
1073 return nil
1074}
1075
1076func handleServiceChannelUpdate(ctx context.Context, dc *downstreamConn, params []string) error {
1077 if len(params) < 1 {
1078 return fmt.Errorf("expected at least one argument")
1079 }
1080 name := params[0]
1081
1082 fs := newChannelFlagSet()
1083 if err := fs.Parse(params[1:]); err != nil {
1084 return err
1085 }
1086
1087 uc, upstreamName, err := dc.unmarshalEntity(name)
1088 if err != nil {
1089 return fmt.Errorf("unknown channel %q", name)
1090 }
1091
1092 ch := uc.network.channels.Value(upstreamName)
1093 if ch == nil {
1094 return fmt.Errorf("unknown channel %q", name)
1095 }
1096
1097 if err := fs.update(ch); err != nil {
1098 return err
1099 }
1100
1101 uc.updateChannelAutoDetach(upstreamName)
1102
1103 if err := dc.srv.db.StoreChannel(ctx, uc.network.ID, ch); err != nil {
1104 return fmt.Errorf("failed to update channel: %v", err)
1105 }
1106
1107 sendServicePRIVMSG(dc, fmt.Sprintf("updated channel %q", name))
1108 return nil
1109}
1110
1111func handleServiceServerStatus(ctx context.Context, dc *downstreamConn, params []string) error {
1112 dbStats, err := dc.user.srv.db.Stats(ctx)
1113 if err != nil {
1114 return err
1115 }
1116 serverStats := dc.user.srv.Stats()
1117 sendServicePRIVMSG(dc, fmt.Sprintf("%v/%v users, %v downstreams, %v upstreams, %v networks, %v channels", serverStats.Users, dbStats.Users, serverStats.Downstreams, serverStats.Upstreams, dbStats.Networks, dbStats.Channels))
1118 return nil
1119}
1120
1121func handleServiceServerNotice(ctx context.Context, dc *downstreamConn, params []string) error {
1122 if len(params) != 1 {
1123 return fmt.Errorf("expected exactly one argument")
1124 }
1125 text := params[0]
1126
1127 dc.logger.Printf("broadcasting bouncer-wide NOTICE: %v", text)
1128
1129 broadcastMsg := &irc.Message{
1130 Prefix: servicePrefix,
1131 Command: "NOTICE",
1132 Params: []string{"$" + dc.srv.Config().Hostname, text},
1133 }
1134 var err error
1135 sent := 0
1136 total := 0
1137 dc.srv.forEachUser(func(u *user) {
1138 total++
1139 select {
1140 case <-ctx.Done():
1141 err = ctx.Err()
1142 case u.events <- eventBroadcast{broadcastMsg}:
1143 sent++
1144 }
1145 })
1146
1147 dc.logger.Printf("broadcast bouncer-wide NOTICE to %v/%v downstreams", sent, total)
1148 sendServicePRIVMSG(dc, fmt.Sprintf("sent to %v/%v downstream connections", sent, total))
1149
1150 return err
1151}
Note: See TracBrowser for help on using the repository browser.