GNUnet  0.17.6
Data Structures | Functions
messenger_api.c File Reference

messenger api: client implementation of GNUnet MESSENGER service More...

#include "gnunet_messenger_service.h"
#include "gnunet-service-messenger.h"
#include "messenger_api_handle.h"
#include "messenger_api_message.h"
#include "messenger_api_util.h"
Include dependency graph for messenger_api.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_RoomFind
 

Functions

const char * GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
 Get the name of a message kind. More...
 
static int check_get_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
 
static void handle_get_name (void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
 
static int check_get_key (void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
 
static void handle_get_key (void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
 
static void handle_member_id (void *cls, const struct GNUNET_MESSENGER_MemberMessage *msg)
 
static void handle_room_open (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 
static void handle_room_entry (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 
static void handle_room_close (void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
 
static int check_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
 
static void handle_recv_message (void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
 
static void reconnect (struct GNUNET_MESSENGER_Handle *handle)
 
static void send_open_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
 
static void send_enter_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_PeerIdentity *door)
 
static void send_close_room (struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
 
static int iterate_reset_room (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static void callback_reconnect (void *cls)
 
static int iterate_close_room (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static void callback_mq_error (void *cls, enum GNUNET_MQ_Error error)
 
struct GNUNET_MESSENGER_HandleGNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
 Set up a handle for the messenger related functions and connects to all necessary services. More...
 
int GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle)
 Update a handle of the messenger to use a different ego key and replace the old one with a newly generated one. More...
 
void GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
 Disconnect all of the messengers used services and clears up its used memory. More...
 
const char * GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
 Get the name (if specified, otherwise NULL) used by the messenger. More...
 
int GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
 Set the name for the messenger. More...
 
static const struct GNUNET_IDENTITY_PublicKeyget_non_anonymous_key (const struct GNUNET_IDENTITY_PublicKey *public_key)
 
const struct GNUNET_IDENTITY_PublicKeyGNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
 Get the public key used by the messenger or NULL if the anonymous key was used. More...
 
struct GNUNET_MESSENGER_RoomGNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
 Open a room to send and receive messages. More...
 
struct GNUNET_MESSENGER_RoomGNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
 Enter a room to send and receive messages through a door opened using GNUNET_MESSENGER_open_room. More...
 
void GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
 Close a room which was entered, opened or both in various order and variety. More...
 
static int iterate_find_room (void *cls, const struct GNUNET_HashCode *key, void *value)
 
int GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_MESSENGER_Contact *contact, GNUNET_MESSENGER_MemberCallback callback, void *cls)
 Searches for a specific contact in a given room and calls a selected callback with a given closure for each of them containing the contact as a member. More...
 
const struct GNUNET_HashCodeGNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
 Get the key of a given room. More...
 
const struct GNUNET_MESSENGER_ContactGNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Get the contact of a member in a room which sent a specific message identified with a given hash. More...
 
const char * GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact)
 Get the name used by the contact. More...
 
const struct GNUNET_IDENTITY_PublicKeyGNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact)
 Get the public key used by the contact or NULL if the anonymous key was used. More...
 
void GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_Contact *contact)
 Send a message into a room. More...
 
const struct GNUNET_MESSENGER_MessageGNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Get the message in a room identified by its hash. More...
 
int GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
 Iterates through all members of a given room and calls a selected callback for each of them with a provided closure. More...
 

Detailed Description

messenger api: client implementation of GNUnet MESSENGER service

Author
Tobias Frisch

Definition in file messenger_api.c.

Function Documentation

◆ check_get_name()

static int check_get_name ( void *  cls,
const struct GNUNET_MESSENGER_NameMessage msg 
)
static

Definition at line 75 of file messenger_api.c.

77 {
79  return GNUNET_OK;
80 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
@ GNUNET_OK
Definition: gnunet_common.h:99
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...

References GNUNET_MQ_check_zero_termination, GNUNET_OK, and msg.

◆ handle_get_name()

static void handle_get_name ( void *  cls,
const struct GNUNET_MESSENGER_NameMessage msg 
)
static

Definition at line 83 of file messenger_api.c.

85 {
86  struct GNUNET_MESSENGER_Handle *handle = cls;
87 
88  const char *name = ((const char*) msg) + sizeof(*msg);
89 
90  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set name of handle: %s\n", name);
91 
92  set_handle_name (handle, strlen (name) > 0 ? name : NULL);
93 }
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
void set_handle_name(struct GNUNET_MESSENGER_Handle *handle, const char *name)
Sets the name of a handle to a specific name.
const char * name

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, msg, name, and set_handle_name().

Here is the call graph for this function:

◆ check_get_key()

static int check_get_key ( void *  cls,
const struct GNUNET_MESSENGER_KeyMessage msg 
)
static

Definition at line 96 of file messenger_api.c.

98 {
99  const uint16_t full_length = ntohs (msg->header.size);
100 
101  if (full_length < sizeof(*msg))
102  return GNUNET_NO;
103 
104  const uint16_t length = full_length - sizeof(*msg);
105  const char *buffer = ((const char*) msg) + sizeof(*msg);
106 
108  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
109  return GNUNET_NO;
110 
111  return GNUNET_OK;
112 }
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
ssize_t GNUNET_IDENTITY_read_key_from_buffer(struct GNUNET_IDENTITY_PublicKey *key, const void *buffer, size_t len)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
@ GNUNET_NO
Definition: gnunet_common.h:98
An identity key as per LSD0001.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.

References GNUNET_IDENTITY_read_key_from_buffer(), GNUNET_NO, GNUNET_OK, msg, pubkey, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_get_key()

static void handle_get_key ( void *  cls,
const struct GNUNET_MESSENGER_KeyMessage msg 
)
static

Definition at line 115 of file messenger_api.c.

117 {
118  struct GNUNET_MESSENGER_Handle *handle = cls;
119 
120  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
121  const char *buffer = ((const char*) msg) + sizeof(*msg);
122 
124  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
125  return;
126 
128  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set key of handle: %s\n", str);
129  GNUNET_free(str);
130 
132 
133  if (handle->identity_callback)
134  handle->identity_callback (handle->identity_cls, handle);
135 }
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
#define GNUNET_free(ptr)
Wrapper around free.
void set_handle_key(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey)
Sets the public key of a given handle to a specific public key.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_public_key_to_string(), GNUNET_IDENTITY_read_key_from_buffer(), GNUNET_log, handle, msg, pubkey, set_handle_key(), and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_member_id()

static void handle_member_id ( void *  cls,
const struct GNUNET_MESSENGER_MemberMessage msg 
)
static

Definition at line 138 of file messenger_api.c.

140 {
141  struct GNUNET_MESSENGER_Handle *handle = cls;
142 
143  const struct GNUNET_HashCode *key = &(msg->key);
144  const struct GNUNET_ShortHashCode *id = &(msg->id);
145 
146  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set id of handle in room: %s\n", GNUNET_h2s (key));
147 
149 
150  if (room)
151  {
152  if (!room->contact_id)
154 
155  GNUNET_memcpy(room->contact_id, id, sizeof(*id));
156  }
157 }
struct GNUNET_HashCode key
The key used in the DHT.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A 512-bit hashcode.
struct GNUNET_ShortHashCode * contact_id
A 256-bit hashcode.

References GNUNET_MESSENGER_Room::contact_id, GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, handle, key, and msg.

Here is the call graph for this function:

◆ handle_room_open()

static void handle_room_open ( void *  cls,
const struct GNUNET_MESSENGER_RoomMessage msg 
)
static

Definition at line 160 of file messenger_api.c.

162 {
163  struct GNUNET_MESSENGER_Handle *handle = cls;
164 
165  const struct GNUNET_HashCode *key = &(msg->key);
166 
167  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
168 
170 }
void open_handle_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Marks a room known to a handle identified by a given key as open.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, msg, and open_handle_room().

Here is the call graph for this function:

◆ handle_room_entry()

static void handle_room_entry ( void *  cls,
const struct GNUNET_MESSENGER_RoomMessage msg 
)
static

Definition at line 173 of file messenger_api.c.

175 {
176  struct GNUNET_MESSENGER_Handle *handle = cls;
177 
178  const struct GNUNET_PeerIdentity *door = &(msg->door);
179  const struct GNUNET_HashCode *key = &(msg->key);
180 
181  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entered room: %s\n", GNUNET_h2s (key));
182 
184 }
void entry_handle_room_at(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Adds a tunnel for a room known to a handle identified by a given key to a list of opened connections.
The identity of the host (wraps the signing key of the peer).

References entry_handle_room_at(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, and msg.

Here is the call graph for this function:

◆ handle_room_close()

static void handle_room_close ( void *  cls,
const struct GNUNET_MESSENGER_RoomMessage msg 
)
static

Definition at line 187 of file messenger_api.c.

189 {
190  struct GNUNET_MESSENGER_Handle *handle = cls;
191 
192  const struct GNUNET_HashCode *key = &(msg->key);
193 
194  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closed room: %s\n", GNUNET_h2s (key));
195 
197 }
void close_handle_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Destroys and so implicitly closes a room known to a handle identified by a given key.

References close_handle_room(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, and msg.

Here is the call graph for this function:

◆ check_recv_message()

static int check_recv_message ( void *  cls,
const struct GNUNET_MESSENGER_RecvMessage msg 
)
static

Definition at line 200 of file messenger_api.c.

202 {
203  const uint16_t full_length = ntohs (msg->header.size);
204 
205  if (full_length < sizeof(*msg))
206  return GNUNET_NO;
207 
208  const uint16_t length = full_length - sizeof(*msg);
209  const char *buffer = ((const char*) msg) + sizeof(*msg);
210 
211  struct GNUNET_MESSENGER_Message message;
212 
214  return GNUNET_NO;
215 
216  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
217  return GNUNET_NO;
218 
219  cleanup_message(&message);
220  return GNUNET_OK;
221 }
@ GNUNET_YES
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
int decode_message(struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, int include_header, uint16_t *padding)
Decodes a message from a given buffer of a maximal length in bytes.
uint16_t get_message_kind_size(enum GNUNET_MESSENGER_MessageKind kind, int include_header)
Returns the minimal size in bytes to encode a message of a specific kind.
void cleanup_message(struct GNUNET_MESSENGER_Message *message)
Frees the messages body memory.

References cleanup_message(), decode_message(), get_message_kind_size(), GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_NO, GNUNET_OK, GNUNET_YES, msg, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_recv_message()

static void handle_recv_message ( void *  cls,
const struct GNUNET_MESSENGER_RecvMessage msg 
)
static

Definition at line 224 of file messenger_api.c.

226 {
227  struct GNUNET_MESSENGER_Handle *handle = cls;
228 
229  const struct GNUNET_HashCode *key = &(msg->key);
230  const struct GNUNET_HashCode *sender = &(msg->sender);
231  const struct GNUNET_HashCode *context = &(msg->context);
232  const struct GNUNET_HashCode *hash = &(msg->hash);
233  const enum GNUNET_MESSENGER_MessageFlags flags = (
234  (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
235  );
236 
237  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
238  const char *buffer = ((const char*) msg) + sizeof(*msg);
239 
240  struct GNUNET_MESSENGER_Message message;
241  decode_message (&message, length, buffer, GNUNET_YES, NULL);
242 
243  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n", GNUNET_MESSENGER_name_of_kind (message.header.kind));
244 
246 
247  if (room)
248  {
250 
251  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Raw contact from sender and context: (%s : %s)\n",
253 
255  store, context, sender
256  );
257 
258  contact = handle_room_message (room, contact, &message, hash);
259 
260  const struct GNUNET_MESSENGER_Message *stored_message = get_room_message(room, hash);
261 
262  if (handle->msg_callback)
263  handle->msg_callback (handle->msg_cls, room, contact, stored_message, hash, flags);
264  }
265  else
266  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n", GNUNET_h2s (key));
267 
268  cleanup_message(&message);
269 }
static pa_context * context
Pulseaudio context.
const char * GNUNET_h2s_full(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
GNUNET_MESSENGER_MessageFlags
Enum for the different supported flags used by message handling Compatible flags can be OR'ed togethe...
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:35
struct GNUNET_MESSENGER_Contact * get_store_contact_raw(struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *key_hash)
Returns a contact using the hash of a specific public key.
struct GNUNET_MESSENGER_ContactStore * get_handle_contact_store(struct GNUNET_MESSENGER_Handle *handle)
Returns the used contact store of a given handle.
struct GNUNET_MESSENGER_Contact * handle_room_message(struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a message with a given hash in a room for the client API to update members and its informatio...
const struct GNUNET_MESSENGER_Message * get_room_message(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a message locally stored from a map for a given hash in a room.

References cleanup_message(), context, decode_message(), get_handle_contact_store(), get_room_message(), get_store_contact_raw(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_log, GNUNET_MESSENGER_name_of_kind(), GNUNET_YES, handle, handle_room_message(), GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, msg, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ reconnect()

static void reconnect ( struct GNUNET_MESSENGER_Handle handle)
static

Definition at line 386 of file messenger_api.c.

387 {
388  const struct GNUNET_MQ_MessageHandler handlers[] =
389  {
393  ),
397  ),
399  member_id,
402  ),
404  room_open,
407  ),
409  room_entry,
412  ),
414  room_close,
417  ),
419  recv_message,
422  ),
424  };
425 
427 }
static int recv_message(void *cls, const struct GNUNET_MessageHeader *msg)
We have received a full message, pass to the MQ dispatcher.
Definition: client.c:334
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
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:1055
#define GNUNET_MESSENGER_SERVICE_NAME
Identifier of GNUnet MESSENGER Service.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY
static void callback_mq_error(void *cls, enum GNUNET_MQ_Error error)
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: dns_api.c:66
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61
Message to receive the current public key of a handle.
Message to receive the current member id of a handle in room.
Message to receive the current name of a handle.
Message to receive something from a room.
General message to confirm interaction with a room.
Message handler for a specific message type.
static char * get_key(char *line)
Definition: testing.c:1808

References callback_mq_error(), GNUNET_DNS_Handle::cfg, get_key(), GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE, GNUNET_MESSENGER_SERVICE_NAME, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, handle, handlers, GNUNET_DNS_Handle::mq, and recv_message().

Referenced by callback_reconnect(), and GNUNET_MESSENGER_connect().

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

◆ send_open_room()

static void send_open_room ( struct GNUNET_MESSENGER_Handle handle,
struct GNUNET_MESSENGER_Room room 
)
static

Definition at line 275 of file messenger_api.c.

277 {
279  struct GNUNET_MQ_Envelope *env;
280 
282  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
284 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:302
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:71
struct GNUNET_HashCode key

References env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, GNUNET_MESSENGER_Room::key, GNUNET_DNS_Handle::mq, and msg.

Referenced by GNUNET_MESSENGER_open_room(), and iterate_reset_room().

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

◆ send_enter_room()

static void send_enter_room ( struct GNUNET_MESSENGER_Handle handle,
struct GNUNET_MESSENGER_Room room,
const struct GNUNET_PeerIdentity door 
)
static

Definition at line 287 of file messenger_api.c.

290 {
292  struct GNUNET_MQ_Envelope *env;
293 
295  GNUNET_memcpy(&(msg->door), door, sizeof(*door));
296  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
298 }

References env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, GNUNET_MESSENGER_Room::key, GNUNET_DNS_Handle::mq, and msg.

Referenced by GNUNET_MESSENGER_enter_room(), and iterate_reset_room().

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

◆ send_close_room()

static void send_close_room ( struct GNUNET_MESSENGER_Handle handle,
struct GNUNET_MESSENGER_Room room 
)
static

Definition at line 301 of file messenger_api.c.

303 {
305  struct GNUNET_MQ_Envelope *env;
306 
308  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
310 }

References env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, GNUNET_MESSENGER_Room::key, GNUNET_DNS_Handle::mq, and msg.

Referenced by GNUNET_MESSENGER_close_room(), and iterate_close_room().

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

◆ iterate_reset_room()

static int iterate_reset_room ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 313 of file messenger_api.c.

316 {
317  struct GNUNET_MESSENGER_Handle *handle = cls;
318  struct GNUNET_MESSENGER_Room *room = value;
319 
320  if (GNUNET_YES == room->opened)
321  send_open_room (handle, room);
322 
323  struct GNUNET_MESSENGER_ListTunnel *entry = room->entries.head;
324 
325  struct GNUNET_PeerIdentity door;
326 
327  while (entry)
328  {
329  GNUNET_PEER_resolve (entry->peer, &door);
330 
331  send_enter_room (handle, room, &door);
332 
333  entry = entry->next;
334  }
335 
336  return GNUNET_YES;
337 }
static char * value
Value of the record to add/remove.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
static void send_enter_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_PeerIdentity *door)
static void send_open_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
struct GNUNET_MESSENGER_ListTunnel * next
struct GNUNET_MESSENGER_ListTunnel * head
struct GNUNET_MESSENGER_ListTunnels entries

References GNUNET_MESSENGER_Room::entries, GNUNET_PEER_resolve(), GNUNET_YES, handle, GNUNET_MESSENGER_ListTunnels::head, GNUNET_MESSENGER_ListTunnel::next, GNUNET_MESSENGER_Room::opened, GNUNET_MESSENGER_ListTunnel::peer, send_enter_room(), send_open_room(), and value.

Referenced by callback_reconnect().

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

◆ callback_reconnect()

static void callback_reconnect ( void *  cls)
static

Definition at line 340 of file messenger_api.c.

341 {
342  struct GNUNET_MESSENGER_Handle *handle = cls;
343 
344  handle->reconnect_task = NULL;
345  handle->reconnect_time = GNUNET_TIME_STD_BACKOFF(handle->reconnect_time)
346  ;
347 
348  reconnect (handle);
349 
351 }
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static int iterate_reset_room(void *cls, const struct GNUNET_HashCode *key, void *value)
static void reconnect(struct GNUNET_MESSENGER_Handle *handle)
struct GNUNET_SCHEDULER_Task * reconnect_task
Task to reconnect to the service.
Definition: dns_api.c:81

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_TIME_STD_BACKOFF, handle, iterate_reset_room(), reconnect(), and GNUNET_DNS_Handle::reconnect_task.

Referenced by callback_mq_error().

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

◆ iterate_close_room()

static int iterate_close_room ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 354 of file messenger_api.c.

357 {
358  struct GNUNET_MESSENGER_Handle *handle = cls;
359  struct GNUNET_MESSENGER_Room *room = value;
360 
361  send_close_room (handle, room);
362 
363  return GNUNET_YES;
364 }
static void send_close_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)

References GNUNET_YES, handle, send_close_room(), and value.

Referenced by callback_mq_error().

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

◆ callback_mq_error()

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

Definition at line 367 of file messenger_api.c.

369 {
370  struct GNUNET_MESSENGER_Handle *handle = cls;
371 
372  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
373 
375 
376  if (handle->mq)
377  {
379  handle->mq = NULL;
380  }
381 
383 }
@ GNUNET_ERROR_TYPE_ERROR
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685
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:1254
static void callback_reconnect(void *cls)
static int iterate_close_room(void *cls, const struct GNUNET_HashCode *key, void *value)

References callback_reconnect(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), handle, iterate_close_room(), GNUNET_DNS_Handle::mq, and GNUNET_DNS_Handle::reconnect_task.

Referenced by reconnect().

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

◆ get_non_anonymous_key()

static const struct GNUNET_IDENTITY_PublicKey* get_non_anonymous_key ( const struct GNUNET_IDENTITY_PublicKey public_key)
static

Definition at line 531 of file messenger_api.c.

532 {
533  if (0 == GNUNET_memcmp(public_key, get_anonymous_public_key()))
534  return NULL;
535 
536  return public_key;
537 }
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
const struct GNUNET_IDENTITY_PublicKey * get_anonymous_public_key()
Returns the public identity key of GNUNET_IDENTITY_ego_get_anonymous() without recalculating it every...

References get_anonymous_public_key(), and GNUNET_memcmp.

Referenced by GNUNET_MESSENGER_contact_get_key(), GNUNET_MESSENGER_get_key(), and GNUNET_MESSENGER_send_message().

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

◆ iterate_find_room()

static int iterate_find_room ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 617 of file messenger_api.c.

620 {
621  struct GNUNET_MESSENGER_RoomFind *find = cls;
622  struct GNUNET_MESSENGER_Room *room = value;
623 
624  if ((find->counter > 0) && ((!find->contact) || (GNUNET_YES == find_room_member(room, find->contact))))
625  {
626  find->counter--;
627 
628  if (!find->callback)
629  return GNUNET_YES;
630 
631  return find->callback(find->cls, room, find->contact);
632  }
633  else
634  return GNUNET_NO;
635 }
int find_room_member(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
Checks through all members of a given room if a specific contact is found and returns a result depend...
GNUNET_MESSENGER_MemberCallback callback
const struct GNUNET_MESSENGER_Contact * contact

References GNUNET_MESSENGER_RoomFind::callback, GNUNET_MESSENGER_RoomFind::cls, GNUNET_MESSENGER_RoomFind::contact, GNUNET_MESSENGER_RoomFind::counter, find_room_member(), GNUNET_NO, GNUNET_YES, and value.

Referenced by GNUNET_MESSENGER_find_rooms().

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