src/lib/mhd_str.c - manifest_repos/libmicrohttpd - Git at Google

 /*
   This file is part of libmicrohttpd
   Copyright (C) 2015, 2016 Karlson2k (Evgeny Grin)

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

 /**
  * @file microhttpd/mhd_str.c
  * @brief  Functions implementations for string manipulating
  * @author Karlson2k (Evgeny Grin)
  */

 #include "mhd_str.h"

 #ifdef HAVE_STDBOOL_H
 #include <stdbool.h>
 #endif

 #include "mhd_limits.h"

 #ifdef MHD_FAVOR_SMALL_CODE
 #ifdef _MHD_static_inline
 #undef _MHD_static_inline
 #endif /* _MHD_static_inline */
 /* Do not force inlining and do not use macro functions, use normal static
    functions instead.
    This may give more flexibility for size optimizations. */
 #define _MHD_static_inline static
 #ifndef INLINE_FUNC
 #define INLINE_FUNC 1
 #endif /* !INLINE_FUNC */
 #endif /* MHD_FAVOR_SMALL_CODE */

 /*
  * Block of functions/macros that use US-ASCII charset as required by HTTP
  * standards. Not affected by current locale settings.
  */

 #ifdef INLINE_FUNC

 #if 0 /* Disable unused functions. */
 /**
  * Check whether character is lower case letter in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is lower case letter, zero otherwise
  */
 _MHD_static_inline bool
 isasciilower (char c)
 {
   return (c >= 'a') && (c <= 'z');
 }


 #endif /* Disable unused functions. */


 /**
  * Check whether character is upper case letter in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is upper case letter, zero otherwise
  */
 _MHD_static_inline bool
 isasciiupper (char c)
 {
   return (c >= 'A') && (c <= 'Z');
 }


 #if 0 /* Disable unused functions. */
 /**
  * Check whether character is letter in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is letter in US-ASCII, zero otherwise
  */
 _MHD_static_inline bool
 isasciialpha (char c)
 {
   return isasciilower (c) || isasciiupper (c);
 }


 #endif /* Disable unused functions. */


 /**
  * Check whether character is decimal digit in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is decimal digit, zero otherwise
  */
 _MHD_static_inline bool
 isasciidigit (char c)
 {
   return (c >= '0') && (c <= '9');
 }


 #if 0 /* Disable unused functions. */
 /**
  * Check whether character is hexadecimal digit in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is decimal digit, zero otherwise
  */
 _MHD_static_inline bool
 isasciixdigit (char c)
 {
   return isasciidigit (c) ||
          ( (c >= 'A') && (c <= 'F') ) ||
          ( (c >= 'a') && (c <= 'f') );
 }


 /**
  * Check whether character is decimal digit or letter in US-ASCII
  *
  * @param c character to check
  * @return non-zero if character is decimal digit or letter, zero otherwise
  */
 _MHD_static_inline bool
 isasciialnum (char c)
 {
   return isasciialpha (c) || isasciidigit (c);
 }


 #endif /* Disable unused functions. */


 /**
  * Convert US-ASCII character to lower case.
  * If character is upper case letter in US-ASCII than it's converted to lower
  * case analog. If character is NOT upper case letter than it's returned
  * unmodified.
  *
  * @param c character to convert
  * @return converted to lower case character
  */
 _MHD_static_inline char
 toasciilower (char c)
 {
   return isasciiupper (c) ? (c - 'A' + 'a') : c;
 }


 #if 0 /* Disable unused functions. */
 /**
  * Convert US-ASCII character to upper case.
  * If character is lower case letter in US-ASCII than it's converted to upper
  * case analog. If character is NOT lower case letter than it's returned
  * unmodified.
  *
  * @param c character to convert
  * @return converted to upper case character
  */
 _MHD_static_inline char
 toasciiupper (char c)
 {
   return isasciilower (c) ? (c - 'a' + 'A') : c;
 }


 #endif /* Disable unused functions. */


 #if defined(MHD_FAVOR_SMALL_CODE) /* Used only in MHD_str_to_uvalue_n_() */
 /**
  * Convert US-ASCII decimal digit to its value.
  *
  * @param c character to convert
  * @return value of decimal digit or -1 if @ c is not decimal digit
  */
 _MHD_static_inline int
 todigitvalue (char c)
 {
   if (isasciidigit (c))
     return (unsigned char) (c - '0');

   return -1;
 }


 #endif /* MHD_FAVOR_SMALL_CODE */


 /**
  * Convert US-ASCII hexadecimal digit to its value.
  *
  * @param c character to convert
  * @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
  */
 _MHD_static_inline int
 toxdigitvalue (char c)
 {
   if (isasciidigit (c))
     return (unsigned char) (c - '0');
   if ( (c >= 'A') && (c <= 'F') )
     return (unsigned char) (c - 'A' + 10);
   if ( (c >= 'a') && (c <= 'f') )
     return (unsigned char) (c - 'a' + 10);

   return -1;
 }


 #else  /* !INLINE_FUNC */


 /**
  * Checks whether character is lower case letter in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is lower case letter,
  *         boolean false otherwise
  */
 #define isasciilower(c) (((char) (c)) >= 'a' && ((char) (c)) <= 'z')


 /**
  * Checks whether character is upper case letter in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is upper case letter,
  *         boolean false otherwise
  */
 #define isasciiupper(c) (((char) (c)) >= 'A' && ((char) (c)) <= 'Z')


 /**
  * Checks whether character is letter in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is letter, boolean false
  *         otherwise
  */
 #define isasciialpha(c) (isasciilower (c) || isasciiupper (c))


 /**
  * Check whether character is decimal digit in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is decimal digit, boolean false
  *         otherwise
  */
 #define isasciidigit(c) (((char) (c)) >= '0' && ((char) (c)) <= '9')


 /**
  * Check whether character is hexadecimal digit in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is hexadecimal digit,
  *         boolean false otherwise
  */
 #define isasciixdigit(c) (isasciidigit ((c)) || \
                           (((char) (c)) >= 'A' && ((char) (c)) <= 'F') || \
                           (((char) (c)) >= 'a' && ((char) (c)) <= 'f') )


 /**
  * Check whether character is decimal digit or letter in US-ASCII
  *
  * @param c character to check
  * @return boolean true if character is decimal digit or letter,
  *         boolean false otherwise
  */
 #define isasciialnum(c) (isasciialpha (c) || isasciidigit (c))


 /**
  * Convert US-ASCII character to lower case.
  * If character is upper case letter in US-ASCII than it's converted to lower
  * case analog. If character is NOT upper case letter than it's returned
  * unmodified.
  *
  * @param c character to convert
  * @return converted to lower case character
  */
 #define toasciilower(c) ((isasciiupper (c)) ? (((char) (c)) - 'A' + 'a') : \
                          ((char) (c)))


 /**
  * Convert US-ASCII character to upper case.
  * If character is lower case letter in US-ASCII than it's converted to upper
  * case analog. If character is NOT lower case letter than it's returned
  * unmodified.
  *
  * @param c character to convert
  * @return converted to upper case character
  */
 #define toasciiupper(c) ((isasciilower (c)) ? (((char) (c)) - 'a' + 'A') : \
                          ((char) (c)))


 /**
  * Convert US-ASCII decimal digit to its value.
  *
  * @param c character to convert
  * @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
  */
 #define todigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
                          (int) (-1))


 /**
  * Convert US-ASCII hexadecimal digit to its value.
  * @param c character to convert
  * @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
  */
 #define toxdigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
                           ( (((char) (c)) >= 'A' && ((char) (c)) <= 'F') ? \
                             (int) (((unsigned char) (c)) - 'A' + 10) : \
                             ( (((char) (c)) >= 'a' && ((char) (c)) <= 'f') ? \
                               (int) (((unsigned char) (c)) - 'a' + 10) : \
                               (int) (-1) )))
 #endif /* !INLINE_FUNC */


 #ifndef MHD_FAVOR_SMALL_CODE
 /**
  * Check two string for equality, ignoring case of US-ASCII letters.
  *
  * @param str1 first string to compare
  * @param str2 second string to compare
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
 MHD_str_equal_caseless_ (const char *str1,
                          const char *str2)
 {
   while (0 != (*str1))
   {
     const char c1 = *str1;
     const char c2 = *str2;
     if ( (c1 != c2) &&
          (toasciilower (c1) != toasciilower (c2)) )
       return 0;
     str1++;
     str2++;
   }
   return 0 == (*str2);
 }


 #endif /* ! MHD_FAVOR_SMALL_CODE */


 /**
  * Check two string for equality, ignoring case of US-ASCII letters and
  * checking not more than @a maxlen characters.
  * Compares up to first terminating null character, but not more than
  * first @a maxlen characters.
  *
  * @param str1 first string to compare
  * @param str2 second string to compare
  * @param maxlen maximum number of characters to compare
  * @return non-zero if two strings are equal, zero otherwise.
  */
 int
 MHD_str_equal_caseless_n_ (const char *const str1,
                            const char *const str2,
                            size_t maxlen)
 {
   size_t i;

   for (i = 0; i < maxlen; ++i)
   {
     const char c1 = str1[i];
     const char c2 = str2[i];
     if (0 == c2)
       return 0 == c1;
     if ( (c1 != c2) &&
          (toasciilower (c1) != toasciilower (c2)) )
       return 0;
   }
   return ! 0;
 }


 /**
  * Check whether @a str has case-insensitive @a token.
  * Token could be surrounded by spaces and tabs and delimited by comma.
  * Match succeed if substring between start, end (of string) or comma
  * contains only case-insensitive token and optional spaces and tabs.
  * @warning token must not contain null-charters except optional
  *          terminating null-character.
  * @param str the string to check
  * @param token the token to find
  * @param token_len length of token, not including optional terminating
  *                  null-character.
  * @return non-zero if two strings are equal, zero otherwise.
  */
 bool
 MHD_str_has_token_caseless_ (const char *str,
                              const char *const token,
                              size_t token_len)
 {
   if (0 == token_len)
     return false;

   while (0 != *str)
   {
     size_t i;
     /* Skip all whitespaces and empty tokens. */
     while (' ' == *str || '\t' == *str || ',' == *str)
       str++;

     /* Check for token match. */
     i = 0;
     while (1)
     {
       const char sc = *(str++);
       const char tc = token[i++];

       if (0 == sc)
         return false;
       if ( (sc != tc) &&
            (toasciilower (sc) != toasciilower (tc)) )
         break;
       if (i >= token_len)
       {
         /* Check whether substring match token fully or
          * has additional unmatched chars at tail. */
         while (' ' == *str || '\t' == *str)
           str++;
         /* End of (sub)string? */
         if ((0 == *str) || (',' == *str) )
           return true;
         /* Unmatched chars at end of substring. */
         break;
       }
     }
     /* Find next substring. */
     while (0 != *str && ',' != *str)
       str++;
   }
   return false;
 }


 #ifndef MHD_FAVOR_SMALL_CODE
 /* Use individual function for each case */

 /**
  * Convert decimal US-ASCII digits in string to number in uint64_t.
  * Conversion stopped at first non-digit character.
  *
  * @param str string to convert
  * @param[out] out_val pointer to uint64_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
 MHD_str_to_uint64_ (const char *str,
                     uint64_t *out_val)
 {
   const char *const start = str;
   uint64_t res;

   if (! str || ! out_val || ! isasciidigit (str[0]))
     return 0;

   res = 0;
   do
   {
     const int digit = (unsigned char) (*str) - '0';
     if ( (res > (UINT64_MAX / 10)) ||
          ( (res == (UINT64_MAX / 10)) &&
            ((uint64_t) digit > (UINT64_MAX % 10)) ) )
       return 0;

     res *= 10;
     res += digit;
     str++;
   } while (isasciidigit (*str));

   *out_val = res;
   return str - start;
 }


 /**
  * Convert not more then @a maxlen decimal US-ASCII digits in string to
  * number in uint64_t.
  * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  *
  * @param str string to convert
  * @param maxlen maximum number of characters to process
  * @param[out] out_val pointer to uint64_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
 MHD_str_to_uint64_n_ (const char *str,
                       size_t maxlen,
                       uint64_t *out_val)
 {
   uint64_t res;
   size_t i;

   if (! str || ! maxlen || ! out_val || ! isasciidigit (str[0]))
     return 0;

   res = 0;
   i = 0;
   do
   {
     const int digit = (unsigned char) str[i] - '0';

     if ( (res > (UINT64_MAX / 10)) ||
          ( (res == (UINT64_MAX / 10)) &&
            ((uint64_t) digit > (UINT64_MAX % 10)) ) )
       return 0;

     res *= 10;
     res += digit;
     i++;
   } while ( (i < maxlen) &&
             isasciidigit (str[i]) );

   *out_val = res;
   return i;
 }


 /**
  * Convert hexadecimal US-ASCII digits in string to number in uint32_t.
  * Conversion stopped at first non-digit character.
  *
  * @param str string to convert
  * @param[out] out_val pointer to uint32_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint32_t or @a out_val is NULL
  */
 size_t
 MHD_strx_to_uint32_ (const char *str,
                      uint32_t *out_val)
 {
   const char *const start = str;
   uint32_t res;
   int digit;

   if (! str || ! out_val)
     return 0;

   res = 0;
   digit = toxdigitvalue (*str);
   while (digit >= 0)
   {
     if ( (res < (UINT32_MAX / 16)) ||
          ((res == (UINT32_MAX / 16)) && ( (uint32_t) digit <= (UINT32_MAX
                                                                % 16)) ) )
     {
       res *= 16;
       res += digit;
     }
     else
       return 0;
     str++;
     digit = toxdigitvalue (*str);
   }

   if (str - start > 0)
     *out_val = res;
   return str - start;
 }


 /**
  * Convert not more then @a maxlen hexadecimal US-ASCII digits in string
  * to number in uint32_t.
  * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  *
  * @param str string to convert
  * @param maxlen maximum number of characters to process
  * @param[out] out_val pointer to uint32_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint32_t or @a out_val is NULL
  */
 size_t
 MHD_strx_to_uint32_n_ (const char *str,
                        size_t maxlen,
                        uint32_t *out_val)
 {
   size_t i;
   uint32_t res;
   int digit;
   if (! str || ! out_val)
     return 0;

   res = 0;
   i = 0;
   while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
   {
     if ( (res > (UINT32_MAX / 16)) ||
          ((res == (UINT32_MAX / 16)) && ( (uint32_t) digit > (UINT32_MAX
                                                               % 16)) ) )
       return 0;

     res *= 16;
     res += digit;
     i++;
   }

   if (i)
     *out_val = res;
   return i;
 }


 /**
  * Convert hexadecimal US-ASCII digits in string to number in uint64_t.
  * Conversion stopped at first non-digit character.
  *
  * @param str string to convert
  * @param[out] out_val pointer to uint64_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
 MHD_strx_to_uint64_ (const char *str,
                      uint64_t *out_val)
 {
   const char *const start = str;
   uint64_t res;
   int digit;
   if (! str || ! out_val)
     return 0;

   res = 0;
   digit = toxdigitvalue (*str);
   while (digit >= 0)
   {
     if ( (res < (UINT64_MAX / 16)) ||
          ((res == (UINT64_MAX / 16)) && ( (uint64_t) digit <= (UINT64_MAX
                                                                % 16)) ) )
     {
       res *= 16;
       res += digit;
     }
     else
       return 0;
     str++;
     digit = toxdigitvalue (*str);
   }

   if (str - start > 0)
     *out_val = res;
   return str - start;
 }


 /**
  * Convert not more then @a maxlen hexadecimal US-ASCII digits in string
  * to number in uint64_t.
  * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  *
  * @param str string to convert
  * @param maxlen maximum number of characters to process
  * @param[out] out_val pointer to uint64_t to store result of conversion
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then possible to store in uint64_t or @a out_val is NULL
  */
 size_t
 MHD_strx_to_uint64_n_ (const char *str,
                        size_t maxlen,
                        uint64_t *out_val)
 {
   size_t i;
   uint64_t res;
   int digit;
   if (! str || ! out_val)
     return 0;

   res = 0;
   i = 0;
   while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
   {
     if ( (res > (UINT64_MAX / 16)) ||
          ((res == (UINT64_MAX / 16)) && ( (uint64_t) digit > (UINT64_MAX
                                                               % 16)) ) )
       return 0;

     res *= 16;
     res += digit;
     i++;
   }

   if (i)
     *out_val = res;
   return i;
 }


 #else  /* MHD_FAVOR_SMALL_CODE */

 /**
  * Generic function for converting not more then @a maxlen
  * hexadecimal or decimal US-ASCII digits in string to number.
  * Conversion stopped at first non-digit character or after @a maxlen
  * digits.
  * To be used only within macro.
  *
  * @param str the string to convert
  * @param maxlen the maximum number of characters to process
  * @param out_val the pointer to variable to store result of conversion
  * @param val_size the size of variable pointed by @a out_val, in bytes, 4 or 8
  * @param max_val the maximum decoded number
  * @param base the numeric base, 10 or 16
  * @return non-zero number of characters processed on succeed,
  *         zero if no digit is found, resulting value is larger
  *         then @max_val, @val_size is not 16/32 or @a out_val is NULL
  */
 size_t
 MHD_str_to_uvalue_n_ (const char *str,
                       size_t maxlen,
                       void *out_val,
                       size_t val_size,
                       uint64_t max_val,
                       int base)
 {
   size_t i;
   uint64_t res;
   int digit;
   const uint64_t max_v_div_b = max_val / base;
   const uint64_t max_v_mod_b = max_val % base;
   /* 'digit->value' must be function, not macro */
   int (*const dfunc)(char) = (base == 16) ?
                              toxdigitvalue : todigitvalue;

   if (! str || ! out_val ||
       ((base != 16) && (base != 10)) )
     return 0;

   res = 0;
   i = 0;
   while (maxlen > i && 0 <= (digit = dfunc (str[i])))
   {
     if ( ((max_v_div_b) < res) ||
          (( (max_v_div_b) == res) && ( (max_v_mod_b) < (uint64_t) digit) ) )
       return 0;

     res *= base;
     res += digit;
     i++;
   }

   if (i)
   {
     if (8 == val_size)
       *(uint64_t *) out_val = res;
     else if (4 == val_size)
       *(uint32_t *) out_val = (uint32_t) res;
     else
       return 0;
   }
   return i;
 }


 #endif /* MHD_FAVOR_SMALL_CODE */
	/*
	This file is part of libmicrohttpd
	Copyright (C) 2015, 2016 Karlson2k (Evgeny Grin)

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/**
	* @file microhttpd/mhd_str.c
	* @brief Functions implementations for string manipulating
	* @author Karlson2k (Evgeny Grin)
	*/

	#include "mhd_str.h"

	#ifdef HAVE_STDBOOL_H
	#include <stdbool.h>
	#endif

	#include "mhd_limits.h"

	#ifdef MHD_FAVOR_SMALL_CODE
	#ifdef _MHD_static_inline
	#undef _MHD_static_inline
	#endif /* _MHD_static_inline */
	/* Do not force inlining and do not use macro functions, use normal static
	functions instead.
	This may give more flexibility for size optimizations. */
	#define _MHD_static_inline static
	#ifndef INLINE_FUNC
	#define INLINE_FUNC 1
	#endif /* !INLINE_FUNC */
	#endif /* MHD_FAVOR_SMALL_CODE */

	/*
	* Block of functions/macros that use US-ASCII charset as required by HTTP
	* standards. Not affected by current locale settings.
	*/

	#ifdef INLINE_FUNC

	#if 0 /* Disable unused functions. */
	/**
	* Check whether character is lower case letter in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is lower case letter, zero otherwise
	*/
	_MHD_static_inline bool
	isasciilower (char c)
	{
	return (c >= 'a') && (c <= 'z');
	}


	#endif /* Disable unused functions. */


	/**
	* Check whether character is upper case letter in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is upper case letter, zero otherwise
	*/
	_MHD_static_inline bool
	isasciiupper (char c)
	{
	return (c >= 'A') && (c <= 'Z');
	}


	#if 0 /* Disable unused functions. */
	/**
	* Check whether character is letter in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is letter in US-ASCII, zero otherwise
	*/
	_MHD_static_inline bool
	isasciialpha (char c)
	{
	return isasciilower (c) \|\| isasciiupper (c);
	}


	#endif /* Disable unused functions. */


	/**
	* Check whether character is decimal digit in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is decimal digit, zero otherwise
	*/
	_MHD_static_inline bool
	isasciidigit (char c)
	{
	return (c >= '0') && (c <= '9');
	}


	#if 0 /* Disable unused functions. */
	/**
	* Check whether character is hexadecimal digit in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is decimal digit, zero otherwise
	*/
	_MHD_static_inline bool
	isasciixdigit (char c)
	{
	return isasciidigit (c) \|\|
	( (c >= 'A') && (c <= 'F') ) \|\|
	( (c >= 'a') && (c <= 'f') );
	}


	/**
	* Check whether character is decimal digit or letter in US-ASCII
	*
	* @param c character to check
	* @return non-zero if character is decimal digit or letter, zero otherwise
	*/
	_MHD_static_inline bool
	isasciialnum (char c)
	{
	return isasciialpha (c) \|\| isasciidigit (c);
	}


	#endif /* Disable unused functions. */


	/**
	* Convert US-ASCII character to lower case.
	* If character is upper case letter in US-ASCII than it's converted to lower
	* case analog. If character is NOT upper case letter than it's returned
	* unmodified.
	*
	* @param c character to convert
	* @return converted to lower case character
	*/
	_MHD_static_inline char
	toasciilower (char c)
	{
	return isasciiupper (c) ? (c - 'A' + 'a') : c;
	}


	#if 0 /* Disable unused functions. */
	/**
	* Convert US-ASCII character to upper case.
	* If character is lower case letter in US-ASCII than it's converted to upper
	* case analog. If character is NOT lower case letter than it's returned
	* unmodified.
	*
	* @param c character to convert
	* @return converted to upper case character
	*/
	_MHD_static_inline char
	toasciiupper (char c)
	{
	return isasciilower (c) ? (c - 'a' + 'A') : c;
	}


	#endif /* Disable unused functions. */


	#if defined(MHD_FAVOR_SMALL_CODE) /* Used only in MHD_str_to_uvalue_n_() */
	/**
	* Convert US-ASCII decimal digit to its value.
	*
	* @param c character to convert
	* @return value of decimal digit or -1 if @ c is not decimal digit
	*/
	_MHD_static_inline int
	todigitvalue (char c)
	{
	if (isasciidigit (c))
	return (unsigned char) (c - '0');

	return -1;
	}


	#endif /* MHD_FAVOR_SMALL_CODE */


	/**
	* Convert US-ASCII hexadecimal digit to its value.
	*
	* @param c character to convert
	* @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
	*/
	_MHD_static_inline int
	toxdigitvalue (char c)
	{
	if (isasciidigit (c))
	return (unsigned char) (c - '0');
	if ( (c >= 'A') && (c <= 'F') )
	return (unsigned char) (c - 'A' + 10);
	if ( (c >= 'a') && (c <= 'f') )
	return (unsigned char) (c - 'a' + 10);

	return -1;
	}


	#else /* !INLINE_FUNC */


	/**
	* Checks whether character is lower case letter in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is lower case letter,
	* boolean false otherwise
	*/
	#define isasciilower(c) (((char) (c)) >= 'a' && ((char) (c)) <= 'z')


	/**
	* Checks whether character is upper case letter in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is upper case letter,
	* boolean false otherwise
	*/
	#define isasciiupper(c) (((char) (c)) >= 'A' && ((char) (c)) <= 'Z')


	/**
	* Checks whether character is letter in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is letter, boolean false
	* otherwise
	*/
	#define isasciialpha(c) (isasciilower (c) \|\| isasciiupper (c))


	/**
	* Check whether character is decimal digit in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is decimal digit, boolean false
	* otherwise
	*/
	#define isasciidigit(c) (((char) (c)) >= '0' && ((char) (c)) <= '9')


	/**
	* Check whether character is hexadecimal digit in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is hexadecimal digit,
	* boolean false otherwise
	*/
	#define isasciixdigit(c) (isasciidigit ((c)) \|\| \
	(((char) (c)) >= 'A' && ((char) (c)) <= 'F') \|\| \
	(((char) (c)) >= 'a' && ((char) (c)) <= 'f') )


	/**
	* Check whether character is decimal digit or letter in US-ASCII
	*
	* @param c character to check
	* @return boolean true if character is decimal digit or letter,
	* boolean false otherwise
	*/
	#define isasciialnum(c) (isasciialpha (c) \|\| isasciidigit (c))


	/**
	* Convert US-ASCII character to lower case.
	* If character is upper case letter in US-ASCII than it's converted to lower
	* case analog. If character is NOT upper case letter than it's returned
	* unmodified.
	*
	* @param c character to convert
	* @return converted to lower case character
	*/
	#define toasciilower(c) ((isasciiupper (c)) ? (((char) (c)) - 'A' + 'a') : \
	((char) (c)))


	/**
	* Convert US-ASCII character to upper case.
	* If character is lower case letter in US-ASCII than it's converted to upper
	* case analog. If character is NOT lower case letter than it's returned
	* unmodified.
	*
	* @param c character to convert
	* @return converted to upper case character
	*/
	#define toasciiupper(c) ((isasciilower (c)) ? (((char) (c)) - 'a' + 'A') : \
	((char) (c)))


	/**
	* Convert US-ASCII decimal digit to its value.
	*
	* @param c character to convert
	* @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
	*/
	#define todigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
	(int) (-1))


	/**
	* Convert US-ASCII hexadecimal digit to its value.
	* @param c character to convert
	* @return value of hexadecimal digit or -1 if @ c is not hexadecimal digit
	*/
	#define toxdigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
	( (((char) (c)) >= 'A' && ((char) (c)) <= 'F') ? \
	(int) (((unsigned char) (c)) - 'A' + 10) : \
	( (((char) (c)) >= 'a' && ((char) (c)) <= 'f') ? \
	(int) (((unsigned char) (c)) - 'a' + 10) : \
	(int) (-1) )))
	#endif /* !INLINE_FUNC */


	#ifndef MHD_FAVOR_SMALL_CODE
	/**
	* Check two string for equality, ignoring case of US-ASCII letters.
	*
	* @param str1 first string to compare
	* @param str2 second string to compare
	* @return non-zero if two strings are equal, zero otherwise.
	*/
	int
	MHD_str_equal_caseless_ (const char *str1,
	const char *str2)
	{
	while (0 != (*str1))
	{
	const char c1 = *str1;
	const char c2 = *str2;
	if ( (c1 != c2) &&
	(toasciilower (c1) != toasciilower (c2)) )
	return 0;
	str1++;
	str2++;
	}
	return 0 == (*str2);
	}


	#endif /* ! MHD_FAVOR_SMALL_CODE */


	/**
	* Check two string for equality, ignoring case of US-ASCII letters and
	* checking not more than @a maxlen characters.
	* Compares up to first terminating null character, but not more than
	* first @a maxlen characters.
	*
	* @param str1 first string to compare
	* @param str2 second string to compare
	* @param maxlen maximum number of characters to compare
	* @return non-zero if two strings are equal, zero otherwise.
	*/
	int
	MHD_str_equal_caseless_n_ (const char *const str1,
	const char *const str2,
	size_t maxlen)
	{
	size_t i;

	for (i = 0; i < maxlen; ++i)
	{
	const char c1 = str1[i];
	const char c2 = str2[i];
	if (0 == c2)
	return 0 == c1;
	if ( (c1 != c2) &&
	(toasciilower (c1) != toasciilower (c2)) )
	return 0;
	}
	return ! 0;
	}


	/**
	* Check whether @a str has case-insensitive @a token.
	* Token could be surrounded by spaces and tabs and delimited by comma.
	* Match succeed if substring between start, end (of string) or comma
	* contains only case-insensitive token and optional spaces and tabs.
	* @warning token must not contain null-charters except optional
	* terminating null-character.
	* @param str the string to check
	* @param token the token to find
	* @param token_len length of token, not including optional terminating
	* null-character.
	* @return non-zero if two strings are equal, zero otherwise.
	*/
	bool
	MHD_str_has_token_caseless_ (const char *str,
	const char *const token,
	size_t token_len)
	{
	if (0 == token_len)
	return false;

	while (0 != *str)
	{
	size_t i;
	/* Skip all whitespaces and empty tokens. */
	while (' ' == str \|\| '\t' == str \|\| ',' == *str)
	str++;

	/* Check for token match. */
	i = 0;
	while (1)
	{
	const char sc = *(str++);
	const char tc = token[i++];

	if (0 == sc)
	return false;
	if ( (sc != tc) &&
	(toasciilower (sc) != toasciilower (tc)) )
	break;
	if (i >= token_len)
	{
	/* Check whether substring match token fully or
	* has additional unmatched chars at tail. */
	while (' ' == str \|\| '\t' == str)
	str++;
	/* End of (sub)string? */
	if ((0 == str) \|\| (',' == str) )
	return true;
	/* Unmatched chars at end of substring. */
	break;
	}
	}
	/* Find next substring. */
	while (0 != str && ',' != str)
	str++;
	}
	return false;
	}


	#ifndef MHD_FAVOR_SMALL_CODE
	/* Use individual function for each case */

	/**
	* Convert decimal US-ASCII digits in string to number in uint64_t.
	* Conversion stopped at first non-digit character.
	*
	* @param str string to convert
	* @param[out] out_val pointer to uint64_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint64_t or @a out_val is NULL
	*/
	size_t
	MHD_str_to_uint64_ (const char *str,
	uint64_t *out_val)
	{
	const char *const start = str;
	uint64_t res;

	if (! str \|\| ! out_val \|\| ! isasciidigit (str[0]))
	return 0;

	res = 0;
	do
	{
	const int digit = (unsigned char) (*str) - '0';
	if ( (res > (UINT64_MAX / 10)) \|\|
	( (res == (UINT64_MAX / 10)) &&
	((uint64_t) digit > (UINT64_MAX % 10)) ) )
	return 0;

	res *= 10;
	res += digit;
	str++;
	} while (isasciidigit (*str));

	*out_val = res;
	return str - start;
	}


	/**
	* Convert not more then @a maxlen decimal US-ASCII digits in string to
	* number in uint64_t.
	* Conversion stopped at first non-digit character or after @a maxlen
	* digits.
	*
	* @param str string to convert
	* @param maxlen maximum number of characters to process
	* @param[out] out_val pointer to uint64_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint64_t or @a out_val is NULL
	*/
	size_t
	MHD_str_to_uint64_n_ (const char *str,
	size_t maxlen,
	uint64_t *out_val)
	{
	uint64_t res;
	size_t i;

	if (! str \|\| ! maxlen \|\| ! out_val \|\| ! isasciidigit (str[0]))
	return 0;

	res = 0;
	i = 0;
	do
	{
	const int digit = (unsigned char) str[i] - '0';

	if ( (res > (UINT64_MAX / 10)) \|\|
	( (res == (UINT64_MAX / 10)) &&
	((uint64_t) digit > (UINT64_MAX % 10)) ) )
	return 0;

	res *= 10;
	res += digit;
	i++;
	} while ( (i < maxlen) &&
	isasciidigit (str[i]) );

	*out_val = res;
	return i;
	}


	/**
	* Convert hexadecimal US-ASCII digits in string to number in uint32_t.
	* Conversion stopped at first non-digit character.
	*
	* @param str string to convert
	* @param[out] out_val pointer to uint32_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint32_t or @a out_val is NULL
	*/
	size_t
	MHD_strx_to_uint32_ (const char *str,
	uint32_t *out_val)
	{
	const char *const start = str;
	uint32_t res;
	int digit;

	if (! str \|\| ! out_val)
	return 0;

	res = 0;
	digit = toxdigitvalue (*str);
	while (digit >= 0)
	{
	if ( (res < (UINT32_MAX / 16)) \|\|
	((res == (UINT32_MAX / 16)) && ( (uint32_t) digit <= (UINT32_MAX
	% 16)) ) )
	{
	res *= 16;
	res += digit;
	}
	else
	return 0;
	str++;
	digit = toxdigitvalue (*str);
	}

	if (str - start > 0)
	*out_val = res;
	return str - start;
	}


	/**
	* Convert not more then @a maxlen hexadecimal US-ASCII digits in string
	* to number in uint32_t.
	* Conversion stopped at first non-digit character or after @a maxlen
	* digits.
	*
	* @param str string to convert
	* @param maxlen maximum number of characters to process
	* @param[out] out_val pointer to uint32_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint32_t or @a out_val is NULL
	*/
	size_t
	MHD_strx_to_uint32_n_ (const char *str,
	size_t maxlen,
	uint32_t *out_val)
	{
	size_t i;
	uint32_t res;
	int digit;
	if (! str \|\| ! out_val)
	return 0;

	res = 0;
	i = 0;
	while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
	{
	if ( (res > (UINT32_MAX / 16)) \|\|
	((res == (UINT32_MAX / 16)) && ( (uint32_t) digit > (UINT32_MAX
	% 16)) ) )
	return 0;

	res *= 16;
	res += digit;
	i++;
	}

	if (i)
	*out_val = res;
	return i;
	}


	/**
	* Convert hexadecimal US-ASCII digits in string to number in uint64_t.
	* Conversion stopped at first non-digit character.
	*
	* @param str string to convert
	* @param[out] out_val pointer to uint64_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint64_t or @a out_val is NULL
	*/
	size_t
	MHD_strx_to_uint64_ (const char *str,
	uint64_t *out_val)
	{
	const char *const start = str;
	uint64_t res;
	int digit;
	if (! str \|\| ! out_val)
	return 0;

	res = 0;
	digit = toxdigitvalue (*str);
	while (digit >= 0)
	{
	if ( (res < (UINT64_MAX / 16)) \|\|
	((res == (UINT64_MAX / 16)) && ( (uint64_t) digit <= (UINT64_MAX
	% 16)) ) )
	{
	res *= 16;
	res += digit;
	}
	else
	return 0;
	str++;
	digit = toxdigitvalue (*str);
	}

	if (str - start > 0)
	*out_val = res;
	return str - start;
	}


	/**
	* Convert not more then @a maxlen hexadecimal US-ASCII digits in string
	* to number in uint64_t.
	* Conversion stopped at first non-digit character or after @a maxlen
	* digits.
	*
	* @param str string to convert
	* @param maxlen maximum number of characters to process
	* @param[out] out_val pointer to uint64_t to store result of conversion
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then possible to store in uint64_t or @a out_val is NULL
	*/
	size_t
	MHD_strx_to_uint64_n_ (const char *str,
	size_t maxlen,
	uint64_t *out_val)
	{
	size_t i;
	uint64_t res;
	int digit;
	if (! str \|\| ! out_val)
	return 0;

	res = 0;
	i = 0;
	while (i < maxlen && (digit = toxdigitvalue (str[i])) >= 0)
	{
	if ( (res > (UINT64_MAX / 16)) \|\|
	((res == (UINT64_MAX / 16)) && ( (uint64_t) digit > (UINT64_MAX
	% 16)) ) )
	return 0;

	res *= 16;
	res += digit;
	i++;
	}

	if (i)
	*out_val = res;
	return i;
	}


	#else /* MHD_FAVOR_SMALL_CODE */

	/**
	* Generic function for converting not more then @a maxlen
	* hexadecimal or decimal US-ASCII digits in string to number.
	* Conversion stopped at first non-digit character or after @a maxlen
	* digits.
	* To be used only within macro.
	*
	* @param str the string to convert
	* @param maxlen the maximum number of characters to process
	* @param out_val the pointer to variable to store result of conversion
	* @param val_size the size of variable pointed by @a out_val, in bytes, 4 or 8
	* @param max_val the maximum decoded number
	* @param base the numeric base, 10 or 16
	* @return non-zero number of characters processed on succeed,
	* zero if no digit is found, resulting value is larger
	* then @max_val, @val_size is not 16/32 or @a out_val is NULL
	*/
	size_t
	MHD_str_to_uvalue_n_ (const char *str,
	size_t maxlen,
	void *out_val,
	size_t val_size,
	uint64_t max_val,
	int base)
	{
	size_t i;
	uint64_t res;
	int digit;
	const uint64_t max_v_div_b = max_val / base;
	const uint64_t max_v_mod_b = max_val % base;
	/* 'digit->value' must be function, not macro */
	int (*const dfunc)(char) = (base == 16) ?
	toxdigitvalue : todigitvalue;

	if (! str \|\| ! out_val \|\|
	((base != 16) && (base != 10)) )
	return 0;

	res = 0;
	i = 0;
	while (maxlen > i && 0 <= (digit = dfunc (str[i])))
	{
	if ( ((max_v_div_b) < res) \|\|
	(( (max_v_div_b) == res) && ( (max_v_mod_b) < (uint64_t) digit) ) )
	return 0;

	res *= base;
	res += digit;
	i++;
	}

	if (i)
	{
	if (8 == val_size)
	(uint64_t ) out_val = res;
	else if (4 == val_size)
	(uint32_t ) out_val = (uint32_t) res;
	else
	return 0;
	}
	return i;
	}


	#endif /* MHD_FAVOR_SMALL_CODE */