podman

1
// Package govalidator is package of validators and sanitizers for strings, structs and collections.
2
package govalidator
3

4
import (
5
	"bytes"
6
	"crypto/rsa"
7
	"crypto/x509"
8
	"encoding/base64"
9
	"encoding/json"
10
	"encoding/pem"
11
	"fmt"
12
	"io/ioutil"
13
	"net"
14
	"net/url"
15
	"reflect"
16
	"regexp"
17
	"sort"
18
	"strconv"
19
	"strings"
20
	"time"
21
	"unicode"
22
	"unicode/utf8"
23
)
24

25
var (
26
	fieldsRequiredByDefault bool
27
	nilPtrAllowedByRequired = false
28
	notNumberRegexp         = regexp.MustCompile("[^0-9]+")
29
	whiteSpacesAndMinus     = regexp.MustCompile(`[\s-]+`)
30
	paramsRegexp            = regexp.MustCompile(`\(.*\)$`)
31
)
32

33
const maxURLRuneCount = 2083
34
const minURLRuneCount = 3
35
const rfc3339WithoutZone = "2006-01-02T15:04:05"
36

37
// SetFieldsRequiredByDefault causes validation to fail when struct fields
38
// do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`).
39
// This struct definition will fail govalidator.ValidateStruct() (and the field values do not matter):
40
//     type exampleStruct struct {
41
//         Name  string ``
42
//         Email string `valid:"email"`
43
// This, however, will only fail when Email is empty or an invalid email address:
44
//     type exampleStruct2 struct {
45
//         Name  string `valid:"-"`
46
//         Email string `valid:"email"`
47
// Lastly, this will only fail when Email is an invalid email address but not when it's empty:
48
//     type exampleStruct2 struct {
49
//         Name  string `valid:"-"`
50
//         Email string `valid:"email,optional"`
51
func SetFieldsRequiredByDefault(value bool) {
52
	fieldsRequiredByDefault = value
53
}
54

55
// SetNilPtrAllowedByRequired causes validation to pass for nil ptrs when a field is set to required.
56
// The validation will still reject ptr fields in their zero value state. Example with this enabled:
57
//     type exampleStruct struct {
58
//         Name  *string `valid:"required"`
59
// With `Name` set to "", this will be considered invalid input and will cause a validation error.
60
// With `Name` set to nil, this will be considered valid by validation.
61
// By default this is disabled.
62
func SetNilPtrAllowedByRequired(value bool) {
63
	nilPtrAllowedByRequired = value
64
}
65

66
// IsEmail checks if the string is an email.
67
func IsEmail(str string) bool {
68
	// TODO uppercase letters are not supported
69
	return rxEmail.MatchString(str)
70
}
71

72
// IsExistingEmail checks if the string is an email of existing domain
73
func IsExistingEmail(email string) bool {
74

75
	if len(email) < 6 || len(email) > 254 {
76
		return false
77
	}
78
	at := strings.LastIndex(email, "@")
79
	if at <= 0 || at > len(email)-3 {
80
		return false
81
	}
82
	user := email[:at]
83
	host := email[at+1:]
84
	if len(user) > 64 {
85
		return false
86
	}
87
	switch host {
88
	case "localhost", "example.com":
89
		return true
90
	}
91
	if userDotRegexp.MatchString(user) || !userRegexp.MatchString(user) || !hostRegexp.MatchString(host) {
92
		return false
93
	}
94
	if _, err := net.LookupMX(host); err != nil {
95
		if _, err := net.LookupIP(host); err != nil {
96
			return false
97
		}
98
	}
99

100
	return true
101
}
102

103
// IsURL checks if the string is an URL.
104
func IsURL(str string) bool {
105
	if str == "" || utf8.RuneCountInString(str) >= maxURLRuneCount || len(str) <= minURLRuneCount || strings.HasPrefix(str, ".") {
106
		return false
107
	}
108
	strTemp := str
109
	if strings.Contains(str, ":") && !strings.Contains(str, "://") {
110
		// support no indicated urlscheme but with colon for port number
111
		// http:// is appended so url.Parse will succeed, strTemp used so it does not impact rxURL.MatchString
112
		strTemp = "http://" + str
113
	}
114
	u, err := url.Parse(strTemp)
115
	if err != nil {
116
		return false
117
	}
118
	if strings.HasPrefix(u.Host, ".") {
119
		return false
120
	}
121
	if u.Host == "" && (u.Path != "" && !strings.Contains(u.Path, ".")) {
122
		return false
123
	}
124
	return rxURL.MatchString(str)
125
}
126

127
// IsRequestURL checks if the string rawurl, assuming
128
// it was received in an HTTP request, is a valid
129
// URL confirm to RFC 3986
130
func IsRequestURL(rawurl string) bool {
131
	url, err := url.ParseRequestURI(rawurl)
132
	if err != nil {
133
		return false //Couldn't even parse the rawurl
134
	}
135
	if len(url.Scheme) == 0 {
136
		return false //No Scheme found
137
	}
138
	return true
139
}
140

141
// IsRequestURI checks if the string rawurl, assuming
142
// it was received in an HTTP request, is an
143
// absolute URI or an absolute path.
144
func IsRequestURI(rawurl string) bool {
145
	_, err := url.ParseRequestURI(rawurl)
146
	return err == nil
147
}
148

149
// IsAlpha checks if the string contains only letters (a-zA-Z). Empty string is valid.
150
func IsAlpha(str string) bool {
151
	if IsNull(str) {
152
		return true
153
	}
154
	return rxAlpha.MatchString(str)
155
}
156

157
//IsUTFLetter checks if the string contains only unicode letter characters.
158
//Similar to IsAlpha but for all languages. Empty string is valid.
159
func IsUTFLetter(str string) bool {
160
	if IsNull(str) {
161
		return true
162
	}
163

164
	for _, c := range str {
165
		if !unicode.IsLetter(c) {
166
			return false
167
		}
168
	}
169
	return true
170

171
}
172

173
// IsAlphanumeric checks if the string contains only letters and numbers. Empty string is valid.
174
func IsAlphanumeric(str string) bool {
175
	if IsNull(str) {
176
		return true
177
	}
178
	return rxAlphanumeric.MatchString(str)
179
}
180

181
// IsUTFLetterNumeric checks if the string contains only unicode letters and numbers. Empty string is valid.
182
func IsUTFLetterNumeric(str string) bool {
183
	if IsNull(str) {
184
		return true
185
	}
186
	for _, c := range str {
187
		if !unicode.IsLetter(c) && !unicode.IsNumber(c) { //letters && numbers are ok
188
			return false
189
		}
190
	}
191
	return true
192

193
}
194

195
// IsNumeric checks if the string contains only numbers. Empty string is valid.
196
func IsNumeric(str string) bool {
197
	if IsNull(str) {
198
		return true
199
	}
200
	return rxNumeric.MatchString(str)
201
}
202

203
// IsUTFNumeric checks if the string contains only unicode numbers of any kind.
204
// Numbers can be 0-9 but also Fractions ¾,Roman Ⅸ and Hangzhou 〩. Empty string is valid.
205
func IsUTFNumeric(str string) bool {
206
	if IsNull(str) {
207
		return true
208
	}
209
	if strings.IndexAny(str, "+-") > 0 {
210
		return false
211
	}
212
	if len(str) > 1 {
213
		str = strings.TrimPrefix(str, "-")
214
		str = strings.TrimPrefix(str, "+")
215
	}
216
	for _, c := range str {
217
		if !unicode.IsNumber(c) { //numbers && minus sign are ok
218
			return false
219
		}
220
	}
221
	return true
222

223
}
224

225
// IsUTFDigit checks if the string contains only unicode radix-10 decimal digits. Empty string is valid.
226
func IsUTFDigit(str string) bool {
227
	if IsNull(str) {
228
		return true
229
	}
230
	if strings.IndexAny(str, "+-") > 0 {
231
		return false
232
	}
233
	if len(str) > 1 {
234
		str = strings.TrimPrefix(str, "-")
235
		str = strings.TrimPrefix(str, "+")
236
	}
237
	for _, c := range str {
238
		if !unicode.IsDigit(c) { //digits && minus sign are ok
239
			return false
240
		}
241
	}
242
	return true
243

244
}
245

246
// IsHexadecimal checks if the string is a hexadecimal number.
247
func IsHexadecimal(str string) bool {
248
	return rxHexadecimal.MatchString(str)
249
}
250

251
// IsHexcolor checks if the string is a hexadecimal color.
252
func IsHexcolor(str string) bool {
253
	return rxHexcolor.MatchString(str)
254
}
255

256
// IsRGBcolor checks if the string is a valid RGB color in form rgb(RRR, GGG, BBB).
257
func IsRGBcolor(str string) bool {
258
	return rxRGBcolor.MatchString(str)
259
}
260

261
// IsLowerCase checks if the string is lowercase. Empty string is valid.
262
func IsLowerCase(str string) bool {
263
	if IsNull(str) {
264
		return true
265
	}
266
	return str == strings.ToLower(str)
267
}
268

269
// IsUpperCase checks if the string is uppercase. Empty string is valid.
270
func IsUpperCase(str string) bool {
271
	if IsNull(str) {
272
		return true
273
	}
274
	return str == strings.ToUpper(str)
275
}
276

277
// HasLowerCase checks if the string contains at least 1 lowercase. Empty string is valid.
278
func HasLowerCase(str string) bool {
279
	if IsNull(str) {
280
		return true
281
	}
282
	return rxHasLowerCase.MatchString(str)
283
}
284

285
// HasUpperCase checks if the string contains as least 1 uppercase. Empty string is valid.
286
func HasUpperCase(str string) bool {
287
	if IsNull(str) {
288
		return true
289
	}
290
	return rxHasUpperCase.MatchString(str)
291
}
292

293
// IsInt checks if the string is an integer. Empty string is valid.
294
func IsInt(str string) bool {
295
	if IsNull(str) {
296
		return true
297
	}
298
	return rxInt.MatchString(str)
299
}
300

301
// IsFloat checks if the string is a float.
302
func IsFloat(str string) bool {
303
	return str != "" && rxFloat.MatchString(str)
304
}
305

306
// IsDivisibleBy checks if the string is a number that's divisible by another.
307
// If second argument is not valid integer or zero, it's return false.
308
// Otherwise, if first argument is not valid integer or zero, it's return true (Invalid string converts to zero).
309
func IsDivisibleBy(str, num string) bool {
310
	f, _ := ToFloat(str)
311
	p := int64(f)
312
	q, _ := ToInt(num)
313
	if q == 0 {
314
		return false
315
	}
316
	return (p == 0) || (p%q == 0)
317
}
318

319
// IsNull checks if the string is null.
320
func IsNull(str string) bool {
321
	return len(str) == 0
322
}
323

324
// IsNotNull checks if the string is not null.
325
func IsNotNull(str string) bool {
326
	return !IsNull(str)
327
}
328

329
// HasWhitespaceOnly checks the string only contains whitespace
330
func HasWhitespaceOnly(str string) bool {
331
	return len(str) > 0 && rxHasWhitespaceOnly.MatchString(str)
332
}
333

334
// HasWhitespace checks if the string contains any whitespace
335
func HasWhitespace(str string) bool {
336
	return len(str) > 0 && rxHasWhitespace.MatchString(str)
337
}
338

339
// IsByteLength checks if the string's length (in bytes) falls in a range.
340
func IsByteLength(str string, min, max int) bool {
341
	return len(str) >= min && len(str) <= max
342
}
343

344
// IsUUIDv3 checks if the string is a UUID version 3.
345
func IsUUIDv3(str string) bool {
346
	return rxUUID3.MatchString(str)
347
}
348

349
// IsUUIDv4 checks if the string is a UUID version 4.
350
func IsUUIDv4(str string) bool {
351
	return rxUUID4.MatchString(str)
352
}
353

354
// IsUUIDv5 checks if the string is a UUID version 5.
355
func IsUUIDv5(str string) bool {
356
	return rxUUID5.MatchString(str)
357
}
358

359
// IsUUID checks if the string is a UUID (version 3, 4 or 5).
360
func IsUUID(str string) bool {
361
	return rxUUID.MatchString(str)
362
}
363

364
// Byte to index table for O(1) lookups when unmarshaling.
365
// We use 0xFF as sentinel value for invalid indexes.
366
var ulidDec = [...]byte{
367
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
368
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
369
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
370
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
371
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01,
372
	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF,
373
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
374
	0x0F, 0x10, 0x11, 0xFF, 0x12, 0x13, 0xFF, 0x14, 0x15, 0xFF,
375
	0x16, 0x17, 0x18, 0x19, 0x1A, 0xFF, 0x1B, 0x1C, 0x1D, 0x1E,
376
	0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C,
377
	0x0D, 0x0E, 0x0F, 0x10, 0x11, 0xFF, 0x12, 0x13, 0xFF, 0x14,
378
	0x15, 0xFF, 0x16, 0x17, 0x18, 0x19, 0x1A, 0xFF, 0x1B, 0x1C,
379
	0x1D, 0x1E, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
380
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
381
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
382
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
383
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
384
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
385
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
386
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
387
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
388
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
389
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
390
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
391
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
392
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
393
}
394

395
// EncodedSize is the length of a text encoded ULID.
396
const ulidEncodedSize = 26
397

398
// IsULID checks if the string is a ULID.
399
//
400
// Implementation got from:
401
//   https://github.com/oklog/ulid (Apache-2.0 License)
402
//
403
func IsULID(str string) bool {
404
	// Check if a base32 encoded ULID is the right length.
405
	if len(str) != ulidEncodedSize {
406
		return false
407
	}
408

409
	// Check if all the characters in a base32 encoded ULID are part of the
410
	// expected base32 character set.
411
	if ulidDec[str[0]] == 0xFF ||
412
		ulidDec[str[1]] == 0xFF ||
413
		ulidDec[str[2]] == 0xFF ||
414
		ulidDec[str[3]] == 0xFF ||
415
		ulidDec[str[4]] == 0xFF ||
416
		ulidDec[str[5]] == 0xFF ||
417
		ulidDec[str[6]] == 0xFF ||
418
		ulidDec[str[7]] == 0xFF ||
419
		ulidDec[str[8]] == 0xFF ||
420
		ulidDec[str[9]] == 0xFF ||
421
		ulidDec[str[10]] == 0xFF ||
422
		ulidDec[str[11]] == 0xFF ||
423
		ulidDec[str[12]] == 0xFF ||
424
		ulidDec[str[13]] == 0xFF ||
425
		ulidDec[str[14]] == 0xFF ||
426
		ulidDec[str[15]] == 0xFF ||
427
		ulidDec[str[16]] == 0xFF ||
428
		ulidDec[str[17]] == 0xFF ||
429
		ulidDec[str[18]] == 0xFF ||
430
		ulidDec[str[19]] == 0xFF ||
431
		ulidDec[str[20]] == 0xFF ||
432
		ulidDec[str[21]] == 0xFF ||
433
		ulidDec[str[22]] == 0xFF ||
434
		ulidDec[str[23]] == 0xFF ||
435
		ulidDec[str[24]] == 0xFF ||
436
		ulidDec[str[25]] == 0xFF {
437
		return false
438
	}
439

440
	// Check if the first character in a base32 encoded ULID will overflow. This
441
	// happens because the base32 representation encodes 130 bits, while the
442
	// ULID is only 128 bits.
443
	//
444
	// See https://github.com/oklog/ulid/issues/9 for details.
445
	if str[0] > '7' {
446
		return false
447
	}
448
	return true
449
}
450

451
// IsCreditCard checks if the string is a credit card.
452
func IsCreditCard(str string) bool {
453
	sanitized := whiteSpacesAndMinus.ReplaceAllString(str, "")
454
	if !rxCreditCard.MatchString(sanitized) {
455
		return false
456
	}
457
	
458
	number, _ := ToInt(sanitized)
459
	number, lastDigit := number / 10, number % 10	
460

461
	var sum int64
462
	for i:=0; number > 0; i++ {
463
		digit := number % 10
464
		
465
		if i % 2 == 0 {
466
			digit *= 2
467
			if digit > 9 {
468
				digit -= 9
469
			}
470
		}
471
		
472
		sum += digit
473
		number = number / 10
474
	}
475
	
476
	return (sum + lastDigit) % 10 == 0
477
}
478

479
// IsISBN10 checks if the string is an ISBN version 10.
480
func IsISBN10(str string) bool {
481
	return IsISBN(str, 10)
482
}
483

484
// IsISBN13 checks if the string is an ISBN version 13.
485
func IsISBN13(str string) bool {
486
	return IsISBN(str, 13)
487
}
488

489
// IsISBN checks if the string is an ISBN (version 10 or 13).
490
// If version value is not equal to 10 or 13, it will be checks both variants.
491
func IsISBN(str string, version int) bool {
492
	sanitized := whiteSpacesAndMinus.ReplaceAllString(str, "")
493
	var checksum int32
494
	var i int32
495
	if version == 10 {
496
		if !rxISBN10.MatchString(sanitized) {
497
			return false
498
		}
499
		for i = 0; i < 9; i++ {
500
			checksum += (i + 1) * int32(sanitized[i]-'0')
501
		}
502
		if sanitized[9] == 'X' {
503
			checksum += 10 * 10
504
		} else {
505
			checksum += 10 * int32(sanitized[9]-'0')
506
		}
507
		if checksum%11 == 0 {
508
			return true
509
		}
510
		return false
511
	} else if version == 13 {
512
		if !rxISBN13.MatchString(sanitized) {
513
			return false
514
		}
515
		factor := []int32{1, 3}
516
		for i = 0; i < 12; i++ {
517
			checksum += factor[i%2] * int32(sanitized[i]-'0')
518
		}
519
		return (int32(sanitized[12]-'0'))-((10-(checksum%10))%10) == 0
520
	}
521
	return IsISBN(str, 10) || IsISBN(str, 13)
522
}
523

524
// IsJSON checks if the string is valid JSON (note: uses json.Unmarshal).
525
func IsJSON(str string) bool {
526
	var js json.RawMessage
527
	return json.Unmarshal([]byte(str), &js) == nil
528
}
529

530
// IsMultibyte checks if the string contains one or more multibyte chars. Empty string is valid.
531
func IsMultibyte(str string) bool {
532
	if IsNull(str) {
533
		return true
534
	}
535
	return rxMultibyte.MatchString(str)
536
}
537

538
// IsASCII checks if the string contains ASCII chars only. Empty string is valid.
539
func IsASCII(str string) bool {
540
	if IsNull(str) {
541
		return true
542
	}
543
	return rxASCII.MatchString(str)
544
}
545

546
// IsPrintableASCII checks if the string contains printable ASCII chars only. Empty string is valid.
547
func IsPrintableASCII(str string) bool {
548
	if IsNull(str) {
549
		return true
550
	}
551
	return rxPrintableASCII.MatchString(str)
552
}
553

554
// IsFullWidth checks if the string contains any full-width chars. Empty string is valid.
555
func IsFullWidth(str string) bool {
556
	if IsNull(str) {
557
		return true
558
	}
559
	return rxFullWidth.MatchString(str)
560
}
561

562
// IsHalfWidth checks if the string contains any half-width chars. Empty string is valid.
563
func IsHalfWidth(str string) bool {
564
	if IsNull(str) {
565
		return true
566
	}
567
	return rxHalfWidth.MatchString(str)
568
}
569

570
// IsVariableWidth checks if the string contains a mixture of full and half-width chars. Empty string is valid.
571
func IsVariableWidth(str string) bool {
572
	if IsNull(str) {
573
		return true
574
	}
575
	return rxHalfWidth.MatchString(str) && rxFullWidth.MatchString(str)
576
}
577

578
// IsBase64 checks if a string is base64 encoded.
579
func IsBase64(str string) bool {
580
	return rxBase64.MatchString(str)
581
}
582

583
// IsFilePath checks is a string is Win or Unix file path and returns it's type.
584
func IsFilePath(str string) (bool, int) {
585
	if rxWinPath.MatchString(str) {
586
		//check windows path limit see:
587
		//  http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath
588
		if len(str[3:]) > 32767 {
589
			return false, Win
590
		}
591
		return true, Win
592
	} else if rxUnixPath.MatchString(str) {
593
		return true, Unix
594
	}
595
	return false, Unknown
596
}
597

598
//IsWinFilePath checks both relative & absolute paths in Windows
599
func IsWinFilePath(str string) bool {
600
	if rxARWinPath.MatchString(str) {
601
		//check windows path limit see:
602
		//  http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath
603
		if len(str[3:]) > 32767 {
604
			return false
605
		}
606
		return true
607
	}
608
	return false
609
}
610

611
//IsUnixFilePath checks both relative & absolute paths in Unix
612
func IsUnixFilePath(str string) bool {
613
	if rxARUnixPath.MatchString(str) {
614
		return true
615
	}
616
	return false
617
}
618

619
// IsDataURI checks if a string is base64 encoded data URI such as an image
620
func IsDataURI(str string) bool {
621
	dataURI := strings.Split(str, ",")
622
	if !rxDataURI.MatchString(dataURI[0]) {
623
		return false
624
	}
625
	return IsBase64(dataURI[1])
626
}
627

628
// IsMagnetURI checks if a string is valid magnet URI
629
func IsMagnetURI(str string) bool {
630
	return rxMagnetURI.MatchString(str)
631
}
632

633
// IsISO3166Alpha2 checks if a string is valid two-letter country code
634
func IsISO3166Alpha2(str string) bool {
635
	for _, entry := range ISO3166List {
636
		if str == entry.Alpha2Code {
637
			return true
638
		}
639
	}
640
	return false
641
}
642

643
// IsISO3166Alpha3 checks if a string is valid three-letter country code
644
func IsISO3166Alpha3(str string) bool {
645
	for _, entry := range ISO3166List {
646
		if str == entry.Alpha3Code {
647
			return true
648
		}
649
	}
650
	return false
651
}
652

653
// IsISO693Alpha2 checks if a string is valid two-letter language code
654
func IsISO693Alpha2(str string) bool {
655
	for _, entry := range ISO693List {
656
		if str == entry.Alpha2Code {
657
			return true
658
		}
659
	}
660
	return false
661
}
662

663
// IsISO693Alpha3b checks if a string is valid three-letter language code
664
func IsISO693Alpha3b(str string) bool {
665
	for _, entry := range ISO693List {
666
		if str == entry.Alpha3bCode {
667
			return true
668
		}
669
	}
670
	return false
671
}
672

673
// IsDNSName will validate the given string as a DNS name
674
func IsDNSName(str string) bool {
675
	if str == "" || len(strings.Replace(str, ".", "", -1)) > 255 {
676
		// constraints already violated
677
		return false
678
	}
679
	return !IsIP(str) && rxDNSName.MatchString(str)
680
}
681

682
// IsHash checks if a string is a hash of type algorithm.
683
// Algorithm is one of ['md4', 'md5', 'sha1', 'sha256', 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
684
func IsHash(str string, algorithm string) bool {
685
	var len string
686
	algo := strings.ToLower(algorithm)
687

688
	if algo == "crc32" || algo == "crc32b" {
689
		len = "8"
690
	} else if algo == "md5" || algo == "md4" || algo == "ripemd128" || algo == "tiger128" {
691
		len = "32"
692
	} else if algo == "sha1" || algo == "ripemd160" || algo == "tiger160" {
693
		len = "40"
694
	} else if algo == "tiger192" {
695
		len = "48"
696
	} else if algo == "sha3-224" {
697
		len = "56"
698
	} else if algo == "sha256" || algo == "sha3-256" {
699
		len = "64"
700
	} else if algo == "sha384" || algo == "sha3-384" {
701
		len = "96"
702
	} else if algo == "sha512" || algo == "sha3-512" {
703
		len = "128"
704
	} else {
705
		return false
706
	}
707

708
	return Matches(str, "^[a-f0-9]{"+len+"}$")
709
}
710

711
// IsSHA3224 checks is a string is a SHA3-224 hash. Alias for `IsHash(str, "sha3-224")`
712
func IsSHA3224(str string) bool {
713
	return IsHash(str, "sha3-224")
714
}
715

716
// IsSHA3256 checks is a string is a SHA3-256 hash. Alias for `IsHash(str, "sha3-256")`
717
func IsSHA3256(str string) bool {
718
	return IsHash(str, "sha3-256")
719
}
720

721
// IsSHA3384 checks is a string is a SHA3-384 hash. Alias for `IsHash(str, "sha3-384")`
722
func IsSHA3384(str string) bool {
723
	return IsHash(str, "sha3-384")
724
}
725

726
// IsSHA3512 checks is a string is a SHA3-512 hash. Alias for `IsHash(str, "sha3-512")`
727
func IsSHA3512(str string) bool {
728
	return IsHash(str, "sha3-512")
729
}
730

731
// IsSHA512 checks is a string is a SHA512 hash. Alias for `IsHash(str, "sha512")`
732
func IsSHA512(str string) bool {
733
	return IsHash(str, "sha512")
734
}
735

736
// IsSHA384 checks is a string is a SHA384 hash. Alias for `IsHash(str, "sha384")`
737
func IsSHA384(str string) bool {
738
	return IsHash(str, "sha384")
739
}
740

741
// IsSHA256 checks is a string is a SHA256 hash. Alias for `IsHash(str, "sha256")`
742
func IsSHA256(str string) bool {
743
	return IsHash(str, "sha256")
744
}
745

746
// IsTiger192 checks is a string is a Tiger192 hash. Alias for `IsHash(str, "tiger192")`
747
func IsTiger192(str string) bool {
748
	return IsHash(str, "tiger192")
749
}
750

751
// IsTiger160 checks is a string is a Tiger160 hash. Alias for `IsHash(str, "tiger160")`
752
func IsTiger160(str string) bool {
753
	return IsHash(str, "tiger160")
754
}
755

756
// IsRipeMD160 checks is a string is a RipeMD160 hash. Alias for `IsHash(str, "ripemd160")`
757
func IsRipeMD160(str string) bool {
758
	return IsHash(str, "ripemd160")
759
}
760

761
// IsSHA1 checks is a string is a SHA-1 hash. Alias for `IsHash(str, "sha1")`
762
func IsSHA1(str string) bool {
763
	return IsHash(str, "sha1")
764
}
765

766
// IsTiger128 checks is a string is a Tiger128 hash. Alias for `IsHash(str, "tiger128")`
767
func IsTiger128(str string) bool {
768
	return IsHash(str, "tiger128")
769
}
770

771
// IsRipeMD128 checks is a string is a RipeMD128 hash. Alias for `IsHash(str, "ripemd128")`
772
func IsRipeMD128(str string) bool {
773
	return IsHash(str, "ripemd128")
774
}
775

776
// IsCRC32 checks is a string is a CRC32 hash. Alias for `IsHash(str, "crc32")`
777
func IsCRC32(str string) bool {
778
	return IsHash(str, "crc32")
779
}
780

781
// IsCRC32b checks is a string is a CRC32b hash. Alias for `IsHash(str, "crc32b")`
782
func IsCRC32b(str string) bool {
783
	return IsHash(str, "crc32b")
784
}
785

786
// IsMD5 checks is a string is a MD5 hash. Alias for `IsHash(str, "md5")`
787
func IsMD5(str string) bool {
788
	return IsHash(str, "md5")
789
}
790

791
// IsMD4 checks is a string is a MD4 hash. Alias for `IsHash(str, "md4")`
792
func IsMD4(str string) bool {
793
	return IsHash(str, "md4")
794
}
795

796
// IsDialString validates the given string for usage with the various Dial() functions
797
func IsDialString(str string) bool {
798
	if h, p, err := net.SplitHostPort(str); err == nil && h != "" && p != "" && (IsDNSName(h) || IsIP(h)) && IsPort(p) {
799
		return true
800
	}
801

802
	return false
803
}
804

805
// IsIP checks if a string is either IP version 4 or 6. Alias for `net.ParseIP`
806
func IsIP(str string) bool {
807
	return net.ParseIP(str) != nil
808
}
809

810
// IsPort checks if a string represents a valid port
811
func IsPort(str string) bool {
812
	if i, err := strconv.Atoi(str); err == nil && i > 0 && i < 65536 {
813
		return true
814
	}
815
	return false
816
}
817

818
// IsIPv4 checks if the string is an IP version 4.
819
func IsIPv4(str string) bool {
820
	ip := net.ParseIP(str)
821
	return ip != nil && strings.Contains(str, ".")
822
}
823

824
// IsIPv6 checks if the string is an IP version 6.
825
func IsIPv6(str string) bool {
826
	ip := net.ParseIP(str)
827
	return ip != nil && strings.Contains(str, ":")
828
}
829

830
// IsCIDR checks if the string is an valid CIDR notiation (IPV4 & IPV6)
831
func IsCIDR(str string) bool {
832
	_, _, err := net.ParseCIDR(str)
833
	return err == nil
834
}
835

836
// IsMAC checks if a string is valid MAC address.
837
// Possible MAC formats:
838
// 01:23:45:67:89:ab
839
// 01:23:45:67:89:ab:cd:ef
840
// 01-23-45-67-89-ab
841
// 01-23-45-67-89-ab-cd-ef
842
// 0123.4567.89ab
843
// 0123.4567.89ab.cdef
844
func IsMAC(str string) bool {
845
	_, err := net.ParseMAC(str)
846
	return err == nil
847
}
848

849
// IsHost checks if the string is a valid IP (both v4 and v6) or a valid DNS name
850
func IsHost(str string) bool {
851
	return IsIP(str) || IsDNSName(str)
852
}
853

854
// IsMongoID checks if the string is a valid hex-encoded representation of a MongoDB ObjectId.
855
func IsMongoID(str string) bool {
856
	return rxHexadecimal.MatchString(str) && (len(str) == 24)
857
}
858

859
// IsLatitude checks if a string is valid latitude.
860
func IsLatitude(str string) bool {
861
	return rxLatitude.MatchString(str)
862
}
863

864
// IsLongitude checks if a string is valid longitude.
865
func IsLongitude(str string) bool {
866
	return rxLongitude.MatchString(str)
867
}
868

869
// IsIMEI checks if a string is valid IMEI
870
func IsIMEI(str string) bool {
871
	return rxIMEI.MatchString(str)
872
}
873

874
// IsIMSI checks if a string is valid IMSI
875
func IsIMSI(str string) bool {
876
	if !rxIMSI.MatchString(str) {
877
		return false
878
	}
879

880
	mcc, err := strconv.ParseInt(str[0:3], 10, 32)
881
	if err != nil {
882
		return false
883
	}
884

885
	switch mcc {
886
	case 202, 204, 206, 208, 212, 213, 214, 216, 218, 219:
887
	case 220, 221, 222, 226, 228, 230, 231, 232, 234, 235:
888
	case 238, 240, 242, 244, 246, 247, 248, 250, 255, 257:
889
	case 259, 260, 262, 266, 268, 270, 272, 274, 276, 278:
890
	case 280, 282, 283, 284, 286, 288, 289, 290, 292, 293:
891
	case 294, 295, 297, 302, 308, 310, 311, 312, 313, 314:
892
	case 315, 316, 330, 332, 334, 338, 340, 342, 344, 346:
893
	case 348, 350, 352, 354, 356, 358, 360, 362, 363, 364:
894
	case 365, 366, 368, 370, 372, 374, 376, 400, 401, 402:
895
	case 404, 405, 406, 410, 412, 413, 414, 415, 416, 417:
896
	case 418, 419, 420, 421, 422, 424, 425, 426, 427, 428:
897
	case 429, 430, 431, 432, 434, 436, 437, 438, 440, 441:
898
	case 450, 452, 454, 455, 456, 457, 460, 461, 466, 467:
899
	case 470, 472, 502, 505, 510, 514, 515, 520, 525, 528:
900
	case 530, 536, 537, 539, 540, 541, 542, 543, 544, 545:
901
	case 546, 547, 548, 549, 550, 551, 552, 553, 554, 555:
902
	case 602, 603, 604, 605, 606, 607, 608, 609, 610, 611:
903
	case 612, 613, 614, 615, 616, 617, 618, 619, 620, 621:
904
	case 622, 623, 624, 625, 626, 627, 628, 629, 630, 631:
905
	case 632, 633, 634, 635, 636, 637, 638, 639, 640, 641:
906
	case 642, 643, 645, 646, 647, 648, 649, 650, 651, 652:
907
	case 653, 654, 655, 657, 658, 659, 702, 704, 706, 708:
908
	case 710, 712, 714, 716, 722, 724, 730, 732, 734, 736:
909
	case 738, 740, 742, 744, 746, 748, 750, 995:
910
		return true
911
	default:
912
		return false
913
	}
914
	return true
915
}
916

917
// IsRsaPublicKey checks if a string is valid public key with provided length
918
func IsRsaPublicKey(str string, keylen int) bool {
919
	bb := bytes.NewBufferString(str)
920
	pemBytes, err := ioutil.ReadAll(bb)
921
	if err != nil {
922
		return false
923
	}
924
	block, _ := pem.Decode(pemBytes)
925
	if block != nil && block.Type != "PUBLIC KEY" {
926
		return false
927
	}
928
	var der []byte
929

930
	if block != nil {
931
		der = block.Bytes
932
	} else {
933
		der, err = base64.StdEncoding.DecodeString(str)
934
		if err != nil {
935
			return false
936
		}
937
	}
938

939
	key, err := x509.ParsePKIXPublicKey(der)
940
	if err != nil {
941
		return false
942
	}
943
	pubkey, ok := key.(*rsa.PublicKey)
944
	if !ok {
945
		return false
946
	}
947
	bitlen := len(pubkey.N.Bytes()) * 8
948
	return bitlen == int(keylen)
949
}
950

951
// IsRegex checks if a give string is a valid regex with RE2 syntax or not
952
func IsRegex(str string) bool {
953
	if _, err := regexp.Compile(str); err == nil {
954
		return true
955
	}
956
	return false
957
}
958

959
func toJSONName(tag string) string {
960
	if tag == "" {
961
		return ""
962
	}
963

964
	// JSON name always comes first. If there's no options then split[0] is
965
	// JSON name, if JSON name is not set, then split[0] is an empty string.
966
	split := strings.SplitN(tag, ",", 2)
967

968
	name := split[0]
969

970
	// However it is possible that the field is skipped when
971
	// (de-)serializing from/to JSON, in which case assume that there is no
972
	// tag name to use
973
	if name == "-" {
974
		return ""
975
	}
976
	return name
977
}
978

979
func prependPathToErrors(err error, path string) error {
980
	switch err2 := err.(type) {
981
	case Error:
982
		err2.Path = append([]string{path}, err2.Path...)
983
		return err2
984
	case Errors:
985
		errors := err2.Errors()
986
		for i, err3 := range errors {
987
			errors[i] = prependPathToErrors(err3, path)
988
		}
989
		return err2
990
	}
991
	return err
992
}
993

994
// ValidateArray performs validation according to condition iterator that validates every element of the array
995
func ValidateArray(array []interface{}, iterator ConditionIterator) bool {
996
	return Every(array, iterator)
997
}
998

999
// ValidateMap use validation map for fields.
1000
// result will be equal to `false` if there are any errors.
1001
// s is the map containing the data to be validated.
1002
// m is the validation map in the form:
1003
//   map[string]interface{}{"name":"required,alpha","address":map[string]interface{}{"line1":"required,alphanum"}}
1004
func ValidateMap(s map[string]interface{}, m map[string]interface{}) (bool, error) {
1005
	if s == nil {
1006
		return true, nil
1007
	}
1008
	result := true
1009
	var err error
1010
	var errs Errors
1011
	var index int
1012
	val := reflect.ValueOf(s)
1013
	for key, value := range s {
1014
		presentResult := true
1015
		validator, ok := m[key]
1016
		if !ok {
1017
			presentResult = false
1018
			var err error
1019
			err = fmt.Errorf("all map keys has to be present in the validation map; got %s", key)
1020
			err = prependPathToErrors(err, key)
1021
			errs = append(errs, err)
1022
		}
1023
		valueField := reflect.ValueOf(value)
1024
		mapResult := true
1025
		typeResult := true
1026
		structResult := true
1027
		resultField := true
1028
		switch subValidator := validator.(type) {
1029
		case map[string]interface{}:
1030
			var err error
1031
			if v, ok := value.(map[string]interface{}); !ok {
1032
				mapResult = false
1033
				err = fmt.Errorf("map validator has to be for the map type only; got %s", valueField.Type().String())
1034
				err = prependPathToErrors(err, key)
1035
				errs = append(errs, err)
1036
			} else {
1037
				mapResult, err = ValidateMap(v, subValidator)
1038
				if err != nil {
1039
					mapResult = false
1040
					err = prependPathToErrors(err, key)
1041
					errs = append(errs, err)
1042
				}
1043
			}
1044
		case string:
1045
			if (valueField.Kind() == reflect.Struct ||
1046
				(valueField.Kind() == reflect.Ptr && valueField.Elem().Kind() == reflect.Struct)) &&
1047
				subValidator != "-" {
1048
				var err error
1049
				structResult, err = ValidateStruct(valueField.Interface())
1050
				if err != nil {
1051
					err = prependPathToErrors(err, key)
1052
					errs = append(errs, err)
1053
				}
1054
			}
1055
			resultField, err = typeCheck(valueField, reflect.StructField{
1056
				Name:      key,
1057
				PkgPath:   "",
1058
				Type:      val.Type(),
1059
				Tag:       reflect.StructTag(fmt.Sprintf("%s:%q", tagName, subValidator)),
1060
				Offset:    0,
1061
				Index:     []int{index},
1062
				Anonymous: false,
1063
			}, val, nil)
1064
			if err != nil {
1065
				errs = append(errs, err)
1066
			}
1067
		case nil:
1068
			// already handlerd when checked before
1069
		default:
1070
			typeResult = false
1071
			err = fmt.Errorf("map validator has to be either map[string]interface{} or string; got %s", valueField.Type().String())
1072
			err = prependPathToErrors(err, key)
1073
			errs = append(errs, err)
1074
		}
1075
		result = result && presentResult && typeResult && resultField && structResult && mapResult
1076
		index++
1077
	}
1078
	// checks required keys
1079
	requiredResult := true
1080
	for key, value := range m {
1081
		if schema, ok := value.(string); ok {
1082
			tags := parseTagIntoMap(schema)
1083
			if required, ok := tags["required"]; ok {
1084
				if _, ok := s[key]; !ok {
1085
					requiredResult = false
1086
					if required.customErrorMessage != "" {
1087
						err = Error{key, fmt.Errorf(required.customErrorMessage), true, "required", []string{}}
1088
					} else {
1089
						err = Error{key, fmt.Errorf("required field missing"), false, "required", []string{}}
1090
					}
1091
					errs = append(errs, err)
1092
				}
1093
			}
1094
		}
1095
	}
1096

1097
	if len(errs) > 0 {
1098
		err = errs
1099
	}
1100
	return result && requiredResult, err
1101
}
1102

1103
// ValidateStruct use tags for fields.
1104
// result will be equal to `false` if there are any errors.
1105
// todo currently there is no guarantee that errors will be returned in predictable order (tests may to fail)
1106
func ValidateStruct(s interface{}) (bool, error) {
1107
	if s == nil {
1108
		return true, nil
1109
	}
1110
	result := true
1111
	var err error
1112
	val := reflect.ValueOf(s)
1113
	if val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
1114
		val = val.Elem()
1115
	}
1116
	// we only accept structs
1117
	if val.Kind() != reflect.Struct {
1118
		return false, fmt.Errorf("function only accepts structs; got %s", val.Kind())
1119
	}
1120
	var errs Errors
1121
	for i := 0; i < val.NumField(); i++ {
1122
		valueField := val.Field(i)
1123
		typeField := val.Type().Field(i)
1124
		if typeField.PkgPath != "" {
1125
			continue // Private field
1126
		}
1127
		structResult := true
1128
		if valueField.Kind() == reflect.Interface {
1129
			valueField = valueField.Elem()
1130
		}
1131
		if (valueField.Kind() == reflect.Struct ||
1132
			(valueField.Kind() == reflect.Ptr && valueField.Elem().Kind() == reflect.Struct)) &&
1133
			typeField.Tag.Get(tagName) != "-" {
1134
			var err error
1135
			structResult, err = ValidateStruct(valueField.Interface())
1136
			if err != nil {
1137
				err = prependPathToErrors(err, typeField.Name)
1138
				errs = append(errs, err)
1139
			}
1140
		}
1141
		resultField, err2 := typeCheck(valueField, typeField, val, nil)
1142
		if err2 != nil {
1143

1144
			// Replace structure name with JSON name if there is a tag on the variable
1145
			jsonTag := toJSONName(typeField.Tag.Get("json"))
1146
			if jsonTag != "" {
1147
				switch jsonError := err2.(type) {
1148
				case Error:
1149
					jsonError.Name = jsonTag
1150
					err2 = jsonError
1151
				case Errors:
1152
					for i2, err3 := range jsonError {
1153
						switch customErr := err3.(type) {
1154
						case Error:
1155
							customErr.Name = jsonTag
1156
							jsonError[i2] = customErr
1157
						}
1158
					}
1159

1160
					err2 = jsonError
1161
				}
1162
			}
1163

1164
			errs = append(errs, err2)
1165
		}
1166
		result = result && resultField && structResult
1167
	}
1168
	if len(errs) > 0 {
1169
		err = errs
1170
	}
1171
	return result, err
1172
}
1173

1174
// ValidateStructAsync performs async validation of the struct and returns results through the channels
1175
func ValidateStructAsync(s interface{}) (<-chan bool, <-chan error) {
1176
	res := make(chan bool)
1177
	errors := make(chan error)
1178

1179
	go func() {
1180
		defer close(res)
1181
		defer close(errors)
1182

1183
		isValid, isFailed := ValidateStruct(s)
1184

1185
		res <- isValid
1186
		errors <- isFailed
1187
	}()
1188

1189
	return res, errors
1190
}
1191

1192
// ValidateMapAsync performs async validation of the map and returns results through the channels
1193
func ValidateMapAsync(s map[string]interface{}, m map[string]interface{}) (<-chan bool, <-chan error) {
1194
	res := make(chan bool)
1195
	errors := make(chan error)
1196

1197
	go func() {
1198
		defer close(res)
1199
		defer close(errors)
1200

1201
		isValid, isFailed := ValidateMap(s, m)
1202

1203
		res <- isValid
1204
		errors <- isFailed
1205
	}()
1206

1207
	return res, errors
1208
}
1209

1210
// parseTagIntoMap parses a struct tag `valid:required~Some error message,length(2|3)` into map[string]string{"required": "Some error message", "length(2|3)": ""}
1211
func parseTagIntoMap(tag string) tagOptionsMap {
1212
	optionsMap := make(tagOptionsMap)
1213
	options := strings.Split(tag, ",")
1214

1215
	for i, option := range options {
1216
		option = strings.TrimSpace(option)
1217

1218
		validationOptions := strings.Split(option, "~")
1219
		if !isValidTag(validationOptions[0]) {
1220
			continue
1221
		}
1222
		if len(validationOptions) == 2 {
1223
			optionsMap[validationOptions[0]] = tagOption{validationOptions[0], validationOptions[1], i}
1224
		} else {
1225
			optionsMap[validationOptions[0]] = tagOption{validationOptions[0], "", i}
1226
		}
1227
	}
1228
	return optionsMap
1229
}
1230

1231
func isValidTag(s string) bool {
1232
	if s == "" {
1233
		return false
1234
	}
1235
	for _, c := range s {
1236
		switch {
1237
		case strings.ContainsRune("\\'\"!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
1238
			// Backslash and quote chars are reserved, but
1239
			// otherwise any punctuation chars are allowed
1240
			// in a tag name.
1241
		default:
1242
			if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
1243
				return false
1244
			}
1245
		}
1246
	}
1247
	return true
1248
}
1249

1250
// IsSSN will validate the given string as a U.S. Social Security Number
1251
func IsSSN(str string) bool {
1252
	if str == "" || len(str) != 11 {
1253
		return false
1254
	}
1255
	return rxSSN.MatchString(str)
1256
}
1257

1258
// IsSemver checks if string is valid semantic version
1259
func IsSemver(str string) bool {
1260
	return rxSemver.MatchString(str)
1261
}
1262

1263
// IsType checks if interface is of some type
1264
func IsType(v interface{}, params ...string) bool {
1265
	if len(params) == 1 {
1266
		typ := params[0]
1267
		return strings.Replace(reflect.TypeOf(v).String(), " ", "", -1) == strings.Replace(typ, " ", "", -1)
1268
	}
1269
	return false
1270
}
1271

1272
// IsTime checks if string is valid according to given format
1273
func IsTime(str string, format string) bool {
1274
	_, err := time.Parse(format, str)
1275
	return err == nil
1276
}
1277

1278
// IsUnixTime checks if string is valid unix timestamp value
1279
func IsUnixTime(str string) bool {
1280
	if _, err := strconv.Atoi(str); err == nil {
1281
		return true
1282
	}
1283
	return false
1284
}
1285

1286
// IsRFC3339 checks if string is valid timestamp value according to RFC3339
1287
func IsRFC3339(str string) bool {
1288
	return IsTime(str, time.RFC3339)
1289
}
1290

1291
// IsRFC3339WithoutZone checks if string is valid timestamp value according to RFC3339 which excludes the timezone.
1292
func IsRFC3339WithoutZone(str string) bool {
1293
	return IsTime(str, rfc3339WithoutZone)
1294
}
1295

1296
// IsISO4217 checks if string is valid ISO currency code
1297
func IsISO4217(str string) bool {
1298
	for _, currency := range ISO4217List {
1299
		if str == currency {
1300
			return true
1301
		}
1302
	}
1303

1304
	return false
1305
}
1306

1307
// ByteLength checks string's length
1308
func ByteLength(str string, params ...string) bool {
1309
	if len(params) == 2 {
1310
		min, _ := ToInt(params[0])
1311
		max, _ := ToInt(params[1])
1312
		return len(str) >= int(min) && len(str) <= int(max)
1313
	}
1314

1315
	return false
1316
}
1317

1318
// RuneLength checks string's length
1319
// Alias for StringLength
1320
func RuneLength(str string, params ...string) bool {
1321
	return StringLength(str, params...)
1322
}
1323

1324
// IsRsaPub checks whether string is valid RSA key
1325
// Alias for IsRsaPublicKey
1326
func IsRsaPub(str string, params ...string) bool {
1327
	if len(params) == 1 {
1328
		len, _ := ToInt(params[0])
1329
		return IsRsaPublicKey(str, int(len))
1330
	}
1331

1332
	return false
1333
}
1334

1335
// StringMatches checks if a string matches a given pattern.
1336
func StringMatches(s string, params ...string) bool {
1337
	if len(params) == 1 {
1338
		pattern := params[0]
1339
		return Matches(s, pattern)
1340
	}
1341
	return false
1342
}
1343

1344
// StringLength checks string's length (including multi byte strings)
1345
func StringLength(str string, params ...string) bool {
1346

1347
	if len(params) == 2 {
1348
		strLength := utf8.RuneCountInString(str)
1349
		min, _ := ToInt(params[0])
1350
		max, _ := ToInt(params[1])
1351
		return strLength >= int(min) && strLength <= int(max)
1352
	}
1353

1354
	return false
1355
}
1356

1357
// MinStringLength checks string's minimum length (including multi byte strings)
1358
func MinStringLength(str string, params ...string) bool {
1359

1360
	if len(params) == 1 {
1361
		strLength := utf8.RuneCountInString(str)
1362
		min, _ := ToInt(params[0])
1363
		return strLength >= int(min)
1364
	}
1365

1366
	return false
1367
}
1368

1369
// MaxStringLength checks string's maximum length (including multi byte strings)
1370
func MaxStringLength(str string, params ...string) bool {
1371

1372
	if len(params) == 1 {
1373
		strLength := utf8.RuneCountInString(str)
1374
		max, _ := ToInt(params[0])
1375
		return strLength <= int(max)
1376
	}
1377

1378
	return false
1379
}
1380

1381
// Range checks string's length
1382
func Range(str string, params ...string) bool {
1383
	if len(params) == 2 {
1384
		value, _ := ToFloat(str)
1385
		min, _ := ToFloat(params[0])
1386
		max, _ := ToFloat(params[1])
1387
		return InRange(value, min, max)
1388
	}
1389

1390
	return false
1391
}
1392

1393
// IsInRaw checks if string is in list of allowed values
1394
func IsInRaw(str string, params ...string) bool {
1395
	if len(params) == 1 {
1396
		rawParams := params[0]
1397

1398
		parsedParams := strings.Split(rawParams, "|")
1399

1400
		return IsIn(str, parsedParams...)
1401
	}
1402

1403
	return false
1404
}
1405

1406
// IsIn checks if string str is a member of the set of strings params
1407
func IsIn(str string, params ...string) bool {
1408
	for _, param := range params {
1409
		if str == param {
1410
			return true
1411
		}
1412
	}
1413

1414
	return false
1415
}
1416

1417
func checkRequired(v reflect.Value, t reflect.StructField, options tagOptionsMap) (bool, error) {
1418
	if nilPtrAllowedByRequired {
1419
		k := v.Kind()
1420
		if (k == reflect.Ptr || k == reflect.Interface) && v.IsNil() {
1421
			return true, nil
1422
		}
1423
	}
1424

1425
	if requiredOption, isRequired := options["required"]; isRequired {
1426
		if len(requiredOption.customErrorMessage) > 0 {
1427
			return false, Error{t.Name, fmt.Errorf(requiredOption.customErrorMessage), true, "required", []string{}}
1428
		}
1429
		return false, Error{t.Name, fmt.Errorf("non zero value required"), false, "required", []string{}}
1430
	} else if _, isOptional := options["optional"]; fieldsRequiredByDefault && !isOptional {
1431
		return false, Error{t.Name, fmt.Errorf("Missing required field"), false, "required", []string{}}
1432
	}
1433
	// not required and empty is valid
1434
	return true, nil
1435
}
1436

1437
func typeCheck(v reflect.Value, t reflect.StructField, o reflect.Value, options tagOptionsMap) (isValid bool, resultErr error) {
1438
	if !v.IsValid() {
1439
		return false, nil
1440
	}
1441

1442
	tag := t.Tag.Get(tagName)
1443

1444
	// checks if the field should be ignored
1445
	switch tag {
1446
	case "":
1447
		if v.Kind() != reflect.Slice && v.Kind() != reflect.Map {
1448
			if !fieldsRequiredByDefault {
1449
				return true, nil
1450
			}
1451
			return false, Error{t.Name, fmt.Errorf("All fields are required to at least have one validation defined"), false, "required", []string{}}
1452
		}
1453
	case "-":
1454
		return true, nil
1455
	}
1456

1457
	isRootType := false
1458
	if options == nil {
1459
		isRootType = true
1460
		options = parseTagIntoMap(tag)
1461
	}
1462

1463
	if isEmptyValue(v) {
1464
		// an empty value is not validated, checks only required
1465
		isValid, resultErr = checkRequired(v, t, options)
1466
		for key := range options {
1467
			delete(options, key)
1468
		}
1469
		return isValid, resultErr
1470
	}
1471

1472
	var customTypeErrors Errors
1473
	optionsOrder := options.orderedKeys()
1474
	for _, validatorName := range optionsOrder {
1475
		validatorStruct := options[validatorName]
1476
		if validatefunc, ok := CustomTypeTagMap.Get(validatorName); ok {
1477
			delete(options, validatorName)
1478

1479
			if result := validatefunc(v.Interface(), o.Interface()); !result {
1480
				if len(validatorStruct.customErrorMessage) > 0 {
1481
					customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: TruncatingErrorf(validatorStruct.customErrorMessage, fmt.Sprint(v), validatorName), CustomErrorMessageExists: true, Validator: stripParams(validatorName)})
1482
					continue
1483
				}
1484
				customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: fmt.Errorf("%s does not validate as %s", fmt.Sprint(v), validatorName), CustomErrorMessageExists: false, Validator: stripParams(validatorName)})
1485
			}
1486
		}
1487
	}
1488

1489
	if len(customTypeErrors.Errors()) > 0 {
1490
		return false, customTypeErrors
1491
	}
1492

1493
	if isRootType {
1494
		// Ensure that we've checked the value by all specified validators before report that the value is valid
1495
		defer func() {
1496
			delete(options, "optional")
1497
			delete(options, "required")
1498

1499
			if isValid && resultErr == nil && len(options) != 0 {
1500
				optionsOrder := options.orderedKeys()
1501
				for _, validator := range optionsOrder {
1502
					isValid = false
1503
					resultErr = Error{t.Name, fmt.Errorf(
1504
						"The following validator is invalid or can't be applied to the field: %q", validator), false, stripParams(validator), []string{}}
1505
					return
1506
				}
1507
			}
1508
		}()
1509
	}
1510

1511
	for _, validatorSpec := range optionsOrder {
1512
		validatorStruct := options[validatorSpec]
1513
		var negate bool
1514
		validator := validatorSpec
1515
		customMsgExists := len(validatorStruct.customErrorMessage) > 0
1516

1517
		// checks whether the tag looks like '!something' or 'something'
1518
		if validator[0] == '!' {
1519
			validator = validator[1:]
1520
			negate = true
1521
		}
1522

1523
		// checks for interface param validators
1524
		for key, value := range InterfaceParamTagRegexMap {
1525
			ps := value.FindStringSubmatch(validator)
1526
			if len(ps) == 0 {
1527
				continue
1528
			}
1529

1530
			validatefunc, ok := InterfaceParamTagMap[key]
1531
			if !ok {
1532
				continue
1533
			}
1534

1535
			delete(options, validatorSpec)
1536

1537
			field := fmt.Sprint(v)
1538
			if result := validatefunc(v.Interface(), ps[1:]...); (!result && !negate) || (result && negate) {
1539
				if customMsgExists {
1540
					return false, Error{t.Name, TruncatingErrorf(validatorStruct.customErrorMessage, field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1541
				}
1542
				if negate {
1543
					return false, Error{t.Name, fmt.Errorf("%s does validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1544
				}
1545
				return false, Error{t.Name, fmt.Errorf("%s does not validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1546
			}
1547
		}
1548
	}
1549

1550
	switch v.Kind() {
1551
	case reflect.Bool,
1552
		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
1553
		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
1554
		reflect.Float32, reflect.Float64,
1555
		reflect.String:
1556
		// for each tag option checks the map of validator functions
1557
		for _, validatorSpec := range optionsOrder {
1558
			validatorStruct := options[validatorSpec]
1559
			var negate bool
1560
			validator := validatorSpec
1561
			customMsgExists := len(validatorStruct.customErrorMessage) > 0
1562

1563
			// checks whether the tag looks like '!something' or 'something'
1564
			if validator[0] == '!' {
1565
				validator = validator[1:]
1566
				negate = true
1567
			}
1568

1569
			// checks for param validators
1570
			for key, value := range ParamTagRegexMap {
1571
				ps := value.FindStringSubmatch(validator)
1572
				if len(ps) == 0 {
1573
					continue
1574
				}
1575

1576
				validatefunc, ok := ParamTagMap[key]
1577
				if !ok {
1578
					continue
1579
				}
1580

1581
				delete(options, validatorSpec)
1582

1583
				switch v.Kind() {
1584
				case reflect.String,
1585
					reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
1586
					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
1587
					reflect.Float32, reflect.Float64:
1588

1589
					field := fmt.Sprint(v) // make value into string, then validate with regex
1590
					if result := validatefunc(field, ps[1:]...); (!result && !negate) || (result && negate) {
1591
						if customMsgExists {
1592
							return false, Error{t.Name, TruncatingErrorf(validatorStruct.customErrorMessage, field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1593
						}
1594
						if negate {
1595
							return false, Error{t.Name, fmt.Errorf("%s does validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1596
						}
1597
						return false, Error{t.Name, fmt.Errorf("%s does not validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1598
					}
1599
				default:
1600
					// type not yet supported, fail
1601
					return false, Error{t.Name, fmt.Errorf("Validator %s doesn't support kind %s", validator, v.Kind()), false, stripParams(validatorSpec), []string{}}
1602
				}
1603
			}
1604

1605
			if validatefunc, ok := TagMap[validator]; ok {
1606
				delete(options, validatorSpec)
1607

1608
				switch v.Kind() {
1609
				case reflect.String,
1610
					reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
1611
					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
1612
					reflect.Float32, reflect.Float64:
1613
					field := fmt.Sprint(v) // make value into string, then validate with regex
1614
					if result := validatefunc(field); !result && !negate || result && negate {
1615
						if customMsgExists {
1616
							return false, Error{t.Name, TruncatingErrorf(validatorStruct.customErrorMessage, field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1617
						}
1618
						if negate {
1619
							return false, Error{t.Name, fmt.Errorf("%s does validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1620
						}
1621
						return false, Error{t.Name, fmt.Errorf("%s does not validate as %s", field, validator), customMsgExists, stripParams(validatorSpec), []string{}}
1622
					}
1623
				default:
1624
					//Not Yet Supported Types (Fail here!)
1625
					err := fmt.Errorf("Validator %s doesn't support kind %s for value %v", validator, v.Kind(), v)
1626
					return false, Error{t.Name, err, false, stripParams(validatorSpec), []string{}}
1627
				}
1628
			}
1629
		}
1630
		return true, nil
1631
	case reflect.Map:
1632
		if v.Type().Key().Kind() != reflect.String {
1633
			return false, &UnsupportedTypeError{v.Type()}
1634
		}
1635
		var sv stringValues
1636
		sv = v.MapKeys()
1637
		sort.Sort(sv)
1638
		result := true
1639
		for i, k := range sv {
1640
			var resultItem bool
1641
			var err error
1642
			if v.MapIndex(k).Kind() != reflect.Struct {
1643
				resultItem, err = typeCheck(v.MapIndex(k), t, o, options)
1644
				if err != nil {
1645
					return false, err
1646
				}
1647
			} else {
1648
				resultItem, err = ValidateStruct(v.MapIndex(k).Interface())
1649
				if err != nil {
1650
					err = prependPathToErrors(err, t.Name+"."+sv[i].Interface().(string))
1651
					return false, err
1652
				}
1653
			}
1654
			result = result && resultItem
1655
		}
1656
		return result, nil
1657
	case reflect.Slice, reflect.Array:
1658
		result := true
1659
		for i := 0; i < v.Len(); i++ {
1660
			var resultItem bool
1661
			var err error
1662
			if v.Index(i).Kind() != reflect.Struct {
1663
				resultItem, err = typeCheck(v.Index(i), t, o, options)
1664
				if err != nil {
1665
					return false, err
1666
				}
1667
			} else {
1668
				resultItem, err = ValidateStruct(v.Index(i).Interface())
1669
				if err != nil {
1670
					err = prependPathToErrors(err, t.Name+"."+strconv.Itoa(i))
1671
					return false, err
1672
				}
1673
			}
1674
			result = result && resultItem
1675
		}
1676
		return result, nil
1677
	case reflect.Interface:
1678
		// If the value is an interface then encode its element
1679
		if v.IsNil() {
1680
			return true, nil
1681
		}
1682
		return ValidateStruct(v.Interface())
1683
	case reflect.Ptr:
1684
		// If the value is a pointer then checks its element
1685
		if v.IsNil() {
1686
			return true, nil
1687
		}
1688
		return typeCheck(v.Elem(), t, o, options)
1689
	case reflect.Struct:
1690
		return true, nil
1691
	default:
1692
		return false, &UnsupportedTypeError{v.Type()}
1693
	}
1694
}
1695

1696
func stripParams(validatorString string) string {
1697
	return paramsRegexp.ReplaceAllString(validatorString, "")
1698
}
1699

1700
// isEmptyValue checks whether value empty or not
1701
func isEmptyValue(v reflect.Value) bool {
1702
	switch v.Kind() {
1703
	case reflect.String, reflect.Array:
1704
		return v.Len() == 0
1705
	case reflect.Map, reflect.Slice:
1706
		return v.Len() == 0 || v.IsNil()
1707
	case reflect.Bool:
1708
		return !v.Bool()
1709
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1710
		return v.Int() == 0
1711
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1712
		return v.Uint() == 0
1713
	case reflect.Float32, reflect.Float64:
1714
		return v.Float() == 0
1715
	case reflect.Interface, reflect.Ptr:
1716
		return v.IsNil()
1717
	}
1718

1719
	return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
1720
}
1721

1722
// ErrorByField returns error for specified field of the struct
1723
// validated by ValidateStruct or empty string if there are no errors
1724
// or this field doesn't exists or doesn't have any errors.
1725
func ErrorByField(e error, field string) string {
1726
	if e == nil {
1727
		return ""
1728
	}
1729
	return ErrorsByField(e)[field]
1730
}
1731

1732
// ErrorsByField returns map of errors of the struct validated
1733
// by ValidateStruct or empty map if there are no errors.
1734
func ErrorsByField(e error) map[string]string {
1735
	m := make(map[string]string)
1736
	if e == nil {
1737
		return m
1738
	}
1739
	// prototype for ValidateStruct
1740

1741
	switch e := e.(type) {
1742
	case Error:
1743
		m[e.Name] = e.Err.Error()
1744
	case Errors:
1745
		for _, item := range e.Errors() {
1746
			n := ErrorsByField(item)
1747
			for k, v := range n {
1748
				m[k] = v
1749
			}
1750
		}
1751
	}
1752

1753
	return m
1754
}
1755

1756
// Error returns string equivalent for reflect.Type
1757
func (e *UnsupportedTypeError) Error() string {
1758
	return "validator: unsupported type: " + e.Type.String()
1759
}
1760

1761
func (sv stringValues) Len() int           { return len(sv) }
1762
func (sv stringValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
1763
func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
1764
func (sv stringValues) get(i int) string   { return sv[i].String() }
1765

1766
func IsE164(str string) bool {
1767
	return rxE164.MatchString(str)
1768
}
1769