GNUnet  0.19.2
core_api.c File Reference

core service; this is the main API for encrypted P2P communications More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_core_service.h"
#include "core.h"
Include dependency graph for core_api.c:

Go to the source code of this file.

Data Structures

struct  PeerRecord
 Information we track for each peer. More...
 
struct  GNUNET_CORE_Handle
 Context for the core service connection. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "core-api", __VA_ARGS__)
 

Functions

static void reconnect (struct GNUNET_CORE_Handle *h)
 Our current client connection went down. More...
 
static void reconnect_task (void *cls)
 Task schedule to try to re-connect to core. More...
 
static int disconnect_and_free_peer_entry (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Notify clients about disconnect and free the entry for connected peer. More...
 
static void reconnect_later (struct GNUNET_CORE_Handle *h)
 Close down any existing connection to the CORE service and try re-establishing it later. More...
 
static void handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
 Error handler for the message queue to the CORE service. More...
 
static void core_mq_send_impl (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
 Implement sending functionality of a message queue for us sending messages to a peer. More...
 
static void core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Handle destruction of a message queue. More...
 
static void core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implementation function that cancels the currently sent message. More...
 
static void core_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 We had an error processing a message we forwarded from a peer to the CORE service. More...
 
static void connect_peer (struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *peer)
 Add the given peer to the list of our connected peers and create the respective data structures and notify the application. More...
 
static void handle_init_reply (void *cls, const struct InitReplyMessage *m)
 Handle init reply message received from CORE service. More...
 
static void handle_connect_notify (void *cls, const struct ConnectNotifyMessage *cnm)
 Handle connect message received from CORE service. More...
 
static void handle_disconnect_notify (void *cls, const struct DisconnectNotifyMessage *dnm)
 Handle disconnect message received from CORE service. More...
 
static int check_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
 Check that message received from CORE service is well-formed. More...
 
static void handle_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
 Handle inbound message received from CORE service. More...
 
static void handle_send_ready (void *cls, const struct SendMessageReady *smr)
 Handle message received from CORE service notifying us that we are now allowed to send a message to a peer. More...
 
struct GNUNET_CORE_HandleGNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
 Connect to the core service. More...
 
void GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
 Disconnect from the core service. More...
 
struct GNUNET_MQ_HandleGNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *pid)
 Obtain the message queue for a connected peer. More...
 

Detailed Description

core service; this is the main API for encrypted P2P communications

Author
Christian Grothoff

Definition in file core_api.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "core-api", __VA_ARGS__)

Definition at line 32 of file core_api.c.

Function Documentation

◆ reconnect()

static void reconnect ( struct GNUNET_CORE_Handle h)
static

Our current client connection went down.

Clean it up and try to reconnect!

Parameters
hour handle to the core service

Definition at line 629 of file core_api.c.

630 {
632  { GNUNET_MQ_hd_fixed_size (init_reply,
634  struct InitReplyMessage,
635  h),
638  struct ConnectNotifyMessage,
639  h),
643  h),
644  GNUNET_MQ_hd_var_size (notify_inbound,
646  struct NotifyTrafficMessage,
647  h),
648  GNUNET_MQ_hd_fixed_size (send_ready,
650  struct SendMessageReady,
651  h),
653  struct InitMessage *init;
654  struct GNUNET_MQ_Envelope *env;
655  uint16_t *ts;
656 
657  GNUNET_assert (NULL == h->mq);
659  if (NULL == h->mq)
660  {
661  reconnect_later (h);
662  return;
663  }
665  sizeof(uint16_t) * h->hcnt,
667  LOG (GNUNET_ERROR_TYPE_INFO, "(Re)connecting to CORE service\n");
668  init->options = htonl (0);
669  ts = (uint16_t *) &init[1];
670  for (unsigned int hpos = 0; hpos < h->hcnt; hpos++)
671  ts[hpos] = htons (h->handlers[hpos].type);
672  GNUNET_MQ_send (h->mq, env);
673 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void reconnect_later(struct GNUNET_CORE_Handle *h)
Close down any existing connection to the CORE service and try re-establishing it later.
Definition: core_api.c:214
#define LOG(kind,...)
Definition: core_api.c:32
static void handle_mq_error(void *cls, enum GNUNET_MQ_Error error)
Error handler for the message queue to the CORE service.
Definition: core_api.c:240
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static void disconnect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a peer disconnects.
static void * connect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a peer connects.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1057
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_INFO
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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:62
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
Notify clients about new peer-to-peer connections (triggered after key exchange).
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT
Notify clients about peer disconnecting.
#define GNUNET_MESSAGE_TYPE_CORE_INIT
Initial setup message from core client to core.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
Notify clients about incoming P2P messages.
#define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
Response from core to core client to INIT message.
#define GNUNET_MESSAGE_TYPE_CORE_SEND_READY
Confirmation from core that message can now be sent.
Message sent by the service to clients to notify them about a peer connecting.
Definition: core.h:124
Message sent by the service to clients to notify them about a peer disconnecting.
Definition: core.h:147
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
Message handler for a specific message type.
Message transmitted core clients to gnunet-service-core to start the interaction.
Definition: core.h:83
Message transmitted by the gnunet-service-core process to its clients in response to an INIT message.
Definition: core.h:101
Message sent by the service to clients to notify them about messages being received or transmitted.
Definition: core.h:175
Core notifying client that it is allowed to now transmit a message to the given target (response to G...
Definition: core.h:241

References GNUNET_ARM_Handle::cfg, connect_notify(), disconnect_notify(), env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_INFO, GNUNET_MESSAGE_TYPE_CORE_INIT, GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, GNUNET_MESSAGE_TYPE_CORE_SEND_READY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), h, handle_mq_error(), handlers, init, LOG, GNUNET_ARM_Handle::mq, and reconnect_later().

Referenced by GNUNET_CORE_connect(), and reconnect_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reconnect_task()

static void reconnect_task ( void *  cls)
static

Task schedule to try to re-connect to core.

Parameters
clsthe struct GNUNET_CORE_Handle

Definition at line 163 of file core_api.c.

164 {
165  struct GNUNET_CORE_Handle *h = cls;
166 
167  h->reconnect_task = NULL;
168  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service after delay\n");
169  reconnect (h);
170 }
static void reconnect(struct GNUNET_CORE_Handle *h)
Our current client connection went down.
Definition: core_api.c:629
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
Context for the core service connection.
Definition: core_api.c:78
void * cls
Closure for the various callbacks.
Definition: core_api.c:87

References GNUNET_CORE_Handle::cls, GNUNET_ERROR_TYPE_DEBUG, h, LOG, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by reconnect_later().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ disconnect_and_free_peer_entry()

static int disconnect_and_free_peer_entry ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Notify clients about disconnect and free the entry for connected peer.

Parameters
clsthe struct GNUNET_CORE_Handle *
keythe peer identity (not used)
valuethe struct PeerRecord to free.
Returns
GNUNET_YES (continue)

Definition at line 183 of file core_api.c.

