source: code/trunk/service.go@ 566

Last change on this file since 566 was 566, checked in by hubert, 4 years ago

Hand-made word splitter for BouncerServ

Remove the (direct) dependency on shlex (go-scfg still depends on it).

Co-authored-by: Simon Ser <contact@…>
File size: 22.6 KB
Line 
1package soju
2
3import (
4 "crypto"
5 "crypto/ecdsa"
6 "crypto/ed25519"
7 "crypto/elliptic"
8 "crypto/rand"
9 "crypto/rsa"
10 "crypto/sha1"
11 "crypto/sha256"
12 "crypto/x509"
13 "crypto/x509/pkix"
14 "encoding/hex"
15 "errors"
16 "flag"
17 "fmt"
18 "io/ioutil"
19 "math/big"
20 "sort"
21 "strconv"
22 "strings"
23 "time"
24 "unicode"
25
26 "golang.org/x/crypto/bcrypt"
27 "gopkg.in/irc.v3"
28)
29
30const serviceNick = "BouncerServ"
31const serviceNickCM = "bouncerserv"
32const serviceRealname = "soju bouncer service"
33
34var servicePrefix = &irc.Prefix{
35 Name: serviceNick,
36 User: serviceNick,
37 Host: serviceNick,
38}
39
40type serviceCommandSet map[string]*serviceCommand
41
42type serviceCommand struct {
43 usage string
44 desc string
45 handle func(dc *downstreamConn, params []string) error
46 children serviceCommandSet
47 admin bool
48}
49
50func sendServiceNOTICE(dc *downstreamConn, text string) {
51 dc.SendMessage(&irc.Message{
52 Prefix: servicePrefix,
53 Command: "NOTICE",
54 Params: []string{dc.nick, text},
55 })
56}
57
58func sendServicePRIVMSG(dc *downstreamConn, text string) {
59 dc.SendMessage(&irc.Message{
60 Prefix: servicePrefix,
61 Command: "PRIVMSG",
62 Params: []string{dc.nick, text},
63 })
64}
65
66func splitWords(s string) ([]string, error) {
67 var words []string
68 var lastWord strings.Builder
69 escape := false
70 prev := ' '
71 wordDelim := ' '
72
73 for _, r := range s {
74 if escape {
75 // last char was a backslash, write the byte as-is.
76 lastWord.WriteRune(r)
77 escape = false
78 } else if r == '\\' {
79 escape = true
80 } else if wordDelim == ' ' && unicode.IsSpace(r) {
81 // end of last word
82 if !unicode.IsSpace(prev) {
83 words = append(words, lastWord.String())
84 lastWord.Reset()
85 }
86 } else if r == wordDelim {
87 // wordDelim is either " or ', switch back to
88 // space-delimited words.
89 wordDelim = ' '
90 } else if r == '"' || r == '\'' {
91 if wordDelim == ' ' {
92 // start of (double-)quoted word
93 wordDelim = r
94 } else {
95 // either wordDelim is " and r is ' or vice-versa
96 lastWord.WriteRune(r)
97 }
98 } else {
99 lastWord.WriteRune(r)
100 }
101
102 prev = r
103 }
104
105 if !unicode.IsSpace(prev) {
106 words = append(words, lastWord.String())
107 }
108
109 if wordDelim != ' ' {
110 return nil, fmt.Errorf("unterminated quoted string")
111 }
112 if escape {
113 return nil, fmt.Errorf("unterminated backslash sequence")
114 }
115
116 return words, nil
117}
118
119func handleServicePRIVMSG(dc *downstreamConn, text string) {
120 words, err := splitWords(text)
121 if err != nil {
122 sendServicePRIVMSG(dc, fmt.Sprintf(`error: failed to parse command: %v`, err))
123 return
124 }
125
126 cmd, params, err := serviceCommands.Get(words)
127 if err != nil {
128 sendServicePRIVMSG(dc, fmt.Sprintf(`error: %v (type "help" for a list of commands)`, err))
129 return
130 }
131 if cmd.admin && !dc.user.Admin {
132 sendServicePRIVMSG(dc, fmt.Sprintf(`error: you must be an admin to use this command`))
133 return
134 }
135
136 if cmd.handle == nil {
137 if len(cmd.children) > 0 {
138 var l []string
139 appendServiceCommandSetHelp(cmd.children, words, dc.user.Admin, &l)
140 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
141 } else {
142 // Pretend the command does not exist if it has neither children nor handler.
143 // This is obviously a bug but it is better to not die anyway.
144 dc.logger.Printf("command without handler and subcommands invoked:", words[0])
145 sendServicePRIVMSG(dc, fmt.Sprintf("command %q not found", words[0]))
146 }
147 return
148 }
149
150 if err := cmd.handle(dc, params); err != nil {
151 sendServicePRIVMSG(dc, fmt.Sprintf("error: %v", err))
152 }
153}
154
155func (cmds serviceCommandSet) Get(params []string) (*serviceCommand, []string, error) {
156 if len(params) == 0 {
157 return nil, nil, fmt.Errorf("no command specified")
158 }
159
160 name := params[0]
161 params = params[1:]
162
163 cmd, ok := cmds[name]
164 if !ok {
165 for k := range cmds {
166 if !strings.HasPrefix(k, name) {
167 continue
168 }
169 if cmd != nil {
170 return nil, params, fmt.Errorf("command %q is ambiguous", name)
171 }
172 cmd = cmds[k]
173 }
174 }
175 if cmd == nil {
176 return nil, params, fmt.Errorf("command %q not found", name)
177 }
178
179 if len(params) == 0 || len(cmd.children) == 0 {
180 return cmd, params, nil
181 }
182 return cmd.children.Get(params)
183}
184
185func (cmds serviceCommandSet) Names() []string {
186 l := make([]string, 0, len(cmds))
187 for name := range cmds {
188 l = append(l, name)
189 }
190 sort.Strings(l)
191 return l
192}
193
194var serviceCommands serviceCommandSet
195
196func init() {
197 serviceCommands = serviceCommandSet{
198 "help": {
199 usage: "[command]",
200 desc: "print help message",
201 handle: handleServiceHelp,
202 },
203 "network": {
204 children: serviceCommandSet{
205 "create": {
206 usage: "-addr <addr> [-name name] [-username username] [-pass pass] [-realname realname] [-nick nick] [-enabled enabled] [-connect-command command]...",
207 desc: "add a new network",
208 handle: handleServiceNetworkCreate,
209 },
210 "status": {
211 desc: "show a list of saved networks and their current status",
212 handle: handleServiceNetworkStatus,
213 },
214 "update": {
215 usage: "<name> [-addr addr] [-name name] [-username username] [-pass pass] [-realname realname] [-nick nick] [-enabled enabled] [-connect-command command]...",
216 desc: "update a network",
217 handle: handleServiceNetworkUpdate,
218 },
219 "delete": {
220 usage: "<name>",
221 desc: "delete a network",
222 handle: handleServiceNetworkDelete,
223 },
224 },
225 },
226 "certfp": {
227 children: serviceCommandSet{
228 "generate": {
229 usage: "[-key-type rsa|ecdsa|ed25519] [-bits N] <network name>",
230 desc: "generate a new self-signed certificate, defaults to using RSA-3072 key",
231 handle: handleServiceCertfpGenerate,
232 },
233 "fingerprint": {
234 usage: "<network name>",
235 desc: "show fingerprints of certificate associated with the network",
236 handle: handleServiceCertfpFingerprints,
237 },
238 },
239 },
240 "sasl": {
241 children: serviceCommandSet{
242 "set-plain": {
243 usage: "<network name> <username> <password>",
244 desc: "set SASL PLAIN credentials",
245 handle: handleServiceSASLSetPlain,
246 },
247 "reset": {
248 usage: "<network name>",
249 desc: "disable SASL authentication and remove stored credentials",
250 handle: handleServiceSASLReset,
251 },
252 },
253 },
254 "user": {
255 children: serviceCommandSet{
256 "create": {
257 usage: "-username <username> -password <password> [-admin]",
258 desc: "create a new soju user",
259 handle: handleUserCreate,
260 admin: true,
261 },
262 "delete": {
263 usage: "<username>",
264 desc: "delete a user",
265 handle: handleUserDelete,
266 admin: true,
267 },
268 },
269 admin: true,
270 },
271 "change-password": {
272 usage: "<new password>",
273 desc: "change your password",
274 handle: handlePasswordChange,
275 },
276 "channel": {
277 children: serviceCommandSet{
278 "status": {
279 usage: "[-network name]",
280 desc: "show a list of saved channels and their current status",
281 handle: handleServiceChannelStatus,
282 },
283 "update": {
284 usage: "<name> [-relay-detached <default|none|highlight|message>] [-reattach-on <default|none|highlight|message>] [-detach-after <duration>] [-detach-on <default|none|highlight|message>]",
285 desc: "update a channel",
286 handle: handleServiceChannelUpdate,
287 },
288 },
289 },
290 }
291}
292
293func appendServiceCommandSetHelp(cmds serviceCommandSet, prefix []string, admin bool, l *[]string) {
294 for _, name := range cmds.Names() {
295 cmd := cmds[name]
296 if cmd.admin && !admin {
297 continue
298 }
299 words := append(prefix, name)
300 if len(cmd.children) == 0 {
301 s := strings.Join(words, " ")
302 *l = append(*l, s)
303 } else {
304 appendServiceCommandSetHelp(cmd.children, words, admin, l)
305 }
306 }
307}
308
309func handleServiceHelp(dc *downstreamConn, params []string) error {
310 if len(params) > 0 {
311 cmd, rest, err := serviceCommands.Get(params)
312 if err != nil {
313 return err
314 }
315 words := params[:len(params)-len(rest)]
316
317 if len(cmd.children) > 0 {
318 var l []string
319 appendServiceCommandSetHelp(cmd.children, words, dc.user.Admin, &l)
320 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
321 } else {
322 text := strings.Join(words, " ")
323 if cmd.usage != "" {
324 text += " " + cmd.usage
325 }
326 text += ": " + cmd.desc
327
328 sendServicePRIVMSG(dc, text)
329 }
330 } else {
331 var l []string
332 appendServiceCommandSetHelp(serviceCommands, nil, dc.user.Admin, &l)
333 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
334 }
335 return nil
336}
337
338func newFlagSet() *flag.FlagSet {
339 fs := flag.NewFlagSet("", flag.ContinueOnError)
340 fs.SetOutput(ioutil.Discard)
341 return fs
342}
343
344type stringSliceFlag []string
345
346func (v *stringSliceFlag) String() string {
347 return fmt.Sprint([]string(*v))
348}
349
350func (v *stringSliceFlag) Set(s string) error {
351 *v = append(*v, s)
352 return nil
353}
354
355// stringPtrFlag is a flag value populating a string pointer. This allows to
356// disambiguate between a flag that hasn't been set and a flag that has been
357// set to an empty string.
358type stringPtrFlag struct {
359 ptr **string
360}
361
362func (f stringPtrFlag) String() string {
363 if f.ptr == nil || *f.ptr == nil {
364 return ""
365 }
366 return **f.ptr
367}
368
369func (f stringPtrFlag) Set(s string) error {
370 *f.ptr = &s
371 return nil
372}
373
374type boolPtrFlag struct {
375 ptr **bool
376}
377
378func (f boolPtrFlag) String() string {
379 if f.ptr == nil || *f.ptr == nil {
380 return "<nil>"
381 }
382 return strconv.FormatBool(**f.ptr)
383}
384
385func (f boolPtrFlag) Set(s string) error {
386 v, err := strconv.ParseBool(s)
387 if err != nil {
388 return err
389 }
390 *f.ptr = &v
391 return nil
392}
393
394type networkFlagSet struct {
395 *flag.FlagSet
396 Addr, Name, Nick, Username, Pass, Realname *string
397 Enabled *bool
398 ConnectCommands []string
399}
400
401func newNetworkFlagSet() *networkFlagSet {
402 fs := &networkFlagSet{FlagSet: newFlagSet()}
403 fs.Var(stringPtrFlag{&fs.Addr}, "addr", "")
404 fs.Var(stringPtrFlag{&fs.Name}, "name", "")
405 fs.Var(stringPtrFlag{&fs.Nick}, "nick", "")
406 fs.Var(stringPtrFlag{&fs.Username}, "username", "")
407 fs.Var(stringPtrFlag{&fs.Pass}, "pass", "")
408 fs.Var(stringPtrFlag{&fs.Realname}, "realname", "")
409 fs.Var(boolPtrFlag{&fs.Enabled}, "enabled", "")
410 fs.Var((*stringSliceFlag)(&fs.ConnectCommands), "connect-command", "")
411 return fs
412}
413
414func (fs *networkFlagSet) update(network *Network) error {
415 if fs.Addr != nil {
416 if addrParts := strings.SplitN(*fs.Addr, "://", 2); len(addrParts) == 2 {
417 scheme := addrParts[0]
418 switch scheme {
419 case "ircs", "irc+insecure", "unix":
420 default:
421 return fmt.Errorf("unknown scheme %q (supported schemes: ircs, irc+insecure, unix)", scheme)
422 }
423 }
424 network.Addr = *fs.Addr
425 }
426 if fs.Name != nil {
427 network.Name = *fs.Name
428 }
429 if fs.Nick != nil {
430 network.Nick = *fs.Nick
431 }
432 if fs.Username != nil {
433 network.Username = *fs.Username
434 }
435 if fs.Pass != nil {
436 network.Pass = *fs.Pass
437 }
438 if fs.Realname != nil {
439 network.Realname = *fs.Realname
440 }
441 if fs.Enabled != nil {
442 network.Enabled = *fs.Enabled
443 }
444 if fs.ConnectCommands != nil {
445 if len(fs.ConnectCommands) == 1 && fs.ConnectCommands[0] == "" {
446 network.ConnectCommands = nil
447 } else {
448 for _, command := range fs.ConnectCommands {
449 _, err := irc.ParseMessage(command)
450 if err != nil {
451 return fmt.Errorf("flag -connect-command must be a valid raw irc command string: %q: %v", command, err)
452 }
453 }
454 network.ConnectCommands = fs.ConnectCommands
455 }
456 }
457 return nil
458}
459
460func handleServiceNetworkCreate(dc *downstreamConn, params []string) error {
461 fs := newNetworkFlagSet()
462 if err := fs.Parse(params); err != nil {
463 return err
464 }
465 if fs.Addr == nil {
466 return fmt.Errorf("flag -addr is required")
467 }
468
469 record := &Network{
470 Addr: *fs.Addr,
471 Nick: dc.nick,
472 Enabled: true,
473 }
474 if err := fs.update(record); err != nil {
475 return err
476 }
477
478 network, err := dc.user.createNetwork(record)
479 if err != nil {
480 return fmt.Errorf("could not create network: %v", err)
481 }
482
483 sendServicePRIVMSG(dc, fmt.Sprintf("created network %q", network.GetName()))
484 return nil
485}
486
487func handleServiceNetworkStatus(dc *downstreamConn, params []string) error {
488 n := 0
489 dc.user.forEachNetwork(func(net *network) {
490 var statuses []string
491 var details string
492 if uc := net.conn; uc != nil {
493 if dc.nick != uc.nick {
494 statuses = append(statuses, "connected as "+uc.nick)
495 } else {
496 statuses = append(statuses, "connected")
497 }
498 details = fmt.Sprintf("%v channels", uc.channels.Len())
499 } else if !net.Enabled {
500 statuses = append(statuses, "disabled")
501 } else {
502 statuses = append(statuses, "disconnected")
503 if net.lastError != nil {
504 details = net.lastError.Error()
505 }
506 }
507
508 if net == dc.network {
509 statuses = append(statuses, "current")
510 }
511
512 name := net.GetName()
513 if name != net.Addr {
514 name = fmt.Sprintf("%v (%v)", name, net.Addr)
515 }
516
517 s := fmt.Sprintf("%v [%v]", name, strings.Join(statuses, ", "))
518 if details != "" {
519 s += ": " + details
520 }
521 sendServicePRIVMSG(dc, s)
522
523 n++
524 })
525
526 if n == 0 {
527 sendServicePRIVMSG(dc, `No network configured, add one with "network create".`)
528 }
529
530 return nil
531}
532
533func handleServiceNetworkUpdate(dc *downstreamConn, params []string) error {
534 if len(params) < 1 {
535 return fmt.Errorf("expected at least one argument")
536 }
537
538 fs := newNetworkFlagSet()
539 if err := fs.Parse(params[1:]); err != nil {
540 return err
541 }
542
543 net := dc.user.getNetwork(params[0])
544 if net == nil {
545 return fmt.Errorf("unknown network %q", params[0])
546 }
547
548 record := net.Network // copy network record because we'll mutate it
549 if err := fs.update(&record); err != nil {
550 return err
551 }
552
553 network, err := dc.user.updateNetwork(&record)
554 if err != nil {
555 return fmt.Errorf("could not update network: %v", err)
556 }
557
558 sendServicePRIVMSG(dc, fmt.Sprintf("updated network %q", network.GetName()))
559 return nil
560}
561
562func handleServiceNetworkDelete(dc *downstreamConn, params []string) error {
563 if len(params) != 1 {
564 return fmt.Errorf("expected exactly one argument")
565 }
566
567 net := dc.user.getNetwork(params[0])
568 if net == nil {
569 return fmt.Errorf("unknown network %q", params[0])
570 }
571
572 if err := dc.user.deleteNetwork(net.ID); err != nil {
573 return err
574 }
575
576 sendServicePRIVMSG(dc, fmt.Sprintf("deleted network %q", net.GetName()))
577 return nil
578}
579
580func handleServiceCertfpGenerate(dc *downstreamConn, params []string) error {
581 fs := newFlagSet()
582 keyType := fs.String("key-type", "rsa", "key type to generate (rsa, ecdsa, ed25519)")
583 bits := fs.Int("bits", 3072, "size of key to generate, meaningful only for RSA")
584
585 if err := fs.Parse(params); err != nil {
586 return err
587 }
588
589 if len(fs.Args()) != 1 {
590 return errors.New("exactly one argument is required")
591 }
592
593 net := dc.user.getNetwork(fs.Arg(0))
594 if net == nil {
595 return fmt.Errorf("unknown network %q", fs.Arg(0))
596 }
597
598 var (
599 privKey crypto.PrivateKey
600 pubKey crypto.PublicKey
601 )
602 switch *keyType {
603 case "rsa":
604 key, err := rsa.GenerateKey(rand.Reader, *bits)
605 if err != nil {
606 return err
607 }
608 privKey = key
609 pubKey = key.Public()
610 case "ecdsa":
611 key, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
612 if err != nil {
613 return err
614 }
615 privKey = key
616 pubKey = key.Public()
617 case "ed25519":
618 var err error
619 pubKey, privKey, err = ed25519.GenerateKey(rand.Reader)
620 if err != nil {
621 return err
622 }
623 }
624
625 // Using PKCS#8 allows easier extension for new key types.
626 privKeyBytes, err := x509.MarshalPKCS8PrivateKey(privKey)
627 if err != nil {
628 return err
629 }
630
631 notBefore := time.Now()
632 // Lets make a fair assumption nobody will use the same cert for more than 20 years...
633 notAfter := notBefore.Add(24 * time.Hour * 365 * 20)
634 serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
635 serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
636 if err != nil {
637 return err
638 }
639 cert := &x509.Certificate{
640 SerialNumber: serialNumber,
641 Subject: pkix.Name{CommonName: "soju auto-generated certificate"},
642 NotBefore: notBefore,
643 NotAfter: notAfter,
644 KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
645 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
646 }
647 derBytes, err := x509.CreateCertificate(rand.Reader, cert, cert, pubKey, privKey)
648 if err != nil {
649 return err
650 }
651
652 net.SASL.External.CertBlob = derBytes
653 net.SASL.External.PrivKeyBlob = privKeyBytes
654 net.SASL.Mechanism = "EXTERNAL"
655
656 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
657 return err
658 }
659
660 sendServicePRIVMSG(dc, "certificate generated")
661
662 sha1Sum := sha1.Sum(derBytes)
663 sendServicePRIVMSG(dc, "SHA-1 fingerprint: "+hex.EncodeToString(sha1Sum[:]))
664 sha256Sum := sha256.Sum256(derBytes)
665 sendServicePRIVMSG(dc, "SHA-256 fingerprint: "+hex.EncodeToString(sha256Sum[:]))
666
667 return nil
668}
669
670func handleServiceCertfpFingerprints(dc *downstreamConn, params []string) error {
671 if len(params) != 1 {
672 return fmt.Errorf("expected exactly one argument")
673 }
674
675 net := dc.user.getNetwork(params[0])
676 if net == nil {
677 return fmt.Errorf("unknown network %q", params[0])
678 }
679
680 sha1Sum := sha1.Sum(net.SASL.External.CertBlob)
681 sendServicePRIVMSG(dc, "SHA-1 fingerprint: "+hex.EncodeToString(sha1Sum[:]))
682 sha256Sum := sha256.Sum256(net.SASL.External.CertBlob)
683 sendServicePRIVMSG(dc, "SHA-256 fingerprint: "+hex.EncodeToString(sha256Sum[:]))
684 return nil
685}
686
687func handleServiceSASLSetPlain(dc *downstreamConn, params []string) error {
688 if len(params) != 3 {
689 return fmt.Errorf("expected exactly 3 arguments")
690 }
691
692 net := dc.user.getNetwork(params[0])
693 if net == nil {
694 return fmt.Errorf("unknown network %q", params[0])
695 }
696
697 net.SASL.Plain.Username = params[1]
698 net.SASL.Plain.Password = params[2]
699 net.SASL.Mechanism = "PLAIN"
700
701 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
702 return err
703 }
704
705 sendServicePRIVMSG(dc, "credentials saved")
706 return nil
707}
708
709func handleServiceSASLReset(dc *downstreamConn, params []string) error {
710 if len(params) != 1 {
711 return fmt.Errorf("expected exactly one argument")
712 }
713
714 net := dc.user.getNetwork(params[0])
715 if net == nil {
716 return fmt.Errorf("unknown network %q", params[0])
717 }
718
719 net.SASL.Plain.Username = ""
720 net.SASL.Plain.Password = ""
721 net.SASL.External.CertBlob = nil
722 net.SASL.External.PrivKeyBlob = nil
723 net.SASL.Mechanism = ""
724
725 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
726 return err
727 }
728
729 sendServicePRIVMSG(dc, "credentials reset")
730 return nil
731}
732
733func handlePasswordChange(dc *downstreamConn, params []string) error {
734 if len(params) != 1 {
735 return fmt.Errorf("expected exactly one argument")
736 }
737
738 hashed, err := bcrypt.GenerateFromPassword([]byte(params[0]), bcrypt.DefaultCost)
739 if err != nil {
740 return fmt.Errorf("failed to hash password: %v", err)
741 }
742 if err := dc.user.updatePassword(string(hashed)); err != nil {
743 return err
744 }
745
746 sendServicePRIVMSG(dc, "password updated")
747 return nil
748}
749
750func handleUserCreate(dc *downstreamConn, params []string) error {
751 fs := newFlagSet()
752 username := fs.String("username", "", "")
753 password := fs.String("password", "", "")
754 admin := fs.Bool("admin", false, "")
755
756 if err := fs.Parse(params); err != nil {
757 return err
758 }
759 if *username == "" {
760 return fmt.Errorf("flag -username is required")
761 }
762 if *password == "" {
763 return fmt.Errorf("flag -password is required")
764 }
765
766 hashed, err := bcrypt.GenerateFromPassword([]byte(*password), bcrypt.DefaultCost)
767 if err != nil {
768 return fmt.Errorf("failed to hash password: %v", err)
769 }
770
771 user := &User{
772 Username: *username,
773 Password: string(hashed),
774 Admin: *admin,
775 }
776 if _, err := dc.srv.createUser(user); err != nil {
777 return fmt.Errorf("could not create user: %v", err)
778 }
779
780 sendServicePRIVMSG(dc, fmt.Sprintf("created user %q", *username))
781 return nil
782}
783
784func handleUserDelete(dc *downstreamConn, params []string) error {
785 if len(params) != 1 {
786 return fmt.Errorf("expected exactly one argument")
787 }
788 username := params[0]
789
790 u := dc.srv.getUser(username)
791 if u == nil {
792 return fmt.Errorf("unknown username %q", username)
793 }
794
795 u.stop()
796
797 if err := dc.srv.db.DeleteUser(u.ID); err != nil {
798 return fmt.Errorf("failed to delete user: %v", err)
799 }
800
801 sendServicePRIVMSG(dc, fmt.Sprintf("deleted user %q", username))
802 return nil
803}
804
805func handleServiceChannelStatus(dc *downstreamConn, params []string) error {
806 var defaultNetworkName string
807 if dc.network != nil {
808 defaultNetworkName = dc.network.GetName()
809 }
810
811 fs := newFlagSet()
812 networkName := fs.String("network", defaultNetworkName, "")
813
814 if err := fs.Parse(params); err != nil {
815 return err
816 }
817
818 n := 0
819
820 sendNetwork := func(net *network) {
821 for _, entry := range net.channels.innerMap {
822 ch := entry.value.(*Channel)
823
824 var uch *upstreamChannel
825 if net.conn != nil {
826 uch = net.conn.channels.Value(ch.Name)
827 }
828
829 name := ch.Name
830 if *networkName == "" {
831 name += "/" + net.GetName()
832 }
833
834 var status string
835 if uch != nil {
836 status = "joined"
837 } else if net.conn != nil {
838 status = "parted"
839 } else {
840 status = "disconnected"
841 }
842
843 if ch.Detached {
844 status += ", detached"
845 }
846
847 s := fmt.Sprintf("%v [%v]", name, status)
848 sendServicePRIVMSG(dc, s)
849
850 n++
851 }
852 }
853
854 if *networkName == "" {
855 dc.user.forEachNetwork(sendNetwork)
856 } else {
857 net := dc.user.getNetwork(*networkName)
858 if net == nil {
859 return fmt.Errorf("unknown network %q", *networkName)
860 }
861 sendNetwork(net)
862 }
863
864 if n == 0 {
865 sendServicePRIVMSG(dc, "No channel configured.")
866 }
867
868 return nil
869}
870
871type channelFlagSet struct {
872 *flag.FlagSet
873 RelayDetached, ReattachOn, DetachAfter, DetachOn *string
874}
875
876func newChannelFlagSet() *channelFlagSet {
877 fs := &channelFlagSet{FlagSet: newFlagSet()}
878 fs.Var(stringPtrFlag{&fs.RelayDetached}, "relay-detached", "")
879 fs.Var(stringPtrFlag{&fs.ReattachOn}, "reattach-on", "")
880 fs.Var(stringPtrFlag{&fs.DetachAfter}, "detach-after", "")
881 fs.Var(stringPtrFlag{&fs.DetachOn}, "detach-on", "")
882 return fs
883}
884
885func (fs *channelFlagSet) update(channel *Channel) error {
886 if fs.RelayDetached != nil {
887 filter, err := parseFilter(*fs.RelayDetached)
888 if err != nil {
889 return err
890 }
891 channel.RelayDetached = filter
892 }
893 if fs.ReattachOn != nil {
894 filter, err := parseFilter(*fs.ReattachOn)
895 if err != nil {
896 return err
897 }
898 channel.ReattachOn = filter
899 }
900 if fs.DetachAfter != nil {
901 dur, err := time.ParseDuration(*fs.DetachAfter)
902 if err != nil || dur < 0 {
903 return fmt.Errorf("unknown duration for -detach-after %q (duration format: 0, 300s, 22h30m, ...)", *fs.DetachAfter)
904 }
905 channel.DetachAfter = dur
906 }
907 if fs.DetachOn != nil {
908 filter, err := parseFilter(*fs.DetachOn)
909 if err != nil {
910 return err
911 }
912 channel.DetachOn = filter
913 }
914 return nil
915}
916
917func handleServiceChannelUpdate(dc *downstreamConn, params []string) error {
918 if len(params) < 1 {
919 return fmt.Errorf("expected at least one argument")
920 }
921 name := params[0]
922
923 fs := newChannelFlagSet()
924 if err := fs.Parse(params[1:]); err != nil {
925 return err
926 }
927
928 uc, upstreamName, err := dc.unmarshalEntity(name)
929 if err != nil {
930 return fmt.Errorf("unknown channel %q", name)
931 }
932
933 ch := uc.network.channels.Value(upstreamName)
934 if ch == nil {
935 return fmt.Errorf("unknown channel %q", name)
936 }
937
938 if err := fs.update(ch); err != nil {
939 return err
940 }
941
942 uc.updateChannelAutoDetach(upstreamName)
943
944 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
945 return fmt.Errorf("failed to update channel: %v", err)
946 }
947
948 sendServicePRIVMSG(dc, fmt.Sprintf("updated channel %q", name))
949 return nil
950}
Note: See TracBrowser for help on using the repository browser.