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

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 542 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 235 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);
}

References convert_with_table(), size, and table.

Referenced by GNUNET_CONFIGURATION_get_value_size().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_fancy_time_to_relative()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_relative	(	const char *	fancy_time,
		struct GNUNET_TIME_Relative *	rtime
	)

Convert a given fancy human-readable time to our internal representation.

Parameters

fancy_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 259 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 },
    { "w", 7 * 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 */ },
    { "y", 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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_byte_size_fancy()

char * GNUNET_STRINGS_byte_size_fancy

(

unsigned long long

size

)

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

Parameters

size	number of bytes

Returns

fancy representation of the size (possibly rounded) for humans

Definition at line 105 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 374 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, 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 436 of file strings.c.

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

References GNUNET_STRINGS_conv().

Here is the call graph for this function:

GNUNET_STRINGS_utf8_normalize()

char * GNUNET_STRINGS_utf8_normalize

(

const char *

input

)

Normalize the utf-8 input string to NFC.

Parameters

input

input string

Returns

result (freshly allocated) or NULL on error.

Definition at line 460 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, and GNUNET_memcpy.

Referenced by GNUNET_GNSRECORD_string_normalize().

Here is the caller graph for this function:

GNUNET_STRINGS_from_utf8()

char * GNUNET_STRINGS_from_utf8	(	const char *	input,
		size_t	len,
		const char *	charset
	)

Convert the len bytes-long UTF-8 string given in input to the given charset.

Parameters

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

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

References GNUNET_STRINGS_conv().

Here is the call graph for this function:

GNUNET_STRINGS_utf8_tolower()

char * GNUNET_STRINGS_utf8_tolower

(

const char *

input

)

Convert the utf-8 input string to lower case.

Parameters

input

input string

Returns

NULL on error

Definition at line 481 of file strings.c.

{
  uint8_t *tmp_in;
  size_t len;
  char *ret;
 
  tmp_in = u8_tolower ((uint8_t *) input,
                       strlen ((char *) input),
                       NULL,
                       UNINORM_NFD,
                       NULL,
                       &len);
 
  if (NULL == tmp_in)
    return NULL;
  ret = GNUNET_malloc (len + 1);
  memcpy (ret,
          tmp_in,
          len);
  free (tmp_in);
  return ret;
}

References GNUNET_malloc, and ret.

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(), header_iterator(), and store_handle_encryption_key().

Here is the caller graph for this function:

GNUNET_STRINGS_utf8_toupper()

char * GNUNET_STRINGS_utf8_toupper

(

const char *

input

)

Convert the utf-8 input string to upper case.

Parameters

input

input string

Returns

NULL on error

Definition at line 506 of file strings.c.

{
  uint8_t *tmp_in;
  size_t len;
  char *ret;
 
  tmp_in = u8_toupper ((uint8_t *) input,
                       strlen ((char *) input),
                       NULL,
                       UNINORM_NFD,
                       NULL,
                       &len);
 
  if (NULL == tmp_in)
    return NULL;
  ret = GNUNET_malloc (len + 1);
  memcpy (ret,
          tmp_in,
          len);
  free (tmp_in);
  return ret;
}

References GNUNET_malloc, and ret.

Referenced by GNUNET_CRYPTO_hash_from_string2(), and GNUNET_HOSTLIST_client_start().

Here is the caller graph for this function:

GNUNET_STRINGS_filename_expand()

char * GNUNET_STRINGS_filename_expand

(

const char *

fil

)

Complete filename (a la shell) from abbrevition.

Parameters

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

{
  char *buffer;
  size_t len;
  char *fm;
  const char *fil_ptr;
 
  if (NULL == fil)
    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 (NULL != getcwd (buffer,
                          len))
      {
        fm = buffer;
        break;
      }
      if ( (errno == ERANGE) &&
           (len < 1024 * 1024 * 4) )
      {
        len *= 2;
        GNUNET_free (buffer);
        continue;
      }
      GNUNET_free (buffer);
      break;
    }
    if (NULL == fm)
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                    "getcwd");
      buffer = getenv ("PWD");    /* alternative */
      if (buffer != NULL)
        fm = GNUNET_strdup (buffer);
    }
    if (NULL == fm)
      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, LOG, and LOG_STRERROR.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_buffer_fill()

size_t GNUNET_STRINGS_buffer_fill	(	char *	buffer,
		size_t	size,
		unsigned int	count,
			...
	)

Fill a buffer of the given size with count 0-terminated strings (given as varargs).

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

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

Parameters

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 43 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 71 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 694 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 763 of file strings.c.

