source: code/trunk/service.go@ 569

Last change on this file since 569 was 569, checked in by contact, 4 years ago

Only update realname if specified in "user udpate"

This will allow adding more flags.
File size: 23.2 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> [-realname <realname>] [-admin]",
258 desc: "create a new soju user",
259 handle: handleUserCreate,
260 admin: true,
261 },
262 "update": {
263 usage: "[-realname <realname>]",
264 desc: "update the current user",
265 handle: handleUserUpdate,
266 },
267 "delete": {
268 usage: "<username>",
269 desc: "delete a user",
270 handle: handleUserDelete,
271 admin: true,
272 },
273 },
274 },
275 "change-password": {
276 usage: "<new password>",
277 desc: "change your password",
278 handle: handlePasswordChange,
279 },
280 "channel": {
281 children: serviceCommandSet{
282 "status": {
283 usage: "[-network name]",
284 desc: "show a list of saved channels and their current status",
285 handle: handleServiceChannelStatus,
286 },
287 "update": {
288 usage: "<name> [-relay-detached <default|none|highlight|message>] [-reattach-on <default|none|highlight|message>] [-detach-after <duration>] [-detach-on <default|none|highlight|message>]",
289 desc: "update a channel",
290 handle: handleServiceChannelUpdate,
291 },
292 },
293 },
294 }
295}
296
297func appendServiceCommandSetHelp(cmds serviceCommandSet, prefix []string, admin bool, l *[]string) {
298 for _, name := range cmds.Names() {
299 cmd := cmds[name]
300 if cmd.admin && !admin {
301 continue
302 }
303 words := append(prefix, name)
304 if len(cmd.children) == 0 {
305 s := strings.Join(words, " ")
306 *l = append(*l, s)
307 } else {
308 appendServiceCommandSetHelp(cmd.children, words, admin, l)
309 }
310 }
311}
312
313func handleServiceHelp(dc *downstreamConn, params []string) error {
314 if len(params) > 0 {
315 cmd, rest, err := serviceCommands.Get(params)
316 if err != nil {
317 return err
318 }
319 words := params[:len(params)-len(rest)]
320
321 if len(cmd.children) > 0 {
322 var l []string
323 appendServiceCommandSetHelp(cmd.children, words, dc.user.Admin, &l)
324 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
325 } else {
326 text := strings.Join(words, " ")
327 if cmd.usage != "" {
328 text += " " + cmd.usage
329 }
330 text += ": " + cmd.desc
331
332 sendServicePRIVMSG(dc, text)
333 }
334 } else {
335 var l []string
336 appendServiceCommandSetHelp(serviceCommands, nil, dc.user.Admin, &l)
337 sendServicePRIVMSG(dc, "available commands: "+strings.Join(l, ", "))
338 }
339 return nil
340}
341
342func newFlagSet() *flag.FlagSet {
343 fs := flag.NewFlagSet("", flag.ContinueOnError)
344 fs.SetOutput(ioutil.Discard)
345 return fs
346}
347
348type stringSliceFlag []string
349
350func (v *stringSliceFlag) String() string {
351 return fmt.Sprint([]string(*v))
352}
353
354func (v *stringSliceFlag) Set(s string) error {
355 *v = append(*v, s)
356 return nil
357}
358
359// stringPtrFlag is a flag value populating a string pointer. This allows to
360// disambiguate between a flag that hasn't been set and a flag that has been
361// set to an empty string.
362type stringPtrFlag struct {
363 ptr **string
364}
365
366func (f stringPtrFlag) String() string {
367 if f.ptr == nil || *f.ptr == nil {
368 return ""
369 }
370 return **f.ptr
371}
372
373func (f stringPtrFlag) Set(s string) error {
374 *f.ptr = &s
375 return nil
376}
377
378type boolPtrFlag struct {
379 ptr **bool
380}
381
382func (f boolPtrFlag) String() string {
383 if f.ptr == nil || *f.ptr == nil {
384 return "<nil>"
385 }
386 return strconv.FormatBool(**f.ptr)
387}
388
389func (f boolPtrFlag) Set(s string) error {
390 v, err := strconv.ParseBool(s)
391 if err != nil {
392 return err
393 }
394 *f.ptr = &v
395 return nil
396}
397
398type networkFlagSet struct {
399 *flag.FlagSet
400 Addr, Name, Nick, Username, Pass, Realname *string
401 Enabled *bool
402 ConnectCommands []string
403}
404
405func newNetworkFlagSet() *networkFlagSet {
406 fs := &networkFlagSet{FlagSet: newFlagSet()}
407 fs.Var(stringPtrFlag{&fs.Addr}, "addr", "")
408 fs.Var(stringPtrFlag{&fs.Name}, "name", "")
409 fs.Var(stringPtrFlag{&fs.Nick}, "nick", "")
410 fs.Var(stringPtrFlag{&fs.Username}, "username", "")
411 fs.Var(stringPtrFlag{&fs.Pass}, "pass", "")
412 fs.Var(stringPtrFlag{&fs.Realname}, "realname", "")
413 fs.Var(boolPtrFlag{&fs.Enabled}, "enabled", "")
414 fs.Var((*stringSliceFlag)(&fs.ConnectCommands), "connect-command", "")
415 return fs
416}
417
418func (fs *networkFlagSet) update(network *Network) error {
419 if fs.Addr != nil {
420 if addrParts := strings.SplitN(*fs.Addr, "://", 2); len(addrParts) == 2 {
421 scheme := addrParts[0]
422 switch scheme {
423 case "ircs", "irc+insecure", "unix":
424 default:
425 return fmt.Errorf("unknown scheme %q (supported schemes: ircs, irc+insecure, unix)", scheme)
426 }
427 }
428 network.Addr = *fs.Addr
429 }
430 if fs.Name != nil {
431 network.Name = *fs.Name
432 }
433 if fs.Nick != nil {
434 network.Nick = *fs.Nick
435 }
436 if fs.Username != nil {
437 network.Username = *fs.Username
438 }
439 if fs.Pass != nil {
440 network.Pass = *fs.Pass
441 }
442 if fs.Realname != nil {
443 network.Realname = *fs.Realname
444 }
445 if fs.Enabled != nil {
446 network.Enabled = *fs.Enabled
447 }
448 if fs.ConnectCommands != nil {
449 if len(fs.ConnectCommands) == 1 && fs.ConnectCommands[0] == "" {
450 network.ConnectCommands = nil
451 } else {
452 for _, command := range fs.ConnectCommands {
453 _, err := irc.ParseMessage(command)
454 if err != nil {
455 return fmt.Errorf("flag -connect-command must be a valid raw irc command string: %q: %v", command, err)
456 }
457 }
458 network.ConnectCommands = fs.ConnectCommands
459 }
460 }
461 return nil
462}
463
464func handleServiceNetworkCreate(dc *downstreamConn, params []string) error {
465 fs := newNetworkFlagSet()
466 if err := fs.Parse(params); err != nil {
467 return err
468 }
469 if fs.Addr == nil {
470 return fmt.Errorf("flag -addr is required")
471 }
472
473 record := &Network{
474 Addr: *fs.Addr,
475 Nick: dc.nick,
476 Enabled: true,
477 }
478 if err := fs.update(record); err != nil {
479 return err
480 }
481
482 network, err := dc.user.createNetwork(record)
483 if err != nil {
484 return fmt.Errorf("could not create network: %v", err)
485 }
486
487 sendServicePRIVMSG(dc, fmt.Sprintf("created network %q", network.GetName()))
488 return nil
489}
490
491func handleServiceNetworkStatus(dc *downstreamConn, params []string) error {
492 n := 0
493 dc.user.forEachNetwork(func(net *network) {
494 var statuses []string
495 var details string
496 if uc := net.conn; uc != nil {
497 if dc.nick != uc.nick {
498 statuses = append(statuses, "connected as "+uc.nick)
499 } else {
500 statuses = append(statuses, "connected")
501 }
502 details = fmt.Sprintf("%v channels", uc.channels.Len())
503 } else if !net.Enabled {
504 statuses = append(statuses, "disabled")
505 } else {
506 statuses = append(statuses, "disconnected")
507 if net.lastError != nil {
508 details = net.lastError.Error()
509 }
510 }
511
512 if net == dc.network {
513 statuses = append(statuses, "current")
514 }
515
516 name := net.GetName()
517 if name != net.Addr {
518 name = fmt.Sprintf("%v (%v)", name, net.Addr)
519 }
520
521 s := fmt.Sprintf("%v [%v]", name, strings.Join(statuses, ", "))
522 if details != "" {
523 s += ": " + details
524 }
525 sendServicePRIVMSG(dc, s)
526
527 n++
528 })
529
530 if n == 0 {
531 sendServicePRIVMSG(dc, `No network configured, add one with "network create".`)
532 }
533
534 return nil
535}
536
537func handleServiceNetworkUpdate(dc *downstreamConn, params []string) error {
538 if len(params) < 1 {
539 return fmt.Errorf("expected at least one argument")
540 }
541
542 fs := newNetworkFlagSet()
543 if err := fs.Parse(params[1:]); err != nil {
544 return err
545 }
546
547 net := dc.user.getNetwork(params[0])
548 if net == nil {
549 return fmt.Errorf("unknown network %q", params[0])
550 }
551
552 record := net.Network // copy network record because we'll mutate it
553 if err := fs.update(&record); err != nil {
554 return err
555 }
556
557 network, err := dc.user.updateNetwork(&record)
558 if err != nil {
559 return fmt.Errorf("could not update network: %v", err)
560 }
561
562 sendServicePRIVMSG(dc, fmt.Sprintf("updated network %q", network.GetName()))
563 return nil
564}
565
566func handleServiceNetworkDelete(dc *downstreamConn, params []string) error {
567 if len(params) != 1 {
568 return fmt.Errorf("expected exactly one argument")
569 }
570
571 net := dc.user.getNetwork(params[0])
572 if net == nil {
573 return fmt.Errorf("unknown network %q", params[0])
574 }
575
576 if err := dc.user.deleteNetwork(net.ID); err != nil {
577 return err
578 }
579
580 sendServicePRIVMSG(dc, fmt.Sprintf("deleted network %q", net.GetName()))
581 return nil
582}
583
584func handleServiceCertfpGenerate(dc *downstreamConn, params []string) error {
585 fs := newFlagSet()
586 keyType := fs.String("key-type", "rsa", "key type to generate (rsa, ecdsa, ed25519)")
587 bits := fs.Int("bits", 3072, "size of key to generate, meaningful only for RSA")
588
589 if err := fs.Parse(params); err != nil {
590 return err
591 }
592
593 if len(fs.Args()) != 1 {
594 return errors.New("exactly one argument is required")
595 }
596
597 net := dc.user.getNetwork(fs.Arg(0))
598 if net == nil {
599 return fmt.Errorf("unknown network %q", fs.Arg(0))
600 }
601
602 var (
603 privKey crypto.PrivateKey
604 pubKey crypto.PublicKey
605 )
606 switch *keyType {
607 case "rsa":
608 key, err := rsa.GenerateKey(rand.Reader, *bits)
609 if err != nil {
610 return err
611 }
612 privKey = key
613 pubKey = key.Public()
614 case "ecdsa":
615 key, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
616 if err != nil {
617 return err
618 }
619 privKey = key
620 pubKey = key.Public()
621 case "ed25519":
622 var err error
623 pubKey, privKey, err = ed25519.GenerateKey(rand.Reader)
624 if err != nil {
625 return err
626 }
627 }
628
629 // Using PKCS#8 allows easier extension for new key types.
630 privKeyBytes, err := x509.MarshalPKCS8PrivateKey(privKey)
631 if err != nil {
632 return err
633 }
634
635 notBefore := time.Now()
636 // Lets make a fair assumption nobody will use the same cert for more than 20 years...
637 notAfter := notBefore.Add(24 * time.Hour * 365 * 20)
638 serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
639 serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
640 if err != nil {
641 return err
642 }
643 cert := &x509.Certificate{
644 SerialNumber: serialNumber,
645 Subject: pkix.Name{CommonName: "soju auto-generated certificate"},
646 NotBefore: notBefore,
647 NotAfter: notAfter,
648 KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
649 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
650 }
651 derBytes, err := x509.CreateCertificate(rand.Reader, cert, cert, pubKey, privKey)
652 if err != nil {
653 return err
654 }
655
656 net.SASL.External.CertBlob = derBytes
657 net.SASL.External.PrivKeyBlob = privKeyBytes
658 net.SASL.Mechanism = "EXTERNAL"
659
660 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
661 return err
662 }
663
664 sendServicePRIVMSG(dc, "certificate generated")
665
666 sha1Sum := sha1.Sum(derBytes)
667 sendServicePRIVMSG(dc, "SHA-1 fingerprint: "+hex.EncodeToString(sha1Sum[:]))
668 sha256Sum := sha256.Sum256(derBytes)
669 sendServicePRIVMSG(dc, "SHA-256 fingerprint: "+hex.EncodeToString(sha256Sum[:]))
670
671 return nil
672}
673
674func handleServiceCertfpFingerprints(dc *downstreamConn, params []string) error {
675 if len(params) != 1 {
676 return fmt.Errorf("expected exactly one argument")
677 }
678
679 net := dc.user.getNetwork(params[0])
680 if net == nil {
681 return fmt.Errorf("unknown network %q", params[0])
682 }
683
684 sha1Sum := sha1.Sum(net.SASL.External.CertBlob)
685 sendServicePRIVMSG(dc, "SHA-1 fingerprint: "+hex.EncodeToString(sha1Sum[:]))
686 sha256Sum := sha256.Sum256(net.SASL.External.CertBlob)
687 sendServicePRIVMSG(dc, "SHA-256 fingerprint: "+hex.EncodeToString(sha256Sum[:]))
688 return nil
689}
690
691func handleServiceSASLSetPlain(dc *downstreamConn, params []string) error {
692 if len(params) != 3 {
693 return fmt.Errorf("expected exactly 3 arguments")
694 }
695
696 net := dc.user.getNetwork(params[0])
697 if net == nil {
698 return fmt.Errorf("unknown network %q", params[0])
699 }
700
701 net.SASL.Plain.Username = params[1]
702 net.SASL.Plain.Password = params[2]
703 net.SASL.Mechanism = "PLAIN"
704
705 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
706 return err
707 }
708
709 sendServicePRIVMSG(dc, "credentials saved")
710 return nil
711}
712
713func handleServiceSASLReset(dc *downstreamConn, params []string) error {
714 if len(params) != 1 {
715 return fmt.Errorf("expected exactly one argument")
716 }
717
718 net := dc.user.getNetwork(params[0])
719 if net == nil {
720 return fmt.Errorf("unknown network %q", params[0])
721 }
722
723 net.SASL.Plain.Username = ""
724 net.SASL.Plain.Password = ""
725 net.SASL.External.CertBlob = nil
726 net.SASL.External.PrivKeyBlob = nil
727 net.SASL.Mechanism = ""
728
729 if err := dc.srv.db.StoreNetwork(dc.user.ID, &net.Network); err != nil {
730 return err
731 }
732
733 sendServicePRIVMSG(dc, "credentials reset")
734 return nil
735}
736
737func handlePasswordChange(dc *downstreamConn, params []string) error {
738 if len(params) != 1 {
739 return fmt.Errorf("expected exactly one argument")
740 }
741
742 hashed, err := bcrypt.GenerateFromPassword([]byte(params[0]), bcrypt.DefaultCost)
743 if err != nil {
744 return fmt.Errorf("failed to hash password: %v", err)
745 }
746 if err := dc.user.updatePassword(string(hashed)); err != nil {
747 return err
748 }
749
750 sendServicePRIVMSG(dc, "password updated")
751 return nil
752}
753
754func handleUserCreate(dc *downstreamConn, params []string) error {
755 fs := newFlagSet()
756 username := fs.String("username", "", "")
757 password := fs.String("password", "", "")
758 realname := fs.String("realname", "", "")
759 admin := fs.Bool("admin", false, "")
760
761 if err := fs.Parse(params); err != nil {
762 return err
763 }
764 if *username == "" {
765 return fmt.Errorf("flag -username is required")
766 }
767 if *password == "" {
768 return fmt.Errorf("flag -password is required")
769 }
770
771 hashed, err := bcrypt.GenerateFromPassword([]byte(*password), bcrypt.DefaultCost)
772 if err != nil {
773 return fmt.Errorf("failed to hash password: %v", err)
774 }
775
776 user := &User{
777 Username: *username,
778 Password: string(hashed),
779 Realname: *realname,
780 Admin: *admin,
781 }
782 if _, err := dc.srv.createUser(user); err != nil {
783 return fmt.Errorf("could not create user: %v", err)
784 }
785
786 sendServicePRIVMSG(dc, fmt.Sprintf("created user %q", *username))
787 return nil
788}
789
790func handleUserUpdate(dc *downstreamConn, params []string) error {
791 var realname *string
792 fs := newFlagSet()
793 fs.Var(stringPtrFlag{&realname}, "realname", "")
794
795 if err := fs.Parse(params); err != nil {
796 return err
797 }
798
799 if realname != nil {
800 if err := dc.user.updateRealname(*realname); err != nil {
801 return err
802 }
803 }
804
805 sendServicePRIVMSG(dc, fmt.Sprintf("updated user %q", dc.user.Username))
806 return nil
807}
808
809func handleUserDelete(dc *downstreamConn, params []string) error {
810 if len(params) != 1 {
811 return fmt.Errorf("expected exactly one argument")
812 }
813 username := params[0]
814
815 u := dc.srv.getUser(username)
816 if u == nil {
817 return fmt.Errorf("unknown username %q", username)
818 }
819
820 u.stop()
821
822 if err := dc.srv.db.DeleteUser(u.ID); err != nil {
823 return fmt.Errorf("failed to delete user: %v", err)
824 }
825
826 sendServicePRIVMSG(dc, fmt.Sprintf("deleted user %q", username))
827 return nil
828}
829
830func handleServiceChannelStatus(dc *downstreamConn, params []string) error {
831 var defaultNetworkName string
832 if dc.network != nil {
833 defaultNetworkName = dc.network.GetName()
834 }
835
836 fs := newFlagSet()
837 networkName := fs.String("network", defaultNetworkName, "")
838
839 if err := fs.Parse(params); err != nil {
840 return err
841 }
842
843 n := 0
844
845 sendNetwork := func(net *network) {
846 for _, entry := range net.channels.innerMap {
847 ch := entry.value.(*Channel)
848
849 var uch *upstreamChannel
850 if net.conn != nil {
851 uch = net.conn.channels.Value(ch.Name)
852 }
853
854 name := ch.Name
855 if *networkName == "" {
856 name += "/" + net.GetName()
857 }
858
859 var status string
860 if uch != nil {
861 status = "joined"
862 } else if net.conn != nil {
863 status = "parted"
864 } else {
865 status = "disconnected"
866 }
867
868 if ch.Detached {
869 status += ", detached"
870 }
871
872 s := fmt.Sprintf("%v [%v]", name, status)
873 sendServicePRIVMSG(dc, s)
874
875 n++
876 }
877 }
878
879 if *networkName == "" {
880 dc.user.forEachNetwork(sendNetwork)
881 } else {
882 net := dc.user.getNetwork(*networkName)
883 if net == nil {
884 return fmt.Errorf("unknown network %q", *networkName)
885 }
886 sendNetwork(net)
887 }
888
889 if n == 0 {
890 sendServicePRIVMSG(dc, "No channel configured.")
891 }
892
893 return nil
894}
895
896type channelFlagSet struct {
897 *flag.FlagSet
898 RelayDetached, ReattachOn, DetachAfter, DetachOn *string
899}
900
901func newChannelFlagSet() *channelFlagSet {
902 fs := &channelFlagSet{FlagSet: newFlagSet()}
903 fs.Var(stringPtrFlag{&fs.RelayDetached}, "relay-detached", "")
904 fs.Var(stringPtrFlag{&fs.ReattachOn}, "reattach-on", "")
905 fs.Var(stringPtrFlag{&fs.DetachAfter}, "detach-after", "")
906 fs.Var(stringPtrFlag{&fs.DetachOn}, "detach-on", "")
907 return fs
908}
909
910func (fs *channelFlagSet) update(channel *Channel) error {
911 if fs.RelayDetached != nil {
912 filter, err := parseFilter(*fs.RelayDetached)
913 if err != nil {
914 return err
915 }
916 channel.RelayDetached = filter
917 }
918 if fs.ReattachOn != nil {
919 filter, err := parseFilter(*fs.ReattachOn)
920 if err != nil {
921 return err
922 }
923 channel.ReattachOn = filter
924 }
925 if fs.DetachAfter != nil {
926 dur, err := time.ParseDuration(*fs.DetachAfter)
927 if err != nil || dur < 0 {
928 return fmt.Errorf("unknown duration for -detach-after %q (duration format: 0, 300s, 22h30m, ...)", *fs.DetachAfter)
929 }
930 channel.DetachAfter = dur
931 }
932 if fs.DetachOn != nil {
933 filter, err := parseFilter(*fs.DetachOn)
934 if err != nil {
935 return err
936 }
937 channel.DetachOn = filter
938 }
939 return nil
940}
941
942func handleServiceChannelUpdate(dc *downstreamConn, params []string) error {
943 if len(params) < 1 {
944 return fmt.Errorf("expected at least one argument")
945 }
946 name := params[0]
947
948 fs := newChannelFlagSet()
949 if err := fs.Parse(params[1:]); err != nil {
950 return err
951 }
952
953 uc, upstreamName, err := dc.unmarshalEntity(name)
954 if err != nil {
955 return fmt.Errorf("unknown channel %q", name)
956 }
957
958 ch := uc.network.channels.Value(upstreamName)
959 if ch == nil {
960 return fmt.Errorf("unknown channel %q", name)
961 }
962
963 if err := fs.update(ch); err != nil {
964 return err
965 }
966
967 uc.updateChannelAutoDetach(upstreamName)
968
969 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
970 return fmt.Errorf("failed to update channel: %v", err)
971 }
972
973 sendServicePRIVMSG(dc, fmt.Sprintf("updated channel %q", name))
974 return nil
975}
Note: See TracBrowser for help on using the repository browser.