X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fstrings.c;h=6a6cad6fe8b05304ac48d61c71c3ebb5467d331f;hb=82e765caeb53a1de54676738169dab98ca76c47e;hp=85c6a1cc69057ed527d934c07a9f426ba8636f60;hpb=f7e70ab9405d9baaabe1f3c216e0fce96bcf4ed6;p=oweals%2Fgnunet.git diff --git a/src/util/strings.c b/src/util/strings.c index 85c6a1cc6..6a6cad6fe 100644 --- a/src/util/strings.c +++ b/src/util/strings.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2005-2013 Christian Grothoff (and other contributing authors) + Copyright (C) 2005-2013 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -14,8 +14,8 @@ You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /** @@ -29,7 +29,8 @@ #if HAVE_ICONV #include #endif -#include "gnunet_util_lib.h" +#include "gnunet_crypto_lib.h" +#include "gnunet_strings_lib.h" #include #include #include @@ -47,7 +48,7 @@ * * Unlike using "snprintf" with "%s", this function * will add 0-terminators after each string. The - * "GNUNET_string_buffer_tokenize" function can be + * #GNUNET_string_buffer_tokenize() function can be * used to parse the buffer back into individual * strings. * @@ -78,7 +79,7 @@ GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...) if (buffer != NULL) { GNUNET_assert (needed + slen <= size); - memcpy (&buffer[needed], s, slen); + GNUNET_memcpy (&buffer[needed], s, slen); } needed += slen; count--; @@ -197,7 +198,7 @@ struct ConversionTable * @param input input string to parse * @param table table with the conversion of unit names to numbers * @param output where to store the result - * @return GNUNET_OK on success, GNUNET_SYSERR on error + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ static int convert_with_table (const char *input, @@ -255,7 +256,7 @@ convert_with_table (const char *input, * * @param fancy_size human readable string (i.e. 1 MB) * @param size set to the size in bytes - * @return GNUNET_OK on success, GNUNET_SYSERR on error + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ int GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size, @@ -305,12 +306,19 @@ GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time, { "\"", 1000 * 1000LL }, { "m", 60 * 1000 * 1000LL}, { "min", 60 * 1000 * 1000LL}, + { "minute", 60 * 1000 * 1000LL}, { "minutes", 60 * 1000 * 1000LL}, { "'", 60 * 1000 * 1000LL}, { "h", 60 * 60 * 1000 * 1000LL}, + { "hour", 60 * 60 * 1000 * 1000LL}, + { "hours", 60 * 60 * 1000 * 1000LL}, { "d", 24 * 60 * 60 * 1000LL * 1000LL}, { "day", 24 * 60 * 60 * 1000LL * 1000LL}, { "days", 24 * 60 * 60 * 1000LL * 1000LL}, + { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL}, + { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL}, + { "year", 31536000000000LL /* year */ }, + { "years", 31536000000000LL /* year */ }, { "a", 31536000000000LL /* year */ }, { NULL, 0} }; @@ -346,7 +354,8 @@ GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time, struct tm tv; time_t t; - if (0 == strcasecmp ("end of time", fancy_time)) + if (0 == strcasecmp ("end of time", + fancy_time)) { *atime = GNUNET_TIME_UNIT_FOREVER_ABS; return GNUNET_OK; @@ -365,19 +374,6 @@ GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time, return GNUNET_SYSERR; t = mktime (&tv); atime->abs_value_us = (uint64_t) ((uint64_t) t * 1000LL * 1000LL); -#if LINUX - atime->abs_value_us -= 1000LL * 1000LL * timezone; -#elif defined WINDOWS - { - DWORD tzv; - TIME_ZONE_INFORMATION tzi; - tzv = GetTimeZoneInformation (&tzi); - if (TIME_ZONE_ID_INVALID != tzv) - { - atime->abs_value_us -= 1000LL * 1000LL * tzi.Bias * 60LL; - } - } -#endif return GNUNET_OK; } @@ -420,7 +416,7 @@ GNUNET_STRINGS_conv (const char *input, if (0 == strcmp (output_charset, "UTF-8")) { ret = GNUNET_malloc (u8_string_length + 1); - memcpy (ret, u8_string, u8_string_length); + GNUNET_memcpy (ret, u8_string, u8_string_length); ret[u8_string_length] = '\0'; free (u8_string); return ret; @@ -436,15 +432,16 @@ GNUNET_STRINGS_conv (const char *input, goto fail; } ret = GNUNET_malloc (encoded_string_length + 1); - memcpy (ret, encoded_string, encoded_string_length); + GNUNET_memcpy (ret, encoded_string, encoded_string_length); ret[encoded_string_length] = '\0'; free (encoded_string); return ret; fail: - LOG (GNUNET_ERROR_TYPE_WARNING, _("Character sets requested were `%s'->`%s'\n"), + LOG (GNUNET_ERROR_TYPE_WARNING, + _("Character sets requested were `%s'->`%s'\n"), "UTF-8", output_charset); ret = GNUNET_malloc (len + 1); - memcpy (ret, input, len); + GNUNET_memcpy (ret, input, len); ret[len] = '\0'; return ret; } @@ -507,7 +504,7 @@ GNUNET_STRINGS_utf8_tolower (const char *input, tmp_in = u8_tolower ((uint8_t*)input, strlen ((char *) input), NULL, UNINORM_NFD, NULL, &len); - memcpy(output, tmp_in, len); + GNUNET_memcpy(output, tmp_in, len); output[len] = '\0'; free(tmp_in); } @@ -529,7 +526,7 @@ GNUNET_STRINGS_utf8_toupper(const char *input, tmp_in = u8_toupper ((uint8_t*)input, strlen ((char *) input), NULL, UNINORM_NFD, NULL, &len); - memcpy (output, tmp_in, len); + GNUNET_memcpy (output, tmp_in, len); output[len] = '\0'; free (tmp_in); } @@ -548,7 +545,6 @@ GNUNET_STRINGS_filename_expand (const char *fil) char *buffer; #ifndef MINGW size_t len; - size_t n; char *fm; const char *fil_ptr; #else @@ -605,7 +601,8 @@ GNUNET_STRINGS_filename_expand (const char *fil) } if (fm == NULL) { - LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "getcwd"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, + "getcwd"); buffer = getenv ("PWD"); /* alternative */ if (buffer != NULL) fm = GNUNET_strdup (buffer); @@ -613,9 +610,9 @@ GNUNET_STRINGS_filename_expand (const char *fil) if (fm == NULL) fm = GNUNET_strdup ("./"); /* give up */ } - n = strlen (fm) + 1 + strlen (fil_ptr) + 1; - buffer = GNUNET_malloc (n); - GNUNET_snprintf (buffer, n, "%s%s%s", fm, + GNUNET_asprintf (&buffer, + "%s%s%s", + fm, (fm[strlen (fm) - 1] == DIR_SEPARATOR) ? "" : DIR_SEPARATOR_STR, fil_ptr); GNUNET_free (fm); @@ -626,23 +623,29 @@ GNUNET_STRINGS_filename_expand (const char *fil) if ((lRet = plibc_conv_to_win_path (fil, fn)) != ERROR_SUCCESS) { SetErrnoFromWinError (lRet); - LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "plibc_conv_to_win_path"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, + "plibc_conv_to_win_path"); return NULL; } /* is the path relative? */ - if ((strncmp (fn + 1, ":\\", 2) != 0) && (strncmp (fn, "\\\\", 2) != 0)) + if ( (0 != strncmp (fn + 1, ":\\", 2)) && + (0 != strncmp (fn, "\\\\", 2)) ) { char szCurDir[MAX_PATH + 1]; - lRet = GetCurrentDirectory (MAX_PATH + 1, szCurDir); + lRet = GetCurrentDirectory (MAX_PATH + 1, + szCurDir); if (lRet + strlen (fn) + 1 > (MAX_PATH + 1)) { SetErrnoFromWinError (ERROR_BUFFER_OVERFLOW); - LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetCurrentDirectory"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, + "GetCurrentDirectory"); return NULL; } - buffer = GNUNET_malloc (MAX_PATH + 1); - GNUNET_snprintf (buffer, MAX_PATH + 1, "%s\\%s", szCurDir, fn); + GNUNET_asprintf (&buffer, + "%s\\%s", + szCurDir, + fn); GNUNET_free (fn); fn = buffer; } @@ -736,8 +739,35 @@ GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t) if (t.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) return _("end of time"); tt = t.abs_value_us / 1000LL / 1000LL; - tp = gmtime (&tt); + tp = localtime (&tt); + /* This is hacky, but i don't know a way to detect libc character encoding. + * Just expect utf8 from glibc these days. + * As for msvcrt, use the wide variant, which always returns utf16 + * (otherwise we'd have to detect current codepage or use W32API character + * set conversion routines to convert to UTF8). + */ +#ifndef WINDOWS strftime (buf, sizeof (buf), "%a %b %d %H:%M:%S %Y", tp); +#else + { + static wchar_t wbuf[255]; + uint8_t *conved; + size_t ssize; + + wcsftime (wbuf, sizeof (wbuf) / sizeof (wchar_t), + L"%a %b %d %H:%M:%S %Y", tp); + + ssize = sizeof (buf); + conved = u16_to_u8 (wbuf, sizeof (wbuf) / sizeof (wchar_t), + (uint8_t *) buf, &ssize); + if (conved != (uint8_t *) buf) + { + strncpy (buf, (char *) conved, sizeof (buf)); + buf[255 - 1] = '\0'; + free (conved); + } + } +#endif return buf; } @@ -766,7 +796,8 @@ GNUNET_STRINGS_get_short_name (const char *filename) /** - * Get the numeric value corresponding to a character. + * Get the decoded value corresponding to a character according to Crockford + * Base32 encoding. * * @param a a character * @return corresponding numeric value @@ -774,48 +805,80 @@ GNUNET_STRINGS_get_short_name (const char *filename) static unsigned int getValue__ (unsigned char a) { + unsigned int dec; + + switch (a) + { + case 'O': + case 'o': + a = '0'; + break; + case 'i': + case 'I': + case 'l': + case 'L': + a = '1'; + break; + /* also consider U to be V */ + case 'u': + case 'U': + a = 'V'; + break; + default: + break; + } if ((a >= '0') && (a <= '9')) return a - '0'; - if ((a >= 'A') && (a <= 'V')) - return (a - 'A' + 10); - if ((a >= 'a') && (a <= 'v')) - return (a - 'a' + 10); + if ((a >= 'a') && (a <= 'z')) + a = toupper (a); + /* return (a - 'a' + 10); */ + dec = 0; + if ((a >= 'A') && (a <= 'Z')) + { + if ('I' < a) + dec++; + if ('L' < a) + dec++; + if ('O' < a) + dec++; + if ('U' < a) + dec++; + return (a - 'A' + 10 - dec); + } return -1; } /** - * Convert binary data to ASCII encoding. The ASCII encoding is rather - * GNUnet specific. It was chosen such that it only uses characters - * in [0-9A-V], can be produced without complex arithmetics and uses a - * small number of characters. - * Does not append 0-terminator, but returns a pointer to the place where - * it should be placed, if needed. + * Convert binary data to ASCII encoding using Crockford Base32 encoding. + * Returns a pointer to the byte after the last byte in the string, that + * is where the 0-terminator was placed if there was room. * * @param data data to encode * @param size size of data (in bytes) * @param out buffer to fill * @param out_size size of the buffer. Must be large enough to hold - * ((size*8) + (((size*8) % 5) > 0 ? 5 - ((size*8) % 5) : 0)) / 5 bytes - * @return pointer to the next byte in 'out' or NULL on error. + * (size * 8 + 4) / 5 bytes + * @return pointer to the next byte in @a out or NULL on error. */ char * -GNUNET_STRINGS_data_to_string (const void *data, size_t size, char *out, size_t out_size) +GNUNET_STRINGS_data_to_string (const void *data, + size_t size, + char *out, + size_t out_size) { /** * 32 characters for encoding */ - static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV"; + static char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; unsigned int wpos; unsigned int rpos; unsigned int bits; unsigned int vbit; const unsigned char *udata; - GNUNET_assert (data != NULL); - GNUNET_assert (out != NULL); udata = data; - if (out_size < (((size*8) + ((size*8) % 5)) % 5)) + if (out_size < (size * 8 + 4) / 5) { GNUNET_break (0); return NULL; @@ -845,7 +908,7 @@ GNUNET_STRINGS_data_to_string (const void *data, size_t size, char *out, size_t out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; vbit -= 5; } - GNUNET_assert (vbit == 0); + GNUNET_assert (0 == vbit); if (wpos < out_size) out[wpos] = '\0'; return &out[wpos]; @@ -853,8 +916,41 @@ GNUNET_STRINGS_data_to_string (const void *data, size_t size, char *out, size_t /** - * Convert ASCII encoding back to data - * out_size must match exactly the size of the data before it was encoded. + * Return the base32crockford encoding of the given buffer. + * + * The returned string will be freshly allocated, and must be free'd + * with GNUNET_free(). + * + * @param buffer with data + * @param size size of the buffer + * @return freshly allocated, null-terminated string + */ +char * +GNUNET_STRINGS_data_to_string_alloc (const void *buf, + size_t size) +{ + char *str_buf; + size_t len = size * 8; + char *end; + + if (len % 5 > 0) + len += 5 - len % 5; + len /= 5; + str_buf = GNUNET_malloc (len + 1); + end = GNUNET_STRINGS_data_to_string (buf, size, str_buf, len); + if (NULL == end) + { + GNUNET_free (str_buf); + return NULL; + } + *end = '\0'; + return str_buf; +} + + +/** + * Convert Crockford Base32hex encoding back to data. + * @a out_size must match exactly the size of the data before it was encoded. * * @param enc the encoding * @param enclen number of characters in @a enc (without 0-terminator, which can be missing) @@ -888,7 +984,7 @@ GNUNET_STRINGS_string_to_data (const char *enc, size_t enclen, { vbit = encoded_len % 5; /* padding! */ shift = 5 - vbit; - bits = (ret = getValue__ (enc[--rpos])) >> (5 - (encoded_len % 5)); + bits = (ret = getValue__ (enc[--rpos])) >> shift; } else { @@ -987,7 +1083,7 @@ GNUNET_STRINGS_parse_uri (const char *path, char **scheme_part, if (scheme_part) { *scheme_part = GNUNET_malloc (post_scheme_part - path + 1); - memcpy (*scheme_part, path, post_scheme_part - path); + GNUNET_memcpy (*scheme_part, path, post_scheme_part - path); (*scheme_part)[post_scheme_part - path] = '\0'; } if (path_part) @@ -1136,7 +1232,7 @@ GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr, if (addrlen < 6) return GNUNET_SYSERR; - memcpy (zbuf, zt_addr, addrlen); + GNUNET_memcpy (zbuf, zt_addr, addrlen); if ('[' != zbuf[0]) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, @@ -1252,7 +1348,7 @@ GNUNET_STRINGS_to_address_ip (const char *addr, /** * Makes a copy of argv that consists of a single memory chunk that can be - * freed with a single call to GNUNET_free (); + * freed with a single call to GNUNET_free(); */ static char *const * _make_continuous_arg_copy (int argc, @@ -1283,7 +1379,7 @@ _make_continuous_arg_copy (int argc, * other than W32. * Returned argv has u8argv[u8argc] == NULL. * Returned argv is a single memory block, and can be freed with a single - * GNUNET_free () call. + * GNUNET_free() call. * * @param argc argc (as given by main()) * @param argv argv (as given by main()) @@ -1743,4 +1839,144 @@ GNUNET_STRINGS_parse_ipv6_policy (const char *routeListX) } + +/** ******************** Base64 encoding ***********/ + +#define FILLCHAR '=' +static char *cvt = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789+/"; + + +/** + * Encode into Base64. + * + * @param data the data to encode + * @param len the length of the input + * @param output where to write the output (*output should be NULL, + * is allocated) + * @return the size of the output + */ +size_t +GNUNET_STRINGS_base64_encode (const char *data, + size_t len, + char **output) +{ + size_t i; + char c; + size_t ret; + char *opt; + + ret = 0; + opt = GNUNET_malloc (2 + (len * 4 / 3) + 8); + *output = opt; + for (i = 0; i < len; ++i) + { + c = (data[i] >> 2) & 0x3f; + opt[ret++] = cvt[(int) c]; + c = (data[i] << 4) & 0x3f; + if (++i < len) + c |= (data[i] >> 4) & 0x0f; + opt[ret++] = cvt[(int) c]; + if (i < len) + { + c = (data[i] << 2) & 0x3f; + if (++i < len) + c |= (data[i] >> 6) & 0x03; + opt[ret++] = cvt[(int) c]; + } + else + { + ++i; + opt[ret++] = FILLCHAR; + } + if (i < len) + { + c = data[i] & 0x3f; + opt[ret++] = cvt[(int) c]; + } + else + { + opt[ret++] = FILLCHAR; + } + } + opt[ret++] = FILLCHAR; + return ret; +} + +#define cvtfind(a)( (((a) >= 'A')&&((a) <= 'Z'))? (a)-'A'\ + :(((a)>='a')&&((a)<='z')) ? (a)-'a'+26\ + :(((a)>='0')&&((a)<='9')) ? (a)-'0'+52\ + :((a) == '+') ? 62\ + :((a) == '/') ? 63 : -1) + + +/** + * Decode from Base64. + * + * @param data the data to encode + * @param len the length of the input + * @param output where to write the output (*output should be NULL, + * is allocated) + * @return the size of the output + */ +size_t +GNUNET_STRINGS_base64_decode (const char *data, + size_t len, char **output) +{ + size_t i; + char c; + char c1; + size_t ret = 0; + +#define CHECK_CRLF while (data[i] == '\r' || data[i] == '\n') {\ + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, "ignoring CR/LF\n"); \ + i++; \ + if (i >= len) goto END; \ + } + + *output = GNUNET_malloc ((len * 3 / 4) + 8); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "base64_decode decoding len=%d\n", + (int) len); + for (i = 0; i < len; ++i) + { + CHECK_CRLF; + if (FILLCHAR == data[i]) + break; + c = (char) cvtfind (data[i]); + ++i; + CHECK_CRLF; + c1 = (char) cvtfind (data[i]); + c = (c << 2) | ((c1 >> 4) & 0x3); + (*output)[ret++] = c; + if (++i < len) + { + CHECK_CRLF; + c = data[i]; + if (FILLCHAR == c) + break; + c = (char) cvtfind (c); + c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf); + (*output)[ret++] = c1; + } + if (++i < len) + { + CHECK_CRLF; + c1 = data[i]; + if (FILLCHAR == c1) + break; + + c1 = (char) cvtfind (c1); + c = ((c << 6) & 0xc0) | c1; + (*output)[ret++] = c; + } + } +END: + return ret; +} + + + + + /* end of strings.c */