Libgnunetutil

Multi-function utilities library for GNUnet programs. More...

Collaboration diagram for Libgnunetutil:

Modules
	BIO library
	Buffered binary disk IO (with endianness conversion)
	Bandwidth library
	Functions related to bandwidth (unit)
	Configuration library
	Configuration management.
	Container
	Common data structures in GNUnet programs.
	Crypto library: cryptographic operations
	Provides cryptographic primitives.
	Crypto library: hash operations
	Provides hashing and operations on hashes.
	DNS Stub library
	Helper library to send DNS requests to DNS resolver.
	DNS parser library
	Helper library to parse DNS packets.
	Disk library
	Disk IO APIs.
	Getopt library
	Command line parsing and –help formatting.
	Helper library
	Dealing with SUID helper processes.
	Load library
	Load calculations.
	Logging
	MQ library
	General-purpose message queue.
	Memory management
	Network protocol definitions
	Types of messages used in GNUnet.
	Networking
	OS library
	Low level process routines.
	Peer library
	Helper library for interning of peer identifiers.
	Plugin library
	Plugin loading and unloading.
	Program library
	Start command-line programs.
	SOCKS proxy
	SOCKS proxy for connections.
	Scheduler library
	Event loop (scheduler)
	Signal library
	Manage signal handlers.
	Strings library
	Strings and string handling functions, including malloc and string tokenizing.
	Time library
	Time and time calculations.

Files
file	gnunet_bandwidth_lib.h
	Functions related to bandwidth (unit)
file	gnunet_bio_lib.h
	Buffered IO library.
file	gnunet_child_management_lib.h
	GNUnet child management api.
file	gnunet_common.h
	commonly used definitions; globals in this file are exempt from the rule that the module name ("common") must be part of the symbol name.
file	gnunet_configuration_lib.h
	Configuration API.
file	gnunet_container_lib.h
	Container classes for GNUnet.
file	gnunet_crypto_lib.h
	cryptographic primitives for GNUnet
file	gnunet_disk_lib.h
	Disk IO APIs.
file	gnunet_dnsparser_lib.h
	API for helper library to parse DNS packets.
file	gnunet_dnsstub_lib.h
	API for helper library to send DNS requests to DNS resolver.
file	gnunet_getopt_lib.h
	Command line parsing and –help formatting.
file	gnunet_helper_lib.h
	API for dealing with SUID helper processes.
file	gnunet_load_lib.h
	Functions related to load calculations.
file	gnunet_mq_lib.h
	General-purpose message queue.
file	gnunet_nc_lib.h
	General-purpose broadcast mechanism for message queues.
file	gnunet_op_lib.h
	Asynchronous operations; register callbacks for operations and call them when a response arrives.
file	gnunet_os_lib.h
	Low level process routines.
file	gnunet_peer_lib.h
	Helper library for interning of peer identifiers.
file	gnunet_plugin_lib.h
	Plugin loading and unloading.
file	gnunet_program_lib.h
	Functions related to starting programs.
file	gnunet_protocols.h
	Constants for network protocols.
file	gnunet_scheduler_lib.h
	API to schedule computations using continuation passing style.
file	gnunet_signal_lib.h
	Functions related to signals.
file	gnunet_socks.h
	SOCKS proxy for connections.
file	gnunet_strings_lib.h
	Strings and string handling functions.
file	gnunet_time_lib.h
	Functions related to time.

Data Structures
struct	GNUNET_Buffer
	Dynamically growing buffer. More...
struct	GNUNET_HashCode
	A 512-bit hashcode. More...
struct	GNUNET_ShortHashCode
	A 256-bit hashcode. More...
struct	GNUNET_Uuid
	A UUID, a 128 bit "random" value. More...
struct	GNUNET_MessageHeader
	Header for all communications. More...
struct	GNUNET_OperationResultMessage
	Answer from service to client about last operation. More...
struct	GNUNET_AsyncScopeId
	Identifier for an asynchronous execution context. More...
struct	GNUNET_AsyncScopeSave
	Saved async scope identifier or root scope. More...
struct	GNUNET_CRYPTO_HashAsciiEncoded
	0-terminated ASCII encoding of a struct GNUNET_HashCode. More...
struct	GNUNET_CRYPTO_EccSignaturePurpose
	header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed data More...
struct	GNUNET_CRYPTO_EddsaSignature
	an ECC signature using EdDSA. More...
struct	GNUNET_CRYPTO_EcdsaSignature
	an ECC signature using ECDSA More...
struct	GNUNET_CRYPTO_EddsaPublicKey
	Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and EdDSA signatures. More...
struct	GNUNET_CRYPTO_EcdsaPublicKey
	Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDSA signatures. More...
struct	GNUNET_PeerIdentity
	The identity of the host (wraps the signing key of the peer). More...
struct	GNUNET_CRYPTO_EcdhePublicKey
	Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and encryption (ECDH), See http://cr.yp.to/ecdh.html. More...
struct	GNUNET_CRYPTO_EcdhePrivateKey
	Private ECC key encoded for transmission. More...
struct	GNUNET_CRYPTO_EcdsaPrivateKey
	Private ECC key encoded for transmission. More...
struct	GNUNET_CRYPTO_EddsaPrivateKey
	Private ECC key encoded for transmission. More...
struct	GNUNET_CRYPTO_EddsaPrivateScalar
	Private ECC scalar encoded for transmission. More...
struct	GNUNET_CRYPTO_Edx25519PrivateKey
	Private ECC key material encoded for transmission. More...
struct	GNUNET_CRYPTO_Edx25519PublicKey
	Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and Edx25519 (same as EdDSA) signatures. More...
struct	GNUNET_CRYPTO_Edx25519Signature
	an ECC signature using Edx25519 (same as in EdDSA). More...
struct	GNUNET_CRYPTO_SymmetricSessionKey
	type for session keys More...
struct	GNUNET_CRYPTO_ChallengeNonceP
	Type of a nonce used for challenges. More...
struct	GNUNET_CRYPTO_SymmetricInitializationVector
	IV for sym cipher. More...
struct	GNUNET_CRYPTO_AuthKey
	type for (message) authentication keys More...
struct	GNUNET_CRYPTO_PaillierPublicKey
	Paillier public key. More...
struct	GNUNET_CRYPTO_PaillierPrivateKey
	Paillier private key. More...
struct	GNUNET_CRYPTO_PaillierCiphertext
	Paillier ciphertext. More...
struct	GNUNET_CRYPTO_Cs25519Scalar
	Curve25519 Scalar. More...
struct	GNUNET_CRYPTO_Cs25519Point
	Curve25519 point. More...
struct	GNUNET_CRYPTO_CsPrivateKey
	The private information of an Schnorr key pair. More...
struct	GNUNET_CRYPTO_CsPublicKey
	The public information of an Schnorr key pair. More...
struct	GNUNET_CRYPTO_CsBlindingSecret
	Secret used for blinding (alpha and beta). More...
struct	GNUNET_CRYPTO_CsRSecret
	the private r used in the signature More...
struct	GNUNET_CRYPTO_CsRPublic
	the public R (derived from r) used in c More...
struct	GNUNET_CRYPTO_CsC
	Schnorr c to be signed. More...
struct	GNUNET_CRYPTO_CsS
	s in the signature More...
struct	GNUNET_CRYPTO_CsBlindS
	blinded s in the signature More...
struct	GNUNET_CRYPTO_CsSignature
	CS Signtature containing scalar s and point R. More...
struct	GNUNET_CRYPTO_CsNonce
	Nonce. More...
struct	GNUNET_CRYPTO_PowSalt
	Value for a salt for GNUNET_CRYPTO_pow_hash(). More...
struct	GNUNET_CRYPTO_EccPoint
	Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH), see http://cr.yp.to/ecdh.html. More...
struct	GNUNET_CRYPTO_EccScalar
	A ECC scalar for use in point multiplications. More...
struct	GNUNET_CRYPTO_RsaBlindingKeySecret
	Constant-size pre-secret for blinding key generation. More...

Macros
#define	GNUNET_UTIL_VERSION   0x000A0104
	Version of the API (for entire gnunetutil.so library). More...
#define	GNUNET_MIN(a, b)   (((a) < (b)) ? (a) : (b))
#define	GNUNET_MAX(a, b)   (((a) > (b)) ? (a) : (b))
#define	GNUNET_VA_ARG_ENUM(va, X)   ((enum X) va_arg (va, int))
	wrap va_arg for enums More...
#define	BYTE_SWAP_16(x)   ((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))
	Endian operations. More...
#define	BYTE_SWAP_32(x)
#define	BYTE_SWAP_64(x)
#define	GNUNET_htobe16(x)   BYTE_SWAP_16 (x)
#define	GNUNET_htobe16(x)   (x)
#define	GNUNET_htole16(x)   (x)
#define	GNUNET_htole16(x)   BYTE_SWAP_16 (x)
#define	GNUNET_be16toh(x)   BYTE_SWAP_16 (x)
#define	GNUNET_be16toh(x)   (x)
#define	GNUNET_le16toh(x)   (x)
#define	GNUNET_le16toh(x)   BYTE_SWAP_16 (x)
#define	GNUNET_htobe32(x)   BYTE_SWAP_32 (x)
#define	GNUNET_htobe32(x)   (x)
#define	GNUNET_htole32(x)   (x)
#define	GNUNET_htole32(x)   BYTE_SWAP_32 (x)
#define	GNUNET_be32toh(x)   BYTE_SWAP_32 (x)
#define	GNUNET_be32toh(x)   (x)
#define	GNUNET_le32toh(x)   (x)
#define	GNUNET_le32toh(x)   BYTE_SWAP_32 (x)
#define	GNUNET_htobe64(x)   BYTE_SWAP_64 (x)
#define	GNUNET_htobe64(x)   (x)
#define	GNUNET_htole64(x)   (x)
#define	GNUNET_htole64(x)   BYTE_SWAP_64 (x)
#define	GNUNET_be64toh(x)   BYTE_SWAP_64 (x)
#define	GNUNET_be64toh(x)   (x)
#define	GNUNET_le64toh(x)   (x)
#define	GNUNET_le64toh(x)   BYTE_SWAP_64 (x)
#define	GNUNET_NZL(l)   GNUNET_MAX (1, l)
	Macro used to avoid using 0 for the length of a variable-size array (Non-Zero-Length). More...
#define	GNUNET_PACKED   __attribute__ ((packed))
	gcc-ism to get packed structs. More...
#define	GNUNET_ALIGN   __attribute__ ((aligned (8)))
	gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's. More...
#define	GNUNET_UNUSED   __attribute__ ((unused))
	gcc-ism to document unused arguments More...
#define	GNUNET_NORETURN   __attribute__ ((noreturn))
	gcc-ism to document functions that don't return More...
#define	GNUNET_NETWORK_STRUCT_BEGIN
	Define as empty, GNUNET_PACKED should suffice, but this won't work on W32. More...
#define	GNUNET_NETWORK_STRUCT_END
	Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;. More...
#define	GN_LIKELY(expr)   (expr)
#define	GN_UNLIKELY(expr)   (expr)
#define	GNUNET_LOG_CALL_STATUS   -1
#define	GNUNET_log_from(kind, comp, ...)
#define	GNUNET_log(kind, ...)
#define	GNUNET_B2S(obj)   GNUNET_b2s ((obj), sizeof (*(obj)))
	Convert a fixed-sized object to a string using GNUNET_b2s(). More...
#define	GNUNET_static_assert(cond)   GNUNET_assert (cond)
	Assertion to be checked (if supported by C compiler) at compile time, otherwise checked at runtime and resulting in an abort() on failure. More...
#define	GNUNET_memcmp(a, b)
	Compare memory in a and b, where both must be of the same pointer type. More...
#define	GNUNET_memcmp_priv(a, b)
	Compare memory in a and b in constant time, suitable for private data. More...
#define	GNUNET_is_zero(a)    GNUNET_is_zero_ ((a), sizeof (*(a)))
	Check that memory in a is all zeros. More...
#define	GNUNET_memcpy(dst, src, n)
	Call memcpy() but check for n being 0 first. More...
#define	__func__   "<unknown>"
#define	GNUNET_CONTAINER_DLL_insert_sorted(TYPE, comparator, comparator_cls, head, tail, element)
	Insertion sort of element into DLL from head to tail sorted by comparator. More...
#define	GNUNET_CRYPTO_ECC_SIGNATURE_DATA_ENCODING_LENGTH   126
	Maximum length of an ECC signature. More...
#define	GNUNET_CRYPTO_AES_KEY_LENGTH   (256 / 8)
	length of the sessionkey in bytes (256 BIT sessionkey) More...
#define	GNUNET_CRYPTO_HASH_LENGTH   (512 / 8)
	Length of a hash value. More...
#define	GNUNET_CRYPTO_PKEY_ASCII_LENGTH   52
	How many characters (without 0-terminator) are our ASCII-encoded public keys (ECDSA/EDDSA/ECDHE). More...
#define	GNUNET_CRYPTO_PAILLIER_BITS   2048
	Size of paillier plain texts and public keys. More...

Typedefs
typedef void(*	GNUNET_ChildCompletedCallback) (void *cls, enum GNUNET_OS_ProcessStatusType type, long unsigned int exit_code)
	Defines a GNUNET_ChildCompletedCallback which is sent back upon death or completion of a child process. More...
typedef enum GNUNET_GenericReturnValue(*	GNUNET_FileNameCallback) (void *cls, const char *filename)
	Function called with a filename. More...
typedef void(*	GNUNET_ContinuationCallback) (void *cls)
	Generic continuation callback. More...
typedef void(*	GNUNET_ResultCallback) (void *cls, int64_t result_code, const void *data, uint16_t data_size)
	Function called with the result of an asynchronous operation. More...
typedef void(*	GNUNET_CRYPTO_HashCompletedCallback) (void *cls, const struct GNUNET_HashCode *res)
	Function called once the hash computation over the specified file has completed. More...

Enumerations
enum	GNUNET_GenericReturnValue { GNUNET_SYSERR = -1 , GNUNET_NO = 0 , GNUNET_OK = 1 , GNUNET_YES = 1 }
	Named constants for return values. More...
enum	GNUNET_SCHEDULER_Priority {   GNUNET_SCHEDULER_PRIORITY_KEEP = 0 , GNUNET_SCHEDULER_PRIORITY_IDLE = 1 , GNUNET_SCHEDULER_PRIORITY_BACKGROUND = 2 , GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3 ,   GNUNET_SCHEDULER_PRIORITY_HIGH = 4 , GNUNET_SCHEDULER_PRIORITY_UI = 5 , GNUNET_SCHEDULER_PRIORITY_URGENT = 6 , GNUNET_SCHEDULER_PRIORITY_SHUTDOWN = 7 ,   GNUNET_SCHEDULER_PRIORITY_COUNT = 8 }
	Valid task priorities. More...

Functions
void	GNUNET_buffer_prealloc (struct GNUNET_Buffer *buf, size_t capacity)
	Initialize a buffer with the given capacity. More...
void	GNUNET_buffer_ensure_remaining (struct GNUNET_Buffer *buf, size_t n)
	Make sure that at least n bytes remaining in the buffer. More...
void	GNUNET_buffer_write (struct GNUNET_Buffer *buf, const char *data, size_t len)
	Write bytes to the buffer. More...
void	GNUNET_buffer_write_str (struct GNUNET_Buffer *buf, const char *str)
	Write a 0-terminated string to a buffer, excluding the 0-terminator. More...
void	GNUNET_buffer_write_data_encoded (struct GNUNET_Buffer *buf, const void *data, size_t data_len)
	Write data encoded via GNUNET_STRINGS_data_to_string to the buffer. More...
void	GNUNET_buffer_write_path (struct GNUNET_Buffer *buf, const char *str)
	Write a path component to a buffer, ensuring that there is exactly one slash between the previous contents of the buffer and the new string. More...
void	GNUNET_buffer_write_fstr (struct GNUNET_Buffer *buf, const char *fmt,...) __attribute__((format(printf
	Write a 0-terminated formatted string to a buffer, excluding the 0-terminator. More...
void void	GNUNET_buffer_write_vfstr (struct GNUNET_Buffer *buf, const char *fmt, va_list args)
	Write a 0-terminated formatted string to a buffer, excluding the 0-terminator. More...
char *	GNUNET_buffer_reap_str (struct GNUNET_Buffer *buf)
	Clear the buffer and return the string it contained. More...
void *	GNUNET_buffer_reap (struct GNUNET_Buffer *buf, size_t *size)
	Clear the buffer and return its contents. More...
void	GNUNET_buffer_clear (struct GNUNET_Buffer *buf)
	Free the backing memory of the given buffer. More...
struct GNUNET_ChildWaitHandle *	GNUNET_wait_child (struct GNUNET_OS_Process *proc, GNUNET_ChildCompletedCallback cb, void *cb_cls)
	Starts the handling of the child processes. More...
void	GNUNET_wait_child_cancel (struct GNUNET_ChildWaitHandle *cwh)
	Stop waiting on this child. More...
int	GNUNET_get_log_call_status (int caller_level, const char *comp, const char *file, const char *function, int line)
	Decides whether a particular logging call should or should not be allowed to be made. More...
const char *	GNUNET_b2s (const void *buf, size_t buf_size)
	Convert a buffer to an 8-character string representative of the contents. More...
uint64_t	GNUNET_htonll (uint64_t n)
	Convert unsigned 64-bit integer to network byte order. More...
uint64_t	GNUNET_ntohll (uint64_t n)
	Convert unsigned 64-bit integer to host byte order. More...
double	GNUNET_hton_double (double d)
	Convert double to network byte order. More...
double	GNUNET_ntoh_double (double d)
	Convert double to host byte order. More...
int	GNUNET_memcmp_ct_ (const void *b1, const void *b2, size_t len)
	Compare memory in b1 and b2 in constant time, suitable for private data. More...
enum GNUNET_GenericReturnValue	GNUNET_is_zero_ (const void *a, size_t n)
	Check that memory in a is all zeros. More...
int int void *	GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
	Allocate memory. More...
void **	GNUNET_xnew_array_2d_ (size_t n, size_t m, size_t elementSize, const char *filename, int linenumber)
	Allocate memory for a two dimensional array in one block and set up pointers. More...
void ***	GNUNET_xnew_array_3d_ (size_t n, size_t m, size_t o, size_t elementSize, const char *filename, int linenumber)
	Allocate memory for a three dimensional array in one block and set up pointers. More...
void *	GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename, int linenumber)
	Allocate and initialize memory. More...
void *	GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
	Allocate memory. More...
void *	GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
	Reallocate memory. More...
void	GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
	Free memory. More...
char *	GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
	Dup a string. More...
char *	GNUNET_xstrndup_ (const char *str, size_t len, const char *filename, int linenumber)
	Dup partially a string. More...
void	GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount, unsigned int newCount, const char *filename, int linenumber)
	Grow an array, the new elements are zeroed out. More...
void	GNUNET_async_scope_enter (const struct GNUNET_AsyncScopeId *aid, struct GNUNET_AsyncScopeSave *old_scope)
	Set the async scope for the current thread. More...
void	GNUNET_async_scope_restore (struct GNUNET_AsyncScopeSave *old_scope)
	Clear the current thread's async scope. More...
void	GNUNET_async_scope_get (struct GNUNET_AsyncScopeSave *scope_ret)
	Get the current async scope. More...
void	GNUNET_async_scope_fresh (struct GNUNET_AsyncScopeId *aid_ret)
	Generate a fresh async scope identifier. More...
int	GNUNET_try_compression (const char *data, size_t old_size, char **result, size_t *new_size)
	Try to compress the given block of data using libz. More...
char *	GNUNET_decompress (const char *input, size_t input_size, size_t output_size)
	Decompress input, return the decompressed data as output. More...
size_t	GNUNET_CONTAINER_bloomfilter_get_element_addresses (const struct GNUNET_CONTAINER_BloomFilter *bf)
	Get the number of the addresses set per element in the bloom filter. More...
struct GNUNET_CONTAINER_MultiHashMap32Iterator *	GNUNET_CONTAINER_multihashmap32_iterator_create (const struct GNUNET_CONTAINER_MultiHashMap32 *map)
	Create an iterator for a 32-bit multihashmap. More...
enum GNUNET_GenericReturnValue	GNUNET_CONTAINER_multihashmap32_iterator_next (struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter, uint32_t *key, const void **value)
	Retrieve the next element from the hash map at the iterator's position. More...
void	GNUNET_CONTAINER_multihashmap32_iterator_destroy (struct GNUNET_CONTAINER_MultiHashMapIterator *iter)
	Destroy a 32-bit multihashmap iterator. More...
enum GNUNET_GenericReturnValue	GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap *heap, void **element, GNUNET_CONTAINER_HeapCostType *cost)
	Get element and cost stored at the root of heap. More...
uint32_t	GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len)
	Perform an incremental step in a CRC16 (for TCP/IP) calculation. More...
uint16_t	GNUNET_CRYPTO_crc16_finish (uint32_t sum)
	Convert results from GNUNET_CRYPTO_crc16_step to final crc16. More...
void	GNUNET_CRYPTO_symmetric_derive_iv_v (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, const void *salt, size_t salt_len, va_list argp)
	Derive an IV. More...
void	GNUNET_CRYPTO_pow_hash (const struct GNUNET_CRYPTO_PowSalt *salt, const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
	Calculate the 'proof-of-work' hash (an expensive hash). More...
struct GNUNET_HashContext *	GNUNET_CRYPTO_hash_context_start (void)
	Start incremental hashing operation. More...
struct GNUNET_HashContext *	GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc)
	Make a copy of the hash computation. More...
void	GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc, const void *buf, size_t size)
	Add data to be hashed. More...
void	GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
	Finish the hash computation. More...
void	GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
	Abort hashing, do not bother calculating final result. More...
void	GNUNET_CRYPTO_hmac_raw (const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
	Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the above be renamed? More...
void	GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
	Cancel a file hashing operation. More...
unsigned int	GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h)
	Count the number of leading 0 bits in h. More...
