GNUnet 0.21.1
transport_api2_core.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_protocols.h"
#include "gnunet_transport_core_service.h"
#include "transport.h"
Include dependency graph for transport_api2_core.c:

Go to the source code of this file.

Data Structures

struct  Neighbour
 A neighbour that at least one communicator is connected to. More...
 
struct  GNUNET_TRANSPORT_CoreHandle
 Handle for the transport service (includes all of the state for the transport service). More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
 
#define STARTING_NEIGHBOURS_SIZE   16
 How large to start with for the hashmap of neighbours. More...
 
#define SEND_WINDOW_SIZE   4
 Window size. More...
 

Functions

static void disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
 Function that will schedule the job that will try to connect us again to the client. More...
 
static struct Neighbourneighbour_find (struct GNUNET_TRANSPORT_CoreHandle *h, const struct GNUNET_PeerIdentity *peer)
 Get the neighbour list entry for the given peer. More...
 
static int neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Iterator over hash map entries, for deleting state of a neighbour. More...
 
static void mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
 
static void notify_send_done (void *cls)
 A message from the handler's message queue to a neighbour was transmitted. More...
 
static void do_send (struct Neighbour *n)
 We have an envelope waiting for transmission at n, and our transmission window is positive. More...
 
static void mq_send_impl (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
 Implement sending functionality of a message queue. More...
 
static void mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Handle destruction of a message queue. More...
 
static void mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implementation function that cancels the currently sent message. More...
 
static void peer_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 handle_connect (void *cls, const struct ConnectInfoMessage *cim)
 Function we use for handling incoming connect messages. More...
 
static void handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
 Function we use for handling incoming disconnect messages. More...
 
static void handle_send_ok (void *cls, const struct SendOkMessage *okm)
 Function we use for handling incoming send-ok messages. More...
 
static int check_recv (void *cls, const struct InboundMessage *im)
 Function we use for checking incoming "inbound" messages. More...
 
static void handle_recv (void *cls, const struct InboundMessage *im)
 Function we use for handling incoming messages. More...
 
static void reconnect (void *cls)
 Try again to connect to transport service. More...
 
static void disconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
 Disconnect from the transport service. More...
 
struct GNUNET_MQ_HandleGNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle *handle, const struct GNUNET_PeerIdentity *peer)
 Checks if a given peer is connected to us and get the message queue. More...
 

Macro Definition Documentation

◆ LOG

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

Definition at line 34 of file transport_api2_core.c.

◆ STARTING_NEIGHBOURS_SIZE

#define STARTING_NEIGHBOURS_SIZE   16

How large to start with for the hashmap of neighbours.

Definition at line 39 of file transport_api2_core.c.

◆ SEND_WINDOW_SIZE

#define SEND_WINDOW_SIZE   4

Window size.

How many messages to the same target do we pass to TRANSPORT without a SEND_OK in between? Small values limit thoughput, large values will increase latency.

FIXME-OPTIMIZE: find out what good values are experimentally, maybe set adaptively (i.e. to observed available bandwidth).

Definition at line 49 of file transport_api2_core.c.

Function Documentation

◆ disconnect_and_schedule_reconnect()

static void disconnect_and_schedule_reconnect ( struct GNUNET_TRANSPORT_CoreHandle h)
static

Function that will schedule the job that will try to connect us again to the client.

Parameters
htransport service to reconnect

Definition at line 675 of file transport_api2_core.c.

676{
677 GNUNET_assert (NULL == h->reconnect_task);
678 disconnect (h);
679 {
680 /* Reduce delay based on runtime of the connection,
681 so that there is a cool-down if a connection is up
682 for a while. */
683 struct GNUNET_TIME_Relative runtime;
684 unsigned int minutes;
685
686 runtime = GNUNET_TIME_absolute_get_duration (h->restarted_at);
687 minutes = runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
688 if (minutes > 31)
689 h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
690 else
691 h->reconnect_delay.rel_value_us >>= minutes;
692 }
694 "Scheduling task to reconnect to transport service in %s.\n",
697 GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
698 h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
699}
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
@ GNUNET_YES
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_DEBUG
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:1278
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:570
#define GNUNET_TIME_UNIT_MINUTES
One minute.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
#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_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
Time for relative time used by GNUnet, in microseconds.
static void disconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
Disconnect from the transport service.
static void reconnect(void *cls)
Try again to connect to transport service.
#define LOG(kind,...)

References disconnect(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_MINUTES, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, h, LOG, reconnect(), GNUNET_ARM_Handle::reconnect_task, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_connect(), handle_disconnect(), handle_recv(), handle_send_ok(), and mq_error_handler().

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

◆ neighbour_find()

static struct Neighbour * neighbour_find ( struct GNUNET_TRANSPORT_CoreHandle h,
const struct GNUNET_PeerIdentity peer 
)
static

Get the neighbour list entry for the given peer.

Parameters
hour context
peerpeer to look up
Returns
NULL if no such peer entry exists

Definition at line 193 of file transport_api2_core.c.

195{
196 return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
197}
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.

References GNUNET_CONTAINER_multipeermap_get(), and h.

Referenced by GNUNET_TRANSPORT_core_get_mq(), handle_connect(), handle_disconnect(), handle_recv(), and handle_send_ok().

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

◆ neighbour_delete()

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

Iterator over hash map entries, for deleting state of a neighbour.

Parameters
clsthe struct GNUNET_TRANSPORT_CoreHandle *
keypeer identity
valuevalue in the hash map, the neighbour entry to delete
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 211 of file transport_api2_core.c.

212{
214 struct Neighbour *n = value;
215
217 "Dropping entry for neighbour `%s'.\n",
218 GNUNET_i2s (key));
219 if (NULL != handle->nd_cb)
220 handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
221 if (NULL != n->env)
222 {
224 n->env = NULL;
225 }
227 GNUNET_assert (NULL == n->mq);
229 GNUNET_YES ==
231 GNUNET_free (n);
232 return GNUNET_YES;
233}
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
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.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:768
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
Handle for the transport service (includes all of the state for the transport service).
void * cls
Closure for the callbacks.
A neighbour that at least one communicator is connected to.
struct GNUNET_MQ_Envelope * env
Envelope with the message we are currently transmitting (or NULL).
void * handlers_cls
Closure for mq handlers.
struct GNUNET_PeerIdentity id
Identity of this neighbour.
struct GNUNET_MQ_Handle * mq
Active message queue for the peer.

References GNUNET_TRANSPORT_CoreHandle::cls, Neighbour::env, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MQ_destroy(), GNUNET_MQ_send_cancel(), GNUNET_YES, handle, Neighbour::handlers_cls, Neighbour::id, key, LOG, Neighbour::mq, and value.

Referenced by disconnect(), and handle_disconnect().

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

◆ mq_error_handler()

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

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsclosure with the struct GNUNET_TRANSPORT_CoreHandle *
errorerror code

Definition at line 246 of file transport_api2_core.c.

247{
249
251 "Error %u received from transport service, disconnecting temporarily.\n",
252 error);
254}
static void disconnect_and_schedule_reconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
Function that will schedule the job that will try to connect us again to the client.

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_ERROR_TYPE_DEBUG, h, and LOG.

Referenced by reconnect().

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

◆ notify_send_done()

static void notify_send_done ( void *  cls)
static

A message from the handler's message queue to a neighbour was transmitted.

Now trigger (possibly delayed) notification of the neighbour's message queue that we are done and thus ready for the next message. Note that the MQ being ready is independent of the send window, as we may queue many messages and simply not pass them to TRANSPORT if the send window is insufficient.

Parameters
clsthe struct Neighbour where the message was sent

Definition at line 268 of file transport_api2_core.c.

269{
270 struct Neighbour *n = cls;
271
273 n->env = NULL;
274 if (0 < n->ready_window)
276}
@ GNUNET_NO
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
int16_t awaiting_done
Used to indicate our status if env is non-NULL.
unsigned int ready_window
How many messages can we still send to this peer before we should throttle?

References Neighbour::awaiting_done, Neighbour::env, GNUNET_MQ_impl_send_continue(), GNUNET_NO, Neighbour::mq, and Neighbour::ready_window.

Referenced by do_send().

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

◆ do_send()

static void do_send ( struct Neighbour n)
static

We have an envelope waiting for transmission at n, and our transmission window is positive.

Perform the transmission.

Parameters
nneighbour to perform transmission for

Definition at line 286 of file transport_api2_core.c.

287{
289 GNUNET_assert (NULL != n->env);
290 n->ready_window--;
293 GNUNET_MQ_send (n->h->mq, n->env);
295 "Passed message of type %u for neighbour `%s' to TRANSPORT. ready_window %u\n",
296 ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
297 GNUNET_i2s (&n->id),
298 n->ready_window);
299}
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
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
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:879
struct GNUNET_MQ_Handle * mq
My client connection to the transport service.
struct GNUNET_TRANSPORT_CoreHandle * h
Overall transport handle.
static void notify_send_done(void *cls)
A message from the handler's message queue to a neighbour was transmitted.

References Neighbour::awaiting_done, Neighbour::env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_env_get_msg(), GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_YES, Neighbour::h, Neighbour::id, LOG, GNUNET_TRANSPORT_CoreHandle::mq, notify_send_done(), Neighbour::ready_window, and GNUNET_MessageHeader::type.

Referenced by handle_send_ok(), and mq_send_impl().

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

◆ mq_send_impl()

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

Implement sending functionality of a message queue.

Called one message at a time. Should send the msg to the transport service and then notify the queue once we are ready for the next one.

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

Definition at line 313 of file transport_api2_core.c.

316{
317 struct Neighbour *n = impl_state;
318 struct OutboundMessage *obm;
319 uint16_t msize;
320
321 msize = ntohs (msg->size);
322 if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
323 {
324 GNUNET_break (0);
326 return;
327 }
329 "CORE requested transmission of message of type %u to neighbour `%s'.\n",
330 ntohs (msg->type),
331 GNUNET_i2s (&n->id));
332
333 GNUNET_assert (NULL == n->env);
334 n->env =
336 n->env_size = ntohs (msg->size);
337 {
338 struct GNUNET_MQ_Envelope *env;
339
341 obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
342 }
343 obm->peer = n->id;
344 if (0 == n->ready_window)
345 {
347 "Flow control delays transmission to CORE until we see SEND_OK.\n");
348 return; /* can't send yet, need to wait for SEND_OK */
349 }
350 do_send (n);
351}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#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.
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_TRANSPORT_SEND
Request to TRANSPORT to transmit a message.
uint16_t env_size
Size of the message in env.
Message used to notify the transport service about a message to be transmitted to another peer.
Definition: transport.h:229
uint32_t priority
An enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: transport.h:238
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:252
static void do_send(struct Neighbour *n)
We have an envelope waiting for transmission at n, and our transmission window is positive.

References do_send(), env, Neighbour::env, Neighbour::env_size, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_msg_nested_mh, Neighbour::id, LOG, mq, msg, OutboundMessage::peer, OutboundMessage::priority, Neighbour::ready_window, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_connect().

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

◆ mq_destroy_impl()

static void 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 362 of file transport_api2_core.c.

363{
364 struct Neighbour *n = impl_state;
365
366 GNUNET_assert (mq == n->mq);
367 n->mq = NULL;
368}

References GNUNET_assert, mq, and Neighbour::mq.

Referenced by handle_connect().

Here is the caller graph for this function:

◆ mq_cancel_impl()

static void 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 379 of file transport_api2_core.c.

380{
381 struct Neighbour *n = impl_state;
382
383 n->ready_window++;
384 if (GNUNET_YES == n->awaiting_done)
385 {
387 n->env = NULL;
389 }
390 else
391 {
392 GNUNET_assert (0 == n->ready_window);
393 n->env = NULL;
394 }
395}

References Neighbour::awaiting_done, Neighbour::env, GNUNET_assert, GNUNET_MQ_send_cancel(), GNUNET_NO, GNUNET_YES, and Neighbour::ready_window.

Referenced by handle_connect().

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

◆ peer_mq_error_handler()

static void peer_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 407 of file transport_api2_core.c.

408{
409 struct Neighbour *n = cls;
410
411 if (GNUNET_MQ_ERROR_MALFORMED == error)
412 GNUNET_break_op (0);
413 //TODO Look into bug #7887
414
415 GNUNET_TRANSPORT_core_receive_continue (n->h, &n->id);
416}
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
@ GNUNET_MQ_ERROR_MALFORMED
We received a message that was malformed and thus could not be passed to its handler.

References GNUNET_break_op, GNUNET_MQ_ERROR_MALFORMED, Neighbour::h, and Neighbour::id.

Referenced by handle_connect().

Here is the caller graph for this function:

◆ handle_connect()

static void handle_connect ( void *  cls,
const struct ConnectInfoMessage cim 
)
static

Function we use for handling incoming connect messages.

Parameters
clsclosure, a struct GNUNET_TRANSPORT_Handle *
cimmessage received

Definition at line 426 of file transport_api2_core.c.

427{
429 struct Neighbour *n;
430
432 "Receiving CONNECT message for `%s'\n",
433 GNUNET_i2s (&cim->id));
434 n = neighbour_find (h, &cim->id);
435 if (NULL != n)
436 {
437 GNUNET_break (0);
439 return;
440 }
441 n = GNUNET_new (struct Neighbour);
442 n->id = cim->id;
443 n->h = h;
447 h->neighbours,
448 &n->id,
449 n,
451
455 n,
456 h->handlers,
458 n);
459 if (NULL != h->nc_cb)
460 {
461 n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
463 }
464}
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...
@ GNUNET_OK
#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_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:111
static void peer_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.
static void mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
static struct Neighbour * neighbour_find(struct GNUNET_TRANSPORT_CoreHandle *h, const struct GNUNET_PeerIdentity *peer)
Get the neighbour list entry for the given peer.
#define SEND_WINDOW_SIZE
Window size.
static void mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
static void mq_send_impl(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Implement sending functionality of a message queue.

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_set_handlers_closure(), GNUNET_new, GNUNET_OK, h, Neighbour::h, Neighbour::handlers_cls, ConnectInfoMessage::id, Neighbour::id, LOG, Neighbour::mq, mq_cancel_impl(), mq_destroy_impl(), mq_send_impl(), neighbour_find(), peer_mq_error_handler(), Neighbour::ready_window, and SEND_WINDOW_SIZE.

Here is the call graph for this function:

◆ handle_disconnect()

static void handle_disconnect ( void *  cls,
const struct DisconnectInfoMessage dim 
)
static

Function we use for handling incoming disconnect messages.

Parameters
clsclosure, a struct GNUNET_TRANSPORT_CoreHandle *
dimmessage received

Definition at line 474 of file transport_api2_core.c.

475{
477 struct Neighbour *n;
478
479 GNUNET_break (ntohl (dim->reserved) == 0);
481 "Receiving DISCONNECT message for `%s'.\n",
482 GNUNET_i2s (&dim->peer));
483 n = neighbour_find (h, &dim->peer);
484 if (NULL == n)
485 {
486 GNUNET_break (0);
488 return;
489 }
491}
uint32_t dim
Definition: gnunet_pq_lib.h:3
static int neighbour_delete(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries, for deleting state of a neighbour.

References GNUNET_TRANSPORT_CoreHandle::cls, dim, disconnect_and_schedule_reconnect(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, h, LOG, neighbour_delete(), and neighbour_find().

Here is the call graph for this function:

◆ handle_send_ok()

static void handle_send_ok ( void *  cls,
const struct SendOkMessage okm 
)
static

Function we use for handling incoming send-ok messages.

Parameters
clsclosure, a struct GNUNET_TRANSPORT_CoreHandle *
okmmessage received

Definition at line 501 of file transport_api2_core.c.

502{
504 struct Neighbour *n;
505
507 "Receiving SEND_OK message for transmission to %s\n",
508 GNUNET_i2s (&okm->peer));
509
510 n = neighbour_find (h, &okm->peer);
511
512 if (NULL == n)
513 {
514 /* We should never get a 'SEND_OK' for a peer that we are not
515 connected to */
516 GNUNET_break (0);
518 return;
519 }
520
521 if ((GNUNET_NO == n->awaiting_done) &&
522 (NULL != n->env) &&
523 (0 == n->ready_window))
524 {
525 n->ready_window++;
526 do_send (n);
527 return;
528 }
529 else if ((GNUNET_NO == n->awaiting_done) &&
530 (0 == n->ready_window))
531 {
532 n->ready_window++;
534 return;
535 }
536 n->ready_window++;
537}
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:195

References Neighbour::awaiting_done, GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), do_send(), Neighbour::env, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_impl_send_continue(), GNUNET_NO, h, LOG, Neighbour::mq, neighbour_find(), SendOkMessage::peer, and Neighbour::ready_window.

Here is the call graph for this function:

◆ check_recv()

static int check_recv ( void *  cls,
const struct InboundMessage im 
)
static

Function we use for checking incoming "inbound" messages.

Parameters
clsclosure, a struct GNUNET_TRANSPORT_CoreHandle *
immessage received

Definition at line 547 of file transport_api2_core.c.

548{
549 const struct GNUNET_MessageHeader *imm;
550 uint16_t size;
551
553 "check_recv\n");
554 size = ntohs (im->header.size) - sizeof(*im);
555 if (size < sizeof(struct GNUNET_MessageHeader))
556 {
557 GNUNET_break (0);
558 return GNUNET_SYSERR;
559 }
560 imm = (const struct GNUNET_MessageHeader *) &im[1];
561 if (ntohs (imm->size) != size)
562 {
563 GNUNET_break (0);
564 return GNUNET_SYSERR;
565 }
566 return GNUNET_OK;
567}
#define GNUNET_log(kind,...)
@ GNUNET_SYSERR
static unsigned int size
Size of the "table".
Definition: peer.c:68
Header for all communications.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV.
Definition: transport.h:147

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, InboundMessage::header, GNUNET_MessageHeader::size, and size.

◆ handle_recv()

static void handle_recv ( void *  cls,
const struct InboundMessage im 
)
static

Function we use for handling incoming messages.

Parameters
clsclosure, a struct GNUNET_TRANSPORT_CoreHandle *
immessage received

Definition at line 577 of file transport_api2_core.c.

578{
580 const struct GNUNET_MessageHeader *imm =
581 (const struct GNUNET_MessageHeader *) &im[1];
582 struct Neighbour *n;
583
585 "Received message of type %u with %u bytes from `%s'.\n",
586 (unsigned int) ntohs (imm->type),
587 (unsigned int) ntohs (imm->size),
588 GNUNET_i2s (&im->peer));
589 n = neighbour_find (h, &im->peer);
590 if (NULL == n)
591 {
592 GNUNET_break (0);
594 return;
595 }
597}
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
Which peer sent the message?
Definition: transport.h:152

References GNUNET_TRANSPORT_CoreHandle::cls, disconnect_and_schedule_reconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_inject_message(), h, LOG, Neighbour::mq, neighbour_find(), InboundMessage::peer, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ reconnect()

static void reconnect ( void *  cls)
static

Try again to connect to transport service.

Parameters
clsthe handle to the transport service

Definition at line 606 of file transport_api2_core.c.

607{
610 { GNUNET_MQ_hd_fixed_size (connect,
612 struct ConnectInfoMessage,
613 h),
617 h),
620 struct SendOkMessage,
621 h),
624 struct InboundMessage,
625 h),
627 struct GNUNET_MQ_Envelope *env;
628 struct StartMessage *s;
629 uint32_t options;
630
631 h->reconnect_task = NULL;
632 LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
633 GNUNET_assert (NULL == h->mq);
634 h->mq =
636 h->restarted_at = GNUNET_TIME_absolute_get ();
637 if (NULL == h->mq)
638 return;
640 options = 0;
641 if (h->check_self)
642 options |= 1;
643 if (NULL != h->handlers)
644 options |= 2;
645 s->options = htonl (options);
646 s->self = h->self;
648}
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
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_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START
Message from the core saying that the transport server should start giving it messages.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
Message from TRANSPORT notifying about a message that was received.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
Message from TRANSPORT notifying about a client that disconnected from us.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
Message from the transport service to the library informing about neighbors.
Definition: transport.h:88
Message from the transport service to the library informing about disconnects.
Definition: transport.h:120
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 used to notify the transport API about a message received from the network.
Definition: transport.h:143
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:161
Message from the transport service to the library asking to check if both processes agree about this ...
Definition: transport.h:62
uint32_t options
0: no options 1: The self field should be checked 2: this client is interested in payload traffic
Definition: transport.h:73
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:79
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...

References GNUNET_ARM_Handle::cfg, GNUNET_TRANSPORT_CoreHandle::cls, disconnect(), env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_MESSAGE_TYPE_TRANSPORT_START, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_TIME_absolute_get(), h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), options, StartMessage::options, GNUNET_ARM_Handle::reconnect_task, and StartMessage::self.

Referenced by disconnect_and_schedule_reconnect().

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

◆ disconnect()

static void disconnect ( struct GNUNET_TRANSPORT_CoreHandle h)
static

Disconnect from the transport service.

Parameters
htransport service to reconnect

Definition at line 657 of file transport_api2_core.c.

658{
660 if (NULL != h->mq)
661 {
663 h->mq = NULL;
664 }
665}
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.

References GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_MQ_destroy(), h, GNUNET_ARM_Handle::mq, and neighbour_delete().

Referenced by disconnect_and_schedule_reconnect(), and reconnect().

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

◆ GNUNET_TRANSPORT_core_get_mq()

struct GNUNET_MQ_Handle * GNUNET_TRANSPORT_core_get_mq ( struct GNUNET_TRANSPORT_CoreHandle handle,
const struct GNUNET_PeerIdentity peer 
)

Checks if a given peer is connected to us and get the message queue.

Parameters
handleconnection to transport service
peerthe peer to check
Returns
NULL if disconnected, otherwise message queue for peer

Definition at line 710 of file transport_api2_core.c.

712{
713 struct Neighbour *n;
714
715 n = neighbour_find (handle, peer);
716 if (NULL == n)
717 return NULL;
718 return n->mq;
719}

References handle, Neighbour::mq, and neighbour_find().

Here is the call graph for this function: