/*
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 */