fast_json-schema 0.1.0

data/ext/fast_json/schema/formats/utils/addr_spec_parser.c

@@ -0,0 +1,342 @@
+#include "formats/utils/addr_spec_parser.h"
+#include "formats/utils/utf8.h"
+#include "formats/utils/ip_parser.h"
+
+#include <stdbool.h>
+#include <string.h>
+
+/*
+* RFC 5321 section 4.1.3 length limits.
+*/
+#define MAX_LOCAL_PART  64
+#define MAX_DOMAIN     255
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+#define IS_ALPHA(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+
+/*
+* atext per RFC 5322:
+*   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" /
+*   "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
+*/
+static bool is_atext(unsigned char c) {
+  if(IS_ALPHA(c) || IS_DIGIT(c)) return true;
+
+  switch(c) {
+    case '!': case '#': case '$': case '%': case '&': case '\'':
+    case '*': case '+': case '-': case '/': case '=': case '?':
+    case '^': case '_': case '`': case '{': case '|': case '}':
+    case '~':
+      return true;
+  }
+
+  return false;
+}
+
+/*
+* qtext per RFC 5322:
+*   %d33 / %d35-91 / %d93-126
+* (i.e. VCHAR except '"' and '\').
+*/
+static bool is_qtext(unsigned char c) {
+  return c == 33 || (c >= 35 && c <= 91) || (c >= 93 && c <= 126);
+}
+
+/*
+* General-address-literal dcontent per RFC 5321 section 4.1.3:
+*   dcontent = %d33-90 / %d94-126
+*/
+static bool is_dcontent(unsigned char c) {
+  return (c >= 33 && c <= 90) || (c >= 94 && c <= 126);
+}
+
+/*
+* VCHAR per RFC 5234: %x21-7E.
+* WSP per RFC 5234:   SP / HTAB.
+*/
+static bool is_vchar(unsigned char c) { return c >= 0x21 && c <= 0x7E; }
+static bool is_wsp(unsigned char c)   { return c == ' ' || c == '\t'; }
+
+/*
+* Try to consume a single atext character (or a valid UTF-8 sequence when
+* allow_utf8 is true). Returns the number of bytes consumed, or 0 if the
+* input does not start with an atext character.
+*/
+static long consume_atext(const char *s, long len, bool allow_utf8) {
+  unsigned char c = (unsigned char)s[0];
+
+  if(c < 0x80) return is_atext(c) ? 1 : 0;
+  if(!allow_utf8) return 0;
+
+  return utf8_seq_len((const unsigned char *)s, len);
+}
+
+/*
+* Parse 1*atext starting at s. Returns the number of bytes consumed, or 0 if
+* there is not at least one atext character.
+*/
+static long parse_atext_run(const char *s, long len, bool allow_utf8) {
+  long pos = 0;
+
+  while(pos < len) {
+    long n = consume_atext(s + pos, len - pos, allow_utf8);
+
+    if(n == 0) break;
+
+    pos += n;
+  }
+
+  return pos;
+}
+
+/*
+* Parse a dot-atom-text: 1*atext *("." 1*atext).
+* Returns the number of bytes consumed, or 0 on failure.
+*/
+static long parse_dot_atom(const char *s, long len, bool allow_utf8, bool allow_trailing_dot) {
+  long first = parse_atext_run(s, len, allow_utf8);
+
+  if(first == 0) return 0;
+
+  long pos = first;
+
+  while(pos < len && s[pos] == '.') {
+    long next = parse_atext_run(s + pos + 1, len - pos - 1, allow_utf8);
+
+    if(next == 0) {
+      /*
+      * A single trailing dot is accepted in the domain to support fully
+      * qualified DNS names; consecutive dots and trailing dots in the
+      * local-part remain rejected.
+      */
+      if(allow_trailing_dot && pos + 1 == len) return len;
+
+      return 0;
+    }
+
+    pos += 1 + next;
+  }
+
+  return pos;
+}
+
+/*
+* Parse a quoted-string (excluding any surrounding CFWS - we don't allow it):
+*   DQUOTE *( qtext / quoted-pair ) DQUOTE
+*   quoted-pair = "\" ( VCHAR / WSP )
+*
+* WSP between qcontent items is allowed by RFC 5322 (FWS), but we keep it
+* strict: WSP is only allowed inside the quoted-string as bare octets if it
+* is part of qtext. SP (0x20) and HTAB (0x09) are not in qtext, but are
+* commonly accepted; for strictness we accept SP/HTAB as a bare octet inside
+* the quoted-string (as if folded FWS) - this mirrors the RFC's qcontent
+* allowance via FWS without permitting line folding.
+*
+* Returns the number of bytes consumed including the surrounding DQUOTEs,
+* or 0 on failure.
+*/
+static long parse_quoted_string(const char *s, long len, bool allow_utf8) {
+  if(len < 2 || s[0] != '"') return 0;
+
+  long pos = 1;
+
+  while(pos < len && s[pos] != '"') {
+    unsigned char c = (unsigned char)s[pos];
+
+    if(c == '\\') {
+      if(pos + 1 >= len) return 0;
+
+      unsigned char next = (unsigned char)s[pos + 1];
+
+      if(!is_vchar(next) && !is_wsp(next)) return 0;
+
+      pos += 2;
+      continue;
+    }
+
+    if(is_qtext(c) || is_wsp(c)) {
+      pos++;
+      continue;
+    }
+
+    if(allow_utf8 && c >= 0x80) {
+      long n = utf8_seq_len((const unsigned char *)s + pos, len - pos);
+
+      if(n == 0) return 0;
+
+      pos += n;
+      continue;
+    }
+
+    return 0;
+  }
+
+  if(pos >= len || s[pos] != '"') return 0;
+
+  return pos + 1;
+}
+
+/*
+* Parse the local-part: dot-atom-text or quoted-string.
+* Returns the number of bytes consumed, or 0 on failure.
+*/
+static long parse_local_part(const char *s, long len, bool allow_utf8) {
+  if(len == 0) return 0;
+
+  if(s[0] == '"') return parse_quoted_string(s, len, allow_utf8);
+
+  return parse_dot_atom(s, len, allow_utf8, false);
+}
+
+/*
+* IPv6-address-literal per RFC 5321 section 4.1.3: "IPv6:" IPv6-addr
+*/
+static bool parse_ipv6_literal(const char *s, long len) {
+  if(len < 5) return false;
+  if(memcmp(s, "IPv6:", 5) != 0) return false;
+
+  return parse_ipv6(s + 5, len - 5);
+}
+
+/*
+* Ldh-str per RFC 5321:
+*   Let-dig *( *("-") Let-dig )
+* simplified to: ALPHA/DIGIT, may contain '-' but must end with ALPHA/DIGIT.
+*/
+static bool parse_ldh_str(const char *s, long len) {
+  if(len == 0) return false;
+  if(!IS_ALPHA((unsigned char)s[0]) && !IS_DIGIT((unsigned char)s[0])) return false;
+
+  for(long i = 0; i < len; i++) {
+    unsigned char c = (unsigned char)s[i];
+
+    if(!IS_ALPHA(c) && !IS_DIGIT(c) && c != '-') return false;
+  }
+
+  if(s[len - 1] == '-') return false;
+
+  return true;
+}
+
+/*
+* General-address-literal per RFC 5321 section 4.1.3:
+*   Standardized-tag ":" 1*dcontent
+*   Standardized-tag = Ldh-str
+*/
+static bool parse_general_address_literal(const char *s, long len, bool allow_utf8) {
+  long colon = -1;
+
+  for(long i = 0; i < len; i++) {
+    if(s[i] == ':') { colon = i; break; }
+  }
+
+  if(colon <= 0 || colon >= len - 1) return false;
+
+  if(!parse_ldh_str(s, colon)) return false;
+
+  /*
+  * Standardized-tag must be a registered token; reject "IPv6" here so that an
+  * "IPv6:..." body that failed parse_ipv6_literal does not silently match the
+  * General-address-literal form. Also require at least one ALPHA in the tag
+  * to avoid all-digit tags accidentally matching IPv6-shaped content.
+  */
+  if(colon == 4 && memcmp(s, "IPv6", 4) == 0) return false;
+
+  bool has_alpha = false;
+  for(long i = 0; i < colon; i++) {
+    if(IS_ALPHA((unsigned char)s[i])) { has_alpha = true; break; }
+  }
+  if(!has_alpha) return false;
+
+  long pos = colon + 1;
+
+  if(pos >= len) return false;
+
+  while(pos < len) {
+    unsigned char c = (unsigned char)s[pos];
+
+    if(c < 0x80) {
+      if(!is_dcontent(c)) return false;
+      pos++;
+      continue;
+    }
+
+    if(!allow_utf8) return false;
+
+    long n = utf8_seq_len((const unsigned char *)s + pos, len - pos);
+
+    if(n == 0) return false;
+
+    pos += n;
+  }
+
+  return true;
+}
+
+/*
+* domain-literal contents (between "[" and "]"). Tries IPv4, then IPv6, then
+* General-address-literal. Per RFC 6531 only General-address-literal admits
+* UTF-8 in dcontent; IPv4 and IPv6 literals remain ASCII.
+*/
+static bool parse_domain_literal_body(const char *s, long len, bool allow_utf8) {
+  if(parse_ipv4(s, len)) return true;
+  if(parse_ipv6_literal(s, len)) return true;
+
+  return parse_general_address_literal(s, len, allow_utf8);
+}
+
+/*
+* Parse a domain-literal: "[" body "]"
+* Returns the number of bytes consumed, or 0 on failure.
+*/
+static long parse_domain_literal(const char *s, long len, bool allow_utf8) {
+  if(len < 2 || s[0] != '[') return 0;
+
+  long end = -1;
+
+  for(long i = 1; i < len; i++) {
+    if(s[i] == ']') { end = i; break; }
+  }
+
+  if(end == -1) return 0;
+
+  if(!parse_domain_literal_body(s + 1, end - 1, allow_utf8)) return 0;
+
+  return end + 1;
+}
+
+/*
+* Parse the domain: dot-atom-text or domain-literal.
+* Returns the number of bytes consumed, or 0 on failure.
+*/
+static long parse_domain(const char *s, long len, bool allow_utf8) {
+  if(len == 0) return 0;
+
+  if(s[0] == '[') return parse_domain_literal(s, len, allow_utf8);
+
+  return parse_dot_atom(s, len, allow_utf8, true);
+}
+
+bool parse_addr_spec(const char *s, long len, bool allow_utf8) {
+  if(len == 0) return false;
+
+  long local_len = parse_local_part(s, len, allow_utf8);
+
+  if(local_len == 0) return false;
+  if(local_len > MAX_LOCAL_PART) return false;
+  if(local_len >= len) return false;
+  if(s[local_len] != '@') return false;
+
+  long domain_off = local_len + 1;
+  long domain_len = len - domain_off;
+
+  if(domain_len <= 0) return false;
+  if(domain_len > MAX_DOMAIN) return false;
+
+  long consumed = parse_domain(s + domain_off, domain_len, allow_utf8);
+
+  if(consumed == 0) return false;
+  if(consumed != domain_len) return false;
+
+  return true;
+}

data/ext/fast_json/schema/formats/utils/addr_spec_parser.h

@@ -0,0 +1,16 @@
+#ifndef FAST_JSON_FORMATS_UTILS_ADDR_SPEC_PARSER_H
+#define FAST_JSON_FORMATS_UTILS_ADDR_SPEC_PARSER_H
+
+#include <stdbool.h>
+
+/*
+* Strict RFC 5322 addr-spec parser (with RFC 5321 address-literals).
+* When allow_utf8 is true, RFC 6531 UTF8-non-ASCII extensions are accepted in
+* atext, qtext and General-address-literal dcontent productions.
+*
+* Returns true if the entire input is a valid addr-spec, false otherwise.
+* No CFWS, no obs-* productions, no leading/trailing whitespace.
+*/
+bool parse_addr_spec(const char *s, long len, bool allow_utf8);
+
+#endif

data/ext/fast_json/schema/formats/utils/hostname_parser.c

@@ -0,0 +1,113 @@
+#include "formats/utils/hostname_parser.h"
+#include "formats/utils/utf8.h"
+
+#include <stdbool.h>
+
+#define MAX_HOSTNAME_LEN 253
+#define MAX_LABEL_LEN     63
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+#define IS_ALPHA(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+
+/*
+* let-dig per RFC 1123 section 2.1: ALPHA / DIGIT.
+*/
+static bool is_let_dig(unsigned char c) {
+  return IS_ALPHA(c) || IS_DIGIT(c);
+}
+
+/*
+* let-dig-hyp per RFC 1123 section 2.1: ALPHA / DIGIT / "-".
+*/
+static bool is_let_dig_hyp(unsigned char c) {
+  return is_let_dig(c) || c == '-';
+}
+
+/*
+* Try to consume one "label character" starting at s.
+* Returns the number of bytes consumed, or 0 if the input does not start
+* with a valid label character.
+*
+* In allow_utf8 mode, any byte >= 0x80 must begin a valid UTF-8 sequence
+* and is accepted as a single label character (pragmatic idn-hostname).
+*/
+static long consume_label_char(const char *s, long len, bool allow_utf8, bool allow_hyphen) {
+  unsigned char c = (unsigned char)s[0];
+
+  if(c < 0x80) {
+    if(allow_hyphen) return is_let_dig_hyp(c) ? 1 : 0;
+
+    return is_let_dig(c) ? 1 : 0;
+  }
+
+  if(!allow_utf8) return 0;
+
+  return utf8_seq_len((const unsigned char *)s, len);
+}
+
+/*
+* Parse a single label: let-dig [ *(let-dig-hyp) let-dig ].
+* The label may not start with a hyphen and may not end with a hyphen.
+* Returns the number of bytes consumed, or 0 on failure.
+*/
+static long parse_label(const char *s, long len, bool allow_utf8) {
+  if(len == 0) return 0;
+
+  long first = consume_label_char(s, len, allow_utf8, false);
+
+  if(first == 0) return 0;
+
+  long pos = first;
+  long last_char_start = 0;
+
+  while(pos < len && s[pos] != '.') {
+    long n = consume_label_char(s + pos, len - pos, allow_utf8, true);
+
+    if(n == 0) return 0;
+
+    last_char_start = pos;
+    pos += n;
+
+    if(pos > MAX_LABEL_LEN) return 0;
+  }
+
+  /*
+  * Label must not end with a hyphen. The last consumed character begins at
+  * either `last_char_start` (if more than one character) or at offset 0.
+  */
+  long last_start = last_char_start ? last_char_start : 0;
+
+  if(pos > first && (unsigned char)s[last_start] == '-') return 0;
+
+  return pos;
+}
+
+bool parse_hostname(const char *s, long len, bool allow_utf8) {
+  if(len == 0) return false;
+  if(len > MAX_HOSTNAME_LEN) return false;
+
+  long pos = 0;
+
+  while(pos < len) {
+    long label_len = parse_label(s + pos, len - pos, allow_utf8);
+
+    if(label_len == 0) return false;
+
+    pos += label_len;
+
+    if(pos == len) break;
+
+    if(s[pos] != '.') return false;
+
+    pos++; // consume '.'
+
+    /*
+    * A single trailing dot is accepted (RFC 1034 section 3.1 absolute form).
+    * Any further bytes after the trailing dot, or two consecutive dots,
+    * will be rejected because parse_label returns 0 on empty input.
+    */
+    if(pos == len) return true;
+  }
+
+  return true;
+}

data/ext/fast_json/schema/formats/utils/hostname_parser.h

@@ -0,0 +1,17 @@
+#ifndef FAST_JSON_FORMATS_UTILS_HOSTNAME_PARSER_H
+#define FAST_JSON_FORMATS_UTILS_HOSTNAME_PARSER_H
+
+#include <stdbool.h>
+
+/*
+* Hostname parser per RFC 1123 section 2.1 + RFC 1035 section 2.3.4 length limits.
+*
+* When allow_utf8 is true, label characters may also be valid UTF-8
+* multi-byte sequences (pragmatic idn-hostname; not full IDNA2008).
+*
+* Returns true if the entire input is a syntactically valid hostname,
+* false otherwise. A single trailing dot is allowed (RFC 1034 section 3.1).
+*/
+bool parse_hostname(const char *s, long len, bool allow_utf8);
+
+#endif

data/ext/fast_json/schema/formats/utils/ip_parser.c

@@ -0,0 +1,126 @@
+#include "formats/utils/ip_parser.h"
+
+#include <stdbool.h>
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+#define IS_HEX(c)   (IS_DIGIT(c) || ((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
+
+bool parse_ipv4(const char *s, long len) {
+  long pos = 0;
+
+  for(int i = 0; i < 4; i++) {
+    if(pos >= len) return false;
+    if(!IS_DIGIT(s[pos])) return false;
+
+    /*
+    * Reject leading zeros: "0" is allowed alone, but "01", "001" are not.
+    * Per RFC 3986 section 3.2.2 dec-octet, leading zeros are forbidden to avoid
+    * historical octal-vs-decimal ambiguity.
+    */
+    if(s[pos] == '0' && pos + 1 < len && IS_DIGIT(s[pos + 1])) return false;
+
+    int value = 0;
+    int digits = 0;
+
+    while(pos < len && IS_DIGIT(s[pos]) && digits < 3) {
+      value = value * 10 + (s[pos] - '0');
+      pos++;
+      digits++;
+    }
+
+    if(value > 255) return false;
+
+    if(i < 3) {
+      if(pos >= len || s[pos] != '.') return false;
+      pos++;
+    }
+  }
+
+  return pos == len;
+}
+
+/*
+* Parse an IPv6 hex group: 1-4 hex digits.
+* Returns the number of digits consumed, or 0 if none.
+*/
+static int parse_ipv6_group(const char *s, long len) {
+  int digits = 0;
+
+  while(digits < 4 && digits < len && IS_HEX((unsigned char)s[digits])) digits++;
+
+  return digits;
+}
+
+bool parse_ipv6(const char *s, long len) {
+  long pos = 0;
+  int groups = 0;
+  bool seen_compression = false;
+  bool last_was_group = false;
+
+  if(len >= 2 && s[0] == ':' && s[1] == ':') {
+    seen_compression = true;
+    pos = 2;
+  } else if(len >= 1 && s[0] == ':') {
+    return false;
+  }
+
+  while(pos < len) {
+    /* Try IPv4 tail first when we are at the start of a group and there are dots ahead. */
+    if(!last_was_group) {
+      bool has_dot = false;
+
+      for(long k = pos; k < len; k++) {
+        if(s[k] == '.') { has_dot = true; break; }
+        if(s[k] == ':') break;
+      }
+
+      if(has_dot) {
+        if(!parse_ipv4(s + pos, len - pos)) return false;
+
+        groups += 2;
+        pos = len;
+        last_was_group = true;
+        break;
+      }
+    }
+
+    int g = parse_ipv6_group(s + pos, len - pos);
+
+    if(g == 0) return false;
+
+    pos += g;
+    groups++;
+    last_was_group = true;
+
+    if(pos == len) break;
+
+    if(s[pos] != ':') return false;
+
+    /* Possible "::" compression. */
+    if(pos + 1 < len && s[pos + 1] == ':') {
+      if(seen_compression) return false;
+
+      seen_compression = true;
+      pos += 2;
+      last_was_group = false;
+
+      if(pos == len) break; // trailing "::"
+      continue;
+    }
+
+    pos++;
+    last_was_group = false;
+  }
+
+  if(pos != len) return false;
+
+  if(!last_was_group && !seen_compression) return false; // trailing single ":"
+
+  if(seen_compression) {
+    if(groups > 7) return false;
+
+    return true;
+  }
+
+  return groups == 8;
+}

data/ext/fast_json/schema/formats/utils/ip_parser.h

@@ -0,0 +1,25 @@
+#ifndef FAST_JSON_FORMATS_UTILS_IP_PARSER_H
+#define FAST_JSON_FORMATS_UTILS_IP_PARSER_H
+
+#include <stdbool.h>
+
+/*
+* IPv4 dotted-decimal address per RFC 2673 section 3.2 / RFC 3986 section 3.2.2:
+*   IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+*   dec-octet   = 1*3DIGIT, value 0..255, no leading zeros
+*
+* Returns true if the entire input is a valid IPv4 address, false otherwise.
+*/
+bool parse_ipv4(const char *s, long len);
+
+/*
+* IPv6 address per RFC 4291 section 2.2:
+*   - Up to 8 groups of 1-4 hex digits separated by ":"
+*   - At most one "::" compression standing for one or more zero groups
+*   - Optional trailing IPv4 dotted form (counts as 2 groups)
+*
+* Returns true if the entire input is a valid IPv6 address, false otherwise.
+*/
+bool parse_ipv6(const char *s, long len);
+
+#endif

data/ext/fast_json/schema/formats/utils/json_pointer_parser.c

@@ -0,0 +1,45 @@
+#include "formats/utils/json_pointer_parser.h"
+#include "formats/utils/utf8.h"
+
+bool parse_json_pointer(const char *s, long len) {
+  long pos = 0;
+
+  while(pos < len) {
+    if(s[pos] != '/') return false;
+
+    pos++;
+
+    while(pos < len && s[pos] != '/') {
+      unsigned char c = (unsigned char)s[pos];
+
+      /* 
+      * Escape sequence: "~" ( "0" / "1" )
+      */
+      if(c == '~') {
+        if(pos + 1 >= len) return false;
+        if(s[pos + 1] != '0' && s[pos + 1] != '1') return false;
+        pos += 2;
+        continue;
+      }
+
+      /*
+      * ASCII byte
+      */
+      if(c < 0x80) {
+        pos++;
+        continue;
+      }
+
+      /*
+      * UTF-8 multi-byte sequence
+      */
+      long n = utf8_seq_len((const unsigned char *)(s + pos), len - pos);
+
+      if(n == 0) return false;
+
+      pos += n;
+    }
+  }
+
+  return true;
+}

data/ext/fast_json/schema/formats/utils/json_pointer_parser.h

@@ -0,0 +1,20 @@
+#ifndef FAST_JSON_FORMATS_UTILS_JSON_POINTER_PARSER_H
+#define FAST_JSON_FORMATS_UTILS_JSON_POINTER_PARSER_H
+
+#include <stdbool.h>
+
+/*
+* RFC 6901 section 3 JSON Pointer parser.
+*
+*   json-pointer    = *( "/" reference-token )
+*   reference-token = *( unescaped / escaped )
+*   unescaped       = %x00-2E / %x30-7D / %x7F-10FFFF
+*   escaped         = "~" ( "0" / "1" )
+*
+* The empty string is a valid JSON Pointer (whole-document reference).
+* UTF-8 multi-byte sequences are accepted in token content per the
+* unescaped %x80-10FFFF range. NUL bytes are accepted per %x00-2E.
+*/
+bool parse_json_pointer(const char *s, long len);
+
+#endif