unsigned int	GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h)
	Count the number of tailing 0 bits in h. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_kdf_v (void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
	Derive key. More...
void	GNUNET_CRYPTO_kdf_mod_mpi (gcry_mpi_t *r, gcry_mpi_t n, const void *xts, size_t xts_len, const void *skm, size_t skm_len, const char *ctx)
	Deterministically generate a pseudo-random number uniformly from the integers modulo a libgcrypt mpi. More...
char *	GNUNET_CRYPTO_ecdsa_public_key_to_string (const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
	Convert a public key to a string. More...
char *	GNUNET_CRYPTO_ecdsa_private_key_to_string (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
	Convert a private key to a string. More...
char *	GNUNET_CRYPTO_eddsa_private_key_to_string (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
	Convert a private key to a string. More...
char *	GNUNET_CRYPTO_eddsa_public_key_to_string (const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
	Convert a public key to a string. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecdsa_public_key_from_string (const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
	Convert a string representing a public key to a public key. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_eddsa_private_key_from_string (const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
	Convert a string representing a private key to a private key. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_eddsa_public_key_from_string (const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
	Convert a string representing a public key to a public key. More...
struct GNUNET_CRYPTO_EccDlogContext *	GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max, unsigned int mem)
	Do pre-calculation for ECC discrete logarithm for small factors. More...
int	GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *input)
	Calculate ECC discrete logarithm for small factors. More...
void	GNUNET_CRYPTO_ecc_dexp (int val, struct GNUNET_CRYPTO_EccPoint *r)
	Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing val. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecc_dexp_mpi (const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
	Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing val. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecc_pmul_mpi (const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
	Multiply the point p on the elliptic curve by val. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecc_add (const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
	Add two points on the elliptic curve. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccPoint *r, struct GNUNET_CRYPTO_EccPoint *r_inv)
	Obtain a random point on the curve and its additive inverse. More...
void	GNUNET_CRYPTO_ecc_rnd_mpi (struct GNUNET_CRYPTO_EccScalar *r, struct GNUNET_CRYPTO_EccScalar *r_neg)
	Obtain a random scalar for point multiplication on the curve and its additive inverse. More...
void	GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccScalar *r)
	Generate a random value mod n. More...
void	GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *dlc)
	Release precalculated values. More...
void	GNUNET_CRYPTO_ecc_scalar_from_int (int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
	Create a scalar from int value. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_eddsa_sign_raw (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, void *data, size_t size, struct GNUNET_CRYPTO_EddsaSignature *sig)
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_ecdsa_sign_derived (const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
	This is a signature function for ECDSA which takes a private key, derives/blinds it and signs the message. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_eddsa_sign_derived (const struct GNUNET_CRYPTO_EddsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
	This is a signature function for EdDSA which takes a private key and derives it using the label and context before signing. More...
void	GNUNET_CRYPTO_eddsa_key_get_public_from_scalar (const struct GNUNET_CRYPTO_EddsaPrivateScalar *s, struct GNUNET_CRYPTO_EddsaPublicKey *pkey)
	Extract the public key of the given private scalar. More...
void	GNUNET_CRYPTO_mpi_print_unsigned (void *buf, size_t size, gcry_mpi_t val)
	Output the given MPI value to the given buffer in network byte order. More...
void	GNUNET_CRYPTO_mpi_scan_unsigned (gcry_mpi_t *result, const void *data, size_t size)
	Convert data buffer into MPI value. More...
void	GNUNET_CRYPTO_paillier_create (struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
	Create a freshly generated paillier public key. More...
int	GNUNET_CRYPTO_paillier_encrypt (const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const gcry_mpi_t m, int desired_ops, struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
	Encrypt a plaintext with a paillier public key. More...
void	GNUNET_CRYPTO_paillier_decrypt (const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key, const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext, gcry_mpi_t m)
	Decrypt a paillier ciphertext with a private key. More...
int	GNUNET_CRYPTO_paillier_hom_add (const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *c1, const struct GNUNET_CRYPTO_PaillierCiphertext *c2, struct GNUNET_CRYPTO_PaillierCiphertext *result)
	Compute a ciphertext that represents the sum of the plaintext in c1 and c2. More...
int	GNUNET_CRYPTO_paillier_hom_get_remaining (const struct GNUNET_CRYPTO_PaillierCiphertext *c)
	Get the number of remaining supported homomorphic operations. More...
struct GNUNET_CRYPTO_RsaPrivateKey *	GNUNET_CRYPTO_rsa_private_key_create (unsigned int len)
	Create a new private key. More...
void	GNUNET_CRYPTO_rsa_private_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *key)
	Free memory occupied by the private key. More...
size_t	GNUNET_CRYPTO_rsa_private_key_encode (const struct GNUNET_CRYPTO_RsaPrivateKey *key, void **buffer)
	Encode the private key in a format suitable for storing it into a file. More...
struct GNUNET_CRYPTO_RsaPrivateKey *	GNUNET_CRYPTO_rsa_private_key_decode (const void *buf, size_t buf_size)
	Decode the private key from the data-format back to the "normal", internal format. More...
struct GNUNET_CRYPTO_RsaPrivateKey *	GNUNET_CRYPTO_rsa_private_key_dup (const struct GNUNET_CRYPTO_RsaPrivateKey *key)
	Duplicate the given private key. More...
struct GNUNET_CRYPTO_RsaPublicKey *	GNUNET_CRYPTO_rsa_private_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey *priv)
	Extract the public key of the given private key. More...
void	GNUNET_CRYPTO_rsa_public_key_hash (const struct GNUNET_CRYPTO_RsaPublicKey *key, struct GNUNET_HashCode *hc)
	Compute hash over the public key. More...
bool	GNUNET_CRYPTO_rsa_public_key_check (const struct GNUNET_CRYPTO_RsaPublicKey *key)
	Check if key is well-formed. More...
unsigned int	GNUNET_CRYPTO_rsa_public_key_len (const struct GNUNET_CRYPTO_RsaPublicKey *key)
	Obtain the length of the RSA key in bits. More...
void	GNUNET_CRYPTO_rsa_public_key_free (struct GNUNET_CRYPTO_RsaPublicKey *key)
	Free memory occupied by the public key. More...
size_t	GNUNET_CRYPTO_rsa_public_key_encode (const struct GNUNET_CRYPTO_RsaPublicKey *key, void **buffer)
	Encode the public key in a format suitable for storing it into a file. More...
struct GNUNET_CRYPTO_RsaPublicKey *	GNUNET_CRYPTO_rsa_public_key_decode (const char *buf, size_t len)
	Decode the public key from the data-format back to the "normal", internal format. More...
struct GNUNET_CRYPTO_RsaPublicKey *	GNUNET_CRYPTO_rsa_public_key_dup (const struct GNUNET_CRYPTO_RsaPublicKey *key)
	Duplicate the given public key. More...
int	GNUNET_CRYPTO_rsa_signature_cmp (const struct GNUNET_CRYPTO_RsaSignature *s1, const struct GNUNET_CRYPTO_RsaSignature *s2)
	Compare the values of two signatures. More...
int	GNUNET_CRYPTO_rsa_private_key_cmp (const struct GNUNET_CRYPTO_RsaPrivateKey *p1, const struct GNUNET_CRYPTO_RsaPrivateKey *p2)
	Compare the values of two private keys. More...
int	GNUNET_CRYPTO_rsa_public_key_cmp (const struct GNUNET_CRYPTO_RsaPublicKey *p1, const struct GNUNET_CRYPTO_RsaPublicKey *p2)
	Compare the values of two public keys. More...
int	GNUNET_CRYPTO_rsa_blind (const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks, struct GNUNET_CRYPTO_RsaPublicKey *pkey, void **buf, size_t *buf_size)
	Blinds the given message with the given blinding key. More...
struct GNUNET_CRYPTO_RsaSignature *	GNUNET_CRYPTO_rsa_sign_blinded (const struct GNUNET_CRYPTO_RsaPrivateKey *key, const void *msg, size_t msg_len)
	Sign a blinded value, which must be a full domain hash of a message. More...
struct GNUNET_CRYPTO_RsaSignature *	GNUNET_CRYPTO_rsa_sign_fdh (const struct GNUNET_CRYPTO_RsaPrivateKey *key, const struct GNUNET_HashCode *hash)
	Create and sign a full domain hash of a message. More...
void	GNUNET_CRYPTO_rsa_signature_free (struct GNUNET_CRYPTO_RsaSignature *sig)
	Free memory occupied by signature. More...
size_t	GNUNET_CRYPTO_rsa_signature_encode (const struct GNUNET_CRYPTO_RsaSignature *sig, void **buffer)
	Encode the given signature in a format suitable for storing it into a file. More...
struct GNUNET_CRYPTO_RsaSignature *	GNUNET_CRYPTO_rsa_signature_decode (const void *buf, size_t buf_size)
	Decode the signature from the data-format back to the "normal", internal format. More...
struct GNUNET_CRYPTO_RsaSignature *	GNUNET_CRYPTO_rsa_signature_dup (const struct GNUNET_CRYPTO_RsaSignature *sig)
	Duplicate the given rsa signature. More...
struct GNUNET_CRYPTO_RsaSignature *	GNUNET_CRYPTO_rsa_unblind (const struct GNUNET_CRYPTO_RsaSignature *sig, const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks, struct GNUNET_CRYPTO_RsaPublicKey *pkey)
	Unblind a blind-signed signature. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_rsa_verify (const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_RsaSignature *sig, const struct GNUNET_CRYPTO_RsaPublicKey *public_key)
	Verify whether the given hash corresponds to the given signature and the signature is valid with respect to the given public key. More...
void	GNUNET_CRYPTO_cs_private_key_generate (struct GNUNET_CRYPTO_CsPrivateKey *priv)
	Create a new random private key. More...
void	GNUNET_CRYPTO_cs_private_key_get_public (const struct GNUNET_CRYPTO_CsPrivateKey *priv, struct GNUNET_CRYPTO_CsPublicKey *pub)
	Extract the public key of the given private key. More...
void	GNUNET_CRYPTO_cs_r_derive (const struct GNUNET_CRYPTO_CsNonce *nonce, const char *seed, const struct GNUNET_CRYPTO_CsPrivateKey *lts, struct GNUNET_CRYPTO_CsRSecret r[2])
	Derive a new secret r pair r0 and r1. More...
void	GNUNET_CRYPTO_cs_r_get_public (const struct GNUNET_CRYPTO_CsRSecret *r_priv, struct GNUNET_CRYPTO_CsRPublic *r_pub)
	Extract the public R of the given secret r. More...
void	GNUNET_CRYPTO_cs_blinding_secrets_derive (const struct GNUNET_CRYPTO_CsNonce *blind_seed, struct GNUNET_CRYPTO_CsBlindingSecret bs[2])
	Derives new random blinding factors. More...
void	GNUNET_CRYPTO_cs_calc_blinded_c (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2], const struct GNUNET_CRYPTO_CsRPublic r_pub[2], const struct GNUNET_CRYPTO_CsPublicKey *pub, const void *msg, size_t msg_len, struct GNUNET_CRYPTO_CsC blinded_c[2], struct GNUNET_CRYPTO_CsRPublic blinded_r_pub[2])
	Calculate two blinded c's Comment: One would be insecure due to Wagner's algorithm solving ROS. More...
unsigned int	GNUNET_CRYPTO_cs_sign_derive (const struct GNUNET_CRYPTO_CsPrivateKey *priv, const struct GNUNET_CRYPTO_CsRSecret r[2], const struct GNUNET_CRYPTO_CsC c[2], const struct GNUNET_CRYPTO_CsNonce *nonce, struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar)
	Sign a blinded c This function derives b from a nonce and a longterm secret In original papers b is generated randomly To provide abort-idempotency, b needs to be derived but still need to be UNPREDICTABLE. More...
void	GNUNET_CRYPTO_cs_unblind (const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar, const struct GNUNET_CRYPTO_CsBlindingSecret *bs, struct GNUNET_CRYPTO_CsS *signature_scalar)
	Unblind a blind-signed signature using a c that was blinded. More...
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_cs_verify (const struct GNUNET_CRYPTO_CsSignature *sig, const struct GNUNET_CRYPTO_CsPublicKey *pub, const void *msg, size_t msg_len)
	Verify whether the given message corresponds to the given signature and the signature is valid with respect to the given public key. More...
struct GNUNET_OP_Handle *	GNUNET_OP_create ()
	Create new operations handle. More...
void	GNUNET_OP_destroy (struct GNUNET_OP_Handle *h)
	Destroy operations handle. More...
uint64_t	GNUNET_OP_get_next_id (struct GNUNET_OP_Handle *h)
	Get a unique operation ID to distinguish between asynchronous requests. More...
int	GNUNET_OP_get (struct GNUNET_OP_Handle *h, uint64_t op_id, GNUNET_ResultCallback *result_cb, void **cls, void **ctx)
	Find operation by ID. More...
uint64_t	GNUNET_OP_add (struct GNUNET_OP_Handle *h, GNUNET_ResultCallback result_cb, void *cls, void *ctx)
	Add a new operation. More...
int	GNUNET_OP_result (struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx)
	Call the result callback of an operation and remove it. More...
int	GNUNET_OP_remove (struct GNUNET_OP_Handle *h, uint64_t op_id)
	Remove / cancel an operation. More...

Variables
GNUNET_MQ_MessageValidationCallback	GNUNET_MQ_MessageHandler::mv
	Callback to validate a message of the specified type. More...
GNUNET_MQ_MessageCallback	GNUNET_MQ_MessageHandler::cb
	Callback, called every time a new message of the specified type has been received. More...
void *	GNUNET_MQ_MessageHandler::cls
	Closure for mv and cb. More...
uint16_t	GNUNET_MQ_MessageHandler::type
	Type of the message this handler covers, in host byte order. More...
uint16_t	GNUNET_MQ_MessageHandler::expected_size
	Expected size of messages of this type. More...

Detailed Description

Multi-function utilities library for GNUnet programs.

Author

Christian Grothoff

Common buffer management functions.

Author

Florian Dold

Christian Grothoff

Nils Durner

Philipp Toelke

Christian Grothoff

Florian Dold

Christian Grothoff

Christian Grothoff

Krista Bennett

Gerd Knorr kraxe.nosp@m.l@by.nosp@m.tesex.nosp@m..org

Ioana Patrascu

Tzvetan Horozov

Milan

Christian Grothoff

Tobias Frisch

Jeffrey Burdges

Christian Grothoff

Krista Bennett

Gerd Knorr kraxe.nosp@m.l@by.nosp@m.tesex.nosp@m..org

Ioana Patrascu

Tzvetan Horozov

Macro Definition Documentation

GNUNET_UTIL_VERSION

#define GNUNET_UTIL_VERSION   0x000A0104

Version of the API (for entire gnunetutil.so library).

Definition at line 96 of file gnunet_common.h.

GNUNET_MIN

#define GNUNET_MIN	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Definition at line 115 of file gnunet_common.h.

GNUNET_MAX

#define GNUNET_MAX	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Definition at line 117 of file gnunet_common.h.

GNUNET_VA_ARG_ENUM

#define GNUNET_VA_ARG_ENUM	(		va,
			X
	)		((enum X) va_arg (va, int))

wrap va_arg for enums

Definition at line 151 of file gnunet_common.h.

BYTE_SWAP_16

#define BYTE_SWAP_16

(

x

)

((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))

Endian operations.

Definition at line 172 of file gnunet_common.h.

BYTE_SWAP_32

#define BYTE_SWAP_32

(

x

)

Value:

  ((((x) & 0x000000ffU) << 24) | (((x) & 0x0000ff00U) << 8)   \
   | (((x) & 0x00ff0000U) >> 8) | (((x) & 0xff000000U) >> 24))

Definition at line 174 of file gnunet_common.h.

BYTE_SWAP_64

#define BYTE_SWAP_64

(

x

)

Value:

  ((((x) & 0x00000000000000ffUL) << 56) | (((x) & 0x000000000000ff00UL) << 40)   \
   | (((x) & 0x0000000000ff0000UL) << 24) | (((x) & 0x00000000ff000000UL) << 8)    \
   | (((x) & 0x000000ff00000000UL) >> 8) | (((x) & 0x0000ff0000000000UL) >> 24)    \
   | (((x) & 0x00ff000000000000UL) >> 40) | (((x) & 0xff00000000000000UL) >> \
                                             56))

Definition at line 178 of file gnunet_common.h.

GNUNET_htobe16 [1/2]

#define GNUNET_htobe16

(

x

)

BYTE_SWAP_16 (x)

Definition at line 203 of file gnunet_common.h.

GNUNET_htobe16 [2/2]

#define GNUNET_htobe16

(

x

)

(x)

Definition at line 203 of file gnunet_common.h.

GNUNET_htole16 [1/2]

#define GNUNET_htole16

(

x

)

(x)

Definition at line 204 of file gnunet_common.h.

GNUNET_htole16 [2/2]

#define GNUNET_htole16

(

x

)

BYTE_SWAP_16 (x)

Definition at line 204 of file gnunet_common.h.

GNUNET_be16toh [1/2]

#define GNUNET_be16toh

(

x

)

BYTE_SWAP_16 (x)

Definition at line 205 of file gnunet_common.h.

GNUNET_be16toh [2/2]

#define GNUNET_be16toh

(

x

)

(x)

Definition at line 205 of file gnunet_common.h.

GNUNET_le16toh [1/2]

#define GNUNET_le16toh

(

x

)

(x)

Definition at line 206 of file gnunet_common.h.

GNUNET_le16toh [2/2]

#define GNUNET_le16toh

(

x

)

BYTE_SWAP_16 (x)

Definition at line 206 of file gnunet_common.h.

GNUNET_htobe32 [1/2]

#define GNUNET_htobe32

(

x

)

BYTE_SWAP_32 (x)

Definition at line 208 of file gnunet_common.h.

GNUNET_htobe32 [2/2]

#define GNUNET_htobe32

(

x

)

(x)

Definition at line 208 of file gnunet_common.h.

GNUNET_htole32 [1/2]

#define GNUNET_htole32

(

x

)

(x)

Definition at line 209 of file gnunet_common.h.

GNUNET_htole32 [2/2]

#define GNUNET_htole32

(

x

)

BYTE_SWAP_32 (x)

Definition at line 209 of file gnunet_common.h.

GNUNET_be32toh [1/2]

#define GNUNET_be32toh

(

x

)

BYTE_SWAP_32 (x)

Definition at line 210 of file gnunet_common.h.

GNUNET_be32toh [2/2]

#define GNUNET_be32toh

(

x

)

(x)

Definition at line 210 of file gnunet_common.h.

GNUNET_le32toh [1/2]

#define GNUNET_le32toh

(

x

)

(x)

Definition at line 211 of file gnunet_common.h.

GNUNET_le32toh [2/2]

#define GNUNET_le32toh

(

x

)

BYTE_SWAP_32 (x)

Definition at line 211 of file gnunet_common.h.

GNUNET_htobe64 [1/2]

#define GNUNET_htobe64

(

x

)

BYTE_SWAP_64 (x)

Definition at line 213 of file gnunet_common.h.

GNUNET_htobe64 [2/2]

#define GNUNET_htobe64

(

x

)

(x)

Definition at line 213 of file gnunet_common.h.

GNUNET_htole64 [1/2]

#define GNUNET_htole64

(

x

)

(x)

Definition at line 214 of file gnunet_common.h.

GNUNET_htole64 [2/2]

#define GNUNET_htole64

(

x

)

BYTE_SWAP_64 (x)

Definition at line 214 of file gnunet_common.h.

GNUNET_be64toh [1/2]

#define GNUNET_be64toh

(

x

)

BYTE_SWAP_64 (x)

Definition at line 215 of file gnunet_common.h.

GNUNET_be64toh [2/2]

#define GNUNET_be64toh

(

x

)

(x)

Definition at line 215 of file gnunet_common.h.

GNUNET_le64toh [1/2]

#define GNUNET_le64toh

(

x

)

(x)

Definition at line 216 of file gnunet_common.h.

GNUNET_le64toh [2/2]

#define GNUNET_le64toh

(

x

)

BYTE_SWAP_64 (x)

Definition at line 216 of file gnunet_common.h.

GNUNET_NZL

#define GNUNET_NZL

(

l

)

GNUNET_MAX (1, l)

Macro used to avoid using 0 for the length of a variable-size array (Non-Zero-Length).

Basically, C standard says that "int[n] x;" is undefined if n=0. This was supposed to prevent issues with pointer aliasing. However, C compilers may conclude that n!=0 as n=0 would be undefined, and then optimize under the assumption n!=0, which could cause actual issues. Hence, when initializing an array on the stack with a variable-length that might be zero, write "int[GNUNET_NZL(n)] x;" instead of "int[n] x".

Definition at line 232 of file gnunet_common.h.

GNUNET_PACKED

#define GNUNET_PACKED   __attribute__ ((packed))

gcc-ism to get packed structs.

Definition at line 238 of file gnunet_common.h.

GNUNET_ALIGN

#define GNUNET_ALIGN   __attribute__ ((aligned (8)))

gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.

See also gcc bug #33594.

Definition at line 253 of file gnunet_common.h.

GNUNET_UNUSED

#define GNUNET_UNUSED   __attribute__ ((unused))

gcc-ism to document unused arguments

Definition at line 259 of file gnunet_common.h.

GNUNET_NORETURN

#define GNUNET_NORETURN   __attribute__ ((noreturn))

gcc-ism to document functions that don't return

Definition at line 264 of file gnunet_common.h.

GNUNET_NETWORK_STRUCT_BEGIN

#define GNUNET_NETWORK_STRUCT_BEGIN

Define as empty, GNUNET_PACKED should suffice, but this won't work on W32.

Definition at line 269 of file gnunet_common.h.

GNUNET_NETWORK_STRUCT_END

#define GNUNET_NETWORK_STRUCT_END

Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;.

Definition at line 274 of file gnunet_common.h.

GN_LIKELY

#define GN_LIKELY

(

expr

)

(expr)

Definition at line 515 of file gnunet_common.h.

GN_UNLIKELY

#define GN_UNLIKELY

(

expr

)

(expr)

Definition at line 516 of file gnunet_common.h.

GNUNET_LOG_CALL_STATUS

#define GNUNET_LOG_CALL_STATUS   -1

Definition at line 520 of file gnunet_common.h.

GNUNET_log_from

#define GNUNET_log_from	(		kind,
			comp,
			...
	)

Value:

  do                                                                      \
  {                                                                       \
    static int log_call_enabled = GNUNET_LOG_CALL_STATUS;                 \
    if ((GNUNET_EXTRA_LOGGING > 0) ||                                     \
        ((GNUNET_ERROR_TYPE_DEBUG & (kind)) == 0))                        \
    {                                                                     \
      if (GN_UNLIKELY (log_call_enabled == -1))                           \
        log_call_enabled =                                                \
          GNUNET_get_log_call_status ((kind) & (~GNUNET_ERROR_TYPE_BULK), \
                                      (comp),                             \
                                      __FILE__,                           \
                                      __FUNCTION__,                       \
                                      __LINE__);                          \
      if (GN_UNLIKELY (GNUNET_get_log_skip () > 0))                       \
      {                                                                   \
        GNUNET_log_skip (-1, GNUNET_NO);                                  \
      }                                                                   \
      else                                                                \
      {                                                                   \
        if (GN_UNLIKELY (log_call_enabled))                               \
          GNUNET_log_from_nocheck ((kind), comp, __VA_ARGS__);            \
      }                                                                   \
    }                                                                     \
  } while (0)

Definition at line 542 of file gnunet_common.h.

GNUNET_log

#define GNUNET_log	(		kind,
			...
	)

Value:

  do                                                                      \
  {                                                                       \
    static int log_call_enabled = GNUNET_LOG_CALL_STATUS;                 \
    if ((GNUNET_EXTRA_LOGGING > 0) ||                                     \
        ((GNUNET_ERROR_TYPE_DEBUG & (kind)) == 0))                        \
    {                                                                     \
      if (GN_UNLIKELY (log_call_enabled == -1))                           \
        log_call_enabled =                                                \
          GNUNET_get_log_call_status ((kind) & (~GNUNET_ERROR_TYPE_BULK), \
                                      NULL,                               \
                                      __FILE__,                           \
                                      __FUNCTION__,                       \
                                      __LINE__);                          \
      if (GN_UNLIKELY (GNUNET_get_log_skip () > 0))                       \
      {                                                                   \
        GNUNET_log_skip (-1, GNUNET_NO);                                  \
      }                                                                   \
      else                                                                \
      {                                                                   \
        if (GN_UNLIKELY (log_call_enabled))                               \
          GNUNET_log_nocheck ((kind), __VA_ARGS__);                       \
      }                                                                   \
    }                                                                     \
  } while (0)

Definition at line 568 of file gnunet_common.h.

GNUNET_B2S

#define GNUNET_B2S

(

obj

)

GNUNET_b2s ((obj), sizeof (*(obj)))

Convert a fixed-sized object to a string using GNUNET_b2s().

Parameters

obj	address of object to convert

Returns

string representing the binary obj buffer

Definition at line 661 of file gnunet_common.h.

GNUNET_static_assert

#define GNUNET_static_assert

(

cond

)

GNUNET_assert (cond)

Assertion to be checked (if supported by C compiler) at compile time, otherwise checked at runtime and resulting in an abort() on failure.

This is the case where the compiler does not support static assertions.

Parameters

cond	condition to test, 0 implies failure

Definition at line 1015 of file gnunet_common.h.

GNUNET_memcmp

#define GNUNET_memcmp	(		a,
			b
	)

Value:

  ({                              \
    const typeof (*b) * _a = (a);  \
    const typeof (*a) * _b = (b);  \
    memcmp (_a, _b, sizeof(*a)); \
  })

Compare memory in a and b, where both must be of the same pointer type.

Do NOT use this function on arrays, it would only compare the first element!

Definition at line 1224 of file gnunet_common.h.

GNUNET_memcmp_priv

#define GNUNET_memcmp_priv	(		a,
			b
	)

Value:

  ({                              \
    const typeof (*b) * _a = (a);  \
    const typeof (*a) * _b = (b);  \
    GNUNET_memcmp_ct_ (_a, _b, sizeof(*a)); \
  })

Compare memory in a and b in constant time, suitable for private data.

Both a and b must be of the same pointer type.

Do NOT use this function on arrays, it would only compare the first element!

Definition at line 1253 of file gnunet_common.h.

GNUNET_is_zero

#define GNUNET_is_zero

(

a

)

GNUNET_is_zero_ ((a), sizeof (*(a)))

Check that memory in a is all zeros.

a must be a pointer.

Parameters

a	pointer to a struct which should be tested for the entire memory being zero'ed out.

Returns

GNUNET_YES if a is zero, GNUNET_NO otherwise

Definition at line 1281 of file gnunet_common.h.

GNUNET_memcpy

#define GNUNET_memcpy	(		dst,
			src,
			n
	)

Value:

  do                               \
  {                                \
    if (0 != n)                    \
    {                              \
      (void) memcpy (dst, src, n); \
    }                              \
  } while (0)

Call memcpy() but check for n being 0 first.

In the latter case, it is now safe to pass NULL for src or dst. Unlike traditional memcpy(), returns nothing.

Parameters

dst	destination of the copy, may be NULL if n is zero
src	source of the copy, may be NULL if n is zero
n	number of bytes to copy

Definition at line 1294 of file gnunet_common.h.

__func__

#define __func__   "<unknown>"

Definition at line 1794 of file gnunet_common.h.

GNUNET_CONTAINER_DLL_insert_sorted

#define GNUNET_CONTAINER_DLL_insert_sorted	(		TYPE,
			comparator,
			comparator_cls,
			head,
			tail,
			element
	)

Value:

  do                                                                        \
  {                                                                         \
    if ((NULL == head) || (0 < comparator (comparator_cls, element, head))) \
    {                                                                       \
      /* insert at head, element < head */                                  \
      GNUNET_CONTAINER_DLL_insert (head, tail, element);                    \
    }                                                                       \
    else                                                                    \
    {                                                                       \
      TYPE *pos;                                                            \
                                                                            \
      for (pos = head; NULL != pos; pos = pos->next)                        \
      if (0 < comparator (comparator_cls, element, pos))                  \
      break;     /* element < pos */                                        \
      if (NULL == pos)     /* => element > tail */                              \
      {                                                                     \
        GNUNET_CONTAINER_DLL_insert_tail (head, tail, element);             \
      }                                                                     \
      else     /* prev < element < pos */                                       \
      {                                                                     \
        GNUNET_CONTAINER_DLL_insert_after (head, tail, pos->prev, element); \
      }                                                                     \
    }                                                                       \
  } while (0)

Insertion sort of element into DLL from head to tail sorted by comparator.

Parameters

	TYPE	element type of the elements, e.g. struct ListElement
	comparator	function like memcmp() to compare elements; takes three arguments, the comparator_cls and two elements, returns an int (-1, 0 or 1)
	comparator_cls	closure for comparator
[in,out]	head	head of DLL
[in,out]	tail	tail of DLL
	element	element to insert

Definition at line 2096 of file gnunet_container_lib.h.

GNUNET_CRYPTO_ECC_SIGNATURE_DATA_ENCODING_LENGTH

#define GNUNET_CRYPTO_ECC_SIGNATURE_DATA_ENCODING_LENGTH   126

Maximum length of an ECC signature.

Note: round up to multiple of 8 minus 2 for alignment.

Definition at line 77 of file gnunet_crypto_lib.h.

GNUNET_CRYPTO_AES_KEY_LENGTH

#define GNUNET_CRYPTO_AES_KEY_LENGTH   (256 / 8)

length of the sessionkey in bytes (256 BIT sessionkey)

Definition at line 110 of file gnunet_crypto_lib.h.

GNUNET_CRYPTO_HASH_LENGTH

#define GNUNET_CRYPTO_HASH_LENGTH   (512 / 8)

Length of a hash value.

Definition at line 115 of file gnunet_crypto_lib.h.

GNUNET_CRYPTO_PKEY_ASCII_LENGTH

#define GNUNET_CRYPTO_PKEY_ASCII_LENGTH   52

How many characters (without 0-terminator) are our ASCII-encoded public keys (ECDSA/EDDSA/ECDHE).

Definition at line 121 of file gnunet_crypto_lib.h.

GNUNET_CRYPTO_PAILLIER_BITS

#define GNUNET_CRYPTO_PAILLIER_BITS   2048

Size of paillier plain texts and public keys.

Private keys and ciphertexts are twice this size.

Definition at line 408 of file gnunet_crypto_lib.h.

Typedef Documentation

GNUNET_ChildCompletedCallback

typedef void(* GNUNET_ChildCompletedCallback) (void *cls, enum GNUNET_OS_ProcessStatusType type, long unsigned int exit_code)

Defines a GNUNET_ChildCompletedCallback which is sent back upon death or completion of a child process.

Parameters

cls	handle for the callback
type	type of the process
exit_code	status code of the process

Definition at line 54 of file gnunet_child_management_lib.h.

GNUNET_FileNameCallback

typedef enum GNUNET_GenericReturnValue(* GNUNET_FileNameCallback) (void *cls, const char *filename)

Function called with a filename.

Parameters

cls	closure
filename	complete filename (absolute path)

Returns

GNUNET_OK to continue to iterate, GNUNET_NO to stop iteration with no error, GNUNET_SYSERR to abort iteration with error!

Definition at line 1 of file gnunet_common.h.

GNUNET_ContinuationCallback

typedef void(* GNUNET_ContinuationCallback) (void *cls)

Generic continuation callback.

Parameters

cls

Closure.

Definition at line 404 of file gnunet_common.h.

GNUNET_ResultCallback

typedef void(* GNUNET_ResultCallback) (void *cls, int64_t result_code, const void *data, uint16_t data_size)

Function called with the result of an asynchronous operation.

Parameters

cls	Closure.
result_code	Result code for the operation.
data	Data result for the operation.
data_size	Size of data.

Definition at line 420 of file gnunet_common.h.

GNUNET_CRYPTO_HashCompletedCallback

typedef void(* GNUNET_CRYPTO_HashCompletedCallback) (void *cls, const struct GNUNET_HashCode *res)

Function called once the hash computation over the specified file has completed.

Parameters

cls	closure
res	resulting hash, NULL on error

Definition at line 1007 of file gnunet_crypto_lib.h.

Enumeration Type Documentation

GNUNET_GenericReturnValue

enum GNUNET_GenericReturnValue

Named constants for return values.

The following invariants hold: GNUNET_NO == 0 (to allow if (GNUNET_NO)) GNUNET_OK != GNUNET_SYSERR, GNUNET_OK != GNUNET_NO, GNUNET_NO != GNUNET_SYSERR and finally GNUNET_YES != GNUNET_NO.

Enumerator
GNUNET_SYSERR
GNUNET_NO
GNUNET_OK
GNUNET_YES

Definition at line 105 of file gnunet_common.h.

{
  GNUNET_SYSERR = -1,
  GNUNET_NO = 0,
  GNUNET_OK = 1,
  /* intentionally identical to #GNUNET_OK! */
  GNUNET_YES = 1,
};

GNUNET_SCHEDULER_Priority

enum GNUNET_SCHEDULER_Priority

Valid task priorities.

Use these, do not pass random integers! For various reasons (#3862 – building with QT Creator, and our restricted cross-compilation with emscripten) this cannot be in gnunet_scheduler_lib.h, but it works if we declare it here. Naturally, logically this is part of the scheduler.

Enumerator
GNUNET_SCHEDULER_PRIORITY_KEEP	Run with the same priority as the current job.
GNUNET_SCHEDULER_PRIORITY_IDLE	Run when otherwise idle.
GNUNET_SCHEDULER_PRIORITY_BACKGROUND	Run as background job (higher than idle, lower than default).
GNUNET_SCHEDULER_PRIORITY_DEFAULT	Run with the default priority (normal P2P operations). Any task that is scheduled without an explicit priority being specified will run with this priority.
GNUNET_SCHEDULER_PRIORITY_HIGH	Run with high priority (important requests). Higher than DEFAULT.
GNUNET_SCHEDULER_PRIORITY_UI	Run with priority for interactive tasks. Higher than "HIGH".
GNUNET_SCHEDULER_PRIORITY_URGENT	Run with priority for urgent tasks. Use for things like aborts and shutdowns that need to preempt "UI"-level tasks. Higher than "UI".
GNUNET_SCHEDULER_PRIORITY_SHUTDOWN	This is an internal priority level that is only used for tasks that are being triggered due to shutdown (they have automatically highest priority). User code must not use this priority level directly. Tasks run with this priority level that internally schedule other tasks will see their original priority level be inherited (unless otherwise specified).
GNUNET_SCHEDULER_PRIORITY_COUNT	Number of priorities (must be the last priority). This priority must not be used by clients.

Definition at line 1806 of file gnunet_common.h.

{
  GNUNET_SCHEDULER_PRIORITY_KEEP = 0,
 
  GNUNET_SCHEDULER_PRIORITY_IDLE = 1,
 
  GNUNET_SCHEDULER_PRIORITY_BACKGROUND = 2,
 
  GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3,
 
  GNUNET_SCHEDULER_PRIORITY_HIGH = 4,
 
  GNUNET_SCHEDULER_PRIORITY_UI = 5,
 
  GNUNET_SCHEDULER_PRIORITY_URGENT = 6,
 
  GNUNET_SCHEDULER_PRIORITY_SHUTDOWN = 7,
 
  GNUNET_SCHEDULER_PRIORITY_COUNT = 8
};

Function Documentation

GNUNET_buffer_prealloc()

void GNUNET_buffer_prealloc	(	struct GNUNET_Buffer *	buf,
		size_t	capacity
	)

Initialize a buffer with the given capacity.

When a buffer is allocated with this function, a warning is logged when the buffer exceeds the initial capacity.

Parameters

buf	the buffer to initialize
capacity	the capacity (in bytes) to allocate for buf

Definition at line 35 of file buffer.c.

{
  /* Buffer should be zero-initialized */
  GNUNET_assert (0 == buf->mem);
  GNUNET_assert (0 == buf->capacity);
  GNUNET_assert (0 == buf->position);
  buf->mem = GNUNET_malloc (capacity);
  buf->capacity = capacity;
  buf->warn_grow = GNUNET_YES;
}

References buf, GNUNET_assert, GNUNET_malloc, and GNUNET_YES.

GNUNET_buffer_ensure_remaining()

void GNUNET_buffer_ensure_remaining	(	struct GNUNET_Buffer *	buf,
		size_t	n
	)

Make sure that at least n bytes remaining in the buffer.

Parameters

buf	buffer to potentially grow
n	number of bytes that should be available to write

Definition at line 55 of file buffer.c.

{
  size_t new_capacity = buf->position + n;
 
  /* guard against overflow */
  GNUNET_assert (new_capacity >= buf->position);
  if (new_capacity <= buf->capacity)
    return;
  /* warn if calculation of expected size was wrong */
  GNUNET_break (GNUNET_YES != buf->warn_grow);
  if (new_capacity < buf->capacity * 2)
    new_capacity = buf->capacity * 2;
  buf->capacity = new_capacity;
  if (NULL != buf->mem)
    buf->mem = GNUNET_realloc (buf->mem, new_capacity);
  else
    buf->mem = GNUNET_malloc (new_capacity);
}

References buf, GNUNET_assert, GNUNET_break, GNUNET_malloc, GNUNET_realloc, and GNUNET_YES.

Referenced by GNUNET_buffer_reap_str(), GNUNET_buffer_write(), GNUNET_buffer_write_data_encoded(), GNUNET_buffer_write_path(), and GNUNET_buffer_write_vfstr().

Here is the caller graph for this function:

GNUNET_buffer_write()

void GNUNET_buffer_write	(	struct GNUNET_Buffer *	buf,
		const char *	data,
		size_t	len
	)

Write bytes to the buffer.

Grows the buffer if necessary.

Parameters

buf	buffer to write to
data	data to read from
len	number of bytes to copy from data to buf

Definition at line 86 of file buffer.c.

{
  GNUNET_buffer_ensure_remaining (buf, len);
  memcpy (buf->mem + buf->position, data, len);
  buf->position += len;
}

References buf, data, GNUNET_buffer_ensure_remaining(), and len.

Referenced by GNUNET_buffer_write_path(), GNUNET_buffer_write_str(), GNUNET_STRINGS_urlencode(), and write_to_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_buffer_write_str()

void GNUNET_buffer_write_str	(	struct GNUNET_Buffer *	buf,
		const char *	str
	)

Write a 0-terminated string to a buffer, excluding the 0-terminator.

Grows the buffer if necessary.

Parameters

buf	the buffer to write to
str	the string to write to buf
buf	the buffer to write to
str	the string to write to buf

Definition at line 103 of file buffer.c.

{
  size_t len = strlen (str);
 
  GNUNET_buffer_write (buf, str, len);
}

References buf, GNUNET_buffer_write(), and len.

Referenced by GNUNET_CONFIGURATION_serialize_diagnostics(), and login_redirect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_buffer_write_data_encoded()

void GNUNET_buffer_write_data_encoded	(	struct GNUNET_Buffer *	buf,
		const void *	data,
		size_t	data_len
	)

Write data encoded via GNUNET_STRINGS_data_to_string to the buffer.

Grows the buffer if necessary.

Parameters

buf	buffer to write to
data	data to read from
data_len	number of bytes to copy from data to buf

Definition at line 264 of file buffer.c.

{
  size_t outlen = data_len * 8;
 
  if (outlen % 5 > 0)
    outlen += 5 - outlen % 5;
  outlen /= 5;
  GNUNET_buffer_ensure_remaining (buf,
                                  outlen);
  GNUNET_assert (NULL !=
                 GNUNET_STRINGS_data_to_string (data,
                                                data_len,
                                                (buf->mem
                                                 + buf->position),
                                                outlen));
  buf->position += outlen;
  GNUNET_assert (buf->position <= buf->capacity);
}

References buf, data, GNUNET_assert, GNUNET_buffer_ensure_remaining(), and GNUNET_STRINGS_data_to_string().

Here is the call graph for this function:

GNUNET_buffer_write_path()

void GNUNET_buffer_write_path	(	struct GNUNET_Buffer *	buf,
		const char *	str
	)

Write a path component to a buffer, ensuring that there is exactly one slash between the previous contents of the buffer and the new string.

Parameters

buf	buffer to write to
str	string containing the new path component

Definition at line 180 of file buffer.c.

{
  size_t len = strlen (str);
 
  while ( (0 != len) && ('/' == str[0]) )
  {
    str++;
    len--;
  }
  if ( (0 == buf->position) || ('/' != buf->mem[buf->position - 1]) )
  {
    GNUNET_buffer_ensure_remaining (buf, 1);
    buf->mem[buf->position++] = '/';
  }
  GNUNET_buffer_write (buf, str, len);
}

References buf, GNUNET_buffer_ensure_remaining(), GNUNET_buffer_write(), and len.

Here is the call graph for this function:

GNUNET_buffer_write_fstr()

void GNUNET_buffer_write_fstr	(	struct GNUNET_Buffer *	buf,
		const char *	fmt,
			...
	)

Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.

Grows the buffer if necessary.

Parameters

buf	the buffer to write to
fmt	format string
...	format arguments

Referenced by GNUNET_CONFIGURATION_serialize_diagnostics(), GNUNET_STRINGS_urlencode(), and login_redirect().

Here is the caller graph for this function:

GNUNET_buffer_write_vfstr()

void void GNUNET_buffer_write_vfstr	(	struct GNUNET_Buffer *	buf,
		const char *	fmt,
		va_list	args
	)

Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.

Grows the buffer if necessary.

Parameters

buf	the buffer to write to
fmt	format string
args	format argument list

Definition at line 230 of file buffer.c.

{
  int res;
  va_list args2;
 
  va_copy (args2, args);
  res = vsnprintf (NULL, 0, fmt, args2);
  va_end (args2);
 
  GNUNET_assert (res >= 0);
  GNUNET_buffer_ensure_remaining (buf, res + 1);
 
  va_copy (args2, args);
  res = vsnprintf (buf->mem + buf->position, res + 1, fmt, args2);
  va_end (args2);
 
  GNUNET_assert (res >= 0);
  buf->position += res;
  GNUNET_assert (buf->position <= buf->capacity);
}

References consensus-simulation::args, buf, GNUNET_assert, GNUNET_buffer_ensure_remaining(), and res.

Referenced by GNUNET_buffer_write_fstr().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_buffer_reap_str()

char* GNUNET_buffer_reap_str

(

struct GNUNET_Buffer *

buf

)

Clear the buffer and return the string it contained.

The caller is responsible to eventually GNUNET_free the returned string.

The returned string is always 0-terminated.

Parameters

buf	the buffer to reap the string from

Returns

the buffer contained in the string

Definition at line 123 of file buffer.c.

{
  char *res;
 
  /* ensure 0-termination */
  if ( (0 == buf->position) || ('\0' != buf->mem[buf->position - 1]))
  {
    GNUNET_buffer_ensure_remaining (buf, 1);
    buf->mem[buf->position++] = '\0';
  }
  res = buf->mem;
  memset (buf, 0, sizeof (struct GNUNET_Buffer));
  return res;
}

References buf, GNUNET_buffer_ensure_remaining(), and res.

Referenced by GNUNET_CONFIGURATION_serialize_diagnostics(), GNUNET_STRINGS_urlencode(), and login_redirect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_buffer_reap()

void* GNUNET_buffer_reap	(	struct GNUNET_Buffer *	buf,
		size_t *	size
	)

Clear the buffer and return its contents.

The caller is responsible to eventually GNUNET_free the returned data.

Parameters

buf	the buffer to reap the contents from
size	where to store the size of the returned data

Returns

the data contained in the string

Definition at line 149 of file buffer.c.

{
  *size = buf->position;
  void *res = buf->mem;
  memset (buf, 0, sizeof (struct GNUNET_Buffer));
  return res;
}

References buf, res, and size.

GNUNET_buffer_clear()

void GNUNET_buffer_clear

(

struct GNUNET_Buffer *

buf

)

Free the backing memory of the given buffer.

Does not free the memory of the buffer control structure, which is typically stack-allocated.

Definition at line 164 of file buffer.c.

{
  GNUNET_free (buf->mem);
  memset (buf, 0, sizeof (struct GNUNET_Buffer));
}

References buf, and GNUNET_free.

Referenced by GNUNET_STRINGS_urlencode().

Here is the caller graph for this function:

GNUNET_wait_child()

struct GNUNET_ChildWaitHandle* GNUNET_wait_child	(	struct GNUNET_OS_Process *	proc,
		GNUNET_ChildCompletedCallback	cb,
		void *	cb_cls
	)

Starts the handling of the child processes.

Function checks the status of the child process and sends back a GNUNET_ChildCompletedCallback upon completion/death of the child.

Parameters

proc	child process which is monitored
cb	reference to the callback which is called after completion
cb_cls	closure for the callback

Returns

GNUNET_ChildWaitHandle is returned

Starts the handling of the child processes.

Parameters

proc	The child process to be monitored.
cb	The callback to be called, when the child process completed.
cb_cls	The closure for the callback.

Returns

An handle for the the child being monitored.

Definition at line 205 of file child_management.c.

{
  struct GNUNET_ChildWaitHandle *cwh;
 
  child_management_start ();
  cwh = GNUNET_new (struct GNUNET_ChildWaitHandle);
  cwh->proc = proc;
  cwh->cb = cb;
  cwh->cb_cls = cb_cls;
  GNUNET_CONTAINER_DLL_insert (cwh_head,
                               cwh_tail,
                               cwh);
  if (NULL == sig_task)
  {
    sig_task = GNUNET_SCHEDULER_add_read_file (
      GNUNET_TIME_UNIT_FOREVER_REL,
      GNUNET_DISK_pipe_handle (sigpipe,
                               GNUNET_DISK_PIPE_END_READ),
      &maint_child_death,
      NULL);
  }
  return cwh;
}

References GNUNET_ChildWaitHandle::cb, GNUNET_ChildWaitHandle::cb_cls, child_management_start(), cwh_head, cwh_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_new, GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_UNIT_FOREVER_REL, maint_child_death(), GNUNET_ChildWaitHandle::proc, sig_task, and sigpipe.

Referenced by handle_uri(), and netjail_stop_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_wait_child_cancel()

void GNUNET_wait_child_cancel

(

struct GNUNET_ChildWaitHandle *

cwh

)

Stop waiting on this child.

Stop waiting on this child.

Parameters

cwh	The handle to be removed.

Definition at line 238 of file child_management.c.

{
  GNUNET_CONTAINER_DLL_remove (cwh_head,
                               cwh_tail,
                               cwh);
  GNUNET_free (cwh);
  if (NULL != cwh_head)
    return;
  child_management_done ();
}

References child_management_done(), cwh_head, cwh_tail, GNUNET_CONTAINER_DLL_remove, and GNUNET_free.

Referenced by netjail_start_cleanup(), netjail_stop_cleanup(), and shutdown_program().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_get_log_call_status()

int GNUNET_get_log_call_status	(	int	caller_level,
		const char *	comp,
		const char *	file,
		const char *	function,
		int	line
	)

Decides whether a particular logging call should or should not be allowed to be made.

Used internally by GNUNET_log*()

Parameters

caller_level	loglevel the caller wants to use
comp	component name the caller uses (NULL means that global component name is used)
file	file name containing the logging call, usually FILE
function	function which tries to make a logging call, usually FUNCTION
line	line at which the call is made, usually LINE

Returns

0 to disallow the call, 1 to allow it

Definition at line 500 of file common_logging.c.

{
  struct LogDef *ld;
  int i;
  int force_only;
 
  if (NULL == comp)
    /* Use default component */
    comp = component_nopid;
 
  /* We have no definitions to override globally configured log level,
   * so just use it right away.
   */
  if ((min_level >= 0) && (GNUNET_NO == gnunet_force_log_present))
    return caller_level <= min_level;
 
  /* Only look for forced definitions? */
  force_only = min_level >= 0;
  for (i = 0; i < logdefs_len; i++)
  {
    ld = &logdefs[i];
    if (((! force_only) || ld->force) &&
        ((line >= ld->from_line) && (line <= ld->to_line) ) &&
        (0 == regexec (&ld->component_regex, comp, 0, NULL, 0)) &&
        (0 == regexec (&ld->file_regex, file, 0, NULL, 0)) &&
        (0 == regexec (&ld->function_regex, function, 0, NULL, 0)))
    {
      /* We're finished */
      return caller_level <= ld->level;
    }
  }
  /* No matches - use global level, if defined */
  if (min_level >= 0)
    return caller_level <= min_level;
  /* All programs/services previously defaulted to WARNING.
   * Now *we* default to WARNING, and THEY default to NULL.
   * Or rather we default to MESSAGE, since things aren't always bad.
   */
  return caller_level <= GNUNET_ERROR_TYPE_MESSAGE;
}

References component_nopid, LogDef::component_regex, LogDef::file_regex, LogDef::force, LogDef::from_line, LogDef::function_regex, GNUNET_ERROR_TYPE_MESSAGE, gnunet_force_log_present, GNUNET_NO, LogDef::level, line, logdefs, logdefs_len, min_level, and LogDef::to_line.

Referenced by GCCH_debug(), GCT_debug(), and get_nick_record().

Here is the caller graph for this function:

GNUNET_b2s()

const char* GNUNET_b2s	(	const void *	buf,
		size_t	buf_size
	)

Convert a buffer to an 8-character string representative of the contents.

This is used for logging binary data when debugging.

Parameters

buf	buffer to log
buf_size	number of bytes in buf

Returns

text representation of buf, valid until next call to this function

Definition at line 324 of file common_logging.c.

{
  static GNUNET_THREAD_LOCAL char ret[9];
  struct GNUNET_HashCode hc;
  char *tmp;
 
  GNUNET_CRYPTO_hash (buf,
                      buf_size,
                      &hc);
  tmp = GNUNET_STRINGS_data_to_string_alloc (&hc,
                                             sizeof (hc));
  memcpy (ret,
          tmp,
          8);
  GNUNET_free (tmp);
  ret[8] = '\0';
  return ret;
}

References buf, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_THREAD_LOCAL, and ret.

Here is the call graph for this function:

GNUNET_htonll()

uint64_t GNUNET_htonll

(

uint64_t

n

)

Convert unsigned 64-bit integer to network byte order.

Parameters

n	The value in host byte order.

Returns

The same value in network byte order.

Definition at line 37 of file common_endian.c.

{
#if __BYTE_ORDER == __BIG_ENDIAN
  return n;
#elif __BYTE_ORDER == __LITTLE_ENDIAN
  return (((uint64_t) htonl (n)) << 32) + htonl (n >> 32);
#else
  #error byteorder undefined
#endif
}

Referenced by abd_string_to_value(), block_proc(), change_service(), commit_set(), consider_sending_fc(), create_loc_uri(), determine_id(), GCCH_handle_channel_plaintext_data_ack(), GNUNET_ABD_delegate_issue(), GNUNET_ABD_delegate_serialize(), GNUNET_ABD_delegates_serialize(), GNUNET_ARM_request_service_list(), GNUNET_BIO_write_int64(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_CRYPTO_random_timeflake(), GNUNET_DATASTORE_get_key(), GNUNET_DATASTORE_get_zero_anonymity(), GNUNET_DATASTORE_reserve(), GNUNET_FS_tree_encoder_next(), GNUNET_GNSRECORD_records_serialize(), GNUNET_hton_double(), GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_relative_time(), GNUNET_PQ_query_param_uint64(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_credential_store(), GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_generate_peergetconfig_msg_(), GNUNET_TESTBED_generate_slavegetconfig_msg_(), GST_send_operation_fail_msg(), GST_send_operation_success_msg(), handle_client_accept(), hash_for_index_cb(), notify_change(), opstart_manage_service(), opstart_overlay_connect(), opstart_peer_create(), opstart_peer_destroy(), opstart_peer_reconfigure(), opstart_peer_start(), opstart_peer_stop(), opstart_shutdown_peers(), p2_controller_connect_cb(), print_record(), run(), save(), send_ack(), send_add_queue(), send_channel_data_ack(), send_client_done(), send_client_element(), send_controller_link_response(), send_hello_thru_rocc(), send_overlay_connect_success_msg(), send_update_queue(), signal_result(), transmit(), transmit_item(), transmit_set(), unindex_process(), union_accept(), uri_chk_parse(), and uri_loc_parse().

GNUNET_ntohll()

uint64_t GNUNET_ntohll

(

uint64_t

n

)

Convert unsigned 64-bit integer to host byte order.

Parameters

n	The value in network byte order.

Returns

The same value in host byte order.

Definition at line 54 of file common_endian.c.

{
#if __BYTE_ORDER == __BIG_ENDIAN
  return n;
#elif __BYTE_ORDER == __LITTLE_ENDIAN
  return (((uint64_t) ntohl (n)) << 32) + ntohl (n >> 32);
#else
  #error byteorder undefined
#endif
}

Referenced by abd_value_to_string(), backward_resolution(), cb_intersection_element_removed(), cmp_pow_value(), copy_element_cb(), find_proof(), forward_overlay_connect(), GNUNET_ABD_delegate_deserialize(), GNUNET_ABD_delegates_deserialize(), GNUNET_BIO_read_int64(), GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_count_tailing_zeros(), GNUNET_FRAGMENT_print_ack(), GNUNET_FRAGMENT_process_ack(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_publish_stop(), GNUNET_FS_uri_chk_get_file_size(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_ntoh_double(), GNUNET_xfree_(), GNUNET_xrealloc_(), handle_add_queue_message(), handle_alice_client_message(), handle_arm_list_result(), handle_arm_result(), handle_attribute_store_message(), handle_bob_client_message(), handle_client_index_start(), handle_client_loc_sign(), handle_credential_store_message(), handle_data(), handle_flow_control(), handle_get(), handle_get_key(), handle_get_zero_anonymity(), handle_iteration_next(), handle_link_controllers(), handle_link_controllers_result(), handle_manage_peer_service(), handle_monitor_next(), handle_op_fail_event(), handle_opsuccess(), handle_overlay_connect(), handle_peer_conevent(), handle_peer_config(), handle_peer_create(), handle_peer_create_success(), handle_peer_destroy(), handle_peer_event(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_remote_overlay_connect(), handle_reserve(), handle_result(), handle_set(), handle_shutdown_peers(), handle_slave_config(), handle_slave_get_config(), handle_start(), handle_statistics_value(), handle_statistics_watch_value(), handle_stop(), handle_union_p2p_strata_estimator(), handle_update_queue_message(), process_result_with_request(), reconstruct_cb(), set_result_cb(), try_match_block(), uri_chk_to_string(), uri_loc_to_string(), and verify_message_crypto().

GNUNET_hton_double()

double GNUNET_hton_double

(

double

d

)

Convert double to network byte order.

Parameters

d	The value in host byte order.

Returns

The same value in network byte order.

Definition at line 70 of file common_endian.c.

{
  double res;
  uint64_t *in = (uint64_t *) &d;
  uint64_t *out = (uint64_t *) &res;
 
  out[0] = GNUNET_htonll (in[0]);
 
  return res;
}

References GNUNET_htonll(), and res.

Referenced by setup_estimate_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ntoh_double()

double GNUNET_ntoh_double

(

double

d

)

Convert double to host byte order.

Parameters

d	The value in network byte order.

Returns

The same value in host byte order.

Definition at line 83 of file common_endian.c.

{
  double res;
  uint64_t *in = (uint64_t *) &d;
  uint64_t *out = (uint64_t *) &res;
 
  out[0] = GNUNET_ntohll (in[0]);
 
  return res;
}

References GNUNET_ntohll(), and res.

Referenced by handle_estimate().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_memcmp_ct_()

int GNUNET_memcmp_ct_	(	const void *	b1,
		const void *	b2,
		size_t	len
	)

Compare memory in b1 and b2 in constant time, suitable for private data.

Parameters

b1	some buffer of size len
b2	another buffer of size len
len	number of bytes in b1 and b2

Returns

0 if buffers are equal,

Definition at line 131 of file consttime_memcmp.c.

{
  const uint8_t *c1, *c2;
  uint16_t d, r, m;
 
#if USE_VOLATILE_TEMPORARY
  volatile uint16_t v;
#else
  uint16_t v;
#endif
 
  c1 = b1;
  c2 = b2;
 
  r = 0;
  while (len)
  {
    /*
     * Take the low 8 bits of r (in the range 0x00 to 0xff,
     * or 0 to 255);
     * As explained elsewhere, the low 8 bits of r will be zero
     * if and only if all bytes compared so far were identical;
     * Zero-extend to a 16-bit type (in the range 0x0000 to
     * 0x00ff);
     * Add 255, yielding a result in the range 255 to 510;
     * Save that in a volatile variable to prevent
     * the compiler from trying any shortcuts (the
     * use of a volatile variable depends on "#ifdef
     * USE_VOLATILE_TEMPORARY", and most compilers won't
     * need it);
     * Divide by 256 yielding a result of 1 if the original
     * value of r was non-zero, or 0 if r was zero;
     * Subtract 1, yielding 0 if r was non-zero, or -1 if r
     * was zero;
     * Convert to uint16_t, yielding 0x0000 if r was
     * non-zero, or 0xffff if r was zero;
     * Save in m.
     */v = ((uint16_t) (uint8_t) r) + 255;
    m = v / 256 - 1;
 
    /*
     * Get the values from *c1 and *c2 as uint8_t (each will
     * be in the range 0 to 255, or 0x00 to 0xff);
     * Convert them to signed int values (still in the
     * range 0 to 255);
     * Subtract them using signed arithmetic, yielding a
     * result in the range -255 to +255;
     * Convert to uint16_t, yielding a result in the range
     * 0xff01 to 0xffff (for what was previously -255 to
     * -1), or 0, or in the range 0x0001 to 0x00ff (for what
     * was previously +1 to +255).
     */d = (uint16_t) ((int) *c1 - (int) *c2);
 
    /*
     * If the low 8 bits of r were previously 0, then m
     * is now 0xffff, so (d & m) is the same as d, so we
     * effectively copy d to r;
     * Otherwise, if r was previously non-zero, then m is
     * now 0, so (d & m) is zero, so leave r unchanged.
     * Note that the low 8 bits of d will be zero if and
     * only if d == 0, which happens when *c1 == *c2.
     * The low 8 bits of r are thus zero if and only if the
     * entirety of r is zero, which happens if and only if
     * all bytes compared so far were equal.  As soon as a
     * non-zero value is stored in r, it remains unchanged
     * for the remainder of the loop.
     */r |= (d & m);
 
    /*
     * Increment pointers, decrement length, and loop.
     */
    ++c1;
    ++c2;
    --len;
  }
 
  /*
   * At this point, r is an unsigned value, which will be 0 if the
   * final result should be zero, or in the range 0x0001 to 0x00ff
   * (1 to 255) if the final result should be positive, or in the
   * range 0xff01 to 0xffff (65281 to 65535) if the final result
   * should be negative.
   *
   * We want to convert the unsigned values in the range 0xff01
   * to 0xffff to signed values in the range -255 to -1, while
   * converting the other unsigned values to equivalent signed
   * values (0, or +1 to +255).
   *
   * On a machine with two's complement arithmetic, simply copying
   * the underlying bits (with sign extension if int is wider than
   * 16 bits) would do the job, so something like this might work:
   *
   *     return (int16_t)r;
   *
   * However, that invokes implementation-defined behaviour,
   * because values larger than 32767 can't fit in a signed 16-bit
   * integer without overflow.
   *
   * To avoid any implementation-defined behaviour, we go through
   * these contortions:
   *
   * a. Calculate ((uint32_t)r + 0x8000).  The cast to uint32_t
   *    it to prevent problems on platforms where int is narrower
   *    than 32 bits.  If int is a larger than 32-bits, then the
   *    usual arithmetic conversions cause this addition to be
   *    done in unsigned int arithmetic.  If int is 32 bits
   *    or narrower, then this addition is done in uint32_t
   *    arithmetic.  In either case, no overflow or wraparound
   *    occurs, and the result from this step has a value that
   *    will be one of 0x00008000 (32768), or in the range
   *    0x00008001 to 0x000080ff (32769 to 33023), or in the range
   *    0x00017f01 to 0x00017fff (98049 to 98303).
   *
   * b. Cast the result from (a) to uint16_t.  This effectively
   *    discards the high bits of the result, in a way that is
   *    well defined by the C language.  The result from this step
   *    will be of type uint16_t, and its value will be one of
   *    0x8000 (32768), or in the range 0x8001 to 0x80ff (32769 to
   *    33023), or in the range 0x7f01 to 0x7fff (32513 to
   *    32767).
   *
   * c. Cast the result from (b) to int32_t.  We use int32_t
   *    instead of int because we need a type that's strictly
   *    larger than 16 bits, and the C standard allows
   *    implementations where int is only 16 bits.  The result
   *    from this step will be of type int32_t, and its value will
   *    be one of 0x00008000 (32768), or in the range 0x00008001
   *    to 0x000080ff (32769 to 33023), or in the range 0x00007f01
   *    to 0x00007fff (32513 to 32767).
   *
   * d. Take the result from (c) and subtract 0x8000 (32768) using
   *    signed int32_t arithmetic.  The result from this step will
   *    be of type int32_t and the value will be one of
   *    0x00000000 (0), or in the range 0x00000001 to 0x000000ff
   *    (+1 to +255), or in the range 0xffffff01 to 0xffffffff
   *    (-255 to -1).
   *
   * e. Cast the result from (d) to int.  This does nothing
   *    interesting, except to make explicit what would have been
   *    implicit in the return statement.  The final result is an
   *    int in the range -255 to +255.
   *
   * Unfortunately, compilers don't seem to be good at figuring
   * out that most of this can be optimised away by careful choice
   * of register width and sign extension.
   *
   */return (/*e*/ int) (/*d*/
    (/*c*/ int32_t) (/*b*/ uint16_t) (/*a*/ (uint32_t) r + 0x8000)
    - 0x8000);
}

References consensus-simulation::int, len, and m.

GNUNET_is_zero_()

enum GNUNET_GenericReturnValue GNUNET_is_zero_	(	const void *	a,
		size_t	n
	)

Check that memory in a is all zeros.

a must be a pointer.

Parameters

a	pointer to n bytes which should be tested for the entire memory being zero'ed out.
n	number of bytes in to be tested

Returns

GNUNET_YES if a is zero, GNUNET_NO otherwise

Definition at line 470 of file common_allocation.c.

{
  const char *b = a;
 
  for (size_t i = 0; i < n; i++)
    if (b[i])
      return GNUNET_NO;
  return GNUNET_YES;
}

GNUNET_xmalloc_()

int int void* GNUNET_xmalloc_	(	size_t	size,
		const char *	filename,
		int	linenumber
	)

Allocate memory.

Checks the return value, aborts if no more memory is available. Don't use GNUNET_xmalloc_ directly. Use the GNUNET_malloc macro. The memory will be zero'ed out.

Parameters

size	number of bytes to allocate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Checks the return value, aborts if no more memory is available.

Parameters

size	how many bytes of memory to allocate, do NOT use this function (or GNUNET_malloc()) to allocate more than several MB of memory, if you are possibly needing a very large chunk use GNUNET_xmalloc_unchecked_() instead.
filename	where in the code was the call to GNUNET_malloc()
linenumber	where in the code was the call to GNUNET_malloc()

Returns

pointer to size bytes of memory

Definition at line 60 of file common_allocation.c.

{
  void *ret;
 
  /* As a security precaution, we generally do not allow very large
   * allocations using the default 'GNUNET_malloc()' macro */
  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
  if (NULL == ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
    GNUNET_assert (0);
  }
  return ret;
}

References filename, GNUNET_assert, GNUNET_assert_at, GNUNET_ERROR_TYPE_ERROR, GNUNET_MAX_MALLOC_CHECKED, GNUNET_xmalloc_unchecked_(), LOG_STRERROR, ret, and size.

Referenced by GNUNET_xgrow_(), GNUNET_xnew_array_2d_(), GNUNET_xnew_array_3d_(), GNUNET_xstrdup_(), and GNUNET_xstrndup_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_xnew_array_2d_()

void** GNUNET_xnew_array_2d_	(	size_t	n,
		size_t	m,
		size_t	elementSize,
		const char *	filename,
		int	linenumber
	)

Allocate memory for a two dimensional array in one block and set up pointers.

Aborts if no more memory is available. Don't use GNUNET_xnew_array_2d_ directly. Use the GNUNET_new_array_2d macro. The memory of the elements will be zero'ed out.

Parameters

n	size of the first dimension
m	size of the second dimension
elementSize	size of a single element in bytes
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 92 of file common_allocation.c.

{
  /* use char pointer internally to avoid void pointer arithmetic warnings */
  char **ret = GNUNET_xmalloc_ (n * sizeof(void *)     /* 1. dim header */
                                + n * m * elementSize, /* element data */
                                filename,
                                linenumber);
 
  for (size_t i = 0; i < n; i++)
    ret[i] = (char *) ret    /* base address */
             + n * sizeof(void *)  /* skip 1. dim header */
             + i * m * elementSize; /* skip to 2. dim row header */
  return (void **) ret;
}

References filename, GNUNET_xmalloc_(), m, and ret.

Here is the call graph for this function:

GNUNET_xnew_array_3d_()

void*** GNUNET_xnew_array_3d_	(	size_t	n,
		size_t	m,
		size_t	o,
		size_t	elementSize,
		const char *	filename,
		int	linenumber
	)

Allocate memory for a three dimensional array in one block and set up pointers.

Aborts if no more memory is available. Don't use GNUNET_xnew_array_3d_ directly. Use the GNUNET_new_array_3d macro. The memory of the elements will be zero'ed out.

Parameters

n	size of the first dimension
m	size of the second dimension
o	size of the third dimension
elementSize	size of a single element in bytes
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 128 of file common_allocation.c.

{
  /* use char pointer internally to avoid void pointer arithmetic warnings */
  char ***ret = GNUNET_xmalloc_ (n * sizeof(void **)     /* 1. dim header */
                                 + n * m * sizeof(void *)    /* 2. dim header */
                                 + n * m * o * elementSize, /* element data */
                                 filename,
                                 linenumber);
 
  for (size_t i = 0; i < n; i++)
  {
    /* need to cast to (char *) temporarily for byte level accuracy */
    ret[i] = (char **) ((char *) ret   /* base address */
                        + n * sizeof(void **)  /* skip 1. dim header */
                        + i * m * sizeof(void *)); /* skip to 2. dim header */
    for (size_t j = 0; j < m; j++)
      ret[i][j] = (char *) ret    /* base address */
                  + n * sizeof(void **)   /* skip 1. dim header */
                  + n * m * sizeof(void *)   /* skip 2. dim header */
                  + i * m * o * elementSize   /* skip to 2. dim part */
                  + j * o * elementSize; /* skip to 3. dim row data */
  }
  return (void ***) ret;
}

References filename, GNUNET_xmalloc_(), m, and ret.

Here is the call graph for this function:

GNUNET_xmemdup_()

void* GNUNET_xmemdup_	(	const void *	buf,
		size_t	size,
		const char *	filename,
		int	linenumber
	)

Allocate and initialize memory.

Checks the return value, aborts if no more memory is available. Don't use GNUNET_xmemdup_ directly. Use the GNUNET_memdup macro.

Parameters

buf	buffer to initialize from (must contain size bytes)
size	number of bytes to allocate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 160 of file common_allocation.c.

{
  void *ret;
 
  /* As a security precaution, we generally do not allow very large
   * allocations here */
  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
  ret = malloc (size);
  if (ret == NULL)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
    GNUNET_assert (0);
  }
  GNUNET_memcpy (ret, buf, size);
  return ret;
}

References buf, filename, GNUNET_assert, GNUNET_assert_at, GNUNET_ERROR_TYPE_ERROR, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, INT_MAX, LOG_STRERROR, ret, and size.

GNUNET_xmalloc_unchecked_()

void* GNUNET_xmalloc_unchecked_	(	size_t	size,
		const char *	filename,
		int	linenumber
	)

Allocate memory.

This function does not check if the allocation request is within reasonable bounds, allowing allocations larger than 40 MB. If you don't expect the possibility of very large allocations, use GNUNET_malloc instead. The memory will be zero'ed out.

Parameters

size	number of bytes to allocate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

pointer to size bytes of memory, NULL if we do not have enough memory

Allocate memory.

Allocates size bytes of memory. The memory will be zero'ed out.

Parameters

size	the number of bytes to allocate
filename	where in the code was the call to GNUNET_malloc_unchecked()
linenumber	where in the code was the call to GNUNET_malloc_unchecked()

Returns

pointer to size bytes of memory, NULL if we do not have enough memory

Definition at line 192 of file common_allocation.c.

{
  void *result;
 
  (void) filename;
  (void) linenumber;
 
  result = malloc (size);
  if (NULL == result)
    return NULL;
  memset (result, 0, size);
 
  return result;
}

References filename, result, and size.

Referenced by GNUNET_xmalloc_().

Here is the caller graph for this function:

GNUNET_xrealloc_()

void* GNUNET_xrealloc_	(	void *	ptr,
		size_t	n,
		const char *	filename,
		int	linenumber
	)

Reallocate memory.

Checks the return value, aborts if no more memory is available.

Checks the return value, aborts if no more memory is available. The content of the intersection of the new and old size will be unchanged.

Parameters

ptr	the pointer to reallocate
n	how many bytes of memory to allocate
filename	where in the code was the call to GNUNET_realloc()
linenumber	where in the code was the call to GNUNET_realloc()

Returns

pointer to size bytes of memory

Definition at line 220 of file common_allocation.c.

{
  (void) filename;
  (void) linenumber;
 
#if defined(M_SIZE)
#if ENABLE_POISONING
  {
    uint64_t *base = ptr;
    size_t s = M_SIZE (ptr);
 
    if (s > n)
    {
      const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
      char *cbase = ptr;
 
      GNUNET_memcpy (&cbase[n],
                     &baadfood,
                     GNUNET_MIN (8 - (n % 8),
                                 s - n));
      for (size_t i = 1 + (n + 7) / 8; i < s / 8; i++)
        base[i] = baadfood;
      GNUNET_memcpy (&base[s / 8],
                     &baadfood,
                     s % 8);
    }
  }
#endif
#endif
  ptr = realloc (ptr, n);
  if ((NULL == ptr) && (n > 0))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
    GNUNET_assert (0);
  }
  return ptr;
}

References filename, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_memcpy, GNUNET_MIN, GNUNET_ntohll(), and LOG_STRERROR.

Here is the call graph for this function:

GNUNET_xfree_()

void GNUNET_xfree_	(	void *	ptr,
		const char *	filename,
		int	linenumber
	)

Free memory.

Merely a wrapper for the case that we want to keep track of allocations. Don't use GNUNET_xfree_ directly. Use the GNUNET_free macro.

Parameters

ptr	pointer to memory to free
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Merely a wrapper for the case that we want to keep track of allocations.

Parameters

ptr	the pointer to free
filename	where in the code was the call to GNUNET_free()
linenumber	where in the code was the call to GNUNET_free()

Definition at line 284 of file common_allocation.c.

{
  if (NULL == ptr)
    return;
#if defined(M_SIZE)
#if ENABLE_POISONING
  {
    const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
    uint64_t *base = ptr;
    size_t s = M_SIZE (ptr);
 
    for (size_t i = 0; i < s / 8; i++)
      base[i] = baadfood;
    GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
  }
#endif
#endif
  free (ptr);
}

References GNUNET_memcpy, and GNUNET_ntohll().

Referenced by GNUNET_xgrow_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_xstrdup_()

char* GNUNET_xstrdup_	(	const char *	str,
		const char *	filename,
		int	linenumber
	)

Dup a string.

Don't call GNUNET_xstrdup_ directly. Use the GNUNET_strdup macro.

Parameters

str	string to duplicate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

the duplicated string

Dup a string.

Parameters

str	the string to dup
filename	where in the code was the call to GNUNET_strdup()
linenumber	where in the code was the call to GNUNET_strdup()

Returns

strdup(@a str)

Definition at line 316 of file common_allocation.c.

{
  char *res;
  size_t slen;
 
  GNUNET_assert_at (str != NULL, filename, linenumber);
  slen = strlen (str) + 1;
  res = GNUNET_xmalloc_ (slen, filename, linenumber);
  GNUNET_memcpy (res, str, slen);
  return res;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_xmalloc_(), and res.

Here is the call graph for this function:

GNUNET_xstrndup_()

char* GNUNET_xstrndup_	(	const char *	str,
		size_t	len,
		const char *	filename,
		int	linenumber
	)

Dup partially a string.

Don't call GNUNET_xstrndup_ directly. Use the GNUNET_strndup macro.

Parameters

str	string to duplicate
len	length of the string to duplicate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

the duplicated string

Dup partially a string.

Parameters

str	the string to dup
len	the length of the string to dup
filename	where in the code was the call to GNUNET_strndup()
linenumber	where in the code was the call to GNUNET_strndup()

Returns

strndup(@a str,@a len)

Definition at line 355 of file common_allocation.c.

{
  char *res;
 
  if (0 == len)
    return GNUNET_strdup ("");
  GNUNET_assert_at (NULL != str, filename, linenumber);
  len = strnlen (str, len);
  res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
  GNUNET_memcpy (res, str, len);
  /* res[len] = '\0'; 'malloc' zeros out anyway */
  return res;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_strdup, GNUNET_xmalloc_(), len, res, and strnlen().

Here is the call graph for this function:

GNUNET_xgrow_()

void GNUNET_xgrow_	(	void **	old,
		size_t	elementSize,
		unsigned int *	oldCount,
		unsigned int	newCount,
		const char *	filename,
		int	linenumber
	)

Grow an array, the new elements are zeroed out.

Grows old by (*oldCount-newCount)*elementSize bytes and sets *oldCount to newCount.

Don't call GNUNET_xgrow_ directly. Use the GNUNET_array_grow macro.

Parameters

old	address of the pointer to the array *old may be NULL
elementSize	the size of the elements of the array
oldCount	address of the number of elements in the *old array
newCount	number of elements in the new array, may be 0 (then *old will be NULL afterwards)
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Grow an array, the new elements are zeroed out.

Grows old by (*oldCount-newCount)*elementSize bytes and sets *oldCount to newCount.

Parameters

old	address of the pointer to the array *old may be NULL
elementSize	the size of the elements of the array
oldCount	address of the number of elements in the *old array
newCount	number of elements in the new array, may be 0
filename	where in the code was the call to GNUNET_array_grow()
linenumber	where in the code was the call to GNUNET_array_grow()

Definition at line 386 of file common_allocation.c.

{
  void *tmp;
  size_t size;
 
  GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
  size = newCount * elementSize;
  if (0 == size)
  {
    tmp = NULL;
  }
  else
  {
    tmp = GNUNET_xmalloc_ (size, filename, linenumber);
    if (NULL != *old)
    {
      GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
    }
  }
 
  if (NULL != *old)
  {
    GNUNET_xfree_ (*old, filename, linenumber);
  }
  *old = tmp;
  *oldCount = newCount;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_MIN, GNUNET_xfree_(), GNUNET_xmalloc_(), INT_MAX, and size.

Here is the call graph for this function:

GNUNET_async_scope_enter()

void GNUNET_async_scope_enter	(	const struct GNUNET_AsyncScopeId *	aid,
		struct GNUNET_AsyncScopeSave *	old_scope
	)

Set the async scope for the current thread.

Parameters

	aid	the async scope identifier
[out]	old_scope	location to save the old scope

Definition at line 1445 of file common_logging.c.

{
  *old_scope = current_async_scope;
  current_async_scope.have_scope = GNUNET_YES;
  current_async_scope.scope_id = *aid;
}

References current_async_scope, GNUNET_YES, GNUNET_AsyncScopeSave::have_scope, and GNUNET_AsyncScopeSave::scope_id.

Referenced by GNUNET_SCHEDULER_begin_async_scope(), and GNUNET_SCHEDULER_do_work().

Here is the caller graph for this function:

GNUNET_async_scope_restore()

void GNUNET_async_scope_restore

(

struct GNUNET_AsyncScopeSave *

old_scope

)

Clear the current thread's async scope.

Parameters

old_scope

scope to restore

Definition at line 1460 of file common_logging.c.

{
  current_async_scope = *old_scope;
}

References current_async_scope.

Referenced by GNUNET_SCHEDULER_do_work().

Here is the caller graph for this function:

GNUNET_async_scope_get()

void GNUNET_async_scope_get

(

struct GNUNET_AsyncScopeSave *

scope_ret

)

Get the current async scope.

Parameters

[out]

scope_ret

pointer to where the result is stored

Definition at line 1486 of file common_logging.c.

{
  *scope_ret = current_async_scope;
}

References current_async_scope.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_do_work(), and setup_job_headers().

Here is the caller graph for this function:

GNUNET_async_scope_fresh()

void GNUNET_async_scope_fresh

(

struct GNUNET_AsyncScopeId *

aid_ret

)

Generate a fresh async scope identifier.

Parameters

[out]

aid_ret

pointer to where the result is stored

Definition at line 1472 of file common_logging.c.

{
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
                              aid_ret,
                              sizeof(struct GNUNET_AsyncScopeId));
}

References GNUNET_CRYPTO_QUALITY_WEAK, and GNUNET_CRYPTO_random_block().

Here is the call graph for this function:

GNUNET_try_compression()

int GNUNET_try_compression	(	const char *	data,
		size_t	old_size,
		char **	result,
		size_t *	new_size
	)

Try to compress the given block of data using libz.

Only returns the compressed block if compression worked and the new block is actually smaller. Decompress using GNUNET_decompress().

Parameters

	data	block to compress; if compression resulted in a smaller block, the first bytes of data are updated to the compressed data
	old_size	number of bytes in data
[out]	result	set to the compressed data, if compression worked
[out]	new_size	set to size of result, if compression worked

Returns

GNUNET_YES if compression reduce the size, GNUNET_NO if compression did not help

Definition at line 33 of file compress.c.

{
  char *tmp;
  uLongf dlen;
 
  *result = NULL;
  *new_size = 0;
#ifdef compressBound
  dlen = compressBound (old_size);
#else
  dlen = old_size + (old_size / 100) + 20;
  /* documentation says 100.1% oldSize + 12 bytes, but we
   * should be able to overshoot by more to be safe */
#endif
  tmp = GNUNET_malloc (dlen);
  if (Z_OK ==
      compress2 ((Bytef *) tmp,
                 &dlen,
                 (const Bytef *) data,
                 old_size, 9))
  {
    if (dlen < old_size)
    {
      *result = tmp;
      *new_size = dlen;
      return GNUNET_YES;
    }
  }
  GNUNET_free (tmp);
  return GNUNET_NO;
}

References data, GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_YES, and result.

Referenced by GNUNET_FS_meta_data_serialize(), and strata_estimator_write().

Here is the caller graph for this function:

GNUNET_decompress()

char* GNUNET_decompress	(	const char *	input,
		size_t	input_size,
		size_t	output_size
	)

Decompress input, return the decompressed data as output.

Dual to GNUNET_try_compression(). Caller must set output_size to the number of bytes that were originally compressed.

Parameters

input	compressed data
input_size	number of bytes in input
output_size	expected size of the output

Returns

NULL on error, buffer of output_size decompressed bytes otherwise

Definition at line 70 of file compress.c.

{
  char *output;
  uLongf olen;
 
  olen = output_size;
  output = GNUNET_malloc (olen);
  if (Z_OK ==
      uncompress ((Bytef *) output,
                  &olen,
                  (const Bytef *) input,
                  input_size))
    return output;
  GNUNET_free (output);
  return NULL;
}

References GNUNET_free, and GNUNET_malloc.

Referenced by GNUNET_FS_meta_data_deserialize(), and strata_estimator_read().

Here is the caller graph for this function:

GNUNET_CONTAINER_bloomfilter_get_element_addresses()

size_t GNUNET_CONTAINER_bloomfilter_get_element_addresses

(

const struct GNUNET_CONTAINER_BloomFilter *

bf

)

Get the number of the addresses set per element in the bloom filter.

Parameters

bf	the filter

Returns

addresses set per element in the bf

Definition at line 88 of file container_bloomfilter.c.

{
  if (bf == NULL)
    return 0;
  return bf->addressesPerElement;
}

References GNUNET_CONTAINER_BloomFilter::addressesPerElement.

GNUNET_CONTAINER_multihashmap32_iterator_create()

struct GNUNET_CONTAINER_MultiHashMap32Iterator* GNUNET_CONTAINER_multihashmap32_iterator_create

(

const struct GNUNET_CONTAINER_MultiHashMap32 *

map

)

Create an iterator for a 32-bit multihashmap.

The iterator can be used to retrieve all the elements in the multihashmap one by one, without having to handle all elements at once (in contrast to GNUNET_CONTAINER_multihashmap32_iterate). Note that the iterator can not be used anymore if elements have been removed from 'map' after the creation of the iterator, or 'map' has been destroyed. Adding elements to 'map' may result in skipped or repeated elements.

Parameters

map	the map to create an iterator for

Returns

an iterator over the given multihashmap map

Create an iterator for a 32-bit multihashmap.

The iterator can be used to retrieve all the elements in the multihashmap one by one, without having to handle all elements at once (in contrast to GNUNET_CONTAINER_multihashmap_iterate()). Note that the iterator can not be used anymore if elements have been removed from 'map' after the creation of the iterator, or 'map' has been destroyed. Adding elements to 'map' may result in skipped or repeated elements.

Parameters

map	the map to create an iterator for

Returns

an iterator over the given multihashmap map

Definition at line 536 of file container_multihashmap32.c.

{
  struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter;
 
  iter = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap32Iterator);
  iter->map = map;
  iter->modification_counter = map->modification_counter;
  iter->me = map->map[0];
  return iter;
}

References GNUNET_new, map, GNUNET_CONTAINER_MultiHashMap32Iterator::map, GNUNET_CONTAINER_MultiPeerMap::map, GNUNET_CONTAINER_MultiHashMap32Iterator::me, GNUNET_CONTAINER_MultiHashMap32Iterator::modification_counter, and GNUNET_CONTAINER_MultiPeerMap::modification_counter.

GNUNET_CONTAINER_multihashmap32_iterator_next()

enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_iterator_next	(	struct GNUNET_CONTAINER_MultiHashMap32Iterator *	iter,
		uint32_t *	key,
		const void **	value
	)

Retrieve the next element from the hash map at the iterator's position.

If there are no elements left, GNUNET_NO is returned, and 'key' and 'value' are not modified. This operation is only allowed if no elements have been removed from the multihashmap since the creation of 'iter', and the map has not been destroyed. Adding elements may result in repeating or skipping elements.

Parameters

iter	the iterator to get the next element from
key	pointer to store the key in, can be NULL
value	pointer to store the value in, can be NULL

Returns

GNUNET_YES we returned an element, GNUNET_NO if we are out of elements

Definition at line 564 of file container_multihashmap32.c.

{
  /* make sure the map has not been modified */
  GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
 
  /* look for the next entry, skipping empty buckets */
  while (1)
  {
    if (iter->idx >= iter->map->map_length)
      return GNUNET_NO;
    if (NULL != iter->me)
    {
      if (NULL != key)
        *key = iter->me->key;
      if (NULL != value)
        *value = iter->me->value;
      iter->me = iter->me->next;
      return GNUNET_YES;
    }
    iter->idx += 1;
    if (iter->idx < iter->map->map_length)
      iter->me = iter->map->map[iter->idx];
  }
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_CONTAINER_MultiHashMap32Iterator::idx, key, MapEntry::key, GNUNET_CONTAINER_MultiHashMap32::map, GNUNET_CONTAINER_MultiHashMap32Iterator::map, GNUNET_CONTAINER_MultiHashMap32::map_length, GNUNET_CONTAINER_MultiHashMap32Iterator::me, GNUNET_CONTAINER_MultiHashMap32::modification_counter, GNUNET_CONTAINER_MultiHashMap32Iterator::modification_counter, MapEntry::next, value, and MapEntry::value.

GNUNET_CONTAINER_multihashmap32_iterator_destroy()

void GNUNET_CONTAINER_multihashmap32_iterator_destroy

(

struct GNUNET_CONTAINER_MultiHashMapIterator *

iter

)

Destroy a 32-bit multihashmap iterator.

Parameters

iter	the iterator to destroy

Destroy a 32-bit multihashmap iterator.

Parameters

iter	the iterator to destroy

Definition at line 599 of file container_multihashmap32.c.

{
  GNUNET_free (iter);
}

References GNUNET_free.

GNUNET_CONTAINER_heap_peek2()

enum GNUNET_GenericReturnValue GNUNET_CONTAINER_heap_peek2	(	const struct GNUNET_CONTAINER_Heap *	heap,
		void **	element,
		GNUNET_CONTAINER_HeapCostType *	cost
	)

Get element and cost stored at the root of heap.

Parameters

[in]	heap	Heap to inspect.
[out]	element	Root element is returned here.
[out]	cost	Cost of element is returned here.

Returns

GNUNET_YES if an element is returned, GNUNET_NO if the heap is empty.

Definition at line 171 of file container_heap.c.

{
  if (NULL == heap->root)
    return GNUNET_NO;
  if (NULL != element)
    *element = heap->root->element;
  if (NULL != cost)
    *cost = heap->root->cost;
  return GNUNET_YES;
}

References GNUNET_CONTAINER_HeapNode::cost, GNUNET_CONTAINER_HeapNode::element, GNUNET_NO, GNUNET_YES, and GNUNET_CONTAINER_Heap::root.

Referenced by GCP_attach_path().

Here is the caller graph for this function:

GNUNET_CRYPTO_crc16_step()

uint32_t GNUNET_CRYPTO_crc16_step	(	uint32_t	sum,
		const void *	buf,
		size_t	len
	)

Perform an incremental step in a CRC16 (for TCP/IP) calculation.

Parameters

sum	current sum, initially 0
buf	buffer to calculate CRC over (must be 16-bit aligned)
len	number of bytes in buf, must be multiple of 2

Returns

updated crc sum (must be subjected to GNUNET_CRYPTO_crc16_finish to get actual crc16)

Definition at line 110 of file crypto_crc.c.

{
  const uint16_t *hdr = buf;
 
  for (; len >= 2; len -= 2)
    sum += *(hdr++);
  if (len == 1)
    sum += ntohs(*((uint8_t *)hdr) << 8);
  return sum;
}

References buf, len, and consensus-simulation::sum.

Referenced by GNUNET_CRYPTO_crc16_n(), GNUNET_TUN_calculate_icmp_checksum(), GNUNET_TUN_calculate_tcp4_checksum(), GNUNET_TUN_calculate_tcp6_checksum(), GNUNET_TUN_calculate_udp4_checksum(), and GNUNET_TUN_calculate_udp6_checksum().

Here is the caller graph for this function:

GNUNET_CRYPTO_crc16_finish()

uint16_t GNUNET_CRYPTO_crc16_finish

(

uint32_t

sum

)

Convert results from GNUNET_CRYPTO_crc16_step to final crc16.

Parameters

sum	cumulative sum

Returns

crc16 value

Definition at line 123 of file crypto_crc.c.

{
  sum = (sum >> 16) + (sum & 0xFFFF);
  sum += (sum >> 16);
 
  return ~sum;
}

References consensus-simulation::sum.

Referenced by GNUNET_CRYPTO_crc16_n(), GNUNET_TUN_calculate_icmp_checksum(), GNUNET_TUN_calculate_tcp4_checksum(), GNUNET_TUN_calculate_tcp6_checksum(), GNUNET_TUN_calculate_udp4_checksum(), and GNUNET_TUN_calculate_udp6_checksum().

Here is the caller graph for this function:

GNUNET_CRYPTO_symmetric_derive_iv_v()

void GNUNET_CRYPTO_symmetric_derive_iv_v	(	struct GNUNET_CRYPTO_SymmetricInitializationVector *	iv,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	skey,
		const void *	salt,
		size_t	salt_len,
		va_list	argp
	)

Derive an IV.

Parameters

iv	initialization vector
skey	session key
salt	salt for the derivation
salt_len	size of the salt
argp	pairs of void * & size_t for context chunks, terminated by NULL

Definition at line 221 of file crypto_symmetric.c.

{
  char aes_salt[salt_len + 4];
  char twofish_salt[salt_len + 4];
 
  GNUNET_memcpy (aes_salt, salt, salt_len);
  GNUNET_memcpy (&aes_salt[salt_len], "AES!", 4);
  GNUNET_memcpy (twofish_salt, salt, salt_len);
  GNUNET_memcpy (&twofish_salt[salt_len], "FISH", 4);
  GNUNET_CRYPTO_kdf_v (iv->aes_iv,
                       sizeof(iv->aes_iv),
                       aes_salt,
                       salt_len + 4,
                       skey->aes_key,
                       sizeof(skey->aes_key),
                       argp);
  GNUNET_CRYPTO_kdf_v (iv->twofish_iv,
                       sizeof(iv->twofish_iv),
                       twofish_salt,
                       salt_len + 4,
                       skey->twofish_key,
                       sizeof(skey->twofish_key),
                       argp);
}

References GNUNET_CRYPTO_SymmetricInitializationVector::aes_iv, GNUNET_CRYPTO_SymmetricSessionKey::aes_key, GNUNET_CRYPTO_kdf_v(), GNUNET_memcpy, salt, GNUNET_CRYPTO_SymmetricInitializationVector::twofish_iv, and GNUNET_CRYPTO_SymmetricSessionKey::twofish_key.

Referenced by GNUNET_CRYPTO_symmetric_derive_iv().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_pow_hash()

void GNUNET_CRYPTO_pow_hash	(	const struct GNUNET_CRYPTO_PowSalt *	salt,
		const void *	buf,
		size_t	buf_len,
		struct GNUNET_HashCode *	result
	)

Calculate the 'proof-of-work' hash (an expensive hash).

Parameters

salt	salt for the hash. Must be crypto_pwhash_argon2id_SALTBYTES long.
buf	data to hash
buf_len	number of bytes in buf
result	where to write the resulting hash

We're using a non-standard formula to avoid issues with ASICs appearing (see #3795).

Parameters

salt	salt for the hash. Must be crypto_pwhash_argon2id_SALTBYTES long.
buf	data to hash
buf_len	number of bytes in buf
result	where to write the resulting hash

Definition at line 42 of file crypto_pow.c.

{
  /* Threads hardcoded at 1 in libsodium */
  GNUNET_break (0 ==
                crypto_pwhash_argon2id ((unsigned char *) result,
                                        sizeof (struct GNUNET_HashCode),
                                        buf,
                                        buf_len,
                                        (unsigned char*) salt,
                                        3, /* iterations */
                                        1024 * 1024, /* memory (1 MiB) */
                                        crypto_pwhash_argon2id_ALG_ARGON2ID13));
}

References buf, GNUNET_break, result, and salt.

Referenced by find_proof().

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_context_start()

struct GNUNET_HashContext* GNUNET_CRYPTO_hash_context_start

(

void

)

Start incremental hashing operation.

Returns

context for incremental hash computation

Definition at line 349 of file crypto_hash.c.

{
  struct GNUNET_HashContext *hc;
 
  BENCHMARK_START (hash_context_start);
  hc = GNUNET_new (struct GNUNET_HashContext);
  GNUNET_assert (0 ==
                 gcry_md_open (&hc->hd,
                               GCRY_MD_SHA512,
                               0));
  BENCHMARK_END (hash_context_start);
  return hc;
}

References BENCHMARK_END, BENCHMARK_START, GNUNET_assert, GNUNET_new, and GNUNET_HashContext::hd.

Referenced by create_randomized_element_iterator(), decode_and_send(), GCCH_get_id(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_SET_element_hash(), GNUNET_SETI_element_hash(), GNUNET_SETU_element_hash(), handle_union_p2p_inquiry(), and hash_addresses().

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_context_copy()

struct GNUNET_HashContext* GNUNET_CRYPTO_hash_context_copy

(

const struct GNUNET_HashContext *

hc

)

Make a copy of the hash computation.

Parameters

hc	hash context to use (to continue hashing independently)

Returns

copy of hc

Definition at line 376 of file crypto_hash.c.

{
  struct GNUNET_HashContext *cp;
 
  cp = GNUNET_new (struct GNUNET_HashContext);
  GNUNET_assert (0 ==
                 gcry_md_copy (&cp->hd,
                               hc->hd));
  return cp;
}

References GNUNET_assert, GNUNET_new, and GNUNET_HashContext::hd.

GNUNET_CRYPTO_hash_context_read()

void GNUNET_CRYPTO_hash_context_read	(	struct GNUNET_HashContext *	hc,
		const void *	buf,
		size_t	size
	)

Add data to be hashed.

Parameters

hc	cumulative hash context
buf	data to add
size	number of bytes in buf

Definition at line 365 of file crypto_hash.c.

{
  BENCHMARK_START (hash_context_read);
  gcry_md_write (hc->hd, buf, size);
  BENCHMARK_END (hash_context_read);
}

References BENCHMARK_END, BENCHMARK_START, buf, GNUNET_HashContext::hd, and size.

Referenced by create_randomized_element_iterator(), decode_and_send(), GCCH_get_id(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_SET_element_hash(), GNUNET_SETI_element_hash(), GNUNET_SETU_element_hash(), handle_union_p2p_inquiry(), and hash_addresses().

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_context_finish()

void GNUNET_CRYPTO_hash_context_finish	(	struct GNUNET_HashContext *	hc,
		struct GNUNET_HashCode *	r_hash
	)

Finish the hash computation.

Parameters

hc	hash context to use, is freed in the process
r_hash	where to write the latest / final hash code

Definition at line 389 of file crypto_hash.c.

{
  const void *res = gcry_md_read (hc->hd, 0);
 
  BENCHMARK_START (hash_context_finish);
 
  GNUNET_assert (NULL != res);
  if (NULL != r_hash)
    GNUNET_memcpy (r_hash,
                   res,
                   sizeof(struct GNUNET_HashCode));
  GNUNET_CRYPTO_hash_context_abort (hc);
  BENCHMARK_END (hash_context_finish);
}

References BENCHMARK_END, BENCHMARK_START, GNUNET_assert, GNUNET_CRYPTO_hash_context_abort(), GNUNET_memcpy, GNUNET_HashContext::hd, and res.

Referenced by create_randomized_element_iterator(), decode_and_send(), GCCH_get_id(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_SET_element_hash(), GNUNET_SETI_element_hash(), GNUNET_SETU_element_hash(), handle_union_p2p_inquiry(), and hash_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_context_abort()

void GNUNET_CRYPTO_hash_context_abort

(

struct GNUNET_HashContext *

hc

)

Abort hashing, do not bother calculating final result.

Parameters

hc	hash context to destroy

Definition at line 407 of file crypto_hash.c.

{
  gcry_md_close (hc->hd);
  GNUNET_free (hc);
}

References GNUNET_free, and GNUNET_HashContext::hd.

Referenced by GNUNET_CRYPTO_hash_context_finish().

Here is the caller graph for this function:

GNUNET_CRYPTO_hmac_raw()

void GNUNET_CRYPTO_hmac_raw	(	const void *	key,
		size_t	key_len,
		const void *	plaintext,
		size_t	plaintext_len,
		struct GNUNET_HashCode *	hmac
	)

Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the above be renamed?

Parameters

key	secret key
key_len	secret key length
plaintext	input plaintext
plaintext_len	length of plaintext
hmac	where to store the hmac

Definition at line 299 of file crypto_hash.c.

{
  static int once;
  static gcry_md_hd_t md;
  const unsigned char *mc;
 
  if (! once)
  {
    once = 1;
    GNUNET_assert (GPG_ERR_NO_ERROR ==
                   gcry_md_open (&md,
                                 GCRY_MD_SHA512,
                                 GCRY_MD_FLAG_HMAC));
  }
  else
  {
    gcry_md_reset (md);
  }
  GNUNET_assert (GPG_ERR_NO_ERROR ==
                 gcry_md_setkey (md, key, key_len));
  gcry_md_write (md, plaintext, plaintext_len);
  mc = gcry_md_read (md, GCRY_MD_SHA512);
  GNUNET_assert (NULL != mc);
  GNUNET_memcpy (hmac->bits, mc, sizeof(hmac->bits));
}

References GNUNET_HashCode::bits, GNUNET_assert, GNUNET_memcpy, key, mc, and once.

Referenced by calculate_hmac(), GNUNET_CRYPTO_hmac(), and OIDC_generate_id_token_hmac().

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_file_cancel()

void GNUNET_CRYPTO_hash_file_cancel

(

struct GNUNET_CRYPTO_FileHashContext *

fhc

)

Cancel a file hashing operation.

Parameters

fhc	operation to cancel (callback must not yet have been invoked)

Definition at line 225 of file crypto_hash_file.c.

{
  GNUNET_SCHEDULER_cancel (fhc->task);
  GNUNET_free (fhc->filename);
  GNUNET_break (GNUNET_OK ==
                GNUNET_DISK_file_close (fhc->fh));
  gcry_md_close (fhc->md);
  GNUNET_free (fhc);
}

References GNUNET_CRYPTO_FileHashContext::fh, GNUNET_CRYPTO_FileHashContext::filename, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_CRYPTO_FileHashContext::md, and GNUNET_CRYPTO_FileHashContext::task.

Referenced by client_disconnect_cb(), GNUNET_FS_indexing_done(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), and publish_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_count_leading_zeros()

unsigned int GNUNET_CRYPTO_hash_count_leading_zeros

(

const struct GNUNET_HashCode *

h

)

Count the number of leading 0 bits in h.

Parameters

h

a hash

Returns

number of leading 0 bits in h

Definition at line 176 of file crypto_hash.c.

{
  const unsigned long long *llp = (const unsigned long long *) h;
  unsigned int ret = 0;
  unsigned int i;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
  for (i = 0; i<sizeof (*h) / sizeof (*llp); i++)
  {
    if (0LLU != llp[i])
      break;
    ret += sizeof (*llp) * 8;
  }
  if (ret == 8 * sizeof (*h))
    return ret;
  ret += __builtin_clzll (GNUNET_ntohll ((uint64_t) llp[i]));
  return ret;
}

References GNUNET_ntohll(), GNUNET_static_assert, h, and ret.

Referenced by add_known_to_bloom(), datacache_get_iterator(), find_proof(), get_matching_bits(), and select_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_hash_count_tailing_zeros()

unsigned int GNUNET_CRYPTO_hash_count_tailing_zeros

(

const struct GNUNET_HashCode *

h

)

Count the number of tailing 0 bits in h.

Parameters

h

a hash

Returns

number of tailing 0 bits in h

Definition at line 198 of file crypto_hash.c.

{
  const unsigned long long *llp = (const unsigned long long *) h;
  unsigned int ret = 0;
  int i;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
  for (i = sizeof (*h) / sizeof (*llp) - 1; i>=0; i--)
  {
    if (0LLU != llp[i])
      break;
    ret += sizeof (*llp) * 8;
  }
  if (ret == 8 * sizeof (*h))
    return ret;
  ret += __builtin_ctzll (GNUNET_ntohll ((uint64_t) llp[i]));
  return ret;
}

References GNUNET_ntohll(), GNUNET_static_assert, h, and ret.

Here is the call graph for this function:

GNUNET_CRYPTO_kdf_v()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf_v	(	void *	result,
		size_t	out_len,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
		va_list	argp
	)

Derive key.

Parameters

result	buffer for the derived key, allocated by caller
out_len	desired length of the derived key
xts	salt
xts_len	length of xts
skm	source key material
skm_len	length of skm
argp	va_list of void * & size_t pairs for context chunks

Returns

GNUNET_YES on success

Definition at line 1 of file crypto_kdf.c.

{
  /*
   * "Finally, we point out to a particularly advantageous instantiation using
   * HMAC-SHA512 as XTR and HMAC-SHA256 in PRF* (in which case the output from SHA-512 is
   * truncated to 256 bits). This makes sense in two ways: First, the extraction part is where we need a
   * stronger hash function due to the unconventional demand from the hash function in the extraction
   * setting. Second, as shown in Section 6, using HMAC with a truncated output as an extractor
   * allows to prove the security of HKDF under considerably weaker assumptions on the underlying
   * hash function."
   *
   * http://eprint.iacr.org/2010/264
   */
  return GNUNET_CRYPTO_hkdf_v (result,
                               out_len,
                               GCRY_MD_SHA512,
                               GCRY_MD_SHA256,
                               xts,
                               xts_len,
                               skm,
                               skm_len,
                               argp);
}

Referenced by GNUNET_CRYPTO_hmac_derive_key_v(), and GNUNET_CRYPTO_symmetric_derive_iv_v().

Here is the caller graph for this function:

GNUNET_CRYPTO_kdf_mod_mpi()

void GNUNET_CRYPTO_kdf_mod_mpi	(	gcry_mpi_t *	r,
		gcry_mpi_t	n,
		const void *	xts,
		size_t	xts_len,
		const void *	skm,
		size_t	skm_len,
		const char *	ctx
	)

Deterministically generate a pseudo-random number uniformly from the integers modulo a libgcrypt mpi.

Parameters

[out]	r	MPI value set to the FDH
	n	MPI to work modulo
	xts	salt
	xts_len	length of xts
	skm	source key material
	skm_len	length of skm
	ctx	context string

Definition at line 95 of file crypto_kdf.c.

{
  gcry_error_t rc;
  unsigned int nbits;
  size_t rsize;
  uint16_t ctr;
 
  nbits = gcry_mpi_get_nbits (n);
  /* GNUNET_assert (nbits > 512); */
  ctr = 0;
  while (1)
  {
    /* Ain't clear if n is always divisible by 8 */
    size_t bsize = (nbits - 1) / 8 + 1;
    uint8_t buf[bsize];
    uint16_t ctr_nbo = htons (ctr);
 
    rc = GNUNET_CRYPTO_kdf (buf,
                            bsize,
                            xts, xts_len,
                            skm, skm_len,
                            ctx, strlen (ctx),
                            &ctr_nbo, sizeof(ctr_nbo),
                            NULL, 0);
    GNUNET_assert (GNUNET_YES == rc);
    rc = gcry_mpi_scan (r,
                        GCRYMPI_FMT_USG,
                        (const unsigned char *) buf,
                        bsize,
                        &rsize);
    GNUNET_assert (GPG_ERR_NO_ERROR == rc);  /* Allocation error? */
    GNUNET_assert (rsize == bsize);
    gcry_mpi_clear_highbit (*r,
                            nbits);
    GNUNET_assert (0 ==
                   gcry_mpi_test_bit (*r,
                                      nbits));
    ++ctr;
    /* We reject this FDH if either *r > n and retry with another ctr */
    if (0 > gcry_mpi_cmp (*r, n))
      break;
    gcry_mpi_release (*r);
  }
}

References bsize, buf, ctx, GNUNET_assert, GNUNET_CRYPTO_kdf(), and GNUNET_YES.

Referenced by cs_full_domain_hash(), GNUNET_CRYPTO_rsa_blind(), and rsa_blinding_key_derive().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecdsa_public_key_to_string()

char* GNUNET_CRYPTO_ecdsa_public_key_to_string

(

const struct GNUNET_CRYPTO_EcdsaPublicKey *

pub

)

Convert a public key to a string.

Parameters

pub	key to convert

Returns

string representing pub

Definition at line 224 of file crypto_ecc.c.

{
  char *pubkeybuf;
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
  char *end;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  pubkeybuf = GNUNET_malloc (keylen + 1);
  end =
    GNUNET_STRINGS_data_to_string ((unsigned char *) pub,
                                   sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
                                   pubkeybuf,
                                   keylen);
  if (NULL == end)
  {
    GNUNET_free (pubkeybuf);
    return NULL;
  }
  *end = '\0';
  return pubkeybuf;
}

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

Referenced by get_ego().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecdsa_private_key_to_string()

char* GNUNET_CRYPTO_ecdsa_private_key_to_string

(

const struct GNUNET_CRYPTO_EcdsaPrivateKey *

priv

)

Convert a private key to a string.

Parameters

priv	key to convert

Returns

string representing priv

Definition at line 305 of file crypto_ecc.c.

{
  char *privkeybuf;
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)) * 8;
  char *end;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  privkeybuf = GNUNET_malloc (keylen + 1);
  end = GNUNET_STRINGS_data_to_string ((unsigned char *) priv,
                                       sizeof(
                                         struct GNUNET_CRYPTO_EcdsaPrivateKey),
                                       privkeybuf,
                                       keylen);
  if (NULL == end)
  {
    GNUNET_free (privkeybuf);
    return NULL;
  }
  *end = '\0';
  return privkeybuf;
}

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

Here is the call graph for this function:

GNUNET_CRYPTO_eddsa_private_key_to_string()

char* GNUNET_CRYPTO_eddsa_private_key_to_string

(

const struct GNUNET_CRYPTO_EddsaPrivateKey *

priv

)

Convert a private key to a string.

Parameters

priv	key to convert

Returns

string representing pub

Definition at line 278 of file crypto_ecc.c.

{
  char *privkeybuf;
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
  char *end;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  privkeybuf = GNUNET_malloc (keylen + 1);
  end = GNUNET_STRINGS_data_to_string ((unsigned char *) priv,
                                       sizeof(
                                         struct GNUNET_CRYPTO_EddsaPrivateKey),
                                       privkeybuf,
                                       keylen);
  if (NULL == end)
  {
    GNUNET_free (privkeybuf);
    return NULL;
  }
  *end = '\0';
  return privkeybuf;
}

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

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_eddsa_public_key_to_string()

char* GNUNET_CRYPTO_eddsa_public_key_to_string

(

const struct GNUNET_CRYPTO_EddsaPublicKey *

pub

)

Convert a public key to a string.

Parameters

pub	key to convert

Returns

string representing pub

Definition at line 251 of file crypto_ecc.c.

{
  char *pubkeybuf;
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
  char *end;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  pubkeybuf = GNUNET_malloc (keylen + 1);
  end =
    GNUNET_STRINGS_data_to_string ((unsigned char *) pub,
                                   sizeof(struct GNUNET_CRYPTO_EddsaPublicKey),
                                   pubkeybuf,
                                   keylen);
  if (NULL == end)
  {
    GNUNET_free (pubkeybuf);
    return NULL;
  }
  *end = '\0';
  return pubkeybuf;
}

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

Referenced by conversation_value_to_string(), create_keys(), GCP_2s(), GNUNET_FRIENDS_write(), GNUNET_HELLO_compose_uri(), GNUNET_i2s(), GNUNET_i2s2(), GNUNET_i2s_full(), main(), messenger_value_to_string(), print_key(), run(), and uri_loc_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecdsa_public_key_from_string()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_public_key_from_string	(	const char *	enc,
		size_t	enclen,
		struct GNUNET_CRYPTO_EcdsaPublicKey *	pub
	)

Convert a string representing a public key to a public key.

Parameters

enc	encoded public key
enclen	number of bytes in enc (without 0-terminator)
pub	where to store the public key

Returns

GNUNET_OK on success

Definition at line 305 of file crypto_ecc.c.

{
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)) * 8;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  if (enclen != keylen)
    return GNUNET_SYSERR;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     enclen,
                                     pub,
                                     sizeof(
                                       struct GNUNET_CRYPTO_EcdsaPublicKey)))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

GNUNET_CRYPTO_eddsa_private_key_from_string()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_private_key_from_string	(	const char *	enc,
		size_t	enclen,
		struct GNUNET_CRYPTO_EddsaPrivateKey *	priv
	)

Convert a string representing a private key to a private key.

Parameters

enc	encoded public key
enclen	number of bytes in enc (without 0-terminator)
priv	where to store the private key

Returns

GNUNET_OK on success

Definition at line 305 of file crypto_ecc.c.

{
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)) * 8;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  if (enclen != keylen)
    return GNUNET_SYSERR;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     enclen,
                                     priv,
                                     sizeof(
                                       struct GNUNET_CRYPTO_EddsaPrivateKey)))
    return GNUNET_SYSERR;
#if CRYPTO_BUG
  if (GNUNET_OK != check_eddsa_key (priv))
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
#endif
  return GNUNET_OK;
}

GNUNET_CRYPTO_eddsa_public_key_from_string()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_public_key_from_string	(	const char *	enc,
		size_t	enclen,
		struct GNUNET_CRYPTO_EddsaPublicKey *	pub
	)

Convert a string representing a public key to a public key.

Parameters

enc	encoded public key
enclen	number of bytes in enc (without 0-terminator)
pub	where to store the public key

Returns

GNUNET_OK on success

Definition at line 305 of file crypto_ecc.c.

{
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)) * 8;
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  if (enclen != keylen)
    return GNUNET_SYSERR;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     enclen,
                                     pub,
                                     sizeof(
                                       struct GNUNET_CRYPTO_EddsaPublicKey)))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

