/*
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
#if HAVE_ICONV
#include <iconv.h>
#endif
-#include "gnunet_common.h"
-#include "gnunet_strings_lib.h"
+#include "gnunet_util_lib.h"
#include <unicase.h>
#include <unistr.h>
#include <uniconv.h>
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;
*
* @param fancy_time human readable string (i.e. 1 minute)
* @param rtime set to the relative time
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
{
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;
}
/**
* Convert a given fancy human-readable time to our internal
- * representation.
+ * representation. The human-readable time is expected to be
+ * in local time, whereas the returned value will be in UTC.
*
* @param fancy_time human readable string (i.e. %Y-%m-%d %H:%M:%S)
* @param atime set to the absolute time
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
(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;
}
* Convert the len characters long character sequence
* given in input that is in the given input charset
* to a string in given output charset.
+ *
+ * @param input input string
+ * @param len number of bytes in @a input
+ * @param input_charset character set used for @a input
+ * @param ouptut_charset desired character set for the return value
* @return the converted string (0-terminated),
* if conversion fails, a copy of the orignal
* 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;
uint8_t *u8_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 = u8_conv_from_encoding (input_charset,
+ iconveh_error,
+ input, len,
+ NULL, NULL,
&u8_string_length);
if (NULL == u8_string)
{
free (u8_string);
return ret;
}
- encoded_string = u8_conv_to_encoding (output_charset, iconveh_error,
- u8_string, u8_string_length,
- NULL, NULL,
+ 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)
* Convert the len characters long character sequence
* given in input that is in the given charset
* to UTF-8.
+ *
+ * @param input the input string (not necessarily 0-terminated)
+ * @param len the number of bytes in the @a input
+ * @param charset character set to convert from
* @return the converted string (0-terminated),
* if conversion fails, a copy of the orignal
* string is returned.
*/
char *
-GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset)
+GNUNET_STRINGS_to_utf8 (const char *input,
+ size_t len,
+ const char *charset)
{
return GNUNET_STRINGS_conv (input, len, charset, "UTF-8");
}
* Convert the len bytes-long UTF-8 string
* given in input to the given charset.
*
+ * @param input the input string (not necessarily 0-terminated)
+ * @param len the number of bytes in the @a input
+ * @param charset character set to convert to
* @return the converted string (0-terminated),
* if conversion fails, a copy of the orignal
* string is returned.
*/
char *
-GNUNET_STRINGS_from_utf8 (const char *input, size_t len, const char *charset)
+GNUNET_STRINGS_from_utf8 (const char *input,
+ size_t len,
+ const char *charset)
{
return GNUNET_STRINGS_conv (input, len, "UTF-8", charset);
}
int do_round)
{
static char buf[128];
- const char *unit = _( /* time unit */ "ms");
- uint64_t dval = delta.rel_value;
+ const char *unit = _( /* time unit */ "ยตs");
+ uint64_t dval = delta.rel_value_us;
- if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value == delta.rel_value)
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == delta.rel_value_us)
return _("forever");
- if (0 == delta.rel_value)
+ if (0 == delta.rel_value_us)
return _("0 ms");
- if ( ( (GNUNET_YES == do_round) &&
- (dval > 5 * 1000) ) ||
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 1000) ) ||
(0 == (dval % 1000) ))
{
dval = dval / 1000;
- unit = _( /* time unit */ "s");
+ unit = _( /* time unit */ "ms");
if ( ( (GNUNET_YES == do_round) &&
- (dval > 5 * 60) ) ||
- (0 == (dval % 60) ) )
+ (dval > 5 * 1000) ) ||
+ (0 == (dval % 1000) ))
{
- dval = dval / 60;
- unit = _( /* time unit */ "m");
+ dval = dval / 1000;
+ unit = _( /* time unit */ "s");
if ( ( (GNUNET_YES == do_round) &&
- (dval > 5 * 60) ) ||
- (0 == (dval % 60) ))
+ (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 / 60;
+ unit = _( /* time unit */ "m");
+ if ( ( (GNUNET_YES == do_round) &&
+ (dval > 5 * 60) ) ||
+ (0 == (dval % 60) ))
{
- dval = dval / 24;
- if (1 == dval)
- unit = _( /* time unit */ "day");
- else
- unit = _( /* time unit */ "days");
- }
+ 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");
+ }
+ }
}
}
}
/**
- * "asctime", except for GNUnet time.
- * This is one of the very few calls in the entire API that is
- * NOT reentrant!
+ * "asctime", except for GNUnet time. Converts a GNUnet internal
+ * absolute time (which is in UTC) to a string in local time.
+ * Note that the returned value will be overwritten if this function
+ * is called again.
*
* @param t time to convert
* @return absolute time in human-readable format
time_t tt;
struct tm *tp;
- if (t.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+ if (t.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
return _("end of time");
- tt = t.abs_value / 1000;
+ tt = t.abs_value_us / 1000LL / 1000LL;
tp = gmtime (&tt);
strftime (buf, sizeof (buf), "%a %b %d %H:%M:%S %Y", tp);
return buf;
* 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.
+ * small number of characters.
* Does not append 0-terminator, but returns a pointer to the place where
* it should be placed, if needed.
*
* @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
+ * 32 characters for encoding
*/
static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
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))
{
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;
}
/**
* Perform 'checks' on 'filename'
- *
+ *
* @param filename file to check
* @param checks checks to perform
* @return GNUNET_YES if all checks pass, GNUNET_NO if at least one of them
/**
* Tries to convert 'zt_addr' string to an IPv6 address.
* The string is expected to have the format "[ABCD::01]:80".
- *
+ *
* @param zt_addr 0-terminated string. May be mangled by the function.
* @param addrlen length of zt_addr (not counting 0-terminator).
* @param r_buf a buffer to fill. Initially gets filled with zeroes,
* case the contents of r_buf are undefined.
*/
int
-GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
+GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
uint16_t addrlen,
struct sockaddr_in6 *r_buf)
{
unsigned int port;
if (addrlen < 6)
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
memcpy (zbuf, zt_addr, addrlen);
if ('[' != zbuf[0])
{
/**
* Tries to convert 'zt_addr' string to an IPv4 address.
* The string is expected to have the format "1.2.3.4:80".
- *
+ *
* @param zt_addr 0-terminated string. May be mangled by the function.
* @param addrlen length of zt_addr (not counting 0-terminator).
* @param r_buf a buffer to fill.
/**
* Tries to convert 'addr' string to an IP (v4 or v6) address.
* Will automatically decide whether to treat 'addr' as v4 or v6 address.
- *
+ *
* @param addr a string, may not be 0-terminated.
* @param addrlen number of bytes in addr (if addr is 0-terminated,
* 0-terminator should not be counted towards addrlen).
* case the contents of r_buf are undefined.
*/
int
-GNUNET_STRINGS_to_address_ip (const char *addr,
+GNUNET_STRINGS_to_address_ip (const char *addr,
uint16_t addrlen,
struct sockaddr_storage *r_buf)
{
size_t strl;
/* Hopefully it will allocate us NUL-terminated strings... */
split_u8argv[i] = (char *) u16_to_u8 (wargv[i], wcslen (wargv[i]) + 1, NULL, &strl);
- if (split_u8argv == NULL)
+ if (NULL == split_u8argv[i])
{
int j;
for (j = 0; j < i; j++)
projects / oweals / gnunet.git / blobdiff