GNUnet debian-0.24.3
Strings library

Strings and string handling functions, including malloc and string tokenizing. More...

Collaboration diagram for Strings library:

Data Structures

struct  GNUNET_STRINGS_PortPolicy
 
struct  GNUNET_STRINGS_IPv4NetworkPolicy
 IPV4 network in CIDR notation. More...
 
struct  GNUNET_STRINGS_IPv6NetworkPolicy
 network in CIDR notation for IPV6. More...
 

Enumerations

enum  GNUNET_STRINGS_FilenameCheck { GNUNET_STRINGS_CHECK_EXISTS = 0x00000001 , GNUNET_STRINGS_CHECK_IS_DIRECTORY = 0x00000002 , GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004 , GNUNET_STRINGS_CHECK_IS_ABSOLUTE = 0x00000008 }
 Flags for what we should check a file for. More...
 

Functions

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. More...
 
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. More...
 
char * GNUNET_STRINGS_byte_size_fancy (unsigned long long size)
 Convert a given filesize into a fancy human-readable format. More...
 
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 to a string in given output charset. More...
 
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-8. More...
 
char * GNUNET_STRINGS_utf8_normalize (const char *input)
 Normalize the utf-8 input string to NFC. More...
 
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. More...
 
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower (const char *input, char *output)
 Convert the utf-8 input string to lower case. More...
 
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_toupper (const char *input, char *output)
 Convert the utf-8 input string to upper case. More...
 
char * GNUNET_STRINGS_filename_expand (const char *fil)
 Complete filename (a la shell) from abbrevition. More...
 
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). More...
 
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 (varargs) of type "const char**" to the locations of the respective strings in the buffer. More...
 
const char * GNUNET_STRINGS_get_short_name (const char *filename)
 "man basename" Returns a pointer to a part of filename (allocates nothing)! More...
 
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. More...
 
char * GNUNET_STRINGS_data_to_string_alloc (const void *buf, size_t size)
 Return the base32crockford encoding of the given buffer. More...
 
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. More...
 
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. More...
 
size_t GNUNET_STRINGS_base64_encode (const void *in, size_t len, char **output)
 Encode into Base64. More...
 
size_t GNUNET_STRINGS_urlencode (size_t len, const char data[static len], char **out)
 url/percent encode (RFC3986). More...
 
size_t GNUNET_STRINGS_base64url_encode (const void *in, size_t len, char **output)
 Encode into Base64url. More...
 
size_t GNUNET_STRINGS_base64_decode (const char *data, size_t len, void **output)
 Decode from Base64. More...
 
size_t GNUNET_STRINGS_base64url_decode (const char *data, size_t len, void **out)
 Decode from Base64url. More...
 
size_t GNUNET_STRINGS_urldecode (const char *data, size_t len, char **out)
 url/percent encode (RFC3986). More...
 
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. More...
 
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. More...
 
enum GNUNET_GenericReturnValue GNUNET_STRINGS_check_filename (const char *filename, enum GNUNET_STRINGS_FilenameCheck checks)
 Perform checks on filename. More...
 
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr, size_t addrlen, struct sockaddr_in6 *r_buf)
 Tries to convert zt_addr string to an IPv6 address. More...
 
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr, size_t addrlen, struct sockaddr_in *r_buf)
 Tries to convert zt_addr string to an IPv4 address. More...
 
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. More...
 
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. More...
 
size_t GNUNET_strlcpy (char *dst, const char *src, size_t n)
 Like strlcpy but portable. More...
 
char * GNUNET_STRINGS_get_suffix_from_binary_name (const char *argv0)
 Sometimes we use the binary name to determine which specific test to run. More...
 
struct GNUNET_STRINGS_IPv4NetworkPolicyGNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
 Parse an IPv4 network policy. More...
 
struct GNUNET_STRINGS_IPv6NetworkPolicyGNUNET_STRINGS_parse_ipv6_policy (const char *routeListX)
 Parse an IPv6 network policy. More...
 

Detailed Description

Strings and string handling functions, including malloc and string tokenizing.

Enumeration Type Documentation

◆ GNUNET_STRINGS_FilenameCheck

Flags for what we should check a file for.

Enumerator
GNUNET_STRINGS_CHECK_EXISTS 

Check that it exists.

GNUNET_STRINGS_CHECK_IS_DIRECTORY 

Check that it is a directory.

GNUNET_STRINGS_CHECK_IS_LINK 

Check that it is a link.

GNUNET_STRINGS_CHECK_IS_ABSOLUTE 

Check that the path is an absolute path.

Definition at line 548 of file gnunet_strings_lib.h.

549{
553 GNUNET_STRINGS_CHECK_EXISTS = 0x00000001,
554
559
563 GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004,
564
569};
@ 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.

Function Documentation

◆ GNUNET_STRINGS_fancy_size_to_bytes()

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.

Parameters
fancy_sizehuman readable string (e.g. 1 MB)
sizeset to the size in bytes
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 235 of file strings.c.

237{
238 static const struct ConversionTable table[] =
239 { { "B", 1 },
240 { "KiB", 1024 },
241 { "kB", 1000 },
242 { "MiB", 1024 * 1024 },
243 { "MB", 1000 * 1000 },
244 { "GiB", 1024 * 1024 * 1024 },
245 { "GB", 1000 * 1000 * 1000 },
246 { "TiB", 1024LL * 1024LL * 1024LL * 1024LL },
247 { "TB", 1000LL * 1000LL * 1000LL * 1024LL },
248 { "PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
249 { "PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
250 { "EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
251 { "EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
252 { NULL, 0 } };
253
254 return convert_with_table (fancy_size, table, size);
255}
static struct PeerEntry ** table
Table with our interned peer IDs.
Definition: peer.c:56
static unsigned int size
Size of the "table".
Definition: peer.c:68
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 ...
Definition: strings.c:180
Unit conversion table entry for 'convert_with_table'.
Definition: strings.c:155

References convert_with_table(), size, and table.

Referenced by GNUNET_CONFIGURATION_get_value_size().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_fancy_time_to_relative()

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.

Parameters
fancy_timehuman readable string (e.g. 1 minute)
rtimeset to the relative time
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 259 of file strings.c.

261{
262 static const struct ConversionTable table[] =
263 { { "us", 1 },
264 { "ms", 1000 },
265 { "s", 1000 * 1000LL },
266 { "second", 1000 * 1000LL },
267 { "seconds", 1000 * 1000LL },
268 { "\"", 1000 * 1000LL },
269 { "m", 60 * 1000 * 1000LL },
270 { "min", 60 * 1000 * 1000LL },
271 { "minute", 60 * 1000 * 1000LL },
272 { "minutes", 60 * 1000 * 1000LL },
273 { "'", 60 * 1000 * 1000LL },
274 { "h", 60 * 60 * 1000 * 1000LL },
275 { "hour", 60 * 60 * 1000 * 1000LL },
276 { "hours", 60 * 60 * 1000 * 1000LL },
277 { "d", 24 * 60 * 60 * 1000LL * 1000LL },
278 { "day", 24 * 60 * 60 * 1000LL * 1000LL },
279 { "days", 24 * 60 * 60 * 1000LL * 1000LL },
280 { "w", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
281 { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
282 { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
283 { "year", 31536000000000LL /* year */ },
284 { "years", 31536000000000LL /* year */ },
285 { "y", 31536000000000LL /* year */ },
286 { "a", 31536000000000LL /* year */ },
287 { NULL, 0 } };
288 int ret;
289 unsigned long long val;
290
291 if (0 == strcasecmp ("forever", fancy_time))
292 {
294 return GNUNET_OK;
295 }
296 ret = convert_with_table (fancy_time, table, &val);
297 rtime->rel_value_us = (uint64_t) val;
298 return ret;
299}
static int ret
Final status code.
Definition: gnunet-arm.c:93
@ GNUNET_OK
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
uint64_t rel_value_us
The actual value.

References convert_with_table(), GNUNET_OK, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_Relative::rel_value_us, ret, and table.

Referenced by create_did_ego_lockup_cb(), GNUNET_CONFIGURATION_get_value_time(), parse_expiration(), run(), set_relative_time(), and set_timetravel_time().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_byte_size_fancy()

char * GNUNET_STRINGS_byte_size_fancy ( unsigned long long  size)

Convert a given filesize into a fancy human-readable format.

Parameters
sizenumber of bytes
Returns
fancy representation of the size (possibly rounded) for humans

Definition at line 105 of file strings.c.

106{
107 const char *unit = /* size unit */ "b";
108 char *ret;
109
110 if (size > 5 * 1024)
111 {
112 size = size / 1024;
113 unit = "KiB";
114 if (size > 5 * 1024)
115 {
116 size = size / 1024;
117 unit = "MiB";
118 if (size > 5 * 1024)
119 {
120 size = size / 1024;
121 unit = "GiB";
122 if (size > 5 * 1024)
123 {
124 size = size / 1024;
125 unit = "TiB";
126 }
127 }
128 }
129 }
130 ret = GNUNET_malloc (32);
131 GNUNET_snprintf (ret, 32, "%llu %s", size, unit);
132 return ret;
133}
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.

References GNUNET_malloc, GNUNET_snprintf(), ret, and size.

Referenced by progress_cb(), and publish_inspector().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_conv()

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 to a string in given output charset.

Parameters
inputinput string
lennumber of bytes in input
input_charsetcharacter set used for input
output_charsetdesired character set for the return value
Returns
the converted string (0-terminated), if conversion fails, a copy of the original string is returned.

Definition at line 354 of file strings.c.

358{
359 char *ret;
360 uint8_t *u8_string;
361 char *encoded_string;
362 size_t u8_string_length;
363 size_t encoded_string_length;
364
365 u8_string = u8_conv_from_encoding (input_charset,
366 iconveh_error,
367 input,
368 len,
369 NULL,
370 NULL,
371 &u8_string_length);
372 if (NULL == u8_string)
373 {
374 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
375 goto fail;
376 }
377 if (0 == strcmp (output_charset, "UTF-8"))
378 {
379 ret = GNUNET_malloc (u8_string_length + 1);
380 GNUNET_memcpy (ret, u8_string, u8_string_length);
381 ret[u8_string_length] = '\0';
382 free (u8_string);
383 return ret;
384 }
385 encoded_string = u8_conv_to_encoding (output_charset,
386 iconveh_error,
387 u8_string,
388 u8_string_length,
389 NULL,
390 NULL,
391 &encoded_string_length);
392 free (u8_string);
393 if (NULL == encoded_string)
394 {
395 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
396 goto fail;
397 }
398 ret = GNUNET_malloc (encoded_string_length + 1);
399 GNUNET_memcpy (ret, encoded_string, encoded_string_length);
400 ret[encoded_string_length] = '\0';
401 free (encoded_string);
402 return ret;
403fail:
405 _ ("Character sets requested were `%s'->`%s'\n"),
406 "UTF-8",
407 output_charset);
408 ret = GNUNET_malloc (len + 1);
409 GNUNET_memcpy (ret, input, len);
410 ret[len] = '\0';
411 return ret;
412}
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_ERROR_TYPE_WARNING
#define _(String)
GNU gettext support macro.
Definition: platform.h:179
#define LOG(kind,...)
Definition: strings.c:36
#define LOG_STRERROR(kind, syscall)
Definition: strings.c:38

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_malloc, GNUNET_memcpy, LOG, LOG_STRERROR, and ret.

Referenced by GNUNET_STRINGS_from_utf8(), and GNUNET_STRINGS_to_utf8().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_to_utf8()

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-8.

Parameters
inputthe input string (not necessarily 0-terminated)
lenthe number of bytes in the input
charsetcharacter set to convert from
Returns
the converted string (0-terminated)

Definition at line 416 of file strings.c.

419{
420 return GNUNET_STRINGS_conv (input,
421 len,
422 charset,
423 "UTF-8");
424}
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 ...
Definition: strings.c:354

References GNUNET_STRINGS_conv().

Here is the call graph for this function:

◆ GNUNET_STRINGS_utf8_normalize()

char * GNUNET_STRINGS_utf8_normalize ( const char *  input)

Normalize the utf-8 input string to NFC.

Parameters
inputinput string
Returns
result (freshly allocated) or NULL on error.

Definition at line 440 of file strings.c.

441{
442 uint8_t *tmp;
443 size_t len;
444 char *output;
445 tmp = u8_normalize (UNINORM_NFC,
446 (uint8_t *) input,
447 strlen ((char*) input),
448 NULL,
449 &len);
450 if (NULL == tmp)
451 return NULL;
452 output = GNUNET_malloc (len + 1);
453 GNUNET_memcpy (output, tmp, len);
454 output[len] = '\0';
455 free (tmp);
456 return output;
457}

References GNUNET_malloc, and GNUNET_memcpy.

Referenced by GNUNET_GNSRECORD_string_normalize().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_from_utf8()

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.

Parameters
inputthe input string (not necessarily 0-terminated)
lenthe number of bytes in the input
charsetcharacter set to convert to
Returns
the converted string (0-terminated), if conversion fails, a copy of the original string is returned.

Definition at line 428 of file strings.c.

431{
432 return GNUNET_STRINGS_conv (input,
433 len,
434 "UTF-8",
435 charset);
436}

References GNUNET_STRINGS_conv().

Here is the call graph for this function:

◆ GNUNET_STRINGS_utf8_tolower()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower ( const char *  input,
char *  output 
)

Convert the utf-8 input string to lower case.

Output needs to be allocated appropriately.

Parameters
inputinput string
outputoutput buffer
Returns
GNUNET_OK on success

Definition at line 461 of file strings.c.

463{
464 uint8_t *tmp_in;
465 size_t len;
466
467 tmp_in = u8_tolower ((uint8_t *) input,
468 strlen ((char *) input),
469 NULL,
470 UNINORM_NFD,
471 NULL,
472 &len);
473 if (NULL == tmp_in)
474 return GNUNET_SYSERR;
475 GNUNET_memcpy (output, tmp_in, len);
476 output[len] = '\0';
477 GNUNET_free (tmp_in);
478 return GNUNET_OK;
479}
@ GNUNET_SYSERR
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_free, GNUNET_memcpy, GNUNET_OK, and GNUNET_SYSERR.

Referenced by ego_create(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_credential_new(), handle_collect(), handle_create_message(), handle_delete_message(), handle_rename_message(), handle_verify(), and header_iterator().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_utf8_toupper()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_toupper ( const char *  input,
char *  output 
)

Convert the utf-8 input string to upper case.

Output needs to be allocated appropriately.

Parameters
inputinput string
outputoutput buffer
Returns
GNUNET_OK on success

Definition at line 483 of file strings.c.

485{
486 uint8_t *tmp_in;
487 size_t len;
488
489 tmp_in = u8_toupper ((uint8_t *) input,
490 strlen ((char *) input),
491 NULL,
492 UNINORM_NFD,
493 NULL,
494 &len);
495 if (NULL == tmp_in)
496 return GNUNET_SYSERR;
497 /* 0-terminator does not fit */
498 GNUNET_memcpy (output, tmp_in, len);
499 output[len] = '\0';
500 GNUNET_free (tmp_in);
501 return GNUNET_OK;
502}

References GNUNET_free, GNUNET_memcpy, GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_CRYPTO_hash_from_string2(), and GNUNET_HOSTLIST_client_start().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_filename_expand()

char * GNUNET_STRINGS_filename_expand ( const char *  fil)

Complete filename (a la shell) from abbrevition.

Parameters
filthe name of the file, may contain ~/ or be relative to the current directory
Returns
the full file name, NULL is returned on error

Definition at line 506 of file strings.c.

507{
508 char *buffer;
509 size_t len;
510 char *fm;
511 const char *fil_ptr;
512
513 if (NULL == fil)
514 return NULL;
515
516 if (fil[0] == DIR_SEPARATOR)
517 /* absolute path, just copy */
518 return GNUNET_strdup (fil);
519 if (fil[0] == '~')
520 {
521 fm = getenv ("HOME");
522 if (fm == NULL)
523 {
525 _ ("Failed to expand `$HOME': environment variable `HOME' not set"));
526 return NULL;
527 }
528 fm = GNUNET_strdup (fm);
529 /* do not copy '~' */
530 fil_ptr = fil + 1;
531
532 /* skip over dir separator to be consistent */
533 if (fil_ptr[0] == DIR_SEPARATOR)
534 fil_ptr++;
535 }
536 else
537 {
538 /* relative path */
539 fil_ptr = fil;
540 len = 512;
541 fm = NULL;
542 while (1)
543 {
544 buffer = GNUNET_malloc (len);
545 if (NULL != getcwd (buffer,
546 len))
547 {
548 fm = buffer;
549 break;
550 }
551 if ( (errno == ERANGE) &&
552 (len < 1024 * 1024 * 4) )
553 {
554 len *= 2;
555 GNUNET_free (buffer);
556 continue;
557 }
558 GNUNET_free (buffer);
559 break;
560 }
561 if (NULL == fm)
562 {
564 "getcwd");
565 buffer = getenv ("PWD"); /* alternative */
566 if (buffer != NULL)
567 fm = GNUNET_strdup (buffer);
568 }
569 if (NULL == fm)
570 fm = GNUNET_strdup ("./"); /* give up */
571 }
572 GNUNET_asprintf (&buffer,
573 "%s%s%s",
574 fm,
575 (fm[strlen (fm) - 1] == DIR_SEPARATOR)
576 ? ""
578 fil_ptr);
579 GNUNET_free (fm);
580 return buffer;
581}
char * getenv()
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 DIR_SEPARATOR
Definition: platform.h:166
#define DIR_SEPARATOR_STR
Definition: platform.h:167

References _, DIR_SEPARATOR, DIR_SEPARATOR_STR, getenv(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_strdup, LOG, and LOG_STRERROR.

Referenced by check_client_index_start(), file_test_internal(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_parse(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_directory_scan(), GNUNET_DISK_file_open(), GNUNET_FS_directory_scan_start(), GNUNET_FS_make_file_reader_context_(), GNUNET_log_setup(), handle_client_index_start(), handle_inline(), hash_for_index_cb(), print_filename_option(), and set_filename().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_buffer_fill()

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).

If "buffer" is NULL, only compute the amount of space required (sum of "strlen(arg)+1").

Unlike using "snprintf" with "%s", this function will add 0-terminators after each string. The "GNUNET_string_buffer_tokenize" function can be used to parse the buffer back into individual strings.

Parameters
bufferthe buffer to fill with strings, can be NULL in which case only the necessary amount of space will be calculated
sizenumber of bytes available in buffer
countnumber of strings that follow
...count 0-terminated strings to copy to buffer
Returns
number of bytes written to the buffer (or number of bytes that would have been written)

Definition at line 43 of file strings.c.

46{
47 size_t needed;
48 va_list ap;
49
50 needed = 0;
51 va_start (ap, count);
52 while (count > 0)
53 {
54 const char *s = va_arg (ap, const char *);
55 size_t slen = strlen (s) + 1;
56
57 GNUNET_assert (slen <= size - needed);
58 if (NULL != buffer)
59 GNUNET_memcpy (&buffer[needed],
60 s,
61 slen);
62 needed += slen;
63 count--;
64 }
65 va_end (ap);
66 return needed;
67}
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References GNUNET_assert, GNUNET_memcpy, and size.

Referenced by save(), transmit(), transmit_get(), transmit_set(), and transmit_watch().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_buffer_tokenize()

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 (varargs) of type "const char**" to the locations of the respective strings in the buffer.

Parameters
bufferthe buffer to parse
sizesize of the buffer
countnumber of strings to locate
...pointers to where to store the strings
Returns
offset of the character after the last 0-termination in the buffer, or 0 on error.

Definition at line 71 of file strings.c.

75{
76 unsigned int start;
77 unsigned int needed;
78 const char **r;
79 va_list ap;
80
81 needed = 0;
82 va_start (ap, count);
83 while (count > 0)
84 {
85 r = va_arg (ap, const char **);
86
87 start = needed;
88 while ((needed < size) && (buffer[needed] != '\0'))
89 needed++;
90 if (needed == size)
91 {
92 va_end (ap);
93 return 0; /* error */
94 }
95 *r = &buffer[start];
96 needed++; /* skip 0-termination */
97 count--;
98 }
99 va_end (ap);
100 return needed;
101}
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38

References size, and start.

Referenced by check_get(), check_set(), check_statistics_value(), check_watch(), handle_get(), handle_set(), handle_statistics_value(), handle_watch(), and process_sblock().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_get_short_name()

const char * GNUNET_STRINGS_get_short_name ( const char *  filename)

"man basename" Returns a pointer to a part of filename (allocates nothing)!

Parameters
filenamefilename to extract basename from
Returns
short (base) name of the file (that is, everything following the last directory separator in filename. If filename ends with a directory separator, the result will be a zero-length string. If filename has no directory separators, the result is filename itself.

Definition at line 669 of file strings.c.

670{
671 const char *short_fn = filename;
672 const char *ss;
673
674 while (NULL != (ss = strstr (short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
675 short_fn = 1 + ss;
676 return short_fn;
677}
static char * filename

References DIR_SEPARATOR_STR, and filename.

Referenced by expand_tree(), iter_check_config(), and iter_testbed_path().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_data_to_string()

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.

Does not append 0-terminator, but returns a pointer to the place where it should be placed, if needed.

Parameters
datadata to encode
sizesize of data (in bytes)
outbuffer to fill
out_sizesize of the buffer. Must be large enough to hold ((size*8) + (((size*8) % 5) > 0 ? 5 - ((size*8) % 5) : 0)) / 5
Returns
pointer to the next byte in 'out' or NULL on error.

32 characters for encoding

Definition at line 738 of file strings.c.

742{
746 static const char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
747 unsigned int wpos;
748 unsigned int rpos;
749 unsigned int bits;
750 unsigned int vbit;
751 const unsigned char *udata;
752
753 GNUNET_assert (size < SIZE_MAX / 8 - 4);
754 udata = data;
755 if (out_size < (size * 8 + 4) / 5)
756 {
757 GNUNET_break (0);
758 return NULL;
759 }
760 vbit = 0;
761 wpos = 0;
762 rpos = 0;
763 bits = 0;
764 while ((rpos < size) || (vbit > 0))
765 {
766 if ((rpos < size) && (vbit < 5))
767 {
768 bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
769 vbit += 8;
770 }
771 if (vbit < 5)
772 {
773 bits <<= (5 - vbit); /* zero-padding */
774 GNUNET_assert (vbit == ((size * 8) % 5));
775 vbit = 5;
776 }
777 if (wpos >= out_size)
778 {
779 GNUNET_break (0);
780 return NULL;
781 }
782 out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
783 vbit -= 5;
784 }
785 GNUNET_assert (0 == vbit);
786 if (wpos < out_size)
787 out[wpos] = '\0';
788 return &out[wpos];
789}
static char * data
The data to insert into the dht.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define SIZE_MAX
Definition: platform.h:209

References data, GNUNET_assert, GNUNET_break, size, and SIZE_MAX.

Referenced by auth_key_to_string(), GNUNET_buffer_write_data_encoded(), GNUNET_CRYPTO_ecdsa_private_key_to_string(), GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_CRYPTO_eddsa_private_key_to_string(), GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_GNSRECORD_z2s(), GNUNET_PQ_event_notify(), GNUNET_sh2s(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_uuid2s(), output_message(), print_examples_ecdh(), run_edkey(), run_pkey(), run_with_key(), sh_to_channel(), uri_loc_to_string(), and uri_sks_to_string().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_data_to_string_alloc()

char * GNUNET_STRINGS_data_to_string_alloc ( const void *  buf,
size_t  size 
)

Return the base32crockford encoding of the given buffer.

The returned string will be freshly allocated, and must be free'd with GNUNET_free().

Parameters
bufbuffer with data
sizesize of the buffer buf
Returns
freshly allocated, null-terminated string

Definition at line 793 of file strings.c.

794{
795 char *str_buf;
796 size_t len = size * 8;
797 char *end;
798
799 if (len % 5 > 0)
800 len += 5 - len % 5;
801 len /= 5;
802 str_buf = GNUNET_malloc (len + 1);
804 size,
805 str_buf,
806 len);
807 if (NULL == end)
808 {
809 GNUNET_free (str_buf);
810 return NULL;
811 }
812 *end = '\0';
813 return str_buf;
814}
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:33
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.
Definition: strings.c:738

References end, GNUNET_free, GNUNET_malloc, GNUNET_STRINGS_data_to_string(), and size.

Referenced by attr_collect(), attr_store_task(), conversation_value_to_string(), cred_collect(), cred_iter_cb(), cred_store_task(), d2j(), generate_id_token_body(), generate_userinfo_json(), GNUNET_b2s(), GNUNET_CRYPTO_private_key_to_string(), GNUNET_CRYPTO_public_key_to_string(), GNUNET_HELLO_builder_to_url2(), GNUNET_HELLO_parser_to_url(), GNUNET_JSON_from_data(), handle_attribute_delete_message(), handle_credential_delete_message(), issue_ticket(), iter_cb(), lookup_authz_cb(), main(), messenger_value_to_string(), move_attr_finished(), move_attrs(), oidc_ticket_issue_cb(), process_attrs(), process_record(), purge_attributes(), run(), rvk_move_attr_cb(), save_member(), save_member_session(), save_operation(), setup_job_headers(), value_to_string(), and write_encrypted_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_string_to_data()

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.

out_size must match exactly the size of the data before it was encoded.

Parameters
encthe encoding
enclennumber of characters in enc (without 0-terminator, which can be missing)
outlocation where to store the decoded data
out_sizesize of the output buffer out
Returns
GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 818 of file strings.c.

822{
823 size_t rpos;
824 size_t wpos;
825 unsigned int bits;
826 unsigned int vbit;
827 int ret;
828 int shift;
829 unsigned char *uout;
830 size_t encoded_len;
831
832 if (0 == enclen)
833 {
834 if (0 == out_size)
835 return GNUNET_OK;
836 return GNUNET_SYSERR;
837 }
838 GNUNET_assert (out_size < SIZE_MAX / 8);
839 encoded_len = out_size * 8;
840 uout = out;
841 wpos = out_size;
842 rpos = enclen;
843 if ((encoded_len % 5) > 0)
844 {
845 vbit = encoded_len % 5; /* padding! */
846 shift = 5 - vbit;
847 bits = (ret = getValue__ (enc[--rpos])) >> shift;
848 }
849 else
850 {
851 vbit = 5;
852 shift = 0;
853 bits = (ret = getValue__ (enc[--rpos]));
854 }
855 if ((encoded_len + shift) / 5 != enclen)
856 return GNUNET_SYSERR;
857 if (-1 == ret)
858 return GNUNET_SYSERR;
859 while (wpos > 0)
860 {
861 if (0 == rpos)
862 {
863 GNUNET_break (0);
864 return GNUNET_SYSERR;
865 }
866 bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
867 if (-1 == ret)
868 return GNUNET_SYSERR;
869 vbit += 5;
870 if (vbit >= 8)
871 {
872 uout[--wpos] = (unsigned char) bits;
873 bits >>= 8;
874 vbit -= 8;
875 }
876 }
877 if ((0 != rpos) || (0 != vbit))
878 return GNUNET_SYSERR;
879 return GNUNET_OK;
880}
static OpusEncoder * enc
OPUS encoder.
static unsigned int getValue__(unsigned char a)
Get the decoded value corresponding to a character according to Crockford Base32 encoding.
Definition: strings.c:688

References enc, getValue__(), GNUNET_assert, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, ret, and SIZE_MAX.

Referenced by channel_to_sh(), check_authorization(), consume_fail(), conversation_string_to_value(), delete_attribute_cont(), delete_credential_cont(), ego_create(), expect_data_dynamic(), expect_data_fixed(), GNUNET_CONFIGURATION_get_data(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_CRYPTO_eddsa_private_key_from_string(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_hash_from_string2(), GNUNET_CRYPTO_private_key_from_string(), GNUNET_CRYPTO_public_key_from_string(), GNUNET_HELLO_parser_from_url(), GNUNET_STRINGS_string_to_data_alloc(), lookup_redirect_uri_result(), main(), messenger_string_to_value(), parse_attr(), parse_credential(), parse_fixed_data(), parse_rsa_public_key(), parse_rsa_signature(), read_service_conf(), run(), set_base32(), start_process(), string_to_auth_key(), string_to_value(), uri_loc_parse(), and uri_sks_parse().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_string_to_data_alloc()

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.

out_size will be determined from enc and out will be allocated to be large enough.

Parameters
encthe encoding
enclennumber of characters in enc (without 0-terminator, which can be missing)
[out]outlocation where to allocate and store the decoded data
[out]out_sizeset to the size of the output buffer out
Returns
GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 884 of file strings.c.

888{
889 size_t size;
890 void *data;
891 int res;
892
893 size = (enclen * 5) / 8;
895 {
896 GNUNET_break_op (0);
897 return GNUNET_SYSERR;
898 }
901 enclen,
902 data,
903 size);
904 if ( (0 < size) &&
905 (GNUNET_OK != res) )
906 {
907 size--;
909 enclen,
910 data,
911 size);
912 }
913 if (GNUNET_OK != res)
914 {
915 GNUNET_break_op (0);
917 return GNUNET_SYSERR;
918 }
919 *out = data;
920 *out_size = size;
921 return GNUNET_OK;
922}
static char * res
Currently read line or NULL on EOF.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_MAX_MALLOC_CHECKED
Maximum allocation with GNUNET_malloc macro.
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.
Definition: strings.c:818

References data, enc, GNUNET_break_op, GNUNET_free, GNUNET_malloc, GNUNET_MAX_MALLOC_CHECKED, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, res, and size.

Referenced by GNUNET_PQ_event_do_poll(), parse_variable_data(), and read_encrypted_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_base64_encode()

size_t GNUNET_STRINGS_base64_encode ( const void *  in,
size_t  len,
char **  output 
)

Encode into Base64.

Parameters
datathe data to encode
lenthe length of the input
outputwhere to write the output (*output should be NULL, is allocated)
Returns
the size of the output

Definition at line 1604 of file strings.c.

1607{
1608 const unsigned char *data = in;
1609 size_t ret;
1610 char *opt;
1611
1612 ret = 0;
1613 GNUNET_assert (len < SIZE_MAX / 4);
1614 opt = GNUNET_malloc (2 + (len * 4 / 3) + 8);
1615 for (size_t i = 0; i < len; ++i)
1616 {
1617 char c;
1618
1619 c = (data[i] >> 2) & 0x3f;
1620 opt[ret++] = cvt[(int) c];
1621 c = (data[i] << 4) & 0x3f;
1622 if (++i < len)
1623 c |= (data[i] >> 4) & 0x0f;
1624 opt[ret++] = cvt[(int) c];
1625 if (i < len)
1626 {
1627 c = (data[i] << 2) & 0x3f;
1628 if (++i < len)
1629 c |= (data[i] >> 6) & 0x03;
1630 opt[ret++] = cvt[(int) c];
1631 }
1632 else
1633 {
1634 ++i;
1635 opt[ret++] = FILLCHAR;
1636 }
1637 if (i < len)
1638 {
1639 c = data[i] & 0x3f;
1640 opt[ret++] = cvt[(int) c];
1641 }
1642 else
1643 {
1644 opt[ret++] = FILLCHAR;
1645 }
1646 }
1647 *output = opt;
1648 return ret;
1649}
static const char * cvt
Definition: strings.c:1598
#define FILLCHAR
******************** Base64 encoding
Definition: strings.c:1597

References cvt, data, FILLCHAR, GNUNET_assert, GNUNET_malloc, ret, and SIZE_MAX.

Referenced by dns_value_to_string(), GNUNET_ABD_delegate_to_string(), GNUNET_HELLO_sign_address(), GNUNET_JSON_from_data64(), GNUNET_STRINGS_base64url_encode(), OIDC_access_token_new(), pabc_create_presentation(), and store_and_free_entries().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_urlencode()

size_t GNUNET_STRINGS_urlencode ( size_t  len,
const char  data[static len],
char **  out 
)

url/percent encode (RFC3986).

FIXME: awkward API, len is not actually used out is 0-terminated, should probably be changed to only input data and directly return @out or NULL.

Parameters
datathe data to decode
lenthe length of the input
outwhere to write the output (*out should be NULL, is allocated)
Returns
the size of the output

Definition at line 1868 of file strings.c.

1871{
1872 struct GNUNET_Buffer buf = { 0 };
1873 const uint8_t *i8 = (uint8_t *) data;
1874 const uint8_t *end = (uint8_t *) (data + len);
1875
1876 while (end != i8)
1877 {
1878 if (0 == *i8)
1879 {
1880 /* invalid UTF-8 (or bad @a len): fail */
1881 GNUNET_break (0);
1882 GNUNET_buffer_clear (&buf);
1883 return 0;
1884 }
1885 if (0 == (0x80 & *i8))
1886 {
1887 /* traditional ASCII */
1888 if (isalnum (*i8) ||
1889 (*i8 == '-') ||
1890 (*i8 == '_') ||
1891 (*i8 == '.') ||
1892 (*i8 == '~') )
1893 GNUNET_buffer_write (&buf,
1894 (const char*) i8,
1895 1);
1896 else if (*i8 == ' ')
1897 GNUNET_buffer_write (&buf,
1898 "+",
1899 1);
1900 else
1902 "%%%X%X",
1903 *i8 >> 4,
1904 *i8 & 15);
1905 i8++;
1906 continue;
1907 }
1908 if (0x80 + 0x40 == ((0x80 + 0x40 + 0x20) & *i8))
1909 {
1910 /* 2-byte value, percent-encode */
1912 "%%%X%X",
1913 *i8 >> 4,
1914 *i8 & 15);
1915 i8++;
1916 if ( (end == i8) ||
1917 (0 == *i8) )
1918 {
1919 /* invalid UTF-8 (or bad @a len): fail */
1920 GNUNET_break (0);
1921 GNUNET_buffer_clear (&buf);
1922 return 0;
1923 }
1925 "%%%X%X",
1926 *i8 >> 4,
1927 *i8 & 15);
1928 i8++;
1929 continue;
1930 }
1931 if (0x80 + 0x40 + 0x20 == ((0x80 + 0x40 + 0x20 + 0x10) & *i8))
1932 {
1933 /* 3-byte value, percent-encode */
1934 for (unsigned int i = 0; i<3; i++)
1935 {
1936 if ( (end == i8) ||
1937 (0 == *i8) )
1938 {
1939 /* invalid UTF-8 (or bad @a len): fail */
1940 GNUNET_break (0);
1941 GNUNET_buffer_clear (&buf);
1942 return 0;
1943 }
1945 "%%%X%X",
1946 *i8 >> 4,
1947 *i8 & 15);
1948 i8++;
1949 }
1950 continue;
1951 }
1952 if (0x80 + 0x40 + 0x20 + 0x10 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08) & *i8))
1953 {
1954 /* 4-byte value, percent-encode */
1955 for (unsigned int i = 0; i<4; i++)
1956 {
1957 if ( (end == i8) ||
1958 (0 == *i8) )
1959 {
1960 /* invalid UTF-8 (or bad @a len): fail */
1961 GNUNET_break (0);
1962 GNUNET_buffer_clear (&buf);
1963 return 0;
1964 }
1966 "%%%X%X",
1967 *i8 >> 4,
1968 *i8 & 15);
1969 i8++;
1970 }
1971 continue;
1972 }
1973 if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08
1974 + 0x04) & *i8))
1975 {
1976 /* 5-byte value, percent-encode (outside of UTF-8 modern standard, but so what) */
1977 for (unsigned int i = 0; i<5; i++)
1978 {
1979 if ( (end == i8) ||
1980 (0 == *i8) )
1981 {
1982 /* invalid UTF-8 (or bad @a len): fail */
1983 GNUNET_break (0);
1984 GNUNET_buffer_clear (&buf);
1985 return 0;
1986 }
1988 "%%%X%X",
1989 *i8 >> 4,
1990 *i8 & 15);
1991 i8++;
1992 }
1993 continue;
1994 }
1995 if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 + 0x04 == ((0x80 + 0x40 + 0x20 + 0x10
1996 + 0x08 + 0x04 + 0x02)
1997 & *i8))
1998 {
1999 /* 6-byte value, percent-encode (outside of UTF-8 modern standard, but so what) */
2000 for (unsigned int i = 0; i<6; i++)
2001 {
2002 if ( (end == i8) ||
2003 (0 == *i8) )
2004 {
2005 /* invalid UTF-8 (or bad @a len): fail */
2006 GNUNET_break (0);
2007 GNUNET_buffer_clear (&buf);
2008 return 0;
2009 }
2011 "%%%X%X",
2012 *i8 >> 4,
2013 *i8 & 15);
2014 i8++;
2015 }
2016 continue;
2017 }
2018 /* really, really invalid UTF-8: fail */
2019 GNUNET_break (0);
2020 GNUNET_buffer_clear (&buf);
2021 return 0;
2022 }
2023 *out = GNUNET_buffer_reap_str (&buf);
2024 return strlen (*out);
2025}
char * GNUNET_buffer_reap_str(struct GNUNET_Buffer *buf)
Clear the buffer and return the string it contained.
Definition: buffer.c:123
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.
Definition: buffer.c:86
void GNUNET_buffer_clear(struct GNUNET_Buffer *buf)
Free the backing memory of the given buffer.
Definition: buffer.c:165
Dynamically growing buffer.

References data, end, GNUNET_break, GNUNET_buffer_clear(), GNUNET_buffer_reap_str(), GNUNET_buffer_write(), and GNUNET_buffer_write_fstr().

Referenced by GNUNET_HELLO_builder_to_url2(), GNUNET_HELLO_parser_to_url(), login_redirect(), PABC_load_public_parameters(), PABC_read_usr_ctx(), PABC_write_public_parameters(), and PABC_write_usr_ctx().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_base64url_encode()

size_t GNUNET_STRINGS_base64url_encode ( const void *  in,
size_t  len,
char **  output 
)

Encode into Base64url.

RFC7515

Parameters
inthe data to encode
lenthe length of the input
outputwhere to write the output (*output should be NULL, is allocated)
Returns
the size of the output

Definition at line 1653 of file strings.c.

1656{
1657 char *enc;
1658 size_t pos;
1659
1661 len,
1662 output);
1663 enc = *output;
1664 /* Replace with correct characters for base64url */
1665 pos = 0;
1666 while ('\0' != enc[pos])
1667 {
1668 if ('+' == enc[pos])
1669 enc[pos] = '-';
1670 if ('/' == enc[pos])
1671 enc[pos] = '_';
1672 if ('=' == enc[pos])
1673 {
1674 enc[pos] = '\0';
1675 break;
1676 }
1677 pos++;
1678 }
1679 return strlen (enc);
1680}
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1604

References enc, and GNUNET_STRINGS_base64_encode().

Referenced by check_code_challenge(), DID_key_convert_gnunet_to_multibase_base64(), ego_sign_data_cb(), OIDC_build_authz_code(), and OIDC_generate_id_token_hmac().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_base64_decode()

size_t GNUNET_STRINGS_base64_decode ( const char *  data,
size_t  len,
void **  output 
)

Decode from Base64.

Parameters
datathe data to encode
lenthe length of the input
[out]outputwhere to write the output (*output should be NULL, is allocated)
Returns
the size of the output

Definition at line 1706 of file strings.c.

1709{
1710 unsigned char *output;
1711 size_t ret = 0;
1712
1713 GNUNET_assert (len / 3 < SIZE_MAX);
1714 output = GNUNET_malloc ((len * 3 / 4) + 8);
1716 "base64_decode decoding len=%d\n",
1717 (int) len);
1718 for (size_t i = 0; i < len; ++i)
1719 {
1720 unsigned char c;
1721 unsigned char c1;
1722
1723 CHECK_CRLF;
1724 if (FILLCHAR == data[i])
1725 break;
1726 c = (unsigned char) cvtfind (data[i]);
1727 ++i;
1728 CHECK_CRLF;
1729 c1 = (unsigned char) cvtfind (data[i]);
1730 c = (c << 2) | ((c1 >> 4) & 0x3);
1731 output[ret++] = c;
1732 if (++i < len)
1733 {
1734 CHECK_CRLF;
1735 c = data[i];
1736 if (FILLCHAR == c)
1737 break;
1738 c = (unsigned char) cvtfind (c);
1739 c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
1740 output[ret++] = c1;
1741 }
1742 if (++i < len)
1743 {
1744 CHECK_CRLF;
1745 c1 = data[i];
1746 if (FILLCHAR == c1)
1747 break;
1748
1749 c1 = (unsigned char) cvtfind (c1);
1750 c = ((c << 6) & 0xc0) | c1;
1751 output[ret++] = c;
1752 }
1753 }
1754END:
1755 *out = output;
1756 return ret;
1757}
@ END
We're done processing.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
#define CHECK_CRLF
Definition: strings.c:1693
#define cvtfind(a)
Definition: strings.c:1683

References CHECK_CRLF, cvtfind, data, END, FILLCHAR, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, ret, and SIZE_MAX.

Referenced by database_setup(), dns_string_to_value(), GNUNET_ABD_delegate_from_string(), GNUNET_STRINGS_base64url_decode(), OIDC_access_token_parse(), parse_credentials_basic_auth(), and parse_fixed64_data().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_base64url_decode()

size_t GNUNET_STRINGS_base64url_decode ( const char *  data,
size_t  len,
void **  out 
)

Decode from Base64url.

RFC7515

Parameters
datathe data to decode
lenthe length of the input
outwhere to write the output (*out should be NULL, is allocated)
Returns
the size of the output

Definition at line 1764 of file strings.c.

1767{
1768 char *s;
1769 int padding;
1770 size_t ret;
1771
1772 /* make enough space for padding */
1773 GNUNET_assert (len < SIZE_MAX - 3);
1774 s = GNUNET_malloc (len + 3);
1775 memcpy (s,
1776 data,
1777 len);
1778 for (size_t i = 0; i < strlen (s); i++)
1779 {
1780 if (s[i] == '-')
1781 s[i] = '+';
1782 if (s[i] == '_')
1783 s[i] = '/';
1784 }
1785 padding = len % 4;
1786 switch (padding) // Pad with trailing '='s
1787 {
1788 case 0:
1789 break; // No pad chars in this case
1790 case 2:
1791 memcpy (&s[len],
1792 "==",
1793 2);
1794 len += 2;
1795 break; // Two pad chars
1796 case 3:
1797 s[len] = '=';
1798 len++;
1799 break; // One pad char
1800 default:
1801 GNUNET_assert (0);
1802 break;
1803 }
1805 len,
1806 out);
1807 GNUNET_free (s);
1808 return ret;
1809}
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **out)
Decode from Base64.
Definition: strings.c:1706

References data, GNUNET_assert, GNUNET_free, GNUNET_malloc, GNUNET_STRINGS_base64_decode(), ret, and SIZE_MAX.

Referenced by jwt_get_expiration(), jwt_get_issuer(), jwt_parse_attributes(), OIDC_parse_authz_code(), and set_attributes_from_idtoken().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_urldecode()

size_t GNUNET_STRINGS_urldecode ( const char *  data,
size_t  len,
char **  out 
)

url/percent encode (RFC3986).

Parameters
datathe data to encode
lenthe length of the input
[out]outwhere to write the output (*output should be NULL, is allocated)
Returns
the size of the output

Definition at line 1813 of file strings.c.

1816{
1817 const char *rpos = data;
1818 char *wpos;
1819 size_t resl = 0;
1820 *out = GNUNET_malloc (len + 1); /* output should always fit into input */
1821 wpos = *out;
1822
1823 while ( ('\0' != *rpos) &&
1824 (data + len != rpos) )
1825 {
1826 unsigned int num;
1827 switch (*rpos)
1828 {
1829 case '%':
1830 if (rpos + 3 > data + len)
1831 {
1832 GNUNET_break_op (0);
1833 GNUNET_free (*out);
1834 return 0;
1835 }
1836 if (1 != sscanf (rpos + 1,
1837 "%2x",
1838 &num))
1839 {
1840 /* Invalid URL encoding, try to continue anyway */
1841 GNUNET_break_op (0);
1842 *wpos = *rpos;
1843 wpos++;
1844 resl++;
1845 rpos++;
1846 break;
1847 }
1848 *wpos = (char) ((unsigned char) num);
1849 wpos++;
1850 resl++;
1851 rpos += 3;
1852 break;
1853 /* TODO: add bad sequence handling */
1854 /* intentional fall through! */
1855 default:
1856 *wpos = *rpos;
1857 wpos++;
1858 resl++;
1859 rpos++;
1860 }
1861 }
1862 *wpos = '\0'; /* add 0-terminator */
1863 return resl;
1864}

References data, GNUNET_break_op, GNUNET_free, and GNUNET_malloc.

Referenced by get_url_parameter_copy(), and GNUNET_HELLO_parser_from_url().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_parse_uri()

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.

Parameters
pathpath to parse. Must be NULL-terminated.
[out]scheme_partpointer to a string that represents the URI scheme will be stored. Can be NULL. The string is allocated by the function, and should be freed by GNUNET_free() when it is no longer needed.
path_parta pointer to 'const char *' where a pointer to the path part of the URI will be stored. Can be NULL. Points to the same block of memory as path, and thus must not be freed. Might point to '\0', if path part is zero-length.
Returns
GNUNET_YES if it's an URI, GNUNET_NO otherwise. If 'path' is not an URI, '* scheme_part' and '*path_part' will remain unchanged (if they weren't NULL).

Definition at line 926 of file strings.c.

929{
930 size_t len;
931 size_t i;
932 int end;
933 int pp_state = 0;
934 const char *post_scheme_part = NULL;
935
936 len = strlen (path);
937 for (end = 0, i = 0; ! end && i < len; i++)
938 {
939 switch (pp_state)
940 {
941 case 0:
942 if ((path[i] == ':') && (i > 0))
943 {
944 pp_state += 1;
945 continue;
946 }
947 if (! (((path[i] >= 'A') && (path[i] <= 'Z') ) ||
948 ((path[i] >= 'a') && (path[i] <= 'z') ) ||
949 ((path[i] >= '0') && (path[i] <= '9') ) || (path[i] == '+') ||
950 (path[i] == '-') || (path[i] == '.')))
951 end = 1;
952 break;
953
954 case 1:
955 case 2:
956 if (path[i] == '/')
957 {
958 pp_state += 1;
959 continue;
960 }
961 end = 1;
962 break;
963
964 case 3:
965 post_scheme_part = &path[i];
966 end = 1;
967 break;
968
969 default:
970 end = 1;
971 }
972 }
973 if (post_scheme_part == NULL)
974 return GNUNET_NO;
975 if (scheme_part)
976 {
977 *scheme_part = GNUNET_strndup (path,
978 post_scheme_part - path);
979 }
980 if (path_part)
981 *path_part = post_scheme_part;
982 return GNUNET_YES;
983}
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.

References end, GNUNET_NO, GNUNET_strndup, and GNUNET_YES.

Referenced by GNUNET_STRINGS_path_is_absolute().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_path_is_absolute()

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.

Parameters
filenamefilename to check
can_be_uriGNUNET_YES to check for being URI, GNUNET_NO - to assume it's not URI
r_is_uria pointer to an int that is set to GNUNET_YES if 'filename' is URI and to GNUNET_NO otherwise. Can be NULL. If 'can_be_uri' is not GNUNET_YES, *r_is_uri is set to GNUNET_NO.
r_uri_schemea pointer to a char * that is set to a pointer to URI scheme. The string is allocated by the function, and should be freed with GNUNET_free (). Can be NULL.
Returns
GNUNET_YES if 'filename' is absolute, GNUNET_NO otherwise.

Definition at line 987 of file strings.c.

991{
992 const char *post_scheme_path;
993 int is_uri;
994 char *uri;
995 /* consider POSIX paths to be absolute too, even on W32,
996 * as plibc expansion will fix them for us.
997 */
998 if (filename[0] == '/')
999 return GNUNET_YES;
1000 if (can_be_uri)
1001 {
1002 is_uri = GNUNET_STRINGS_parse_uri (filename, &uri, &post_scheme_path);
1003 if (r_is_uri)
1004 *r_is_uri = is_uri;
1005 if (is_uri)
1006 {
1007 if (r_uri_scheme)
1008 *r_uri_scheme = uri;
1009 else
1010 GNUNET_free (uri);
1011
1012 return GNUNET_STRINGS_path_is_absolute (post_scheme_path,
1013 GNUNET_NO,
1014 NULL,
1015 NULL);
1016 }
1017 }
1018 else
1019 {
1020 if (r_is_uri)
1021 *r_is_uri = GNUNET_NO;
1022 }
1023
1024 return GNUNET_NO;
1025}
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
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.
Definition: strings.c:987
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.
Definition: strings.c:926

References filename, GNUNET_free, GNUNET_NO, GNUNET_STRINGS_parse_uri(), GNUNET_STRINGS_path_is_absolute(), GNUNET_YES, and uri.

Referenced by GNUNET_OS_check_helper_binary(), GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_get_suid_binary_path(), GNUNET_STRINGS_check_filename(), and GNUNET_STRINGS_path_is_absolute().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_check_filename()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_check_filename ( const char *  filename,
enum GNUNET_STRINGS_FilenameCheck  checks 
)

Perform checks on filename.

FIXME: some duplication with "GNUNET_DISK_"-APIs. We should unify those.

Parameters
filenamefile to check
checkschecks to perform
Returns
GNUNET_YES if all checks pass, GNUNET_NO if at least one of them fails, GNUNET_SYSERR when a check can't be performed

Definition at line 1029 of file strings.c.

1031{
1032 struct stat st;
1033
1034 if ((NULL == filename) || (filename[0] == '\0'))
1035 return GNUNET_SYSERR;
1036 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
1038 return GNUNET_NO;
1039 if (0 != (checks
1042 {
1043 if (0 != lstat (filename, &st))
1044 {
1045 if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
1046 return GNUNET_NO;
1047 else
1048 return GNUNET_SYSERR;
1049 }
1050 }
1051 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
1052 if (! S_ISDIR (st.st_mode))
1053 return GNUNET_NO;
1054 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
1055 if (! S_ISLNK (st.st_mode))
1056 return GNUNET_NO;
1057 return GNUNET_YES;
1058}
#define S_ISLNK(m)
Definition: disk.c:61
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.

References filename, GNUNET_NO, GNUNET_STRINGS_CHECK_EXISTS, GNUNET_STRINGS_CHECK_IS_ABSOLUTE, GNUNET_STRINGS_CHECK_IS_DIRECTORY, GNUNET_STRINGS_CHECK_IS_LINK, GNUNET_STRINGS_path_is_absolute(), GNUNET_SYSERR, GNUNET_YES, S_ISLNK, and st.

Here is the call graph for this function:

◆ GNUNET_STRINGS_to_address_ipv6()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv6 ( const char *  zt_addr,
size_t  addrlen,
struct sockaddr_in6 *  r_buf 
)

Tries to convert zt_addr string to an IPv6 address.

The string is expected to have the format "[ABCD::01]:80".

Parameters
zt_addr0-terminated string. May be mangled by the function.
addrlenlength of zt_addr (not counting 0-terminator).
r_bufa buffer to fill. Initially gets filled with zeroes, then its sin6_port, sin6_family and sin6_addr are set appropriately.
Returns
GNUNET_OK if conversion succeeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1062 of file strings.c.

1065{
1066 if (addrlen < 6)
1067 return GNUNET_SYSERR;
1068 if (addrlen > 512)
1069 return GNUNET_SYSERR; /* sanity check to protect zbuf allocation,
1070 actual limit is not precise */
1071 {
1072 char zbuf[addrlen + 1];
1073 int ret;
1074 char *port_colon;
1075 unsigned int port;
1076 char dummy[2];
1077
1078 GNUNET_memcpy (zbuf, zt_addr, addrlen);
1079 if ('[' != zbuf[0])
1080 {
1082 _ ("IPv6 address did not start with `['\n"));
1083 return GNUNET_SYSERR;
1084 }
1085 zbuf[addrlen] = '\0';
1086 port_colon = strrchr (zbuf, ':');
1087 if (NULL == port_colon)
1088 {
1090 _ ("IPv6 address did contain ':' to separate port number\n"));
1091 return GNUNET_SYSERR;
1092 }
1093 if (']' != *(port_colon - 1))
1094 {
1095 GNUNET_log (
1097 _ (
1098 "IPv6 address did contain ']' before ':' to separate port number\n"));
1099 return GNUNET_SYSERR;
1100 }
1101 ret = sscanf (port_colon, ":%u%1s", &port, dummy);
1102 if ((1 != ret) || (port > 65535))
1103 {
1104 GNUNET_log (
1106 _ (
1107 "IPv6 address did contain a valid port number after the last ':'\n"));
1108 return GNUNET_SYSERR;
1109 }
1110 *(port_colon - 1) = '\0';
1111 memset (r_buf, 0, sizeof(struct sockaddr_in6));
1112 ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
1113 if (ret <= 0)
1114 {
1116 _ ("Invalid IPv6 address `%s': %s\n"),
1117 &zbuf[1],
1118 strerror (errno));
1119 return GNUNET_SYSERR;
1120 }
1121 r_buf->sin6_port = htons (port);
1122 r_buf->sin6_family = AF_INET6;
1123#if HAVE_SOCKADDR_IN_SIN_LEN
1124 r_buf->sin6_len = (u_char) sizeof(struct sockaddr_in6);
1125#endif
1126 return GNUNET_OK;
1127 }
1128}
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.

References _, dummy, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, port, and ret.

Referenced by GNUNET_STRINGS_parse_socket_addr(), and GNUNET_STRINGS_to_address_ip().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_to_address_ipv4()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv4 ( const char *  zt_addr,
size_t  addrlen,
struct sockaddr_in *  r_buf 
)

Tries to convert zt_addr string to an IPv4 address.

The string is expected to have the format "1.2.3.4:80".

Parameters
zt_addr0-terminated string. May be mangled by the function.
addrlenlength of zt_addr (not counting 0-terminator).
r_bufa buffer to fill.
Returns
GNUNET_OK if conversion succeeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1132 of file strings.c.

1135{
1136 unsigned int temps[4];
1137 unsigned int port;
1138 unsigned int cnt;
1139 char dummy[2];
1140
1141 if (addrlen < 9)
1142 return GNUNET_SYSERR;
1143 cnt = sscanf (zt_addr,
1144 "%u.%u.%u.%u:%u%1s",
1145 &temps[0],
1146 &temps[1],
1147 &temps[2],
1148 &temps[3],
1149 &port,
1150 dummy);
1151 if (5 != cnt)
1152 return GNUNET_SYSERR;
1153 for (cnt = 0; cnt < 4; cnt++)
1154 if (temps[cnt] > 0xFF)
1155 return GNUNET_SYSERR;
1156 if (port > 65535)
1157 return GNUNET_SYSERR;
1158 r_buf->sin_family = AF_INET;
1159 r_buf->sin_port = htons (port);
1160 r_buf->sin_addr.s_addr =
1161 htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
1162#if HAVE_SOCKADDR_IN_SIN_LEN
1163 r_buf->sin_len = (u_char) sizeof(struct sockaddr_in);
1164#endif
1165 return GNUNET_OK;
1166}

References dummy, GNUNET_OK, GNUNET_SYSERR, and port.

Referenced by GNUNET_STRINGS_parse_socket_addr(), and GNUNET_STRINGS_to_address_ip().

Here is the caller graph for this function:

◆ GNUNET_STRINGS_parse_socket_addr()

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.

Parameters
addrthe address
[out]afset to the parsed address family (e.g. AF_INET)
[out]saset to the parsed address
Returns
0 on error, otherwise number of bytes in sa

Definition at line 1185 of file strings.c.

1188{
1189 *af = AF_UNSPEC;
1190 if ('[' == *addr)
1191 {
1192 /* IPv6 */
1193 *sa = GNUNET_malloc (sizeof(struct sockaddr_in6));
1194 if (GNUNET_OK !=
1196 strlen (addr),
1197 (struct sockaddr_in6 *) *sa))
1198 {
1199 GNUNET_free (*sa);
1200 *sa = NULL;
1201 return 0;
1202 }
1203 *af = AF_INET6;
1204 return sizeof(struct sockaddr_in6);
1205 }
1206 else
1207 {
1208 /* IPv4 */
1209 *sa = GNUNET_malloc (sizeof(struct sockaddr_in));
1210 if (GNUNET_OK !=
1212 strlen (addr),
1213 (struct sockaddr_in *) *sa))
1214 {
1215 GNUNET_free (*sa);
1216 *sa = NULL;
1217 return 0;
1218 }
1219 *af = AF_INET;
1220 return sizeof(struct sockaddr_in);
1221 }
1222}
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv6(const char *zt_addr, size_t addrlen, struct sockaddr_in6 *r_buf)
Tries to convert zt_addr string to an IPv6 address.
Definition: strings.c:1062
enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ipv4(const char *zt_addr, size_t addrlen, struct sockaddr_in *r_buf)
Tries to convert zt_addr string to an IPv4 address.
Definition: strings.c:1132

References GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_STRINGS_to_address_ipv4(), and GNUNET_STRINGS_to_address_ipv6().

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_to_address_ip()

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.

Will automatically decide whether to treat 'addr' as v4 or v6 address.

Parameters
addra string, may not be 0-terminated.
addrlennumber of bytes in addr (if addr is 0-terminated, 0-terminator should not be counted towards addrlen).
r_bufa buffer to fill.
Returns
GNUNET_OK if conversion succeeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1170 of file strings.c.

1173{
1174 if (addr[0] == '[')
1175 return GNUNET_STRINGS_to_address_ipv6 (addr,
1176 addrlen,
1177 (struct sockaddr_in6 *) r_buf);
1178 return GNUNET_STRINGS_to_address_ipv4 (addr,
1179 addrlen,
1180 (struct sockaddr_in *) r_buf);
1181}

References GNUNET_STRINGS_to_address_ipv4(), and GNUNET_STRINGS_to_address_ipv6().

Here is the call graph for this function:

◆ GNUNET_strlcpy()

size_t GNUNET_strlcpy ( char *  dst,
const char *  src,
size_t  n 
)

Like strlcpy but portable.

The given string src is copied in full length (until its null byte). The destination buffer is guaranteed to be null-terminated.

to a destination buffer and ensures that the destination string is null-terminated.

Parameters
dstdestination of the copy
srcsource of the copy, must be null-terminated
nthe length of the string to copy, including its terminating null byte
Returns
the length of the string that was copied, excluding the terminating null byte

Definition at line 137 of file strings.c.

140{
141 size_t slen;
142
143 GNUNET_assert (0 != n);
144 slen = strnlen (src, n - 1);
145 memcpy (dst, src, slen);
146 dst[slen] = '\0';
147 return slen;
148}
static size_t strnlen(const char *s, size_t n)

References GNUNET_assert, and strnlen().

Referenced by add_unixpath(), create_keys(), GCP_2s(), GNUNET_i2s(), GNUNET_i2s2(), mylog(), regex_split(), and try_unixpath().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_get_suffix_from_binary_name()

char * GNUNET_STRINGS_get_suffix_from_binary_name ( const char *  argv0)

Sometimes we use the binary name to determine which specific test to run.

In those cases, the string after the last "_" in 'argv[0]' specifies a string that determines the configuration file or plugin to use.

This function returns the respective substring, taking care of issues such as binaries ending in '.exe' on W32.

Parameters
argv0the name of the binary
Returns
string between the last '_' and the '.exe' (or the end of the string), NULL if argv0 has no '_'

Definition at line 2042 of file strings.c.

2043{
2044 const char *ret;
2045 const char *dot;
2046
2047 ret = strrchr (argv0, '_');
2048 if (NULL == ret)
2049 return NULL;
2050 ret++; /* skip underscore */
2051 dot = strchr (ret,
2052 '.');
2053 if (NULL != dot)
2054 return GNUNET_strndup (ret,
2055 dot - ret);
2056 return GNUNET_strdup (ret);
2057}

References GNUNET_strdup, GNUNET_strndup, and ret.

◆ GNUNET_STRINGS_parse_ipv4_policy()

struct GNUNET_STRINGS_IPv4NetworkPolicy * GNUNET_STRINGS_parse_ipv4_policy ( const char *  routeListX)

Parse an IPv4 network policy.

The argument specifies a list of subnets. The format is (network[/netmask][:[!]SPORT-DPORT];)* (no whitespace, must be terminated with a semicolon). The network must be given in dotted-decimal notation. The netmask can be given in CIDR notation (/16) or in dotted-decimal (/255.255.0.0).

Parameters
routeListXa string specifying the IPv4 subnets
Returns
the converted list, terminated with all zeros; NULL if the syntax is flawed

Definition at line 1280 of file strings.c.

1281{
1282 size_t count;
1283 size_t len;
1284 size_t pos;
1285 unsigned int temps[8];
1287 char *routeList;
1288
1289 if (NULL == routeListX)
1290 return NULL;
1291 len = strlen (routeListX);
1292 if (0 == len)
1293 return NULL;
1294 routeList = GNUNET_strdup (routeListX);
1295 count = 0;
1296 for (size_t i = 0; i < len; i++)
1297 if (routeList[i] == ';')
1298 count++;
1299 GNUNET_assert (count < SIZE_MAX);
1300 result = GNUNET_new_array (count + 1,
1302 pos = 0;
1303 for (size_t i = 0; i < count; i++)
1304 {
1305 size_t colon;
1306 size_t end;
1307 char dummy;
1308
1309 for (colon = pos; ':' != routeList[colon]; colon++)
1310 if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
1311 break;
1312 for (end = colon; ';' != routeList[end]; end++)
1313 if ('\0' == routeList[end])
1314 break;
1315 if ('\0' == routeList[end])
1316 break;
1317 routeList[end] = '\0';
1318 if (':' == routeList[colon])
1319 {
1320 routeList[colon] = '\0';
1321 if (GNUNET_OK != parse_port_policy (&routeList[colon + 1], &result[i].pp))
1322 break;
1323 }
1324 if (8 ==
1325 sscanf (&routeList[pos],
1326 "%u.%u.%u.%u/%u.%u.%u.%u%c",
1327 &temps[0],
1328 &temps[1],
1329 &temps[2],
1330 &temps[3],
1331 &temps[4],
1332 &temps[5],
1333 &temps[6],
1334 &temps[7],
1335 &dummy))
1336 {
1337 for (unsigned int j = 0; j < 8; j++)
1338 if (temps[j] > 0xFF)
1339 {
1341 _ ("Invalid format for IP: `%s'\n"),
1342 &routeList[pos]);
1344 GNUNET_free (routeList);
1345 return NULL;
1346 }
1347 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1348 + (temps[2] << 8) + temps[3]);
1349 result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16)
1350 + (temps[6] << 8) + temps[7]);
1351 pos = end + 1;
1352 continue;
1353 }
1354
1355 /* try second notation */
1356 {
1357 unsigned int slash;
1358
1359 if (5 ==
1360 sscanf (&routeList[pos],
1361 "%u.%u.%u.%u/%u%c",
1362 &temps[0],
1363 &temps[1],
1364 &temps[2],
1365 &temps[3],
1366 &slash,
1367 &dummy))
1368 {
1369 for (unsigned int j = 0; j < 4; j++)
1370 if (temps[j] > 0xFF)
1371 {
1373 _ ("Invalid format for IP: `%s'\n"),
1374 &routeList[pos]);
1376 GNUNET_free (routeList);
1377 return NULL;
1378 }
1379 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1380 + (temps[2] << 8) + temps[3]);
1381 if (slash <= 32)
1382 {
1383 result[i].netmask.s_addr = 0;
1384 while (slash > 0)
1385 {
1386 result[i].netmask.s_addr =
1387 (result[i].netmask.s_addr >> 1) + 0x80000000;
1388 slash--;
1389 }
1390 result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
1391 pos = end + 1;
1392 continue;
1393 }
1394 else
1395 {
1397 _ (
1398 "Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
1399 slash);
1401 GNUNET_free (routeList);
1402 return NULL; /* error */
1403 }
1404 }
1405 }
1406
1407 /* try third notation */
1408 if (4 ==
1409 sscanf (&routeList[pos],
1410 "%u.%u.%u.%u%c",
1411 &temps[0],
1412 &temps[1],
1413 &temps[2],
1414 &temps[3],
1415 &dummy))
1416 {
1417 for (unsigned int j = 0; j < 4; j++)
1418 if (temps[j] > 0xFF)
1419 {
1421 _ ("Invalid format for IP: `%s'\n"),
1422 &routeList[pos]);
1424 GNUNET_free (routeList);
1425 return NULL;
1426 }
1427 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1428 + (temps[2] << 8) + temps[3]);
1429 result[i].netmask.s_addr = htonl (0xffffffff); /* yeah, the htonl is useless */
1430 pos = end + 1;
1431 continue;
1432 }
1434 _ ("Invalid format for IP: `%s'\n"),
1435 &routeList[pos]);
1437 GNUNET_free (routeList);
1438 return NULL; /* error */
1439 }
1440 if (pos < strlen (routeList))
1441 {
1443 _ ("Invalid format: `%s'\n"),
1444 &routeListX[pos]);
1446 GNUNET_free (routeList);
1447 return NULL; /* oops */
1448 }
1449 GNUNET_free (routeList);
1450 return result; /* ok */
1451}
static int result
Global testing status.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static enum GNUNET_GenericReturnValue parse_port_policy(const char *port_policy, struct GNUNET_STRINGS_PortPolicy *pp)
Parse the given port policy.
Definition: strings.c:1235
IPV4 network in CIDR notation.
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
struct in_addr netmask
IPv4 netmask.

References _, dummy, end, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_new_array, GNUNET_OK, GNUNET_strdup, LOG, GNUNET_STRINGS_IPv4NetworkPolicy::netmask, parse_port_policy(), GNUNET_STRINGS_IPv4NetworkPolicy::pp, result, and SIZE_MAX.

Referenced by GNUNET_REGEX_ipv4policy2regex(), and process_acl4().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_parse_ipv6_policy()

struct GNUNET_STRINGS_IPv6NetworkPolicy * GNUNET_STRINGS_parse_ipv6_policy ( const char *  routeListX)

Parse an IPv6 network policy.

The argument specifies a list of subnets. The format is (network[/netmask[:[!]SPORT[-DPORT]]];)* (no whitespace, must be terminated with a semicolon). The network must be given in colon-hex notation. The netmask must be given in CIDR notation (/16) or can be omitted to specify a single host. Note that the netmask is mandatory if ports are specified.

Parameters
routeListXa string specifying the policy
Returns
the converted list, 0-terminated, NULL if the syntax is flawed

Definition at line 1455 of file strings.c.

1456{
1457 size_t count;
1458 size_t len;
1459 size_t pos;
1460 int ret;
1461 char *routeList;
1463 unsigned int off;
1464
1465 if (NULL == routeListX)
1466 return NULL;
1467 len = strlen (routeListX);
1468 if (0 == len)
1469 return NULL;
1470 routeList = GNUNET_strdup (routeListX);
1471 count = 0;
1472 for (size_t j = 0; j < len; j++)
1473 if (';' == routeList[j])
1474 count++;
1475 if (';' != routeList[len - 1])
1476 {
1478 _ ("Invalid network notation (does not end with ';': `%s')\n"),
1479 routeList);
1480 GNUNET_free (routeList);
1481 return NULL;
1482 }
1483 GNUNET_assert (count < UINT_MAX);
1484 result = GNUNET_new_array (count + 1,
1486 pos = 0;
1487 for (size_t i = 0; i < count; i++)
1488 {
1489 size_t start;
1490 size_t slash;
1491
1492 start = pos;
1493 while (';' != routeList[pos])
1494 pos++;
1495 slash = pos;
1496 while ( (slash > start) &&
1497 (routeList[slash] != '/') )
1498 slash--;
1499 if (slash <= start)
1500 {
1501 memset (&result[i].netmask,
1502 0xFF,
1503 sizeof(struct in6_addr));
1504 slash = pos;
1505 }
1506 else
1507 {
1508 size_t colon;
1509
1510 routeList[pos] = '\0';
1511 for (colon = pos; ':' != routeList[colon]; colon--)
1512 if ('/' == routeList[colon])
1513 break;
1514 if (':' == routeList[colon])
1515 {
1516 routeList[colon] = '\0';
1517 if (GNUNET_OK !=
1518 parse_port_policy (&routeList[colon + 1],
1519 &result[i].pp))
1520 {
1522 GNUNET_free (routeList);
1523 return NULL;
1524 }
1525 }
1526 ret = inet_pton (AF_INET6,
1527 &routeList[slash + 1],
1528 &result[i].netmask);
1529 if (ret <= 0)
1530 {
1531 char dummy;
1532 unsigned int bits;
1533 int save = errno;
1534
1535 if ( (1 != sscanf (&routeList[slash + 1],
1536 "%u%c",
1537 &bits,
1538 &dummy)) ||
1539 (bits > 128))
1540 {
1541 if (0 == ret)
1542 {
1544 _ ("Wrong format `%s' for netmask\n"),
1545 &routeList[slash]);
1546 }
1547 else
1548 {
1549 errno = save;
1551 "inet_pton");
1552 }
1554 GNUNET_free (routeList);
1555 return NULL;
1556 }
1557 off = 0;
1558 while (bits > 8)
1559 {
1560 result[i].netmask.s6_addr[off++] = 0xFF;
1561 bits -= 8;
1562 }
1563 while (bits > 0)
1564 {
1565 result[i].netmask.s6_addr[off] =
1566 (result[i].netmask.s6_addr[off] >> 1) + 0x80;
1567 bits--;
1568 }
1569 }
1570 }
1571 routeList[slash] = '\0';
1572 ret = inet_pton (AF_INET6,
1573 &routeList[start],
1574 &result[i].network);
1575 if (ret <= 0)
1576 {
1577 if (0 == ret)
1579 _ ("Wrong format `%s' for network\n"),
1580 &routeList[slash + 1]);
1581 else
1583 "inet_pton");
1585 GNUNET_free (routeList);
1586 return NULL;
1587 }
1588 pos++;
1589 }
1590 GNUNET_free (routeList);
1591 return result;
1592}
static void save()
Write persistent statistics to disk.
@ GNUNET_ERROR_TYPE_ERROR
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.

References _, dummy, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_new_array, GNUNET_OK, GNUNET_strdup, LOG, LOG_STRERROR, GNUNET_STRINGS_IPv6NetworkPolicy::netmask, GNUNET_STRINGS_IPv6NetworkPolicy::network, parse_port_policy(), GNUNET_STRINGS_IPv6NetworkPolicy::pp, result, ret, save(), and start.

Referenced by GNUNET_REGEX_ipv6policy2regex(), and process_acl6().

Here is the call graph for this function:
Here is the caller graph for this function: