NAME

       rgxg_net_cidr_string,  rgxg_net_cidr_ipv4,  rgxg_net_cidr_ipv6 - create regex that matches
       all addresses of the given CIDR block

SYNOPSIS

       #include <rgxg/net.h>

       int rgxg_net_cidr_string (const char *cidr, char **endptr, char *regex,
            rgxg_options_t options);

       int rgxg_net_cidr_ipv4 (const rgxg_ipv4_t *address, int prefix, char *regex,
            rgxg_options_t options);
       int rgxg_net_cidr_ipv6 (const rgxg_ipv6_t *address, int prefix, char *regex,
            rgxg_options_t options);

DESCRIPTION

       rgxg_net_cidr_string() generates  the  (extended)  regular  expression  that  matches  all
       addresses   of  the  CIDR  block  given  as  string  in  cidr  (e.g.  "192.168.0.0/24"  or
       "2001:db8:aaaa::/64").  cidr must be valid and not NULL.

       If endptr is not NULL, rgxg_net_cidr_string() stores on success the address of  the  first
       character  which  is  not  part  of  the  CIDR block in *endptr.  If there is no error and
       **endptr is '\0', then the entire string has been parsed. The *endptr values in case of an
       error are described in the ERRORS section below.

       rgxg_net_cidr_ipv4()  and  rgxg_net_cidr_ipv6() generate the (extended) regular expression
       that matches all addresses of the CIDR block specified  by  address  and  prefix  (network
       identifier),  which  must  be  between  0  and  32 (rgxg_net_cidr_ipv4()) respectively 128
       (rgxg_net_cidr_ipv6()) inclusive.  address must be valid and not NULL.

       The rgxg_ipv4_t and rgxg_ipv6_t structures which are the types of address are  defined  in
       <rgxg/net.h>.

           typedef struct {
               uint8_t octet[4];
           } rgxg_ipv4_t;

           typedef struct {
               uint16_t hextet[8];
           } rgxg_ipv6_t;

       The  n-th  element  of the octet/hextet array stores the (n+1)-th octet/hextet of the IPv4
       respectively IPv6 address (i.e. for instance the first octet  '192'  in  '192.168.0.0'  is
       stored in octet[0]).

       The  generated  regular expression is written to the character string regex, including the
       terminating null byte ('\0'), unless RGXG_NONULLBYTE is set. If regex is NULL  the  return
       value  is  the  number of characters (excluding the terminating null byte) that would have
       been written in case regex has  been  initialized.  Note  that  the  functions  assume  an
       arbitrarily  long  regex string, callers must ensure that the given string is large enough
       to not overflow the actual space.

       options is either zero, or the bitwise-or of one or more of the following macros:

       Options marked as 'IPv6 only' can be used with rgxg_net_cidr_string() (when  parsing  IPv6
       CIDR blocks) and with rgxg_net_cidr_ipv6().

       RGXG_NOUPPERCASE (IPv6 only)
              The  generated  regular  expression  only  matches  IPv6  addresses with lower case
              letters. By default both lower and upper case letters are matched.

       RGXG_NOLOWERCASE (IPv6 only)
              The generated regular expression  only  matches  IPv6  addresses  with  upper  case
              letters. By default both lower and upper case letters are matched.

       RGXG_NOZEROCOMPRESSION (IPv6 only)
              The   generated  regular  expression  does  not  match  IPv6  addresses  with  zero
              compression (second form of text representation  of  IPv6  addresses  mentioned  in
              section 2.2 of RFC 4291).

       RGXG_NOMIXEDNOTATION (IPv6 only)
              The  generated  regular  expression does not match IPv6 addresses in mixed notation
              (third form of text representation of IPv6 addresses mentioned in  section  2.2  of
              RFC 4291).

       RGXG_NOOUTERPARENS (IPv6 only)
              Omit the outer parenthesis, if any, of the regular expression.

       RGXG_NONULLBYTE
              Do not add the terminating null byte ('\0') to the regex string.

       Note that RGXG_NOUPPERCASE and RGXG_NOLOWERCASE are mutual exclusive options.

RETURN VALUE

       Upon  successful  return,  these  functions return the number of characters (excluding the
       terminating null byte) written to regex.

       If an error occurs, a (negative) error code is returned (see ERRORS section).

ERRORS

       The following errors can be returned:

       RGXG_ERROR_PREFIX
              Invalid network identifier (e.g. the prefix is lesser than 0  or  greater  than  32
              (IPv4) respectively 128 (IPv6)).

              rgxg_net_cidr_string():  If  endptr  is  not  NULL,  *endptr  points  to  the first
              character of the invalid prefix.

       RGXG_ERROR_ARG2BIG (rgxg_net_cidr_string() only)
              At least one octet/hextet is too large.

              rgxg_net_cidr_string(): If endptr is not NULL, *endptr points to the first digit of
              the too large octet/hextet.

       RGXG_ERROR_SYNTAX (rgxg_net_cidr_string() only)
              Syntax  error  in  cidr  string.   If  endptr  is  not  NULL, *endptr points to the
              character that causes the syntax error.

       RGXG_ERROR_MUTEXOPTIONS (rgxg_net_cidr_string()/rgxg_net_cidr_ipv6() only)
              Two mutual exclusive options were specified.

AVAILABILITY

       These functions are available since rgxg 0.1.

SEE ALSO

       regex(7), rgxg_number_greaterequal(3), rgxg_number_range(3).

AUTHOR

       Hannes von Haugwitz <hannes@vonhaugwitz.com>