cubefs

1
// Copyright 2023 The CubeFS Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12
// implied. See the License for the specific language governing
13
// permissions and limitations under the License.
14

15
package caps
16

17
import (
18
	"encoding/json"
19
	"fmt"
20
	"regexp"
21
	"strings"
22
)
23

24
// Caps defines the capability type
25
type Caps struct {
26
	API          []string
27
	OwnerVOL     []string
28
	NoneOwnerVOL []string
29
}
30

31
// ContainCaps whether contain a capability with kind
32
func (c *Caps) ContainCaps(cat string, cap string) (r bool) {
33
	if cat == "API" {
34
		return traversalCaps(c.API, cap)
35
	} else if cat == "OwnerVOL" {
36
		return traversalCaps(c.OwnerVOL, cap)
37
	} else if cat == "NoneOwnerVOL" {
38
		return traversalCaps(c.NoneOwnerVOL, cap)
39
	}
40
	return false
41
}
42

43
func traversalCaps(caps []string, cap string) (r bool) {
44
	r = false
45
	for _, s := range caps {
46
		a := strings.Split(s, ":")
47
		b := strings.Split(cap, ":")
48
		i := 0
49
		for ; i < 3; i++ {
50
			if a[i] != "*" && a[i] != b[i] {
51
				break
52
			}
53
		}
54
		if i == 3 {
55
			r = true
56
			break
57
		}
58
	}
59
	return
60
}
61

62
// Init init a Caps instance
63
func (c *Caps) Init(b []byte) (err error) {
64
	if err = json.Unmarshal(b, c); err != nil {
65
		return
66
	}
67
	if err = c.check(); err != nil {
68
		return
69
	}
70
	c.cleanDup()
71
	return
72
}
73

74
// Dump dump the content of Caps
75
func (c *Caps) Dump() (d string) {
76
	for _, s := range c.API {
77
		d += fmt.Sprintf("API:%s,", s)
78
	}
79
	// TODO c.vol (no usage?)
80
	return
81
}
82

83
// Union union caps
84
func (c *Caps) Union(caps *Caps) {
85
	c.API = append(c.API, caps.API...)
86
	c.OwnerVOL = append(c.OwnerVOL, caps.OwnerVOL...)
87
	c.NoneOwnerVOL = append(c.NoneOwnerVOL, caps.NoneOwnerVOL...)
88
	c.cleanDup()
89
}
90

91
func (c *Caps) check() (err error) {
92
	apiRe := regexp.MustCompile("^[A-Za-z0-9*]{1,20}:[A-Za-z0-9*]{1,20}:[A-Za-z0-9*]{1,20}$")
93
	volRe := regexp.MustCompile("^[A-Za-z0-9*]{1,20}:[a-zA-Z0-9_-]{3,256}:[A-Za-z0-9*]{1,20}$")
94
	if err = checkRegexp(apiRe, c.API); err != nil {
95
		return
96
	}
97
	if err = checkRegexp(volRe, c.OwnerVOL); err != nil {
98
		return
99
	}
100
	if err = checkRegexp(volRe, c.NoneOwnerVOL); err != nil {
101
		return
102
	}
103
	return
104
}
105

106
func checkRegexp(re *regexp.Regexp, caps []string) (err error) {
107
	for _, cap := range caps {
108
		if !re.MatchString(cap) {
109
			err = fmt.Errorf("invalid cap [%s]", cap)
110
			return
111
		}
112
	}
113
	return
114
}
115

116
// Delete delete caps
117
func (c *Caps) Delete(caps *Caps) {
118
	c.API = deleteCaps(c.API, caps.API)
119
	c.OwnerVOL = deleteCaps(c.OwnerVOL, caps.OwnerVOL)
120
	c.NoneOwnerVOL = deleteCaps(c.NoneOwnerVOL, caps.NoneOwnerVOL)
121
}
122

123
func deleteCaps(caps []string, deleteCaps []string) []string {
124
	m := make(map[string]bool)
125
	for _, item := range caps {
126
		m[item] = true
127
	}
128
	caps = []string{}
129
	for _, item := range deleteCaps {
130
		delete(m, item)
131
	}
132
	for k := range m {
133
		caps = append(caps, k)
134
	}
135
	return caps
136
}
137

138
func (c *Caps) cleanDup() {
139
	c.API = cleanCaps(c.API)
140
	c.OwnerVOL = cleanCaps(c.OwnerVOL)
141
	c.NoneOwnerVOL = cleanCaps(c.NoneOwnerVOL)
142
}
143

144
func cleanCaps(caps []string) []string {
145
	newCaps := make([]string, 0)
146
	m := make(map[string]map[string]bool)
147
	for _, cap := range caps {
148
		a := strings.Split(cap, ":")
149
		key1 := a[0]
150
		key2 := a[1] + ":" + a[2]
151
		if _, ok := m[key1]; !ok {
152
			m[key1] = make(map[string]bool)
153
		}
154
		if _, ok := m[key1][key2]; !ok {
155
			newCaps = append(newCaps, cap)
156
			m[key1][key2] = true
157
		}
158
	}
159
	return newCaps
160
}
161