GNUnet 0.22.0
gnunet-service-messenger_tunnel.h File Reference
Include dependency graph for gnunet-service-messenger_tunnel.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_SrvTunnel
 

Functions

struct GNUNET_MESSENGER_SrvTunnelcreate_tunnel (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *door)
 Creates and allocates a tunnel of a room to a specific peer identity (called door). More...
 
void destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Destroys a tunnel and frees its memory fully. More...
 
void bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel)
 Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necessary. More...
 
enum GNUNET_GenericReturnValue check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
 Callback for message verification via header in a tunnel that is provided as a closure from a CADET channel. More...
 
void handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
 Callback for message handling via header in a tunnel that is provided as a closure from a CADET channel. More...
 
void callback_tunnel_disconnect (void *cls, const struct GNUNET_CADET_Channel *channel)
 Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its closure. More...
 
enum GNUNET_GenericReturnValue connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Tries to connect a tunnel by creating a new CADET channel and binding it. More...
 
void disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Disconnects and unbinds a channel from a tunnel. More...
 
enum GNUNET_GenericReturnValue is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Returns the status of a currently bound channel of a tunnel. More...
 
void send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env, const struct GNUNET_HashCode *hash)
 Sends an envelope containing a message with a given hash through a tunnel. More...
 
enum GNUNET_GenericReturnValue send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message)
 Sends a message by packing it automatically into an envelope and passing it through the tunnel. More...
 
void forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 Forwards a given message with a known hash through a tunnel. More...
 
const struct GNUNET_HashCodeget_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Returns the hash of the latest peer message published through a given tunnel and matching the tunnels peer identity. More...
 
void get_tunnel_peer_identity (const struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_PeerIdentity *peer)
 Writes the peer identity of the peer connected via tunnel to this peer into the peer parameter. More...
 
uint32_t get_tunnel_messenger_version (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Returns the current messenger version the peer connected via a given tunnel has reported to be using if it was compatible during updating. More...
 
enum GNUNET_GenericReturnValue update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel, uint32_t version)
 Updates the messenger version of the tunnel to a given version if it is compatible to the running peer of the service. More...
 

Function Documentation

◆ create_tunnel()

struct GNUNET_MESSENGER_SrvTunnel * create_tunnel ( struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_PeerIdentity door 
)

Creates and allocates a tunnel of a room to a specific peer identity (called door).

Parameters
[in,out]roomRoom
[in]doorPeer identity
Returns
New tunnel

Definition at line 39 of file gnunet-service-messenger_tunnel.c.

41{
42 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
43
44 GNUNET_assert ((room) && (door));
45
46 tunnel = GNUNET_new (struct GNUNET_MESSENGER_SrvTunnel);
47
48 tunnel->room = room;
49 tunnel->channel = NULL;
50
51 tunnel->peer = GNUNET_PEER_intern (door);
52
53 tunnel->messenger_version = 0;
54
55 tunnel->peer_message = NULL;
56
57 init_message_state (&(tunnel->state));
58
59 return tunnel;
60}
void init_message_state(struct GNUNET_MESSENGER_MessageState *state)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
GNUNET_PEER_Id GNUNET_PEER_intern(const struct GNUNET_PeerIdentity *pid)
Intern an peer identity.
Definition: peer.c:108
struct GNUNET_CADET_Channel * channel
struct GNUNET_MESSENGER_MessageState state
struct GNUNET_MESSENGER_SrvRoom * room

References GNUNET_MESSENGER_SrvTunnel::channel, GNUNET_assert, GNUNET_new, GNUNET_PEER_intern(), init_message_state(), GNUNET_MESSENGER_SrvTunnel::messenger_version, GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_SrvTunnel::peer_message, GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvTunnel::state.

Referenced by callback_room_connect(), and enter_srv_room_at().

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

◆ destroy_tunnel()

void destroy_tunnel ( struct GNUNET_MESSENGER_SrvTunnel tunnel)

Destroys a tunnel and frees its memory fully.

Parameters
[in,out]tunnel

Definition at line 64 of file gnunet-service-messenger_tunnel.c.