{
  static const 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(), GNUNET_buffer_write_data_encoded(), GNUNET_CRYPTO_ecdsa_private_key_to_string(), GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_CRYPTO_eddsa_private_key_to_string(), GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_GNSRECORD_z2s(), GNUNET_PQ_event_notify(), GNUNET_sh2s(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_uuid2s(), output_message(), print_examples_ecdh(), run_edkey(), run_pkey(), run_with_key(), sh_to_channel(), uri_loc_to_string(), and uri_sks_to_string().

Here is the caller graph for this function:

GNUNET_STRINGS_data_to_string_alloc()

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

Return the base32crockford encoding of the given buffer.

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

Parameters

buf	buffer with data
size	size of the buffer buf

Returns

freshly allocated, null-terminated string

Definition at line 818 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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_string_to_data()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data	(	const char *	enc,
		size_t	enclen,
		void *	out,
		size_t	out_size
	)

Convert CrockfordBase32 encoding back to data.

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

Parameters

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 843 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;
}

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

Referenced by channel_to_sh(), check_authorization(), consume_fail(), conversation_string_to_value(), delete_attribute_cont(), delete_credential_cont(), ego_create(), expect_data_dynamic(), expect_data_fixed(), GNUNET_CONFIGURATION_get_data(), GNUNET_CRYPTO_blindable_private_key_from_string(), GNUNET_CRYPTO_blindable_public_key_from_string(), 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_parser_from_url(), GNUNET_STRINGS_string_to_data_alloc(), lookup_redirect_uri_result(), main(), messenger_string_to_value(), parse_attr(), parse_credential(), parse_fixed_data(), parse_rsa_public_key(), parse_rsa_signature(), read_service_conf(), run(), set_base32(), start_process(), string_to_auth_key(), string_to_value(), uri_loc_parse(), and uri_sks_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_string_to_data_alloc()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data_alloc	(	const char *	enc,
		size_t	enclen,
		void **	out,
		size_t *	out_size
	)

Convert CrockfordBase32 encoding back to data.

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

Parameters

	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 909 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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_base64_encode()

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

Encode into Base64.

Parameters

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

{
  const unsigned char *data = in;
  size_t ret;
  char *opt;
 
  ret = 0;
  GNUNET_assert (len < SIZE_MAX / 4);
  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, ret, and SIZE_MAX.

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

Here is the caller graph for this function:

GNUNET_STRINGS_urlencode()

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

url/percent encode (RFC3986).

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

Parameters

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

{
  struct GNUNET_Buffer buf = { 0 };
  const uint8_t *i8 = (uint8_t *) data;
  const uint8_t *end = (uint8_t *) (data + len);
 
  while (end != i8)
  {
    if (0 == *i8)
    {
      /* invalid UTF-8 (or bad @a len): fail */
      GNUNET_break (0);
      GNUNET_buffer_clear (&buf);
      return 0;
    }
    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++;
      if ( (end == i8) ||
           (0 == *i8) )
      {
        /* invalid UTF-8 (or bad @a len): fail */
        GNUNET_break (0);
        GNUNET_buffer_clear (&buf);
        return 0;
      }
      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++)
      {
        if ( (end == i8) ||
             (0 == *i8) )
        {
          /* invalid UTF-8 (or bad @a len): fail */
          GNUNET_break (0);
          GNUNET_buffer_clear (&buf);
          return 0;
        }
        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++)
      {
        if ( (end == i8) ||
             (0 == *i8) )
        {
          /* invalid UTF-8 (or bad @a len): fail */
          GNUNET_break (0);
          GNUNET_buffer_clear (&buf);
          return 0;
        }
        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++)
      {
        if ( (end == i8) ||
             (0 == *i8) )
        {
          /* invalid UTF-8 (or bad @a len): fail */
          GNUNET_break (0);
          GNUNET_buffer_clear (&buf);
          return 0;
        }
        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++)
      {
        if ( (end == i8) ||
             (0 == *i8) )
        {
          /* invalid UTF-8 (or bad @a len): fail */
          GNUNET_break (0);
          GNUNET_buffer_clear (&buf);
          return 0;
        }
        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 data, end, GNUNET_break, GNUNET_buffer_clear(), GNUNET_buffer_reap_str(), GNUNET_buffer_write(), and GNUNET_buffer_write_fstr().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_base64url_encode()

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

Encode into Base64url.

RFC7515

Parameters

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 1678 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, and GNUNET_STRINGS_base64_encode().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_base64_decode()

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

Decode from Base64.

Parameters

	data	the data to decode
	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 1731 of file strings.c.

{
  unsigned char *output;
  size_t ret = 0;
 
  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)
  {
    unsigned char c;
    unsigned char c1;
 
    CHECK_CRLF;
    if (FILLCHAR == data[i])
      break;
    c = (unsigned char) cvtfind (data[i]);
    ++i;
    CHECK_CRLF;
    c1 = (unsigned 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 = (unsigned 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 = (unsigned 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, ret, and SIZE_MAX.

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

Here is the caller graph for this function:

GNUNET_STRINGS_base64url_decode()

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

Decode from Base64url.

RFC7515

Parameters

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 1789 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 (size_t 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(), ret, and SIZE_MAX.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_urldecode()

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

url/percent encode (RFC3986).

Parameters

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

{
  const char *rpos = data;
  char *wpos;
  size_t resl = 0;
  *out = GNUNET_malloc (len + 1); /* output should always fit into input */
  wpos = *out;
 
  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))
      {
        /* Invalid URL encoding, try to continue anyway */
        GNUNET_break_op (0);
        *wpos = *rpos;
        wpos++;
        resl++;
        rpos++;
        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, and GNUNET_malloc.

Referenced by get_url_parameter_copy(), and GNUNET_HELLO_parser_from_url().

Here is the caller graph for this function:

GNUNET_STRINGS_parse_uri()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_parse_uri	(	const char *	path,
		char **	scheme_part,
		const char **	path_part
	)

Parse a path that might be an URI.

Parameters

	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 951 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_strndup (path,
                                   post_scheme_part - path);
  }
  if (path_part)
    *path_part = post_scheme_part;
  return GNUNET_YES;
}

References end, GNUNET_NO, GNUNET_strndup, and GNUNET_YES.

Referenced by GNUNET_STRINGS_path_is_absolute().

Here is the caller graph for this function:

GNUNET_STRINGS_path_is_absolute()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_path_is_absolute	(	const char *	filename,
		int	can_be_uri,
		int *	r_is_uri,
		char **	r_uri_scheme
	)

Check whether filename is absolute or not, and if it's an URI.

Parameters

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 1012 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;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_check_filename()

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

Perform checks on filename.

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

Parameters

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 1054 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 filename, GNUNET_NO, GNUNET_STRINGS_CHECK_EXISTS, GNUNET_STRINGS_CHECK_IS_ABSOLUTE, GNUNET_STRINGS_CHECK_IS_DIRECTORY, GNUNET_STRINGS_CHECK_IS_LINK, GNUNET_STRINGS_path_is_absolute(), GNUNET_SYSERR, GNUNET_YES, S_ISLNK, and st.

Here is the call graph for this function:

GNUNET_STRINGS_to_address_ipv6()

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

Tries to convert zt_addr string to an IPv6 address.

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

Parameters

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

{
  if (addrlen < 6)
    return GNUNET_SYSERR;
  if (addrlen > 512)
    return GNUNET_SYSERR; /* sanity check to protect zbuf allocation,
                             actual limit is not precise */
  {
    char zbuf[addrlen + 1];
    int ret;
    char *port_colon;
    unsigned int port;
    char dummy[2];
 
    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;
  }
}

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

Referenced by GNUNET_STRINGS_parse_socket_addr(), and GNUNET_STRINGS_to_address_ip().

Here is the caller graph for this function:

GNUNET_STRINGS_to_address_ipv4()

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

Tries to convert zt_addr string to an IPv4 address.

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

Parameters

zt_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 1157 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;
}

References dummy, GNUNET_OK, GNUNET_SYSERR, and port.

Referenced by GNUNET_STRINGS_parse_socket_addr(), and GNUNET_STRINGS_to_address_ip().

Here is the caller graph for this function:

GNUNET_STRINGS_parse_socket_addr()

size_t GNUNET_STRINGS_parse_socket_addr	(	const char *	addr,
		uint8_t *	af,
		struct sockaddr **	sa
	)

Parse an address given as a string into a struct sockaddr.

Parameters

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

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

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

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_to_address_ip()

enum GNUNET_GenericReturnValue GNUNET_STRINGS_to_address_ip	(	const char *	addr,
		uint16_t	addrlen,
		struct sockaddr_storage *	r_buf
	)

Tries to convert addr string to an IP (v4 or v6) address.

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

Parameters

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 1195 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);
}

References GNUNET_STRINGS_to_address_ipv4(), and GNUNET_STRINGS_to_address_ipv6().

Here is the call graph for this function:

GNUNET_strlcpy()

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

Like strlcpy but portable.

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

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

Parameters

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 137 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;
}

References GNUNET_assert, and strnlen().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_get_suffix_from_binary_name()

char * GNUNET_STRINGS_get_suffix_from_binary_name

(

const char *

argv0

)

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

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

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

Parameters

argv0

the name of the binary

Returns

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

Definition at line 2067 of file strings.c.

{
  const char *ret;
  const char *dot;
 
  ret = strrchr (argv0, '_');
  if (NULL == ret)
    return NULL;
  ret++; /* skip underscore */
  dot = strchr (ret,
                '.');
  if (NULL != dot)
    return GNUNET_strndup (ret,
                           dot - ret);
  return GNUNET_strdup (ret);
}

References GNUNET_strdup, GNUNET_strndup, and ret.

GNUNET_STRINGS_parse_ipv4_policy()

struct GNUNET_STRINGS_IPv4NetworkPolicy * GNUNET_STRINGS_parse_ipv4_policy

(

const char *

routeListX

)

Parse an IPv4 network policy.

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

Parameters

routeListX

a string specifying the IPv4 subnets

Returns

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

Definition at line 1305 of file strings.c.

{
  size_t count;
  size_t len;
  size_t pos;
  unsigned int temps[8];
  struct GNUNET_STRINGS_IPv4NetworkPolicy *result;
  char *routeList;
 
  if (NULL == routeListX)
    return NULL;
  len = strlen (routeListX);
  if (0 == len)
    return NULL;
  routeList = GNUNET_strdup (routeListX);
  count = 0;
  for (size_t i = 0; i < len; i++)
    if (routeList[i] == ';')
      count++;
  GNUNET_assert (count < SIZE_MAX);
  result = GNUNET_new_array (count + 1,
                             struct GNUNET_STRINGS_IPv4NetworkPolicy);
  pos = 0;
  for (size_t i = 0; i < count; i++)
  {
    size_t colon;
    size_t end;
    char dummy;
 
    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;
    }
    if (8 ==
        sscanf (&routeList[pos],
                "%u.%u.%u.%u/%u.%u.%u.%u%c",
                &temps[0],
                &temps[1],
                &temps[2],
                &temps[3],
                &temps[4],
                &temps[5],
                &temps[6],
                &temps[7],
                &dummy))
    {
      for (unsigned int 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;
      continue;
    }
 
    /* try second notation */
    {
      unsigned int slash;
 
      if (5 ==
          sscanf (&routeList[pos],
                  "%u.%u.%u.%u/%u%c",
                  &temps[0],
                  &temps[1],
                  &temps[2],
                  &temps[3],
                  &slash,
                  &dummy))
      {
        for (unsigned int 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)
        {
          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;
          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 */
    if (4 ==
        sscanf (&routeList[pos],
                "%u.%u.%u.%u%c",
                &temps[0],
                &temps[1],
                &temps[2],
                &temps[3],
                &dummy))
    {
      for (unsigned int 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 = htonl (0xffffffff); /* yeah, the htonl is useless */
      pos = end + 1;
      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_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_new_array, GNUNET_OK, GNUNET_strdup, LOG, GNUNET_STRINGS_IPv4NetworkPolicy::netmask, parse_port_policy(), GNUNET_STRINGS_IPv4NetworkPolicy::pp, result, and SIZE_MAX.

Referenced by GNUNET_REGEX_ipv4policy2regex(), and process_acl4().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_STRINGS_parse_ipv6_policy()

struct GNUNET_STRINGS_IPv6NetworkPolicy * GNUNET_STRINGS_parse_ipv6_policy

(

const char *

routeListX

)

Parse an IPv6 network policy.

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

Parameters

routeListX

a string specifying the policy

Returns

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

Definition at line 1480 of file strings.c.

{
  size_t count;
  size_t len;
  size_t pos;
  int ret;
  char *routeList;
  struct GNUNET_STRINGS_IPv6NetworkPolicy *result;
  unsigned int off;
 
  if (NULL == routeListX)
    return NULL;
  len = strlen (routeListX);
  if (0 == len)
    return NULL;
  routeList = GNUNET_strdup (routeListX);
  count = 0;
  for (size_t j = 0; j < len; j++)
    if (';' == routeList[j])
      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;
  }
  GNUNET_assert (count < UINT_MAX);
  result = GNUNET_new_array (count + 1,
                             struct GNUNET_STRINGS_IPv6NetworkPolicy);
  pos = 0;
  for (size_t i = 0; i < count; i++)
  {
    size_t start;
    size_t slash;
 
    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
    {
      size_t colon;
 
      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)
      {
        char dummy;
        unsigned int bits;
        int save = errno;
 
        if ( (1 != sscanf (&routeList[slash + 1],
                           "%u%c",
                           &bits,
                           &dummy)) ||
             (bits > 128))
        {
          if (0 == ret)
          {
            LOG (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Wrong format `%s' for netmask\n"),
                 &routeList[slash]);
          }
          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++;
  }
  GNUNET_free (routeList);
  return result;
}

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

Referenced by GNUNET_REGEX_ipv6policy2regex(), and process_acl6().

Here is the call graph for this function:

Here is the caller graph for this function: