podman

1
package validator
2

3
import (
4
	"fmt"
5
	"reflect"
6
	"regexp"
7
	"strconv"
8
	"strings"
9
	"time"
10
)
11

12
// extractTypeInternal gets the actual underlying type of field value.
13
// It will dive into pointers, customTypes and return you the
14
// underlying value and it's kind.
15
func (v *validate) extractTypeInternal(current reflect.Value, nullable bool) (reflect.Value, reflect.Kind, bool) {
16

17
BEGIN:
18
	switch current.Kind() {
19
	case reflect.Ptr:
20

21
		nullable = true
22

23
		if current.IsNil() {
24
			return current, reflect.Ptr, nullable
25
		}
26

27
		current = current.Elem()
28
		goto BEGIN
29

30
	case reflect.Interface:
31

32
		nullable = true
33

34
		if current.IsNil() {
35
			return current, reflect.Interface, nullable
36
		}
37

38
		current = current.Elem()
39
		goto BEGIN
40

41
	case reflect.Invalid:
42
		return current, reflect.Invalid, nullable
43

44
	default:
45

46
		if v.v.hasCustomFuncs {
47

48
			if fn, ok := v.v.customFuncs[current.Type()]; ok {
49
				current = reflect.ValueOf(fn(current))
50
				goto BEGIN
51
			}
52
		}
53

54
		return current, current.Kind(), nullable
55
	}
56
}
57

58
// getStructFieldOKInternal traverses a struct to retrieve a specific field denoted by the provided namespace and
59
// returns the field, field kind and whether is was successful in retrieving the field at all.
60
//
61
// NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
62
// could not be retrieved because it didn't exist.
63
func (v *validate) getStructFieldOKInternal(val reflect.Value, namespace string) (current reflect.Value, kind reflect.Kind, nullable bool, found bool) {
64

65
BEGIN:
66
	current, kind, nullable = v.ExtractType(val)
67
	if kind == reflect.Invalid {
68
		return
69
	}
70

71
	if namespace == "" {
72
		found = true
73
		return
74
	}
75

76
	switch kind {
77

78
	case reflect.Ptr, reflect.Interface:
79
		return
80

81
	case reflect.Struct:
82

83
		typ := current.Type()
84
		fld := namespace
85
		var ns string
86

87
		if !typ.ConvertibleTo(timeType) {
88

89
			idx := strings.Index(namespace, namespaceSeparator)
90

91
			if idx != -1 {
92
				fld = namespace[:idx]
93
				ns = namespace[idx+1:]
94
			} else {
95
				ns = ""
96
			}
97

98
			bracketIdx := strings.Index(fld, leftBracket)
99
			if bracketIdx != -1 {
100
				fld = fld[:bracketIdx]
101

102
				ns = namespace[bracketIdx:]
103
			}
104

105
			val = current.FieldByName(fld)
106
			namespace = ns
107
			goto BEGIN
108
		}
109

110
	case reflect.Array, reflect.Slice:
111
		idx := strings.Index(namespace, leftBracket)
112
		idx2 := strings.Index(namespace, rightBracket)
113

114
		arrIdx, _ := strconv.Atoi(namespace[idx+1 : idx2])
115

116
		if arrIdx >= current.Len() {
117
			return
118
		}
119

120
		startIdx := idx2 + 1
121

122
		if startIdx < len(namespace) {
123
			if namespace[startIdx:startIdx+1] == namespaceSeparator {
124
				startIdx++
125
			}
126
		}
127

128
		val = current.Index(arrIdx)
129
		namespace = namespace[startIdx:]
130
		goto BEGIN
131

132
	case reflect.Map:
133
		idx := strings.Index(namespace, leftBracket) + 1
134
		idx2 := strings.Index(namespace, rightBracket)
135

136
		endIdx := idx2
137

138
		if endIdx+1 < len(namespace) {
139
			if namespace[endIdx+1:endIdx+2] == namespaceSeparator {
140
				endIdx++
141
			}
142
		}
143

144
		key := namespace[idx:idx2]
145

146
		switch current.Type().Key().Kind() {
147
		case reflect.Int:
148
			i, _ := strconv.Atoi(key)
149
			val = current.MapIndex(reflect.ValueOf(i))
150
			namespace = namespace[endIdx+1:]
151

152
		case reflect.Int8:
153
			i, _ := strconv.ParseInt(key, 10, 8)
154
			val = current.MapIndex(reflect.ValueOf(int8(i)))
155
			namespace = namespace[endIdx+1:]
156

157
		case reflect.Int16:
158
			i, _ := strconv.ParseInt(key, 10, 16)
159
			val = current.MapIndex(reflect.ValueOf(int16(i)))
160
			namespace = namespace[endIdx+1:]
161

162
		case reflect.Int32:
163
			i, _ := strconv.ParseInt(key, 10, 32)
164
			val = current.MapIndex(reflect.ValueOf(int32(i)))
165
			namespace = namespace[endIdx+1:]
166

167
		case reflect.Int64:
168
			i, _ := strconv.ParseInt(key, 10, 64)
169
			val = current.MapIndex(reflect.ValueOf(i))
170
			namespace = namespace[endIdx+1:]
171

172
		case reflect.Uint:
173
			i, _ := strconv.ParseUint(key, 10, 0)
174
			val = current.MapIndex(reflect.ValueOf(uint(i)))
175
			namespace = namespace[endIdx+1:]
176

177
		case reflect.Uint8:
178
			i, _ := strconv.ParseUint(key, 10, 8)
179
			val = current.MapIndex(reflect.ValueOf(uint8(i)))
180
			namespace = namespace[endIdx+1:]
181

182
		case reflect.Uint16:
183
			i, _ := strconv.ParseUint(key, 10, 16)
184
			val = current.MapIndex(reflect.ValueOf(uint16(i)))
185
			namespace = namespace[endIdx+1:]
186

187
		case reflect.Uint32:
188
			i, _ := strconv.ParseUint(key, 10, 32)
189
			val = current.MapIndex(reflect.ValueOf(uint32(i)))
190
			namespace = namespace[endIdx+1:]
191

192
		case reflect.Uint64:
193
			i, _ := strconv.ParseUint(key, 10, 64)
194
			val = current.MapIndex(reflect.ValueOf(i))
195
			namespace = namespace[endIdx+1:]
196

197
		case reflect.Float32:
198
			f, _ := strconv.ParseFloat(key, 32)
199
			val = current.MapIndex(reflect.ValueOf(float32(f)))
200
			namespace = namespace[endIdx+1:]
201

202
		case reflect.Float64:
203
			f, _ := strconv.ParseFloat(key, 64)
204
			val = current.MapIndex(reflect.ValueOf(f))
205
			namespace = namespace[endIdx+1:]
206

207
		case reflect.Bool:
208
			b, _ := strconv.ParseBool(key)
209
			val = current.MapIndex(reflect.ValueOf(b))
210
			namespace = namespace[endIdx+1:]
211

212
		// reflect.Type = string
213
		default:
214
			val = current.MapIndex(reflect.ValueOf(key))
215
			namespace = namespace[endIdx+1:]
216
		}
217

218
		goto BEGIN
219
	}
220

221
	// if got here there was more namespace, cannot go any deeper
222
	panic("Invalid field namespace")
223
}
224

225
// asInt returns the parameter as a int64
226
// or panics if it can't convert
227
func asInt(param string) int64 {
228
	i, err := strconv.ParseInt(param, 0, 64)
229
	panicIf(err)
230

231
	return i
232
}
233

234
// asIntFromTimeDuration parses param as time.Duration and returns it as int64
235
// or panics on error.
236
func asIntFromTimeDuration(param string) int64 {
237
	d, err := time.ParseDuration(param)
238
	if err != nil {
239
		// attempt parsing as an integer assuming nanosecond precision
240
		return asInt(param)
241
	}
242
	return int64(d)
243
}
244

245
// asIntFromType calls the proper function to parse param as int64,
246
// given a field's Type t.
247
func asIntFromType(t reflect.Type, param string) int64 {
248
	switch t {
249
	case timeDurationType:
250
		return asIntFromTimeDuration(param)
251
	default:
252
		return asInt(param)
253
	}
254
}
255

256
// asUint returns the parameter as a uint64
257
// or panics if it can't convert
258
func asUint(param string) uint64 {
259

260
	i, err := strconv.ParseUint(param, 0, 64)
261
	panicIf(err)
262

263
	return i
264
}
265

266
// asFloat64 returns the parameter as a float64
267
// or panics if it can't convert
268
func asFloat64(param string) float64 {
269
	i, err := strconv.ParseFloat(param, 64)
270
	panicIf(err)
271
	return i
272
}
273

274
// asFloat64 returns the parameter as a float64
275
// or panics if it can't convert
276
func asFloat32(param string) float64 {
277
	i, err := strconv.ParseFloat(param, 32)
278
	panicIf(err)
279
	return i
280
}
281

282
// asBool returns the parameter as a bool
283
// or panics if it can't convert
284
func asBool(param string) bool {
285

286
	i, err := strconv.ParseBool(param)
287
	panicIf(err)
288

289
	return i
290
}
291

292
func panicIf(err error) {
293
	if err != nil {
294
		panic(err.Error())
295
	}
296
}
297

298
// Checks if field value matches regex. If fl.Field can be cast to Stringer, it uses the Stringer interfaces
299
// String() return value. Otherwise, it uses fl.Field's String() value.
300
func fieldMatchesRegexByStringerValOrString(regex *regexp.Regexp, fl FieldLevel) bool {
301
	switch fl.Field().Kind() {
302
	case reflect.String:
303
		return regex.MatchString(fl.Field().String())
304
	default:
305
		if stringer, ok := fl.Field().Interface().(fmt.Stringer); ok {
306
			return regex.MatchString(stringer.String())
307
		} else {
308
			return regex.MatchString(fl.Field().String())
309
		}
310
	}
311
}
312