podman

1
package validator
2

3
import (
4
	"context"
5
	"fmt"
6
	"reflect"
7
	"strconv"
8
)
9

10
// per validate construct
11
type validate struct {
12
	v              *Validate
13
	top            reflect.Value
14
	ns             []byte
15
	actualNs       []byte
16
	errs           ValidationErrors
17
	includeExclude map[string]struct{} // reset only if StructPartial or StructExcept are called, no need otherwise
18
	ffn            FilterFunc
19
	slflParent     reflect.Value // StructLevel & FieldLevel
20
	slCurrent      reflect.Value // StructLevel & FieldLevel
21
	flField        reflect.Value // StructLevel & FieldLevel
22
	cf             *cField       // StructLevel & FieldLevel
23
	ct             *cTag         // StructLevel & FieldLevel
24
	misc           []byte        // misc reusable
25
	str1           string        // misc reusable
26
	str2           string        // misc reusable
27
	fldIsPointer   bool          // StructLevel & FieldLevel
28
	isPartial      bool
29
	hasExcludes    bool
30
}
31

32
// parent and current will be the same the first run of validateStruct
33
func (v *validate) validateStruct(ctx context.Context, parent reflect.Value, current reflect.Value, typ reflect.Type, ns []byte, structNs []byte, ct *cTag) {
34

35
	cs, ok := v.v.structCache.Get(typ)
36
	if !ok {
37
		cs = v.v.extractStructCache(current, typ.Name())
38
	}
39

40
	if len(ns) == 0 && len(cs.name) != 0 {
41

42
		ns = append(ns, cs.name...)
43
		ns = append(ns, '.')
44

45
		structNs = append(structNs, cs.name...)
46
		structNs = append(structNs, '.')
47
	}
48

49
	// ct is nil on top level struct, and structs as fields that have no tag info
50
	// so if nil or if not nil and the structonly tag isn't present
51
	if ct == nil || ct.typeof != typeStructOnly {
52

53
		var f *cField
54

55
		for i := 0; i < len(cs.fields); i++ {
56

57
			f = cs.fields[i]
58

59
			if v.isPartial {
60

61
				if v.ffn != nil {
62
					// used with StructFiltered
63
					if v.ffn(append(structNs, f.name...)) {
64
						continue
65
					}
66

67
				} else {
68
					// used with StructPartial & StructExcept
69
					_, ok = v.includeExclude[string(append(structNs, f.name...))]
70

71
					if (ok && v.hasExcludes) || (!ok && !v.hasExcludes) {
72
						continue
73
					}
74
				}
75
			}
76

77
			v.traverseField(ctx, current, current.Field(f.idx), ns, structNs, f, f.cTags)
78
		}
79
	}
80

81
	// check if any struct level validations, after all field validations already checked.
82
	// first iteration will have no info about nostructlevel tag, and is checked prior to
83
	// calling the next iteration of validateStruct called from traverseField.
84
	if cs.fn != nil {
85

86
		v.slflParent = parent
87
		v.slCurrent = current
88
		v.ns = ns
89
		v.actualNs = structNs
90

91
		cs.fn(ctx, v)
92
	}
93
}
94