Referenced by blacklist_cfg_iter(), conversation_string_to_value(), create_keys(), gns_string_to_value(), GNUNET_FRIENDS_parse(), hosts_directory_scan_callback(), messenger_string_to_value(), on_identity(), run(), s2i_full(), server_parse_url(), show_peer(), and uri_loc_parse().

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_dlog_prepare()

struct GNUNET_CRYPTO_EccDlogContext* GNUNET_CRYPTO_ecc_dlog_prepare	(	unsigned int	max,
		unsigned int	mem
	)

Do pre-calculation for ECC discrete logarithm for small factors.

Parameters

max	maximum value the factor can be
mem	memory to use (should be smaller than max), must not be zero.

Returns

NULL on error

Definition at line 65 of file crypto_ecc_dlog.c.

{
  struct GNUNET_CRYPTO_EccDlogContext *edc;
  int K = ((max + (mem - 1)) / mem);
 
  GNUNET_assert (max < INT32_MAX);
  edc = GNUNET_new (struct GNUNET_CRYPTO_EccDlogContext);
  edc->max = max;
  edc->mem = mem;
  edc->map = GNUNET_CONTAINER_multipeermap_create (mem * 2,
                                                   GNUNET_NO);
  for (int i = -(int) mem; i <= (int) mem; i++)
  {
    struct GNUNET_CRYPTO_EccScalar Ki;
    struct GNUNET_PeerIdentity key;
 
    GNUNET_CRYPTO_ecc_scalar_from_int (K * i,
                                       &Ki);
    if (0 == i) /* libsodium does not like to multiply with zero */
      GNUNET_assert (
        0 ==
        crypto_core_ed25519_sub ((unsigned char *) &key,
                                 (unsigned char *) &key,
                                 (unsigned char *) &key));
    else
      GNUNET_assert (
        0 ==
        crypto_scalarmult_ed25519_base_noclamp ((unsigned char*) &key,
                                                Ki.v));
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "K*i: %d (mem=%u, i=%d) => %s\n",
                K * i,
                mem,
                i,
                GNUNET_i2s (&key));
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (edc->map,
                                                      &key,
                                                      (void *) (long) i + max,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  return edc;
}

References edc, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, consensus-simulation::int, key, GNUNET_CRYPTO_EccDlogContext::map, max, GNUNET_CRYPTO_EccDlogContext::max, GNUNET_CRYPTO_EccDlogContext::mem, and GNUNET_CRYPTO_EccScalar::v.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_dlog()

int GNUNET_CRYPTO_ecc_dlog	(	struct GNUNET_CRYPTO_EccDlogContext *	edc,
		const struct GNUNET_CRYPTO_EccPoint *	input
	)

Calculate ECC discrete logarithm for small factors.

Opposite of GNUNET_CRYPTO_ecc_dexp().

Parameters

edc	precalculated values, determine range of factors
input	point on the curve to factor

Returns

INT_MAX if dlog failed, otherwise the factor

Definition at line 112 of file crypto_ecc_dlog.c.

{
  unsigned int K = ((edc->max + (edc->mem - 1)) / edc->mem);
  int res;
  struct GNUNET_CRYPTO_EccPoint g;
  struct GNUNET_CRYPTO_EccPoint q;
  struct GNUNET_CRYPTO_EccPoint nq;
 
  {
    struct GNUNET_CRYPTO_EccScalar fact;
 
    memset (&fact,
            0,
            sizeof (fact));
    sodium_increment (fact.v,
                      sizeof (fact.v));
    GNUNET_assert (0 ==
                   crypto_scalarmult_ed25519_base_noclamp (g.v,
                                                           fact.v));
  }
  /* make compiler happy: initialize q and nq, technically not needed! */
  memset (&q,
          0,
          sizeof (q));
  memset (&nq,
          0,
          sizeof (nq));
  res = INT_MAX;
  for (unsigned int i = 0; i <= edc->max / edc->mem; i++)
  {
    struct GNUNET_PeerIdentity key;
    void *retp;
 
    GNUNET_assert (sizeof (key) == crypto_scalarmult_BYTES);
    if (0 == i)
    {
      memcpy (&key,
              input,
              sizeof (key));
    }
    else
    {
      memcpy (&key,
              &q,
              sizeof (key));
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Trying offset i=%u): %s\n",
                i,
                GNUNET_i2s (&key));
    retp = GNUNET_CONTAINER_multipeermap_get (edc->map,
                                              &key);
    if (NULL != retp)
    {
      res = (((long) retp) - edc->max) * K - i;
      /* we continue the loop here to make the implementation
         "constant-time". If we do not care about this, we could just
         'break' here and do fewer operations... */
    }
    if (i == edc->max / edc->mem)
      break;
    /* q = q + g */
    if (0 == i)
    {
      GNUNET_assert (0 ==
                     crypto_core_ed25519_add (q.v,
                                              input->v,
                                              g.v));
    }
    else
    {
      GNUNET_assert (0 ==
                     crypto_core_ed25519_add (q.v,
                                              q.v,
                                              g.v));
    }
  }
  return res;
}

References edc, GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, INT_MAX, key, GNUNET_CRYPTO_EccDlogContext::map, GNUNET_CRYPTO_EccDlogContext::max, GNUNET_CRYPTO_EccDlogContext::mem, q, res, GNUNET_CRYPTO_EccPoint::v, and GNUNET_CRYPTO_EccScalar::v.

Referenced by handle_bobs_cryptodata_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_dexp()

void GNUNET_CRYPTO_ecc_dexp	(	int	val,
		struct GNUNET_CRYPTO_EccPoint *	r
	)

Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing val.

Afterwards, point addition will correspond to integer addition. GNUNET_CRYPTO_ecc_dlog() can be used to convert a point back to an integer (as long as the integer is smaller than the MAX of the edc context).

Parameters

val	value to encode into a point
r	where to write the point (must be allocated)

Definition at line 210 of file crypto_ecc_dlog.c.

{
  struct GNUNET_CRYPTO_EccScalar fact;
 
  GNUNET_CRYPTO_ecc_scalar_from_int (val,
                                     &fact);
  crypto_scalarmult_ed25519_base_noclamp (r->v,
                                          fact.v);
}

GNUNET_CRYPTO_ecc_dexp_mpi()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_dexp_mpi	(	const struct GNUNET_CRYPTO_EccScalar *	val,
		struct GNUNET_CRYPTO_EccPoint *	r
	)

Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing val.

Parameters

val	(positive) value to encode into a point
r	where to write the point (must be allocated)

Returns

GNUNET_OK on success.

Definition at line 210 of file crypto_ecc_dlog.c.

{
  if (0 ==
      crypto_scalarmult_ed25519_base_noclamp (r->v,
                                              val->v))
    return GNUNET_OK;
  return GNUNET_SYSERR;
}

Referenced by send_alices_cryptodata_message().

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_pmul_mpi()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi	(	const struct GNUNET_CRYPTO_EccPoint *	p,
		const struct GNUNET_CRYPTO_EccScalar *	val,
		struct GNUNET_CRYPTO_EccPoint *	r
	)

Multiply the point p on the elliptic curve by val.

Parameters

p	point to multiply
val	(positive) value to encode into a point
r	where to write the point (must be allocated)

Returns

GNUNET_OK on success.

Definition at line 210 of file crypto_ecc_dlog.c.

{
  if (0 ==
      crypto_scalarmult_ed25519_noclamp (r->v,
                                         val->v,
                                         p->v))
    return GNUNET_OK;
  return GNUNET_SYSERR;
}

Referenced by handle_alices_cryptodata_message(), and handle_bobs_cryptodata_message().

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_add()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add	(	const struct GNUNET_CRYPTO_EccPoint *	a,
		const struct GNUNET_CRYPTO_EccPoint *	b,
		struct GNUNET_CRYPTO_EccPoint *	r
	)

Add two points on the elliptic curve.

Parameters

a	some value
b	some value
r	where to write the point (must be allocated)

Returns

GNUNET_OK on success.

Definition at line 210 of file crypto_ecc_dlog.c.

{
  if (0 ==
      crypto_core_ed25519_add (r->v,
                               a->v,
                               b->v))
    return GNUNET_OK;
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_CRYPTO_EccPoint::v, and GNUNET_CRYPTO_EccScalar::v.

Referenced by handle_alices_cryptodata_message(), and handle_bobs_cryptodata_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_rnd()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_rnd	(	struct GNUNET_CRYPTO_EccPoint *	r,
		struct GNUNET_CRYPTO_EccPoint *	r_inv
	)

Obtain a random point on the curve and its additive inverse.

Parameters

[out]	r	set to a random point on the curve
[out]	r_inv	set to the additive inverse of r

Returns

GNUNET_OK on success.

Definition at line 210 of file crypto_ecc_dlog.c.

{
  struct GNUNET_CRYPTO_EccScalar s;
  unsigned char inv_s[crypto_scalarmult_ed25519_SCALARBYTES];
 
  GNUNET_CRYPTO_ecc_random_mod_n (&s);
  if (0 !=
      crypto_scalarmult_ed25519_base_noclamp (r->v,
                                              s.v))
    return GNUNET_SYSERR;
  crypto_core_ed25519_scalar_negate (inv_s,
                                     s.v);
  if (0 !=
      crypto_scalarmult_ed25519_base_noclamp (r_inv->v,
                                              inv_s))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

GNUNET_CRYPTO_ecc_rnd_mpi()

void GNUNET_CRYPTO_ecc_rnd_mpi	(	struct GNUNET_CRYPTO_EccScalar *	r,
		struct GNUNET_CRYPTO_EccScalar *	r_neg
	)

Obtain a random scalar for point multiplication on the curve and its additive inverse.

Parameters

[out]	r	set to a random scalar on the curve
[out]	r_neg	set to the negation of

Definition at line 285 of file crypto_ecc_dlog.c.

{
  GNUNET_CRYPTO_ecc_random_mod_n (r);
  crypto_core_ed25519_scalar_negate (r_neg->v,
                                     r->v);
}

References GNUNET_CRYPTO_ecc_random_mod_n(), and GNUNET_CRYPTO_EccScalar::v.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_random_mod_n()

void GNUNET_CRYPTO_ecc_random_mod_n

(

struct GNUNET_CRYPTO_EccScalar *

r

)

Generate a random value mod n.

Parameters

[out]

r

random value mod n.

Definition at line 195 of file crypto_ecc_dlog.c.

{
  crypto_core_ed25519_scalar_random (r->v);
}

References GNUNET_CRYPTO_EccScalar::v.

Referenced by GNUNET_CRYPTO_ecc_rnd_mpi(), and send_alices_cryptodata_message().

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_dlog_release()

void GNUNET_CRYPTO_ecc_dlog_release

(

struct GNUNET_CRYPTO_EccDlogContext *

dlc

)

Release precalculated values.

Parameters

dlc	dlog context

Definition at line 202 of file crypto_ecc_dlog.c.

{
  GNUNET_CONTAINER_multipeermap_destroy (edc->map);
  GNUNET_free (edc);
}

References edc, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_free, and GNUNET_CRYPTO_EccDlogContext::map.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_ecc_scalar_from_int()

void GNUNET_CRYPTO_ecc_scalar_from_int	(	int64_t	val,
		struct GNUNET_CRYPTO_EccScalar *	r
	)

Create a scalar from int value.

Parameters

	val	the int value
[out]	r	where to write the salar

Definition at line 295 of file crypto_ecc_dlog.c.

{
  unsigned char fact[crypto_scalarmult_ed25519_SCALARBYTES];
  uint64_t valBe;
 
  GNUNET_assert (sizeof (*r) == sizeof (fact));
  if (val < 0)
  {
    if (INT64_MIN == val)
      valBe = GNUNET_htonll ((uint64_t) INT64_MAX);
    else
      valBe = GNUNET_htonll ((uint64_t) (-val));
  }
  else
  {
    valBe = GNUNET_htonll ((uint64_t) val);
  }
  memset (fact,
          0,
          sizeof (fact));
  for (unsigned int i = 0; i < sizeof (val); i++)
    fact[i] = ((unsigned char*) &valBe)[sizeof (val) - 1 - i];
  if (val < 0)
  {
    if (INT64_MIN == val)
      /* See above: fact is one too small, increment now that we can */
      sodium_increment (fact,
                        sizeof (fact));
    crypto_core_ed25519_scalar_negate (r->v,
                                       fact);
  }
  else
  {
    memcpy (r,
            fact,
            sizeof (fact));
  }
}

References GNUNET_assert, GNUNET_htonll(), and GNUNET_CRYPTO_EccScalar::v.

Referenced by GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_dlog_prepare(), handle_alices_cryptodata_message(), and send_alices_cryptodata_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_eddsa_sign_raw()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_raw	(	const struct GNUNET_CRYPTO_EddsaPrivateKey *	priv,
		void *	data,
		size_t	size,
		struct GNUNET_CRYPTO_EddsaSignature *	sig
	)

Parameters

priv
data
size
sig

Returns

enum GNUNET_GenericReturnValue

Definition at line 512 of file crypto_ecc.c.

{
  unsigned char sk[crypto_sign_SECRETKEYBYTES];
  unsigned char pk[crypto_sign_PUBLICKEYBYTES];
  int res;
 
  GNUNET_assert (0 == crypto_sign_seed_keypair (pk, sk, priv->d));
  res = crypto_sign_detached ((uint8_t *) sig,
                              NULL,
                              (uint8_t *) data,
                              size,
                              sk);
  return (res == 0) ? GNUNET_OK : GNUNET_SYSERR;
}

Referenced by ego_sign_data_cb().

Here is the caller graph for this function:

GNUNET_CRYPTO_ecdsa_sign_derived()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_sign_derived	(	const struct GNUNET_CRYPTO_EcdsaPrivateKey *	pkey,
		const char *	label,
		const char *	context,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	purpose,
		struct GNUNET_CRYPTO_EcdsaSignature *	sig
	)

This is a signature function for ECDSA which takes a private key, derives/blinds it and signs the message.

Parameters

pkey	original private key
label	label to use for key deriviation
context	additional context to use for HKDF of 'h'; typically the name of the subsystem/application
purpose	the signature purpose
sig	the resulting signature

Returns

GNUNET_OK on success

Definition at line 48 of file crypto_ecc_gnsrecord.c.

{
  struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
  enum GNUNET_GenericReturnValue res;
  key = GNUNET_CRYPTO_ecdsa_private_key_derive (priv,
                                                label,
                                                context);
  res = GNUNET_CRYPTO_ecdsa_sign_ (key,
                                   purpose,
                                   sig);
  GNUNET_free (key);
  return res;
}

References context, GNUNET_CRYPTO_kdf(), pub, and salt.

Here is the call graph for this function:

GNUNET_CRYPTO_eddsa_sign_derived()

enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_derived	(	const struct GNUNET_CRYPTO_EddsaPrivateKey *	pkey,
		const char *	label,
		const char *	context,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	purpose,
		struct GNUNET_CRYPTO_EddsaSignature *	sig
	)

This is a signature function for EdDSA which takes a private key and derives it using the label and context before signing.

Parameters

pkey	original private key
label	label to use for key deriviation
context	additional context to use for HKDF of 'h'; typically the name of the subsystem/application
purpose	the signature purpose
sig	the resulting signature

Returns

GNUNET_OK on success

Derive the private key

Instead of expanding the private here, we already have the secret scalar as input. Use it. Note that sk is not plain SHA512 (d). sk[0..31] contains the derived private scalar sk[0..31] = h * SHA512 (d)[0..31] sk[32..63] = SHA512 (d)[32..63]

Calculate the derived zone key zk' from the derived private scalar.

Calculate r: r = SHA512 (sk[32..63] | M) where M is our message (purpose). Note that sk[32..63] is the other half of the expansion from the original, non-derived private key "d".

Temporarily put zk into S

Reduce the scalar value r

Calculate R := r * G of the signature

Calculate hram := SHA512 (R | zk' | M)

Reduce the resulting scalar value

Calculate S := r + hram * s mod L

Definition at line 48 of file crypto_ecc_gnsrecord.c.

{
  struct GNUNET_CRYPTO_EddsaPrivateScalar priv;
  crypto_hash_sha512_state hs;
  unsigned char sk[64];
  unsigned char r[64];
  unsigned char hram[64];
  unsigned char R[32];
  unsigned char zk[32];
  unsigned char tmp[32];
 
  GNUNET_CRYPTO_eddsa_private_key_derive (pkey,
                                          label,
                                          context,
                                          &priv);
 
  crypto_hash_sha512_init (&hs);
 
  memcpy (sk, priv.s, 64);
 
  crypto_scalarmult_ed25519_base_noclamp (zk,
                                          sk);
 
  crypto_hash_sha512_update (&hs, sk + 32, 32);
  crypto_hash_sha512_update (&hs, (uint8_t*) purpose, ntohl (purpose->size));
  crypto_hash_sha512_final (&hs, r);
 
  memcpy (sig->s, zk, 32);
 
  unsigned char r_mod[64];
  crypto_core_ed25519_scalar_reduce (r_mod, r);
 
  crypto_scalarmult_ed25519_base_noclamp (R, r_mod);
  memcpy (sig->r, R, sizeof (R));
 
  crypto_hash_sha512_init (&hs);
  crypto_hash_sha512_update (&hs, (uint8_t*) sig, 64);
  crypto_hash_sha512_update (&hs, (uint8_t*) purpose,
                             ntohl (purpose->size));
  crypto_hash_sha512_final (&hs, hram);
 
  unsigned char hram_mod[64];
  crypto_core_ed25519_scalar_reduce (hram_mod, hram);
 
  crypto_core_ed25519_scalar_mul (tmp, hram_mod, sk);
  crypto_core_ed25519_scalar_add (sig->s, tmp, r_mod);
 
  sodium_memzero (sk, sizeof (sk));
  sodium_memzero (r, sizeof (r));
  sodium_memzero (r_mod, sizeof (r_mod));
  return GNUNET_OK;
}

GNUNET_CRYPTO_eddsa_key_get_public_from_scalar()

void GNUNET_CRYPTO_eddsa_key_get_public_from_scalar	(	const struct GNUNET_CRYPTO_EddsaPrivateScalar *	s,
		struct GNUNET_CRYPTO_EddsaPublicKey *	pkey
	)

Extract the public key of the given private scalar.

Parameters

s	the private scalar
pkey	the resulting public key

Calculate the derived zone key zk' from the derived private scalar.

Definition at line 448 of file crypto_ecc_gnsrecord.c.

{
  unsigned char sk[32];
 
  memcpy (sk, priv->s, 32);
 
  crypto_scalarmult_ed25519_base_noclamp (pkey->q_y,
                                          sk);
}

References pkey, and GNUNET_CRYPTO_EddsaPrivateScalar::s.

GNUNET_CRYPTO_mpi_print_unsigned()

void GNUNET_CRYPTO_mpi_print_unsigned	(	void *	buf,
		size_t	size,
		gcry_mpi_t	val
	)

Output the given MPI value to the given buffer in network byte order.

The MPI val may not be negative.

Parameters

buf	where to output to
size	number of bytes in buf
val	value to write to buf

Definition at line 79 of file crypto_mpi.c.

{
  size_t rsize;
  int rc;
 
  if (gcry_mpi_get_flag (val, GCRYMPI_FLAG_OPAQUE))
  {
    /* Store opaque MPIs left aligned into the buffer.  */
    unsigned int nbits;
    const void *p;
 
    p = gcry_mpi_get_opaque (val, &nbits);
    GNUNET_assert (p);
    rsize = (nbits + 7) / 8;
    if (rsize > size)
      rsize = size;
    GNUNET_memcpy (buf, p, rsize);
    if (rsize < size)
      memset (buf + rsize, 0, size - rsize);
  }
  else
  {
    /* Store regular MPIs as unsigned integers right aligned into
       the buffer.  */
    rsize = size;
    if (0 !=
        (rc = gcry_mpi_print (GCRYMPI_FMT_USG,
                              buf,
                              rsize, &rsize,
                              val)))
    {
      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
                "gcry_mpi_print",
                rc);
      GNUNET_assert (0);
    }
    adjust (buf, rsize, size);
  }
}

References adjust(), buf, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_memcpy, LOG_GCRY, p, and size.

Referenced by cs_full_domain_hash(), decrypt_conclude(), encrypt_fair(), GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_paillier_create(), GNUNET_CRYPTO_paillier_encrypt(), GNUNET_CRYPTO_paillier_encrypt1(), GNUNET_CRYPTO_paillier_hom_add(), GNUNET_SECRETSHARING_encrypt(), GNUNET_SECRETSHARING_plaintext_generate_i(), insert_decrypt_element(), insert_round1_element(), insert_round2_element(), and keygen_round2_conclude().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_mpi_scan_unsigned()

void GNUNET_CRYPTO_mpi_scan_unsigned	(	gcry_mpi_t *	result,
		const void *	data,
		size_t	size
	)

Convert data buffer into MPI value.

The buffer is interpreted as network byte order, unsigned integer.

Parameters

result	where to store MPI value (allocated)
data	raw data (GCRYMPI_FMT_USG)
size	number of bytes in data

Definition at line 132 of file crypto_mpi.c.

{
  int rc;
 
  if (0 != (rc = gcry_mpi_scan (result,
                                GCRYMPI_FMT_USG,
                                data, size, &size)))
  {
    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
              "gcry_mpi_scan",
              rc);
    GNUNET_assert (0);
  }
}

References data, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, LOG_GCRY, result, and size.

Referenced by cs_full_domain_hash(), decrypt_conclude(), decrypt_new_element(), encrypt_fair(), get_fair_encryption_challenge(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_paillier_decrypt(), GNUNET_CRYPTO_paillier_encrypt(), GNUNET_CRYPTO_paillier_encrypt1(), GNUNET_CRYPTO_paillier_hom_add(), GNUNET_SECRETSHARING_encrypt(), insert_decrypt_element(), keygen_reveal_get_exp_coeff(), keygen_reveal_get_exp_preshare(), keygen_round1_new_element(), restore_fair(), and verify_fair().

Here is the caller graph for this function:

GNUNET_CRYPTO_paillier_create()

void GNUNET_CRYPTO_paillier_create	(	struct GNUNET_CRYPTO_PaillierPublicKey *	public_key,
		struct GNUNET_CRYPTO_PaillierPrivateKey *	private_key
	)

Create a freshly generated paillier public key.

Parameters

[out]	public_key	Where to store the public key?
[out]	private_key	Where to store the private key?

Definition at line 40 of file crypto_paillier.c.

{
  gcry_mpi_t p;
  gcry_mpi_t q;
  gcry_mpi_t phi;
  gcry_mpi_t mu;
  gcry_mpi_t n;
 
  /* Generate two distinct primes.  The probability that the loop body
     is executed more than once is very very low... */
  p = NULL;
  q = NULL;
  do
  {
    if (NULL != p)
      gcry_mpi_release (p);
    if (NULL != q)
      gcry_mpi_release (q);
    GNUNET_assert (0 ==
                   gcry_prime_generate (&p,
                                        GNUNET_CRYPTO_PAILLIER_BITS / 2,
                                        0, NULL, NULL, NULL,
                                        GCRY_STRONG_RANDOM, 0));
    GNUNET_assert (0 ==
                   gcry_prime_generate (&q,
                                        GNUNET_CRYPTO_PAILLIER_BITS / 2,
                                        0, NULL, NULL, NULL,
                                        GCRY_STRONG_RANDOM, 0));
  }
  while (0 == gcry_mpi_cmp (p, q));
  /* n = p * q */
  GNUNET_assert (NULL != (n = gcry_mpi_new (0)));
  gcry_mpi_mul (n,
                p,
                q);
  GNUNET_CRYPTO_mpi_print_unsigned (public_key,
                                    sizeof(struct
                                           GNUNET_CRYPTO_PaillierPublicKey),
                                    n);
 
  /* compute phi(n) = (p-1)(q-1) */
  GNUNET_assert (NULL != (phi = gcry_mpi_new (0)));
  gcry_mpi_sub_ui (p, p, 1);
  gcry_mpi_sub_ui (q, q, 1);
  gcry_mpi_mul (phi, p, q);
  gcry_mpi_release (p);
  gcry_mpi_release (q);
 
  /* lambda equals phi(n) in the simplified key generation */
  GNUNET_CRYPTO_mpi_print_unsigned (private_key->lambda,
                                    GNUNET_CRYPTO_PAILLIER_BITS / 8,
                                    phi);
  /* mu = phi^{-1} mod n, as we use g = n + 1 */
  GNUNET_assert (NULL != (mu = gcry_mpi_new (0)));
  GNUNET_assert (0 != gcry_mpi_invm (mu,
                                     phi,
                                     n));
  gcry_mpi_release (phi);
  gcry_mpi_release (n);
  GNUNET_CRYPTO_mpi_print_unsigned (private_key->mu,
                                    GNUNET_CRYPTO_PAILLIER_BITS / 8,
                                    mu);
  gcry_mpi_release (mu);
}

References GNUNET_assert, GNUNET_CRYPTO_mpi_print_unsigned(), GNUNET_CRYPTO_PAILLIER_BITS, GNUNET_CRYPTO_PaillierPrivateKey::lambda, GNUNET_CRYPTO_PaillierPrivateKey::mu, p, and q.

Referenced by handle_client_keygen(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_paillier_encrypt()

int GNUNET_CRYPTO_paillier_encrypt	(	const struct GNUNET_CRYPTO_PaillierPublicKey *	public_key,
		const gcry_mpi_t	m,
		int	desired_ops,
		struct GNUNET_CRYPTO_PaillierCiphertext *	ciphertext
	)

Encrypt a plaintext with a paillier public key.

Parameters

	public_key	Public key to use.
	m	Plaintext to encrypt.
	desired_ops	How many homomorphic ops the caller intends to use
[out]	ciphertext	Encryption of plaintext with public_key.

Returns

guaranteed number of supported homomorphic operations >= 1, or desired_ops, in case that is lower, or -1 if less than one homomorphic operation is possible

Definition at line 221 of file crypto_paillier.c.

{
  int possible_opts;
  gcry_mpi_t n_square;
  gcry_mpi_t r;
  gcry_mpi_t rn;
  gcry_mpi_t g;
  gcry_mpi_t gm;
  gcry_mpi_t c;
  gcry_mpi_t n;
  gcry_mpi_t max_num;
  unsigned int highbit;
 
  /* set max_num = 2^{GNUNET_CRYPTO_PAILLIER_BITS}, the largest
     number we can have as a result */
  GNUNET_assert (NULL != (max_num = gcry_mpi_set_ui (NULL, 1)));
  gcry_mpi_mul_2exp (max_num,
                     max_num,
                     GNUNET_CRYPTO_PAILLIER_BITS);
 
  /* Determine how many operations we could allow, assuming the other
     number has the same length (or is smaller), by counting the
     number of possible operations.  We essentially divide max_num by
     2 until the result is no longer larger than 'm', incrementing the
     maximum number of operations in each round, starting at -2 */for (possible_opts = -2; gcry_mpi_cmp (max_num, m) > 0; possible_opts++)
    gcry_mpi_div (max_num,
                  NULL,
                  max_num,
                  GCRYMPI_CONST_TWO,
                  0);
  gcry_mpi_release (max_num);
 
  if (possible_opts < 1)
    possible_opts = 0;
  /* Enforce soft-cap by caller */
  possible_opts = GNUNET_MIN (desired_ops, possible_opts);
  ciphertext->remaining_ops = htonl (possible_opts);
 
  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
                                   public_key,
                                   sizeof(struct
                                          GNUNET_CRYPTO_PaillierPublicKey));
 
  /* check public key for number of bits, bail out if key is all zeros */
  highbit = GNUNET_CRYPTO_PAILLIER_BITS - 1;
  while ((! gcry_mpi_test_bit (n, highbit)) &&
         (0 != highbit))
    highbit--;
  if (0 == highbit)
  {
    /* invalid public key */
    GNUNET_break_op (0);
    gcry_mpi_release (n);
    return GNUNET_SYSERR;
  }
 
  /* generate r < n (without bias) */
  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
  do
  {
    gcry_mpi_randomize (r, highbit + 1, GCRY_STRONG_RANDOM);
  }
  while (gcry_mpi_cmp (r, n) >= 0);
 
  /* g = n + 1 */
  GNUNET_assert (0 != (g = gcry_mpi_new (0)));
  gcry_mpi_add_ui (g, n, 1);
 
  /* n_square = n^2 */
  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
  gcry_mpi_mul (n_square,
                n,
                n);
 
  /* gm = g^m mod n^2 */
  GNUNET_assert (0 != (gm = gcry_mpi_new (0)));
  gcry_mpi_powm (gm, g, m, n_square);
  gcry_mpi_release (g);
 
  /* rn <- r^n mod n^2 */
  GNUNET_assert (0 != (rn = gcry_mpi_new (0)));
  gcry_mpi_powm (rn, r, n, n_square);
  gcry_mpi_release (r);
  gcry_mpi_release (n);
 
  /* c <- rn * gm mod n^2 */
  GNUNET_assert (0 != (c = gcry_mpi_new (0)));
  gcry_mpi_mulm (c, rn, gm, n_square);
  gcry_mpi_release (n_square);
  gcry_mpi_release (gm);
  gcry_mpi_release (rn);
 
  GNUNET_CRYPTO_mpi_print_unsigned (ciphertext->bits,
                                    sizeof(ciphertext->bits),
                                    c);
  gcry_mpi_release (c);
 
  return possible_opts;
}

References ciphertext, GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_mpi_print_unsigned(), GNUNET_CRYPTO_mpi_scan_unsigned(), GNUNET_CRYPTO_PAILLIER_BITS, GNUNET_MIN, GNUNET_SYSERR, and m.

Referenced by compute_service_response(), and send_alices_cryptodata_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_paillier_decrypt()

void GNUNET_CRYPTO_paillier_decrypt	(	const struct GNUNET_CRYPTO_PaillierPrivateKey *	private_key,
		const struct GNUNET_CRYPTO_PaillierPublicKey *	public_key,
		const struct GNUNET_CRYPTO_PaillierCiphertext *	ciphertext,
		gcry_mpi_t	m
	)

Decrypt a paillier ciphertext with a private key.

Parameters

	private_key	Private key to use for decryption.
	public_key	Public key to use for decryption.
	ciphertext	Ciphertext to decrypt.
[out]	m	Decryption of ciphertext with private_key.

Definition at line 328 of file crypto_paillier.c.

{
  gcry_mpi_t mu;
  gcry_mpi_t lambda;
  gcry_mpi_t n;
  gcry_mpi_t n_square;
  gcry_mpi_t c;
  gcry_mpi_t cmu;
  gcry_mpi_t cmum1;
  gcry_mpi_t mod;
 
  GNUNET_CRYPTO_mpi_scan_unsigned (&lambda,
                                   private_key->lambda,
                                   sizeof(private_key->lambda));
  GNUNET_CRYPTO_mpi_scan_unsigned (&mu,
                                   private_key->mu,
                                   sizeof(private_key->mu));
  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
                                   public_key,
                                   sizeof(struct
                                          GNUNET_CRYPTO_PaillierPublicKey));
  GNUNET_CRYPTO_mpi_scan_unsigned (&c,
                                   ciphertext->bits,
                                   sizeof(ciphertext->bits));
 
  /* n_square = n * n */
  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
  gcry_mpi_mul (n_square, n, n);
 
  /* cmu = c^lambda mod n^2 */
  GNUNET_assert (0 != (cmu = gcry_mpi_new (0)));
  gcry_mpi_powm (cmu,
                 c,
                 lambda,
                 n_square);
  gcry_mpi_release (n_square);
  gcry_mpi_release (lambda);
  gcry_mpi_release (c);
 
  /* cmum1 = cmu - 1 */
  GNUNET_assert (0 != (cmum1 = gcry_mpi_new (0)));
  gcry_mpi_sub_ui (cmum1, cmu, 1);
  gcry_mpi_release (cmu);
 
  /* mod = cmum1 / n (mod n) */
  GNUNET_assert (0 != (mod = gcry_mpi_new (0)));
  gcry_mpi_div (mod, NULL, cmum1, n, 0);
  gcry_mpi_release (cmum1);
 
  /* m = mod * mu mod n */
  gcry_mpi_mulm (m, mod, mu, n);
  gcry_mpi_release (mod);
  gcry_mpi_release (mu);
  gcry_mpi_release (n);
}

References ciphertext, GNUNET_assert, GNUNET_CRYPTO_mpi_scan_unsigned(), GNUNET_CRYPTO_PaillierPrivateKey::lambda, m, and GNUNET_CRYPTO_PaillierPrivateKey::mu.

Referenced by compute_scalar_product(), and keygen_round2_new_element().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_paillier_hom_add()

int GNUNET_CRYPTO_paillier_hom_add	(	const struct GNUNET_CRYPTO_PaillierPublicKey *	public_key,
		const struct GNUNET_CRYPTO_PaillierCiphertext *	c1,
		const struct GNUNET_CRYPTO_PaillierCiphertext *	c2,
		struct GNUNET_CRYPTO_PaillierCiphertext *	result
	)

Compute a ciphertext that represents the sum of the plaintext in c1 and c2.

Note that this operation can only be done a finite number of times before an overflow occurs.

Parameters

	public_key	Public key to use for encryption.
	c1	Paillier cipher text.
	c2	Paillier cipher text.
[out]	result	Result of the homomorphic operation.

Returns

GNUNET_OK if the result could be computed, GNUNET_SYSERR if no more homomorphic operations are remaining.

Definition at line 392 of file crypto_paillier.c.

{
  gcry_mpi_t a;
  gcry_mpi_t b;
  gcry_mpi_t c;
  gcry_mpi_t n;
  gcry_mpi_t n_square;
  int32_t o1;
  int32_t o2;
 
  o1 = (int32_t) ntohl (c1->remaining_ops);
  o2 = (int32_t) ntohl (c2->remaining_ops);
  if ((0 >= o1) || (0 >= o2))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  GNUNET_CRYPTO_mpi_scan_unsigned (&a,
                                   c1->bits,
                                   sizeof(c1->bits));
  GNUNET_CRYPTO_mpi_scan_unsigned (&b,
                                   c2->bits,
                                   sizeof(c2->bits));
  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
                                   public_key,
                                   sizeof(struct
                                          GNUNET_CRYPTO_PaillierPublicKey));
 
  /* n_square = n * n */
  GNUNET_assert (0 != (n_square = gcry_mpi_new (0)));
  gcry_mpi_mul (n_square, n, n);
  gcry_mpi_release (n);
 
  /* c = a * b mod n_square */
  GNUNET_assert (0 != (c = gcry_mpi_new (0)));
  gcry_mpi_mulm (c, a, b, n_square);
  gcry_mpi_release (n_square);
  gcry_mpi_release (a);
  gcry_mpi_release (b);
 
  result->remaining_ops = htonl (GNUNET_MIN (o1, o2) - 1);
  GNUNET_CRYPTO_mpi_print_unsigned (result->bits,
                                    sizeof(result->bits),
                                    c);
  gcry_mpi_release (c);
  return ntohl (result->remaining_ops);
}

References GNUNET_CRYPTO_PaillierCiphertext::bits, GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_mpi_print_unsigned(), GNUNET_CRYPTO_mpi_scan_unsigned(), GNUNET_MIN, GNUNET_SYSERR, GNUNET_CRYPTO_PaillierCiphertext::remaining_ops, and result.

Referenced by compute_service_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_paillier_hom_get_remaining()

int GNUNET_CRYPTO_paillier_hom_get_remaining

(

const struct GNUNET_CRYPTO_PaillierCiphertext *

c

)

Get the number of remaining supported homomorphic operations.

Parameters

c	Paillier cipher text.

Returns

the number of remaining homomorphic operations

Definition at line 455 of file crypto_paillier.c.

{
  GNUNET_assert (NULL != c);
  return ntohl (c->remaining_ops);
}

References GNUNET_assert, and GNUNET_CRYPTO_PaillierCiphertext::remaining_ops.

GNUNET_CRYPTO_rsa_private_key_create()

struct GNUNET_CRYPTO_RsaPrivateKey* GNUNET_CRYPTO_rsa_private_key_create

(

unsigned int

len

)

Create a new private key.

Caller must free return value.

Parameters

len	length of the key in bits (e.g. 2048)

Returns

fresh private key

Definition at line 144 of file crypto_rsa.c.

{
  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
  gcry_sexp_t s_key;
  gcry_sexp_t s_keyparam;
 
  BENCHMARK_START (rsa_private_key_create);
 
  GNUNET_assert (0 ==
                 gcry_sexp_build (&s_keyparam,
                                  NULL,
                                  "(genkey(rsa(nbits %d)))",
                                  len));
  GNUNET_assert (0 ==
                 gcry_pk_genkey (&s_key,
                                 s_keyparam));
  gcry_sexp_release (s_keyparam);
#if EXTRA_CHECKS
  GNUNET_assert (0 ==
                 gcry_pk_testkey (s_key));
#endif
  ret = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
  ret->sexp = s_key;
  BENCHMARK_END (rsa_private_key_create);
  return ret;
}

References BENCHMARK_END, BENCHMARK_START, GNUNET_assert, GNUNET_new, len, and ret.

Referenced by output_vectors().

Here is the caller graph for this function:

GNUNET_CRYPTO_rsa_private_key_free()

void GNUNET_CRYPTO_rsa_private_key_free

(

struct GNUNET_CRYPTO_RsaPrivateKey *

key

)

Free memory occupied by the private key.

Parameters

key	pointer to the memory to free

Definition at line 173 of file crypto_rsa.c.

{
  gcry_sexp_release (key->sexp);
  GNUNET_free (key);
}

References GNUNET_free, and key.

Referenced by checkvec(), GNUNET_CRYPTO_rsa_private_key_decode(), and output_vectors().

Here is the caller graph for this function:

GNUNET_CRYPTO_rsa_private_key_encode()

size_t GNUNET_CRYPTO_rsa_private_key_encode	(	const struct GNUNET_CRYPTO_RsaPrivateKey *	key,
		void **	buffer
	)

Encode the private key in a format suitable for storing it into a file.

Parameters

	key	the private key
[out]	buffer	set to a buffer with the encoded key

Returns

size of memory allocatedin buffer

Definition at line 181 of file crypto_rsa.c.

{
  size_t n;
  char *b;
 
  n = gcry_sexp_sprint (key->sexp,
                        GCRYSEXP_FMT_DEFAULT,
                        NULL,
                        0);
  b = GNUNET_malloc (n);
  GNUNET_assert ((n - 1) ==      /* since the last byte is \0 */
                 gcry_sexp_sprint (key->sexp,
                                   GCRYSEXP_FMT_DEFAULT,
                                   b,
                                   n));
  *buffer = b;
  return n;
}

References GNUNET_assert, GNUNET_malloc, and key.

Referenced by GNUNET_CRYPTO_rsa_private_key_cmp(), and output_vectors().

Here is the caller graph for this function:

GNUNET_CRYPTO_rsa_private_key_decode()

struct GNUNET_CRYPTO_RsaPrivateKey* GNUNET_CRYPTO_rsa_private_key_decode	(	const void *	buf,
		size_t	buf_size
	)

Decode the private key from the data-format back to the "normal", internal format.

Parameters

buf	the buffer where the private key data is stored
buf_size	the size of the data in buf

Returns

NULL on error

Definition at line 204 of file crypto_rsa.c.

{
  struct GNUNET_CRYPTO_RsaPrivateKey *key;
 
  key = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
  if (0 !=
      gcry_sexp_new (&key->sexp,
                     buf,
                     buf_size,
                     0))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Decoded private key is not valid\n");
    GNUNET_free (key);
    return NULL;
  }
  if (0 != gcry_pk_testkey (key->sexp))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Decoded private key is not valid\n");
    GNUNET_CRYPTO_rsa_private_key_free (key);
    return NULL;
  }
  return key;
}

References buf, GNUNET_CRYPTO_rsa_private_key_free(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_new, key, and LOG.

Referenced by checkvec().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_rsa_private_key_dup()

struct GNUNET_CRYPTO_RsaPrivateKey* GNUNET_CRYPTO_rsa_private_key_dup

(

const struct GNUNET_CRYPTO_RsaPrivateKey *

key

)

Duplicate the given private key.

Parameters

key	the private key to duplicate

Returns

the duplicate key; NULL upon error

Definition at line 1221 of file crypto_rsa.c.

{
  struct GNUNET_CRYPTO_RsaPrivateKey *dup;
  gcry_sexp_t dup_sexp;
  size_t erroff;
 
  /* check if we really are exporting a private key */
  dup_sexp = gcry_sexp_find_token (key->sexp, "private-key", 0);
  GNUNET_assert (NULL != dup_sexp);
  gcry_sexp_release (dup_sexp);
  /* copy the sexp */
  GNUNET_assert (0 == gcry_sexp_build (&dup_sexp, &erroff, "%S", key->sexp));
  dup = GNUNET_new (struct GNUNET_CRYPTO_RsaPrivateKey);
  dup->sexp = dup_sexp;
  return dup;
}

References GNUNET_assert, GNUNET_new, key, and GNUNET_CRYPTO_RsaPrivateKey::sexp.

GNUNET_CRYPTO_rsa_private_key_get_public()

struct GNUNET_CRYPTO_RsaPublicKey* GNUNET_CRYPTO_rsa_private_key_get_public

(

const struct GNUNET_CRYPTO_RsaPrivateKey *

priv

)

Extract the public key of the given private key.

Parameters

priv	the private key

Returns

NULL on error, otherwise the public key

Definition at line 233 of file crypto_rsa.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey *pub;
  gcry_mpi_t ne[2];
  int rc;
  gcry_sexp_t result;
 
  BENCHMARK_START (rsa_private_key_get_public);
 
  rc = key_from_sexp (ne, priv->sexp, "public-key", "ne");
  if (0 != rc)
    rc = key_from_sexp (ne, priv->sexp, "private-key", "ne");
  if (0 != rc)
    rc = key_from_sexp (ne, priv->sexp, "rsa", "ne");
  if (0 != rc)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  rc = gcry_sexp_build (&result,
                        NULL,
                        "(public-key(rsa(n %m)(e %m)))",
                        ne[0],
                        ne[1]);
  gcry_mpi_release (ne[0]);
  gcry_mpi_release (ne[1]);
  pub = GNUNET_new (struct GNUNET_CRYPTO_RsaPublicKey);
  pub->sexp = result;
  BENCHMARK_END (rsa_private_key_get_public);
  return pub;
}

References BENCHMARK_END, BENCHMARK_START, GNUNET_break_op, GNUNET_new, key_from_sexp(), pub, result, and GNUNET_CRYPTO_RsaPrivateKey::sexp.

Referenced by GNUNET_CRYPTO_rsa_sign_fdh(), output_vectors(), and rsa_sign_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CRYPTO_rsa_public_key_hash()

void GNUNET_CRYPTO_rsa_public_key_hash	(	const struct GNUNET_CRYPTO_RsaPublicKey *	key,
		struct GNUNET_HashCode *	hc
	)

Compute hash over the public key.

Parameters

key	public key to hash
hc	where to store the hash code

Definition at line 407 of file crypto_rsa.c.

{
  void *buf;
  size_t buf_size;
 
  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (key,
                                                  &buf);
  GNUNET_CRYPTO_hash (buf,
                      buf_size,
                      hc);
  GNUNET_free (buf);
}

References buf, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_rsa_public_key_encode(), GNUNET_free, and key.

Here is the call graph for this function:

GNUNET_CRYPTO_rsa_public_key_check()

bool GNUNET_CRYPTO_rsa_public_key_check

(

const struct GNUNET_CRYPTO_RsaPublicKey *

key

)

Check if key is well-formed.

Returns

true if key is well-formed.

Definition at line 301 of file crypto_rsa.c.

{
  gcry_mpi_t ne[2];
  int ret;
 
  ret = key_from_sexp (ne,
                       key->sexp,
                       "public-key",
                       "ne");
  if (0 != ret)
    ret = key_from_sexp (ne,
                         key->sexp,
                         "rsa",
                         "ne");
  if (0 != ret)
    return false;
  gcry_mpi_release (ne[0]);
  gcry_mpi_release (ne[1]);
  return true;
}

References key, key_from_sexp(), and ret.

Here is the call graph for this function:

GNUNET_CRYPTO_rsa_public_key_len()

unsigned int GNUNET_CRYPTO_rsa_public_key_len

(

const struct GNUNET_CRYPTO_RsaPublicKey *

key

)

Obtain the length of the RSA key in bits.

Parameters

key	the public key to introspect

Returns

length of the key in bits

Definition at line 680 of file crypto_rsa.c.

{
  gcry_mpi_t n;
  unsigned int rval;
 
  if (0 != key_from_sexp (&n, key->sexp, "rsa", "n"))
  {   /* Not an RSA public key */
    GNUNET_break (0);
    return 0;
  }
  rval = gcry_mpi_get_nbits (n);
  gcry_mpi_release (n);
  return rval;
}

References GNUNET_break, key, and