186 {
187  struct GNUNET_CORE_Handle *h = cls;
188  struct PeerRecord *pr = value;
189 
190  GNUNET_assert (pr->h == h);
191  if (NULL != h->disconnects)
192  h->disconnects (h->cls, &pr->peer, pr->client_cls);
195  GNUNET_MQ_destroy (pr->mq);
196  GNUNET_assert (NULL == pr->mq);
197  if (NULL != pr->env)
198  {
199  GNUNET_MQ_discard (pr->env);
200  pr->env = NULL;
201  }
202  GNUNET_free (pr);
203  return GNUNET_YES;
204 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_YES
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:285
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
Information we track for each peer.
Definition: core_api.c:39
struct GNUNET_CORE_Handle * h
Corresponding CORE handle.
Definition: core_api.c:43
void * client_cls
Value the client returned when we connected, used as the closure in various places.
Definition: core_api.c:60
struct GNUNET_PeerIdentity peer
Peer the record is about.
Definition: core_api.c:65
struct GNUNET_MQ_Handle * mq
Message queue for the peer.
Definition: core_api.c:48
struct GNUNET_MQ_Envelope * env
Message we are currently trying to pass to the CORE service for this peer (from mq).
Definition: core_api.c:54

References PeerRecord::client_cls, GNUNET_CORE_Handle::cls, PeerRecord::env, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_MQ_discard(), GNUNET_YES, h, PeerRecord::h, key, PeerRecord::mq, PeerRecord::peer, and value.

Referenced by GNUNET_CORE_disconnect(), handle_disconnect_notify(), and reconnect_later().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reconnect_later()

static void reconnect_later ( struct GNUNET_CORE_Handle h)
static

Close down any existing connection to the CORE service and try re-establishing it later.

Parameters
hour handle

Definition at line 214 of file core_api.c.

215 {
216  GNUNET_assert (NULL == h->reconnect_task);
217  if (NULL != h->mq)
218  {
220  h->mq = NULL;
221  }
222  GNUNET_assert (NULL == h->reconnect_task);
223  h->reconnect_task =
227  h);
229 }
static int disconnect_and_free_peer_entry(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Notify clients about disconnect and free the entry for connected peer.
Definition: core_api.c:183
static void reconnect_task(void *cls)
Task schedule to try to re-connect to core.
Definition: core_api.c:163
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
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:1241
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: arm_api.c:152

References disconnect_and_free_peer_entry(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, GNUNET_ARM_Handle::mq, GNUNET_ARM_Handle::reconnect_task, reconnect_task(), and GNUNET_ARM_Handle::retry_backoff.

Referenced by handle_connect_notify(), handle_disconnect_notify(), handle_mq_error(), handle_notify_inbound(), handle_send_ready(), and reconnect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_mq_error()

static void handle_mq_error ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Error handler for the message queue to the CORE service.

On errors, we reconnect.

Parameters
clsclosure, a struct GNUNET_CORE_Handle *
errorerror code

Definition at line 240 of file core_api.c.

241 {
242  struct GNUNET_CORE_Handle *h = cls;
243 
244  LOG (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %d\n", error);
245  reconnect_later (h);
246 }

References GNUNET_CORE_Handle::cls, GNUNET_ERROR_TYPE_DEBUG, h, LOG, and reconnect_later().

Referenced by reconnect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_mq_send_impl()

static void core_mq_send_impl ( struct GNUNET_MQ_Handle mq,
const struct GNUNET_MessageHeader msg,
void *  impl_state 
)
static

Implement sending functionality of a message queue for us sending messages to a peer.

Parameters
mqthe message queue
msgthe message to send
impl_statestate of the implementation

Definition at line 258 of file core_api.c.

261 {
262  struct PeerRecord *pr = impl_state;
263  struct GNUNET_CORE_Handle *h = pr->h;
264  struct SendMessageRequest *smr;
265  struct SendMessage *sm;
266  struct GNUNET_MQ_Envelope *env;
267  uint16_t msize;
269 
270  if (NULL == h->mq)
271  {
272  /* We're currently reconnecting, pretend this worked */
274  return;
275  }
276  GNUNET_assert (NULL == pr->env);
277  /* extract options from envelope */
279  flags = GNUNET_MQ_env_get_options (env);
280 
281  /* check message size for sanity */
282  msize = ntohs (msg->size);
283  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(struct SendMessage))
284  {
285  GNUNET_break (0);
287  return;
288  }
289 
290  /* ask core for transmission */
292  "Asking core for transmission of %u bytes to `%s'\n",
293  (unsigned int) msize,
294  GNUNET_i2s (&pr->peer));
296  smr->priority = htonl ((uint32_t) flags);
297  smr->peer = pr->peer;
298  smr->size = htons (msize);
299  smr->smr_id = htons (++pr->smr_id_gen);
300  GNUNET_MQ_send (h->mq, env);
301 
302  /* prepare message with actual transmission data */
304  sm->priority = htonl ((uint32_t) flags);
305  sm->peer = pr->peer;
307  "Calling get_message with buffer of %u bytes\n",
308  (unsigned int) msize);
309 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct.
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:421
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:839
struct GNUNET_MQ_Envelope * GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations.
Definition: mq.c:813
#define GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
Request from client to transmit message.
#define GNUNET_MESSAGE_TYPE_CORE_SEND
Client with message to transmit (after SEND_READY confirmation was received).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
uint16_t smr_id_gen
SendMessageRequest ID generator for this peer.
Definition: core_api.c:70
Client notifying core about the maximum-priority message it has in the queue for a particular target.
Definition: core.h:196
uint32_t priority
How important is this message?
Definition: core.h:205
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:216
uint16_t size
How large is the message?
Definition: core.h:226
uint16_t smr_id
Counter for this peer to match SMRs to replies.
Definition: core.h:231
Client asking core to transmit a particular message to a particular target (response to GNUNET_MESSAG...
Definition: core.h:272
uint32_t priority
How important is this message? Contains a enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: core.h:282
struct GNUNET_PeerIdentity peer
Identity of the intended receiver.
Definition: core.h:293

References env, PeerRecord::env, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_CORE_SEND, GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST, GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_msg, GNUNET_MQ_msg_nested_mh, GNUNET_MQ_send(), h, PeerRecord::h, LOG, mq, GNUNET_ARM_Handle::mq, msg, SendMessageRequest::peer, SendMessage::peer, PeerRecord::peer, SendMessageRequest::priority, SendMessage::priority, SendMessageRequest::size, GNUNET_MessageHeader::size, SendMessageRequest::smr_id, and PeerRecord::smr_id_gen.

Referenced by connect_peer().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_mq_destroy_impl()

static void core_mq_destroy_impl ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Handle destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters
mqthe message queue to destroy
impl_statestate of the implementation

Definition at line 320 of file core_api.c.

321 {
322  struct PeerRecord *pr = impl_state;
323 
324  GNUNET_assert (mq == pr->mq);
325  pr->mq = NULL;
326 }

References GNUNET_assert, mq, and PeerRecord::mq.

Referenced by connect_peer().

Here is the caller graph for this function:

◆ core_mq_cancel_impl()

static void core_mq_cancel_impl ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Implementation function that cancels the currently sent message.

Should basically undo whatever mq_send_impl() did.

Parameters
mqmessage queue
impl_statestate specific to the implementation

Definition at line 337 of file core_api.c.

338 {
339  struct PeerRecord *pr = impl_state;
340 
341  (void) mq;
342  GNUNET_assert (NULL != pr->env);
343  GNUNET_MQ_discard (pr->env);
344  pr->env = NULL;
345 }

References PeerRecord::env, GNUNET_assert, GNUNET_MQ_discard(), and mq.

Referenced by connect_peer().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_mq_error_handler()

static void core_mq_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

We had an error processing a message we forwarded from a peer to the CORE service.

We should just complain about it but otherwise continue processing.

Parameters
clsclosure
errorerror code

Definition at line 357 of file core_api.c.

358 {
359  /* struct PeerRecord *pr = cls; */
360  (void) cls;
361  (void) error;
362  GNUNET_break_op (0);
363 }
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.

References GNUNET_break_op.

Referenced by connect_peer().

Here is the caller graph for this function:

◆ connect_peer()

static void connect_peer ( struct GNUNET_CORE_Handle h,
const struct GNUNET_PeerIdentity peer 
)
static

Add the given peer to the list of our connected peers and create the respective data structures and notify the application.

Parameters
hthe core handle
peerthe peer that is connecting to us

Definition at line 375 of file core_api.c.

377 {
378  struct PeerRecord *pr;
379 
380  pr = GNUNET_new (struct PeerRecord);
381  pr->peer = *peer;
382  pr->h = h;
385  h->peers,
386  &pr->peer,
387  pr,
392  pr,
393  h->handlers,
395  pr);
396  if (NULL != h->connects)
397  {
398  pr->client_cls = h->connects (h->cls, &pr->peer, pr->mq);
400  }
401 }
static void core_mq_send_impl(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Implement sending functionality of a message queue for us sending messages to a peer.
Definition: core_api.c:258
static void core_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
Definition: core_api.c:337
static void core_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
Definition: core_api.c:320
static void core_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
We had an error processing a message we forwarded from a peer to the CORE service.
Definition: core_api.c:357
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:465
void GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
Change the closure argument in all of the handlers of the mq.
Definition: mq.c:489
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References PeerRecord::client_cls, core_mq_cancel_impl(), core_mq_destroy_impl(), core_mq_error_handler(), core_mq_send_impl(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_set_handlers_closure(), GNUNET_new, GNUNET_YES, h, PeerRecord::h, PeerRecord::mq, PeerRecord::peer, and peer.

Referenced by handle_connect_notify(), and handle_init_reply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_init_reply()

static void handle_init_reply ( void *  cls,
const struct InitReplyMessage m 
)
static

Handle init reply message received from CORE service.

Notify application that we are now connected to the CORE. Also fake loopback connection.

Parameters
clsthe struct GNUNET_CORE_Handle
mthe init reply

Definition at line 413 of file core_api.c.

414 {
415  struct GNUNET_CORE_Handle *h = cls;
417 
418  GNUNET_break (0 == ntohl (m->reserved));
420  if (NULL != (init = h->init))
421  {
422  /* mark so we don't call init on reconnect */
423  h->init = NULL;
424  h->me = m->my_identity;
426  "Connected to core service of peer `%s'.\n",
427  GNUNET_i2s (&h->me));
428  h->have_init = GNUNET_YES;
429  init (h->cls, &h->me);
430  }
431  else
432  {
434  "Successfully reconnected to core service.\n");
435  if (GNUNET_NO == h->have_init)
436  {
437  h->me = m->my_identity;
438  h->have_init = GNUNET_YES;
439  }
440  else
441  {
442  GNUNET_break (0 == memcmp (&h->me,
443  &m->my_identity,
444  sizeof(struct GNUNET_PeerIdentity)));
445  }
446  }
447  /* fake 'connect to self' */
448  connect_peer (h, &h->me);
449 }
static void connect_peer(struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *peer)
Add the given peer to the list of our connected peers and create the respective data structures and n...
Definition: core_api.c:375
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
void(* GNUNET_CORE_StartupCallback)(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
@ GNUNET_NO
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
The identity of the host (wraps the signing key of the peer).

References GNUNET_CORE_Handle::cls, connect_peer(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_NO, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, h, init, LOG, m, and GNUNET_ARM_Handle::retry_backoff.

Here is the call graph for this function:

◆ handle_connect_notify()

static void handle_connect_notify ( void *  cls,
const struct ConnectNotifyMessage cnm 
)
static

Handle connect message received from CORE service.

Notify the application about the new connection.

Parameters
clsthe struct GNUNET_CORE_Handle
cnmthe connect message

Definition at line 460 of file core_api.c.

461 {
462  struct GNUNET_CORE_Handle *h = cls;
463  struct PeerRecord *pr;
464 
466  "Received notification about connection from `%s'.\n",
467  GNUNET_i2s (&cnm->peer));
468  if (0 == memcmp (&h->me, &cnm->peer, sizeof(struct GNUNET_PeerIdentity)))
469  {
470  /* connect to self!? */
471  GNUNET_break (0);
472  return;
473  }
474  pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &cnm->peer);
475  if (NULL != pr)
476  {
477  GNUNET_break (0);
478  reconnect_later (h);
479  return;
480  }
481  connect_peer (h, &cnm->peer);
482 }
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:138

References GNUNET_CORE_Handle::cls, connect_peer(), GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), h, LOG, ConnectNotifyMessage::peer, and reconnect_later().