65{
66 GNUNET_assert (tunnel);
67
68 if (tunnel->channel)
70
71 GNUNET_PEER_change_rc (tunnel->peer, -1);
72
73 if (tunnel->peer_message)
74 GNUNET_free (tunnel->peer_message);
75
76 clear_message_state (&(tunnel->state));
77
78 GNUNET_free (tunnel);
79}
void clear_message_state(struct GNUNET_MESSENGER_MessageState *state)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_PEER_change_rc(GNUNET_PEER_Id id, int delta)
Change the reference counter of an interned PID.
Definition: peer.c:192

References GNUNET_MESSENGER_SrvTunnel::channel, clear_message_state(), GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_free, GNUNET_PEER_change_rc(), GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_SrvTunnel::peer_message, and GNUNET_MESSENGER_SrvTunnel::state.

Here is the call graph for this function:

◆ bind_tunnel()

void bind_tunnel ( struct GNUNET_MESSENGER_SrvTunnel tunnel,
struct GNUNET_CADET_Channel channel 
)

Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necessary.

Parameters
[in,out]tunnelTunnel
[in,out]channelCADET channel

Definition at line 83 of file gnunet-service-messenger_tunnel.c.

85{
86 GNUNET_assert (tunnel);
87
88 if (tunnel->channel)
90
91 tunnel->channel = channel;
92}
void delayed_disconnect_channel(struct GNUNET_CADET_Channel *channel)
Starts an urgent task to close a CADET channel asynchronously.

References GNUNET_MESSENGER_SrvTunnel::channel, delayed_disconnect_channel(), and GNUNET_assert.

Referenced by callback_room_connect().

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

◆ check_tunnel_message()

enum GNUNET_GenericReturnValue check_tunnel_message ( void *  cls,
const struct GNUNET_MessageHeader header 
)

Callback for message verification via header in a tunnel that is provided as a closure from a CADET channel.

Parameters
[in,out]clsClosure
[in]headerMessage header

Definition at line 198 of file gnunet-service-messenger_tunnel.c.

200{
201 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
202 struct GNUNET_MESSENGER_Message message;
203 struct GNUNET_HashCode hash;
204 uint16_t length;
205 const char *buffer;
206
207 GNUNET_assert (header);
208
209 tunnel = cls;
210
211 if (! tunnel)
212 return GNUNET_SYSERR;
213
214 length = ntohs (header->size) - sizeof(*header);
215 buffer = (const char*) &header[1];
216
218 GNUNET_YES))
219 {
221 "Tunnel error: Message too short! (%d)\n", length);
222 return GNUNET_SYSERR;
223 }
224
225 {
226 uint16_t padding;
227 padding = 0;
228
229 if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
230 &padding))
231 {
232 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
233 return GNUNET_SYSERR;
234 }
235
236 hash_message (&message, length - padding, buffer, &hash);
237 }
238
239 return verify_tunnel_message (tunnel->room, &message, &hash);
240}
static enum GNUNET_GenericReturnValue verify_tunnel_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
#define GNUNET_log(kind,...)
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_YES
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
void hash_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, struct GNUNET_HashCode *hash)
Calculates a hash of a given buffer with a length in bytes from a message.
uint16_t get_message_kind_size(enum GNUNET_MESSENGER_MessageKind kind, enum GNUNET_GenericReturnValue include_header)
Returns the minimal size in bytes to encode a message of a specific kind.
enum GNUNET_GenericReturnValue decode_message(struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, enum GNUNET_GenericReturnValue include_header, uint16_t *padding)
Decodes a message from a given buffer of a maximal length in bytes.
A 512-bit hashcode.

References decode_message(), get_message_kind_size(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_SYSERR, GNUNET_YES, hash_message(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, and verify_tunnel_message().

Here is the call graph for this function:

◆ handle_tunnel_message()

void handle_tunnel_message ( void *  cls,
const struct GNUNET_MessageHeader header 
)

Callback for message handling via header in a tunnel that is provided as a closure from a CADET channel.

Parameters
[in,out]clsClosure
[in]headerMessage header

Definition at line 284 of file gnunet-service-messenger_tunnel.c.

285{
286 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
287 struct GNUNET_MESSENGER_Message message;
288 struct GNUNET_HashCode hash;
289 uint16_t length;
290 const char *buffer;
291
292 GNUNET_assert (header);
293
294 tunnel = cls;
295
296 if (! tunnel)
297 return;
298
299 length = ntohs (header->size) - sizeof(*header);
300 buffer = (const char*) &header[1];
301
302 {
303 uint16_t padding;
304 padding = 0;
305
306 decode_message (&message, length, buffer, GNUNET_YES, &padding);
307 hash_message (&message, length - padding, buffer, &hash);
308 }
309
310 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
311 GNUNET_MESSENGER_name_of_kind (message.header.kind));
312
313 {
314 enum GNUNET_GenericReturnValue new_message;
315 new_message = update_room_message (tunnel->room,
316 copy_message (&message),
317 &hash);
318
319 if (GNUNET_YES != new_message)
320 goto receive_done;
321 }
322
323 update_tunnel_last_message (tunnel, &hash);
324
325 {
326 enum GNUNET_GenericReturnValue forward_message;
327 forward_message = GNUNET_YES;
328
329 switch (message.header.kind)
330 {
332 forward_message = recv_message_info (tunnel->room, tunnel, &message, &hash);
333 break;
335 forward_message = recv_message_peer (tunnel->room, tunnel, &message, &hash);
336 break;
338 forward_message = recv_message_miss (tunnel->room, tunnel, &message, &hash);
339 break;
341 forward_message = recv_message_request (tunnel->room, tunnel, &message,
342 &hash);
343 break;
344 default:
345 break;
346 }
347
348 if (GNUNET_YES == forward_message)
349 {
350 forward_srv_room_message (tunnel->room, tunnel, &message, &hash);
351 callback_room_handle_message (tunnel->room, &message, &hash);
352 }
353 }
354
355receive_done:
356 cleanup_message (&message);
357
359}
enum GNUNET_GenericReturnValue recv_message_request(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received request message by checking for the requested message and forwarding it back if th...
enum GNUNET_GenericReturnValue recv_message_miss(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received miss message to react to activity in the basement of a room.
enum GNUNET_GenericReturnValue recv_message_info(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received info message to change the current member id to the one generated by the host conn...
enum GNUNET_GenericReturnValue recv_message_peer(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received peer message to link it to its origin tunnel if the peer identity matches.
void forward_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Forwards a message with a given hash to a specific tunnel inside of a room.
enum GNUNET_GenericReturnValue update_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
void callback_room_handle_message(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
static void update_tunnel_last_message(struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_HashCode *hash)
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:872
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_ERROR_TYPE_DEBUG
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:44
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
void cleanup_message(struct GNUNET_MESSENGER_Message *message)
Frees the messages body memory.

References callback_room_handle_message(), GNUNET_MESSENGER_SrvTunnel::channel, cleanup_message(), copy_message(), decode_message(), forward_srv_room_message(), GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_name_of_kind(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, recv_message_info(), recv_message_miss(), recv_message_peer(), recv_message_request(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, update_room_message(), and update_tunnel_last_message().

Here is the call graph for this function:

◆ callback_tunnel_disconnect()

void callback_tunnel_disconnect ( void *  cls,
const struct GNUNET_CADET_Channel channel 
)

Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its closure.

Parameters
[in,out]clsClosure
[in]channelCADET channel

Definition at line 96 of file gnunet-service-messenger_tunnel.c.

98{
99 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
100 struct GNUNET_MESSENGER_SrvRoom *room;
102
103 tunnel = cls;
104
105 if (! tunnel)
106 return;
107
108 tunnel->channel = NULL;
109
110 GNUNET_assert (tunnel->room);
111
112 room = tunnel->room;
113
114 if (! room->host)
115 return;
116
118
120 &identity,
121 tunnel)) ||
123 &identity)))
124 return;
125
128
131 return;
132
133 {
134 struct GNUNET_MESSENGER_ListTunnel *element;
135 element = find_list_tunnels_alternate (&(room->basement), &identity);
136
137 if (! element)
138 return;
139
140 GNUNET_PEER_resolve (element->peer, &identity);
141 }
142
143 enter_srv_room_at (room, room->host, &identity);
144}
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
struct GNUNET_MESSENGER_Message * create_message_miss(const struct GNUNET_PeerIdentity *peer)
Creates and allocates a new miss message containing the missing peer identity.
enum GNUNET_GenericReturnValue enter_srv_room_at(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door)
Connects a tunnel to a hosting peer of a room through a so called door which is represented by a peer...
enum GNUNET_GenericReturnValue send_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle into a room.
void get_tunnel_peer_identity(const struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_PeerIdentity *peer)
Writes the peer identity of the peer connected via tunnel to this peer into the peer parameter.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL).
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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_NO
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
struct GNUNET_MESSENGER_ListTunnel * find_list_tunnels_alternate(struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer)
Searches linearly through the list of tunnels peer identities for matching against a specific peer id...
enum GNUNET_GenericReturnValue contains_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer)
Tests linearly if the list of tunnels peer identities contains a specific peer identity and returns G...
enum GNUNET_GenericReturnValue auto_connecting
struct GNUNET_CONTAINER_MultiPeerMap * tunnels
struct GNUNET_MESSENGER_Service * service
struct GNUNET_MESSENGER_ListTunnels basement
struct GNUNET_MESSENGER_SrvHandle * host
The identity of the host (wraps the signing key of the peer).

References GNUNET_MESSENGER_Service::auto_connecting, GNUNET_MESSENGER_SrvRoom::basement, GNUNET_MESSENGER_SrvTunnel::channel, contains_list_tunnels(), create_message_miss(), enter_srv_room_at(), find_list_tunnels_alternate(), get_tunnel_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_NO, GNUNET_PEER_resolve(), GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, identity, GNUNET_MESSENGER_ListTunnel::peer, GNUNET_MESSENGER_SrvTunnel::room, send_srv_room_message(), GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by connect_tunnel(), and open_srv_room().

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

◆ connect_tunnel()

enum GNUNET_GenericReturnValue connect_tunnel ( struct GNUNET_MESSENGER_SrvTunnel tunnel)

Tries to connect a tunnel by creating a new CADET channel and binding it.

The function returns GNUNET_YES on success, otherwise GNUNET_NO.

Parameters
[in,out]tunnelTunnel
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 363 of file gnunet-service-messenger_tunnel.c.

364{
365 const struct GNUNET_PeerIdentity *door;
367 const struct GNUNET_HashCode *key;
368
369
370 GNUNET_assert (tunnel);
371
372 if (tunnel->channel)
373 return GNUNET_NO;
374
375 door = GNUNET_PEER_resolve2 (tunnel->peer);
376 cadet = get_srv_room_cadet (tunnel->room);
377 key = get_srv_room_key (tunnel->room);
378
379 {
380 struct GNUNET_HashCode port;
382 tunnel_message,
384 struct
387
389 tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port,
390 NULL,
392 handlers);
393 }
394
395 return GNUNET_YES;
396}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
struct GNUNET_CADET_Handle * get_srv_room_cadet(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the CADET handle from a rooms service.
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
void callback_tunnel_disconnect(void *cls, const struct GNUNET_CADET_Channel *channel)
Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its cl...
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1015
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
const struct GNUNET_PeerIdentity * GNUNET_PEER_resolve2(GNUNET_PEER_Id id)
Convert an interned PID to a normal peer identity.
Definition: peer.c:234
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
void convert_messenger_key_to_port(const struct GNUNET_HashCode *key, struct GNUNET_HashCode *port)
Converts a Messenger service key of a room to the specific port which gets used for the CADET channel...
Opaque handle to the service.
Definition: cadet_api.c:39
Message handler for a specific message type.
Header for all communications.

References cadet, callback_tunnel_disconnect(), GNUNET_MESSENGER_SrvTunnel::channel, convert_messenger_key_to_port(), get_srv_room_cadet(), get_srv_room_key(), GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_PEER_resolve2(), GNUNET_YES, handlers, key, GNUNET_MESSENGER_SrvTunnel::peer, port, and GNUNET_MESSENGER_SrvTunnel::room.

Referenced by enter_srv_room_at(), and rebuild_srv_room_basement_structure().

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

◆ disconnect_tunnel()

void disconnect_tunnel ( struct GNUNET_MESSENGER_SrvTunnel tunnel)

Disconnects and unbinds a channel from a tunnel.

The actual disconnection will be asynchronous.

Parameters
[in,out]tunnelTunnel

Definition at line 400 of file gnunet-service-messenger_tunnel.c.

401{
402 GNUNET_assert (tunnel);
403
404 if (tunnel->channel)
405 {
407
408 tunnel->channel = NULL;
409 }
410}

References GNUNET_MESSENGER_SrvTunnel::channel, delayed_disconnect_channel(), and GNUNET_assert.

Referenced by callback_room_connect(), rebuild_srv_room_basement_structure(), and recv_message_info().

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

◆ is_tunnel_connected()

enum GNUNET_GenericReturnValue is_tunnel_connected ( const struct GNUNET_MESSENGER_SrvTunnel tunnel)

Returns the status of a currently bound channel of a tunnel.

Parameters
[in]tunnelTunnel
Returns
GNUNET_YES or GNUNET_NO

Definition at line 414 of file gnunet-service-messenger_tunnel.c.

415{
416 GNUNET_assert (tunnel);
417
418 return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
419}

References GNUNET_MESSENGER_SrvTunnel::channel, GNUNET_assert, GNUNET_NO, and GNUNET_YES.

Referenced by iterate_send_room_message(), and send_room_info().

Here is the caller graph for this function:

◆ send_tunnel_envelope()

void send_tunnel_envelope ( struct GNUNET_MESSENGER_SrvTunnel tunnel,
struct GNUNET_MQ_Envelope env,
const struct GNUNET_HashCode hash 
)

Sends an envelope containing a message with a given hash through a tunnel.

Parameters
[in,out]tunnelTunnel
[in,out]envEnvelope
[in]hashHash of message

Definition at line 445 of file gnunet-service-messenger_tunnel.c.

448{
449 struct GNUNET_MQ_Handle *mq;
450 struct GNUNET_MESSENGER_MessageSent *sent;
451
452 GNUNET_assert ((tunnel) && (env) && (hash));
453
456
457 GNUNET_memcpy (&(sent->hash), hash, sizeof(struct GNUNET_HashCode));
458
459 sent->tunnel = tunnel;
460
463}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void callback_tunnel_sent(void *cls)
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected channel.
Definition: cadet_api.c:1066
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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:305
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:655
struct GNUNET_MESSENGER_SrvTunnel * tunnel
Handle to a message queue.
Definition: mq.c:87

References callback_tunnel_sent(), GNUNET_MESSENGER_SrvTunnel::channel, env, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_memcpy, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_new, GNUNET_MESSENGER_MessageSent::hash, mq, and GNUNET_MESSENGER_MessageSent::tunnel.

Referenced by forward_tunnel_message(), iterate_send_room_message(), and send_tunnel_message().

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

◆ send_tunnel_message()

enum GNUNET_GenericReturnValue send_tunnel_message ( struct GNUNET_MESSENGER_SrvTunnel tunnel,
void *  handle,
struct GNUNET_MESSENGER_Message message 
)

Sends a message by packing it automatically into an envelope and passing it through the tunnel.

The used handle will sign the message and the hash will be calculated and stored.

Parameters
[in,out]tunnelTunnel
[in,out]handleHandle
[in,out]messageMessage
Returns
GNUNET_YES on success, GNUNET_NO otherwise

Definition at line 467 of file gnunet-service-messenger_tunnel.c.

470{
471 struct GNUNET_HashCode hash;
472 struct GNUNET_MQ_Envelope *env;
473
474 GNUNET_assert ((tunnel) && (handle));
475
476 if (! message)
477 return GNUNET_NO;
478
480 tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
482 );
483
484 destroy_message (message);
485
486 if (! env)
487 return GNUNET_NO;
488
489 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
490 GNUNET_h2s (&hash));
491
492 send_tunnel_envelope (tunnel, env, &hash);
493 return GNUNET_YES;
494}
struct GNUNET_MQ_Envelope * pack_srv_room_message(const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_PackMode mode)
Packs a message depending on the selected mode into a newly allocated envelope.
void send_tunnel_envelope(struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env, const struct GNUNET_HashCode *hash)
Sends an envelope containing a message with a given hash through a tunnel.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
@ GNUNET_MESSENGER_PACK_MODE_ENVELOPE

References destroy_message(), env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_NO, GNUNET_YES, handle, pack_srv_room_message(), GNUNET_MESSENGER_SrvTunnel::room, and send_tunnel_envelope().

Referenced by recv_message_info(), and send_room_info().

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

◆ forward_tunnel_message()

void forward_tunnel_message ( struct GNUNET_MESSENGER_SrvTunnel tunnel,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

Forwards a given message with a known hash through a tunnel.

Parameters
[in,out]tunnelTunnel
[in]messageMessage
[in]hashHash of message

Definition at line 498 of file gnunet-service-messenger_tunnel.c.

501{
502 struct GNUNET_MESSENGER_Message *copy;
503 struct GNUNET_MQ_Envelope *env;
504
505 GNUNET_assert ((tunnel) && (message) && (hash));
506
507 copy = copy_message (message);
509 NULL);
510
511 destroy_message (copy);
512
513 if (! env)
514 return;
515
516 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
517 GNUNET_h2s (hash));
518
519 send_tunnel_envelope (tunnel, env, hash);
520}
struct GNUNET_MQ_Envelope * pack_message(struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, const GNUNET_MESSENGER_SignFunction sign, enum GNUNET_MESSENGER_PackMode mode, const void *cls)
Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_P...

References copy_message(), destroy_message(), env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, pack_message(), and send_tunnel_envelope().

Referenced by callback_found_message(), check_srv_room_peer_status(), forward_about_members(), and recv_message_info().

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

◆ get_tunnel_peer_message()

const struct GNUNET_HashCode * get_tunnel_peer_message ( const struct GNUNET_MESSENGER_SrvTunnel tunnel)

Returns the hash of the latest peer message published through a given tunnel and matching the tunnels peer identity.

If no peer message has been linked to the tunnel yet, NULL gets returned.

Parameters
[in]tunnelTunnel
Returns
Hash of peer message or NULL

Definition at line 524 of file gnunet-service-messenger_tunnel.c.

525{
526 GNUNET_assert (tunnel);
527
528 return tunnel->peer_message;
529}

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::peer_message.

◆ get_tunnel_peer_identity()

void get_tunnel_peer_identity ( const struct GNUNET_MESSENGER_SrvTunnel tunnel,
struct GNUNET_PeerIdentity peer 
)

Writes the peer identity of the peer connected via tunnel to this peer into the peer parameter.

Parameters
[in]tunnelTunnel
[out]peerPeer identity

Definition at line 533 of file gnunet-service-messenger_tunnel.c.

535{
536 GNUNET_assert (tunnel);
537
538 GNUNET_PEER_resolve (tunnel->peer, peer);
539}

