1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// Copyright (C) 2016-2017 Luke Shumaker <lukeshu@sbcglobal.net>
//
// 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 sd_login
import (
"strings"
)
func valid_session_name(id string) bool {
if id == "" {
return false
}
return strings.TrimLeft(id, letters+digits) == ""
}
func valid_slice_name(s string) bool {
return strings.HasSuffix(s, ".slice") && valid_unit_name(s) == unit_name_plain
}
func valid_filename(s string) bool {
switch s {
case "", ".", "..":
return false
}
if strings.ContainsRune(s, '/') {
return false
}
return true
}
const (
unit_name_invalid = 0
unit_name_plain = 1 << 0 // foo.service
unit_name_instance = 1 << 1 // foo@bar.service
unit_name_template = 1 << 2 // foo@.service
)
// valid_unit_name returns returns which type of unit the given unit
// name is valid for.
//
// To simply check whether a unit name is valid, without caring about
// the type, you can simply check that it doesn't return the "invalid"
// type:
//
// is_valid := valid_unit_name(unitname) != unit_name_invalid
//
// To check whether it matches a specific type (in this example,
// "template"), you can test equality against that type:
//
// is_valid_template := valid_unit_name(unitname) == unit_name_template
//
// If there are several acceptable types, you can treat multiple types
// as bitmasks, and use the usual bitfield checks:
//
// is_valid_plain_or_instance := valid_unit_name(unitname)&(unit_name_plain|unit_name_instance) != 0
func valid_unit_name(unit string) int {
const_unit_name_max := 256
const_unit_types := []string{
"service",
"socket",
"busname",
"target",
"device",
"mount",
"automount",
"swap",
"timer",
"path",
"slice",
"scope",
}
if unit == "" {
return unit_name_invalid
}
// If the unit name is too long
if len(unit) >= const_unit_name_max {
return unit_name_invalid
}
// If there is no dot in the unit name
dot := strings.LastIndexByte(unit, '.')
if dot < 0 || dot == 0 {
return unit_name_invalid
}
// If the .suffix isn't a real unit type
utype := unit[dot+1:]
found := false
for _, _utype := range const_unit_types {
if utype == _utype {
found = true
break
}
}
if !found {
return unit_name_invalid
}
at := strings.IndexByte(unit, '@')
// If the unit has more than one '@'
if at >= 0 && strings.IndexByte(unit[at+1:], '@') >= 0 {
return unit_name_invalid
}
// If the '@' is at the start of the unit
if at == 0 {
return unit_name_invalid
}
if at < 0 {
return unit_name_plain
} else {
if dot > at+1 {
return unit_name_instance
}
if dot == at+1 {
return unit_name_template
}
}
return unit_name_invalid
}
|
