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_SBoxRecord
	Record type used to box up SMIMEA records. More...
struct	GNUNET_GNSRECORD_ReverseRecord
	Record type used internally to keep track of reverse mappings into a namespace. More...
struct	GNUNET_GNSRECORD_PowP
	Struct for a proof of work as part of the revocation. More...
struct	GNUNET_GNSRECORD_SignaturePurposePS
	The signature object we use for the PoW. More...

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

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.

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_MAINTENANCE = 1 << (15 - 2) , 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.
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.
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.
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.
uint32_t	GNUNET_GNSRECORD_typename_to_number (const char *dns_typename)
	Convert a type name (e.g.
const char *	GNUNET_GNSRECORD_number_to_typename (uint32_t type)
	Convert a type number to the corresponding type string (e.g.
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.
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.
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.
int	GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd)
	Test if a given record is expired.
char *	GNUNET_GNSRECORD_string_normalize (const char *src)
	Normalize a UTF-8 string to a GNS name.
const char *	GNUNET_GNSRECORD_z2s (const struct GNUNET_CRYPTO_BlindablePublicKey *z)
	Convert a zone to a string (for printing debug messages).
const char *	GNUNET_GNSRECORD_pkey_to_zkey (const struct GNUNET_CRYPTO_BlindablePublicKey *pkey)
	Convert public key to the respective absolute domain name in the ".zkey" pTLD.
int	GNUNET_GNSRECORD_zkey_to_pkey (const char *zkey, struct GNUNET_CRYPTO_BlindablePublicKey *pkey)
	Convert an absolute domain name to the respective public key.
void	GNUNET_GNSRECORD_query_from_private_key (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone.
void	GNUNET_GNSRECORD_query_from_public_key (const struct GNUNET_CRYPTO_BlindablePublicKey *pub, const char *label, struct GNUNET_HashCode *query)
	Calculate the DHT query for a given label in a given zone.
ssize_t	GNUNET_GNSRECORD_block_calculate_size (const struct GNUNET_CRYPTO_BlindablePrivateKey *key, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
	Get size of buffer for block creation.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_sign (const struct GNUNET_CRYPTO_BlindablePrivateKey *key, const char *label, struct GNUNET_GNSRECORD_Block *block)
	Sign a block create with GNUNET_GNSRECORD_block_create_unsigned.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create (const struct GNUNET_CRYPTO_BlindablePrivateKey *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.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create_unsigned (const struct GNUNET_CRYPTO_BlindablePrivateKey *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().
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_create2 (const struct GNUNET_CRYPTO_BlindablePrivateKey *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).
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
	Check if a signature is valid.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block, const struct GNUNET_CRYPTO_BlindablePublicKey *zone_key, const char *label, GNUNET_GNSRECORD_RecordCallback proc, void *proc_cls)
	Decrypt block.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a, const struct GNUNET_GNSRECORD_Data *b)
	Compares if two records are equal.
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.
size_t	GNUNET_GNSRECORD_block_get_size (const struct GNUNET_GNSRECORD_Block *block)
	Returns the length of this block in bytes.
struct GNUNET_TIME_Absolute	GNUNET_GNSRECORD_block_get_expiration (const struct GNUNET_GNSRECORD_Block *block)
	Returns the expiration of a 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.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_identity_from_data (const char *data, size_t data_size, uint32_t type, struct GNUNET_CRYPTO_BlindablePublicKey *key)
	Build a #GNUNET_GNSRECORD_PublicKey from zone delegation resource record data.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_data_from_identity (const struct GNUNET_CRYPTO_BlindablePublicKey *key, char **data, size_t *data_size, uint32_t *type)
	Create record data and size from an identity key.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_is_zonekey_type (uint32_t type)
	Check if this type is one of the supported GNS zone types.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_is_critical (uint32_t type)
	Check if this type is a critical record.
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.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_label_check (const char *label, char **emsg)
	Check label for invalid characters.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_check_pow (const struct GNUNET_GNSRECORD_PowP *pow, unsigned int matching_bits, struct GNUNET_TIME_Relative epoch_duration)
	Check if the given proof-of-work is valid.
void	GNUNET_GNSRECORD_pow_init (const struct GNUNET_CRYPTO_BlindablePrivateKey *key, struct GNUNET_GNSRECORD_PowP *pow)
	Initializes a fresh PoW computation.
struct GNUNET_GNSRECORD_PowCalculationHandle *	GNUNET_GNSRECORD_pow_start (struct GNUNET_GNSRECORD_PowP *pow, int epochs, unsigned int difficulty)
	Starts a proof-of-work calculation given the pow object as well as target epochs and difficulty.
enum GNUNET_GenericReturnValue	GNUNET_GNSRECORD_pow_round (struct GNUNET_GNSRECORD_PowCalculationHandle *pc)
	Calculate a single round in the key revocation PoW.
size_t	GNUNET_GNSRECORD_proof_get_size (const struct GNUNET_GNSRECORD_PowP *pow)
void	GNUNET_GNSRECORD_pow_stop (struct GNUNET_GNSRECORD_PowCalculationHandle *pc)
	Stop a PoW calculation.

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 55 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 60 of file gnunet_gnsrecord_lib.h.

GNUNET_GNSRECORD_TYPE_ANY

#define GNUNET_GNSRECORD_TYPE_ANY   0

Record type indicating any record/'*'.

Definition at line 66 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 84 of file gnunet_gnsrecord_lib.h.

GNUNET_MAX_POW_SIZE

#define GNUNET_MAX_POW_SIZE

Value:

        sizeof(struct GNUNET_GNSRECORD_PowP)  \
        + sizeof(struct GNUNET_CRYPTO_BlindablePublicKey)  \
        + 1024

Maximum length of a revocation.

Definition at line 868 of file gnunet_gnsrecord_lib.h.

POW_COUNT

#define POW_COUNT   32

The proof-of-work narrowing factor.

The number of PoWs that are calculates as part of revocation.

Definition at line 876 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 389 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_MAINTENANCE	Maintenance records. E.g. TOMBSTONEs
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 99 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_MAINTENANCE = 1 << (15 - 2),
 
  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 146 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 284 of file json_gnsrecord.c.

{
  struct GnsRecordInfo *gnsrecord_info = GNUNET_new (struct GnsRecordInfo);
  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 };
 
  gnsrecord_info->rd = rd;
  gnsrecord_info->name = name;
  gnsrecord_info->rd_count = rd_count;
  return ret;
}

References clean_gnsrecordobject(), GNUNET_new, name, GnsRecordInfo::name, parse_gnsrecordobject(), GNUNET_JSON_Specification::parser, rd, GnsRecordInfo::rd, rd_count, GnsRecordInfo::rd_count, and ret.

Referenced by bulk_tx_start(), and namestore_add_or_update().

Here is the call graph for this function:

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 313 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 %" PRIu64 " %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, 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_MAINTENANCE,
      rd[i].flags & GNUNET_GNSRECORD_RF_MAINTENANCE,
      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_SHADOW,
      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_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_MAINTENANCE, 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_MAINTENANCE, GNUNET_JSON_GNSRECORD_FLAG_PRIVATE, GNUNET_JSON_GNSRECORD_FLAG_RELATIVE, GNUNET_JSON_GNSRECORD_FLAG_SHADOW, 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 147 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 GNUNET_TESTING_PluginFunctions::cls, 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 169 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 GNUNET_TESTING_PluginFunctions::cls, 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 192 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 GNUNET_TESTING_PluginFunctions::cls, gns_plugins, GNUNET_GNSRECORD_TYPE_ANY, init(), num_plugins, plugin, and ret.

Referenced by del_monitor(), DID_create_namestore_lookup_cb(), 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 219 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;
}

References GNUNET_TESTING_PluginFunctions::cls, gns_plugins, GNUNET_GNSRECORD_TYPE_ANY, init(), num_plugins, plugin, ret, and type.

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 call graph for this function:

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 >> 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, GNUNET_GNSRECORD_Data::record_type, NetworkRecord::record_type, ret, and str.

Referenced by block_create_ecdsa(), block_create_eddsa(), block_get_size_ecdsa(), block_get_size_eddsa(), consistency_iter(), GNUNET_NAMESTORE_records_store(), handle_zone_to_name_it(), lookup_it(), namestore_postgres_store_records(), namestore_sqlite_store_records(), 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, GNUNET_GNSRECORD_Data::data_size, NetworkRecord::data_size, 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, NetworkRecord::record_type, and str.

Referenced by block_create_ecdsa(), block_create_eddsa(), consistency_iter(), GNUNET_NAMESTORE_records_store(), handle_zone_to_name_it(), lookup_it(), namestore_postgres_store_records(), namestore_sqlite_store_records(), 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, and rd_count.

Referenced by block_decrypt_ecdsa(), and block_decrypt_eddsa().

Here is the caller graph for this function:

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, 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, LOG, rd_count, NetworkRecord::record_type, and str.

Referenced by block_decrypt_ecdsa(), block_decrypt_eddsa(), check_rd(), check_result(), check_result(), continue_store_activity(), database_setup(), get_records_and_call_iterator(), handle_edit_record_set_response(), handle_lookup_result(), handle_record_result(), handle_result(), handle_result(), handle_zone_to_name_response(), parse_result_call_iterator(), process_tickets(), store_record_set(), 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 205 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 36 of file gnsrecord_misc.c.

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

References GNUNET_STRINGS_utf8_normalize().

Referenced by block_create2(), GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_decrypt(), GNUNET_GNSRECORD_block_sign(), GNUNET_GNSRECORD_query_from_private_key(), GNUNET_GNSRECORD_query_from_public_key(), handle_edit_record_set(), handle_edit_record_set_cancel(), handle_record_lookup(), run_edkey(), run_pkey(), and store_record_set().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_z2s()

const char * GNUNET_GNSRECORD_z2s

(

const struct GNUNET_CRYPTO_BlindablePublicKey *

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 61 of file gnsrecord_misc.c.

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

References 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(), namestore_sqlite_store_records(), namestore_sqlite_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_CRYPTO_BlindablePublicKey *

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 elliptic 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 elliptic curve

Returns

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

Definition at line 228 of file gnsrecord_misc.c.

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

References GNUNET_CRYPTO_blindable_public_key_to_string(), GNUNET_free, 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_CRYPTO_BlindablePublicKey *	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 elliptic 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 elliptic curve

Returns

GNUNET_SYSERR if zkey has the wrong syntax

Definition at line 254 of file gnsrecord_misc.c.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_query_from_private_key()

void GNUNET_GNSRECORD_query_from_private_key	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 1027 of file gnsrecord_crypto.c.

{
  char *norm_label;
  struct GNUNET_CRYPTO_BlindablePublicKey pub;
 
  norm_label = GNUNET_GNSRECORD_string_normalize (label);
  switch (ntohl (zone->type))
  {
  case GNUNET_GNSRECORD_TYPE_PKEY:
  case GNUNET_GNSRECORD_TYPE_EDKEY:
 
    GNUNET_CRYPTO_blindable_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_CRYPTO_blindable_key_get_public(), GNUNET_free, GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, pub, and GNUNET_CRYPTO_BlindablePrivateKey::type.

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_CRYPTO_BlindablePublicKey *	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 1056 of file gnsrecord_crypto.c.

{
  char *norm_label;
  struct GNUNET_CRYPTO_BlindablePublicKey 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);
}

References GNUNET_CRYPTO_BlindablePublicKey::ecdsa_key, GNUNET_CRYPTO_BlindablePublicKey::eddsa_key, GNUNET_assert, GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, pub, and GNUNET_CRYPTO_BlindablePublicKey::type.

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 call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_calculate_size()

ssize_t GNUNET_GNSRECORD_block_calculate_size	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 512 of file gnsrecord_crypto.c.

{
  struct GNUNET_CRYPTO_BlindablePublicKey pkey;
  ssize_t res = -1;
 
  GNUNET_CRYPTO_blindable_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;
 
}

References block_get_size_ecdsa(), block_get_size_eddsa(), GNUNET_assert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, key, pkey, rd, rd_count, and res.

Here is the call graph for this function:

GNUNET_GNSRECORD_block_sign()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_sign	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 275 of file gnsrecord_crypto.c.

{
  struct GNUNET_CRYPTO_BlindablePublicKey pkey;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  GNUNET_CRYPTO_blindable_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;
}

References block_sign_ecdsa(), block_sign_eddsa(), GNUNET_assert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_SYSERR, key, pkey, and res.

Referenced by sign_worker().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 539 of file gnsrecord_crypto.c.

{
  struct GNUNET_CRYPTO_BlindablePublicKey pkey;
  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
  char *norm_label;
 
  GNUNET_CRYPTO_blindable_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;
}

References block_create_ecdsa(), block_create_eddsa(), expire, GNUNET_assert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_SYSERR, GNUNET_YES, key, pkey, rd, rd_count, res, and result.

Referenced by run_edkey(), and run_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create_unsigned()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create_unsigned	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 664 of file gnsrecord_crypto.c.

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

References block_create2(), expire, GNUNET_NO, pkey, rd, rd_count, and result.

Referenced by dispatch_job(), and dispatch_job_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_create2()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create2	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	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 677 of file gnsrecord_crypto.c.

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

References block_create2(), expire, GNUNET_YES, pkey, rd, rd_count, and result.

Here is the call graph for this function:

GNUNET_GNSRECORD_block_verify()

enum GNUNET_GenericReturnValue 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 697 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;
}

References GNUNET_GNSRECORD_EcdsaBlock::derived_key, GNUNET_GNSRECORD_EddsaBlock::derived_key, GNUNET_GNSRECORD_Block::ecdsa_block, GNUNET_GNSRECORD_Block::eddsa_block, GNUNET_GNSRECORD_EcdsaBlock::expiration_time, GNUNET_GNSRECORD_EddsaBlock::expiration_time, GNRBlockPS::expiration_time, GNUNET_CRYPTO_ecdsa_verify_(), GNUNET_CRYPTO_eddsa_verify_(), GNUNET_free, GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, GNUNET_CRYPTO_SignaturePurpose::purpose, GNRBlockPS::purpose, res, GNUNET_GNSRECORD_EcdsaBlock::signature, GNUNET_GNSRECORD_EddsaBlock::signature, GNUNET_CRYPTO_SignaturePurpose::size, GNUNET_GNSRECORD_Block::size, and GNUNET_GNSRECORD_Block::type.

Referenced by block_plugin_gns_check_block(), and handle_lookup_block_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_block_decrypt()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_decrypt	(	const struct GNUNET_GNSRECORD_Block *	block,
		const struct GNUNET_CRYPTO_BlindablePublicKey *	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 988 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_PUBLIC_KEY_TYPE_ECDSA:
    res = block_decrypt_ecdsa (block,
                               &zone_key->ecdsa_key, norm_label, proc,
                               proc_cls);
    break;
  case GNUNET_PUBLIC_KEY_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;
}

References block_decrypt_ecdsa(), block_decrypt_eddsa(), GNUNET_CRYPTO_BlindablePublicKey::ecdsa_key, GNUNET_CRYPTO_BlindablePublicKey::eddsa_key, GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_PUBLIC_KEY_TYPE_ECDSA, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SYSERR, res, and GNUNET_CRYPTO_BlindablePublicKey::type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_records_cmp()

enum GNUNET_GenericReturnValue 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 90 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 %llu != %llu\n",
         (unsigned long long) a->data_size,
         (unsigned long long) 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;
}

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.

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 140 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_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::expiration_time, expire, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_max(), GNUNET_TIME_absolute_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_ZERO_ABS, LOG, min, rd, rd_count, and GNUNET_TIME_Relative::rel_value_us.

Referenced by GNUNET_GNSRECORD_normalize_record_set(), process_lookup_result(), run_edkey(), and run_pkey().

Here is the call graph for this function:

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 329 of file gnsrecord_misc.c.

{
  return ntohl (block->size);
}

References GNUNET_GNSRECORD_Block::size.

Referenced by block_plugin_gns_check_block(), block_plugin_gns_check_reply(), dispatch_job(), dispatch_job_monitor(), GNUNET_NAMECACHE_block_cache(), handle_dht_response(), handle_lookup_block_it(), namecache_cache_block(), namecache_postgres_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 336 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_break, GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_TIME_absolute_get_zero_(), and GNUNET_TIME_absolute_ntoh().

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

Here is the call graph for this function:

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

References GNUNET_GNSRECORD_EcdsaBlock::derived_key, GNUNET_GNSRECORD_EddsaBlock::derived_key, GNUNET_GNSRECORD_Block::ecdsa_block, GNUNET_GNSRECORD_Block::eddsa_block, GNUNET_CRYPTO_hash(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_OK, GNUNET_SYSERR, and GNUNET_GNSRECORD_Block::type.

Referenced by block_plugin_gns_get_key(), namecache_cache_block(), namecache_postgres_cache_block(), and namecache_sqlite_cache_block().

Here is the call graph for this function:

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_CRYPTO_BlindablePublicKey *	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 266 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;
}

References data, data_size, GNUNET_GNSRECORD_is_zonekey_type(), GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, key, and type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_data_from_identity()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_data_from_identity	(	const struct GNUNET_CRYPTO_BlindablePublicKey *	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 296 of file gnsrecord_misc.c.

{
  char *tmp;
  *type = ntohl (key->type);
  *data_size = GNUNET_CRYPTO_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 data, data_size, GNUNET_CRYPTO_public_key_get_length(), GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, key, and type.

Referenced by gns_string_to_value(), and missing_zone_creation_cont().

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 315 of file gnsrecord_misc.c.

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

References GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_NO, GNUNET_YES, and type.

Referenced by GNUNET_GNSRECORD_identity_from_data(), GNUNET_GNSRECORD_normalize_record_set(), namestore_postgres_store_records(), namestore_sqlite_store_records(), and 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 239 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 GNUNET_TESTING_PluginFunctions::cls, gns_plugins, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_NO, GNUNET_YES, init(), num_plugins, plugin, and type.

Referenced by GNUNET_GNSRECORD_normalize_record_set(), and 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 379 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 maintenance record (e.g. tombstone) unless filter permits explicitly.
    * Remember expiration time. */
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_MAINTENANCE))
    {
      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;
}

References _, GNUNET_TIME_Absolute::abs_value_us, filter, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE, GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_is_critical(), GNUNET_GNSRECORD_is_zonekey_type(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_RF_CRITICAL, GNUNET_GNSRECORD_RF_MAINTENANCE, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_TYPE_REDIRECT, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, rd, and rd_count.

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

Here is the call graph for this function:

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 44 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_NO, GNUNET_OK, and GNUNET_strdup.

Referenced by store_record_set().

Here is the caller graph for this function:

GNUNET_GNSRECORD_check_pow()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_check_pow	(	const struct GNUNET_GNSRECORD_PowP *	pow,
		unsigned int	difficulty,
		struct GNUNET_TIME_Relative	epoch_duration
	)

Check if the given proof-of-work is valid.

Parameters

pow	proof of work
matching_bits	how many bits must match (configuration)
epoch_duration	length of single epoch in configuration

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Parameters

pow	proof of work
difficulty	how many bits must match (configuration) LSD0001: D
epoch_duration	length of single epoch in configuration

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Check if signature valid

First, check if PoW set is strictly monotically increasing

Check expiration

Extend by 10% for unsynchronized clocks

Definition at line 164 of file gnsrecord_pow.c.

{
  char buf[sizeof(struct GNUNET_CRYPTO_BlindablePublicKey)
           + sizeof (struct GNUNET_TIME_AbsoluteNBO)
           + sizeof (uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  struct GNUNET_TIME_Absolute ts;
  struct GNUNET_TIME_Absolute exp;
  struct GNUNET_TIME_Relative ttl;
  struct GNUNET_TIME_Relative buffer;
  /* LSD0001: D' */
  unsigned int score = 0;
  unsigned int tmp_score = 0;
  unsigned int epochs;
  uint64_t pow_val;
  ssize_t pklen;
  const struct GNUNET_CRYPTO_BlindablePublicKey *pk;
 
  pk = (const struct GNUNET_CRYPTO_BlindablePublicKey *) &pow[1];
 
  if (GNUNET_OK != check_signature (pow))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Proof of work signature invalid!\n");
    return GNUNET_SYSERR;
  }
 
  for (unsigned int i = 0; i < POW_COUNT - 1; i++)
  {
    if (GNUNET_ntohll (pow->pow[i]) >= GNUNET_ntohll (pow->pow[i + 1]))
      return GNUNET_NO;
  }
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 &pow->timestamp,
                 sizeof (uint64_t));
  pklen = GNUNET_CRYPTO_public_key_get_length (pk);
  if (0 > pklen)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
                 pk,
                 pklen);
  for (unsigned int i = 0; i < POW_COUNT; i++)
  {
    pow_val = GNUNET_ntohll (pow->pow[i]);
    GNUNET_memcpy (buf, &pow->pow[i], sizeof(uint64_t));
    GNUNET_CRYPTO_pow_hash (&salt,
                            buf,
                            sizeof(buf),
                            &result);
    tmp_score = GNUNET_CRYPTO_hash_count_leading_zeros (&result);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Score %u with %" PRIu64 " (#%u)\n",
                tmp_score, pow_val, i);
 
    score += tmp_score;
 
  }
  score = score / POW_COUNT;
  if (score < difficulty)
    return GNUNET_NO;
  /* LSD0001: (D'-D+1) */
  epochs = score - difficulty + 1;
 
  ts = GNUNET_TIME_absolute_ntoh (pow->timestamp);
  ttl = GNUNET_TIME_relative_multiply (epoch_duration,
                                       epochs);
  buffer = GNUNET_TIME_relative_divide (epoch_duration,
                                        10);
  exp = GNUNET_TIME_absolute_add (ts, ttl);
  exp = GNUNET_TIME_absolute_add (exp,
                                  buffer);
 
  if (0 != GNUNET_TIME_absolute_get_remaining (ts).rel_value_us)
    return GNUNET_NO; /* Not yet valid. */
  /* Revert to actual start time */
  ts = GNUNET_TIME_absolute_add (ts,
                                 buffer);
 
  if (0 == GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
    return GNUNET_NO; /* expired */
  return GNUNET_YES;
}

References check_signature(), epoch_duration, epochs, GNUNET_ALIGN, GNUNET_break, GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_pow_hash(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_multiply(), GNUNET_YES, pk, GNUNET_GNSRECORD_PowP::pow, POW_COUNT, result, salt, GNUNET_GNSRECORD_PowP::timestamp, and ttl.

Referenced by block_plugin_revocation_check_block(), ego_callback(), GNUNET_REVOCATION_revoke(), run(), run_with_key(), and verify_revoke_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_pow_init()

void GNUNET_GNSRECORD_pow_init	(	const struct GNUNET_CRYPTO_BlindablePrivateKey *	key,
		struct GNUNET_GNSRECORD_PowP *	pow
	)

Initializes a fresh PoW computation.

Parameters

	key	the key to calculate the PoW for.
	pow	the pow object to work with in the calculation.
	key	the key to calculate the PoW for.
[out]	pow	starting point for PoW calculation (not yet valid)

Definition at line 317 of file gnsrecord_pow.c.

{
  GNUNET_assert (GNUNET_OK == sign_pow (key, pow));
}

References GNUNET_assert, GNUNET_OK, key, and sign_pow().

Referenced by ego_callback(), and run_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_pow_start()

struct GNUNET_GNSRECORD_PowCalculationHandle * GNUNET_GNSRECORD_pow_start	(	struct GNUNET_GNSRECORD_PowP *	pow,
		int	epochs,
		unsigned int	difficulty
	)

Starts a proof-of-work calculation given the pow object as well as target epochs and difficulty.

Parameters

pow	the PoW to based calculations on.
epochs	the number of epochs for which the PoW must be valid.
difficulty	the base difficulty of the PoW.

Returns

a handle for use in PoW rounds

Definition at line 325 of file gnsrecord_pow.c.

{
  struct GNUNET_GNSRECORD_PowCalculationHandle *pc;
  struct GNUNET_TIME_Relative ttl;
 
 
  pc = GNUNET_new (struct GNUNET_GNSRECORD_PowCalculationHandle);
  pc->pow = pow;
  ttl = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_YEARS,
                                       epochs);
  pc->pow->ttl = GNUNET_TIME_relative_hton (ttl);
  pc->current_pow = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                              UINT64_MAX);
  pc->difficulty = difficulty;
  pc->epochs = epochs;
  return pc;
}

References epochs, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_new, GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_YEARS, pc, and ttl.

Referenced by ego_callback(), run(), and run_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_pow_round()

enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_pow_round

(

struct GNUNET_GNSRECORD_PowCalculationHandle *

pc

)

Calculate a single round in the key revocation PoW.

Parameters

pc	handle to the PoW, initially called with NULL.

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Calculate a single round in the key revocation PoW.

Parameters

pc	handle to the PoW, initially called with NULL.
epochs	number of epochs for which the revocation must be valid.
pow	current pow value to try
difficulty	current base difficulty to achieve

Returns

GNUNET_YES if the pow is acceptable, GNUNET_NO if not

Do not try duplicates

Definition at line 371 of file gnsrecord_pow.c.

{
  char buf[sizeof(struct GNUNET_CRYPTO_BlindablePublicKey)
           + sizeof (uint64_t)
           + sizeof (uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  const struct GNUNET_CRYPTO_BlindablePublicKey *pk;
  unsigned int zeros;
  int ret;
  uint64_t pow_nbo;
  ssize_t ksize;
 
  pc->current_pow++;
  pk = (const struct GNUNET_CRYPTO_BlindablePublicKey *) &(pc->pow[1]);
 
  for (unsigned int i = 0; i < POW_COUNT; i++)
    if (pc->current_pow == pc->best[i].pow)
      return GNUNET_NO;
  pow_nbo = GNUNET_htonll (pc->current_pow);
  GNUNET_memcpy (buf, &pow_nbo, sizeof(uint64_t));
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 &pc->pow->timestamp,
                 sizeof (uint64_t));
  ksize = GNUNET_CRYPTO_public_key_get_length (pk);
  GNUNET_assert (0 < ksize);
  GNUNET_memcpy (&buf[sizeof(uint64_t) * 2],
                 pk,
                 ksize);
  GNUNET_CRYPTO_pow_hash (&salt,
                          buf,
                          sizeof(buf),
                          &result);
  zeros = GNUNET_CRYPTO_hash_count_leading_zeros (&result);
  for (unsigned int i = 0; i < POW_COUNT; i++)
  {
    if (pc->best[i].bits < zeros)
    {
      pc->best[i].bits = zeros;
      pc->best[i].pow = pc->current_pow;
      pc->pow->pow[i] = pow_nbo;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "New best score %u with %" PRIu64 " (#%u)\n",
                  zeros, pc->current_pow, i);
 
      break;
    }
  }
  ret = calculate_score (pc) >= pc->difficulty + pc->epochs ? GNUNET_YES :
        GNUNET_NO;
  if (GNUNET_YES == ret)
  {
    /* Sort POWs) */
    qsort (pc->pow->pow, POW_COUNT, sizeof (uint64_t), &cmp_pow_value);
  }
  return ret;
}

References calculate_score(), cmp_pow_value(), GNUNET_ALIGN, GNUNET_assert, GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_pow_hash(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_YES, pc, pk, POW_COUNT, result, ret, and salt.

Referenced by calculate_pow(), and run_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_proof_get_size()

size_t GNUNET_GNSRECORD_proof_get_size

(

const struct GNUNET_GNSRECORD_PowP *

pow

)

Definition at line 433 of file gnsrecord_pow.c.

{
  size_t size;
  size_t ksize;
  const struct GNUNET_CRYPTO_BlindablePublicKey *pk;
 
  size = sizeof (struct GNUNET_GNSRECORD_PowP);
  pk = (const struct GNUNET_CRYPTO_BlindablePublicKey *) &pow[1];
  ksize = GNUNET_CRYPTO_public_key_get_length (pk);
  size += ksize;
  size += GNUNET_CRYPTO_blinded_key_signature_get_length_by_type (pk->type);
  return size;
}

References GNUNET_CRYPTO_blinded_key_signature_get_length_by_type(), GNUNET_CRYPTO_public_key_get_length(), pk, size, and GNUNET_CRYPTO_BlindablePrivateKey::type.

Referenced by calculate_pow(), GNUNET_REVOCATION_revoke(), run(), run_with_key(), and sync_pow().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNSRECORD_pow_stop()

void GNUNET_GNSRECORD_pow_stop

(

struct GNUNET_GNSRECORD_PowCalculationHandle *

pc

)

Stop a PoW calculation.

Parameters

pc	the calculation to clean up

Returns

GNUNET_YES if pow valid, GNUNET_NO if pow was set but is not valid

Definition at line 456 of file gnsrecord_pow.c.

{
  GNUNET_free (pc);
}

References GNUNET_free, and pc.

Referenced by calculate_pow_shutdown().

Here is the caller graph for this function: