38 #define LOG(kind, ...) GNUNET_log_from (kind, "util-strings", __VA_ARGS__)
40 #define LOG_STRERROR(kind, syscall) \
41 GNUNET_log_from_strerror (kind, "util-strings", syscall)
47 unsigned int count, ...)
56 const char *s = va_arg (ap,
const char *);
57 size_t slen = strlen (s) + 1;
87 r = va_arg (ap,
const char **);
90 while ((needed <
size) && (buffer[needed] !=
'\0'))
109 const char *unit =
"b";
147 memcpy (dst, src, slen);
184 unsigned long long *output)
186 unsigned long long ret;
189 unsigned long long last;
196 for (tok = strtok_r (in,
" ", &sptr);
198 tok = strtok_r (NULL,
" ", &sptr))
207 last *=
table[i].value;
215 last = strtoull (tok, &endptr, 10);
216 if ((0 != errno) || (endptr == tok))
221 if (
'\0' == endptr[0])
238 unsigned long long *
size)
244 {
"MiB", 1024 * 1024 },
245 {
"MB", 1000 * 1000 },
246 {
"GiB", 1024 * 1024 * 1024 },
247 {
"GB", 1000 * 1000 * 1000 },
248 {
"TiB", 1024LL * 1024LL * 1024LL * 1024LL },
249 {
"TB", 1000LL * 1000LL * 1000LL * 1024LL },
250 {
"PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
251 {
"PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
252 {
"EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
253 {
"EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
267 {
"s", 1000 * 1000LL },
268 {
"second", 1000 * 1000LL },
269 {
"seconds", 1000 * 1000LL },
270 {
"\"", 1000 * 1000LL },
271 {
"m", 60 * 1000 * 1000LL },
272 {
"min", 60 * 1000 * 1000LL },
273 {
"minute", 60 * 1000 * 1000LL },
274 {
"minutes", 60 * 1000 * 1000LL },
275 {
"'", 60 * 1000 * 1000LL },
276 {
"h", 60 * 60 * 1000 * 1000LL },
277 {
"hour", 60 * 60 * 1000 * 1000LL },
278 {
"hours", 60 * 60 * 1000 * 1000LL },
279 {
"d", 24 * 60 * 60 * 1000LL * 1000LL },
280 {
"day", 24 * 60 * 60 * 1000LL * 1000LL },
281 {
"days", 24 * 60 * 60 * 1000LL * 1000LL },
282 {
"week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
283 {
"weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
284 {
"year", 31536000000000LL },
285 {
"years", 31536000000000LL },
286 {
"a", 31536000000000LL },
289 unsigned long long val;
291 if (0 == strcasecmp (
"forever", fancy_time))
310 if (0 == strcasecmp (
"end of time", fancy_time))
315 eos = &fancy_time[strlen (fancy_time)];
316 memset (&tv, 0,
sizeof(tv));
317 if ((eos != strptime (fancy_time,
"%a %b %d %H:%M:%S %Y", &tv)) &&
318 (eos != strptime (fancy_time,
"%c", &tv)) &&
319 (eos != strptime (fancy_time,
"%Ec", &tv)) &&
320 (eos != strptime (fancy_time,
"%Y-%m-%d %H:%M:%S", &tv)) &&
321 (eos != strptime (fancy_time,
"%Y-%m-%d %H:%M", &tv)) &&
322 (eos != strptime (fancy_time,
"%x", &tv)) &&
323 (eos != strptime (fancy_time,
"%Ex", &tv)) &&
324 (eos != strptime (fancy_time,
"%Y-%m-%d", &tv)) &&
325 (eos != strptime (fancy_time,
"%Y-%m", &tv)) &&
326 (eos != strptime (fancy_time,
"%Y", &tv)))
329 atime->
abs_value_us = (uint64_t) ((uint64_t)
t * 1000LL * 1000LL);
346 const char *input_charset,
347 const char *output_charset)
351 char *encoded_string;
352 size_t u8_string_length;
353 size_t encoded_string_length;
355 u8_string = u8_conv_from_encoding (input_charset,
362 if (NULL == u8_string)
367 if (0 == strcmp (output_charset,
"UTF-8"))
371 ret[u8_string_length] =
'\0';
375 encoded_string = u8_conv_to_encoding (output_charset,
381 &encoded_string_length);
383 if (NULL == encoded_string)
390 ret[encoded_string_length] =
'\0';
391 free (encoded_string);
395 _ (
"Character sets requested were `%s'->`%s'\n"),
435 tmp = u8_normalize (UNINORM_NFC,
437 strlen ((
char*) input),
456 tmp_in = u8_tolower ((uint8_t *) input,
457 strlen ((
char *) input),
478 tmp_in = u8_toupper ((uint8_t *) input,
479 strlen ((
char *) input),
514 _ (
"Failed to expand `$HOME': environment variable `HOME' not set"));
534 if (getcwd (buffer,
len) != NULL)
539 if ((errno == ERANGE) && (
len < 1024 * 1024 * 4))
574 const char *unit =
"µs";
611 (
unsigned long long) dval, unit);
624 return "end of time";
625 tt =
t.abs_value_us / 1000LL / 1000LL;
626 tp = localtime (&
tt);
633 strftime (
buf,
sizeof(
buf),
"%a %b %d %H:%M:%S %Y", tp);
686 if ((a >=
'0') && (a <=
'9'))
688 if ((a >=
'a') && (a <=
'z'))
692 if ((a >=
'A') && (a <=
'Z'))
702 return(a -
'A' + 10 -
dec);
717 static char *encTable__ =
"0123456789ABCDEFGHJKMNPQRSTVWXYZ";
722 const unsigned char *udata;
726 if (out_size < (
size * 8 + 4) / 5)
735 while ((rpos <
size) || (vbit > 0))
737 if ((rpos <
size) && (vbit < 5))
739 bits = (bits << 8) | udata[rpos++];
748 if (wpos >= out_size)
753 out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
810 encoded_len = out_size * 8;
814 if ((encoded_len % 5) > 0)
816 vbit = encoded_len % 5;
826 if ((encoded_len + shift) / 5 != enclen)
843 uout[--wpos] = (
unsigned char) bits;
848 if ((0 != rpos) || (0 != vbit))
864 size = (enclen * 5) / 8;
899 const char **path_part)
905 const char *post_scheme_part = NULL;
908 for (
end = 0, i = 0; !
end && i <
len; i++)
913 if ((path[i] ==
':') && (i > 0))
918 if (! (((path[i] >=
'A') && (path[i] <=
'Z') ) ||
919 ((path[i] >=
'a') && (path[i] <=
'z') ) ||
920 ((path[i] >=
'0') && (path[i] <=
'9') ) || (path[i] ==
'+') ||
921 (path[i] ==
'-') || (path[i] ==
'.')))
936 post_scheme_part = &path[i];
944 if (post_scheme_part == NULL)
950 (*scheme_part)[post_scheme_part - path] =
'\0';
953 *path_part = post_scheme_part;
964 const char *post_scheme_path;
1024 if (! S_ISDIR (
st.st_mode))
1036 struct sockaddr_in6 *r_buf)
1038 char zbuf[addrlen + 1];
1050 _ (
"IPv6 address did not start with `['\n"));
1053 zbuf[addrlen] =
'\0';
1054 port_colon = strrchr (zbuf,
':');
1055 if (NULL == port_colon)
1058 _ (
"IPv6 address did contain ':' to separate port number\n"));
1061 if (
']' != *(port_colon - 1))
1065 _ (
"IPv6 address did contain ']' before ':' to separate port number\n"));
1069 if ((1 !=
ret) || (
port > 65535))
1073 _ (
"IPv6 address did contain a valid port number after the last ':'\n"));
1076 *(port_colon - 1) =
'\0';
1077 memset (r_buf, 0,
sizeof(
struct sockaddr_in6));
1078 ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
1082 _ (
"Invalid IPv6 address `%s': %s\n"),
1087 r_buf->sin6_port = htons (
port);
1088 r_buf->sin6_family = AF_INET6;
1089 #if HAVE_SOCKADDR_IN_SIN_LEN
1090 r_buf->sin6_len = (u_char)
sizeof(
struct sockaddr_in6);
1099 struct sockaddr_in *r_buf)
1101 unsigned int temps[4];
1108 cnt = sscanf (zt_addr,
1109 "%u.%u.%u.%u:%u%1s",
1118 for (cnt = 0; cnt < 4; cnt++)
1119 if (temps[cnt] > 0xFF)
1123 r_buf->sin_family = AF_INET;
1124 r_buf->sin_port = htons (
port);
1125 r_buf->sin_addr.s_addr =
1126 htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
1127 #if HAVE_SOCKADDR_IN_SIN_LEN
1128 r_buf->sin_len = (u_char)
sizeof(
struct sockaddr_in);
1137 struct sockaddr_storage *r_buf)
1142 (
struct sockaddr_in6 *) r_buf);
1145 (
struct sockaddr_in *) r_buf);
1152 struct sockaddr **sa)
1164 (
struct sockaddr_in6 *) *sa))
1173 return sizeof(
struct sockaddr_in6);
1182 (
struct sockaddr_in *) *sa))
1191 return sizeof(
struct sockaddr_in);
1200 static char *
const *
1203 size_t argvsize = 0;
1207 for (
int i = 0; i < argc; i++)
1208 argvsize += strlen (argv[i]) + 1 +
sizeof(
char *);
1210 p = (
char *) &new_argv[argc + 1];
1211 for (
int i = 0; i < argc; i++)
1214 strcpy (
p, argv[i]);
1215 p += strlen (argv[i]) + 1;
1217 new_argv[argc] = NULL;
1218 return (
char *
const *) new_argv;
1226 char *
const **u8argv)
1228 char *
const *new_argv =
1260 if (2 == sscanf (pos,
"%u-%u%1s", &s, &
e, eol))
1262 if ((0 == s) || (s > 0xFFFF) || (
e < s) || (
e > 0xFFFF))
1271 if (1 == sscanf (pos,
"%u%1s", &s, eol))
1273 if ((0 == s) || (s > 0xFFFF))
1284 _ (
"Malformed port policy `%s'\n"),
1299 unsigned int temps[8];
1307 if (NULL == routeListX)
1309 len = strlen (routeListX);
1314 for (i = 0; i <
len; i++)
1315 if (routeList[i] ==
';')
1323 for (colon = pos;
':' != routeList[colon]; colon++)
1324 if ((
';' == routeList[colon]) || (
'\0' == routeList[colon]))
1326 for (
end = colon;
';' != routeList[
end];
end++)
1327 if (
'\0' == routeList[
end])
1329 if (
'\0' == routeList[
end])
1331 routeList[
end] =
'\0';
1332 if (
':' == routeList[colon])
1334 routeList[colon] =
'\0';
1338 cnt = sscanf (&routeList[pos],
1339 "%u.%u.%u.%u/%u.%u.%u.%u%1s",
1351 for (j = 0; j < 8; j++)
1352 if (temps[j] > 0xFF)
1355 _ (
"Invalid format for IP: `%s'\n"),
1361 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1362 + (temps[2] << 8) + temps[3]);
1363 result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16)
1364 + (temps[6] << 8) + temps[7]);
1370 cnt = sscanf (&routeList[pos],
1371 "%u.%u.%u.%u/%u%1s",
1380 for (j = 0; j < 4; j++)
1381 if (temps[j] > 0xFF)
1384 _ (
"Invalid format for IP: `%s'\n"),
1390 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1391 + (temps[2] << 8) + temps[3]);
1392 if ((slash <= 32) && (slash >= 0))
1394 result[i].netmask.s_addr = 0;
1397 result[i].netmask.s_addr =
1398 (
result[i].netmask.s_addr >> 1) + 0x80000000;
1409 _ (
"Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
1418 cnt = sscanf (&routeList[pos],
1427 for (j = 0; j < 4; j++)
1428 if (temps[j] > 0xFF)
1431 _ (
"Invalid format for IP: `%s'\n"),
1437 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1438 + (temps[2] << 8) + temps[3]);
1439 result[i].netmask.s_addr = 0;
1442 result[i].netmask.s_addr = (
result[i].netmask.s_addr >> 1) + 0x80000000;
1451 _ (
"Invalid format for IP: `%s'\n"),
1457 if (pos < strlen (routeList))
1460 _ (
"Invalid format: `%s'\n"),
1489 if (NULL == routeListX)
1491 len = strlen (routeListX);
1496 for (i = 0; i <
len; i++)
1497 if (
';' == routeList[i])
1499 if (
';' != routeList[
len - 1])
1502 _ (
"Invalid network notation (does not end with ';': `%s')\n"),
1515 while (
';' != routeList[pos])
1518 while ((slash >=
start) && (routeList[slash] !=
'/'))
1528 routeList[pos] =
'\0';
1529 for (colon = pos;
':' != routeList[colon]; colon--)
1530 if (
'/' == routeList[colon])
1532 if (
':' == routeList[colon])
1534 routeList[colon] =
'\0';
1547 if ((1 != sscanf (&routeList[slash + 1],
"%u%1s", &bits,
dummy)) ||
1552 _ (
"Wrong format `%s' for netmask\n"),
1553 &routeList[slash + 1]);
1566 result[i].netmask.s6_addr[off++] = 0xFF;
1571 result[i].netmask.s6_addr[off] =
1572 (
result[i].netmask.s6_addr[off] >> 1) + 0x80;
1577 routeList[slash] =
'\0';
1583 _ (
"Wrong format `%s' for network\n"),
1584 &routeList[slash + 1]);
1601 #define FILLCHAR '='
1602 static char *
cvt =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1603 "abcdefghijklmnopqrstuvwxyz"
1612 const char *
data = in;
1619 for (
size_t i = 0; i <
len; ++i)
1623 c = (
data[i] >> 2) & 0x3f;
1625 c = (
data[i] << 4) & 0x3f;
1627 c |= (
data[i] >> 4) & 0x0f;
1631 c = (
data[i] << 2) & 0x3f;
1633 c |= (
data[i] >> 6) & 0x03;
1668 while (
'\0' !=
enc[pos])
1670 if (
'+' ==
enc[pos])
1672 if (
'/' ==
enc[pos])
1674 if (
'=' ==
enc[pos])
1681 return strlen (
enc);
1685 #define cvtfind(a) \
1686 ((((a) >= 'A') && ((a) <= 'Z')) \
1688 : (((a) >= 'a') && ((a) <= 'z')) \
1690 : (((a) >= '0') && ((a) <= '9')) \
1692 : ((a) == '+') ? 62 : ((a) == '/') ? 63 : -1)
1703 #define CHECK_CRLF \
1704 while (data[i] == '\r' || data[i] == '\n') \
1706 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
1707 "ignoring CR/LF\n"); \
1716 "base64_decode decoding len=%d\n",
1718 for (
size_t i = 0; i <
len; ++i)
1730 c = (c << 2) | ((c1 >> 4) & 0x3);
1739 c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
1750 c = ((c << 6) & 0xc0) | c1;
1774 for (
int i = 0; i < strlen (s); i++)
1811 const char *rpos =
data;
1816 while ( (
'\0' != *rpos) &&
1829 if (1 != sscanf (rpos + 1,
"%2x", &num))
1831 *wpos = (char) ((
unsigned char) num);
1856 const uint8_t *i8 = (uint8_t *)
data;
1860 if (0 == (0x80 & *i8))
1863 if (isalnum (*i8) || (*i8 ==
'-') || (*i8 ==
'_') || (*i8 ==
'.') ||
1866 else if (*i8 ==
' ')
1876 if (0x80 + 0x40 == ((0x80 + 0x40 + 0x20) & *i8))
1891 if (0x80 + 0x40 + 0x20 == ((0x80 + 0x40 + 0x20 + 0x10) & *i8))
1894 for (
unsigned int i = 0; i<3; i++)
1904 if (0x80 + 0x40 + 0x20 + 0x10 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08) & *i8))
1907 for (
unsigned int i = 0; i<4; i++)
1917 if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08
1921 for (
unsigned int i = 0; i<5; i++)
1931 if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 + 0x04 == ((0x80 + 0x40 + 0x20 + 0x10
1932 + 0x08 + 0x04 + 0x02)
1936 for (
unsigned int i = 0; i<6; i++)
1952 return strlen (*out);
static size_t strnlen(const char *s, size_t n)
static int ret
Return value of the commandline.
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
static int start
Set if we are to start default services (including ARM).
static int end
Set if we are to shutdown all services (including ARM).
static struct Experiment * e
static uint16_t port
Port number.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
@ END
We're done processing.
static OpusDecoder * dec
OPUS decoder.
static OpusEncoder * enc
OPUS encoder.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
uint32_t data
The data value.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static int result
Global testing status.
static void do_round(void *cls)
Send out PUSHes and PULLs, possibly update #view, samplers.
static void save()
Write persistent statistics to disk.
static struct GNUNET_OS_Process * p
Helper process we started.
static struct GNUNET_SCHEDULER_Task * t
Main task.
char * GNUNET_buffer_reap_str(struct GNUNET_Buffer *buf)
Clear the buffer and return the string it contained.
void GNUNET_buffer_write_fstr(struct GNUNET_Buffer *buf, const char *fmt,...) __attribute__((format(printf
Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.
void GNUNET_buffer_write(struct GNUNET_Buffer *buf, const char *data, size_t len)
Write bytes to the buffer.
void GNUNET_buffer_clear(struct GNUNET_Buffer *buf)
Free the backing memory of the given buffer.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
cryptographic primitives for GNUnet
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_MAX_MALLOC_CHECKED
Maximum allocation with GNUNET_malloc macro.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data_alloc(const char *enc, size_t enclen, void **out, size_t *out_size)
Convert CrockfordBase32 encoding back to data.
size_t GNUNET_STRINGS_base64url_decode(const char *data, size_t len, void **out)
Decode from Base64url.
struct GNUNET_STRINGS_IPv6NetworkPolicy * GNUNET_STRINGS_parse_ipv6_policy(const char *routeListX)
Parse an IPv6 network policy.
size_t GNUNET_STRINGS_parse_socket_addr(const char *addr, uint8_t *af, struct sockaddr **sa)
Parse an address given as a string into a struct sockaddr.
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using CrockfordBase32.
char * GNUNET_STRINGS_conv(const char *input, size_t len, const char *input_charset, const char *output_charset)
Convert the len characters long character sequence given in input that is in the given input charset ...
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ip(const char *addr, uint16_t addrlen, struct sockaddr_storage *r_buf)
Tries to convert addr string to an IP (v4 or v6) address.
GNUNET_STRINGS_FilenameCheck
Flags for what we should check a file for.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv4(const char *zt_addr, uint16_t addrlen, struct sockaddr_in *r_buf)
Tries to convert zt_addr string to an IPv4 address.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to upper case.
char * GNUNET_STRINGS_utf8_normalize(const char *input)
Normalize the utf-8 input string to NFC.
size_t GNUNET_STRINGS_urldecode(const char *data, size_t len, char **out)
url/percent encode (RFC3986).
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
size_t GNUNET_STRINGS_urlencode(const char *data, size_t len, char **out)
url/percent encode (RFC3986).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
char * GNUNET_STRINGS_byte_size_fancy(unsigned long long size)
Convert a given filesize into a fancy human-readable format.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_path_is_absolute(const char *filename, int can_be_uri, int *r_is_uri, char **r_uri_scheme)
Check whether filename is absolute or not, and if it's an URI.
size_t GNUNET_STRINGS_base64url_encode(const void *in, size_t len, char **output)
Encode into Base64url.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_parse_uri(const char *path, char **scheme_part, const char **path_part)
Parse a path that might be an URI.
size_t GNUNET_STRINGS_buffer_fill(char *buffer, size_t size, unsigned int count,...)
Fill a buffer of the given size with count 0-terminated strings (given as varargs).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **out)
Decode from Base64.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv6(const char *zt_addr, uint16_t addrlen, struct sockaddr_in6 *r_buf)
Tries to convert zt_addr string to an IPv6 address.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_check_filename(const char *filename, enum GNUNET_STRINGS_FilenameCheck checks)
Perform checks on filename.
const char * GNUNET_STRINGS_get_short_name(const char *filename)
"man basename" Returns a pointer to a part of filename (allocates nothing)!
struct GNUNET_STRINGS_IPv4NetworkPolicy * GNUNET_STRINGS_parse_ipv4_policy(const char *routeListX)
Parse an IPv4 network policy.
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
char * GNUNET_STRINGS_to_utf8(const char *input, size_t len, const char *charset)
Convert the len characters long character sequence given in input that is in the given charset to UTF...
char * GNUNET_STRINGS_from_utf8(const char *input, size_t len, const char *charset)
Convert the len bytes-long UTF-8 string given in input to the given charset.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size, unsigned long long *size)
Convert a given fancy human-readable size to bytes.
@ GNUNET_STRINGS_CHECK_IS_ABSOLUTE
Check that the path is an absolute path.
@ GNUNET_STRINGS_CHECK_IS_DIRECTORY
Check that it is a directory.
@ GNUNET_STRINGS_CHECK_EXISTS
Check that it exists.
@ GNUNET_STRINGS_CHECK_IS_LINK
Check that it is a link.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_timestamp(const char *fancy_time, struct GNUNET_TIME_Timestamp *atime)
Convert a given fancy human-readable time to our internal representation.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
bool GNUNET_TIME_absolute_is_never(struct GNUNET_TIME_Absolute abs)
Test if abs is never.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
static struct PeerEntry ** table
Table with our interned peer IDs.
static unsigned int size
Size of the "table".
static struct GNUNET_TIME_Relative delta
static enum GNUNET_GenericReturnValue parse_port_policy(const char *port_policy, struct GNUNET_STRINGS_PortPolicy *pp)
Parse the given port policy.
static enum GNUNET_GenericReturnValue convert_with_table(const char *input, const struct ConversionTable *table, unsigned long long *output)
Convert a string of the form "4 X 5 Y" into a numeric value by interpreting "X" and "Y" as units and ...
#define FILLCHAR
******************** Base64 encoding
static char *const * _make_continuous_arg_copy(int argc, char *const *argv)
Makes a copy of argv that consists of a single memory chunk that can be freed with a single call to G...
static unsigned int getValue__(unsigned char a)
Get the decoded value corresponding to a character according to Crockford Base32 encoding.
#define LOG_STRERROR(kind, syscall)
Unit conversion table entry for 'convert_with_table'.
const char * name
Name of the unit (or NULL for end of table).
unsigned long long value
Factor to apply for this unit.
Common buffer management functions.
IPV4 network in CIDR notation.
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
struct in_addr netmask
IPv4 netmask.
network in CIDR notation for IPV6.
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
struct in6_addr network
IPv6 address.
struct in6_addr netmask
IPv6 netmask.
uint16_t start_port
Starting port range (0 if none given).
int negate_portrange
GNUNET_YES if the port range should be negated ("!" in policy).
uint16_t end_port
End of port range (0 if none given).
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Rounded time for timestamps used by GNUnet, in seconds.
struct GNUNET_TIME_Absolute abs_time
The actual value.