GNUnet 0.24.1-16-gbc519cf4b
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 547 of file gnunet_strings_lib.h.

548{
552 GNUNET_STRINGS_CHECK_EXISTS = 0x00000001,
553
558
562 GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004,
563
568};
@ 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 { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
281 { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
282 { "year", 31536000000000LL /* year */ },
283 { "years", 31536000000000LL /* year */ },
284 { "a", 31536000000000LL /* year */ },
285 { NULL, 0 } };
286 int ret;
287 unsigned long long val;
288
289 if (0 == strcasecmp ("forever", fancy_time))
290 {
292 return GNUNET_OK;
293 }
294 ret = convert_with_table (fancy_time, table, &val);
295 rtime->rel_value_us = (uint64_t) val;
296 return ret;
297}
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 352 of file strings.c.

356{
357 char *ret;
358 uint8_t *u8_string;
359 char *encoded_string;
360 size_t u8_string_length;
361 size_t encoded_string_length;
362
363 u8_string = u8_conv_from_encoding (input_charset,
364 iconveh_error,
365 input,
366 len,
367 NULL,
368 NULL,
369 &u8_string_length);
370 if (NULL == u8_string)
371 {
372 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
373 goto fail;
374 }
375 if (0 == strcmp (output_charset, "UTF-8"))
376 {
377 ret = GNUNET_malloc (u8_string_length + 1);
378 GNUNET_memcpy (ret, u8_string, u8_string_length);
379 ret[u8_string_length] = '\0';
380 free (u8_string);
381 return ret;
382 }
383 encoded_string = u8_conv_to_encoding (output_charset,
384 iconveh_error,
385 u8_string,
386 u8_string_length,
387 NULL,
388 NULL,
389 &encoded_string_length);
390 free (u8_string);
391 if (NULL == encoded_string)
392 {
393 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
394 goto fail;
395 }
396 ret = GNUNET_malloc (encoded_string_length + 1);
397 GNUNET_memcpy (ret, encoded_string, encoded_string_length);
398 ret[encoded_string_length] = '\0';
399 free (encoded_string);
400 return ret;
401fail:
403 _ ("Character sets requested were `%s'->`%s'\n"),
404 "UTF-8",
405 output_charset);
406 ret = GNUNET_malloc (len + 1);
407 GNUNET_memcpy (ret, input, len);
408 ret[len] = '\0';
409 return ret;
410}
#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 414 of file strings.c.

417{
418 return GNUNET_STRINGS_conv (input,
419 len,
420 charset,
421 "UTF-8");
422}
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:352

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 438 of file strings.c.

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

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 426 of file strings.c.

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

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 459 of file strings.c.

461{
462 uint8_t *tmp_in;
463 size_t len;
464
465 tmp_in = u8_tolower ((uint8_t *) input,
466 strlen ((char *) input),
467 NULL,
468 UNINORM_NFD,
469 NULL,
470 &len);
471 if (NULL == tmp_in)
472 return GNUNET_SYSERR;
473 GNUNET_memcpy (output, tmp_in, len);
474 output[len] = '\0';
475 GNUNET_free (tmp_in);
476 return GNUNET_OK;
477}
@ 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 481 of file strings.c.

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

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 504 of file strings.c.

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

668{
669 const char *short_fn = filename;
670 const char *ss;
671
672 while (NULL != (ss = strstr (short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
673 short_fn = 1 + ss;
674 return short_fn;
675}
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 736 of file strings.c.

740{
744 static const char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
745 unsigned int wpos;
746 unsigned int rpos;
747 unsigned int bits;
748 unsigned int vbit;
749 const unsigned char *udata;
750
751 GNUNET_assert (size < SIZE_MAX / 8 - 4);
752 udata = data;
753 if (out_size < (size * 8 + 4) / 5)
754 {
755 GNUNET_break (0);
756 return NULL;
757 }
758 vbit = 0;
759 wpos = 0;
760 rpos = 0;
761 bits = 0;
762 while ((rpos < size) || (vbit > 0))
763 {
764 if ((rpos < size) && (vbit < 5))
765 {
766 bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
767 vbit += 8;
768 }
769 if (vbit < 5)
770 {
771 bits <<= (5 - vbit); /* zero-padding */
772 GNUNET_assert (vbit == ((size * 8) % 5));
773 vbit = 5;
774 }
775 if (wpos >= out_size)
776 {
777 GNUNET_break (0);
778 return NULL;
779 }
780 out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
781 vbit -= 5;
782 }
783 GNUNET_assert (0 == vbit);
784 if (wpos < out_size)
785 out[wpos] = '\0';
786 return &out[wpos];
787}
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 791 of file strings.c.

792{
793 char *str_buf;
794 size_t len = size * 8;
795 char *end;
796
797 if (len % 5 > 0)
798 len += 5 - len % 5;
799 len /= 5;
800 str_buf = GNUNET_malloc (len + 1);
802 size,
803 str_buf,
804 len);
805 if (NULL == end)
806 {
807 GNUNET_free (str_buf);
808 return NULL;
809 }
810 *end = '\0';
811 return str_buf;
812}
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:736

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 816 of file strings.c.

820{
821 size_t rpos;
822 size_t wpos;
823 unsigned int bits;
824 unsigned int vbit;
825 int ret;
826 int shift;
827 unsigned char *uout;
828 size_t encoded_len;
829
830 if (0 == enclen)
831 {
832 if (0 == out_size)
833 return GNUNET_OK;
834 return GNUNET_SYSERR;
835 }
836 GNUNET_assert (out_size < SIZE_MAX / 8);
837 encoded_len = out_size * 8;
838 uout = out;
839 wpos = out_size;
840 rpos = enclen;
841 if ((encoded_len % 5) > 0)
842 {
843 vbit = encoded_len % 5; /* padding! */
844 shift = 5 - vbit;
845 bits = (ret = getValue__ (enc[--rpos])) >> shift;
846 }
847 else
848 {
849 vbit = 5;
850 shift = 0;
851 bits = (ret = getValue__ (enc[--rpos]));
852 }
853 if ((encoded_len + shift) / 5 != enclen)
854 return GNUNET_SYSERR;
855 if (-1 == ret)
856 return GNUNET_SYSERR;
857 while (wpos > 0)
858 {
859 if (0 == rpos)
860 {
861 GNUNET_break (0);
862 return GNUNET_SYSERR;
863 }
864 bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
865 if (-1 == ret)
866 return GNUNET_SYSERR;
867 vbit += 5;
868 if (vbit >= 8)
869 {
870 uout[--wpos] = (unsigned char) bits;
871 bits >>= 8;
872 vbit -= 8;
873 }
874 }
875 if ((0 != rpos) || (0 != vbit))
876 return GNUNET_SYSERR;
877 return GNUNET_OK;
878}
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:686

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 882 of file strings.c.

886{
887 size_t size;
888 void *data;
889 int res;
890
891 size = (enclen * 5) / 8;
893 {
894 GNUNET_break_op (0);
895 return GNUNET_SYSERR;
896 }
899 enclen,
900 data,
901 size);
902 if ( (0 < size) &&
903 (GNUNET_OK != res) )
904 {
905 size--;
907 enclen,
908 data,
909 size);
910 }
911 if (GNUNET_OK != res)
912 {
913 GNUNET_break_op (0);
915 return GNUNET_SYSERR;
916 }
917 *out = data;
918 *out_size = size;
919 return GNUNET_OK;
920}
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:816

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 1602 of file strings.c.

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

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 1866 of file strings.c.

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

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

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 1704 of file strings.c.

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

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 1762 of file strings.c.

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

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 1811 of file strings.c.

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

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 924 of file strings.c.

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

989{
990 const char *post_scheme_path;
991 int is_uri;
992 char *uri;
993 /* consider POSIX paths to be absolute too, even on W32,
994 * as plibc expansion will fix them for us.
995 */
996 if (filename[0] == '/')
997 return GNUNET_YES;
998 if (can_be_uri)
999 {
1000 is_uri = GNUNET_STRINGS_parse_uri (filename, &uri, &post_scheme_path);
1001 if (r_is_uri)
1002 *r_is_uri = is_uri;
1003 if (is_uri)
1004 {
1005 if (r_uri_scheme)
1006 *r_uri_scheme = uri;
1007 else
1008 GNUNET_free (uri);
1009
1010 return GNUNET_STRINGS_path_is_absolute (post_scheme_path,
1011 GNUNET_NO,
1012 NULL,
1013 NULL);
1014 }
1015 }
1016 else
1017 {
1018 if (r_is_uri)
1019 *r_is_uri = GNUNET_NO;
1020 }
1021
1022 return GNUNET_NO;
1023}
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:985
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:924

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 1027 of file strings.c.

1029{
1030 struct stat st;
1031
1032 if ((NULL == filename) || (filename[0] == '\0'))
1033 return GNUNET_SYSERR;
1034 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
1036 return GNUNET_NO;
1037 if (0 != (checks
1040 {
1041 if (0 != lstat (filename, &st))
1042 {
1043 if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
1044 return GNUNET_NO;
1045 else
1046 return GNUNET_SYSERR;
1047 }
1048 }
1049 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
1050 if (! S_ISDIR (st.st_mode))
1051 return GNUNET_NO;
1052 if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
1053 if (! S_ISLNK (st.st_mode))
1054 return GNUNET_NO;
1055 return GNUNET_YES;
1056}
#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 1060 of file strings.c.

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

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

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 1183 of file strings.c.

1186{
1187 *af = AF_UNSPEC;
1188 if ('[' == *addr)
1189 {
1190 /* IPv6 */
1191 *sa = GNUNET_malloc (sizeof(struct sockaddr_in6));
1192 if (GNUNET_OK !=
1194 strlen (addr),
1195 (struct sockaddr_in6 *) *sa))
1196 {
1197 GNUNET_free (*sa);
1198 *sa = NULL;
1199 return 0;
1200 }
1201 *af = AF_INET6;
1202 return sizeof(struct sockaddr_in6);
1203 }
1204 else
1205 {
1206 /* IPv4 */
1207 *sa = GNUNET_malloc (sizeof(struct sockaddr_in));
1208 if (GNUNET_OK !=
1210 strlen (addr),
1211 (struct sockaddr_in *) *sa))
1212 {
1213 GNUNET_free (*sa);
1214 *sa = NULL;
1215 return 0;
1216 }
1217 *af = AF_INET;
1218 return sizeof(struct sockaddr_in);
1219 }
1220}
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:1060
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:1130

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 1168 of file strings.c.

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

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 2040 of file strings.c.

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

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 1278 of file strings.c.

1279{
1280 size_t count;
1281 size_t len;
1282 size_t pos;
1283 unsigned int temps[8];
1285 char *routeList;
1286
1287 if (NULL == routeListX)
1288 return NULL;
1289 len = strlen (routeListX);
1290 if (0 == len)
1291 return NULL;
1292 routeList = GNUNET_strdup (routeListX);
1293 count = 0;
1294 for (size_t i = 0; i < len; i++)
1295 if (routeList[i] == ';')
1296 count++;
1297 GNUNET_assert (count < SIZE_MAX);
1298 result = GNUNET_new_array (count + 1,
1300 pos = 0;
1301 for (size_t i = 0; i < count; i++)
1302 {
1303 size_t colon;
1304 size_t end;
1305 char dummy;
1306
1307 for (colon = pos; ':' != routeList[colon]; colon++)
1308 if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
1309 break;
1310 for (end = colon; ';' != routeList[end]; end++)
1311 if ('\0' == routeList[end])
1312 break;
1313 if ('\0' == routeList[end])
1314 break;
1315 routeList[end] = '\0';
1316 if (':' == routeList[colon])
1317 {
1318 routeList[colon] = '\0';
1319 if (GNUNET_OK != parse_port_policy (&routeList[colon + 1], &result[i].pp))
1320 break;
1321 }
1322 if (8 ==
1323 sscanf (&routeList[pos],
1324 "%u.%u.%u.%u/%u.%u.%u.%u%c",
1325 &temps[0],
1326 &temps[1],
1327 &temps[2],
1328 &temps[3],
1329 &temps[4],
1330 &temps[5],
1331 &temps[6],
1332 &temps[7],
1333 &dummy))
1334 {
1335 for (unsigned int j = 0; j < 8; j++)
1336 if (temps[j] > 0xFF)
1337 {
1339 _ ("Invalid format for IP: `%s'\n"),
1340 &routeList[pos]);
1342 GNUNET_free (routeList);
1343 return NULL;
1344 }
1345 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1346 + (temps[2] << 8) + temps[3]);
1347 result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16)
1348 + (temps[6] << 8) + temps[7]);
1349 pos = end + 1;
1350 continue;
1351 }
1352
1353 /* try second notation */
1354 {
1355 unsigned int slash;
1356
1357 if (5 ==
1358 sscanf (&routeList[pos],
1359 "%u.%u.%u.%u/%u%c",
1360 &temps[0],
1361 &temps[1],
1362 &temps[2],
1363 &temps[3],
1364 &slash,
1365 &dummy))
1366 {
1367 for (unsigned int j = 0; j < 4; j++)
1368 if (temps[j] > 0xFF)
1369 {
1371 _ ("Invalid format for IP: `%s'\n"),
1372 &routeList[pos]);
1374 GNUNET_free (routeList);
1375 return NULL;
1376 }
1377 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1378 + (temps[2] << 8) + temps[3]);
1379 if (slash <= 32)
1380 {
1381 result[i].netmask.s_addr = 0;
1382 while (slash > 0)
1383 {
1384 result[i].netmask.s_addr =
1385 (result[i].netmask.s_addr >> 1) + 0x80000000;
1386 slash--;
1387 }
1388 result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
1389 pos = end + 1;
1390 continue;
1391 }
1392 else
1393 {
1395 _ (
1396 "Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
1397 slash);
1399 GNUNET_free (routeList);
1400 return NULL; /* error */
1401 }
1402 }
1403 }
1404
1405 /* try third notation */
1406 if (4 ==
1407 sscanf (&routeList[pos],
1408 "%u.%u.%u.%u%c",
1409 &temps[0],
1410 &temps[1],
1411 &temps[2],
1412 &temps[3],
1413 &dummy))
1414 {
1415 for (unsigned int j = 0; j < 4; j++)
1416 if (temps[j] > 0xFF)
1417 {
1419 _ ("Invalid format for IP: `%s'\n"),
1420 &routeList[pos]);
1422 GNUNET_free (routeList);
1423 return NULL;
1424 }
1425 result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1426 + (temps[2] << 8) + temps[3]);
1427 result[i].netmask.s_addr = htonl (0xffffffff); /* yeah, the htonl is useless */
1428 pos = end + 1;
1429 continue;
1430 }
1432 _ ("Invalid format for IP: `%s'\n"),
1433 &routeList[pos]);
1435 GNUNET_free (routeList);
1436 return NULL; /* error */
1437 }
1438 if (pos < strlen (routeList))
1439 {
1441 _ ("Invalid format: `%s'\n"),
1442 &routeListX[pos]);
1444 GNUNET_free (routeList);
1445 return NULL; /* oops */
1446 }
1447 GNUNET_free (routeList);
1448 return result; /* ok */
1449}
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:1233
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 1453 of file strings.c.

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