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 (const char *data, size_t 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, uint16_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, 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...
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...
enum GNUNET_GenericReturnValue	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_IPv4NetworkPolicy *	GNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
	Parse an IPv4 network policy. More...
struct GNUNET_STRINGS_IPv6NetworkPolicy *	GNUNET_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

enum 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 530 of file gnunet_strings_lib.h.

{
  GNUNET_STRINGS_CHECK_EXISTS = 0x00000001,
 
  GNUNET_STRINGS_CHECK_IS_DIRECTORY = 0x00000002,
 
  GNUNET_STRINGS_CHECK_IS_LINK = 0x00000004,
 
  GNUNET_STRINGS_CHECK_IS_ABSOLUTE = 0x00000008
};

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_size	human readable string (e.g. 1 MB)
size	set to the size in bytes

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 138 of file strings.c.

{
  static const struct ConversionTable table[] =
  { { "B", 1 },
    { "KiB", 1024 },
    { "kB", 1000 },
    { "MiB", 1024 * 1024 },
    { "MB", 1000 * 1000 },
    { "GiB", 1024 * 1024 * 1024 },
    { "GB", 1000 * 1000 * 1000 },
    { "TiB", 1024LL * 1024LL * 1024LL * 1024LL },
    { "TB", 1000LL * 1000LL * 1000LL * 1024LL },
    { "PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
    { "PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
    { "EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
    { "EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
    { NULL, 0 } };
 
  return convert_with_table (fancy_size, table, size);
}

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

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_time	human readable string (e.g. 1 minute)
rtime	set to the relative time

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 138 of file strings.c.

{
  static const struct ConversionTable table[] =
  { { "us", 1 },
    { "ms", 1000 },
    { "s", 1000 * 1000LL },
    { "second", 1000 * 1000LL },
    { "seconds", 1000 * 1000LL },
    { "\"", 1000 * 1000LL },
    { "m", 60 * 1000 * 1000LL },
    { "min", 60 * 1000 * 1000LL },
    { "minute", 60 * 1000 * 1000LL },
    { "minutes", 60 * 1000 * 1000LL },
    { "'", 60 * 1000 * 1000LL },
    { "h", 60 * 60 * 1000 * 1000LL },
    { "hour", 60 * 60 * 1000 * 1000LL },
    { "hours", 60 * 60 * 1000 * 1000LL },
    { "d", 24 * 60 * 60 * 1000LL * 1000LL },
    { "day", 24 * 60 * 60 * 1000LL * 1000LL },
    { "days", 24 * 60 * 60 * 1000LL * 1000LL },
    { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
    { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
    { "year", 31536000000000LL /* year */ },
    { "years", 31536000000000LL /* year */ },
    { "a", 31536000000000LL /* year */ },
    { NULL, 0 } };
  int ret;
  unsigned long long val;
 
  if (0 == strcasecmp ("forever", fancy_time))
  {
    *rtime = GNUNET_TIME_UNIT_FOREVER_REL;
    return GNUNET_OK;
  }
  ret = convert_with_table (fancy_time, table, &val);
  rtime->rel_value_us = (uint64_t) val;
  return ret;
}

Referenced by create_did_ego_lockup_cb(), parse_expiration(), and run().

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

size	number of bytes

Returns

fancy representation of the size (possibly rounded) for humans

Definition at line 106 of file strings.c.

{
  const char *unit = /* size unit */ "b";
  char *ret;
 
  if (size > 5 * 1024)
  {
    size = size / 1024;
    unit = "KiB";
    if (size > 5 * 1024)
    {
      size = size / 1024;
      unit = "MiB";
      if (size > 5 * 1024)
      {
        size = size / 1024;
        unit = "GiB";
        if (size > 5 * 1024)
        {
          size = size / 1024;
          unit = "TiB";
        }
      }
    }
  }
  ret = GNUNET_malloc (32);
  GNUNET_snprintf (ret, 32, "%llu %s", size, unit);
  return ret;
}

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

input	input string
len	number of bytes in input
input_charset	character set used for input
output_charset	desired 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 343 of file strings.c.

{
  char *ret;
  uint8_t *u8_string;
  char *encoded_string;
  size_t u8_string_length;
  size_t encoded_string_length;
 
  u8_string = u8_conv_from_encoding (input_charset,
                                     iconveh_error,
                                     input,
                                     len,
                                     NULL,
                                     NULL,
                                     &u8_string_length);
  if (NULL == u8_string)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
    goto fail;
  }
  if (0 == strcmp (output_charset, "UTF-8"))
  {
    ret = GNUNET_malloc (u8_string_length + 1);
    GNUNET_memcpy (ret, u8_string, u8_string_length);
    ret[u8_string_length] = '\0';
    free (u8_string);
    return ret;
  }
  encoded_string = u8_conv_to_encoding (output_charset,
                                        iconveh_error,
                                        u8_string,
                                        u8_string_length,
                                        NULL,
                                        NULL,
                                        &encoded_string_length);
  free (u8_string);
  if (NULL == encoded_string)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
    goto fail;
  }
  ret = GNUNET_malloc (encoded_string_length + 1);
  GNUNET_memcpy (ret, encoded_string, encoded_string_length);
  ret[encoded_string_length] = '\0';
  free (encoded_string);
  return ret;
  fail:
  LOG (GNUNET_ERROR_TYPE_WARNING,
       _ ("Character sets requested were `%s'->`%s'\n"),
       "UTF-8",
       output_charset);
  ret = GNUNET_malloc (len + 1);
  GNUNET_memcpy (ret, input, len);
  ret[len] = '\0';
  return ret;
}

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

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

input	the input string (not necessarily 0-terminated)
len	the number of bytes in the input
charset	character set to convert from

Returns

the converted string (0-terminated)

Definition at line 405 of file strings.c.

{
  return GNUNET_STRINGS_conv (input,
                              len,
                              charset,
                              "UTF-8");
}

References GNUNET_STRINGS_conv(), and len.

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

input

input string

Returns

result (freshly allocated) or NULL on error.

Definition at line 429 of file strings.c.

{
  uint8_t *tmp;
  size_t len;
  char *output;
  tmp = u8_normalize (UNINORM_NFC,
                      (uint8_t *) input,
                      strlen ((char*) input),
                      NULL,
                      &len);
  if (NULL == tmp)
    return NULL;
  output = GNUNET_malloc (len + 1);
  GNUNET_memcpy (output, tmp, len);
  output[len] = '\0';
  free (tmp);
  return output;
}

References GNUNET_malloc, GNUNET_memcpy, and len.

Referenced by GNUNET_GNSRECORD_label_check().

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

input	the input string (not necessarily 0-terminated)
len	the number of bytes in the input
charset	character set to convert to

Returns

the converted string (0-terminated), if conversion fails, a copy of the original string is returned.

Definition at line 417 of file strings.c.

{
  return GNUNET_STRINGS_conv (input,
                              len,
                              "UTF-8",
                              charset);
}

References GNUNET_STRINGS_conv(), and len.

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

input	input string
output	output buffer

Returns

GNUNET_OK on success

Definition at line 429 of file strings.c.

{
  uint8_t *tmp_in;
  size_t len;
 
  tmp_in = u8_tolower ((uint8_t *) input,
                       strlen ((char *) input),
                       NULL,
                       UNINORM_NFD,
                       NULL,
                       &len);
  if (NULL == tmp_in)
    return GNUNET_SYSERR;
  GNUNET_memcpy (output, tmp_in, len);
  output[len] = '\0';
  GNUNET_free (tmp_in);
  return GNUNET_OK;
}

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

input	input string
output	output buffer

Returns

GNUNET_OK on success

Definition at line 429 of file strings.c.

{
  uint8_t *tmp_in;
  size_t len;
 
  tmp_in = u8_toupper ((uint8_t *) input,
                       strlen ((char *) input),
                       NULL,
                       UNINORM_NFD,
                       NULL,
                       &len);
  if (NULL == tmp_in)
    return GNUNET_SYSERR;
  /* 0-terminator does not fit */
  GNUNET_memcpy (output, tmp_in, len);
  output[len] = '\0';
  GNUNET_free (tmp_in);
  return GNUNET_OK;
}

Referenced by client_configure_plugin(), GNUNET_HOSTLIST_client_start(), and load_op_add_address().

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

fil	the 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 494 of file strings.c.

{
  char *buffer;
  size_t len;
  char *fm;
  const char *fil_ptr;
 
  if (fil == NULL)
    return NULL;
 
  if (fil[0] == DIR_SEPARATOR)
    /* absolute path, just copy */
    return GNUNET_strdup (fil);
  if (fil[0] == '~')
  {
    fm = getenv ("HOME");
    if (fm == NULL)
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           _ ("Failed to expand `$HOME': environment variable `HOME' not set"));
      return NULL;
    }
    fm = GNUNET_strdup (fm);
    /* do not copy '~' */
    fil_ptr = fil + 1;
 
    /* skip over dir separator to be consistent */
    if (fil_ptr[0] == DIR_SEPARATOR)
      fil_ptr++;
  }
  else
  {
    /* relative path */
    fil_ptr = fil;
    len = 512;
    fm = NULL;
    while (1)
    {
      buffer = GNUNET_malloc (len);
      if (getcwd (buffer, len) != NULL)
      {
        fm = buffer;
        break;
      }
      if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
      {
        len *= 2;
        GNUNET_free (buffer);
        continue;
      }
      GNUNET_free (buffer);
      break;
    }
    if (fm == NULL)
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "getcwd");
      buffer = getenv ("PWD");    /* alternative */
      if (buffer != NULL)
        fm = GNUNET_strdup (buffer);
    }
    if (fm == NULL)
      fm = GNUNET_strdup ("./");  /* give up */
  }
  GNUNET_asprintf (&buffer,
                   "%s%s%s",
                   fm,
                   (fm[strlen (fm) - 1] == DIR_SEPARATOR) ? ""
                   : DIR_SEPARATOR_STR,
                   fil_ptr);
  GNUNET_free (fm);
  return buffer;
}

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_load(), GNUNET_DISK_directory_scan(), GNUNET_DISK_file_close(), GNUNET_FS_directory_scan_start(), GNUNET_FS_make_file_reader_context_(), GNUNET_log_setup(), handle_client_index_start(), hash_for_index_cb(), and print_filename_option().

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

buffer	the buffer to fill with strings, can be NULL in which case only the necessary amount of space will be calculated
size	number of bytes available in buffer
count	number 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 44 of file strings.c.

{
  size_t needed;
  va_list ap;
 
  needed = 0;
  va_start (ap, count);
  while (count > 0)
  {
    const char *s = va_arg (ap, const char *);
    size_t slen = strlen (s) + 1;
 
    GNUNET_assert (slen <= size - needed);
    if (NULL != buffer)
      GNUNET_memcpy (&buffer[needed],
                     s,
                     slen);
    needed += slen;
    count--;
  }
  va_end (ap);
  return needed;
}

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

buffer	the buffer to parse
size	size of the buffer
count	number 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 72 of file strings.c.

{
  unsigned int start;
  unsigned int needed;
  const char **r;
  va_list ap;
 
  needed = 0;
  va_start (ap, count);
  while (count > 0)
  {
    r = va_arg (ap, const char **);
 
    start = needed;
    while ((needed < size) && (buffer[needed] != '\0'))
      needed++;
    if (needed == size)
    {
      va_end (ap);
      return 0;     /* error */
    }
    *r = &buffer[start];
    needed++;   /* skip 0-termination */
    count--;
  }
  va_end (ap);
  return needed;
}

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

filename

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

{
  const char *short_fn = filename;
  const char *ss;
 
  while (NULL != (ss = strstr (short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
    short_fn = 1 + ss;
  return short_fn;
}

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

data	data to encode
size	size of data (in bytes)
out	buffer to fill
out_size	size 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 708 of file strings.c.

{
  static char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
  unsigned int wpos;
  unsigned int rpos;
  unsigned int bits;
  unsigned int vbit;
  const unsigned char *udata;
 
  GNUNET_assert (size < SIZE_MAX / 8 - 4);
  udata = data;
  if (out_size < (size * 8 + 4) / 5)
  {
    GNUNET_break (0);
    return NULL;
  }
  vbit = 0;
  wpos = 0;
  rpos = 0;
  bits = 0;
  while ((rpos < size) || (vbit > 0))
  {
    if ((rpos < size) && (vbit < 5))
    {
      bits = (bits << 8) | udata[rpos++];     /* eat 8 more bits */
      vbit += 8;
    }
    if (vbit < 5)
    {
      bits <<= (5 - vbit);     /* zero-padding */
      GNUNET_assert (vbit == ((size * 8) % 5));
      vbit = 5;
    }
    if (wpos >= out_size)
    {
      GNUNET_break (0);
      return NULL;
    }
    out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
    vbit -= 5;
  }
  GNUNET_assert (0 == vbit);
  if (wpos < out_size)
    out[wpos] = '\0';
  return &out[wpos];
}

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

Referenced by auth_key_to_string(), channel_to_sh(), 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_from_string2(), GNUNET_GNSRECORD_z2s(), GNUNET_sh2s(), GNUNET_STRINGS_check_filename(), GNUNET_uuid2s(), output_message(), print_examples_ecdh(), run(), run_edkey(), run_pkey(), secret_ready_cb(), 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

buf	buffer with data
size	size of the buffer buf

Returns

freshly allocated, null-terminated string

Definition at line 763 of file strings.c.

{
  char *str_buf;
  size_t len = size * 8;
  char *end;
 
  if (len % 5 > 0)
    len += 5 - len % 5;
  len /= 5;
  str_buf = GNUNET_malloc (len + 1);
  end = GNUNET_STRINGS_data_to_string (buf,
                                       size,
                                       str_buf,
                                       len);
  if (NULL == end)
  {
    GNUNET_free (str_buf);
    return NULL;
  }
  *end = '\0';
  return str_buf;
}

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_HELLO_builder_add_address(), GNUNET_IDENTITY_private_key_from_string(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_JSON_from_data(), handle_attribute_delete_message(), handle_credential_delete_message(), issue_ticket(), iter_cb(), iterate_save_rooms(), lookup_authz_cb(), main(), messenger_value_to_string(), move_attr_finished(), move_attrs(), oidc_ticket_issue_cb(), process_attrs(), process_record(), purge_attributes(), RECLAIM_TICKETS_consume(), RECLAIM_TICKETS_revoke(), run(), rvk_move_attr_cb(), save_member(), save_operation(), setup_job_headers(), ticket_collect(), ticket_issue_cb(), ticket_iter(), value_to_string(), and write_encrypted_message().

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

enc	the encoding
enclen	number of characters in enc (without 0-terminator, which can be missing)
out	location where to store the decoded data
out_size	size of the output buffer out

Returns

GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 763 of file strings.c.

{
  size_t rpos;
  size_t wpos;
  unsigned int bits;
  unsigned int vbit;
  int ret;
  int shift;
  unsigned char *uout;
  size_t encoded_len;
 
  if (0 == enclen)
  {
    if (0 == out_size)
      return GNUNET_OK;
    return GNUNET_SYSERR;
  }
  GNUNET_assert (out_size < SIZE_MAX / 8);
  encoded_len = out_size * 8;
  uout = out;
  wpos = out_size;
  rpos = enclen;
  if ((encoded_len % 5) > 0)
  {
    vbit = encoded_len % 5;   /* padding! */
    shift = 5 - vbit;
    bits = (ret = getValue__ (enc[--rpos])) >> shift;
  }
  else
  {
    vbit = 5;
    shift = 0;
    bits = (ret = getValue__ (enc[--rpos]));
  }
  if ((encoded_len + shift) / 5 != enclen)
    return GNUNET_SYSERR;
  if (-1 == ret)
    return GNUNET_SYSERR;
  while (wpos > 0)
  {
    if (0 == rpos)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
    if (-1 == ret)
      return GNUNET_SYSERR;
    vbit += 5;
    if (vbit >= 8)
    {
      uout[--wpos] = (unsigned char) bits;
      bits >>= 8;
      vbit -= 8;
    }
  }
  if ((0 != rpos) || (0 != vbit))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

Referenced by check_authorization(), conversation_string_to_value(), delete_attribute_cont(), delete_credential_cont(), ego_create(), expect_data_dynamic(), expect_data_fixed(), GNUNET_HELLO_builder_from_url(), GNUNET_HELLO_parse_uri(), lookup_redirect_uri_result(), main(), messenger_string_to_value(), parse_attr(), parse_credential(), parse_ticket(), read_encrypted_message(), read_service_conf(), run(), start_process(), string_to_value(), uri_loc_parse(), and uri_sks_parse().

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

	enc	the encoding
	enclen	number of characters in enc (without 0-terminator, which can be missing)
[out]	out	location where to allocate and store the decoded data
[out]	out_size	set to the size of the output buffer out

Returns

GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding

Definition at line 763 of file strings.c.

{
  size_t size;
  void *data;
  int res;
 
  size = (enclen * 5) / 8;
  if (size >= GNUNET_MAX_MALLOC_CHECKED)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  data = GNUNET_malloc (size);
  res = GNUNET_STRINGS_string_to_data (enc,
                                       enclen,
                                       data,
                                       size);
  if ( (0 < size) &&
       (GNUNET_OK != res) )
  {
    size--;
    res = GNUNET_STRINGS_string_to_data (enc,
                                         enclen,
                                         data,
                                         size);
  }
  if (GNUNET_OK != res)
  {
    GNUNET_break_op (0);
    GNUNET_free (data);
    return GNUNET_SYSERR;
  }
  *out = data;
  *out_size = size;
  return GNUNET_OK;
}

Referenced by event_do_poll(), and read_encrypted_message().

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

data	the data to encode
len	the length of the input
output	where to write the output (*output should be NULL, is allocated)

Returns

the size of the output

Definition at line 1607 of file strings.c.

{
  const char *data = in;
  size_t ret;
  char *opt;
 
  ret = 0;
  GNUNET_assert (len < SIZE_MAX / 4 * 3);
  opt = GNUNET_malloc (2 + (len * 4 / 3) + 8);
  for (size_t i = 0; i < len; ++i)
  {
    char c;
 
    c = (data[i] >> 2) & 0x3f;
    opt[ret++] = cvt[(int) c];
    c = (data[i] << 4) & 0x3f;
    if (++i < len)
      c |= (data[i] >> 4) & 0x0f;
    opt[ret++] = cvt[(int) c];
    if (i < len)
    {
      c = (data[i] << 2) & 0x3f;
      if (++i < len)
        c |= (data[i] >> 6) & 0x03;
      opt[ret++] = cvt[(int) c];
    }
    else
    {
      ++i;
      opt[ret++] = FILLCHAR;
    }
    if (i < len)
    {
      c = data[i] & 0x3f;
      opt[ret++] = cvt[(int) c];
    }
    else
    {
      opt[ret++] = FILLCHAR;
    }
  }
  *output = opt;
  return ret;
}

References cvt, data, FILLCHAR, GNUNET_assert, GNUNET_malloc, consensus-simulation::int, len, ret, and SIZE_MAX.

Referenced by api_send(), 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	(	const char *	data,
		size_t	len,
		char **	out
	)

url/percent encode (RFC3986).

Parameters

data	the data to decode
len	the length of the input
out	where to write the output (*out should be NULL, is allocated)

Returns

the size of the output

Definition at line 1850 of file strings.c.

{
  struct GNUNET_Buffer buf = { 0 };
  const uint8_t *i8 = (uint8_t *) data;
 
  while (0 != *i8)
  {
    if (0 == (0x80 & *i8))
    {
      /* traditional ASCII */
      if (isalnum (*i8) || (*i8 == '-') || (*i8 == '_') || (*i8 == '.') ||
          (*i8 == '~') )
        GNUNET_buffer_write (&buf, (const char*) i8, 1);
      else if (*i8 == ' ')
        GNUNET_buffer_write (&buf, "+", 1);
      else
        GNUNET_buffer_write_fstr (&buf,
                                  "%%%X%X",
                                  *i8 >> 4,
                                  *i8 & 15);
      i8++;
      continue;
    }
    if (0x80 + 0x40 == ((0x80 + 0x40 + 0x20) & *i8))
    {
      /* 2-byte value, percent-encode */
      GNUNET_buffer_write_fstr (&buf,
                                "%%%X%X",
                                *i8 >> 4,
                                *i8 & 15);
      i8++;
      GNUNET_buffer_write_fstr (&buf,
                                "%%%X%X",
                                *i8 >> 4,
                                *i8 & 15);
      i8++;
      continue;
    }
    if (0x80 + 0x40 + 0x20 == ((0x80 + 0x40 + 0x20 + 0x10) & *i8))
    {
      /* 3-byte value, percent-encode */
      for (unsigned int i = 0; i<3; i++)
      {
        GNUNET_buffer_write_fstr (&buf,
                                  "%%%X%X",
                                  *i8 >> 4,
                                  *i8 & 15);
        i8++;
      }
      continue;
    }
    if (0x80 + 0x40 + 0x20 + 0x10 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08) & *i8))
    {
      /* 4-byte value, percent-encode */
      for (unsigned int i = 0; i<4; i++)
      {
        GNUNET_buffer_write_fstr (&buf,
                                  "%%%X%X",
                                  *i8 >> 4,
                                  *i8 & 15);
        i8++;
      }
      continue;
    }
    if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 == ((0x80 + 0x40 + 0x20 + 0x10 + 0x08
                                              + 0x04) & *i8))
    {
      /* 5-byte value, percent-encode (outside of UTF-8 modern standard, but so what) */
      for (unsigned int i = 0; i<5; i++)
      {
        GNUNET_buffer_write_fstr (&buf,
                                  "%%%X%X",
                                  *i8 >> 4,
                                  *i8 & 15);
        i8++;
      }
      continue;
    }
    if (0x80 + 0x40 + 0x20 + 0x10 + 0x08 + 0x04 == ((0x80 + 0x40 + 0x20 + 0x10
                                                     + 0x08 + 0x04 + 0x02)
                                                    & *i8))
    {
      /* 6-byte value, percent-encode (outside of UTF-8 modern standard, but so what) */
      for (unsigned int i = 0; i<6; i++)
      {
        GNUNET_buffer_write_fstr (&buf,
                                  "%%%X%X",
                                  *i8 >> 4,
                                  *i8 & 15);
        i8++;
      }
      continue;
    }
    /* really, really invalid UTF-8: fail */
    GNUNET_break (0);
    GNUNET_buffer_clear (&buf);
    return 0;
  }
  *out = GNUNET_buffer_reap_str (&buf);
  return strlen (*out);
}

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

Referenced by GNUNET_HELLO_builder_add_address(), and login_redirect().

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

in	the data to encode
len	the length of the input
output	where to write the output (*output should be NULL, is allocated)

Returns

the size of the output

Definition at line 1656 of file strings.c.

{
  char *enc;
  size_t pos;
 
  GNUNET_STRINGS_base64_encode (in, len, output);
  enc = *output;
  /* Replace with correct characters for base64url */
  pos = 0;
  while ('\0' != enc[pos])
  {
    if ('+' == enc[pos])
      enc[pos] = '-';
    if ('/' == enc[pos])
      enc[pos] = '_';
    if ('=' == enc[pos])
    {
      enc[pos] = '\0';
      break;
    }
    pos++;
  }
  return strlen (enc);
}

References enc, GNUNET_STRINGS_base64_encode(), and len.

Referenced by check_code_challenge(), DID_key_convert_gnunet_to_multibase_base64(), ego_sign_data_cb(), 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

	data	the data to encode
	len	the length of the input
[out]	output	where to write the output (*output should be NULL, is allocated)

Returns

the size of the output

Definition at line 1695 of file strings.c.

{
  char *output;
  size_t ret = 0;
 
#define CHECK_CRLF                                                \
  while (data[i] == '\r' || data[i] == '\n')                      \
  {                                                               \
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
                "ignoring CR/LF\n");                              \
    i++;                                                          \
    if (i >= len)                                                 \
    goto END;                                                   \
  }
 
  GNUNET_assert (len / 3 < SIZE_MAX);
  output = GNUNET_malloc ((len * 3 / 4) + 8);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "base64_decode decoding len=%d\n",
              (int) len);
  for (size_t i = 0; i < len; ++i)
  {
    char c;
    char c1;
 
    CHECK_CRLF;
    if (FILLCHAR == data[i])
      break;
    c = (char) cvtfind (data[i]);
    ++i;
    CHECK_CRLF;
    c1 = (char) cvtfind (data[i]);
    c = (c << 2) | ((c1 >> 4) & 0x3);
    output[ret++] = c;
    if (++i < len)
    {
      CHECK_CRLF;
      c = data[i];
      if (FILLCHAR == c)
        break;
      c = (char) cvtfind (c);
      c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
      output[ret++] = c1;
    }
    if (++i < len)
    {
      CHECK_CRLF;
      c1 = data[i];
      if (FILLCHAR == c1)
        break;
 
      c1 = (char) cvtfind (c1);
      c = ((c << 6) & 0xc0) | c1;
      output[ret++] = c;
    }
  }
  END:
  *out = output;
  return ret;
}

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

Referenced by database_setup(), dns_string_to_value(), GNUNET_ABD_delegate_from_string(), GNUNET_HELLO_extract_address(), GNUNET_STRINGS_base64url_decode(), listenAndDistribute(), parse_credentials_basic_auth(), and parse_jwt().

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

data	the data to decode
len	the length of the input
out	where to write the output (*out should be NULL, is allocated)

Returns

the size of the output

Definition at line 1760 of file strings.c.

{
  char *s;
  int padding;
  size_t ret;
 
  /* make enough space for padding */
  GNUNET_assert (len < SIZE_MAX - 3);
  s = GNUNET_malloc (len + 3);
  memcpy (s, data, len);
 
  for (int i = 0; i < strlen (s); i++)
  {
    if (s[i] == '-')
      s[i] = '+';
    if (s[i] == '_')
      s[i] = '/';
  }
  padding = len % 4;
  switch (padding) // Pad with trailing '='s
  {
  case 0:
    break;   // No pad chars in this case
  case 2:
    memcpy (&s[len],
            "==",
            2);
    len += 2;
    break;         // Two pad chars
  case 3:
    s[len] = '=';
    len++;
    break;         // One pad char
  default:
    GNUNET_assert (0);
    break;
  }
  ret = GNUNET_STRINGS_base64_decode (s, len, out);
  GNUNET_free (s);
  return ret;
}

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

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

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

	data	the data to encode
	len	the length of the input
[out]	out	where to write the output (*output should be NULL, is allocated)

Returns

the size of the output

Definition at line 1806 of file strings.c.

{
  const char *rpos = data;
  *out = GNUNET_malloc (len + 1); /* output should always fit into input */
  char *wpos = *out;
  size_t resl = 0;
 
  while ( ('\0' != *rpos) &&
          (data + len != rpos) )
  {
    unsigned int num;
    switch (*rpos)
    {
    case '%':
      if (rpos + 3 > data + len)
      {
        GNUNET_break_op (0);
        GNUNET_free (*out);
        return 0;
      }
      if (1 != sscanf (rpos + 1, "%2x", &num))
        break;
      *wpos = (char) ((unsigned char) num);
      wpos++;
      resl++;
      rpos += 3;
      break;
    /* TODO: add bad sequence handling */
    /* intentional fall through! */
    default:
      *wpos = *rpos;
      wpos++;
      resl++;
      rpos++;
    }
  }
  *wpos = '\0'; /* add 0-terminator */
  return resl;
}

References data, GNUNET_break_op, GNUNET_free, GNUNET_malloc, and len.

Referenced by get_url_parameter_copy(), and GNUNET_HELLO_builder_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

	path	path to parse. Must be NULL-terminated.
[out]	scheme_part	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_part	a 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 763 of file strings.c.

{
  size_t len;
  size_t i;
  int end;
  int pp_state = 0;
  const char *post_scheme_part = NULL;
 
  len = strlen (path);
  for (end = 0, i = 0; ! end && i < len; i++)
  {
    switch (pp_state)
    {
    case 0:
      if ((path[i] == ':') && (i > 0))
      {
        pp_state += 1;
        continue;
      }
      if (! (((path[i] >= 'A') && (path[i] <= 'Z') ) ||
             ((path[i] >= 'a') && (path[i] <= 'z') ) ||
             ((path[i] >= '0') && (path[i] <= '9') ) || (path[i] == '+') ||
             (path[i] == '-') || (path[i] == '.')))
        end = 1;
      break;
 
    case 1:
    case 2:
      if (path[i] == '/')
      {
        pp_state += 1;
        continue;
      }
      end = 1;
      break;
 
    case 3:
      post_scheme_part = &path[i];
      end = 1;
      break;
 
    default:
      end = 1;
    }
  }
  if (post_scheme_part == NULL)
    return GNUNET_NO;
  if (scheme_part)
  {
    *scheme_part = GNUNET_malloc (post_scheme_part - path + 1);
    GNUNET_memcpy (*scheme_part, path, post_scheme_part - path);
    (*scheme_part)[post_scheme_part - path] = '\0';
  }
  if (path_part)
    *path_part = post_scheme_part;
  return GNUNET_YES;
}

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

filename	filename to check
can_be_uri	GNUNET_YES to check for being URI, GNUNET_NO - to assume it's not URI
r_is_uri	a 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_scheme	a 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 763 of file strings.c.

{
  const char *post_scheme_path;
  int is_uri;
  char *uri;
  /* consider POSIX paths to be absolute too, even on W32,
   * as plibc expansion will fix them for us.
   */
  if (filename[0] == '/')
    return GNUNET_YES;
  if (can_be_uri)
  {
    is_uri = GNUNET_STRINGS_parse_uri (filename, &uri, &post_scheme_path);
    if (r_is_uri)
      *r_is_uri = is_uri;
    if (is_uri)
    {
      if (r_uri_scheme)
        *r_uri_scheme = uri;
      else
        GNUNET_free (uri);
 
      return GNUNET_STRINGS_path_is_absolute (post_scheme_path,
                                              GNUNET_NO,
                                              NULL,
                                              NULL);
    }
  }
  else
  {
    if (r_is_uri)
      *r_is_uri = GNUNET_NO;
  }
 
  return GNUNET_NO;
}

Referenced by GNUNET_OS_check_helper_binary(), and GNUNET_OS_get_libexec_binary_path().

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

filename	file to check
checks	checks 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 763 of file strings.c.

{
  struct stat st;
 
  if ((NULL == filename) || (filename[0] == '\0'))
    return GNUNET_SYSERR;
  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
    if (! GNUNET_STRINGS_path_is_absolute (filename, GNUNET_NO, NULL, NULL))
      return GNUNET_NO;
  if (0 != (checks
            & (GNUNET_STRINGS_CHECK_EXISTS | GNUNET_STRINGS_CHECK_IS_DIRECTORY
               | GNUNET_STRINGS_CHECK_IS_LINK)))
  {
    if (0 != lstat (filename, &st))
    {
      if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
        return GNUNET_NO;
      else
        return GNUNET_SYSERR;
    }
  }
  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
    if (! S_ISDIR (st.st_mode))
      return GNUNET_NO;
  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
    if (! S_ISLNK (st.st_mode))
      return GNUNET_NO;
  return GNUNET_YES;
}

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

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,
		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_addr	0-terminated string. May be mangled by the function.
addrlen	length of zt_addr (not counting 0-terminator).
r_buf	a 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 763 of file strings.c.

{
  char zbuf[addrlen + 1];
  int ret;
  char *port_colon;
  unsigned int port;
  char dummy[2];
 
  if (addrlen < 6)
    return GNUNET_SYSERR;
  GNUNET_memcpy (zbuf, zt_addr, addrlen);
  if ('[' != zbuf[0])
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("IPv6 address did not start with `['\n"));
    return GNUNET_SYSERR;
  }
  zbuf[addrlen] = '\0';
  port_colon = strrchr (zbuf, ':');
  if (NULL == port_colon)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("IPv6 address did contain ':' to separate port number\n"));
    return GNUNET_SYSERR;
  }
  if (']' != *(port_colon - 1))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ ("IPv6 address did contain ']' before ':' to separate port number\n"));
    return GNUNET_SYSERR;
  }
  ret = sscanf (port_colon, ":%u%1s", &port, dummy);
  if ((1 != ret) || (port > 65535))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ ("IPv6 address did contain a valid port number after the last ':'\n"));
    return GNUNET_SYSERR;
  }
  *(port_colon - 1) = '\0';
  memset (r_buf, 0, sizeof(struct sockaddr_in6));
  ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
  if (ret <= 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Invalid IPv6 address `%s': %s\n"),
                &zbuf[1],
                strerror (errno));
    return GNUNET_SYSERR;
  }
  r_buf->sin6_port = htons (port);
  r_buf->sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  r_buf->sin6_len = (u_char) sizeof(struct sockaddr_in6);
#endif
  return GNUNET_OK;
}

Referenced by GNUNET_STRINGS_parse_socket_addr().

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,
		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_addr	0-terminated string. May be mangled by the function.
addrlen	length of zt_addr (not counting 0-terminator).
r_buf	a 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 763 of file strings.c.

{
  unsigned int temps[4];
  unsigned int port;
  unsigned int cnt;
  char dummy[2];
 
  if (addrlen < 9)
    return GNUNET_SYSERR;
  cnt = sscanf (zt_addr,
                "%u.%u.%u.%u:%u%1s",
                &temps[0],
                &temps[1],
                &temps[2],
                &temps[3],
                &port,
                dummy);
  if (5 != cnt)
    return GNUNET_SYSERR;
  for (cnt = 0; cnt < 4; cnt++)
    if (temps[cnt] > 0xFF)
      return GNUNET_SYSERR;
  if (port > 65535)
    return GNUNET_SYSERR;
  r_buf->sin_family = AF_INET;
  r_buf->sin_port = htons (port);
  r_buf->sin_addr.s_addr =
    htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
#if HAVE_SOCKADDR_IN_SIN_LEN
  r_buf->sin_len = (u_char) sizeof(struct sockaddr_in);
#endif
  return GNUNET_OK;
}

Referenced by GNUNET_STRINGS_parse_socket_addr().

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

	addr	the address
[out]	af	set to the parsed address family (e.g. AF_INET)
[out]	sa	set to the parsed address

Returns

0 on error, otherwise number of bytes in sa

Definition at line 1149 of file strings.c.

{
  char *cp = GNUNET_strdup (addr);
 
  *af = AF_UNSPEC;
  if ('[' == *addr)
  {
    /* IPv6 */
    *sa = GNUNET_malloc (sizeof(struct sockaddr_in6));
    if (GNUNET_OK !=
        GNUNET_STRINGS_to_address_ipv6 (cp,
                                        strlen (cp),
                                        (struct sockaddr_in6 *) *sa))
    {
      GNUNET_free (*sa);
      *sa = NULL;
      GNUNET_free (cp);
      return 0;
    }
    *af = AF_INET6;
    GNUNET_free (cp);
    return sizeof(struct sockaddr_in6);
  }
  else
  {
    /* IPv4 */
    *sa = GNUNET_malloc (sizeof(struct sockaddr_in));
    if (GNUNET_OK !=
        GNUNET_STRINGS_to_address_ipv4 (cp,
                                        strlen (cp),
                                        (struct sockaddr_in *) *sa))
    {
      GNUNET_free (*sa);
      *sa = NULL;
      GNUNET_free (cp);
      return 0;
    }
    *af = AF_INET;
    GNUNET_free (cp);
    return sizeof(struct sockaddr_in);
  }
}

References GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, 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

addr	a string, may not be 0-terminated.
addrlen	number of bytes in addr (if addr is 0-terminated, 0-terminator should not be counted towards addrlen).
r_buf	a 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 763 of file strings.c.

{
  if (addr[0] == '[')
    return GNUNET_STRINGS_to_address_ipv6 (addr,
                                           addrlen,
                                           (struct sockaddr_in6 *) r_buf);
  return GNUNET_STRINGS_to_address_ipv4 (addr,
                                         addrlen,
                                         (struct sockaddr_in *) r_buf);
}

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

Here is the caller graph for this function:

GNUNET_STRINGS_get_utf8_args()

enum GNUNET_GenericReturnValue 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

argc	argc (as given by main())
argv	argv (as given by main())
u8argc	a location to store new argc in (though it's th same as argc)
u8argv	a location to store new argv in

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1200 of file strings.c.

{
  char *const *new_argv =
    (char *const *) _make_continuous_arg_copy (argc, argv);
  *u8argv = new_argv;
  *u8argc = argc;
  return GNUNET_OK;
}

Referenced by main().

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

dst	destination of the copy
src	source of the copy, must be null-terminated
n	the 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 138 of file strings.c.

{
  size_t slen;
 
  GNUNET_assert (0 != n);
  slen = strnlen (src, n - 1);
  memcpy (dst, src, slen);
  dst[slen] = '\0';
  return slen;
}

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

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

routeListX

a string specifying the IPv4 subnets

Returns

the converted list, terminated with all zeros; NULL if the synatx is flawed

Definition at line 1290 of file strings.c.

{
  unsigned int count;
  unsigned int i;
  unsigned int j;
  unsigned int len;
  int cnt;
  unsigned int pos;
  unsigned int temps[8];
  int slash;
  struct GNUNET_STRINGS_IPv4NetworkPolicy *result;
  int colon;
  int end;
  char *routeList;
  char dummy[2];
 
  if (NULL == routeListX)
    return NULL;
  len = strlen (routeListX);
  if (0 == len)
    return NULL;
  routeList = GNUNET_strdup (routeListX);
  count = 0;
  for (i = 0; i < len; i++)
    if (routeList[i] == ';')
      count++;
  result = GNUNET_malloc (sizeof(struct GNUNET_STRINGS_IPv4NetworkPolicy)
                          * (count + 1));
  i = 0;
  pos = 0;
  while (i < count)
  {
    for (colon = pos; ':' != routeList[colon]; colon++)
      if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
        break;
    for (end = colon; ';' != routeList[end]; end++)
      if ('\0' == routeList[end])
        break;
    if ('\0' == routeList[end])
      break;
    routeList[end] = '\0';
    if (':' == routeList[colon])
    {
      routeList[colon] = '\0';
      if (GNUNET_OK != parse_port_policy (&routeList[colon + 1], &result[i].pp))
        break;
    }
    cnt = sscanf (&routeList[pos],
                  "%u.%u.%u.%u/%u.%u.%u.%u%1s",
                  &temps[0],
                  &temps[1],
                  &temps[2],
                  &temps[3],
                  &temps[4],
                  &temps[5],
                  &temps[6],
                  &temps[7],
                  dummy);
    if (8 == cnt)
    {
      for (j = 0; j < 8; j++)
        if (temps[j] > 0xFF)
        {
          LOG (GNUNET_ERROR_TYPE_WARNING,
               _ ("Invalid format for IP: `%s'\n"),
               &routeList[pos]);
          GNUNET_free (result);
          GNUNET_free (routeList);
          return NULL;
        }
      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
                                        + (temps[2] << 8) + temps[3]);
      result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16)
                                        + (temps[6] << 8) + temps[7]);
      pos = end + 1;
      i++;
      continue;
    }
    /* try second notation */
    cnt = sscanf (&routeList[pos],
                  "%u.%u.%u.%u/%u%1s",
                  &temps[0],
                  &temps[1],
                  &temps[2],
                  &temps[3],
                  &slash,
                  dummy);
    if (5 == cnt)
    {
      for (j = 0; j < 4; j++)
        if (temps[j] > 0xFF)
        {
          LOG (GNUNET_ERROR_TYPE_WARNING,
               _ ("Invalid format for IP: `%s'\n"),
               &routeList[pos]);
          GNUNET_free (result);
          GNUNET_free (routeList);
          return NULL;
        }
      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
                                        + (temps[2] << 8) + temps[3]);
      if ((slash <= 32) && (slash >= 0))
      {
        result[i].netmask.s_addr = 0;
        while (slash > 0)
        {
          result[i].netmask.s_addr =
            (result[i].netmask.s_addr >> 1) + 0x80000000;
          slash--;
        }
        result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
        pos = end + 1;
        i++;
        continue;
      }
      else
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             _ ("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
             slash);
        GNUNET_free (result);
        GNUNET_free (routeList);
        return NULL;       /* error */
      }
    }
    /* try third notation */
    slash = 32;
    cnt = sscanf (&routeList[pos],
                  "%u.%u.%u.%u%1s",
                  &temps[0],
                  &temps[1],
                  &temps[2],
                  &temps[3],
                  dummy);
    if (4 == cnt)
    {
      for (j = 0; j < 4; j++)
        if (temps[j] > 0xFF)
        {
          LOG (GNUNET_ERROR_TYPE_WARNING,
               _ ("Invalid format for IP: `%s'\n"),
               &routeList[pos]);
          GNUNET_free (result);
          GNUNET_free (routeList);
          return NULL;
        }
      result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
                                        + (temps[2] << 8) + temps[3]);
      result[i].netmask.s_addr = 0;
      while (slash > 0)
      {
        result[i].netmask.s_addr = (result[i].netmask.s_addr >> 1) + 0x80000000;
        slash--;
      }
      result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
      pos = end + 1;
      i++;
      continue;
    }
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Invalid format for IP: `%s'\n"),
         &routeList[pos]);
    GNUNET_free (result);
    GNUNET_free (routeList);
    return NULL;   /* error */
  }
  if (pos < strlen (routeList))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Invalid format: `%s'\n"),
         &routeListX[pos]);
    GNUNET_free (result);
    GNUNET_free (routeList);
    return NULL;   /* oops */
  }
  GNUNET_free (routeList);
  return result; /* ok */
}

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

