source: code/trunk/service.go@ 477

Last change on this file since 477 was 436, checked in by delthas, 4 years ago

service: Introduce channel update

This adds the channel update service command, which is used to set the
auto-detach, auto-reattach, and message relaying settings of a channel.

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