Here is the call graph for this function:

◆ handle_disconnect_notify()

static void handle_disconnect_notify ( void *  cls,
const struct DisconnectNotifyMessage dnm 
)
static

Handle disconnect message received from CORE service.

Notify the application about the lost connection.

Parameters
clsthe struct GNUNET_CORE_Handle
dnmmessage about the disconnect event

Definition at line 493 of file core_api.c.

494 {
495  struct GNUNET_CORE_Handle *h = cls;
496  struct PeerRecord *pr;
497 
498  if (0 == memcmp (&h->me, &dnm->peer, sizeof(struct GNUNET_PeerIdentity)))
499  {
500  /* disconnect from self!? */
501  GNUNET_break (0);
502  return;
503  }
504  GNUNET_break (0 == ntohl (dnm->reserved));
506  "Received notification about disconnect from `%s'.\n",
507  GNUNET_i2s (&dnm->peer));
508  pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &dnm->peer);
509  if (NULL == pr)
510  {
511  GNUNET_break (0);
512  reconnect_later (h);
513  return;
514  }
516 }
uint32_t reserved
Always zero.
Definition: core.h:156
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:161

References GNUNET_CORE_Handle::cls, disconnect_and_free_peer_entry(), GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), h, LOG, DisconnectNotifyMessage::peer, PeerRecord::peer, reconnect_later(), and DisconnectNotifyMessage::reserved.

Here is the call graph for this function:

◆ check_notify_inbound()

static int check_notify_inbound ( void *  cls,
const struct NotifyTrafficMessage ntm 
)
static

Check that message received from CORE service is well-formed.

Parameters
clsthe struct GNUNET_CORE_Handle
ntmthe message we got
Returns
GNUNET_OK if the message is well-formed

Definition at line 527 of file core_api.c.

528 {
529  uint16_t msize;
530  const struct GNUNET_MessageHeader *em;
531 
532  (void) cls;
533  msize = ntohs (ntm->header.size) - sizeof(struct NotifyTrafficMessage);
534  if (msize < sizeof(struct GNUNET_MessageHeader))
535  {
536  GNUNET_break (0);
537  return GNUNET_SYSERR;
538  }
539  em = (const struct GNUNET_MessageHeader *) &ntm[1];
540  if (msize != ntohs (em->size))
541  {
542  GNUNET_break (0);
543  return GNUNET_SYSERR;
544  }
545  return GNUNET_OK;
546 }
@ GNUNET_OK
@ GNUNET_SYSERR
Header for all communications.
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND.
Definition: core.h:180

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, NotifyTrafficMessage::header, and GNUNET_MessageHeader::size.

◆ handle_notify_inbound()

static void handle_notify_inbound ( void *  cls,
const struct NotifyTrafficMessage ntm 
)
static

Handle inbound message received from CORE service.

If applicable, notify the application.

Parameters
clsthe struct GNUNET_CORE_Handle
ntmthe message we got from CORE.

Definition at line 557 of file core_api.c.

558 {
559  struct GNUNET_CORE_Handle *h = cls;
560  const struct GNUNET_MessageHeader *em;
561  struct PeerRecord *pr;
562 
564  "Received inbound message from `%s'.\n",
565  GNUNET_i2s (&ntm->peer));
566  em = (const struct GNUNET_MessageHeader *) &ntm[1];
567  pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &ntm->peer);
568  if (NULL == pr)
569  {
570  GNUNET_break (0);
571  reconnect_later (h);
572  return;
573  }
574  GNUNET_MQ_inject_message (pr->mq, em);
575 }
void GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given m...
Definition: mq.c:187
struct GNUNET_PeerIdentity peer
Identity of the receiver or sender.
Definition: core.h:185

References GNUNET_CORE_Handle::cls, GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_inject_message(), h, LOG, PeerRecord::mq, NotifyTrafficMessage::peer, and reconnect_later().

Here is the call graph for this function:

◆ handle_send_ready()

static void handle_send_ready ( void *  cls,
const struct SendMessageReady smr 
)
static

Handle message received from CORE service notifying us that we are now allowed to send a message to a peer.

If that message is still pending, put it into the queue to be transmitted.

Parameters
clsthe struct GNUNET_CORE_Handle
smrthe message we got

Definition at line 587 of file core_api.c.

588 {
589  struct GNUNET_CORE_Handle *h = cls;
590  struct PeerRecord *pr;
591 
592  pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &smr->peer);
593  if (NULL == pr)
594  {
595  GNUNET_break (0);
596  reconnect_later (h);
597  return;
598  }
600  "Received notification about transmission readiness to `%s'.\n",
601  GNUNET_i2s (&smr->peer));
602  if (NULL == pr->env)
603  {
604  /* request must have been cancelled between the original request
605  * and the response from CORE, ignore CORE's readiness */
606  return;
607  }
608  if (ntohs (smr->smr_id) != pr->smr_id_gen)
609  {
610  /* READY message is for expired or cancelled message,
611  * ignore! (we should have already sent another request) */
612  return;
613  }
614 
615  /* ok, all good, send message out! */
616  GNUNET_MQ_send (h->mq, pr->env);
617  pr->env = NULL;
619 }
uint16_t smr_id
smr_id from the request.
Definition: core.h:258
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:263

References GNUNET_CORE_Handle::cls, PeerRecord::env, GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_send(), h, LOG, GNUNET_ARM_Handle::mq, PeerRecord::mq, SendMessageReady::peer, reconnect_later(), SendMessageReady::smr_id, and PeerRecord::smr_id_gen.

Here is the call graph for this function: