37#ifdef MHD_FAVOR_SMALL_CODE
38#ifdef _MHD_static_inline
39#undef _MHD_static_inline
44#define _MHD_static_inline static
64_MHD_static_inline
bool
67 return (c >=
'a') && (c <=
'z');
80_MHD_static_inline
bool
83 return (c >=
'A') && (c <=
'Z');
94_MHD_static_inline
bool
110_MHD_static_inline
bool
113 return (c >=
'0') && (c <=
'9');
124_MHD_static_inline
bool
128 ( (c >=
'A') && (c <=
'F') ) ||
129 ( (c >=
'a') && (c <=
'f') );
139_MHD_static_inline
bool
159_MHD_static_inline
char
175_MHD_static_inline
char
185#if defined(MHD_FAVOR_SMALL_CODE)
192_MHD_static_inline
int
196 return (
unsigned char) (c -
'0');
211_MHD_static_inline
int
215 return (
unsigned char) (c -
'0');
216 if ( (c >=
'A') && (c <=
'F') )
217 return (
unsigned char) (c -
'A' + 10);
218 if ( (c >=
'a') && (c <=
'f') )
219 return (
unsigned char) (c -
'a' + 10);
232_MHD_static_inline
bool
235 return ( (c1 == c2) ||
237 ((c1 -
'A' +
'a') == c2) :
252#define isasciilower(c) (((char) (c)) >= 'a' && ((char) (c)) <= 'z')
262#define isasciiupper(c) (((char) (c)) >= 'A' && ((char) (c)) <= 'Z')
272#define isasciialpha(c) (isasciilower (c) || isasciiupper (c))
282#define isasciidigit(c) (((char) (c)) >= '0' && ((char) (c)) <= '9')
292#define isasciixdigit(c) (isasciidigit ((c)) || \
293 (((char) (c)) >= 'A' && ((char) (c)) <= 'F') || \
294 (((char) (c)) >= 'a' && ((char) (c)) <= 'f') )
304#define isasciialnum(c) (isasciialpha (c) || isasciidigit (c))
316#define toasciilower(c) ((isasciiupper (c)) ? (((char) (c)) - 'A' + 'a') : \
329#define toasciiupper(c) ((isasciilower (c)) ? (((char) (c)) - 'a' + 'A') : \
339#define todigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
348#define toxdigitvalue(c) (isasciidigit (c) ? (int) (((char) (c)) - '0') : \
349 ( (((char) (c)) >= 'A' && ((char) (c)) <= 'F') ? \
350 (int) (((unsigned char) (c)) - 'A' + 10) : \
351 ( (((char) (c)) >= 'a' && ((char) (c)) <= 'f') ? \
352 (int) (((unsigned char) (c)) - 'a' + 10) : \
362#define charsequalcaseless(c1, c2) \
363 ( ((c1) == (c2)) || \
364 (isasciiupper (c1) ? \
365 (((c1) - 'A' + 'a') == (c2)) : \
366 (((c1) == ((c2) - 'A' + 'a')) && isasciiupper (c2))) )
371#ifndef MHD_FAVOR_SMALL_CODE
385 const char c1 = *str1;
386 const char c2 = *str2;
415 const char *
const str2,
420 for (i = 0; i < maxlen; ++i)
422 const char c1 = str1[i];
423 const char c2 = str2[i];
446 const char *
const str2,
451 for (i = 0; i < len; ++i)
453 const char c1 = str1[i];
454 const char c2 = str2[i];
479 const char *
const token,
489 while (
' ' == *str ||
'\t' == *str ||
',' == *str)
496 const char sc = *(str++);
497 const char tc = token[i++];
507 while (
' ' == *str ||
'\t' == *str)
510 if ((0 == *str) || (
',' == *str) )
517 while (0 != *str &&
',' != *str)
555 const char *
const token,
556 const size_t token_len,
573 token_removed =
false;
575 while ((
size_t) (s1 - str) < str_len)
577 const char *cur_token;
581 while ( ((
size_t) (s1 - str) < str_len) &&
582 ((
' ' == *s1) || (
'\t' == *s1) || (
',' == *s1)) )
588 if ((
size_t) (s1 - str) >= str_len)
597 while ( ((
size_t) (s1 - str) < str_len) && (token_len > t_pos) &&
604 if ( (token_len == t_pos) && (0 != token_len) )
608 while ( ((
size_t) (s1 - str) < str_len) &&
609 ((
' ' == *s1) || (
'\t' == *s1)) )
614 if (((
size_t) (s1 - str) == str_len) || (
',' == *s1))
616 token_removed =
true;
627 copy_size = (size_t) (s1 - cur_token);
630 if (buf + *buf_size < s2 + copy_size)
632 *buf_size = (ssize_t) -1;
638 if (buf + *buf_size < s2 + copy_size + 2)
640 *buf_size = (ssize_t) -1;
649 memcpy (s2, cur_token, copy_size);
653 while ( ((
size_t) (s1 - str) < str_len) && (
',' != *s1))
659 while ( ((
size_t) (s1 - str) < str_len) &&
660 (
',' != *s1) && (
' ' != *s1) && (
'\t' != *s1) )
662 if (buf + *buf_size <= s2)
664 *buf_size = (ssize_t) -1;
672 while ( ((
size_t) (s1 - str) < str_len) &&
673 ((
' ' == *s1) || (
'\t' == *s1)) )
679 if (((
size_t) (s1 - str) < str_len) && (
',' != *s1))
681 if (buf + *buf_size <= s2)
683 *buf_size = (ssize_t) -1;
690 mhd_assert (((ssize_t) (s2 - buf)) <= *buf_size);
691 *buf_size = (ssize_t) (s2 - buf);
692 return token_removed;
722 const char *
const tokens,
723 const size_t tokens_len)
725 const char *
const t = tokens;
731 token_removed =
false;
734 while (pt < tokens_len && *str_len != 0)
740 while ( (pt < tokens_len) &&
741 ((
' ' == t[pt]) || (
'\t' == t[pt]) || (
',' == t[pt])) )
744 if (pt >= tokens_len)
754 }
while (pt < tokens_len &&
755 (
' ' != t[pt] &&
'\t' != t[pt] &&
',' != t[pt]));
757 tkn_len = pt - (size_t) (tkn - t);
760 while (pt < tokens_len && (
' ' == t[pt] ||
'\t' == t[pt]))
763 }
while(pt < tokens_len &&
',' != t[pt]);
768 if (*str_len == tkn_len)
773 token_removed =
true;
784 if (*str_len > tkn_len + 2)
796 if ( ( ((*str_len) == (pr + tkn_len)) || (
',' == str[pr + tkn_len]) ) &&
801 (
' ' == str[pr + tkn_len + 1]));
802 token_removed =
true;
827 }
while (pr < *str_len &&
',' != str[pr]);
834 if ((*str_len) < (pr + tkn_len))
839 copy_size = *str_len - pr;
851 memmove (str + pw, str + pr, copy_size);
857 mhd_assert ((
' ' != str[0]) && (
'\t' != str[0]));
859 mhd_assert ((0 == pr) || (
' ' == str[pr - 1]));
860 mhd_assert ((0 == pr) || (
',' == str[pr - 2]));
865 return token_removed;
869#ifndef MHD_FAVOR_SMALL_CODE
886 const char *
const start = str;
895 const int digit = (
unsigned char) (*str) -
'0';
932 if (! str || ! maxlen || ! out_val || !
isasciidigit (str[0]))
939 const int digit = (
unsigned char) str[i] -
'0';
949 }
while ( (i < maxlen) &&
971 const char *
const start = str;
975 if (! str || ! out_val)
1022 if (! str || ! out_val)
1059 const char *
const start = str;
1062 if (! str || ! out_val)
1082 if (str - start > 0)
1109 if (! str || ! out_val)
1152MHD_str_to_uvalue_n_ (
const char *str,
1162 const uint64_t max_v_div_b = max_val / base;
1163 const uint64_t max_v_mod_b = max_val % base;
1165 int (*
const dfunc)(char) = (base == 16) ?
1168 if (! str || ! out_val ||
1169 ((base != 16) && (base != 10)) )
1174 while (maxlen > i && 0 <= (digit = dfunc (str[i])))
1176 if ( ((max_v_div_b) < res) ||
1177 (( (max_v_div_b) == res) && ( (max_v_mod_b) < (uint64_t) digit) ) )
1188 *(uint64_t *) out_val = res;
1189 else if (4 == val_size)
1190 *(uint32_t *) out_val = (uint32_t) res;
1214 digit = (int) (val >> 28);
1216 }
while ((0 == digit) && (0 != digit_pos));
1218 while (o_pos < buf_size)
1220 buf[o_pos++] = (digit <= 9) ? (
'0' + (
char) digit) :
1221 (
'A' + (char) digit - 10);
1225 digit = (int) (val >> 28);
1232#ifndef MHD_FAVOR_SMALL_CODE
1240 uint16_t divisor = UINT16_C (10000);
1244 digit = (int) (val / divisor);
1248 while ((0 == digit) && (1 < divisor))
1251 digit = (int) (val / divisor);
1255 while (0 != buf_size)
1257 *chr = (char) digit +
'0';
1261 return (
size_t) (chr - buf);
1264 digit = (int) (val / divisor);
1281 uint64_t divisor = UINT64_C (10000000000000000000);
1285 digit = (int) (val / divisor);
1289 while ((0 == digit) && (1 < divisor))
1292 digit = (int) (val / divisor);
1296 while (0 != buf_size)
1298 *chr = (char) digit +
'0';
1302 return (
size_t) (chr - buf);
1305 digit = (int) (val / divisor);
1328 if (3 <= min_digits)
1333 buf[pos++] =
'0' + digit;
1338 if (buf_size <= pos)
1343 if (2 <= min_digits)
1348 buf[pos++] =
'0' + digit;
1352 if (buf_size <= pos)
1354 buf[pos++] =
'0' + val;
1362MHD_base64_to_bin_n (
const char *base64,
1367#ifndef MHD_FAVOR_SMALL_CODE
1370#define map_type int8_t
1372 static const map_type map[] = {
1375 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1376 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1377 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
1378 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
1379 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1380 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
1381 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1382 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
1383#ifndef MHD_FAVOR_SMALL_CODE
1385 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1386 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1387 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1388 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1389 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1390 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1391 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1392 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1395 const uint8_t *
const in = (
const uint8_t *) base64;
1396 uint8_t *
const out = (uint8_t *) bin;
1399 if (0 == base64_len)
1401 if (0 != base64_len % 4)
1403 if (base64_len / 4 * 3 - 2 > bin_size)
1407 for (i = 0; i < (base64_len - 4); i += 4)
1409#ifdef MHD_FAVOR_SMALL_CODE
1410 if (0 != (0x80 & (in[i] | in[i + 1] | in[i + 2] | in[i + 3])))
1415 const map_type v1 = map[in[i + 0]];
1416 const map_type v2 = map[in[i + 1]];
1417 const map_type v3 = map[in[i + 2]];
1418 const map_type v4 = map[in[i + 3]];
1419 if ((0 > v1) || (0 > v2) || (0 > v3) || (0 > v4))
1421 out[j + 0] = (uint8_t) ((((uint8_t) v1) << 2) | (((uint8_t) v2) >> 4));
1422 out[j + 1] = (uint8_t) ((((uint8_t) v2) << 4) | (((uint8_t) v3) >> 2));
1423 out[j + 2] = (uint8_t) ((((uint8_t) v3) << 6) | (((uint8_t) v4)));
1427#ifdef MHD_FAVOR_SMALL_CODE
1428 if (0 != (0x80 & (in[i] | in[i + 1] | in[i + 2] | in[i + 3])))
1433 const map_type v1 = map[in[i + 0]];
1434 const map_type v2 = map[in[i + 1]];
1435 const map_type v3 = map[in[i + 2]];
1436 const map_type v4 = map[in[i + 3]];
1437 if ((0 > v1) || (0 > v2))
1440 out[j++] = (uint8_t) ((((uint8_t) v1) << 2) | (((uint8_t) v2) >> 4));
1443 if ((-2 != v3) || (-2 != v4))
1445 if (0 != (uint8_t) (((uint8_t) v2) << 4))
1451 out[j++] = (uint8_t) ((((uint8_t) v2) << 4) | (((uint8_t) v3) >> 2));
1456 if (0 != (uint8_t) (((uint8_t) v3) << 6))
1462 out[j++] = (uint8_t) ((((uint8_t) v3) << 6) | (((uint8_t) v4)));
int MHD_str_equal_caseless_(const char *str1, const char *str2)
size_t MHD_strx_to_uint32_(const char *str, uint32_t *out_val)
size_t MHD_str_to_uint64_n_(const char *str, size_t maxlen, uint64_t *out_val)
size_t MHD_strx_to_uint64_n_(const char *str, size_t maxlen, uint64_t *out_val)
int MHD_str_equal_caseless_n_(const char *const str1, const char *const str2, size_t maxlen)
size_t MHD_str_to_uint64_(const char *str, uint64_t *out_val)
bool MHD_str_has_token_caseless_(const char *str, const char *const token, size_t token_len)
size_t MHD_strx_to_uint64_(const char *str, uint64_t *out_val)
size_t MHD_strx_to_uint32_n_(const char *str, size_t maxlen, uint32_t *out_val)
limits values definitions
size_t MHD_uint8_to_str_pad(uint8_t val, uint8_t min_digits, char *buf, size_t buf_size)
bool MHD_str_remove_tokens_caseless_(char *str, size_t *str_len, const char *const tokens, const size_t tokens_len)
size_t MHD_uint16_to_str(uint16_t val, char *buf, size_t buf_size)
size_t MHD_uint64_to_str(uint64_t val, char *buf, size_t buf_size)
#define charsequalcaseless(c1, c2)
bool MHD_str_remove_token_caseless_(const char *str, size_t str_len, const char *const token, const size_t token_len, char *buf, ssize_t *buf_size)
bool MHD_str_equal_caseless_bin_n_(const char *const str1, const char *const str2, size_t len)
size_t MHD_uint32_to_strx(uint32_t val, char *buf, size_t buf_size)
Header for string manipulating helpers.