95
// traverseField validates any field, be it a struct or single field, ensures it's validity and passes it along to be validated via it's tag options
96
func (v *validate) traverseField(ctx context.Context, parent reflect.Value, current reflect.Value, ns []byte, structNs []byte, cf *cField, ct *cTag) {
97
	var typ reflect.Type
98
	var kind reflect.Kind
99

100
	current, kind, v.fldIsPointer = v.extractTypeInternal(current, false)
101

102
	var isNestedStruct bool
103

104
	switch kind {
105
	case reflect.Ptr, reflect.Interface, reflect.Invalid:
106

107
		if ct == nil {
108
			return
109
		}
110

111
		if ct.typeof == typeOmitEmpty || ct.typeof == typeIsDefault {
112
			return
113
		}
114

115
		if ct.typeof == typeOmitNil && (kind != reflect.Invalid && current.IsNil()) {
116
			return
117
		}
118

119
		if ct.hasTag {
120
			if kind == reflect.Invalid {
121
				v.str1 = string(append(ns, cf.altName...))
122
				if v.v.hasTagNameFunc {
123
					v.str2 = string(append(structNs, cf.name...))
124
				} else {
125
					v.str2 = v.str1
126
				}
127
				v.errs = append(v.errs,
128
					&fieldError{
129
						v:              v.v,
130
						tag:            ct.aliasTag,
131
						actualTag:      ct.tag,
132
						ns:             v.str1,
133
						structNs:       v.str2,
134
						fieldLen:       uint8(len(cf.altName)),
135
						structfieldLen: uint8(len(cf.name)),
136
						param:          ct.param,
137
						kind:           kind,
138
					},
139
				)
140
				return
141
			}
142

143
			v.str1 = string(append(ns, cf.altName...))
144
			if v.v.hasTagNameFunc {
145
				v.str2 = string(append(structNs, cf.name...))
146
			} else {
147
				v.str2 = v.str1
148
			}
149
			if !ct.runValidationWhenNil {
150
				v.errs = append(v.errs,
151
					&fieldError{
152
						v:              v.v,
153
						tag:            ct.aliasTag,
154
						actualTag:      ct.tag,
155
						ns:             v.str1,
156
						structNs:       v.str2,
157
						fieldLen:       uint8(len(cf.altName)),
158
						structfieldLen: uint8(len(cf.name)),
159
						value:          current.Interface(),
160
						param:          ct.param,
161
						kind:           kind,
162
						typ:            current.Type(),
163
					},
164
				)
165
				return
166
			}
167
		}
168

169
		if kind == reflect.Invalid {
170
			return
171
		}
172

173
	case reflect.Struct:
174
		isNestedStruct = !current.Type().ConvertibleTo(timeType)
175
		// For backward compatibility before struct level validation tags were supported
176
		// as there were a number of projects relying on `required` not failing on non-pointer
177
		// structs. Since it's basically nonsensical to use `required` with a non-pointer struct
178
		// are explicitly skipping the required validation for it. This WILL be removed in the
179
		// next major version.
180
		if isNestedStruct && !v.v.requiredStructEnabled && ct != nil && ct.tag == requiredTag {
181
			ct = ct.next
182
		}
183
	}
184

185
	typ = current.Type()
186

187
OUTER:
188
	for {
189
		if ct == nil || !ct.hasTag || (isNestedStruct && len(cf.name) == 0) {
190
			// isNestedStruct check here
191
			if isNestedStruct {
192
				// if len == 0 then validating using 'Var' or 'VarWithValue'
193
				// Var - doesn't make much sense to do it that way, should call 'Struct', but no harm...
194
				// VarWithField - this allows for validating against each field within the struct against a specific value
195
				//                pretty handy in certain situations
196
				if len(cf.name) > 0 {
197
					ns = append(append(ns, cf.altName...), '.')
198
					structNs = append(append(structNs, cf.name...), '.')
199
				}
200

201
				v.validateStruct(ctx, parent, current, typ, ns, structNs, ct)
202
			}
203
			return
204
		}
205

206
		switch ct.typeof {
207
		case typeNoStructLevel:
208
			return
209

210
		case typeStructOnly:
211
			if isNestedStruct {
212
				// if len == 0 then validating using 'Var' or 'VarWithValue'
213
				// Var - doesn't make much sense to do it that way, should call 'Struct', but no harm...
214
				// VarWithField - this allows for validating against each field within the struct against a specific value
215
				//                pretty handy in certain situations
216
				if len(cf.name) > 0 {
217
					ns = append(append(ns, cf.altName...), '.')
218
					structNs = append(append(structNs, cf.name...), '.')
219
				}
220

221
				v.validateStruct(ctx, parent, current, typ, ns, structNs, ct)
222
			}
223
			return
224

225
		case typeOmitEmpty:
226

227
			// set Field Level fields
228
			v.slflParent = parent
229
			v.flField = current
230
			v.cf = cf
231
			v.ct = ct
232

233
			if !hasValue(v) {
234
				return
235
			}
236

237
			ct = ct.next
238
			continue
239

240
		case typeOmitNil:
241
			v.slflParent = parent
242
			v.flField = current
243
			v.cf = cf
244
			v.ct = ct
245

246
			switch field := v.Field(); field.Kind() {
247
			case reflect.Slice, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func:
248
				if field.IsNil() {
249
					return
250
				}
251
			default:
252
				if v.fldIsPointer && field.Interface() == nil {
253
					return
254
				}
255
			}
256

257
			ct = ct.next
258
			continue
259

260
		case typeEndKeys:
261
			return
262

263
		case typeDive:
264

265
			ct = ct.next
266

267
			// traverse slice or map here
268
			// or panic ;)
269
			switch kind {
270
			case reflect.Slice, reflect.Array:
271

272
				var i64 int64
273
				reusableCF := &cField{}
274

275
				for i := 0; i < current.Len(); i++ {
276

277
					i64 = int64(i)
278

279
					v.misc = append(v.misc[0:0], cf.name...)
280
					v.misc = append(v.misc, '[')
281
					v.misc = strconv.AppendInt(v.misc, i64, 10)
282
					v.misc = append(v.misc, ']')
283

284
					reusableCF.name = string(v.misc)
285

286
					if cf.namesEqual {
287
						reusableCF.altName = reusableCF.name
288
					} else {
289

290
						v.misc = append(v.misc[0:0], cf.altName...)
291
						v.misc = append(v.misc, '[')
292
						v.misc = strconv.AppendInt(v.misc, i64, 10)
293
						v.misc = append(v.misc, ']')
294

295
						reusableCF.altName = string(v.misc)
296
					}
297
					v.traverseField(ctx, parent, current.Index(i), ns, structNs, reusableCF, ct)
298
				}
299

300
			case reflect.Map:
301

302
				var pv string
303
				reusableCF := &cField{}
304

305
				for _, key := range current.MapKeys() {
306

307
					pv = fmt.Sprintf("%v", key.Interface())
308

309
					v.misc = append(v.misc[0:0], cf.name...)
310
					v.misc = append(v.misc, '[')
311
					v.misc = append(v.misc, pv...)
312
					v.misc = append(v.misc, ']')
313

314
					reusableCF.name = string(v.misc)
315

316
					if cf.namesEqual {
317
						reusableCF.altName = reusableCF.name
318
					} else {
319
						v.misc = append(v.misc[0:0], cf.altName...)
320
						v.misc = append(v.misc, '[')
321
						v.misc = append(v.misc, pv...)
322
						v.misc = append(v.misc, ']')
323

324
						reusableCF.altName = string(v.misc)
325
					}
326

327
					if ct != nil && ct.typeof == typeKeys && ct.keys != nil {
328
						v.traverseField(ctx, parent, key, ns, structNs, reusableCF, ct.keys)
329
						// can be nil when just keys being validated
330
						if ct.next != nil {
331
							v.traverseField(ctx, parent, current.MapIndex(key), ns, structNs, reusableCF, ct.next)
332
						}
333
					} else {
334
						v.traverseField(ctx, parent, current.MapIndex(key), ns, structNs, reusableCF, ct)
335
					}
336
				}
337

338
			default:
339
				// throw error, if not a slice or map then should not have gotten here
340
				// bad dive tag
341
				panic("dive error! can't dive on a non slice or map")
342
			}
343

344
			return
345

346
		case typeOr:
347

348
			v.misc = v.misc[0:0]
349

350
			for {
351

352
				// set Field Level fields
353
				v.slflParent = parent
354
				v.flField = current
355
				v.cf = cf
356
				v.ct = ct
357

358
				if ct.fn(ctx, v) {
359
					if ct.isBlockEnd {
360
						ct = ct.next
361
						continue OUTER
362
					}
363

364
					// drain rest of the 'or' values, then continue or leave
365
					for {
366

367
						ct = ct.next
368

369
						if ct == nil {
370
							continue OUTER
371
						}
372

373
						if ct.typeof != typeOr {
374
							continue OUTER
375
						}
376

377
						if ct.isBlockEnd {
378
							ct = ct.next
379
							continue OUTER
380
						}
381
					}
382
				}
383

384
				v.misc = append(v.misc, '|')
385
				v.misc = append(v.misc, ct.tag...)
386

387
				if ct.hasParam {
388
					v.misc = append(v.misc, '=')
389
					v.misc = append(v.misc, ct.param...)
390
				}
391

392
				if ct.isBlockEnd || ct.next == nil {
393
					// if we get here, no valid 'or' value and no more tags
394
					v.str1 = string(append(ns, cf.altName...))
395

396
					if v.v.hasTagNameFunc {
397
						v.str2 = string(append(structNs, cf.name...))
398
					} else {
399
						v.str2 = v.str1
400
					}
401

402
					if ct.hasAlias {
403

404
						v.errs = append(v.errs,
405
							&fieldError{
406
								v:              v.v,
407
								tag:            ct.aliasTag,
408
								actualTag:      ct.actualAliasTag,
409
								ns:             v.str1,
410
								structNs:       v.str2,
411
								fieldLen:       uint8(len(cf.altName)),
412
								structfieldLen: uint8(len(cf.name)),
413
								value:          current.Interface(),
414
								param:          ct.param,
415
								kind:           kind,
416
								typ:            typ,
417
							},
418
						)
419

420
					} else {
421

422
						tVal := string(v.misc)[1:]
423

424
						v.errs = append(v.errs,
425
							&fieldError{
426
								v:              v.v,
427
								tag:            tVal,
428
								actualTag:      tVal,
429
								ns:             v.str1,
430
								structNs:       v.str2,
431
								fieldLen:       uint8(len(cf.altName)),
432
								structfieldLen: uint8(len(cf.name)),
433
								value:          current.Interface(),
434
								param:          ct.param,
435
								kind:           kind,
436
								typ:            typ,
437
							},
438
						)
439
					}
440

441
					return
442
				}
443

444
				ct = ct.next
445
			}
446

447
		default:
448

449
			// set Field Level fields
450
			v.slflParent = parent
451
			v.flField = current
452
			v.cf = cf
453
			v.ct = ct
454

455
			if !ct.fn(ctx, v) {
456
				v.str1 = string(append(ns, cf.altName...))
457

458
				if v.v.hasTagNameFunc {
459
					v.str2 = string(append(structNs, cf.name...))
460
				} else {
461
					v.str2 = v.str1
462
				}
463

464
				v.errs = append(v.errs,
465
					&fieldError{
466
						v:              v.v,
467
						tag:            ct.aliasTag,
468
						actualTag:      ct.tag,
469
						ns:             v.str1,
470
						structNs:       v.str2,
471
						fieldLen:       uint8(len(cf.altName)),
472
						structfieldLen: uint8(len(cf.name)),
473
						value:          current.Interface(),
474
						param:          ct.param,
475
						kind:           kind,
476
						typ:            typ,
477
					},
478
				)
479

480
				return
481
			}
482
			ct = ct.next
483
		}
484
	}
485

486
}
487