/*
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_common.h"
#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},
- { "min", 60 * 1000},
- { "minutes", 60 * 1000},
- { "'", 60 * 1000},
- { "h", 60 * 60 * 1000},
- { "d", 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;
unsigned long long val;
+ if (0 == strcasecmp ("forever", fancy_time))
+ {
+ *rtime = GNUNET_TIME_UNIT_FOREVER_REL;
+ return GNUNET_OK;
+ }
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.
+ *
+ * @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
+ */
+int
+GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
+ struct GNUNET_TIME_Absolute *atime)
+{
+ struct tm tv;
+ time_t t;
+
+ if (0 == strcasecmp ("end of time", fancy_time))
+ {
+ *atime = GNUNET_TIME_UNIT_FOREVER_ABS;
+ return GNUNET_OK;
+ }
+ memset (&tv, 0, sizeof (tv));
+ if ( (NULL == strptime (fancy_time, "%a %b %d %H:%M:%S %Y", &tv)) &&
+ (NULL == strptime (fancy_time, "%c", &tv)) &&
+ (NULL == strptime (fancy_time, "%Ec", &tv)) &&
+ (NULL == strptime (fancy_time, "%Y-%m-%d %H:%M:%S", &tv)) &&
+ (NULL == strptime (fancy_time, "%Y-%m-%d %H:%M", &tv)) &&
+ (NULL == strptime (fancy_time, "%x", &tv)) &&
+ (NULL == strptime (fancy_time, "%Ex", &tv)) &&
+ (NULL == strptime (fancy_time, "%Y-%m-%d", &tv)) &&
+ (NULL == strptime (fancy_time, "%Y-%m", &tv)) &&
+ (NULL == strptime (fancy_time, "%Y", &tv)) )
+ 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;
+#endif
+ return GNUNET_OK;
+}
+
+
/**
* Convert the len characters long character sequence
* given in input that is in the given input charset
* 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
}
return GNUNET_STRINGS_conv (input, len, charset, "UTF-8");
}
+
/**
* Convert the len bytes-long UTF-8 string
* given in input to the given charset.
-
+ *
* @return the converted string (0-terminated),
* if conversion fails, a copy of the orignal
* string is returned.
return GNUNET_STRINGS_conv (input, len, "UTF-8", charset);
}
+
/**
* Convert the utf-8 input string to lowercase
* Output needs to be allocated appropriately
free(tmp_in);
}
+
/**
* Convert the utf-8 input string to uppercase
* Output needs to be allocated appropriately
GNUNET_STRINGS_filename_expand (const char *fil)
{
char *buffer;
-
#ifndef MINGW
size_t len;
size_t n;
/**
* 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 (_("eternity"));
- if (dval > 5 * 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)
+ 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)
+ 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)
- {
- dval = dval / 24;
- 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;
}
/**
- * "man ctime_r", except for GNUnet time; also, unlike ctime, the
- * return value does not include the newline character.
+ * "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;
- char *ret;
-
- if (t.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
- return GNUNET_strdup (_("end of time"));
- tt = t.abs_value / 1000;
-#ifdef ctime_r
- ret = ctime_r (&tt, GNUNET_malloc (32));
-#else
- ret = GNUNET_strdup (ctime (&tt));
-#endif
- ret[strlen (ret) - 1] = '\0';
- return ret;
+ struct tm *tp;
+
+ 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 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;
}
#define S_ISLNK(m) (((m)&_IFMT) == _IFLNK)
#endif
+
/**
* Perform 'checks' on 'filename'
*
enum GNUNET_STRINGS_FilenameCheck checks)
{
struct stat st;
- if (filename == NULL || filename[0] == '\0')
+ if ( (NULL == filename) || (filename[0] == '\0') )
return GNUNET_SYSERR;
- if (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE)
+ if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
if (!GNUNET_STRINGS_path_is_absolute (filename, GNUNET_NO, NULL, NULL))
return GNUNET_NO;
- if (checks & (GNUNET_STRINGS_CHECK_EXISTS
- | GNUNET_STRINGS_CHECK_IS_DIRECTORY
- | GNUNET_STRINGS_CHECK_IS_LINK))
+ if (0 != (checks & (GNUNET_STRINGS_CHECK_EXISTS
+ | GNUNET_STRINGS_CHECK_IS_DIRECTORY
+ | GNUNET_STRINGS_CHECK_IS_LINK)))
{
- if (STAT (filename, &st))
+ if (0 != STAT (filename, &st))
{
- if (checks & GNUNET_STRINGS_CHECK_EXISTS)
+ if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
return GNUNET_NO;
else
return GNUNET_SYSERR;
}
}
- if (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY)
+ if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
if (!S_ISDIR (st.st_mode))
return GNUNET_NO;
- if (checks & GNUNET_STRINGS_CHECK_IS_LINK)
+ if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
if (!S_ISLNK (st.st_mode))
return GNUNET_NO;
return GNUNET_YES;
}
-#define MAX_IPV6_ADDRLEN 47
-#define MAX_IPV4_ADDRLEN 21
-#define MAX_IP_ADDRLEN MAX_IPV6_ADDRLEN
-
/**
* 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).
uint16_t addrlen,
struct sockaddr_in6 *r_buf)
{
+ char zbuf[addrlen + 1];
int ret;
char *port_colon;
unsigned int port;
if (addrlen < 6)
+ return GNUNET_SYSERR;
+ memcpy (zbuf, zt_addr, addrlen);
+ if ('[' != zbuf[0])
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("IPv6 address did not start with `['\n"));
return GNUNET_SYSERR;
-
- port_colon = strrchr (zt_addr, ':');
- if (port_colon == NULL)
+ }
+ zbuf[addrlen] = '\0';
+ port_colon = strrchr (zbuf, ':');
+ if (NULL == port_colon)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("IPv6 address did contain ':' to separate port number\n"));
+ return GNUNET_SYSERR;
+ }
+ if (']' != *(port_colon - 1))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("IPv6 address did contain ']' before ':' to separate port number\n"));
return GNUNET_SYSERR;
+ }
ret = SSCANF (port_colon, ":%u", &port);
- if (ret != 1 || port > 65535)
+ if ( (1 != ret) || (port > 65535) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("IPv6 address did contain a valid port number after the last ':'\n"));
return GNUNET_SYSERR;
- port_colon[0] = '\0';
+ }
+ *(port_colon-1) = '\0';
memset (r_buf, 0, sizeof (struct sockaddr_in6));
- ret = inet_pton (AF_INET6, zt_addr, &r_buf->sin6_addr);
+ ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
if (ret <= 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Invalid IPv6 address `%s': %s\n"),
+ &zbuf[1],
+ STRERROR (errno));
return GNUNET_SYSERR;
+ }
r_buf->sin6_port = htons (port);
r_buf->sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ r_buf->sin6_len = (u_char) sizeof (struct sockaddr_in6);
+#endif
return GNUNET_OK;
}
/**
* 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).
GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr, uint16_t addrlen,
struct sockaddr_in *r_buf)
{
- unsigned int temps[5];
+ unsigned int temps[4];
unsigned int port;
- int cnt;
+ unsigned int cnt;
if (addrlen < 9)
return GNUNET_SYSERR;
-
cnt = SSCANF (zt_addr, "%u.%u.%u.%u:%u", &temps[0], &temps[1], &temps[2], &temps[3], &port);
- if (cnt != 5)
+ if (5 != cnt)
return GNUNET_SYSERR;
-
for (cnt = 0; cnt < 4; cnt++)
if (temps[cnt] > 0xFF)
return GNUNET_SYSERR;
if (port > 65535)
return GNUNET_SYSERR;
-
-
-
r_buf->sin_family = AF_INET;
r_buf->sin_port = htons (port);
r_buf->sin_addr.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16) +
- (temps[2] << 8) + temps[3]);
+ (temps[2] << 8) + temps[3]);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ r_buf->sin_len = (u_char) sizeof (struct sockaddr_in);
+#endif
return GNUNET_OK;
}
+
/**
* Tries to convert 'addr' string to an IP (v4 or v6) address.
- * IPv6 address must have its address part enclosed in '()' parens
- * instead of '[]'.
* Will automatically decide whether to treat 'addr' as v4 or v6 address.
*
* @param addr a string, may not be 0-terminated.
uint16_t addrlen,
struct sockaddr_storage *r_buf)
{
- uint16_t i;
- char zt_addr[MAX_IP_ADDRLEN + 1];
- uint16_t zt_len = addrlen <= MAX_IP_ADDRLEN ? addrlen : MAX_IP_ADDRLEN;
+ if (addr[0] == '[')
+ return GNUNET_STRINGS_to_address_ipv6 (addr, addrlen, (struct sockaddr_in6 *) r_buf);
+ return GNUNET_STRINGS_to_address_ipv4 (addr, addrlen, (struct sockaddr_in *) r_buf);
+}
+
+
+/**
+ * Makes a copy of argv that consists of a single memory chunk that can be
+ * freed with a single call to GNUNET_free ();
+ */
+static char *const *
+_make_continuous_arg_copy (int argc, char *const *argv)
+{
+ size_t argvsize = 0;
+ int i;
+ char **new_argv;
+ char *p;
+ for (i = 0; i < argc; i++)
+ argvsize += strlen (argv[i]) + 1 + sizeof (char *);
+ new_argv = GNUNET_malloc (argvsize + sizeof (char *));
+ p = (char *) &new_argv[argc + 1];
+ for (i = 0; i < argc; i++)
+ {
+ new_argv[i] = p;
+ strcpy (p, argv[i]);
+ p += strlen (argv[i]) + 1;
+ }
+ new_argv[argc] = NULL;
+ return (char *const *) new_argv;
+}
- if (addrlen < 1)
+
+/**
+ * Returns utf-8 encoded arguments.
+ * Does nothing (returns a copy of argc and argv) on any platform
+ * 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.
+ *
+ * @param argc argc (as given by main())
+ * @param argv argv (as given by main())
+ * @param u8argc a location to store new argc in (though it's th same as argc)
+ * @param u8argv a location to store new argv in
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+int
+GNUNET_STRINGS_get_utf8_args (int argc, char *const *argv, int *u8argc, char *const **u8argv)
+{
+#if WINDOWS
+ wchar_t *wcmd;
+ wchar_t **wargv;
+ int wargc;
+ int i;
+ char **split_u8argv;
+
+ wcmd = GetCommandLineW ();
+ if (NULL == wcmd)
+ return GNUNET_SYSERR;
+ wargv = CommandLineToArgvW (wcmd, &wargc);
+ if (NULL == wargv)
return GNUNET_SYSERR;
- memset (zt_addr, 0, MAX_IP_ADDRLEN + 1);
- strncpy (zt_addr, addr, zt_len);
+ split_u8argv = GNUNET_malloc (argc * sizeof (char *));
- /* For URIs we use '(' and ')' instead of '[' and ']'. Do the substitution
- * now, as GNUNET_STRINGS_to_address_ipv6() takes a proper []-enclosed IPv6
- * address.
- */
- if (zt_addr[0] == '(')
+ for (i = 0; i < wargc; i++)
{
- for (i = 0; i < zt_len; i++)
+ 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)
{
- switch (zt_addr[i])
- {
- case '(':
- zt_addr[i] = '[';
- break;
- case ')':
- zt_addr[i] = ']';
- break;
- default:
- break;
- }
+ int j;
+ for (j = 0; j < i; j++)
+ free (split_u8argv[j]);
+ GNUNET_free (split_u8argv);
+ LocalFree (wargv);
+ return GNUNET_SYSERR;
}
- return GNUNET_STRINGS_to_address_ipv6 (zt_addr, zt_len, (struct sockaddr_in6 *) r_buf);
}
- return GNUNET_STRINGS_to_address_ipv4 (zt_addr, zt_len, (struct sockaddr_in *) r_buf);
+
+ *u8argv = _make_continuous_arg_copy (wargc, split_u8argv);
+ *u8argc = wargc;
+
+ for (i = 0; i < wargc; i++)
+ free (split_u8argv[i]);
+ free (split_u8argv);
+ return GNUNET_OK;
+#else
+ char *const *new_argv = (char *const *) _make_continuous_arg_copy (argc, argv);
+ *u8argv = new_argv;
+ *u8argc = argc;
+ return GNUNET_OK;
+#endif
}
/* end of strings.c */
projects / oweals / gnunet.git / blobdiff