References GNUNET_assert, GNUNET_PEER_resolve(), and GNUNET_MESSENGER_SrvTunnel::peer.

Referenced by callback_tunnel_disconnect(), and recv_message_info().

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

◆ get_tunnel_messenger_version()

uint32_t get_tunnel_messenger_version ( const struct GNUNET_MESSENGER_SrvTunnel tunnel)

Returns the current messenger version the peer connected via a given tunnel has reported to be using if it was compatible during updating.

See also
update_tunnel_messenger_version
Parameters
[in]tunnelTunnel
Returns
Version of messenger

Definition at line 543 of file gnunet-service-messenger_tunnel.c.

544{
545 GNUNET_assert (tunnel);
546
547 return tunnel->messenger_version;
548}

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::messenger_version.

Referenced by iterate_send_room_message(), and recv_message_info().

Here is the caller graph for this function:

◆ update_tunnel_messenger_version()

enum GNUNET_GenericReturnValue update_tunnel_messenger_version ( struct GNUNET_MESSENGER_SrvTunnel tunnel,
uint32_t  version 
)

Updates the messenger version of the tunnel to a given version if it is compatible to the running peer of the service.

Depending on success it returns GNUNET_OK or GNUNET_SYSERR on failure.

Parameters
[in,out]tunnelTunnel
[in]versionVersion of messenger
Returns
GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 552 of file gnunet-service-messenger_tunnel.c.

554{
555 GNUNET_assert (tunnel);
556
557 if (version != GNUNET_MESSENGER_VERSION)
558 return GNUNET_SYSERR;
559
560 if (version > tunnel->messenger_version)
561 tunnel->messenger_version = version;
562
563 return GNUNET_OK;
564}
@ GNUNET_OK
#define GNUNET_MESSENGER_VERSION
Version number of GNUnet Messenger API.

References GNUNET_assert, GNUNET_MESSENGER_VERSION, GNUNET_OK, GNUNET_SYSERR, and GNUNET_MESSENGER_SrvTunnel::messenger_version.

Referenced by recv_message_info().

Here is the caller graph for this function: