source: code/trunk/service.go@ 572

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

Introduce user.updateUser

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