source: code/trunk/service.go@ 540

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

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