GNS Record library

Manipulate GNS record data. More...

Collaboration diagram for GNS Record library:

Data Structures
struct	GNUNET_GNSRECORD_Data
	A GNS record. More...
struct	GNUNET_GNSRECORD_PlaceData
	Data stored in a PLACE record. More...
struct	GNUNET_GNSRECORD_EcdsaBlock
	Information we have in an encrypted block with record data (i.e. More...
struct	GNUNET_GNSRECORD_EddsaBlock
	Information we have in an encrypted block with record data (i.e. More...
struct	GNUNET_GNSRECORD_Block
struct	GNUNET_GNSRECORD_BoxRecord
	Record type used to box up SRV and TLSA records. More...
struct	GNUNET_GNSRECORD_ReverseRecord
	Record type used internally to keep track of reverse mappings into a namespace. More...

Macros
#define	GNUNET_GNS_EMPTY_LABEL_AT   "@"
	String we use to indicate an empty label (top-level entry in the zone). More...
#define	GNUNET_GNSRECORD_MAX_BLOCK_SIZE   (63 * 1024)
	Maximum size of a value that can be stored in a GNS block. More...
#define	GNUNET_GNSRECORD_TYPE_ANY   0
	Record type indicating any record/'*'. More...
#define	GNUNET_GNSRECORD_RF_RCMP_FLAGS   (GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)
	Include the record types generated from GANA. More...

Typedefs
typedef void(*	GNUNET_GNSRECORD_RecordCallback) (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process a records that were decrypted from a block. More...

Enumerations
enum	GNUNET_GNSRECORD_Flags {   GNUNET_GNSRECORD_RF_NONE = 0 , GNUNET_GNSRECORD_RF_CRITICAL = 1 << (15 - 15) , GNUNET_GNSRECORD_RF_SHADOW = 1 << (15 - 14) , GNUNET_GNSRECORD_RF_SUPPLEMENTAL = 1 << (15 - 13) ,   GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION = 1 << (15 - 1) , GNUNET_GNSRECORD_RF_PRIVATE = 1 << (15 - 0) , GNUNET_GNSRECORD_RF_NONE = 0 , GNUNET_GNSRECORD_RF_CRITICAL = 1 << (15 - 15) ,   GNUNET_GNSRECORD_RF_SHADOW = 1 << (15 - 14) , GNUNET_GNSRECORD_RF_SUPPLEMENTAL = 1 << (15 - 13) , GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION = 1 << (15 - 1) , GNUNET_GNSRECORD_RF_PRIVATE = 1 << (15 - 0) }
	Flags that can be set for a record. More...
enum	GNUNET_GNSRECORD_Filter { GNUNET_GNSRECORD_FILTER_NONE = 0 , GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE = 1 , GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE = 2 }
	Filter for GNUNET_GNSRECORD_normalize_record_set(). More...

Functions
struct GNUNET_JSON_Specification	GNUNET_GNSRECORD_JSON_spec_gnsrecord (struct GNUNET_GNSRECORD_Data **rd, unsigned int *rd_count, char **name)
	JSON Specification for GNS Records. More...
json_t *	GNUNET_GNSRECORD_JSON_from_gnsrecord (const char *rname, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
	Convert GNS record to JSON. More...
char *	GNUNET_GNSRECORD_value_to_string (uint32_t type, const void *data, size_t data_size)
	Convert the binary value data of a record of type type to a human-readable string. More...
int	GNUNET_GNSRECORD_string_to_value (uint32_t type, const char *s, void **data, size_t *data_size)
	Convert human-readable version of the value s of a record of type type to the respective binary representation. More...
uint32_t	GNUNET_GNSRECORD_typename_to_number (const char *dns_typename)
	Convert a type name (e.g. More...
const char *	GNUNET_GNSRECORD_number_to_typename (uint32_t type)
	Convert a type number to the corresponding type string (e.g. More...
ssize_t	GNUNET_GNSRECORD_records_get_size (unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Calculate how many bytes we will need to serialize the given records. More...
ssize_t	GNUNET_GNSRECORD_records_serialize (unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
	Serialize the given records to the given destination buffer. More...
unsigned int	GNUNET_GNSRECORD_records_deserialize_get_size (size_t len, const char *src)
int	GNUNET_GNSRECORD_records_deserialize (size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
	Deserialize the given records to the given destination. More...
int	GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd)
	Test if a given record is expired. More...
char *	GNUNET_GNSRECORD_string_normalize (const char *src)
	Normalize a UTF-8 string to a GNS name. More...
const char *	GNUNET_GNSRECORD_z2s (const struct GNUNET_IDENTITY_PublicKey *z)
	Convert a zone to a string (for printing debug messages). More...
const char *	GNUNET_GNSRECORD_pkey_to_zkey (const struct GNUNET_IDENTITY_PublicKey *pkey)
	Convert public key to the respective absolute domain name in the ".zkey" pTLD. More...
int	GNUNET_GNSRECORD_zkey_to_pkey (const char *zkey, struct GNUNET_IDENTITY_PublicKey *pkey)
	Convert an absolute domain name to the respective public key. More...
void	GNUNET_GNSRECORD_query_from_private_key (const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone. More...
void	GNUNET_GNSRECORD_query_from_public_key (const struct GNUNET_IDENTITY_PublicKey *pub, const char *label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone. More...
ssize_t	GNUNET_GNSRECORD_block_calculate_size (const struct GNUNET_IDENTITY_PrivateKey *key, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
	Get size of buffer for block creation. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_sign (const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, struct GNUNET_GNSRECORD_Block *block)
	Sign a block create with GNUNET_GNSRECORD_block_create_unsigned. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create (const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **block)
	Sign name and records. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create_unsigned (const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **result)
	Create name and records but do not sign! Sign later with GNUNET_GNSRECORD_block_sign(). More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create2 (const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **result)
	Sign name and records, cache derived public key (also keeps the private key in static memory, so do not use this function if keeping the private key in the process'es RAM is a major issue). More...
int	GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
	Check if a signature is valid. More...
int	GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block, const struct GNUNET_IDENTITY_PublicKey *zone_key, const char *label, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
	Decrypt block. More...
int	GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a, const struct GNUNET_GNSRECORD_Data *b)
	Compares if two records are equal. More...
struct GNUNET_TIME_Absolute	GNUNET_GNSRECORD_record_get_expiration_time (unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute min)
	Returns the expiration time of the given block of records. More...
size_t	GNUNET_GNSRECORD_block_get_size (const struct GNUNET_GNSRECORD_Block *block)
	Returns the length of this block in bytes. More...
struct GNUNET_TIME_Absolute	GNUNET_GNSRECORD_block_get_expiration (const struct GNUNET_GNSRECORD_Block *block)
	Returns the expiration of a block. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_query_from_block (const struct GNUNET_GNSRECORD_Block *block, struct GNUNET_HashCode *query)
	Builds the query hash from a block. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_identity_from_data (const char *data, size_t data_size, uint32_t type, struct GNUNET_IDENTITY_PublicKey *key)
	Build a #GNUNET_GNSRECORD_PublicKey from zone delegation resource record data. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_data_from_identity (const struct GNUNET_IDENTITY_PublicKey *key, char **data, size_t *data_size, uint32_t *type)
	Create record data and size from an identity key. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_is_zonekey_type (uint32_t type)
	Check if this type is one of the supported GNS zone types. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_is_critical (uint32_t type)
	Check if this type is a critical record. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_normalize_record_set (const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *rd_public, unsigned int *rd_count_public, struct GNUNET_TIME_Absolute *min_expiry, enum GNUNET_GNSRECORD_Filter filter, char **emsg)
	Normalize namestore records: Check for consistency and expirations. More...
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_label_check (const char *label, char **emsg)
	Check label for invalid characters. More...

Detailed Description

Manipulate GNS record data.

See also

Documentation

Macro Definition Documentation

GNUNET_GNS_EMPTY_LABEL_AT

#define GNUNET_GNS_EMPTY_LABEL_AT   "@"

String we use to indicate an empty label (top-level entry in the zone).

DNS uses "@", so do we.

Definition at line 54 of file gnunet_gnsrecord_lib.h.

GNUNET_GNSRECORD_MAX_BLOCK_SIZE

#define GNUNET_GNSRECORD_MAX_BLOCK_SIZE   (63 * 1024)

Maximum size of a value that can be stored in a GNS block.

Definition at line 59 of file gnunet_gnsrecord_lib.h.

GNUNET_GNSRECORD_TYPE_ANY

#define GNUNET_GNSRECORD_TYPE_ANY   0

Record type indicating any record/'*'.

Definition at line 65 of file gnunet_gnsrecord_lib.h.

GNUNET_GNSRECORD_RF_RCMP_FLAGS

#define GNUNET_GNSRECORD_RF_RCMP_FLAGS   (GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)

Include the record types generated from GANA.

When comparing flags for record equality for removal, which flags should must match (in addition to the type, name, expiration value and data of the record)? All flags that are not listed here will be ignored for this purpose. (for example, we don't expect that users will remember to pass the '–private' option when removing a record from the namestore, hence we don't require this particular option to match upon removal). See also GNUNET_GNSRECORD_records_cmp.

Definition at line 83 of file gnunet_gnsrecord_lib.h.

Typedef Documentation

GNUNET_GNSRECORD_RecordCallback

typedef void(* GNUNET_GNSRECORD_RecordCallback) (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)

Process a records that were decrypted from a block.

Parameters

cls	closure
rd_count	number of entries in rd array
rd	array of records with data to store

Definition at line 359 of file gnunet_gnsrecord_lib.h.

Enumeration Type Documentation

GNUNET_GNSRECORD_Flags

enum GNUNET_GNSRECORD_Flags

Flags that can be set for a record.

The numbers in the registry correspond to the bit index as specified in LSD0001 Chapter "Resource Records". Each enum member represents the 16-bit integer value of the flags field if only that particular flag was set. The value can be used to efficiently compare the bitmask setting for the record flag in C. WARNING: The values are in host byte order! In order to correctly check against the flags field a record, the respective fields must also be converted to HBO (or the enum value to NBO).

Enumerator
GNUNET_GNSRECORD_RF_NONE	Entry for no flags / cleared flags.
GNUNET_GNSRECORD_RF_CRITICAL	This record is critical. If it cannot be processed (for example because the record type is unknown) resolution MUST fail
GNUNET_GNSRECORD_RF_SHADOW	This record should not be used unless all (other) records in the set with an absolute expiration time have expired.
GNUNET_GNSRECORD_RF_SUPPLEMENTAL	This is a supplemental record.
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION	This expiration time of the record is a relative time (not an absolute time). Used in GNUnet implementation.
GNUNET_GNSRECORD_RF_PRIVATE	This is a private record of this peer and it should thus not be published.
GNUNET_GNSRECORD_RF_NONE	Entry for no flags / cleared flags.
GNUNET_GNSRECORD_RF_CRITICAL	This record is critical. If it cannot be processed (for example because the record type is unknown) resolution MUST fail
GNUNET_GNSRECORD_RF_SHADOW	This record should not be used unless all (other) records in the set with an absolute expiration time have expired.
GNUNET_GNSRECORD_RF_SUPPLEMENTAL	This is a supplemental record.
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION	This expiration time of the record is a relative time (not an absolute time). Used in GNUnet implementation.
GNUNET_GNSRECORD_RF_PRIVATE	This is a private record of this peer and it should thus not be published.

Definition at line 98 of file gnunet_gnsrecord_lib.h.

{
  GNUNET_GNSRECORD_RF_NONE = 0,
 
 
  GNUNET_GNSRECORD_RF_CRITICAL = 1 << (15 - 15),
 
 
  GNUNET_GNSRECORD_RF_SHADOW = 1 << (15 - 14),
 
 
  GNUNET_GNSRECORD_RF_SUPPLEMENTAL = 1 << (15 - 13),
 
 
  GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION = 1 << (15 - 1),
 
 
  GNUNET_GNSRECORD_RF_PRIVATE = 1 << (15 - 0),
 
};

GNUNET_GNSRECORD_Filter

enum GNUNET_GNSRECORD_Filter

Filter for GNUNET_GNSRECORD_normalize_record_set().

Enumerator
GNUNET_GNSRECORD_FILTER_NONE	No filter flags set. Private and public records are returned, maintenance records (TOMBSTONE etc) are not.
GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE	Include maintenance records (TOMBSTONE etc).
GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE	Filter private records.

Definition at line 141 of file gnunet_gnsrecord_lib.h.

{
  GNUNET_GNSRECORD_FILTER_NONE = 0,
 
  GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE = 1,
 
  GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE = 2,
 
  // GNUNET_NAMESTORE_FILTER_OMIT_PUBLIC = 4,
};

Function Documentation

GNUNET_GNSRECORD_JSON_spec_gnsrecord()

struct GNUNET_JSON_Specification GNUNET_GNSRECORD_JSON_spec_gnsrecord	(	struct GNUNET_GNSRECORD_Data **	rd,
		unsigned int *	rd_count,
		char **	name
	)

JSON Specification for GNS Records.

Parameters

gnsrecord_object

struct of GNUNET_GNSRECORD_Data to fill

Returns

JSON Specification

Definition at line 256 of file json_gnsrecord.c.

{
  struct GnsRecordInfo *gnsrecord_info = GNUNET_new (struct GnsRecordInfo);
 
  gnsrecord_info->rd = rd;
  gnsrecord_info->name = name;
  gnsrecord_info->rd_count = rd_count;
  struct GNUNET_JSON_Specification ret = { .parser = &parse_gnsrecordobject,
                                           .cleaner = &clean_gnsrecordobject,
                                           .cls = NULL,
                                           .field = NULL,
                                           .ptr = (struct GnsRecordInfo *)
                                                  gnsrecord_info,
                                           .ptr_size = 0,
                                           .size_ptr = NULL };
  return ret;
}

Referenced by bulk_tx_start(), and namestore_add_or_update().

Here is the caller graph for this function:

GNUNET_GNSRECORD_JSON_from_gnsrecord()

json_t* GNUNET_GNSRECORD_JSON_from_gnsrecord	(	const char *	rname,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count
	)

Convert GNS record to JSON.

Parameters

rname	name of record
rd	record data

Returns

corresponding JSON encoding

Definition at line 300 of file json_gnsrecord.c.

{
  const char *record_type_str;
  char *value_str;
  json_t *data;
  json_t *record;
  json_t *records;
 
  data = json_object ();
  if (NULL == data)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (0 !=
      json_object_set_new (data,
                           "record_name",
                           json_string (rname)))
  {
    GNUNET_break (0);
    json_decref (data);
    return NULL;
  }
  records = json_array ();
  if (NULL == records)
  {
    GNUNET_break (0);
    json_decref (data);
    return NULL;
  }
  for (int i = 0; i < rd_count; i++)
  {
    value_str = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                                  rd[i].data,
                                                  rd[i].data_size);
    record_type_str = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Packing %s %s %lu %d\n",
                value_str, record_type_str, rd[i].expiration_time, rd[i].flags);
    record = json_pack ("{s:s,s:s,s:I,s:b,s:b,s:b,s:b}",
                        GNUNET_JSON_GNSRECORD_VALUE,
                        value_str,
                        GNUNET_JSON_GNSRECORD_TYPE,
                        record_type_str,
                        (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION) ?
                        GNUNET_JSON_GNSRECORD_RELATIVE_EXPIRATION_TIME : GNUNET_JSON_GNSRECORD_ABSOLUTE_EXPIRATION_TIME,
                        rd[i].expiration_time,
                        GNUNET_JSON_GNSRECORD_FLAG_PRIVATE,
                        rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE,
                        GNUNET_JSON_GNSRECORD_FLAG_RELATIVE,
                        rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION,
                        GNUNET_JSON_GNSRECORD_FLAG_SUPPLEMENTAL,
                        rd[i].flags & GNUNET_GNSRECORD_RF_SUPPLEMENTAL,
                        GNUNET_JSON_GNSRECORD_FLAG_SUPPLEMENTAL,
                        rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW);
    GNUNET_free (value_str);
    if (NULL == record)
    {
      GNUNET_break (0);
      json_decref (records);
      json_decref (data);
      return NULL;
    }
    if (0 !=
        json_array_append_new (records,
                               record))
    {
      GNUNET_break (0);
      json_decref (records);
      json_decref (data);
      return NULL;
    }
  }
  if (0 !=
      json_object_set_new (data,
                           "data",
                           records))
  {
    GNUNET_break (0);
    json_decref (data);
    return NULL;
  }
  return data;
}

References data, data_size, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_value_to_string(), GNUNET_JSON_GNSRECORD_ABSOLUTE_EXPIRATION_TIME, GNUNET_JSON_GNSRECORD_FLAG_PRIVATE, GNUNET_JSON_GNSRECORD_FLAG_RELATIVE, GNUNET_JSON_GNSRECORD_FLAG_SUPPLEMENTAL, GNUNET_JSON_GNSRECORD_RELATIVE_EXPIRATION_TIME, GNUNET_JSON_GNSRECORD_TYPE, GNUNET_JSON_GNSRECORD_VALUE, GNUNET_log, rd, rd_count, record(), and records.

Referenced by handle_gns_response(), namestore_list_iteration(), and ns_get_lookup_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_value_to_string()

char* GNUNET_GNSRECORD_value_to_string	(	uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Convert the binary value data of a record of type type to a human-readable string.

Parameters

type	type of the record
data	value in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the value

Convert the binary value data of a record of type type to a human-readable string.

Parameters

type	type of the record
data	value in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the value

Definition at line 155 of file gnsrecord.c.

{
  struct Plugin *plugin;
  char *ret;
 
  init ();
  for (unsigned int i = 0; i < num_plugins; i++)
  {
    plugin = gns_plugins[i];
    if (NULL != (ret = plugin->api->value_to_string (plugin->api->cls,
                                                     type,
                                                     data,
                                                     data_size)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, data, data_size, gns_plugins, init(), num_plugins, plugin, ret, and type.

Referenced by check_pkey(), del_monitor(), display_record(), display_records_from_block(), gns_value_to_string(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), process_lookup_result(), and start_phone().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_string_to_value()

int GNUNET_GNSRECORD_string_to_value	(	uint32_t	type,
		const char *	s,
		void **	data,
		size_t *	data_size
	)

Convert human-readable version of the value s of a record of type type to the respective binary representation.

Parameters

type	type of the record
s	human-readable string
data	set to value in binary encoding (will be allocated)
data_size	set to number of bytes in data

Returns

GNUNET_OK on success

Definition at line 177 of file gnsrecord.c.

{
  struct Plugin *plugin;
 
  init ();
  for (unsigned int i = 0; i < num_plugins; i++)
  {
    plugin = gns_plugins[i];
    if (GNUNET_OK == plugin->api->string_to_value (plugin->api->cls,
                                                   type,
                                                   s,
                                                   data,
                                                   data_size))
      return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, data, data_size, gns_plugins, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, plugin, and type.

Referenced by gns_string_to_value(), parse(), parse_record(), parse_recordline(), run(), run_with_zone_pkey(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_typename_to_number()

uint32_t GNUNET_GNSRECORD_typename_to_number

(

const char *

dns_typename

)

Convert a type name (e.g.

"AAAA") to the corresponding number.

Parameters

dns_typename

name to convert

Returns

corresponding number, UINT32_MAX on error

Definition at line 200 of file gnsrecord.c.

{
  struct Plugin *plugin;
  uint32_t ret;
 
  if (0 == strcasecmp (dns_typename,
                       "ANY"))
    return GNUNET_GNSRECORD_TYPE_ANY;
  init ();
  for (unsigned int i = 0; i < num_plugins; i++)
  {
    plugin = gns_plugins[i];
    if (UINT32_MAX != (ret = plugin->api->typename_to_number (plugin->api->cls,
                                                              dns_typename)))
      return ret;
  }
  return UINT32_MAX;
}

References TestcasePlugin::api, gns_plugins, GNUNET_GNSRECORD_TYPE_ANY, init(), num_plugins, plugin, and ret.

Referenced by del_monitor(), DID_create(), display_record(), get_gns_cont(), namestore_get(), parse(), parse_record(), parse_recordline(), run(), and run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_number_to_typename()

const char* GNUNET_GNSRECORD_number_to_typename

(

uint32_t

type

)

Convert a type number to the corresponding type string (e.g.

1 to "A")

Parameters

type	number of a type to convert

Returns

corresponding typestring, NULL on error

Definition at line 227 of file gnsrecord.c.

{
  struct Plugin *plugin;
  const char *ret;
 
  if (GNUNET_GNSRECORD_TYPE_ANY == type)
    return "ANY";
  init ();
  for (unsigned int i = 0; i < num_plugins; i++)
  {
    plugin = gns_plugins[i];
    if (NULL != (ret = plugin->api->number_to_typename (plugin->api->cls,
                                                        type)))
      return ret;
  }
  return NULL;
}

Referenced by display_record(), display_records_from_block(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), parse_recordline(), process_lookup_result(), and run_with_zone_pkey().

Here is the caller graph for this function:

GNUNET_GNSRECORD_records_get_size()

ssize_t GNUNET_GNSRECORD_records_get_size	(	unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data *	rd
	)

Calculate how many bytes we will need to serialize the given records.

Parameters

rd_count	number of records in the rd array
rd	array of GNUNET_GNSRECORD_Data with rd_count elements

Returns

the required size to serialize, -1 on error

Efficiently round up to the next power of 2 for padding https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2

Definition at line 78 of file gnsrecord_serialization.c.

{
  size_t ret;
 
  if (0 == rd_count)
    return 0;
 
  ret = sizeof(struct NetworkRecord) * rd_count;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    if ((ret + rd[i].data_size) < ret)
    {
      GNUNET_break (0);
      return -1;
    }
    ret += rd[i].data_size;
#if DEBUG_GNSRECORDS
    {
      char *str;
 
      str = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                              rd[i].data,
                                              rd[i].data_size);
      if (NULL == str)
      {
        GNUNET_break_op (0);
        return -1;
      }
      GNUNET_free (str);
    }
#endif
  }
  if (ret > SSIZE_MAX)
  {
    GNUNET_break (0);
    return -1;
  }
  // Do not pad PKEY
  if ((GNUNET_GNSRECORD_TYPE_PKEY == rd->record_type) ||
      (GNUNET_GNSRECORD_TYPE_EDKEY == rd->record_type))
    return ret;ret--;
  ret |= ret >> 1;
  ret |= ret >> 2;
  ret |= ret >> 4;
  ret |= ret >> 8;
  ret |= ret >> 16;
  ret++;
  return (ssize_t) ret;
}

References data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_break, GNUNET_break_op, GNUNET_free, GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_GNSRECORD_value_to_string(), rd, rd_count, NetworkRecord::record_type, GNUNET_GNSRECORD_Data::record_type, and ret.

Referenced by block_create_ecdsa(), block_create_eddsa(), check_zone_to_name(), consistency_iter(), GNUNET_NAMESTORE_records_store2(), lookup_it(), result_processor(), run_edkey(), run_pkey(), rvk_ticket_update(), send_lookup_response(), send_lookup_response_with_filter(), and store_and_free_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_records_serialize()

ssize_t GNUNET_GNSRECORD_records_serialize	(	unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data *	rd,
		size_t	dest_size,
		char *	dest
	)

Serialize the given records to the given destination buffer.

Parameters

rd_count	number of records in the rd array
rd	array of GNUNET_GNSRECORD_Data with rd_count elements
dest_size	size of the destination array dst
dest	where to write the result

Returns

the size of serialized records, -1 if records do not fit

Definition at line 136 of file gnsrecord_serialization.c.

{
  struct NetworkRecord rec;
  size_t off;
 
  off = 0;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Serializing record %u with flags %d and expiration time %llu\n",
         i,
         rd[i].flags,
         (unsigned long long) rd[i].expiration_time);
    rec.expiration_time = GNUNET_htonll (rd[i].expiration_time);
    rec.data_size = htons ((uint16_t) rd[i].data_size);
    rec.record_type = htonl (rd[i].record_type);
    rec.flags = htons (rd[i].flags);
    if ((off + sizeof(rec) > dest_size) ||
        (off + sizeof(rec) < off))
    {
      GNUNET_break (0);
      return -1;
    }
    GNUNET_memcpy (&dest[off],
                   &rec,
                   sizeof(rec));
    off += sizeof(rec);
    if ((off + rd[i].data_size > dest_size) ||
        (off + rd[i].data_size < off))
    {
      GNUNET_break (0);
      return -1;
    }
    GNUNET_memcpy (&dest[off],
                   rd[i].data,
                   rd[i].data_size);
    off += rd[i].data_size;
#if DEBUG_GNSRECORDS
    {
      char *str;
 
      str = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                              rd[i].data,
                                              rd[i].data_size);
      if (NULL == str)
      {
        GNUNET_break_op (0);
        return -1;
      }
      GNUNET_free (str);
    }
#endif
  }
  memset (&dest[off],
          0,
          dest_size - off);
  return dest_size;
}

References data, data_size, NetworkRecord::data_size, GNUNET_GNSRECORD_Data::data_size, warningfilter::dest, NetworkRecord::expiration_time, NetworkRecord::flags, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_value_to_string(), GNUNET_htonll(), GNUNET_memcpy, LOG, rd, rd_count, and NetworkRecord::record_type.

Referenced by check_zone_to_name(), consistency_iter(), GNUNET_NAMESTORE_records_store2(), lookup_it(), result_processor(), run_edkey(), run_pkey(), rvk_ticket_update(), send_lookup_response(), send_lookup_response_with_filter(), and store_and_free_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_records_deserialize_get_size()

unsigned int GNUNET_GNSRECORD_records_deserialize_get_size	(	size_t	len,
		const char *	src
	)

Definition at line 199 of file gnsrecord_serialization.c.

{
  struct NetworkRecord rec;
  struct NetworkRecord rec_zero;
  size_t off;
  unsigned int rd_count = 0;
 
  memset (&rec_zero, 0, sizeof (rec_zero));
 
  off = 0;
  for (off = 0; (off + sizeof(rec) <= len) && (off + sizeof(rec) >= off);)
  {
    GNUNET_memcpy (&rec,
                   &src[off],
                   sizeof(rec));
    /*
     * If we have found a byte string of zeroes, we have reached
     * the padding
     */
    if (0 == GNUNET_memcmp (&rec, &rec_zero))
      break;
    off += sizeof(rec);
    if ((off + ntohs ((uint16_t) rec.data_size) > len) ||
        (off + ntohs ((uint16_t) rec.data_size) < off))
    {
      GNUNET_break_op (0);
      return 0;
    }
    off += ntohs ((uint16_t) rec.data_size);
    rd_count++;
  }
  return rd_count;
}

References NetworkRecord::data_size, GNUNET_break_op, GNUNET_memcmp, GNUNET_memcpy, len, and rd_count.

GNUNET_GNSRECORD_records_deserialize()

int GNUNET_GNSRECORD_records_deserialize	(	size_t	len,
		const char *	src,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Data *	dest
	)

Deserialize the given records to the given destination.

Parameters

len	size of the serialized record data
src	the serialized record data
rd_count	number of records in the dest array
dest	where to put the data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Parameters

len	size of the serialized record data
src	the serialized record data
rd_count	number of records parsed
dest	where to put the data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 244 of file gnsrecord_serialization.c.

{
  struct NetworkRecord rec;
  size_t off;
 
  off = 0;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    if ((off + sizeof(rec) > len) ||
        (off + sizeof(rec) < off))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    GNUNET_memcpy (&rec,
                   &src[off],
                   sizeof(rec));
    dest[i].expiration_time = GNUNET_ntohll (rec.expiration_time);
    dest[i].data_size = ntohs ((uint16_t) rec.data_size);
    dest[i].record_type = ntohl (rec.record_type);
    dest[i].flags = ntohs (rec.flags);
    off += sizeof(rec);
    if ((off + dest[i].data_size > len) ||
        (off + dest[i].data_size < off))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    dest[i].data = &src[off];
    off += dest[i].data_size;
#if GNUNET_EXTRA_LOGGING
    {
      char *str;
 
      str = GNUNET_GNSRECORD_value_to_string (dest[i].record_type,
                                              dest[i].data,
                                              dest[i].data_size);
      if (NULL == str)
      {
        GNUNET_break_op (0);
        return GNUNET_SYSERR;
      }
      GNUNET_free (str);
    }
#endif
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Deserialized record %u with flags %d and expiration time %llu\n",
         i,
         dest[i].flags,
         (unsigned long long) dest[i].expiration_time);
  }
  return GNUNET_OK;
}

References data, data_size, NetworkRecord::data_size, warningfilter::dest, NetworkRecord::expiration_time, NetworkRecord::flags, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_value_to_string(), GNUNET_memcpy, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, len, LOG, rd_count, and NetworkRecord::record_type.

Referenced by check_rd(), check_result(), continue_store_activity(), database_setup(), handle_lookup_result(), handle_record_result(), handle_result(), handle_zone_to_name_response(), lookup_records(), process_tickets(), update_tickets(), and vpn_allocation_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_is_expired()

int GNUNET_GNSRECORD_is_expired

(

const struct GNUNET_GNSRECORD_Data *

rd

)

Test if a given record is expired.

Parameters

rd	record to test

Returns

GNUNET_YES if the record is expired, GNUNET_NO if not

GNUNET_YES if the record is expired, GNUNET_NO if not

Definition at line 208 of file gnsrecord_misc.c.

{
  struct GNUNET_TIME_Absolute at;
 
  if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    return GNUNET_NO;
  at.abs_value_us = rd->expiration_time;
  return (0 == GNUNET_TIME_absolute_get_remaining (at).rel_value_us) ?
         GNUNET_YES : GNUNET_NO;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, and rd.

Here is the call graph for this function:

GNUNET_GNSRECORD_string_normalize()

char* GNUNET_GNSRECORD_string_normalize

(

const char *

src

)

Normalize a UTF-8 string to a GNS name.

Parameters

src	source string

Returns

converted result

Definition at line 39 of file gnsrecord_misc.c.

{
  /*FIXME: We may want to follow RFC5890/RFC5891 */
  return GNUNET_STRINGS_utf8_normalize (src);
}

Referenced by continue_store_activity(), GNUNET_GNSRECORD_query_from_private_key(), handle_record_lookup(), run_edkey(), and run_pkey().

Here is the caller graph for this function:

GNUNET_GNSRECORD_z2s()

const char* GNUNET_GNSRECORD_z2s

(

const struct GNUNET_IDENTITY_PublicKey *

z

)

Convert a zone to a string (for printing debug messages).

This is one of the very few calls in the entire API that is NOT reentrant!

Parameters

z	public key of a zone

Returns

string form; will be overwritten by next call to GNUNET_GNSRECORD_z2s.

Definition at line 64 of file gnsrecord_misc.c.

{
  static char buf[sizeof(struct GNUNET_IDENTITY_PublicKey) * 8];
  char *end;
 
  end = GNUNET_STRINGS_data_to_string ((const unsigned char *) z,
                                       sizeof(struct
                                              GNUNET_IDENTITY_PublicKey),
                                       buf, sizeof(buf));
  if (NULL == end)
  {
    GNUNET_break (0);
    return NULL;
  }
  *end = '\0';
  return buf;
}

References buf, end, GNUNET_break, and GNUNET_STRINGS_data_to_string().

Referenced by get_nick_record(), handle_gns_resolution_result(), handle_namecache_block_response(), handle_revocation_result(), namestore_flat_zone_to_name(), recursive_gns_resolution_namecache(), and recursive_gns_resolution_revocation().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_pkey_to_zkey()

const char* GNUNET_GNSRECORD_pkey_to_zkey

(

const struct GNUNET_IDENTITY_PublicKey *

pkey

)

Convert public key to the respective absolute domain name in the ".zkey" pTLD.

This is one of the very few calls in the entire API that is NOT reentrant!

Parameters

pkey	a public key with a point on the eliptic curve

Returns

string "X.zkey" where X is the coordinates of the public key in an encoding suitable for DNS labels.

This is one of the very few calls in the entire API that is NOT reentrant!

Parameters

pkey	a public key with a point on the eliptic curve

Returns

string "X.zkey" where X is the public key in an encoding suitable for DNS labels.

Definition at line 231 of file gnsrecord_misc.c.

{
  static char ret[128];
  char *pkeys;
 
  pkeys = GNUNET_IDENTITY_public_key_to_string (pkey);
  GNUNET_snprintf (ret,
                   sizeof(ret),
                   "%s",
                   pkeys);
  GNUNET_free (pkeys);
  return ret;
}

References GNUNET_free, GNUNET_IDENTITY_public_key_to_string(), GNUNET_snprintf(), pkey, and ret.

Referenced by caller_event_handler(), do_accept(), do_call(), do_resume(), do_status(), handle_phone_hangup(), phone_event_handler(), and translate_dot_plus().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_zkey_to_pkey()

int GNUNET_GNSRECORD_zkey_to_pkey	(	const char *	zkey,
		struct GNUNET_IDENTITY_PublicKey *	pkey
	)

Convert an absolute domain name to the respective public key.

Parameters

zkey	string "X" where X is the public key in an encoding suitable for DNS labels.
pkey	set to a public key on the eliptic curve

Returns

GNUNET_SYSERR if zkey has the wrong syntax

Parameters

zkey	string encoding the coordinates of the public key in an encoding suitable for DNS labels.
pkey	set to a public key on the eliptic curve

Returns

GNUNET_SYSERR if zkey has the wrong syntax

Definition at line 256 of file gnsrecord_misc.c.

{
  if (GNUNET_OK !=
      GNUNET_IDENTITY_public_key_from_string (zkey,
                                              pkey))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

Referenced by GNS_find_tld(), handle_gns_redirect_result(), and recursive_gns2dns_resolution().

Here is the caller graph for this function:

GNUNET_GNSRECORD_query_from_private_key()

void GNUNET_GNSRECORD_query_from_private_key	(	const struct GNUNET_IDENTITY_PrivateKey *	zone,
		const char *	label,
		struct GNUNET_HashCode *	query
	)

Calculate the DHT query for a given label in a given zone.

Parameters

zone	private key of the zone
label	label of the record
query	hash to use for the query

Definition at line 1021 of file gnsrecord_crypto.c.

{
  char *norm_label;
  struct GNUNET_IDENTITY_PublicKey pub;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
  switch (ntohl (zone->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
  case GNUNET_GNSRECORD_TYPE_EDKEY:
 
    GNUNET_IDENTITY_key_get_public (zone,
                                    &pub);
    GNUNET_GNSRECORD_query_from_public_key (&pub,
                                            norm_label,
                                            query);
    break;
  default:
    GNUNET_assert (0);
  }
  GNUNET_free (norm_label);
}

References GNUNET_assert, GNUNET_free, GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_IDENTITY_key_get_public(), pub, and zone.

Referenced by initiate_put_from_pipe_trigger().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_query_from_public_key()

void GNUNET_GNSRECORD_query_from_public_key	(	const struct GNUNET_IDENTITY_PublicKey *	pub,
		const char *	label,
		struct GNUNET_HashCode *	query
	)

Calculate the DHT query for a given label in a given zone.

FIXME: We may want to plugin-ize this at some point.

Parameters

pub	public key of the zone
label	label of the record
query	hash to use for the query

Definition at line 1049 of file gnsrecord_crypto.c.

{
  char *norm_label;
  struct GNUNET_IDENTITY_PublicKey pd;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
 
  switch (ntohl (pub->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    pd.type = pub->type;
    GNUNET_CRYPTO_ecdsa_public_key_derive (&pub->ecdsa_key,
                                           norm_label,
                                           "gns",
                                           &pd.ecdsa_key);
    GNUNET_CRYPTO_hash (&pd.ecdsa_key,
                        sizeof (pd.ecdsa_key),
                        query);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    pd.type = pub->type;
    GNUNET_CRYPTO_eddsa_public_key_derive (&pub->eddsa_key,
                                           norm_label,
                                           "gns",
                                           &(pd.eddsa_key));
    GNUNET_CRYPTO_hash (&pd.eddsa_key,
                        sizeof (pd.eddsa_key),
                        query);
    break;
  default:
    GNUNET_assert (0);
  }
  GNUNET_free (norm_label);
}

Referenced by GNUNET_GNSRECORD_query_from_private_key(), handle_namecache_block_response(), recursive_gns_resolution_namecache(), run(), run_edkey(), and run_pkey().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_calculate_size()

ssize_t GNUNET_GNSRECORD_block_calculate_size	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count
	)

Get size of buffer for block creation.

Parameters

key	the zone key
rd	record data
rd_count	number of records

Returns

-1 on error (otherwise the length of the block)

Definition at line 509 of file gnsrecord_crypto.c.

{
  struct GNUNET_IDENTITY_PublicKey pkey;
  ssize_t res = -1;
 
  GNUNET_IDENTITY_key_get_public (key,
                                  &pkey);
  switch (ntohl (key->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    res = block_get_size_ecdsa (rd, rd_count);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    res = block_get_size_eddsa (rd, rd_count);
    break;
  default:
    GNUNET_assert (0);
  }
  return res;
 
}

GNUNET_GNSRECORD_block_sign()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_sign	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		const char *	label,
		struct GNUNET_GNSRECORD_Block *	block
	)

Sign a block create with GNUNET_GNSRECORD_block_create_unsigned.

Parameters

key	the private key
label	the label of the block
block	the unsigned block

Returns

GNUNET_OK on success

Definition at line 186 of file gnsrecord_crypto.c.

{
  struct GNUNET_IDENTITY_PublicKey pkey;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  GNUNET_IDENTITY_key_get_public (key,
                                  &pkey);
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
 
  switch (ntohl (key->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    res = block_sign_ecdsa (&key->ecdsa_key,
                            &pkey.ecdsa_key,
                            norm_label,
                            block);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    res = block_sign_eddsa (&key->eddsa_key,
                            &pkey.eddsa_key,
                            norm_label,
                            block);
    break;
  default:
    GNUNET_assert (0);
  }
  GNUNET_free (norm_label);
  return res;
}

Referenced by sign_worker().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	block
	)

Sign name and records.

Parameters

key	the private key
expire	block expiration
label	the name for the records
rd	record data
rd_count	number of records in rd
result	the block buffer. Will be allocated.

Returns

GNUNET_OK on success

Definition at line 509 of file gnsrecord_crypto.c.

{
  struct GNUNET_IDENTITY_PublicKey pkey;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  GNUNET_IDENTITY_key_get_public (key,
                                  &pkey);
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
 
  switch (ntohl (key->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    res = block_create_ecdsa (&key->ecdsa_key,
                              &pkey.ecdsa_key,
                              expire,
                              norm_label,
                              rd,
                              rd_count,
                              result,
                              GNUNET_YES);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    res = block_create_eddsa (&key->eddsa_key,
                              &pkey.eddsa_key,
                              expire,
                              norm_label,
                              rd,
                              rd_count,
                              result,
                              GNUNET_YES);
    break;
  default:
    GNUNET_assert (0);
  }
  GNUNET_free (norm_label);
  return res;
}

Referenced by run_edkey(), and run_pkey().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create_unsigned()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create_unsigned	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	result
	)

Create name and records but do not sign! Sign later with GNUNET_GNSRECORD_block_sign().

Cache derived public key (also keeps the private key in static memory, so do not use this function if keeping the private key in the process'es RAM is a major issue).

Parameters

key	the private key
expire	block expiration
label	the name for the records
rd	record data
rd_count	number of records in rd
result	the block buffer. Will be allocated.

Returns

GNUNET_OK on success.

Definition at line 509 of file gnsrecord_crypto.c.

{
  return block_create2 (pkey, expire, label, rd, rd_count, result, GNUNET_NO);
}

Referenced by dispatch_job(), and dispatch_job_monitor().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create2()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create2	(	const struct GNUNET_IDENTITY_PrivateKey *	key,
		struct GNUNET_TIME_Absolute	expire,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Block **	result
	)

Sign name and records, cache derived public key (also keeps the private key in static memory, so do not use this function if keeping the private key in the process'es RAM is a major issue).

Parameters

key	the private key
expire	block expiration
label	the name for the records
rd	record data
rd_count	number of records in rd
result	the block buffer. Will be allocated.

Returns

GNUNET_OK on success.

Definition at line 509 of file gnsrecord_crypto.c.

{
  return block_create2 (pkey, expire, label, rd, rd_count, result, GNUNET_YES);
}

GNUNET_GNSRECORD_block_verify()

int GNUNET_GNSRECORD_block_verify

(

const struct GNUNET_GNSRECORD_Block *

block

)

Check if a signature is valid.

This API is used by the GNS Block to validate signatures received from the network.

Parameters

block

block to verify

Returns

GNUNET_OK if the signature is valid

Definition at line 509 of file gnsrecord_crypto.c.

{
  struct GNRBlockPS *purp;
  size_t payload_len = ntohl (block->size)
                       - sizeof (struct GNUNET_GNSRECORD_Block);
  enum GNUNET_GenericReturnValue res = GNUNET_NO;
  purp = GNUNET_malloc (sizeof (struct GNRBlockPS) + payload_len);
  purp->purpose.size = htonl (sizeof (struct GNRBlockPS) + payload_len);
  purp->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
  GNUNET_memcpy (&purp[1],
                 &block[1],
                 payload_len);
  switch (ntohl (block->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    purp->expiration_time = block->ecdsa_block.expiration_time;
    res = GNUNET_CRYPTO_ecdsa_verify_ (
      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
      &purp->purpose,
      &block->ecdsa_block.signature,
      &block->ecdsa_block.derived_key);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    purp->expiration_time = block->eddsa_block.expiration_time;
    res = GNUNET_CRYPTO_eddsa_verify_ (
      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
      &purp->purpose,
      &block->eddsa_block.signature,
      &block->eddsa_block.derived_key);
    break;
  default:
    res = GNUNET_NO;
  }
  GNUNET_free (purp);
  return res;
}

Referenced by handle_lookup_block_response().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_decrypt()

int GNUNET_GNSRECORD_block_decrypt	(	const struct GNUNET_GNSRECORD_Block *	block,
		const struct GNUNET_IDENTITY_PublicKey *	zone_key,
		const char *	label,
		GNUNET_GNSRECORD_RecordCallback	proc,
		void *	proc_cls
	)

Decrypt block.

Parameters

block	block to decrypt
zone_key	public key of the zone
label	the name for the records
proc	function to call with the result
proc_cls	closure for proc

Returns

GNUNET_OK on success, GNUNET_SYSERR if the block was not well-formed

Definition at line 509 of file gnsrecord_crypto.c.

{
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
  switch (ntohl (zone_key->type))
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    res = block_decrypt_ecdsa (block,
                               &zone_key->ecdsa_key, norm_label, proc,
                               proc_cls);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    res = block_decrypt_eddsa (block,
                               &zone_key->eddsa_key, norm_label, proc,
                               proc_cls);
    break;
  default:
    res = GNUNET_SYSERR;
  }
  GNUNET_free (norm_label);
  return res;
}

Referenced by handle_block(), handle_dht_response(), and handle_namecache_block_response().

Here is the caller graph for this function:

GNUNET_GNSRECORD_records_cmp()

int GNUNET_GNSRECORD_records_cmp	(	const struct GNUNET_GNSRECORD_Data *	a,
		const struct GNUNET_GNSRECORD_Data *	b
	)

Compares if two records are equal.

Parameters

a	a record
b	another record

Returns

GNUNET_YES if the records are equal, or GNUNET_NO if not.

Compares if two records are equal.

absolute expiration time).

Parameters

a	record
b	record

Returns

GNUNET_YES if the records are equal or GNUNET_NO if they are not

Definition at line 93 of file gnsrecord_misc.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Comparing records\n");
  if (a->record_type != b->record_type)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Record type %u != %u\n", a->record_type, b->record_type);
    return GNUNET_NO;
  }
  if ((a->expiration_time != b->expiration_time) &&
      ((a->expiration_time != 0) && (b->expiration_time != 0)))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Expiration time %llu != %llu\n",
         (unsigned long long) a->expiration_time,
         (unsigned long long) b->expiration_time);
    return GNUNET_NO;
  }
  if ((a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS)
      != (b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Flags %u (%u) != %u (%u)\n", a->flags,
         a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS, b->flags,
         b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS);
    return GNUNET_NO;
  }
  if (a->data_size != b->data_size)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Data size %lu != %lu\n",
         a->data_size,
         b->data_size);
    return GNUNET_NO;
  }
  if (0 != memcmp (a->data, b->data, a->data_size))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Data contents do not match\n");
    return GNUNET_NO;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Records are equal\n");
  return GNUNET_YES;
}

GNUNET_GNSRECORD_record_get_expiration_time()

struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_record_get_expiration_time	(	unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data *	rd,
		struct GNUNET_TIME_Absolute	min
	)

Returns the expiration time of the given block of records.

The block expiration time is the expiration time of the record with smallest expiration time.

Parameters

rd_count	number of records given in rd
rd	array of records
min	minimum expiration time

Returns

absolute expiration time

Definition at line 93 of file gnsrecord_misc.c.

{
  struct GNUNET_TIME_Absolute expire;
  struct GNUNET_TIME_Absolute at;
  struct GNUNET_TIME_Relative rt;
  struct GNUNET_TIME_Absolute at_shadow;
  struct GNUNET_TIME_Relative rt_shadow;
 
  if (0 == rd_count)
    return GNUNET_TIME_absolute_max (GNUNET_TIME_UNIT_ZERO_ABS, min);
  expire = GNUNET_TIME_UNIT_FOREVER_ABS;
  for (unsigned int c = 0; c < rd_count; c++)
  {
    if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      rt.rel_value_us = rd[c].expiration_time;
      at = GNUNET_TIME_relative_to_absolute (rt);
    }
    else
    {
      at.abs_value_us = rd[c].expiration_time;
    }
 
    for (unsigned int c2 = 0; c2 < rd_count; c2++)
    {
      /* Check for shadow record */
      if ((c == c2) ||
          (rd[c].record_type != rd[c2].record_type) ||
          (0 == (rd[c2].flags & GNUNET_GNSRECORD_RF_SHADOW)))
        continue;
      /* We have a shadow record */
      if (0 != (rd[c2].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
      {
        rt_shadow.rel_value_us = rd[c2].expiration_time;
        at_shadow = GNUNET_TIME_relative_to_absolute (rt_shadow);
      }
      else
      {
        at_shadow.abs_value_us = rd[c2].expiration_time;
      }
      at = GNUNET_TIME_absolute_max (at,
                                     at_shadow);
    }
    expire = GNUNET_TIME_absolute_min (at,
                                       expire);
  }
  expire = GNUNET_TIME_absolute_max (expire, min);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Determined expiration time for block with %u records to be %s\n",
       rd_count,
       GNUNET_STRINGS_absolute_time_to_string (expire));
  return expire;
}

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_RCMP_FLAGS, GNUNET_NO, GNUNET_YES, LOG, and GNUNET_GNSRECORD_Data::record_type.

Referenced by run_edkey(), and run_pkey().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_get_size()

size_t GNUNET_GNSRECORD_block_get_size

(

const struct GNUNET_GNSRECORD_Block *

block

)

Returns the length of this block in bytes.

Block length strongly depends on the zone type.

Parameters

block

the block.

Returns

the length of this block in bytes

Definition at line 330 of file gnsrecord_misc.c.

{
  return ntohl (block->size);
}

Referenced by dispatch_job(), dispatch_job_monitor(), GNUNET_NAMECACHE_block_cache(), handle_dht_response(), handle_lookup_block_it(), namecache_cache_block(), namecache_sqlite_cache_block(), and store_and_free_entries().

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_get_expiration()

struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_block_get_expiration

(

const struct GNUNET_GNSRECORD_Block *

block

)

Returns the expiration of a block.

Parameters

block

the block.

Returns

the block expiration.

Definition at line 330 of file gnsrecord_misc.c.

{
 
  switch (ntohl (block->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    return GNUNET_TIME_absolute_ntoh (block->ecdsa_block.expiration_time);
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    return GNUNET_TIME_absolute_ntoh (block->eddsa_block.expiration_time);
  default:
    GNUNET_break (0); /* Hopefully we never get here, but we might */
  }
  return GNUNET_TIME_absolute_get_zero_ ();
 
}

References GNUNET_GNSRECORD_Block::size.

Referenced by expire_blocks(), handle_dht_response(), handle_lookup_block_it(), handle_namecache_block_response(), and namecache_sqlite_cache_block().

Here is the caller graph for this function:

GNUNET_GNSRECORD_query_from_block()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_query_from_block	(	const struct GNUNET_GNSRECORD_Block *	block,
		struct GNUNET_HashCode *	query
	)

Builds the query hash from a block.

Parameters

block	the block.
query	where to write the query hash.

Returns

GNUNET_SYSERR on error.

Definition at line 330 of file gnsrecord_misc.c.

{
  switch (ntohl (block->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    GNUNET_CRYPTO_hash (&(block->ecdsa_block.derived_key),
                        sizeof (block->ecdsa_block.derived_key),
                        query);
    return GNUNET_OK;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    GNUNET_CRYPTO_hash (&block->eddsa_block.derived_key,
                        sizeof (block->eddsa_block.derived_key),
                        query);
    return GNUNET_OK;
  default:
    return GNUNET_SYSERR;
  }
  return GNUNET_SYSERR;
 
}

Referenced by namecache_cache_block(), and namecache_sqlite_cache_block().

Here is the caller graph for this function:

GNUNET_GNSRECORD_identity_from_data()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_identity_from_data	(	const char *	data,
		size_t	data_size,
		uint32_t	type,
		struct GNUNET_IDENTITY_PublicKey *	key
	)

Build a #GNUNET_GNSRECORD_PublicKey from zone delegation resource record data.

Parameters

data	the record data-
data_size	the data size.
type	the record type
key	the identity key to store the data in (must be allocated).

Returns

GNUNET_OK if successful.

Definition at line 256 of file gnsrecord_misc.c.

{
  if (GNUNET_NO == GNUNET_GNSRECORD_is_zonekey_type (type))
    return GNUNET_SYSERR;
  switch (type)
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
    if (data_size > sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
      return GNUNET_SYSERR;
    memcpy (&key->ecdsa_key, data, data_size);
    break;
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    if (data_size > sizeof (struct GNUNET_CRYPTO_EddsaPublicKey))
      return GNUNET_SYSERR;
    memcpy (&key->eddsa_key, data, data_size);
    break;
  default:
    return GNUNET_NO;
  }
  key->type = htonl (type);
 
  return GNUNET_YES;
}

Referenced by check_pkey(), gns_value_to_string(), handle_gns_resolution_result(), and recursive_pkey_resolution().

Here is the caller graph for this function:

GNUNET_GNSRECORD_data_from_identity()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_data_from_identity	(	const struct GNUNET_IDENTITY_PublicKey *	key,
		char **	data,
		size_t *	data_size,
		uint32_t *	type
	)

Create record data and size from an identity key.

Parameters

key	the identity key to use.
data	the record data (will be allocated)
data_size	the allocated data size.
type	the resulting record type

Returns

GNUNET_OK if successful.

Definition at line 256 of file gnsrecord_misc.c.

{
  char *tmp;
  *type = ntohl (key->type);
  *data_size = GNUNET_IDENTITY_public_key_get_length (key) - sizeof (key->type);
  if (0 == *data_size)
    return GNUNET_SYSERR;
  tmp = GNUNET_malloc (*data_size);
  memcpy (tmp, ((char*) key) + sizeof (key->type), *data_size);
  *data = tmp;
  return GNUNET_OK;
}

References GNUNET_IDENTITY_public_key_from_string(), GNUNET_OK, GNUNET_SYSERR, and pkey.

Referenced by gns_string_to_value(), and register_do_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_is_zonekey_type()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_is_zonekey_type

(

uint32_t

type

)

Check if this type is one of the supported GNS zone types.

Parameters

type	the type to check

Returns

GNUNET_YES if it is one of the supported types.

Definition at line 256 of file gnsrecord_misc.c.

{
  switch (type)
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    return GNUNET_YES;
  default:
    return GNUNET_NO;
  }
}

Referenced by zone_to_name().

Here is the caller graph for this function:

GNUNET_GNSRECORD_is_critical()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_is_critical

(

uint32_t

type

)

Check if this type is a critical record.

Parameters

type	the type to check

Returns

GNUNET_YES if it is critical.

Definition at line 227 of file gnsrecord.c.

{
  struct Plugin *plugin;
 
  if (GNUNET_GNSRECORD_TYPE_ANY == type)
    return GNUNET_NO;
  init ();
  for (unsigned int i = 0; i < num_plugins; i++)
  {
    plugin = gns_plugins[i];
    if (NULL == plugin->api->is_critical)
      continue;
    if (GNUNET_NO == plugin->api->is_critical (plugin->api->cls, type))
      continue;
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References TestcasePlugin::api, gns_plugins, GNUNET_GNSRECORD_TYPE_ANY, init(), num_plugins, plugin, ret, and type.

Referenced by handle_gns_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_normalize_record_set()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_normalize_record_set	(	const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Data *	rd_public,
		unsigned int *	rd_count_public,
		struct GNUNET_TIME_Absolute *	min_expiry,
		enum GNUNET_GNSRECORD_Filter	filter,
		char **	emsg
	)

Normalize namestore records: Check for consistency and expirations.

Purge expired records. Returns a "clean" record set. Also returns the minimum expiration time this block should be published under. Also checks rules with respect to labels (e.g. no delegations under the empty label)

Parameters

label	the label under which this set (supposed to be) stored.
rd	input records
rd_count	size of the rd and rd_public arrays
rd_public	where to write the converted records
rd_count_public	number of records written to rd_public
min_expiry	the minimum expiration of this set
filter	the record set filter, see GNUNET_GNSRECORD_Filter.
emsg	the error message if something went wrong

Returns

GNUNET_OK if set could be normalized and is consistent

Check for delegation and redirect consistency. Note that we check for consistency BEFORE we filter for private records ON PURPOSE. We also want consistent record sets in our local zone(s). The only exception is the tombstone (above) which we ignore for the consistency check(s). FIXME: What about shadow records? Should we ignore them?

Definition at line 330 of file gnsrecord_misc.c.

{
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute minimum_expiration;
  int have_zone_delegation = GNUNET_NO;
  int have_gns2dns = GNUNET_NO;
  int have_other = GNUNET_NO;
  int have_redirect = GNUNET_NO;
  int have_empty_label = (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, label));
  unsigned int rd_count_tmp;
 
  minimum_expiration = GNUNET_TIME_UNIT_ZERO_ABS;
  now = GNUNET_TIME_absolute_get ();
  rd_count_tmp = 0;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    /* Ignore private records for public record set */
    if ((0 != (filter & GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE)) &&
        (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Filtering private record filter=%u...\n", filter);
      continue;
    }
    /* Skip expired records */
    if ((0 == (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
        (rd[i].expiration_time < now.abs_value_us))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Filtering expired record...\n");
      continue;    /* record already expired, skip it */
    }
    /* Ignore the tombstone unless filter permits explicitly.
    * Remember expiration time. */
    if (GNUNET_GNSRECORD_TYPE_TOMBSTONE == rd[i].record_type)
    {
      minimum_expiration.abs_value_us = rd[i].expiration_time;
      if (0 != (filter & GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE))
      {
        rd_public[rd_count_tmp] = rd[i];
        rd_count_tmp++;
      }
      continue;
    }
    /* No NICK records unless empty label */
    if (have_empty_label &&
        (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type))
      continue;
 
    if (GNUNET_YES == GNUNET_GNSRECORD_is_zonekey_type (rd[i].record_type))
    {
      /* No delegation records under empty label*/
      if (have_empty_label)
      {
        *emsg = GNUNET_strdup (_ (
                                 "Zone delegation record not allowed in apex."));
        return GNUNET_SYSERR;
      }
      if ((GNUNET_YES == have_other) ||
          (GNUNET_YES == have_redirect) ||
          (GNUNET_YES == have_gns2dns))
      {
        *emsg = GNUNET_strdup (_ (
                                 "Zone delegation record set contains mutually exclusive records."));
        return GNUNET_SYSERR;
      }
      have_zone_delegation = GNUNET_YES;
    }
    else if (GNUNET_GNSRECORD_TYPE_REDIRECT == rd[i].record_type)
    {
      if (GNUNET_YES == have_redirect)
      {
        *emsg = GNUNET_strdup (_ (
                                 "Multiple REDIRECT records."));
        return GNUNET_SYSERR;
 
      }
      if ((GNUNET_YES == have_other) ||
          (GNUNET_YES == have_zone_delegation) ||
          (GNUNET_YES == have_gns2dns))
      {
        *emsg = GNUNET_strdup (_ (
                                 "Redirection record set contains mutually exclusive records."));
        return GNUNET_SYSERR;
      }
      /* No redirection records under empty label*/
      if (have_empty_label)
      {
        *emsg = GNUNET_strdup (_ (
                                 "Redirection records not allowed in apex."));
        return GNUNET_SYSERR;
      }
      have_redirect = GNUNET_YES;
    }
    else if (GNUNET_GNSRECORD_TYPE_GNS2DNS == rd[i].record_type)
    {
      /* No gns2dns records under empty label*/
      if (have_empty_label)
      {
        *emsg = GNUNET_strdup (_ (
                                 "Redirection records not allowed in apex.."));
        return GNUNET_SYSERR;
      }
      if ((GNUNET_YES == have_other) ||
          (GNUNET_YES == have_redirect) ||
          (GNUNET_YES == have_zone_delegation))
      {
        *emsg = GNUNET_strdup (_ (
                                 "Redirection record set contains mutually exclusive records."));
        return GNUNET_SYSERR;
      }
      have_gns2dns = GNUNET_YES;
    }
    else
    {
      /* Some other record.
       * Not allowed for zone delegations or redirections */
      if ((GNUNET_YES == have_zone_delegation) ||
          (GNUNET_YES == have_redirect) ||
          (GNUNET_YES == have_gns2dns))
      {
        *emsg = GNUNET_strdup (_ (
                                 "Mutually exclusive records."));
        return GNUNET_SYSERR;
      }
      have_other = GNUNET_YES;
    }
 
    rd_public[rd_count_tmp] = rd[i];
    /* Make sure critical record types are marked as such */
    if (GNUNET_YES == GNUNET_GNSRECORD_is_critical (rd[i].record_type))
      rd_public[rd_count_tmp].flags |= GNUNET_GNSRECORD_RF_CRITICAL;
    rd_count_tmp++;
  }
 
  *expiry = GNUNET_GNSRECORD_record_get_expiration_time (rd_count_tmp,
                                                         rd_public,
                                                         minimum_expiration);
  *rd_count_public = rd_count_tmp;
  return GNUNET_OK;
}

Referenced by dispatch_job(), dispatch_job_monitor(), get_existing_rd_exp(), lookup_it(), and send_lookup_response_with_filter().

Here is the caller graph for this function:

GNUNET_GNSRECORD_label_check()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_label_check	(	const char *	label,
		char **	emsg
	)

Check label for invalid characters.

Parameters

label	the label to check
emsg	an error message (NULL if label is valid). Will be allocated.

Returns

GNUNET_OK if label is valid.

Definition at line 39 of file gnsrecord_misc.c.

{
  if (NULL == label)
  {
    *emsg = GNUNET_strdup (_ ("Label is NULL which is not allowed\n"));
    return GNUNET_NO;
  }
  if (0 != strchr (label, '.'))
  {
    *emsg = GNUNET_strdup (_ ("Label  contains `.' which is not allowed\n"));
    return GNUNET_NO;
  }
  return GNUNET_OK;
}

References GNUNET_STRINGS_utf8_normalize().

Here is the call graph for this function: