Adds ipv4 and ipv6 formats support

openapi3/schema.go

@@ -930,14 +930,25 @@ func (schema *Schema) visitJSONString(value string, fast bool) (err error) {
 			schema.compiledPattern = cp
 		} else if v := schema.Format; len(v) > 0 {
 			// No pattern, but does have a format
-			re := SchemaStringFormats[v]
-			if re != nil {
-				cp = &compiledPattern{
-					Regexp:    re,
-					ErrReason: "JSON string doesn't match the format '" + v + " (regular expression `" + re.String() + "`)'",
+			f := SchemaStringFormats[v]
+			switch f.Type {
+			case FormatTypeRe:
+				{
+					re := f.Regexp
+					if re != nil {
+						cp = &compiledPattern{
+							Regexp:    re,
+							ErrReason: "JSON string doesn't match the format '" + v + " (regular expression `" + re.String() + "`)'",
+						}
+						schema.compiledPattern = cp
+					}
+				}
+			case FormatTypeCallback:
+				{
+					return f.Callback(value)
 				}
-				schema.compiledPattern = cp
 			}
+
 		}
 	}
 	if cp != nil {
@@ -953,6 +964,13 @@ func (schema *Schema) visitJSONString(value string, fast bool) (err error) {
 				Reason:      cp.ErrReason,
 			}
 		}
+	} else if len(schema.Format) > 0 && cp == nil {
+		return &SchemaError{
+			Value:       value,
+			Schema:      schema,
+			SchemaField: "format",
+			Reason:      "Unsupported Format",
+		}
 	}
 	return
 }

openapi3/schema_formats.go

@@ -2,6 +2,7 @@ package openapi3
 
 import (
 	"fmt"
+	"net"
 	"regexp"
 )
 
@@ -10,15 +11,89 @@ const (
 	FormatOfStringForUUIDOfRFC4122 = `^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`
 )
 
-var SchemaStringFormats = make(map[string]*regexp.Regexp, 8)
+// FormatType is the type of format validation used
+type FormatType string
 
+// FormatTypeRe is regexp based validation
+const FormatTypeRe = "re"
+
+// FormatTypeCallback is callback based validation
+const FormatTypeCallback = "callback"
+
+type FormatCallback func(Val string) error
+
+//Format is the format type context fo validate the format
+type Format struct {
+	Type     FormatType
+	Regexp   *regexp.Regexp
+	Callback FormatCallback
+}
+
+//SchemaStringFormats allows for validating strings format
+var SchemaStringFormats = make(map[string]Format, 8)
+
+//DefineStringFormat Defines a new regexp pattern for a given format
 func DefineStringFormat(name string, pattern string) {
 	re, err := regexp.Compile(pattern)
 	if err != nil {
 		err := fmt.Errorf("Format '%v' has invalid pattern '%v': %v", name, pattern, err)
 		panic(err)
 	}
-	SchemaStringFormats[name] = re
+	f := Format{
+		Type:     FormatTypeRe,
+		Regexp:   re,
+		Callback: nil}
+	SchemaStringFormats[name] = f
+}
+
+// DefineStringCallbackFormat define callback based type callback validation
+func DefineStringCallbackFormat(name string, callback FormatCallback) {
+
+	f := Format{
+		Type:     FormatTypeCallback,
+		Regexp:   nil,
+		Callback: callback}
+	SchemaStringFormats[name] = f
+}
+
+func validateIP(ip string) (*net.IP, error) {
+	parsed := net.ParseIP(ip)
+	if parsed == nil {
+		return nil, &SchemaError{
+			Value:  ip,
+			Reason: "Not an IP address",
+		}
+	}
+	return &parsed, nil
+}
+
+func validateIPv4(ip string) error {
+	parsed, err := validateIP(ip)
+	if err != nil {
+		return err
+	}
+
+	if parsed.To4() == nil {
+		return &SchemaError{
+			Value:  ip,
+			Reason: "Not an IPv4 address (it's IPv6)",
+		}
+	}
+	return nil
+}
+func validateIPv6(ip string) error {
+	parsed, err := validateIP(ip)
+	if err != nil {
+		return err
+	}
+
+	if parsed.To4() != nil {
+		return &SchemaError{
+			Value:  ip,
+			Reason: "Not an IPv6 address (it's IPv4)",
+		}
+	}
+	return nil
 }
 
 func init() {
@@ -35,4 +110,8 @@ func init() {
 
 	// date-time
 	DefineStringFormat("date-time", `^[0-9]{4}-(0[0-9]|10|11|12)-([0-2][0-9]|30|31)T[0-9]{2}:[0-9]{2}:[0-9]{2}(.[0-9]+)?(Z|(\+|-)[0-9]{2}:[0-9]{2})?$`)
+
+	DefineStringCallbackFormat("ipv4", validateIPv4)
+	DefineStringCallbackFormat("ipv6", validateIPv6)
+
 }