Referenced by GNUNET_TUN_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

routeListX

a string specifying the policy

Returns

the converted list, 0-terminated, NULL if the synatx is flawed

Definition at line 1471 of file strings.c.

{
  unsigned int count;
  unsigned int i;
  unsigned int len;
  unsigned int pos;
  int start;
  int slash;
  int ret;
  char *routeList;
  struct GNUNET_STRINGS_IPv6NetworkPolicy *result;
  unsigned int bits;
  unsigned int off;
  int save;
  int colon;
  char dummy[2];
 
  if (NULL == routeListX)
    return NULL;
  len = strlen (routeListX);
  if (0 == len)
    return NULL;
  routeList = GNUNET_strdup (routeListX);
  count = 0;
  for (i = 0; i < len; i++)
    if (';' == routeList[i])
      count++;
  if (';' != routeList[len - 1])
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Invalid network notation (does not end with ';': `%s')\n"),
         routeList);
    GNUNET_free (routeList);
    return NULL;
  }
 
  result = GNUNET_malloc (sizeof(struct GNUNET_STRINGS_IPv6NetworkPolicy)
                          * (count + 1));
  i = 0;
  pos = 0;
  while (i < count)
  {
    start = pos;
    while (';' != routeList[pos])
      pos++;
    slash = pos;
    while ((slash >= start) && (routeList[slash] != '/'))
      slash--;
 
    if (slash < start)
    {
      memset (&result[i].netmask, 0xFF, sizeof(struct in6_addr));
      slash = pos;
    }
    else
    {
      routeList[pos] = '\0';
      for (colon = pos; ':' != routeList[colon]; colon--)
        if ('/' == routeList[colon])
          break;
      if (':' == routeList[colon])
      {
        routeList[colon] = '\0';
        if (GNUNET_OK !=
            parse_port_policy (&routeList[colon + 1], &result[i].pp))
        {
          GNUNET_free (result);
          GNUNET_free (routeList);
          return NULL;
        }
      }
      ret = inet_pton (AF_INET6, &routeList[slash + 1], &result[i].netmask);
      if (ret <= 0)
      {
        save = errno;
        if ((1 != sscanf (&routeList[slash + 1], "%u%1s", &bits, dummy)) ||
            (bits > 128))
        {
          if (0 == ret)
            LOG (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Wrong format `%s' for netmask\n"),
                 &routeList[slash + 1]);
          else
          {
            errno = save;
            LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_pton");
          }
          GNUNET_free (result);
          GNUNET_free (routeList);
          return NULL;
        }
        off = 0;
        while (bits > 8)
        {
          result[i].netmask.s6_addr[off++] = 0xFF;
          bits -= 8;
        }
        while (bits > 0)
        {
          result[i].netmask.s6_addr[off] =
            (result[i].netmask.s6_addr[off] >> 1) + 0x80;
          bits--;
        }
      }
    }
    routeList[slash] = '\0';
    ret = inet_pton (AF_INET6, &routeList[start], &result[i].network);
    if (ret <= 0)
    {
      if (0 == ret)
        LOG (GNUNET_ERROR_TYPE_WARNING,
             _ ("Wrong format `%s' for network\n"),
             &routeList[slash + 1]);
      else
        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "inet_pton");
      GNUNET_free (result);
      GNUNET_free (routeList);
      return NULL;
    }
    pos++;
    i++;
  }
  GNUNET_free (routeList);
  return result;
}

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

Here is the call graph for this function:

Here is the caller graph for this function: