/*
This file is part of GNUnet.
- (C) 2005, 2006 Christian Grothoff (and other contributing authors)
+ (C) 2005-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
#include "gnunet_strings_lib.h"
#include <unicase.h>
#include <unistr.h>
+#include <uniconv.h>
#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
in = GNUNET_strdup (input);
for (tok = strtok (in, " "); tok != NULL; tok = strtok (NULL, " "))
{
- i = 0;
- while ((table[i].name != NULL) && (0 != strcasecmp (table[i].name, tok)))
- i++;
- if (table[i].name != NULL)
- last *= table[i].value;
- else
+ do
{
- ret += last;
- last = 0;
- if (1 != SSCANF (tok, "%llu", &last))
+ i = 0;
+ while ((table[i].name != NULL) && (0 != strcasecmp (table[i].name, tok)))
+ i++;
+ if (table[i].name != NULL)
{
- GNUNET_free (in);
- return GNUNET_SYSERR; /* expected number */
+ last *= table[i].value;
+ break; /* next tok */
}
- }
+ else
+ {
+ char *endptr;
+ ret += last;
+ errno = 0;
+ last = strtoull (tok, &endptr, 10);
+ if ((0 != errno) || (endptr == tok))
+ {
+ GNUNET_free (in);
+ return GNUNET_SYSERR; /* expected number */
+ }
+ if ('\0' == endptr[0])
+ break; /* next tok */
+ else
+ tok = endptr; /* and re-check (handles times like "10s") */
+ }
+ } while (GNUNET_YES);
}
ret += last;
*output = ret;
{
static const struct ConversionTable table[] =
{
- { "ms", 1},
- { "s", 1000},
- { "\"", 1000},
- { "m", 60 * 1000},
- { "min", 60 * 1000},
- { "minutes", 60 * 1000},
- { "'", 60 * 1000},
- { "h", 60 * 60 * 1000},
- { "d", 24 * 60 * 60 * 1000},
- { "day", 24 * 60 * 60 * 1000},
- { "days", 24 * 60 * 60 * 1000},
- { "a", 31536000000LL /* year */ },
+ { "us", 1},
+ { "ms", 1000 },
+ { "s", 1000 * 1000LL },
+ { "\"", 1000 * 1000LL },
+ { "m", 60 * 1000 * 1000LL},
+ { "min", 60 * 1000 * 1000LL},
+ { "minutes", 60 * 1000 * 1000LL},
+ { "'", 60 * 1000 * 1000LL},
+ { "h", 60 * 60 * 1000 * 1000LL},
+ { "d", 24 * 60 * 60 * 1000LL * 1000LL},
+ { "day", 24 * 60 * 60 * 1000LL * 1000LL},
+ { "days", 24 * 60 * 60 * 1000LL * 1000LL},
+ { "a", 31536000000000LL /* year */ },
{ NULL, 0}
};
int ret;
ret = convert_with_table (fancy_time,
table,
&val);
- rtime->rel_value = (uint64_t) val;
+ rtime->rel_value_us = (uint64_t) val;
return ret;
}
(NULL == strptime (fancy_time, "%Y", &tv)) )
return GNUNET_SYSERR;
t = mktime (&tv);
- atime->abs_value = (uint64_t) ((uint64_t) t * 1000LL);
+ atime->abs_value_us = (uint64_t) ((uint64_t) t * 1000LL * 1000LL);
#if LINUX
- atime->abs_value -= 1000LL * timezone;
+ atime->abs_value_us -= 1000LL * 1000LL * timezone;
#endif
return GNUNET_OK;
}
* string is returned.
*/
char *
-GNUNET_STRINGS_conv (const char *input, size_t len, const char *input_charset, const char *output_charset)
+GNUNET_STRINGS_conv (const char *input,
+ size_t len,
+ const char *input_charset,
+ const char *output_charset)
{
char *ret;
-
-#if ENABLE_NLS && HAVE_ICONV
- size_t tmpSize;
- size_t finSize;
- char *tmp;
- char *itmp;
- iconv_t cd;
-
- cd = iconv_open (output_charset, input_charset);
- if (cd == (iconv_t) - 1)
+ uint8_t *u8_string;
+ char *encoded_string;
+ size_t u8_string_length;
+ size_t encoded_string_length;
+
+ u8_string = u8_conv_from_encoding (input_charset,
+ iconveh_error,
+ input, len,
+ NULL, NULL,
+ &u8_string_length);
+ if (NULL == u8_string)
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "iconv_open");
- LOG (GNUNET_ERROR_TYPE_WARNING, _("Character sets requested were `%s'->`%s'\n"),
- input_charset, output_charset);
- ret = GNUNET_malloc (len + 1);
- memcpy (ret, input, len);
- ret[len] = '\0';
- return ret;
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
+ goto fail;
}
- tmpSize = 3 * len + 4;
- tmp = GNUNET_malloc (tmpSize);
- itmp = tmp;
- finSize = tmpSize;
- if (iconv (cd,
-#if FREEBSD || DARWIN || WINDOWS
- (const char **) &input,
-#else
- (char **) &input,
-#endif
- &len, &itmp, &finSize) == SIZE_MAX)
+ if (0 == strcmp (output_charset, "UTF-8"))
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "iconv");
- iconv_close (cd);
- GNUNET_free (tmp);
- ret = GNUNET_malloc (len + 1);
- memcpy (ret, input, len);
- ret[len] = '\0';
+ ret = GNUNET_malloc (u8_string_length + 1);
+ memcpy (ret, u8_string, u8_string_length);
+ ret[u8_string_length] = '\0';
+ free (u8_string);
return ret;
}
- ret = GNUNET_malloc (tmpSize - finSize + 1);
- memcpy (ret, tmp, tmpSize - finSize);
- ret[tmpSize - finSize] = '\0';
- GNUNET_free (tmp);
- if (0 != iconv_close (cd))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "iconv_close");
+ encoded_string = u8_conv_to_encoding (output_charset, iconveh_error,
+ u8_string, u8_string_length,
+ NULL, NULL,
+ &encoded_string_length);
+ free (u8_string);
+ if (NULL == encoded_string)
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
+ goto fail;
+ }
+ ret = GNUNET_malloc (encoded_string_length + 1);
+ memcpy (ret, encoded_string, encoded_string_length);
+ ret[encoded_string_length] = '\0';
+ free (encoded_string);
return ret;
-#else
+ fail:
+ 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);
ret[len] = '\0';
return ret;
-#endif
}
/**
* Give relative time in human-readable fancy format.
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
*
* @param delta time in milli seconds
+ * @param do_round are we allowed to round a bit?
* @return time as human-readable string
*/
-char *
-GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta)
+const char *
+GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta,
+ int do_round)
{
- const char *unit = _( /* time unit */ "ms");
- char *ret;
- uint64_t dval = delta.rel_value;
-
- if (delta.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
- return GNUNET_strdup (_("forever"));
- if ( (dval > 5 * 1000) || (0 == (dval % 1000) ))
+ static char buf[128];
+ const char *unit = _( /* time unit */ "µs");
+ uint64_t dval = delta.rel_value_us;
+
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == delta.rel_value_us)
+ return _("forever");
+ if (0 == delta.rel_value_us)
+ return _("0 ms");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 1000) ) ||
+ (0 == (dval % 1000) ))
{
dval = dval / 1000;
- unit = _( /* time unit */ "s");
- if ( (dval > 5 * 60) || (0 == (dval % 60) ) )
+ unit = _( /* time unit */ "ms");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 1000) ) ||
+ (0 == (dval % 1000) ))
{
- dval = dval / 60;
- unit = _( /* time unit */ "m");
- if ( (dval > 5 * 60) || (0 == (dval % 60) ))
+ dval = dval / 1000;
+ unit = _( /* time unit */ "s");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 60) ) ||
+ (0 == (dval % 60) ) )
{
- dval = dval / 60;
- unit = _( /* time unit */ "h");
- if ( (dval > 5 * 24) || (0 == (dval % 24)) )
- {
- dval = dval / 24;
- if (1 == dval)
- unit = _( /* time unit */ "day");
- else
- unit = _( /* time unit */ "days");
- }
+ dval = dval / 60;
+ unit = _( /* time unit */ "m");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 60) ) ||
+ (0 == (dval % 60) ))
+ {
+ dval = dval / 60;
+ unit = _( /* time unit */ "h");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 24) ) ||
+ (0 == (dval % 24)) )
+ {
+ dval = dval / 24;
+ if (1 == dval)
+ unit = _( /* time unit */ "day");
+ else
+ unit = _( /* time unit */ "days");
+ }
+ }
}
}
}
- GNUNET_asprintf (&ret, "%llu %s", dval, unit);
- return ret;
+ GNUNET_snprintf (buf, sizeof (buf),
+ "%llu %s", dval, unit);
+ return buf;
}
/**
* "asctime", except for GNUnet time.
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
*
* @param t time to convert
* @return absolute time in human-readable format
*/
-char *
+const char *
GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
{
+ static char buf[255];
time_t tt;
struct tm *tp;
- char buf[255];
- if (t.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
- return GNUNET_strdup (_("end of time"));
- tt = t.abs_value / 1000;
+ 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);
strftime (buf, sizeof (buf), "%a %b %d %H:%M:%S %Y", tp);
- return GNUNET_strdup (buf);
+ return buf;
}
* @return pointer to the next byte in 'out' or NULL on error.
*/
char *
-GNUNET_STRINGS_data_to_string (const unsigned char *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
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))
{
GNUNET_break (0);
{
if ((rpos < size) && (vbit < 5))
{
- bits = (bits << 8) | data[rpos++]; /* eat 8 more bits */
+ bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
vbit += 8;
}
if (vbit < 5)
out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
vbit -= 5;
}
- if (wpos != out_size)
- {
- GNUNET_break (0);
- return NULL;
- }
GNUNET_assert (vbit == 0);
+ if (wpos < out_size)
+ out[wpos] = '\0';
return &out[wpos];
}
* @param enc the encoding
* @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
* @param out location where to store the decoded data
- * @param out_size sizeof the output buffer
+ * @param out_size size of the output buffer
* @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,
- unsigned char *out, size_t out_size)
+ void *out, size_t out_size)
{
unsigned int rpos;
unsigned int wpos;
unsigned int vbit;
int ret;
int shift;
- int encoded_len = out_size * 8;
- if (encoded_len % 5 > 0)
+ unsigned char *uout;
+ unsigned int encoded_len = out_size * 8;
+
+ if (0 == enclen)
+ {
+ if (0 == out_size)
+ return GNUNET_OK;
+ return GNUNET_SYSERR;
+ }
+ uout = out;
+ wpos = out_size;
+ rpos = enclen;
+ if ((encoded_len % 5) > 0)
{
vbit = encoded_len % 5; /* padding! */
shift = 5 - vbit;
+ bits = (ret = getValue__ (enc[--rpos])) >> (5 - (encoded_len % 5));
}
else
{
- vbit = 0;
+ vbit = 5;
shift = 0;
+ bits = (ret = getValue__ (enc[--rpos]));
}
if ((encoded_len + shift) / 5 != enclen)
return GNUNET_SYSERR;
-
- wpos = out_size;
- rpos = enclen;
- bits = (ret = getValue__ (enc[--rpos])) >> (5 - encoded_len % 5);
if (-1 == ret)
return GNUNET_SYSERR;
while (wpos > 0)
{
- GNUNET_assert (rpos > 0);
+ if (0 == rpos)
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
if (-1 == ret)
return GNUNET_SYSERR;
vbit += 5;
if (vbit >= 8)
{
- out[--wpos] = (unsigned char) bits;
+ uout[--wpos] = (unsigned char) bits;
bits >>= 8;
vbit -= 8;
}
}
- GNUNET_assert (rpos == 0);
- GNUNET_assert (vbit == 0);
+ if ( (0 != rpos) ||
+ (0 != vbit) )
+ return GNUNET_SYSERR;
return GNUNET_OK;
}
}
else
{
- is_uri = GNUNET_NO;
if (r_is_uri)
*r_is_uri = GNUNET_NO;
}
projects / oweals / gnunet.git / blobdiff