GNUnet  0.11.x
Functions
gnunet-service-core_kx.h File Reference

code for managing the key exchange (SET_KEY, PING, PONG) with other peers More...

#include "gnunet_util_lib.h"
#include "gnunet_transport_service.h"
Include dependency graph for gnunet-service-core_kx.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void GSC_KX_encrypt_and_transmit (struct GSC_KeyExchangeInfo *kx, const void *payload, size_t payload_size)
 Encrypt and transmit a message with the given payload. More...
 
int GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
 Initialize KX subsystem. More...
 
void GSC_KX_done (void)
 Shutdown KX subsystem. More...
 
int GSC_NEIGHBOURS_check_excess_bandwidth (const struct GSC_KeyExchangeInfo *target)
 Check if the given neighbour has excess bandwidth available. More...
 
unsigned int GSC_NEIGHBOURS_get_queue_length (const struct GSC_KeyExchangeInfo *target)
 Check how many messages are queued for the given neighbour. More...
 
void GSC_KX_handle_client_monitor_peers (struct GNUNET_MQ_Handle *mq)
 Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request. More...
 

Detailed Description

code for managing the key exchange (SET_KEY, PING, PONG) with other peers

Author
Christian Grothoff

Definition in file gnunet-service-core_kx.h.

Function Documentation

◆ GSC_KX_encrypt_and_transmit()

void GSC_KX_encrypt_and_transmit ( struct GSC_KeyExchangeInfo kx,
const void *  payload,
size_t  payload_size 
)

Encrypt and transmit a message with the given payload.

Parameters
kxkey exchange context
payloadpayload of the message
payload_sizenumber of bytes in 'payload'
kxkey exchange context
payloadpayload of the message
payload_sizenumber of bytes in payload

Definition at line 1515 of file gnunet-service-core_kx.c.

