GNUnet  0.10.x
Data Structures | Enumerations | Functions
Strings library

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

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

int GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size, unsigned long long *size)
 Convert a given fancy human-readable size to bytes. More...
 
int 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_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...
 
void GNUNET_STRINGS_utf8_tolower (const char *input, char *output)
 Convert the utf-8 input string to lower case. More...
 
void 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...
 
int GNUNET_STRINGS_string_to_data (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_base64_decode (const char *data, size_t len, void **output)
 Decode from Base64. More...
 
char * GNUNET_STRINGS_pp2s (const struct GNUNET_PeerIdentity *pids, unsigned int num_pids)
 Convert a peer path to a human-readable string. More...
 
int GNUNET_STRINGS_parse_uri (const char *path, char **scheme_part, const char **path_part)
 Parse a path that might be an URI. More...
 
int 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...
 
int GNUNET_STRINGS_check_filename (const char *filename, enum GNUNET_STRINGS_FilenameCheck checks)
 Perform checks on filename. More...
 
int GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr, uint16_t addrlen, struct sockaddr_in6 *r_buf)
 Tries to convert zt_addr string to an IPv6 address. More...
 
int GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr, uint16_t addrlen, struct sockaddr_in *r_buf)
 Tries to convert zt_addr string to an IPv4 address. 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...
 
int 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...
 
int GNUNET_STRINGS_get_utf8_args (int argc, char *const *argv, int *u8argc, char *const **u8argv)
 Returns utf-8 encoded arguments. More...
 
size_t GNUNET_strlcpy (char *dst, const char *src, size_t n)
 Like strlcpy but portable. 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 422 of file gnunet_strings_lib.h.

422  {
426  GNUNET_STRINGS_CHECK_EXISTS = 0x00000001,
427 
432 
436  GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004,
437 
442 };
Check that the path is an absolute path.
Check that it exists.
Check that it is a link.
Check that it is a directory.

Function Documentation

◆ GNUNET_STRINGS_fancy_size_to_bytes()

int 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 (i.e. 1 MB)
sizeset to the size in bytes
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 318 of file strings.c.

References convert_with_table().

Referenced by get_quota(), GNUNET_ATS_solvers_load_quotas(), GNUNET_CONFIGURATION_get_value_size(), parse_quota(), and print_quotas().

320 {
321  static const struct ConversionTable table[] =
322  { { "B", 1 },
323  { "KiB", 1024 },
324  { "kB", 1000 },
325  { "MiB", 1024 * 1024 },
326  { "MB", 1000 * 1000 },
327  { "GiB", 1024 * 1024 * 1024 },
328  { "GB", 1000 * 1000 * 1000 },
329  { "TiB", 1024LL * 1024LL * 1024LL * 1024LL },
330  { "TB", 1000LL * 1000LL * 1000LL * 1024LL },
331  { "PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
332  { "PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
333  { "EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
334  { "EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
335  { NULL, 0 } };
336 
337  return convert_with_table(fancy_size, table, size);
338 }
static int 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:259
static struct PeerEntry ** table
Table with our interned peer IDs.
Definition: peer.c:54
Unit conversion table entry for 'convert_with_table'.
Definition: strings.c:234
static unsigned int size
Size of the "table".
Definition: peer.c:66
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_fancy_time_to_relative()

int 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 (i.e. 1 minute)
rtimeset to the relative time
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 350 of file strings.c.

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

Referenced by get_cred_issuer_cb(), GNUNET_CONFIGURATION_get_value_time(), identity_cb(), main(), parse_expiration(), parse_record(), and set_relative_time().

352 {
353  static const struct ConversionTable table[] =
354  { { "us", 1 },
355  { "ms", 1000 },
356  { "s", 1000 * 1000LL },
357  { "second", 1000 * 1000LL },
358  { "seconds", 1000 * 1000LL },
359  { "\"", 1000 * 1000LL },
360  { "m", 60 * 1000 * 1000LL },
361  { "min", 60 * 1000 * 1000LL },
362  { "minute", 60 * 1000 * 1000LL },
363  { "minutes", 60 * 1000 * 1000LL },
364  { "'", 60 * 1000 * 1000LL },
365  { "h", 60 * 60 * 1000 * 1000LL },
366  { "hour", 60 * 60 * 1000 * 1000LL },
367  { "hours", 60 * 60 * 1000 * 1000LL },
368  { "d", 24 * 60 * 60 * 1000LL * 1000LL },
369  { "day", 24 * 60 * 60 * 1000LL * 1000LL },
370  { "days", 24 * 60 * 60 * 1000LL * 1000LL },
371  { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
372  { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
373  { "year", 31536000000000LL /* year */ },
374  { "years", 31536000000000LL /* year */ },
375  { "a", 31536000000000LL /* year */ },
376  { NULL, 0 } };
377  int ret;
378  unsigned long long val;
379 
380  if (0 == strcasecmp("forever", fancy_time))
381  {
383  return GNUNET_OK;
384  }
385  ret = convert_with_table(fancy_time, table, &val);
386  rtime->rel_value_us = (uint64_t)val;
387  return ret;
388 }
uint64_t rel_value_us
The actual value.
static int 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:259
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
static struct PeerEntry ** table
Table with our interned peer IDs.
Definition: peer.c:54
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Unit conversion table entry for 'convert_with_table'.
Definition: strings.c:234
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 175 of file strings.c.

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

Referenced by progress_cb(), and publish_inspector().

176 {
177  const char *unit = _(/* size unit */ "b");
178  char *ret;
179 
180  if (size > 5 * 1024)
181  {
182  size = size / 1024;
183  unit = "KiB";
184  if (size > 5 * 1024)
185  {
186  size = size / 1024;
187  unit = "MiB";
188  if (size > 5 * 1024)
189  {
190  size = size / 1024;
191  unit = "GiB";
192  if (size > 5 * 1024)
193  {
194  size = size / 1024;
195  unit = "TiB";
196  }
197  }
198  }
199  }
200  ret = GNUNET_malloc(32);
201  GNUNET_snprintf(ret, 32, "%llu %s", size, unit);
202  return ret;
203 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static unsigned int size
Size of the "table".
Definition: peer.c:66
#define GNUNET_malloc(size)
Wrapper around malloc.
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 orignal string is returned.

Definition at line 446 of file strings.c.

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

Referenced by GNUNET_STRINGS_from_utf8(), and GNUNET_STRINGS_to_utf8().

450 {
451  char *ret;
452  uint8_t *u8_string;
453  char *encoded_string;
454  size_t u8_string_length;
455  size_t encoded_string_length;
456 
457  u8_string = u8_conv_from_encoding(input_charset,
458  iconveh_error,
459  input,
460  len,
461  NULL,
462  NULL,
463  &u8_string_length);
464  if (NULL == u8_string)
465  {
466  LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
467  goto fail;
468  }
469  if (0 == strcmp(output_charset, "UTF-8"))
470  {
471  ret = GNUNET_malloc(u8_string_length + 1);
472  GNUNET_memcpy(ret, u8_string, u8_string_length);
473  ret[u8_string_length] = '\0';
474  free(u8_string);
475  return ret;
476  }
477  encoded_string = u8_conv_to_encoding(output_charset,
478  iconveh_error,
479  u8_string,
480  u8_string_length,
481  NULL,
482  NULL,
483  &encoded_string_length);
484  free(u8_string);
485  if (NULL == encoded_string)
486  {
487  LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
488  goto fail;
489  }
490  ret = GNUNET_malloc(encoded_string_length + 1);
491  GNUNET_memcpy(ret, encoded_string, encoded_string_length);
492  ret[encoded_string_length] = '\0';
493  free(encoded_string);
494  return ret;
495 fail:
497  _("Character sets requested were `%s'->`%s'\n"),
498  "UTF-8",
499  output_charset);
500  ret = GNUNET_malloc(len + 1);
501  GNUNET_memcpy(ret, input, len);
502  ret[len] = '\0';
503  return ret;
504 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define LOG(kind,...)
Definition: strings.c:37
#define LOG_STRERROR(kind, syscall)
Definition: strings.c:39
#define GNUNET_malloc(size)
Wrapper around malloc.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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)
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), if conversion fails, a copy of the orignal string is returned.

Definition at line 520 of file strings.c.

References GNUNET_STRINGS_conv().

521 {
522  return GNUNET_STRINGS_conv(input, len, charset, "UTF-8");
523 }
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:446
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call 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 orignal string is returned.

Definition at line 538 of file strings.c.

References GNUNET_STRINGS_conv().

539 {
540  return GNUNET_STRINGS_conv(input, len, "UTF-8", charset);
541 }
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:446
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:

◆ GNUNET_STRINGS_utf8_tolower()

void 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

Convert the utf-8 input string to lower case.

Output needs to be allocated appropriately.

Parameters
inputinput string
outputoutput buffer

Definition at line 552 of file strings.c.

References GNUNET_memcpy, and len.

Referenced by ego_create(), GNUNET_GNSRECORD_string_to_lowercase(), GNUNET_RECLAIM_ATTRIBUTE_claim_new(), handle_collect(), handle_create_message(), handle_delete_message(), handle_get_default_message(), handle_lookup(), handle_rename_message(), handle_set_default_message(), handle_verify(), header_iterator(), and run_with_zone_pkey().

553 {
554  uint8_t *tmp_in;
555  size_t len;
556 
557  tmp_in = u8_tolower((uint8_t *)input,
558  strlen((char *)input),
559  NULL,
560  UNINORM_NFD,
561  NULL,
562  &len);
563  GNUNET_memcpy(output, tmp_in, len);
564  output[len] = '\0';
565  free(tmp_in);
566 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function:

◆ GNUNET_STRINGS_utf8_toupper()

void 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

Convert the utf-8 input string to upper case.

Output needs to be allocated appropriately.

Parameters
inputinput string
outputoutput buffer

Definition at line 577 of file strings.c.

References GNUNET_memcpy, and len.

Referenced by client_configure_plugin(), GNUNET_CRYPTO_hash_from_string2(), GNUNET_HOSTLIST_client_start(), libgnunet_plugin_ats_mlp_init(), libgnunet_plugin_ats_ril_init(), and load_op_add_address().

578 {
579  uint8_t *tmp_in;
580  size_t len;
581 
582  tmp_in = u8_toupper((uint8_t *)input,
583  strlen((char *)input),
584  NULL,
585  UNINORM_NFD,
586  NULL,
587  &len);
588  GNUNET_memcpy(output, tmp_in, len);
589  output[len] = '\0';
590  free(tmp_in);
591 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
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 602 of file strings.c.

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

Referenced by check_client_index_start(), GNUNET_CONFIGURATION_get_value_filename(), 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_DISK_file_test(), GNUNET_FS_directory_scan_start(), GNUNET_FS_make_file_reader_context_(), GNUNET_log_setup(), handle_client_index_start(), hash_for_index_cb(), print_option(), and set_filename().

603 {
604  char *buffer;
605  size_t len;
606  char *fm;
607  const char *fil_ptr;
608 
609  if (fil == NULL)
610  return NULL;
611 
612  if (fil[0] == DIR_SEPARATOR)
613  /* absolute path, just copy */
614  return GNUNET_strdup(fil);
615  if (fil[0] == '~')
616  {
617  fm = getenv("HOME");
618  if (fm == NULL)
619  {
621  _("Failed to expand `$HOME': environment variable `HOME' not set"));
622  return NULL;
623  }
624  fm = GNUNET_strdup(fm);
625  /* do not copy '~' */
626  fil_ptr = fil + 1;
627 
628  /* skip over dir seperator to be consistent */
629  if (fil_ptr[0] == DIR_SEPARATOR)
630  fil_ptr++;
631  }
632  else
633  {
634  /* relative path */
635  fil_ptr = fil;
636  len = 512;
637  fm = NULL;
638  while (1)
639  {
640  buffer = GNUNET_malloc(len);
641  if (getcwd(buffer, len) != NULL)
642  {
643  fm = buffer;
644  break;
645  }
646  if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
647  {
648  len *= 2;
649  GNUNET_free(buffer);
650  continue;
651  }
652  GNUNET_free(buffer);
653  break;
654  }
655  if (fm == NULL)
656  {
658  buffer = getenv("PWD"); /* alternative */
659  if (buffer != NULL)
660  fm = GNUNET_strdup(buffer);
661  }
662  if (fm == NULL)
663  fm = GNUNET_strdup("./"); /* give up */
664  }
665  GNUNET_asprintf(&buffer,
666  "%s%s%s",
667  fm,
668  (fm[strlen(fm) - 1] == DIR_SEPARATOR) ? ""
670  fil_ptr);
671  GNUNET_free(fm);
672  return buffer;
673 }
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#define DIR_SEPARATOR_STR
Definition: platform.h:168
#define LOG(kind,...)
Definition: strings.c:37
#define DIR_SEPARATOR
Definition: platform.h:167
char * getenv()
#define LOG_STRERROR(kind, syscall)
Definition: strings.c:39
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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)

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

References GNUNET_assert, and GNUNET_memcpy.

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

66 {
67  size_t needed;
68  size_t slen;
69  const char *s;
70  va_list ap;
71 
72  needed = 0;
73  va_start(ap, count);
74  while (count > 0)
75  {
76  s = va_arg(ap, const char *);
77 
78  slen = strlen(s) + 1;
79  if (buffer != NULL)
80  {
81  GNUNET_assert(needed + slen <= size);
82  GNUNET_memcpy(&buffer[needed], s, slen);
83  }
84  needed += slen;
85  count--;
86  }
87  va_end(ap);
88  return needed;
89 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static unsigned int size
Size of the "table".
Definition: peer.c:66
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.
Parameters
bufferthe buffer to parse
sizesize of the buffer
countnumber of strings to locate
Returns
offset of the character after the last 0-termination in the buffer, or 0 on error.

Definition at line 135 of file strings.c.

References start.

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

139 {
140  unsigned int start;
141  unsigned int needed;
142  const char **r;
143  va_list ap;
144 
145  needed = 0;
146  va_start(ap, count);
147  while (count > 0)
148  {
149  r = va_arg(ap, const char **);
150 
151  start = needed;
152  while ((needed < size) && (buffer[needed] != '\0'))
153  needed++;
154  if (needed == size)
155  {
156  va_end(ap);
157  return 0; /* error */
158  }
159  *r = &buffer[start];
160  needed++; /* skip 0-termination */
161  count--;
162  }
163  va_end(ap);
164  return needed;
165 }
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static unsigned int size
Size of the "table".
Definition: peer.c:66
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 776 of file strings.c.

References DIR_SEPARATOR_STR, and filename.

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

777 {
778  const char *short_fn = filename;
779  const char *ss;
780 
781  while (NULL != (ss = strstr(short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
782  short_fn = 1 + ss;
783  return short_fn;
784 }
#define DIR_SEPARATOR_STR
Definition: platform.h:168
static char * filename
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.

Convert binary data to ASCII encoding using CrockfordBase32.

Returns a pointer to the byte after the last byte in the string, that is where the 0-terminator was placed if there was room.

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 + 4) / 5 bytes
Returns
pointer to the next byte in out or NULL on error.

32 characters for encoding

Definition at line 857 of file strings.c.

References data, GNUNET_assert, and GNUNET_break.

Referenced by auth_key_to_string(), 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_sh2s(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_uuid2s(), output_message(), print_examples_ecdh(), secret_ready_cb(), uri_loc_to_string(), and uri_sks_to_string().

861 {
865  static char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
866  unsigned int wpos;
867  unsigned int rpos;
868  unsigned int bits;
869  unsigned int vbit;
870  const unsigned char *udata;
871 
872  udata = data;
873  if (out_size < (size * 8 + 4) / 5)
874  {
875  GNUNET_break(0);
876  return NULL;
877  }
878  vbit = 0;
879  wpos = 0;
880  rpos = 0;
881  bits = 0;
882  while ((rpos < size) || (vbit > 0))
883  {
884  if ((rpos < size) && (vbit < 5))
885  {
886  bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
887  vbit += 8;
888  }
889  if (vbit < 5)
890  {
891  bits <<= (5 - vbit); /* zero-padding */
892  GNUNET_assert(vbit == ((size * 8) % 5));
893  vbit = 5;
894  }
895  if (wpos >= out_size)
896  {
897  GNUNET_break(0);
898  return NULL;
899  }
900  out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
901  vbit -= 5;
902  }
903  GNUNET_assert(0 == vbit);
904  if (wpos < out_size)
905  out[wpos] = '\0';
906  return &out[wpos];
907 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static unsigned int size
Size of the "table".
Definition: peer.c:66
uint32_t data
The data value.
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

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

Parameters
bufferwith data
sizesize of the buffer
Returns
freshly allocated, null-terminated string

Definition at line 921 of file strings.c.

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

Referenced by attr_collect(), attr_store_task(), conversation_value_to_string(), GNUNET_CURL_job_add2(), GNUNET_JSON_from_data(), handle_attribute_delete_message(), issue_ticket(), iter_cb(), lookup_authz_cb(), move_attr_finished(), move_attrs(), OIDC_id_token_new(), oidc_ticket_issue_cb(), process_attrs(), process_record(), RECLAIM_TICKETS_consume(), RECLAIM_TICKETS_revoke(), rvk_move_attr_cb(), ticket_collect(), ticket_issue_cb(), ticket_iter(), and value_to_string().

922 {
923  char *str_buf;
924  size_t len = size * 8;
925  char *end;
926 
927  if (len % 5 > 0)
928  len += 5 - len % 5;
929  len /= 5;
930  str_buf = GNUNET_malloc(len + 1);
931  end = GNUNET_STRINGS_data_to_string(buf, size, str_buf, len);
932  if (NULL == end)
933  {
934  GNUNET_free(str_buf);
935  return NULL;
936  }
937  *end = '\0';
938  return str_buf;
939 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static char buf[2048]
static unsigned int size
Size of the "table".
Definition: peer.c:66
#define GNUNET_malloc(size)
Wrapper around malloc.
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 Crockford Base32 encoding.
Definition: strings.c:857
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_string_to_data()

int 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

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

References getValue__(), GNUNET_break, GNUNET_OK, GNUNET_SYSERR, and ret.

Referenced by check_authorization(), conversation_string_to_value(), delete_attribute_cont(), 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_HELLO_parse_uri(), lookup_redirect_uri_result(), parse_attr(), parse_fixed_data(), parse_rsa_public_key(), parse_rsa_signature(), parse_ticket(), parse_variable_data(), read_service_conf(), run(), set_base32(), start_process(), string_to_auth_key(), string_to_value(), uri_loc_parse(), and uri_sks_parse().

957 {
958  unsigned int rpos;
959  unsigned int wpos;
960  unsigned int bits;
961  unsigned int vbit;
962  int ret;
963  int shift;
964  unsigned char *uout;
965  unsigned int encoded_len = out_size * 8;
966 
967  if (0 == enclen)
968  {
969  if (0 == out_size)
970  return GNUNET_OK;
971  return GNUNET_SYSERR;
972  }
973  uout = out;
974  wpos = out_size;
975  rpos = enclen;
976  if ((encoded_len % 5) > 0)
977  {
978  vbit = encoded_len % 5; /* padding! */
979  shift = 5 - vbit;
980  bits = (ret = getValue__(enc[--rpos])) >> shift;
981  }
982  else
983  {
984  vbit = 5;
985  shift = 0;
986  bits = (ret = getValue__(enc[--rpos]));
987  }
988  if ((encoded_len + shift) / 5 != enclen)
989  return GNUNET_SYSERR;
990  if (-1 == ret)
991  return GNUNET_SYSERR;
992  while (wpos > 0)
993  {
994  if (0 == rpos)
995  {
996  GNUNET_break(0);
997  return GNUNET_SYSERR;
998  }
999  bits = ((ret = getValue__(enc[--rpos])) << vbit) | bits;
1000  if (-1 == ret)
1001  return GNUNET_SYSERR;
1002  vbit += 5;
1003  if (vbit >= 8)
1004  {
1005  uout[--wpos] = (unsigned char)bits;
1006  bits >>= 8;
1007  vbit -= 8;
1008  }
1009  }
1010  if ((0 != rpos) || (0 != vbit))
1011  return GNUNET_SYSERR;
1012  return GNUNET_OK;
1013 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static unsigned int getValue__(unsigned char a)
Get the decoded value corresponding to a character according to Crockford Base32 encoding.
Definition: strings.c:795
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static OpusEncoder * enc
OPUS encoder.
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
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 1856 of file strings.c.

References cvt, data, FILLCHAR, GNUNET_malloc, len, and ret.

Referenced by api_send(), base64_and_urlencode(), base64url_encode(), credential_to_json(), dns_value_to_string(), GNUNET_CREDENTIAL_credential_to_string(), GNUNET_HELLO_sign_address(), OIDC_access_token_new(), OIDC_id_token_new(), send_cred_response(), and store_and_free_entries().

1857 {
1858  const char *data = in;
1859  size_t ret;
1860  char *opt;
1861 
1862  ret = 0;
1863  opt = GNUNET_malloc(2 + (len * 4 / 3) + 8);
1864  for (size_t i = 0; i < len; ++i)
1865  {
1866  char c;
1867 
1868  c = (data[i] >> 2) & 0x3f;
1869  opt[ret++] = cvt[(int)c];
1870  c = (data[i] << 4) & 0x3f;
1871  if (++i < len)
1872  c |= (data[i] >> 4) & 0x0f;
1873  opt[ret++] = cvt[(int)c];
1874  if (i < len)
1875  {
1876  c = (data[i] << 2) & 0x3f;
1877  if (++i < len)
1878  c |= (data[i] >> 6) & 0x03;
1879  opt[ret++] = cvt[(int)c];
1880  }
1881  else
1882  {
1883  ++i;
1884  opt[ret++] = FILLCHAR;
1885  }
1886  if (i < len)
1887  {
1888  c = data[i] & 0x3f;
1889  opt[ret++] = cvt[(int)c];
1890  }
1891  else
1892  {
1893  opt[ret++] = FILLCHAR;
1894  }
1895  }
1896  *output = opt;
1897  return ret;
1898 }
#define FILLCHAR
******************** Base64 encoding
Definition: strings.c:1840
static int ret
Final status code.
Definition: gnunet-arm.c:89
static char * cvt
Definition: strings.c:1841
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 **  out 
)

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

References CHECK_CRLF, cvtfind, END, FILLCHAR, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, len, and ret.

Referenced by check_authorization(), database_setup(), dns_string_to_value(), GNUNET_CREDENTIAL_credential_from_string(), GNUNET_HELLO_extract_address(), json_to_credential(), listenAndDistribute(), and OIDC_parse_authz_code().

1921 {
1922  char *output;
1923  size_t ret = 0;
1924 
1925 #define CHECK_CRLF \
1926  while (data[i] == '\r' || data[i] == '\n') \
1927  { \
1928  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
1929  "ignoring CR/LF\n"); \
1930  i++; \
1931  if (i >= len) \
1932  goto END; \
1933  }
1934 
1935  output = GNUNET_malloc((len * 3 / 4) + 8);
1937  "base64_decode decoding len=%d\n",
1938  (int)len);
1939  for (size_t i = 0; i < len; ++i)
1940  {
1941  char c;
1942  char c1;
1943 
1944  CHECK_CRLF;
1945  if (FILLCHAR == data[i])
1946  break;
1947  c = (char)cvtfind(data[i]);
1948  ++i;
1949  CHECK_CRLF;
1950  c1 = (char)cvtfind(data[i]);
1951  c = (c << 2) | ((c1 >> 4) & 0x3);
1952  output[ret++] = c;
1953  if (++i < len)
1954  {
1955  CHECK_CRLF;
1956  c = data[i];
1957  if (FILLCHAR == c)
1958  break;
1959  c = (char)cvtfind(c);
1960  c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
1961  output[ret++] = c1;
1962  }
1963  if (++i < len)
1964  {
1965  CHECK_CRLF;
1966  c1 = data[i];
1967  if (FILLCHAR == c1)
1968  break;
1969 
1970  c1 = (char)cvtfind(c1);
1971  c = ((c << 6) & 0xc0) | c1;
1972  output[ret++] = c;
1973  }
1974  }
1975 END:
1976  *out = output;
1977  return ret;
1978 }
#define CHECK_CRLF
#define FILLCHAR
******************** Base64 encoding
Definition: strings.c:1840
#define cvtfind(a)
Definition: strings.c:1900
We&#39;re done processing.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_log(kind,...)
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function:

◆ GNUNET_STRINGS_pp2s()

char* GNUNET_STRINGS_pp2s ( const struct GNUNET_PeerIdentity pids,
unsigned int  num_pids 
)

Convert a peer path to a human-readable string.

Parameters
pidsarray of PIDs to convert to a string
num_pidslength of the pids array
Returns
string representing the array of pids

Definition at line 100 of file strings.c.

References buf, GNUNET_i2s(), GNUNET_malloc, and GNUNET_snprintf().

Referenced by handle_dht_p2p_put(), handle_dht_p2p_result(), handle_local_result(), and process_client_result().

102 {
103  char *buf;
104  size_t off;
105  size_t plen = num_pids * 5 + 1;
106 
107  off = 0;
108  buf = GNUNET_malloc(plen);
109  for (unsigned int i = 0; i < num_pids; i++)
110  {
111  off += GNUNET_snprintf(&buf[off],
112  plen - off,
113  "%s%s",
114  GNUNET_i2s(&pids[i]),
115  (i == num_pids - 1) ? "" : "-");
116  }
117  return buf;
118 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
static char buf[2048]
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_parse_uri()

int 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).
Parameters
pathpath to parse. Must be NULL-terminated.
scheme_parta pointer to 'char *' where a pointer 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 1033 of file strings.c.

References end, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_YES, and len.

Referenced by GNUNET_STRINGS_path_is_absolute().

1036 {
1037  size_t len;
1038  size_t i;
1039  int end;
1040  int pp_state = 0;
1041  const char *post_scheme_part = NULL;
1042 
1043  len = strlen(path);
1044  for (end = 0, i = 0; !end && i < len; i++)
1045  {
1046  switch (pp_state)
1047  {
1048  case 0:
1049  if ((path[i] == ':') && (i > 0))
1050  {
1051  pp_state += 1;
1052  continue;
1053  }
1054  if (!((path[i] >= 'A' && path[i] <= 'Z') ||
1055  (path[i] >= 'a' && path[i] <= 'z') ||
1056  (path[i] >= '0' && path[i] <= '9') || path[i] == '+' ||
1057  path[i] == '-' || (path[i] == '.')))
1058  end = 1;
1059  break;
1060 
1061  case 1:
1062  case 2:
1063  if (path[i] == '/')
1064  {
1065  pp_state += 1;
1066  continue;
1067  }
1068  end = 1;
1069  break;
1070 
1071  case 3:
1072  post_scheme_part = &path[i];
1073  end = 1;
1074  break;
1075 
1076  default:
1077  end = 1;
1078  }
1079  }
1080  if (post_scheme_part == NULL)
1081  return GNUNET_NO;
1082  if (scheme_part)
1083  {
1084  *scheme_part = GNUNET_malloc(post_scheme_part - path + 1);
1085  GNUNET_memcpy(*scheme_part, path, post_scheme_part - path);
1086  (*scheme_part)[post_scheme_part - path] = '\0';
1087  }
1088  if (path_part)
1089  *path_part = post_scheme_part;
1090  return GNUNET_YES;
1091 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_malloc(size)
Wrapper around malloc.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function:

◆ GNUNET_STRINGS_path_is_absolute()

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

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

References GNUNET_free_non_null, GNUNET_NO, GNUNET_STRINGS_parse_uri(), GNUNET_YES, and uri.

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

1113 {
1114  const char *post_scheme_path;
1115  int is_uri;
1116  char *uri;
1117  /* consider POSIX paths to be absolute too, even on W32,
1118  * as plibc expansion will fix them for us.
1119  */
1120  if (filename[0] == '/')
1121  return GNUNET_YES;
1122  if (can_be_uri)
1123  {
1124  is_uri = GNUNET_STRINGS_parse_uri(filename, &uri, &post_scheme_path);
1125  if (r_is_uri)
1126  *r_is_uri = is_uri;
1127  if (is_uri)
1128  {
1129  if (r_uri_scheme)
1130  *r_uri_scheme = uri;
1131  else
1132  GNUNET_free_non_null(uri);
1133 
1134  return GNUNET_STRINGS_path_is_absolute(post_scheme_path,
1135  GNUNET_NO,
1136  NULL,
1137  NULL);
1138  }
1139  }
1140  else
1141  {
1142  if (r_is_uri)
1143  *r_is_uri = GNUNET_NO;
1144  }
1145 
1146  return GNUNET_NO;
1147 }
int 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:1033
int 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&#39;s an URI.
Definition: strings.c:1109
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static char * filename
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_check_filename()

int 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

Perform checks on filename.

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

References 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, and S_ISLNK.

1161 {
1162  struct stat st;
1163 
1164  if ((NULL == filename) || (filename[0] == '\0'))
1165  return GNUNET_SYSERR;
1166  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
1168  return GNUNET_NO;
1169  if (0 != (checks &
1172  {
1173  if (0 != stat(filename, &st))
1174  {
1175  if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
1176  return GNUNET_NO;
1177  else
1178  return GNUNET_SYSERR;
1179  }
1180  }
1181  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
1182  if (!S_ISDIR(st.st_mode))
1183  return GNUNET_NO;
1184  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
1185  if (!S_ISLNK(st.st_mode))
1186  return GNUNET_NO;
1187  return GNUNET_YES;
1188 }
int 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&#39;s an URI.
Definition: strings.c:1109
Check that the path is an absolute path.
#define GNUNET_NO
Definition: gnunet_common.h:78
Check that it exists.
static char * filename
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define S_ISLNK(m)
Definition: disk.c:61
#define GNUNET_YES
Definition: gnunet_common.h:77
Check that it is a link.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
Check that it is a directory.
Here is the call graph for this function:

◆ GNUNET_STRINGS_to_address_ipv6()

int GNUNET_STRINGS_to_address_ipv6 ( const char *  zt_addr,
uint16_t  addrlen,
struct sockaddr_in6 *  r_buf 
)

Tries to convert zt_addr string to an IPv6 address.

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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1204 of file strings.c.

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

1207 {
1208  char zbuf[addrlen + 1];
1209  int ret;
1210  char *port_colon;
1211  unsigned int port;
1212  char dummy[2];
1213 
1214  if (addrlen < 6)
1215  return GNUNET_SYSERR;
1216  GNUNET_memcpy(zbuf, zt_addr, addrlen);
1217  if ('[' != zbuf[0])
1218  {
1220  _("IPv6 address did not start with `['\n"));
1221  return GNUNET_SYSERR;
1222  }
1223  zbuf[addrlen] = '\0';
1224  port_colon = strrchr(zbuf, ':');
1225  if (NULL == port_colon)
1226  {
1228  _("IPv6 address did contain ':' to separate port number\n"));
1229  return GNUNET_SYSERR;
1230  }
1231  if (']' != *(port_colon - 1))
1232  {
1233  GNUNET_log(
1235  _("IPv6 address did contain ']' before ':' to separate port number\n"));
1236  return GNUNET_SYSERR;
1237  }
1238  ret = sscanf(port_colon, ":%u%1s", &port, dummy);
1239  if ((1 != ret) || (port > 65535))
1240  {
1241  GNUNET_log(
1243  _("IPv6 address did contain a valid port number after the last ':'\n"));
1244  return GNUNET_SYSERR;
1245  }
1246  *(port_colon - 1) = '\0';
1247  memset(r_buf, 0, sizeof(struct sockaddr_in6));
1248  ret = inet_pton(AF_INET6, &zbuf[1], &r_buf->sin6_addr);
1249  if (ret <= 0)
1250  {
1252  _("Invalid IPv6 address `%s': %s\n"),
1253  &zbuf[1],
1254  strerror(errno));
1255  return GNUNET_SYSERR;
1256  }
1257  r_buf->sin6_port = htons(port);
1258  r_buf->sin6_family = AF_INET6;
1259 #if HAVE_SOCKADDR_IN_SIN_LEN
1260  r_buf->sin6_len = (u_char)sizeof(struct sockaddr_in6);
1261 #endif
1262  return GNUNET_OK;
1263 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
#define GNUNET_log(kind,...)
Here is the caller graph for this function:

◆ GNUNET_STRINGS_to_address_ipv4()

int GNUNET_STRINGS_to_address_ipv4 ( const char *  zt_addr,
uint16_t  addrlen,
struct sockaddr_in *  r_buf 
)

Tries to convert zt_addr string to an IPv4 address.

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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1278 of file strings.c.

References dummy, GNUNET_OK, GNUNET_SYSERR, and port.

Referenced by GNUNET_STRINGS_parse_socket_addr(), and GNUNET_STRINGS_to_address_ip().

1281 {
1282  unsigned int temps[4];
1283  unsigned int port;
1284  unsigned int cnt;
1285  char dummy[2];
1286 
1287  if (addrlen < 9)
1288  return GNUNET_SYSERR;
1289  cnt = sscanf(zt_addr,
1290  "%u.%u.%u.%u:%u%1s",
1291  &temps[0],
1292  &temps[1],
1293  &temps[2],
1294  &temps[3],
1295  &port,
1296  dummy);
1297  if (5 != cnt)
1298  return GNUNET_SYSERR;
1299  for (cnt = 0; cnt < 4; cnt++)
1300  if (temps[cnt] > 0xFF)
1301  return GNUNET_SYSERR;
1302  if (port > 65535)
1303  return GNUNET_SYSERR;
1304  r_buf->sin_family = AF_INET;
1305  r_buf->sin_port = htons(port);
1306  r_buf->sin_addr.s_addr =
1307  htonl((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
1308 #if HAVE_SOCKADDR_IN_SIN_LEN
1309  r_buf->sin_len = (u_char)sizeof(struct sockaddr_in);
1310 #endif
1311  return GNUNET_OK;
1312 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
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 (i.e. AF_INET)
[out]saset to the parsed address
Returns
0 on error, otherwise number of bytes in sa

Definition at line 1351 of file strings.c.

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

Referenced by run().

1354 {
1355  char *cp = GNUNET_strdup(addr);
1356 
1357  *af = AF_UNSPEC;
1358  if ('[' == *addr)
1359  {
1360  /* IPv6 */
1361  *sa = GNUNET_malloc(sizeof(struct sockaddr_in6));
1362  if (GNUNET_OK !=
1364  strlen(cp),
1365  (struct sockaddr_in6 *)*sa))
1366  {
1367  GNUNET_free(*sa);
1368  *sa = NULL;
1369  GNUNET_free(cp);
1370  return 0;
1371  }
1372  *af = AF_INET6;
1373  GNUNET_free(cp);
1374  return sizeof(struct sockaddr_in6);
1375  }
1376  else
1377  {
1378  /* IPv4 */
1379  *sa = GNUNET_malloc(sizeof(struct sockaddr_in));
1380  if (GNUNET_OK !=
1382  strlen(cp),
1383  (struct sockaddr_in *)*sa))
1384  {
1385  GNUNET_free(*sa);
1386  *sa = NULL;
1387  GNUNET_free(cp);
1388  return 0;
1389  }
1390  *af = AF_INET;
1391  GNUNET_free(cp);
1392  return sizeof(struct sockaddr_in);
1393  }
1394 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
int GNUNET_STRINGS_to_address_ipv4(const char *zt_addr, uint16_t addrlen, struct sockaddr_in *r_buf)
Tries to convert &#39;zt_addr&#39; string to an IPv4 address.
Definition: strings.c:1278
int GNUNET_STRINGS_to_address_ipv6(const char *zt_addr, uint16_t addrlen, struct sockaddr_in6 *r_buf)
Tries to convert zt_addr string to an IPv6 address.
Definition: strings.c:1204
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_to_address_ip()

int 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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

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 succeded. GNUNET_SYSERR otherwise, in which case the contents of r_buf are undefined.

Definition at line 1327 of file strings.c.

References GNUNET_STRINGS_to_address_ipv4(), and GNUNET_STRINGS_to_address_ipv6().

Referenced by http_common_socket_from_address(), tcp_plugin_string_to_address(), and udp_string_to_address().

1330 {
1331  if (addr[0] == '[')
1332  return GNUNET_STRINGS_to_address_ipv6(addr,
1333  addrlen,
1334  (struct sockaddr_in6 *)r_buf);
1335  return GNUNET_STRINGS_to_address_ipv4(addr,
1336  addrlen,
1337  (struct sockaddr_in *)r_buf);
1338 }
int GNUNET_STRINGS_to_address_ipv4(const char *zt_addr, uint16_t addrlen, struct sockaddr_in *r_buf)
Tries to convert &#39;zt_addr&#39; string to an IPv4 address.
Definition: strings.c:1278
int GNUNET_STRINGS_to_address_ipv6(const char *zt_addr, uint16_t addrlen, struct sockaddr_in6 *r_buf)
Tries to convert zt_addr string to an IPv6 address.
Definition: strings.c:1204
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_STRINGS_get_utf8_args()

int GNUNET_STRINGS_get_utf8_args ( int  argc,
char *const *  argv,
int *  u8argc,
char *const **  u8argv 
)

Returns utf-8 encoded arguments.

Does nothing (returns a copy of argc and argv) on any platform other than W32. Returned argv has u8argv[u8argc] == NULL. Returned argv is a single memory block, and can be freed with a single GNUNET_free() call.

Parameters
argcargc (as given by main())
argvargv (as given by main())
u8argca location to store new argc in (though it's th same as argc)
u8argva location to store new argv in
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Does nothing (returns a copy of argc and argv) on any platform other than W32. Returned argv has u8argv[u8argc] == NULL. Returned argv is a single memory block, and can be freed with a single GNUNET_free() call.

Parameters
argcargc (as given by main())
argvargv (as given by main())
u8argca location to store new argc in (though it's th same as argc)
u8argva location to store new argv in
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1439 of file strings.c.

References _make_continuous_arg_copy(), and GNUNET_OK.

Referenced by main().

1443 {
1444  char *const *new_argv =
1445  (char *const *)_make_continuous_arg_copy(argc, argv);
1446  *u8argv = new_argv;
1447  *u8argc = argc;
1448  return GNUNET_OK;
1449 }
static char *const * _make_continuous_arg_copy(int argc, char *const *argv)
Makes a copy of argv that consists of a single memory chunk that can be freed with a single call to G...
Definition: strings.c:1402
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Here is the call graph for this function:
Here is the caller 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

The given string src is copied until its null byte or until n - 1 bytes have been read. The destination buffer is guaranteed to be null-terminated.

Parameters
dstdestination of the copy (must be n bytes long)
srcsource of the copy (at most n - 1 bytes will be read)
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 219 of file strings.c.

References GNUNET_assert, and strnlen().

Referenced by add_unixpath(), create_keys(), GCP_2s(), GNUNET_CONNECTION_create_from_connect_to_unixpath(), GNUNET_i2s(), GNUNET_i2s2(), GNUNET_TESTBED_hosts_load_from_file(), handle_add_host(), handle_remote_overlay_connect(), mylog(), regex_split(), tokenizer_cb(), and try_unixpath().

220 {
221  size_t slen;
222 
223  GNUNET_assert(0 != n);
224  slen = strnlen(src, n - 1);
225  memcpy(dst, src, slen);
226  dst[slen] = '\0';
227  return slen;
228 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static size_t strnlen(const char *s, size_t n)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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 synatx is flawed

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 synatx is flawed

Definition at line 1519 of file strings.c.

References _, dummy, end, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, len, LOG, GNUNET_STRINGS_IPv4NetworkPolicy::netmask, GNUNET_STRINGS_IPv4NetworkPolicy::network, parse_port_policy(), GNUNET_STRINGS_IPv4NetworkPolicy::pp, and result.

Referenced by GNUNET_TUN_ipv4policy2regex(), and process_acl4().

1520 {
1521  unsigned int count;
1522  unsigned int i;
1523  unsigned int j;
1524  unsigned int len;
1525  int cnt;
1526  unsigned int pos;
1527  unsigned int temps[8];
1528  int slash;
1530  int colon;
1531  int end;
1532  char *routeList;
1533  char dummy[2];
1534 
1535  if (NULL == routeListX)
1536  return NULL;
1537  len = strlen(routeListX);
1538  if (0 == len)
1539  return NULL;
1540  routeList = GNUNET_strdup(routeListX);
1541  count = 0;
1542  for (i = 0; i < len; i++)
1543  if (routeList[i] == ';')
1544  count++;
1545  result = GNUNET_malloc(sizeof(struct GNUNET_STRINGS_IPv4NetworkPolicy) *
1546  (count + 1));
1547  i = 0;
1548  pos = 0;
1549  while (i < count)
1550  {
1551  for (colon = pos; ':' != routeList[colon]; colon++)
1552  if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
1553  break;
1554  for (end = colon; ';' != routeList[end]; end++)
1555  if ('\0' == routeList[end])
1556  break;
1557  if ('\0' == routeList[end])
1558  break;
1559  routeList[end] = '\0';
1560  if (':' == routeList[colon])
1561  {
1562  routeList[colon] = '\0';
1563  if (GNUNET_OK != parse_port_policy(&routeList[colon + 1], &result[i].pp))
1564  break;
1565  }
1566  cnt = sscanf(&routeList[pos],
1567  "%u.%u.%u.%u/%u.%u.%u.%u%1s",
1568  &temps[0],
1569  &temps[1],
1570  &temps[2],
1571  &temps[3],
1572  &temps[4],
1573  &temps[5],
1574  &temps[6],
1575  &temps[7],
1576  dummy);
1577  if (8 == cnt)
1578  {
1579  for (j = 0; j < 8; j++)
1580  if (temps[j] > 0xFF)
1581  {
1583  _("Invalid format for IP: `%s'\n"),
1584  &routeList[pos]);
1585  GNUNET_free(result);
1586  GNUNET_free(routeList);
1587  return NULL;
1588  }
1589  result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
1590  (temps[2] << 8) + temps[3]);
1591  result[i].netmask.s_addr = htonl((temps[4] << 24) + (temps[5] << 16) +
1592  (temps[6] << 8) + temps[7]);
1593  pos = end + 1;
1594  i++;
1595  continue;
1596  }
1597  /* try second notation */
1598  cnt = sscanf(&routeList[pos],
1599  "%u.%u.%u.%u/%u%1s",
1600  &temps[0],
1601  &temps[1],
1602  &temps[2],
1603  &temps[3],
1604  &slash,
1605  dummy);
1606  if (5 == cnt)
1607  {
1608  for (j = 0; j < 4; j++)
1609  if (temps[j] > 0xFF)
1610  {
1612  _("Invalid format for IP: `%s'\n"),
1613  &routeList[pos]);
1614  GNUNET_free(result);
1615  GNUNET_free(routeList);
1616  return NULL;
1617  }
1618  result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
1619  (temps[2] << 8) + temps[3]);
1620  if ((slash <= 32) && (slash >= 0))
1621  {
1622  result[i].netmask.s_addr = 0;
1623  while (slash > 0)
1624  {
1625  result[i].netmask.s_addr =
1626  (result[i].netmask.s_addr >> 1) + 0x80000000;
1627  slash--;
1628  }
1629  result[i].netmask.s_addr = htonl(result[i].netmask.s_addr);
1630  pos = end + 1;
1631  i++;
1632  continue;
1633  }
1634  else
1635  {
1637  _("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
1638  slash);
1639  GNUNET_free(result);
1640  GNUNET_free(routeList);
1641  return NULL; /* error */
1642  }
1643  }
1644  /* try third notation */
1645  slash = 32;
1646  cnt = sscanf(&routeList[pos],
1647  "%u.%u.%u.%u%1s",
1648  &temps[0],
1649  &temps[1],
1650  &temps[2],
1651  &temps[3],
1652  dummy);
1653  if (4 == cnt)
1654  {
1655  for (j = 0; j < 4; j++)
1656  if (temps[j] > 0xFF)
1657  {
1659  _("Invalid format for IP: `%s'\n"),
1660  &routeList[pos]);
1661  GNUNET_free(result);
1662  GNUNET_free(routeList);
1663  return NULL;
1664  }
1665  result[i].network.s_addr = htonl((temps[0] << 24) + (temps[1] << 16) +
1666  (temps[2] << 8) + temps[3]);
1667  result[i].netmask.s_addr = 0;
1668  while (slash > 0)
1669  {
1670  result[i].netmask.s_addr = (result[i].netmask.s_addr >> 1) + 0x80000000;
1671  slash--;
1672  }
1673  result[i].netmask.s_addr = htonl(result[i].netmask.s_addr);
1674  pos = end + 1;
1675  i++;
1676  continue;
1677  }
1679  _("Invalid format for IP: `%s'\n"),
1680  &routeList[pos]);
1681  GNUNET_free(result);
1682  GNUNET_free(routeList);
1683  return NULL; /* error */
1684  }
1685  if (pos < strlen(routeList))
1686  {
1688  _("Invalid format: `%s'\n"),
1689  &routeListX[pos]);
1690  GNUNET_free(result);
1691  GNUNET_free(routeList);
1692  return NULL; /* oops */
1693  }
1694  GNUNET_free(routeList);
1695  return result; /* ok */
1696 }
static int parse_port_policy(const char *port_policy, struct GNUNET_STRINGS_PortPolicy *pp)
Parse the given port policy.
Definition: strings.c:1462
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
struct in_addr netmask
IPv4 netmask.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct in_addr network
IPv4 address.
IPV4 network in CIDR notation.
static int result
Global testing status.
#define LOG(kind,...)
Definition: strings.c:37
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 synatx is flawed

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 synatx is flawed

Definition at line 1711 of file strings.c.

References _, dummy, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, len, 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_TUN_ipv6policy2regex(), and process_acl6().

1712 {
1713  unsigned int count;
1714  unsigned int i;
1715  unsigned int len;
1716  unsigned int pos;
1717  int start;
1718  int slash;
1719  int ret;
1720  char *routeList;
1722  unsigned int bits;
1723  unsigned int off;
1724  int save;
1725  int colon;
1726  char dummy[2];
1727 
1728  if (NULL == routeListX)
1729  return NULL;
1730  len = strlen(routeListX);
1731  if (0 == len)
1732  return NULL;
1733  routeList = GNUNET_strdup(routeListX);
1734  count = 0;
1735  for (i = 0; i < len; i++)
1736  if (';' == routeList[i])
1737  count++;
1738  if (';' != routeList[len - 1])
1739  {
1741  _("Invalid network notation (does not end with ';': `%s')\n"),
1742  routeList);
1743  GNUNET_free(routeList);
1744  return NULL;
1745  }
1746 
1747  result = GNUNET_malloc(sizeof(struct GNUNET_STRINGS_IPv6NetworkPolicy) *
1748  (count + 1));
1749  i = 0;
1750  pos = 0;
1751  while (i < count)
1752  {
1753  start = pos;
1754  while (';' != routeList[pos])
1755  pos++;
1756  slash = pos;
1757  while ((slash >= start) && (routeList[slash] != '/'))
1758  slash--;
1759 
1760  if (slash < start)
1761  {
1762  memset(&result[i].netmask, 0xFF, sizeof(struct in6_addr));
1763  slash = pos;
1764  }
1765  else
1766  {
1767  routeList[pos] = '\0';
1768  for (colon = pos; ':' != routeList[colon]; colon--)
1769  if ('/' == routeList[colon])
1770  break;
1771  if (':' == routeList[colon])
1772  {
1773  routeList[colon] = '\0';
1774  if (GNUNET_OK !=
1775  parse_port_policy(&routeList[colon + 1], &result[i].pp))
1776  {
1777  GNUNET_free(result);
1778  GNUNET_free(routeList);
1779  return NULL;
1780  }
1781  }
1782  ret = inet_pton(AF_INET6, &routeList[slash + 1], &result[i].netmask);
1783  if (ret <= 0)
1784  {
1785  save = errno;
1786  if ((1 != sscanf(&routeList[slash + 1], "%u%1s", &bits, dummy)) ||
1787  (bits > 128))
1788  {
1789  if (0 == ret)
1791  _("Wrong format `%s' for netmask\n"),
1792  &routeList[slash + 1]);
1793  else
1794  {
1795  errno = save;
1797  }
1798  GNUNET_free(result);
1799  GNUNET_free(routeList);
1800  return NULL;
1801  }
1802  off = 0;
1803  while (bits > 8)
1804  {
1805  result[i].netmask.s6_addr[off++] = 0xFF;
1806  bits -= 8;
1807  }
1808  while (bits > 0)
1809  {
1810  result[i].netmask.s6_addr[off] =
1811  (result[i].netmask.s6_addr[off] >> 1) + 0x80;
1812  bits--;
1813  }
1814  }
1815  }
1816  routeList[slash] = '\0';
1817  ret = inet_pton(AF_INET6, &routeList[start], &result[i].network);
1818  if (ret <= 0)
1819  {
1820  if (0 == ret)
1822  _("Wrong format `%s' for network\n"),
1823  &routeList[slash + 1]);
1824  else
1825  LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "inet_pton");
1826  GNUNET_free(result);
1827  GNUNET_free(routeList);
1828  return NULL;
1829  }
1830  pos++;
1831  i++;
1832  }
1833  GNUNET_free(routeList);
1834  return result;
1835 }
static int parse_port_policy(const char *port_policy, struct GNUNET_STRINGS_PortPolicy *pp)
Parse the given port policy.
Definition: strings.c:1462
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
network in CIDR notation for IPV6.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
static void save()
Write persistent statistics to disk.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct in6_addr netmask
IPv6 netmask.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static int result
Global testing status.
#define LOG(kind,...)
Definition: strings.c:37
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
#define LOG_STRERROR(kind, syscall)
Definition: strings.c:39
struct in6_addr network
IPv6 address.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function: