* @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,
*
* @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,
{ "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},
{ "a", 31536000000000LL /* year */ },
{ NULL, 0}
};
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;
}
/**
- * Convert the utf-8 input string to lowercase
- * Output needs to be allocated appropriately
+ * Convert the utf-8 input string to lowercase.
+ * Output needs to be allocated appropriately.
*
* @param input input string
* @param output output buffer
*/
void
-GNUNET_STRINGS_utf8_tolower(const char* input, char** output)
+GNUNET_STRINGS_utf8_tolower (const char *input,
+ char *output)
{
uint8_t *tmp_in;
size_t len;
tmp_in = u8_tolower ((uint8_t*)input, strlen ((char *) input),
NULL, UNINORM_NFD, NULL, &len);
- memcpy(*output, tmp_in, len);
- (*output)[len] = '\0';
+ memcpy(output, tmp_in, len);
+ output[len] = '\0';
free(tmp_in);
}
/**
- * Convert the utf-8 input string to uppercase
- * Output needs to be allocated appropriately
+ * Convert the utf-8 input string to uppercase.
+ * Output needs to be allocated appropriately.
*
* @param input input string
* @param output output buffer
*/
void
-GNUNET_STRINGS_utf8_toupper(const char* input, char** output)
+GNUNET_STRINGS_utf8_toupper(const char *input,
+ char *output)
{
uint8_t *tmp_in;
size_t len;
tmp_in = u8_toupper ((uint8_t*)input, strlen ((char *) input),
NULL, UNINORM_NFD, NULL, &len);
- memcpy(*output, tmp_in, len);
- (*output)[len] = '\0';
- free(tmp_in);
+ memcpy (output, tmp_in, len);
+ output[len] = '\0';
+ free (tmp_in);
}
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;
}
return a - '0';
if ((a >= 'A') && (a <= 'V'))
return (a - 'A' + 10);
+ if ((a >= 'a') && (a <= 'v'))
+ return (a - 'a' + 10);
return -1;
}
* out_size must match exactly the size of the data before it was encoded.
*
* @param enc the encoding
- * @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
+ * @param enclen number of characters in @a enc (without 0-terminator, which can be missing)
* @param out location where to store the decoded data
- * @param out_size size of the output buffer
- * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
+ * @param out_size size of the output buffer @a out
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
*/
int
GNUNET_STRINGS_string_to_data (const char *enc, size_t enclen,
/**
* 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,
* 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())
const char *pos;
int s;
int e;
+ char eol[2];
pos = port_policy;
if ('!' == *pos)
pos++;
}
if (2 == sscanf (pos,
- "%u-%u",
- &s, &e))
+ "%u-%u%1s",
+ &s, &e, eol))
{
+ if ( (0 == s) ||
+ (s > 0xFFFF) ||
+ (e < s) ||
+ (e > 0xFFFF) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Port not in range\n"));
+ return GNUNET_SYSERR;
+ }
pp->start_port = (uint16_t) s;
pp->end_port = (uint16_t) e;
return GNUNET_OK;
}
if (1 == sscanf (pos,
- "%u",
- &s))
+ "%u%1s",
+ &s,
+ eol))
{
+ if ( (0 == s) ||
+ (s > 0xFFFF) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Port not in range\n"));
+ return GNUNET_SYSERR;
+ }
+
pp->start_port = (uint16_t) s;
pp->end_port = (uint16_t) s;
return GNUNET_OK;
if ( (';' == routeList[colon]) ||
('\0' == routeList[colon]) )
break;
- end = colon;
for (end = colon; ';' != routeList[end]; end++)
if ('\0' == routeList[end])
break;
for (j = 0; j < 8; j++)
if (temps[j] > 0xFF)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid format for IP: `%s'\n"),
&routeList[pos]);
GNUNET_free (result);
for (j = 0; j < 4; j++)
if (temps[j] > 0xFF)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid format for IP: `%s'\n"),
&routeList[pos]);
GNUNET_free (result);
}
else
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
slash);
GNUNET_free (result);
for (j = 0; j < 4; j++)
if (temps[j] > 0xFF)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid format for IP: `%s'\n"),
&routeList[pos]);
GNUNET_free (result);
i++;
continue;
}
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid format for IP: `%s'\n"),
&routeList[pos]);
GNUNET_free (result);
}
if (pos < strlen (routeList))
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Invalid format for IP: `%s'\n"),
- &routeList[pos]);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Invalid format: `%s'\n"),
+ &routeListX[pos]);
GNUNET_free (result);
GNUNET_free (routeList);
return NULL; /* oops */
count++;
if (';' != routeList[len - 1])
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Invalid network notation (does not end with ';': `%s')\n"),
routeList);
GNUNET_free (routeList);
if ((1 != SSCANF (&routeList[slash + 1], "%u", &bits)) || (bits > 128))
{
if (0 == ret)
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Wrong format `%s' for netmask\n"),
&routeList[slash + 1]);
else
{
errno = save;
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "inet_pton");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_pton");
}
GNUNET_free (result);
GNUNET_free (routeList);
if (ret <= 0)
{
if (0 == ret)
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
_("Wrong format `%s' for network\n"),
&routeList[slash + 1]);
else
}
+
+/** ******************** 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 */
projects / oweals / gnunet.git / blobdiff