References calculate_seed(), derive_auth_key(), derive_iv(), do_encrypt(), GSC_KeyExchangeInfo::encrypt_key, ENCRYPTED_HEADER_SIZE, env, GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hmac(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s2(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GSC_KeyExchangeInfo::has_excess_bandwidth, EncryptedMessage::hmac, EncryptedMessage::iv_seed, GSC_KeyExchangeInfo::last_sequence_number_sent, GSC_KeyExchangeInfo::mq, GSC_KeyExchangeInfo::peer, ph, and EncryptedMessage::sequence_number.

Referenced by transmit_typemap_task(), and try_transmission().

1518 {
1519  size_t used = payload_size + sizeof(struct EncryptedMessage);
1520  char pbuf[used]; /* plaintext */
1521  struct EncryptedMessage *em; /* encrypted message */
1522  struct EncryptedMessage *ph; /* plaintext header */
1523  struct GNUNET_MQ_Envelope *env;
1525  struct GNUNET_CRYPTO_AuthKey auth_key;
1526 
1527  ph = (struct EncryptedMessage *) pbuf;
1528  ph->sequence_number = htonl (++kx->last_sequence_number_sent);
1529  ph->iv_seed = calculate_seed (kx);
1530  ph->reserved = 0;
1532  GNUNET_memcpy (&ph[1], payload, payload_size);
1533  env = GNUNET_MQ_msg_extra (em,
1534  payload_size,
1536  em->iv_seed = ph->iv_seed;
1537  derive_iv (&iv, &kx->encrypt_key, ph->iv_seed, kx->peer);
1539  &iv,
1540  &ph->sequence_number,
1541  &em->sequence_number,
1542  used - ENCRYPTED_HEADER_SIZE));
1543 #if DEBUG_KX
1544  {
1545  struct GNUNET_HashCode hc;
1546 
1547  GNUNET_CRYPTO_hash (&ph->sequence_number,
1548  used - ENCRYPTED_HEADER_SIZE,
1549  &hc);
1551  "Encrypted payload `%s' of %u bytes for %s\n",
1552  GNUNET_h2s (&hc),
1553  (unsigned int) (used - ENCRYPTED_HEADER_SIZE),
1554  GNUNET_i2s (kx->peer));
1555  }
1556 #endif
1557  derive_auth_key (&auth_key, &kx->encrypt_key, ph->iv_seed);
1558  GNUNET_CRYPTO_hmac (&auth_key,
1559  &em->sequence_number,
1560  used - ENCRYPTED_HEADER_SIZE,
1561  &em->hmac);
1562 #if DEBUG_KX
1563  {
1564  struct GNUNET_HashCode hc;
1565 
1566  GNUNET_CRYPTO_hash (&auth_key, sizeof(auth_key), &hc);
1568  "For peer %s, used AC %s to create hmac %s\n",
1569  GNUNET_i2s (kx->peer),
1570  GNUNET_h2s (&hc),
1571  GNUNET_h2s2 (&em->hmac));
1572  }
1573 #endif
1575  GNUNET_MQ_send (kx->mq, env);
1576 }
const struct GNUNET_PeerIdentity * peer
Identity of the peer.
uint32_t sequence_number
Sequence number, in network byte order.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_ATS_PerformanceHandle * ph
ATS performance handle used.
Definition: gnunet-ats.c:116
uint32_t last_sequence_number_sent
last sequence number transmitted
static int do_encrypt(struct GSC_KeyExchangeInfo *kx, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const void *in, void *out, size_t size)
Encrypt size bytes from in and write the result to out.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HashCode hmac
MAC of the encrypted message (starting at sequence_number), used to verify message integrity...
static void derive_auth_key(struct GNUNET_CRYPTO_AuthKey *akey, const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, uint32_t seed)
Derive an authentication key from "set key" information.
void GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104)
Definition: crypto_hash.c:438
struct GNUNET_MQ_Handle * mq
Message queue for sending messages to peer.
const char * GNUNET_h2s2(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
Encapsulation for encrypted messages exchanged between peers.
A 512-bit hashcode.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
uint32_t iv_seed
Random value used for IV generation.
static uint32_t calculate_seed(struct GSC_KeyExchangeInfo *kx)
Calculate seed value we should use for a message.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static unsigned long long payload
How much data are we currently storing in the database?
#define ENCRYPTED_HEADER_SIZE
Number of bytes (at the beginning) of struct EncryptedMessage that are NOT encrypted.
#define GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE
Encapsulation for an encrypted message between peers.
static void derive_iv(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, uint32_t seed, const struct GNUNET_PeerIdentity *identity)
Derive an IV from packet information.
int has_excess_bandwidth
GNUNET_YES if this peer currently has excess bandwidth.
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_SymmetricSessionKey encrypt_key
Key we use to encrypt our messages for the other peer (initialized by us when we do the handshake)...
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
type for (message) authentication keys
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_init()

int GSC_KX_init ( struct GNUNET_CRYPTO_EddsaPrivateKey pk)

Initialize KX subsystem.

Parameters
pkprivate key to use for the peer
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1913 of file gnunet-service-core_kx.c.

References current_ekm, do_rekey(), EphemeralKeyMessage::ephemeral_key, GNUNET_break, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY, GNUNET_MESSAGE_TYPE_CORE_PING, GNUNET_MESSAGE_TYPE_CORE_PONG, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_notification_context_create(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TRANSPORT_core_connect(), GSC_cfg, GSC_KX_done(), GSC_my_identity, handle_transport_notify_connect(), handle_transport_notify_disconnect(), handle_transport_notify_excess_bw(), ping(), pk, pong(), GNUNET_PeerIdentity::public_key, REKEY_FREQUENCY, and sign_ephemeral_key().

Referenced by run().

1914 {
1916  { GNUNET_MQ_hd_fixed_size (ephemeral_key,
1918  struct EphemeralKeyMessage,
1919  NULL),
1922  struct PingMessage,
1923  NULL),
1926  struct PongMessage,
1927  NULL),
1928  GNUNET_MQ_hd_var_size (encrypted,
1930  struct EncryptedMessage,
1931  NULL),
1932  GNUNET_MQ_handler_end () };
1933 
1934  my_private_key = pk;
1938  if (NULL == my_ephemeral_key)
1939  {
1940  GNUNET_break (0);
1942  my_private_key = NULL;
1943  return GNUNET_SYSERR;
1944  }
1945  sign_ephemeral_key ();
1946  {
1947  struct GNUNET_HashCode eh;
1948 
1950  sizeof(current_ekm.ephemeral_key),
1951  &eh);
1953  "Starting with ephemeral key %s\n",
1954  GNUNET_h2s (&eh));
1955  }
1956 
1959  transport =
1961  &GSC_my_identity,
1962  handlers,
1963  NULL,
1967  if (NULL == transport)
1968  {
1969  GSC_KX_done ();
1970  return GNUNET_SYSERR;
1971  }
1972  return GNUNET_OK;
1973 }
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
static void ping(void *cls)
Send a ping to destination.
static struct GNUNET_CRYPTO_EcdhePrivateKey * my_ephemeral_key
Our ephemeral private key.
static void do_rekey(void *cls)
Task run to trigger rekeying.
Response to a PING.
static struct GNUNET_TRANSPORT_CoreHandle * transport
Transport service.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
static void handle_transport_notify_excess_bw(void *cls, const struct GNUNET_PeerIdentity *pid, void *connect_cls)
One of our neighbours has excess bandwidth, remember this.
struct GNUNET_CRYPTO_EcdhePrivateKey * GNUNET_CRYPTO_ecdhe_key_create(void)
Create a new private key.
Definition: crypto_ecc.c:608
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static void sign_ephemeral_key()
Setup the message that links the ephemeral key to our persistent public key and generate the appropri...
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MESSAGE_TYPE_CORE_PONG
Confirmation that other peer is alive.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
We're sending an (encrypted) PING to the other peer to check if it can decrypt.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
Encapsulation for encrypted messages exchanged between peers.
A 512-bit hashcode.
Message handler for a specific message type.
#define GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY
Session key exchange between peers.
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
static void pong(struct GNUNET_CADET_Channel *channel, const struct CadetPingMessage *ping)
Reply with a pong to origin.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key
Ephemeral public ECC key.
static void * handle_transport_notify_connect(void *cls, const struct GNUNET_PeerIdentity *pid, struct GNUNET_MQ_Handle *mq)
Function called by transport to notify us that a peer connected to us (on the network level)...
#define GNUNET_MESSAGE_TYPE_CORE_PING
Check that other peer is alive (challenge).
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:270
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:121
#define GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE
Encapsulation for an encrypted message between peers.
static struct GNUNET_SCHEDULER_Task * rekey_task
Task scheduled for periodic re-generation (and thus rekeying) of our ephemeral key.
#define REKEY_FREQUENCY
How often do we rekey?
#define GNUNET_log(kind,...)
static struct EphemeralKeyMessage current_ekm
Current message we send for a key exchange.
static void handle_transport_notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called by transport telling us that a peer disconnected.
Message transmitted with the signed ephemeral key of a peer.
void GSC_KX_done()
Shutdown KX subsystem.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
const struct GNUNET_CONFIGURATION_Handle * GSC_cfg
Our configuration.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_done()

void GSC_KX_done ( void  )

Shutdown KX subsystem.

Definition at line 1980 of file gnunet-service-core_kx.c.

References GNUNET_free, GNUNET_notification_context_destroy(), GNUNET_SCHEDULER_cancel(), and GNUNET_TRANSPORT_core_disconnect().

Referenced by GSC_KX_init(), and shutdown_task().

1981 {
1982  if (NULL != transport)
1983  {
1985  transport = NULL;
1986  }
1987  if (NULL != rekey_task)
1988  {
1990  rekey_task = NULL;
1991  }
1992  if (NULL != my_ephemeral_key)
1993  {
1995  my_ephemeral_key = NULL;
1996  }
1997  if (NULL != my_private_key)
1998  {
2000  my_private_key = NULL;
2001  }
2002  if (NULL != nc)
2003  {
2005  nc = NULL;
2006  }
2007 }
static struct GNUNET_CRYPTO_EcdhePrivateKey * my_ephemeral_key
Our ephemeral private key.
static struct GNUNET_TRANSPORT_CoreHandle * transport
Transport service.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
static struct GNUNET_SCHEDULER_Task * rekey_task
Task scheduled for periodic re-generation (and thus rekeying) of our ephemeral key.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:137
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_NEIGHBOURS_check_excess_bandwidth()

int GSC_NEIGHBOURS_check_excess_bandwidth ( const struct GSC_KeyExchangeInfo kxinfo)

Check if the given neighbour has excess bandwidth available.

Parameters
targetneighbour to check
Returns
GNUNET_YES if excess bandwidth is available, GNUNET_NO if not

Definition at line 2030 of file gnunet-service-core_kx.c.

References GSC_KeyExchangeInfo::has_excess_bandwidth.

Referenced by try_transmission().

2031 {
2032  return kxinfo->has_excess_bandwidth;
2033 }
int has_excess_bandwidth
GNUNET_YES if this peer currently has excess bandwidth.
Here is the caller graph for this function:

◆ GSC_NEIGHBOURS_get_queue_length()

unsigned int GSC_NEIGHBOURS_get_queue_length ( const struct GSC_KeyExchangeInfo kxinfo)

Check how many messages are queued for the given neighbour.

Parameters
targetneighbour to check
Returns
number of items in the message queue
Parameters
kxinfodata about neighbour to check
Returns
number of items in the message queue

Definition at line 2017 of file gnunet-service-core_kx.c.

References GNUNET_MQ_get_length(), and GSC_KeyExchangeInfo::mq.

Referenced by try_transmission().

2018 {
2019  return GNUNET_MQ_get_length (kxinfo->mq);
2020 }
struct GNUNET_MQ_Handle * mq
Message queue for sending messages to peer.
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:335
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_handle_client_monitor_peers()

void GSC_KX_handle_client_monitor_peers ( struct GNUNET_MQ_Handle mq)

Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.

For this request type, the client does not have to have transmitted an INIT request. All current peers are returned, regardless of which message types they accept.

Parameters
mqmessage queue to add for monitoring

Definition at line 2045 of file gnunet-service-core_kx.c.

References env, GNUNET_CORE_KX_ITERATION_FINISHED, GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_FOREVER_ABS, msg, GSC_KeyExchangeInfo::next, GSC_KeyExchangeInfo::peer, MonitorNotifyMessage::peer, MonitorNotifyMessage::state, GSC_KeyExchangeInfo::status, GSC_KeyExchangeInfo::timeout, and MonitorNotifyMessage::timeout.

Referenced by handle_client_monitor_peers().

2046 {
2047  struct GNUNET_MQ_Envelope *env;
2048  struct MonitorNotifyMessage *done_msg;
2049  struct GSC_KeyExchangeInfo *kx;
2050 
2052  for (kx = kx_head; NULL != kx; kx = kx->next)
2053  {
2054  struct GNUNET_MQ_Envelope *env;
2055  struct MonitorNotifyMessage *msg;
2056 
2058  msg->state = htonl ((uint32_t) kx->status);
2059  msg->peer = *kx->peer;
2061  GNUNET_MQ_send (mq, env);
2062  }
2064  done_msg->state = htonl ((uint32_t) GNUNET_CORE_KX_ITERATION_FINISHED);
2066  GNUNET_MQ_send (mq, env);
2067 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
const struct GNUNET_PeerIdentity * peer
Identity of the peer.
enum GNUNET_CORE_KxState status
What is our connection status?
struct GNUNET_TIME_AbsoluteNBO timeout
How long will we stay in this state (if nothing else happens)?
Definition: core.h:322
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct GSC_KeyExchangeInfo * kx_head
DLL head.
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:160
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct GSC_KeyExchangeInfo * next
DLL.
Information about the status of a key exchange with another peer.
This is not a state in a peer's state machine, but a special value used with the GNUNET_CORE_MonitorC...
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
uint32_t state
New peer state, an enum GNUNET_CORE_KxState in NBO.
Definition: core.h:312
struct GNUNET_TIME_Absolute timeout
When should the session time out (if there are no PONGs)?
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
Message sent by the service to monitor clients to notify them about a peer changing status...
Definition: core.h:302
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
#define GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY
Reply for monitor by CORE service.
struct GNUNET_PeerIdentity peer
Identity of the peer.
Definition: core.h:317
Here is the call graph for this function:
Here is the caller graph for this function: