11261855873

Committed 09 Oct 2024 07:35PM UTC coverage: 81.111% (+0.1%) from 81.003%

Build # 11261855873

Build Type

push

github

Committed by

web-flow

Commit Message

Retract case-insensitive tag functionality (#233)

* Revert "[CHANGE] Tags are now case-sensitive (#225)"

This reverts commit de1f16b57.

* retract 2.7.0

Signed-off-by: Alberto Ricart <alberto@synadia.com>

---------

Signed-off-by: Alberto Ricart <alberto@synadia.com>

Run Details

15 of 17 new or added lines in 1 file covered. (88.24%)

2 existing lines in 1 file now uncovered.

2744 of 3383 relevant lines covered (81.11%)

26.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.97

/v2/types.go

/*
 * Copyright 2018-2019 The NATS Authors
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package jwt

import (
        "encoding/json"
        "fmt"
        "net"
        "net/url"
        "reflect"
        "strconv"
        "strings"
        "time"
)

const MaxInfoLength = 8 * 1024

type Info struct {
        Description string `json:"description,omitempty"`
        InfoURL     string `json:"info_url,omitempty"`
}

func (s Info) Validate(vr *ValidationResults) {
        if len(s.Description) > MaxInfoLength {
                vr.AddError("Description is too long")
        }
        if s.InfoURL != "" {
                if len(s.InfoURL) > MaxInfoLength {
                        vr.AddError("Info URL is too long")
                }
                u, err := url.Parse(s.InfoURL)
                if err == nil && (u.Hostname() == "" || u.Scheme == "") {
                        err = fmt.Errorf("no hostname or scheme")
                }
                if err != nil {
                        vr.AddError("error parsing info url: %v", err)
                }
        }
}

// ExportType defines the type of import/export.
type ExportType int

const (
        // Unknown is used if we don't know the type
        Unknown ExportType = iota
        // Stream defines the type field value for a stream "stream"
        Stream
        // Service defines the type field value for a service "service"
        Service
)

func (t ExportType) String() string {
        switch t {
        case Stream:
                return "stream"
        case Service:
                return "service"
        }
        return "unknown"
}

// MarshalJSON marshals the enum as a quoted json string
func (t *ExportType) MarshalJSON() ([]byte, error) {
        switch *t {
        case Stream:
                return []byte("\"stream\""), nil
        case Service:
                return []byte("\"service\""), nil
        }
        return nil, fmt.Errorf("unknown export type")
}

// UnmarshalJSON unmashals a quoted json string to the enum value
func (t *ExportType) UnmarshalJSON(b []byte) error {
        var j string
        err := json.Unmarshal(b, &j)
        if err != nil {
                return err
        }
        switch j {
        case "stream":
                *t = Stream
                return nil
        case "service":
                *t = Service
                return nil
        }
        return fmt.Errorf("unknown export type %q", j)
}

type RenamingSubject Subject

func (s RenamingSubject) Validate(from Subject, vr *ValidationResults) {
        v := Subject(s)
        v.Validate(vr)
        if from == "" {
                vr.AddError("subject cannot be empty")
        }
        if strings.Contains(string(s), " ") {
                vr.AddError("subject %q cannot have spaces", v)
        }
        matchesSuffix := func(s Subject) bool {
                return s == ">" || strings.HasSuffix(string(s), ".>")
        }
        if matchesSuffix(v) != matchesSuffix(from) {
                vr.AddError("both, renaming subject and subject, need to end or not end in >")
        }
        fromCnt := from.countTokenWildcards()
        refCnt := 0
        for _, tk := range strings.Split(string(v), ".") {
                if tk == "*" {
                        refCnt++
                }
                if len(tk) < 2 {
                        continue
                }
                if tk[0] == '$' {
                        if idx, err := strconv.Atoi(tk[1:]); err == nil {
                                if idx > fromCnt {
                                        vr.AddError("Reference $%d in %q reference * in %q that do not exist", idx, s, from)
                                } else {
                                        refCnt++
                                }
                        }
                }
        }
        if refCnt != fromCnt {
                vr.AddError("subject does not contain enough * or reference wildcards $[0-9]")
        }
}

// Replaces reference tokens with *
func (s RenamingSubject) ToSubject() Subject {
        if !strings.Contains(string(s), "$") {
                return Subject(s)
        }
        bldr := strings.Builder{}
        tokens := strings.Split(string(s), ".")
        for i, tk := range tokens {
                convert := false
                if len(tk) > 1 && tk[0] == '$' {
                        if _, err := strconv.Atoi(tk[1:]); err == nil {
                                convert = true
                        }
                }
                if convert {
                        bldr.WriteString("*")
                } else {
                        bldr.WriteString(tk)
                }
                if i != len(tokens)-1 {
                        bldr.WriteString(".")
                }
        }
        return Subject(bldr.String())
}

// Subject is a string that represents a NATS subject
type Subject string

// Validate checks that a subject string is valid, ie not empty and without spaces
func (s Subject) Validate(vr *ValidationResults) {
        v := string(s)
        if v == "" {
                vr.AddError("subject cannot be empty")
                // No other checks after that make sense
                return
        }
        if strings.Contains(v, " ") {
                vr.AddError("subject %q cannot have spaces", v)
        }
        if v[0] == '.' || v[len(v)-1] == '.' {
                vr.AddError("subject %q cannot start or end with a `.`", v)
        }
        if strings.Contains(v, "..") {
                vr.AddError("subject %q cannot contain consecutive `.`", v)
        }
}

func (s Subject) countTokenWildcards() int {
        v := string(s)
        if v == "*" {
                return 1
        }
        cnt := 0
        for _, t := range strings.Split(v, ".") {
                if t == "*" {
                        cnt++
                }
        }
        return cnt
}

// HasWildCards is used to check if a subject contains a > or *
func (s Subject) HasWildCards() bool {
        v := string(s)
        return strings.HasSuffix(v, ".>") ||
                strings.Contains(v, ".*.") ||
                strings.HasSuffix(v, ".*") ||
                strings.HasPrefix(v, "*.") ||
                v == "*" ||
                v == ">"
}

// IsContainedIn does a simple test to see if the subject is contained in another subject
func (s Subject) IsContainedIn(other Subject) bool {
        otherArray := strings.Split(string(other), ".")
        myArray := strings.Split(string(s), ".")

        if len(myArray) > len(otherArray) && otherArray[len(otherArray)-1] != ">" {
                return false
        }

        if len(myArray) < len(otherArray) {
                return false
        }

        for ind, tok := range otherArray {
                myTok := myArray[ind]

                if ind == len(otherArray)-1 && tok == ">" {
                        return true
                }

                if tok != myTok && tok != "*" {
                        return false
                }
        }

        return true
}

// TimeRange is used to represent a start and end time
type TimeRange struct {
        Start string `json:"start,omitempty"`
        End   string `json:"end,omitempty"`
}

// Validate checks the values in a time range struct
func (tr *TimeRange) Validate(vr *ValidationResults) {
        format := "15:04:05"

        if tr.Start == "" {
                vr.AddError("time ranges start must contain a start")
        } else {
                _, err := time.Parse(format, tr.Start)
                if err != nil {
                        vr.AddError("start in time range is invalid %q", tr.Start)
                }
        }

        if tr.End == "" {
                vr.AddError("time ranges end must contain an end")
        } else {
                _, err := time.Parse(format, tr.End)
                if err != nil {
                        vr.AddError("end in time range is invalid %q", tr.End)
                }
        }
}

// Src is a comma separated list of CIDR specifications
type UserLimits struct {
        Src    CIDRList    `json:"src,omitempty"`
        Times  []TimeRange `json:"times,omitempty"`
        Locale string      `json:"times_location,omitempty"`
}

func (u *UserLimits) Empty() bool {
        return reflect.DeepEqual(*u, UserLimits{})
}

func (u *UserLimits) IsUnlimited() bool {
        return len(u.Src) == 0 && len(u.Times) == 0
}

// Limits are used to control acccess for users and importing accounts
type Limits struct {
        UserLimits
        NatsLimits
}

func (l *Limits) IsUnlimited() bool {
        return l.UserLimits.IsUnlimited() && l.NatsLimits.IsUnlimited()
}

// Validate checks the values in a limit struct
func (l *Limits) Validate(vr *ValidationResults) {
        if len(l.Src) != 0 {
                for _, cidr := range l.Src {
                        _, ipNet, err := net.ParseCIDR(cidr)
                        if err != nil || ipNet == nil {
                                vr.AddError("invalid cidr %q in user src limits", cidr)
                        }
                }
        }

        if len(l.Times) > 0 {
                for _, t := range l.Times {
                        t.Validate(vr)
                }
        }

        if l.Locale != "" {
                if _, err := time.LoadLocation(l.Locale); err != nil {
                        vr.AddError("could not parse iana time zone by name: %v", err)
                }
        }
}

// Permission defines allow/deny subjects
type Permission struct {
        Allow StringList `json:"allow,omitempty"`
        Deny  StringList `json:"deny,omitempty"`
}

func (p *Permission) Empty() bool {
        return len(p.Allow) == 0 && len(p.Deny) == 0
}

func checkPermission(vr *ValidationResults, subj string, permitQueue bool) {
        tk := strings.Split(subj, " ")
        switch len(tk) {
        case 1:
                Subject(tk[0]).Validate(vr)
        case 2:
                Subject(tk[0]).Validate(vr)
                Subject(tk[1]).Validate(vr)
                if !permitQueue {
                        vr.AddError(`Permission Subject "%s" is not allowed to contain queue`, subj)
                }
        default:
                vr.AddError(`Permission Subject "%s" contains too many spaces`, subj)
        }
}

// Validate the allow, deny elements of a permission
func (p *Permission) Validate(vr *ValidationResults, permitQueue bool) {
        for _, subj := range p.Allow {
                checkPermission(vr, subj, permitQueue)
        }
        for _, subj := range p.Deny {
                checkPermission(vr, subj, permitQueue)
        }
}

// ResponsePermission can be used to allow responses to any reply subject
// that is received on a valid subscription.
type ResponsePermission struct {
        MaxMsgs int           `json:"max"`
        Expires time.Duration `json:"ttl"`
}

// Validate the response permission.
func (p *ResponsePermission) Validate(_ *ValidationResults) {
        // Any values can be valid for now.
}

// Permissions are used to restrict subject access, either on a user or for everyone on a server by default
type Permissions struct {
        Pub  Permission          `json:"pub,omitempty"`
        Sub  Permission          `json:"sub,omitempty"`
        Resp *ResponsePermission `json:"resp,omitempty"`
}

// Validate the pub and sub fields in the permissions list
func (p *Permissions) Validate(vr *ValidationResults) {
        if p.Resp != nil {
                p.Resp.Validate(vr)
        }
        p.Sub.Validate(vr, true)
        p.Pub.Validate(vr, false)
}

// StringList is a wrapper for an array of strings
type StringList []string

// Contains returns true if the list contains the string
func (u *StringList) Contains(p string) bool {
        for _, t := range *u {
                if t == p {
                        return true
                }
        }
        return false
}

// Add appends 1 or more strings to a list
func (u *StringList) Add(p ...string) {
        for _, v := range p {
                if !u.Contains(v) && v != "" {
                        *u = append(*u, v)
                }
        }
}

// Remove removes 1 or more strings from a list
func (u *StringList) Remove(p ...string) {
        for _, v := range p {
                for i, t := range *u {
                        if t == v {
                                a := *u
                                *u = append(a[:i], a[i+1:]...)
                                break
                        }
                }
        }
}

// TagList is a unique array of lower case strings
// All tag list methods lower case the strings in the arguments
type TagList []string

// Contains returns true if the list contains the tags
func (u *TagList) Contains(p string) bool {
        p = strings.ToLower(strings.TrimSpace(p))
        for _, t := range *u {
                if t == p {
                        return true
                }
        }
        return false
}

// Add appends 1 or more tags to a list
func (u *TagList) Add(p ...string) {
        for _, v := range p {
                v = strings.ToLower(strings.TrimSpace(v))
                if !u.Contains(v) && v != "" {
                        *u = append(*u, v)
                }
        }
}

// Remove removes 1 or more tags from a list
func (u *TagList) Remove(p ...string) {
        for _, v := range p {
                v = strings.ToLower(strings.TrimSpace(v))
                for i, t := range *u {
                        if t == v {
                                a := *u
                                *u = append(a[:i], a[i+1:]...)
                                break
                        }
                }
        }
}

type CIDRList TagList

func (c *CIDRList) Contains(p string) bool {
        return (*TagList)(c).Contains(p)
}

func (c *CIDRList) Add(p ...string) {
        (*TagList)(c).Add(p...)
}

func (c *CIDRList) Remove(p ...string) {
        (*TagList)(c).Remove(p...)
}

func (c *CIDRList) Set(values string) {
        *c = CIDRList{}
        c.Add(strings.Split(strings.ToLower(values), ",")...)
}

func (c *CIDRList) UnmarshalJSON(body []byte) (err error) {
        // parse either as array of strings or comma separate list
        var request []string
        var list string
        if err := json.Unmarshal(body, &request); err == nil {
                *c = request
                return nil
        } else if err := json.Unmarshal(body, &list); err == nil {
                c.Set(list)
                return nil
        } else {
                return err
        }
}

1	/*
2	* Copyright 2018-2019 The NATS Authors
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 implied.
12	* See the License for the specific language governing permissions and
13	* limitations under the License.
14	*/
15
16	package jwt
17
18	import (
19	"encoding/json"
20	"fmt"
21	"net"
22	"net/url"
23	"reflect"
24	"strconv"
25	"strings"
26	"time"
27	)
28
29	const MaxInfoLength = 8 * 1024
30
31	type Info struct {
32	Description string `json:"description,omitempty"`
33	InfoURL string `json:"info_url,omitempty"`
34	}
35
36	func (s Info) Validate(vr *ValidationResults) {	122✔
37	if len(s.Description) > MaxInfoLength {	123✔
38	vr.AddError("Description is too long")	1✔
39	}	1✔
40	if s.InfoURL != "" {	130✔
41	if len(s.InfoURL) > MaxInfoLength {	8✔
42	vr.AddError("Info URL is too long")	×
43	}	×
44	u, err := url.Parse(s.InfoURL)	8✔
45	if err == nil && (u.Hostname() == "" \|\| u.Scheme == "") {	11✔
46	err = fmt.Errorf("no hostname or scheme")	3✔
47	}	3✔
48	if err != nil {	12✔
49	vr.AddError("error parsing info url: %v", err)	4✔
50	}	4✔
51	}
52	}
53
54	// ExportType defines the type of import/export.
55	type ExportType int
56
57	const (
58	// Unknown is used if we don't know the type
59	Unknown ExportType = iota
60	// Stream defines the type field value for a stream "stream"
61	Stream
62	// Service defines the type field value for a service "service"
63	Service
64	)
65
66	func (t ExportType) String() string {	4✔
67	switch t {	4✔
68	case Stream:	1✔
69	return "stream"	1✔
70	case Service:	1✔
71	return "service"	1✔
72	}
73	return "unknown"	2✔
74	}
75
76	// MarshalJSON marshals the enum as a quoted json string
77	func (t *ExportType) MarshalJSON() ([]byte, error) {	76✔
78	switch *t {	76✔
79	case Stream:	72✔
80	return []byte("\"stream\""), nil	72✔
81	case Service:	4✔
82	return []byte("\"service\""), nil	4✔
83	}
84	return nil, fmt.Errorf("unknown export type")	×
85	}
86
87	// UnmarshalJSON unmashals a quoted json string to the enum value
88	func (t *ExportType) UnmarshalJSON(b []byte) error {	37✔
89	var j string	37✔
90	err := json.Unmarshal(b, &j)	37✔
91	if err != nil {	37✔
92	return err	×
93	}	×
94	switch j {	37✔
95	case "stream":	32✔
96	*t = Stream	32✔
97	return nil	32✔
98	case "service":	5✔
99	*t = Service	5✔
100	return nil	5✔
101	}
102	return fmt.Errorf("unknown export type %q", j)	×
103	}
104
105	type RenamingSubject Subject
106
107	func (s RenamingSubject) Validate(from Subject, vr *ValidationResults) {	48✔
108	v := Subject(s)	48✔
109	v.Validate(vr)	48✔
110	if from == "" {	48✔
111	vr.AddError("subject cannot be empty")	×
112	}	×
113	if strings.Contains(string(s), " ") {	48✔
114	vr.AddError("subject %q cannot have spaces", v)	×
115	}	×
116	matchesSuffix := func(s Subject) bool {	144✔
117	return s == ">" \|\| strings.HasSuffix(string(s), ".>")	96✔
118	}	96✔
119	if matchesSuffix(v) != matchesSuffix(from) {	51✔
120	vr.AddError("both, renaming subject and subject, need to end or not end in >")	3✔
121	}	3✔
122	fromCnt := from.countTokenWildcards()	48✔
123	refCnt := 0	48✔
124	for _, tk := range strings.Split(string(v), ".") {	122✔
125	if tk == "*" {	89✔
126	refCnt++	15✔
127	}	15✔
128	if len(tk) < 2 {	103✔
129	continue	29✔
130	}
131	if tk[0] == '$' {	53✔
132	if idx, err := strconv.Atoi(tk[1:]); err == nil {	16✔
133	if idx > fromCnt {	9✔
134	vr.AddError("Reference $%d in %q reference * in %q that do not exist", idx, s, from)	1✔
135	} else {	8✔
136	refCnt++	7✔
137	}	7✔
138	}
139	}
140	}
141	if refCnt != fromCnt {	53✔
142	vr.AddError("subject does not contain enough * or reference wildcards $[0-9]")	5✔
143	}	5✔
144	}
145
146	// Replaces reference tokens with *
147	func (s RenamingSubject) ToSubject() Subject {	11✔
148	if !strings.Contains(string(s), "$") {	20✔
149	return Subject(s)	9✔
150	}	9✔
151	bldr := strings.Builder{}	2✔
152	tokens := strings.Split(string(s), ".")	2✔
153	for i, tk := range tokens {	10✔
154	convert := false	8✔
155	if len(tk) > 1 && tk[0] == '$' {	11✔
156	if _, err := strconv.Atoi(tk[1:]); err == nil {	6✔
157	convert = true	3✔
158	}	3✔
159	}
160	if convert {	11✔
161	bldr.WriteString("*")	3✔
162	} else {	8✔
163	bldr.WriteString(tk)	5✔
164	}	5✔
165	if i != len(tokens)-1 {	14✔
166	bldr.WriteString(".")	6✔
167	}	6✔
168	}
169	return Subject(bldr.String())	2✔
170	}
171
172	// Subject is a string that represents a NATS subject
173	type Subject string
174
175	// Validate checks that a subject string is valid, ie not empty and without spaces
176	func (s Subject) Validate(vr *ValidationResults) {	301✔
177	v := string(s)	301✔
178	if v == "" {	305✔
179	vr.AddError("subject cannot be empty")	4✔
180	// No other checks after that make sense	4✔
181	return	4✔
182	}	4✔
183	if strings.Contains(v, " ") {	301✔
184	vr.AddError("subject %q cannot have spaces", v)	4✔
185	}	4✔
186	if v[0] == '.' \|\| v[len(v)-1] == '.' {	301✔
187	vr.AddError("subject %q cannot start or end with a `.`", v)	4✔
188	}	4✔
189	if strings.Contains(v, "..") {	299✔
190	vr.AddError("subject %q cannot contain consecutive `.`", v)	2✔
191	}	2✔
192	}
193
194	func (s Subject) countTokenWildcards() int {	48✔
195	v := string(s)	48✔
196	if v == "*" {	49✔
197	return 1	1✔
198	}	1✔
199	cnt := 0	47✔
200	for _, t := range strings.Split(v, ".") {	124✔
201	if t == "*" {	94✔
202	cnt++	17✔
203	}	17✔
204	}
205	return cnt	47✔
206	}
207
208	// HasWildCards is used to check if a subject contains a > or *
209	func (s Subject) HasWildCards() bool {	46✔
210	v := string(s)	46✔
211	return strings.HasSuffix(v, ".>") \|\|	46✔
212	strings.Contains(v, ".*.") \|\|	46✔
213	strings.HasSuffix(v, ".*") \|\|	46✔
214	strings.HasPrefix(v, "*.") \|\|	46✔
215	v == "*" \|\|	46✔
216	v == ">"	46✔
217	}	46✔
218
219	// IsContainedIn does a simple test to see if the subject is contained in another subject
220	func (s Subject) IsContainedIn(other Subject) bool {	45✔
221	otherArray := strings.Split(string(other), ".")	45✔
222	myArray := strings.Split(string(s), ".")	45✔
223		45✔
224	if len(myArray) > len(otherArray) && otherArray[len(otherArray)-1] != ">" {	52✔
225	return false	7✔
226	}	7✔
227
228	if len(myArray) < len(otherArray) {	44✔
229	return false	6✔
230	}	6✔
231
232	for ind, tok := range otherArray {	82✔
233	myTok := myArray[ind]	50✔
234		50✔
235	if ind == len(otherArray)-1 && tok == ">" {	55✔
236	return true	5✔
237	}	5✔
238
239	if tok != myTok && tok != "*" {	51✔
240	return false	6✔
241	}	6✔
242	}
243
244	return true	21✔
245	}
246
247	// TimeRange is used to represent a start and end time
248	type TimeRange struct {
249	Start string `json:"start,omitempty"`
250	End string `json:"end,omitempty"`
251	}
252
253	// Validate checks the values in a time range struct
254	func (tr TimeRange) Validate(vr ValidationResults) {	14✔
255	format := "15:04:05"	14✔
256		14✔
257	if tr.Start == "" {	15✔
258	vr.AddError("time ranges start must contain a start")	1✔
259	} else {	14✔
260	_, err := time.Parse(format, tr.Start)	13✔
261	if err != nil {	15✔
262	vr.AddError("start in time range is invalid %q", tr.Start)	2✔
263	}	2✔
264	}
265
266	if tr.End == "" {	15✔
267	vr.AddError("time ranges end must contain an end")	1✔
268	} else {	14✔
269	_, err := time.Parse(format, tr.End)	13✔
270	if err != nil {	14✔
271	vr.AddError("end in time range is invalid %q", tr.End)	1✔
272	}	1✔
273	}
274	}
275
276	// Src is a comma separated list of CIDR specifications
277	type UserLimits struct {
278	Src CIDRList `json:"src,omitempty"`
279	Times []TimeRange `json:"times,omitempty"`
280	Locale string `json:"times_location,omitempty"`
281	}
282
283	func (u *UserLimits) Empty() bool {	×
284	return reflect.DeepEqual(*u, UserLimits{})	×
285	}	×
286
287	func (u *UserLimits) IsUnlimited() bool {	1✔
288	return len(u.Src) == 0 && len(u.Times) == 0	1✔
289	}	1✔
290
291	// Limits are used to control acccess for users and importing accounts
292	type Limits struct {
293	UserLimits
294	NatsLimits
295	}
296
297	func (l *Limits) IsUnlimited() bool {	1✔
298	return l.UserLimits.IsUnlimited() && l.NatsLimits.IsUnlimited()	1✔
299	}	1✔
300
301	// Validate checks the values in a limit struct
302	func (l Limits) Validate(vr ValidationResults) {	15✔
303	if len(l.Src) != 0 {	28✔
304	for _, cidr := range l.Src {	33✔
305	_, ipNet, err := net.ParseCIDR(cidr)	20✔
306	if err != nil \|\| ipNet == nil {	26✔
307	vr.AddError("invalid cidr %q in user src limits", cidr)	6✔
308	}	6✔
309	}
310	}
311
312	if len(l.Times) > 0 {	20✔
313	for _, t := range l.Times {	15✔
314	t.Validate(vr)	10✔
315	}	10✔
316	}
317
318	if l.Locale != "" {	20✔
319	if _, err := time.LoadLocation(l.Locale); err != nil {	6✔
320	vr.AddError("could not parse iana time zone by name: %v", err)	1✔
321	}	1✔
322	}
323	}
324
325	// Permission defines allow/deny subjects
326	type Permission struct {
327	Allow StringList `json:"allow,omitempty"`
328	Deny StringList `json:"deny,omitempty"`
329	}
330
331	func (p *Permission) Empty() bool {	×
332	return len(p.Allow) == 0 && len(p.Deny) == 0	×
333	}	×
334
335	func checkPermission(vr *ValidationResults, subj string, permitQueue bool) {	56✔
336	tk := strings.Split(subj, " ")	56✔
337	switch len(tk) {	56✔
338	case 1:	34✔
339	Subject(tk[0]).Validate(vr)	34✔
340	case 2:	20✔
341	Subject(tk[0]).Validate(vr)	20✔
342	Subject(tk[1]).Validate(vr)	20✔
343	if !permitQueue {	22✔
344	vr.AddError(`Permission Subject "%s" is not allowed to contain queue`, subj)	2✔
345	}	2✔
346	default:	2✔
347	vr.AddError(`Permission Subject "%s" contains too many spaces`, subj)	2✔
348	}
349	}
350
351	// Validate the allow, deny elements of a permission
352	func (p Permission) Validate(vr ValidationResults, permitQueue bool) {	178✔
353	for _, subj := range p.Allow {	206✔
354	checkPermission(vr, subj, permitQueue)	28✔
355	}	28✔
356	for _, subj := range p.Deny {	206✔
357	checkPermission(vr, subj, permitQueue)	28✔
358	}	28✔
359	}
360
361	// ResponsePermission can be used to allow responses to any reply subject
362	// that is received on a valid subscription.
363	type ResponsePermission struct {
364	MaxMsgs int `json:"max"`
365	Expires time.Duration `json:"ttl"`
366	}
367
368	// Validate the response permission.
369	func (p ResponsePermission) Validate(_ ValidationResults) {	13✔
370	// Any values can be valid for now.	13✔
371	}	13✔
372
373	// Permissions are used to restrict subject access, either on a user or for everyone on a server by default
374	type Permissions struct {
375	Pub Permission `json:"pub,omitempty"`
376	Sub Permission `json:"sub,omitempty"`
377	Resp *ResponsePermission `json:"resp,omitempty"`
378	}
379
380	// Validate the pub and sub fields in the permissions list
381	func (p Permissions) Validate(vr ValidationResults) {	89✔
382	if p.Resp != nil {	102✔
383	p.Resp.Validate(vr)	13✔
384	}	13✔
385	p.Sub.Validate(vr, true)	89✔
386	p.Pub.Validate(vr, false)	89✔
387	}
388
389	// StringList is a wrapper for an array of strings
390	type StringList []string
391
392	// Contains returns true if the list contains the string
393	func (u *StringList) Contains(p string) bool {	103✔
394	for _, t := range *u {	268✔
395	if t == p {	184✔
396	return true	19✔
397	}	19✔
398	}
399	return false	84✔
400	}
401
402	// Add appends 1 or more strings to a list
403	func (u *StringList) Add(p ...string) {	87✔
404	for _, v := range p {	163✔
405	if !u.Contains(v) && v != "" {	149✔
406	u = append(u, v)	73✔
407	}	73✔
408	}
409	}
410
411	// Remove removes 1 or more strings from a list
412	func (u *StringList) Remove(p ...string) {	3✔
413	for _, v := range p {	6✔
414	for i, t := range *u {	7✔
415	if t == v {	6✔
416	a := *u	2✔
417	*u = append(a[:i], a[i+1:]...)	2✔
418	break	2✔
419	}
420	}
421	}
422	}
423
424	// TagList is a unique array of lower case strings
425	// All tag list methods lower case the strings in the arguments
426	type TagList []string
427
428	// Contains returns true if the list contains the tags
429	func (u *TagList) Contains(p string) bool {	31✔
430	p = strings.ToLower(strings.TrimSpace(p))	31✔
431	for _, t := range *u {	59✔
432	if t == p {	36✔
433	return true	8✔
434	}	8✔
435	}
436	return false	23✔
437	}
438
439	// Add appends 1 or more tags to a list
440	func (u *TagList) Add(p ...string) {	15✔
441	for _, v := range p {	37✔
442	v = strings.ToLower(strings.TrimSpace(v))	22✔
443	if !u.Contains(v) && v != "" {	43✔
444	u = append(u, v)	21✔
445	}	21✔
446	}
447	}
448
449	// Remove removes 1 or more tags from a list
450	func (u *TagList) Remove(p ...string) {	1✔
451	for _, v := range p {	2✔
452	v = strings.ToLower(strings.TrimSpace(v))	1✔
453	for i, t := range *u {	2✔
454	if t == v {	2✔
455	a := *u	1✔
456	*u = append(a[:i], a[i+1:]...)	1✔
457	break	1✔
458	}
459	}
460	}
461	}
462
463	type CIDRList TagList
464
UNCOV 465	func (c *CIDRList) Contains(p string) bool {	×
NEW 466	return (*TagList)(c).Contains(p)	×
UNCOV 467	}	×
468
469	func (c *CIDRList) Add(p ...string) {	6✔
470	(*TagList)(c).Add(p...)	6✔
471	}	6✔
472
473	func (c *CIDRList) Remove(p ...string) {	×
NEW 474	(*TagList)(c).Remove(p...)	×
475	}	×
476
477	func (c *CIDRList) Set(values string) {	6✔
478	*c = CIDRList{}	6✔
479	c.Add(strings.Split(strings.ToLower(values), ",")...)	6✔
480	}	6✔
481
482	func (c *CIDRList) UnmarshalJSON(body []byte) (err error) {	×
483	// parse either as array of strings or comma separate list	×
484	var request []string	×
485	var list string	×
486	if err := json.Unmarshal(body, &request); err == nil {	×
487	*c = request	×
488	return nil	×
489	} else if err := json.Unmarshal(body, &list); err == nil {	×
490	c.Set(list)	×
491	return nil	×
492	} else {	×
493	return err	×
494	}	×
495	}

nats-io / jwt / 11261855873

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous