GNUnet  0.11.x
Data Structures | Functions
gnunet-service-messenger_handle.c File Reference

GNUnet MESSENGER service. More...

#include "gnunet-service-messenger_handle.h"
#include "gnunet-service-messenger.h"
#include "gnunet-service-messenger_message_kind.h"
#include "messenger_api_util.h"
Include dependency graph for gnunet-service-messenger_handle.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_MessageHandle
 

Functions

struct GNUNET_MESSENGER_SrvHandlecreate_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
 Creates and allocates a new handle related to a service and using a given mq (message queue). More...
 
int iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 Destroys a handle and frees its memory fully. More...
 
void get_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
 Writes the path of the directory for a given handle using a specific name to the parameter dir. More...
 
static int create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 
const struct GNUNET_ShortHashCodeget_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Returns the member id of a given handle in a specific room. More...
 
int change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
 Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success. More...
 
static void change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 
static void change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
 
static int iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void set_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
 Sets the EGO used by a given handle. More...
 
const struct GNUNET_MESSENGER_Egoget_handle_ego (const struct GNUNET_MESSENGER_SrvHandle *handle)
 Returns the EGO used by a given handle. More...
 
static void callback_setup_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 
void setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 Tries to set the name and EGO key of a handle initially by looking up a specific name. More...
 
static void callback_update_handle (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 
void update_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 Tries to change the key pair of an EGO of a handle under the same name and informs all rooms about the change automatically. More...
 
static void callback_set_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 
void set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 Tries to rename the handle which implies renaming the EGO its using and moving all related data into the directory fitting to the changed name. More...
 
int open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Makes a given handle a member of the room using a specific key and opens the room from the handles service. More...
 
int entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
 Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity). More...
 
int close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it. More...
 
int send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
 Sends a message from a given handle to the room using a specific key. More...
 
static const struct GNUNET_HashCodeget_next_member_session_contect (const struct GNUNET_MESSENGER_MemberSession *session)
 
static const struct GNUNET_MESSENGER_MemberSessionget_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 
void notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 Notifies the handle that a new message was received or sent. More...
 
static int callback_scan_for_rooms (void *cls, const char *filename)
 
void load_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
 Loads member ids and other potential configuration from a given handle which depends on the given name the handle uses. More...
 
static int iterate_save_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void save_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
 Saves member ids and other potential configuration from a given handle which depends on the given name the handle uses. More...
 

Detailed Description

GNUnet MESSENGER service.

Author
Tobias Frisch

Definition in file gnunet-service-messenger_handle.c.

Function Documentation

◆ create_handle()

struct GNUNET_MESSENGER_SrvHandle* create_handle ( struct GNUNET_MESSENGER_Service service,
struct GNUNET_MQ_Handle mq 
)

Creates and allocates a new handle related to a service and using a given mq (message queue).

Parameters
[in/out]service MESSENGER Service
[in/out]mq Message queue
Returns
New handle

Definition at line 34 of file gnunet-service-messenger_handle.c.

36 {
37  GNUNET_assert((service) && (mq));
38 
40 
41  handle->service = service;
42  handle->mq = mq;
43 
44  handle->name = NULL;
45  handle->ego = NULL;
46 
48 
49  return handle;
50 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
@ GNUNET_NO
Definition: gnunet_common.h:94
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#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.
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_new, GNUNET_NO, handle, mq, GNUNET_DNS_Handle::mq, and service.

Referenced by add_service_handle(), and GNUNET_MESSENGER_connect().

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

◆ iterate_free_member_ids()

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

Definition at line 53 of file gnunet-service-messenger_handle.c.

56 {
58 
59  return GNUNET_YES;
60 }
static char * value
Value of the record to add/remove.
@ GNUNET_YES
Definition: gnunet_common.h:97
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_free, GNUNET_YES, and value.

Referenced by destroy_handle().

Here is the caller graph for this function:

◆ destroy_handle()

void destroy_handle ( struct GNUNET_MESSENGER_SrvHandle handle)

Destroys a handle and frees its memory fully.

Parameters
[in/out]handle Handle

Definition at line 63 of file gnunet-service-messenger_handle.c.

64 {
66 
67  if (handle->service->dir)
69 
70  if (handle->name)
71  GNUNET_free(handle->name);
72 
75 
77 }
int iterate_free_member_ids(void *cls, const struct GNUNET_HashCode *key, void *value)
void save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
Saves member ids and other potential configuration from a given handle which depends on the given nam...
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, handle, iterate_free_member_ids(), and save_handle_configuration().

Referenced by clear_list_handles(), GNUNET_MESSENGER_connect(), GNUNET_MESSENGER_disconnect(), and remove_service_handle().

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

◆ get_handle_data_subdir()

void get_handle_data_subdir ( const struct GNUNET_MESSENGER_SrvHandle handle,
const char *  name,
char **  dir 
)

Writes the path of the directory for a given handle using a specific name to the parameter dir.

This directory will be used to store data regarding the handle and its messages.

Parameters
[in]handleHandle
[in]namePotential name of the handle
[out]dirPath to store data

Definition at line 80 of file gnunet-service-messenger_handle.c.

83 {
84  GNUNET_assert((handle) && (dir));
85 
86  if (name)
87  GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
89  else
90  GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
92 }
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define DIR_SEPARATOR
Definition: platform.h:164
const char * name

References dir, DIR_SEPARATOR, GNUNET_asprintf(), GNUNET_assert, handle, and name.

Referenced by callback_set_handle_name(), iterate_save_rooms(), load_handle_configuration(), and save_handle_configuration().

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

◆ create_handle_member_id()

static int create_handle_member_id ( const struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)
static

Definition at line 95 of file gnunet-service-messenger_handle.c.

97 {
98  GNUNET_assert((handle) && (key));
99 
100  struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
101 
102  if (!random_id)
103  return GNUNET_NO;
104 
105  generate_free_member_id (random_id, NULL);
106 
107  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, random_id,
109  {
110  GNUNET_free(random_id);
111  return GNUNET_NO;
112  }
113 
114  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (random_id),
115  GNUNET_h2s (key));
116 
117  return GNUNET_YES;
118 }
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_log(kind,...)
@ GNUNET_OK
Definition: gnunet_common.h:95
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_INFO
int generate_free_member_id(struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
Tries to generate an unused member id and store it into the id parameter.
A 256-bit hashcode.

References generate_free_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, handle, and key.

Referenced by entry_handle_room(), and open_handle_room().

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

◆ get_handle_member_id()

const struct GNUNET_ShortHashCode* get_handle_member_id ( const struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Returns the member id of a given handle in a specific room.

If the handle is not a member of the specific room, NULL gets returned.

Parameters
[in]handleHandle
[in]keyKey of a room
Returns
Member id or NULL

Definition at line 121 of file gnunet-service-messenger_handle.c.

123 {
124  GNUNET_assert((handle) && (key));
125 
126  return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
127 }
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.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), handle, and key.

Referenced by close_handle_room(), close_service_room(), entry_handle_room(), find_list_handle_by_member(), get_handle_member_session(), handle_get_message(), handle_room_close(), handle_room_entry(), handle_room_open(), join_room_locally(), notify_handle_message(), open_handle_room(), open_room(), pack_room_message(), send_handle_message(), send_room_message(), and solve_room_member_collisions().

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

◆ change_handle_member_id()

int change_handle_member_id ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_ShortHashCode unique_id 
)

Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success.

The client connected to the handle will be informed afterwards automatically.

Parameters
[in/out]handle Handle
[in]keyKey of a room
[in]unique_idUnique member id
Returns
GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 130 of file gnunet-service-messenger_handle.c.

133 {
134  GNUNET_assert((handle) && (key) && (unique_id));
135 
136  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
137 
138  if (!member_id)
139  {
140  member_id = GNUNET_new(struct GNUNET_ShortHashCode);
141  GNUNET_memcpy(member_id, unique_id, sizeof(*member_id));
142 
143  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, member_id,
145  {
146  GNUNET_free(member_id);
147  return GNUNET_SYSERR;
148  }
149  }
150 
151  if (0 == GNUNET_memcmp(unique_id, member_id))
152  goto send_message_to_client;
153 
154  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (member_id),
155  GNUNET_h2s (key));
156 
157  GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
158 
159  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n", GNUNET_sh2s (unique_id));
160 
162  struct GNUNET_MQ_Envelope *env;
163 
164 send_message_to_client:
165 
167 
168  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
169  GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
170 
172  return GNUNET_OK;
173 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
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:355
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
Message to receive the current member id of a handle in room.

References env, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, handle, key, GNUNET_DNS_Handle::mq, and msg.

Referenced by callback_scan_for_rooms(), join_room(), and send_message_id().

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

◆ change_handle_name()

static void change_handle_name ( struct GNUNET_MESSENGER_SrvHandle handle,
const char *  name 
)
static

Definition at line 176 of file gnunet-service-messenger_handle.c.

178 {
180 
181  if (handle->name)
182  GNUNET_free(handle->name);
183 
184  handle->name = name ? GNUNET_strdup(name) : NULL;
185 
186  const uint16_t name_len = handle->name ? strlen (handle->name) : 0;
187 
189  struct GNUNET_MQ_Envelope *env;
190 
192 
193  char *extra = ((char*) msg) + sizeof(*msg);
194 
195  if (name_len)
196  GNUNET_memcpy(extra, handle->name, name_len);
197 
198  extra[name_len] = '\0';
199 
201 }
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:52
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME
Message to receive the current name of a handle.

References env, GNUNET_assert, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_strdup, handle, GNUNET_DNS_Handle::mq, msg, and name.

Referenced by callback_set_handle_name(), callback_setup_handle_name(), and set_handle_name().

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

◆ change_handle_ego()

static void change_handle_ego ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_MESSENGER_Ego ego 
)
static

Definition at line 204 of file gnunet-service-messenger_handle.c.

206 {
208 
209  handle->ego = ego;
210 
211  ego = get_handle_ego (handle);
212 
213  const uint16_t length = GNUNET_IDENTITY_key_get_length(&(ego->pub));
214 
216  struct GNUNET_MQ_Envelope *env;
217 
219 
220  char *extra = ((char*) msg) + sizeof(*msg);
221 
222  if (GNUNET_IDENTITY_write_key_to_buffer(&(ego->pub), extra, length) < 0)
223  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Could not write key to buffer.\n");
224 
226 }
const struct GNUNET_MESSENGER_Ego * get_handle_ego(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the EGO used by a given handle.
ssize_t GNUNET_IDENTITY_write_key_to_buffer(const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
Writes a GNUNET_IDENTITY_PublicKey to a compact buffer.
ssize_t GNUNET_IDENTITY_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:976
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY
struct GNUNET_IDENTITY_PublicKey pub
Message to receive the current public key of a handle.

References env, get_handle_ego(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_key_get_length(), GNUNET_IDENTITY_write_key_to_buffer(), GNUNET_log, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), handle, GNUNET_DNS_Handle::mq, msg, and GNUNET_MESSENGER_Ego::pub.

Referenced by callback_setup_handle_name(), callback_update_handle(), and set_handle_ego().

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

◆ iterate_send_message()

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

Definition at line 235 of file gnunet-service-messenger_handle.c.

238 {
239  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
240 
241  send_handle_message (msg_handle->handle, key, msg_handle->message);
242 
243  return GNUNET_YES;
244 }
int send_handle_message(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle to the room using a specific key.
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_MESSENGER_Message * message

References GNUNET_YES, GNUNET_MESSENGER_MessageHandle::handle, key, GNUNET_MESSENGER_MessageHandle::message, and send_handle_message().

Referenced by callback_set_handle_name(), and set_handle_ego().

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

◆ set_handle_ego()

void set_handle_ego ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_MESSENGER_Ego ego 
)

Sets the EGO used by a given handle.

Parameters
[in/out]handle Handle
[in]egoEGO key pair

Definition at line 247 of file gnunet-service-messenger_handle.c.

249 {
250  GNUNET_assert((handle) && (ego));
251 
252  struct GNUNET_MESSENGER_MessageHandle msg_handle;
253 
254  msg_handle.handle = handle;
255  msg_handle.message = create_message_key (&(ego->priv));
256 
258 
259  destroy_message (msg_handle.message);
260 
261  change_handle_ego (handle, ego);
262 }
static int iterate_send_message(void *cls, const struct GNUNET_HashCode *key, void *value)
static void change_handle_ego(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
struct GNUNET_MESSENGER_Message * create_message_key(const struct GNUNET_IDENTITY_PrivateKey *key)
Creates and allocates a new key message containing the public key to change to derived from its priva...
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
struct GNUNET_IDENTITY_PrivateKey priv

References change_handle_ego(), create_message_key(), destroy_message(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), handle, GNUNET_MESSENGER_MessageHandle::handle, iterate_send_message(), GNUNET_MESSENGER_MessageHandle::message, and GNUNET_MESSENGER_Ego::priv.

Referenced by callback_ego_create().

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

◆ get_handle_ego()

const struct GNUNET_MESSENGER_Ego* get_handle_ego ( const struct GNUNET_MESSENGER_SrvHandle handle)

Returns the EGO used by a given handle.

Parameters
[in]handleHandle
Returns
EGO key pair

Definition at line 265 of file gnunet-service-messenger_handle.c.

266 {
268 
269  static struct GNUNET_MESSENGER_Ego anonymous;
270  static int read_keys = 0;
271 
272  if (handle->ego)
273  return handle->ego;
274 
275  if (!read_keys)
276  {
278  GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key (ego), sizeof(anonymous.priv));
279  GNUNET_IDENTITY_ego_get_public_key (ego, &(anonymous.pub));
280  read_keys = 1;
281  }
282 
283  return &anonymous;
284 }
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:639
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:652
struct GNUNET_IDENTITY_Ego * GNUNET_IDENTITY_ego_get_anonymous()
Obtain the ego representing 'anonymous' users.
Definition: identity_api.c:156
Handle for an ego.
Definition: identity.h:37

References GNUNET_assert, GNUNET_IDENTITY_ego_get_anonymous(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_memcpy, handle, GNUNET_MESSENGER_Ego::priv, and GNUNET_MESSENGER_Ego::pub.

Referenced by change_handle_ego(), get_handle_member_session(), handle_get_message(), join_room(), join_room_locally(), notify_handle_message(), pack_room_message(), recv_message_info(), send_room_info(), and solve_room_member_collisions().

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

◆ callback_setup_handle_name()

static void callback_setup_handle_name ( void *  cls,
const char *  name,
const struct GNUNET_MESSENGER_Ego ego 
)
static

Definition at line 287 of file gnunet-service-messenger_handle.c.

290 {
291  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
292 
293  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting up handle...\n");
294 
297 
298  if (handle->service->dir)
300 }
void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
Loads member ids and other potential configuration from a given handle which depends on the given nam...
static void change_handle_name(struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
@ GNUNET_ERROR_TYPE_DEBUG
const struct GNUNET_MESSENGER_Ego * ego

References change_handle_ego(), change_handle_name(), GNUNET_MESSENGER_SrvHandle::ego, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, load_handle_configuration(), and name.

Referenced by setup_handle_name().

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

◆ setup_handle_name()

void setup_handle_name ( struct GNUNET_MESSENGER_SrvHandle handle,
const char *  name 
)

Tries to set the name and EGO key of a handle initially by looking up a specific name.

Parameters
[in/out]handle Handle
[in]nameName (optionally: valid EGO name)

Definition at line 303 of file gnunet-service-messenger_handle.c.

305 {
307 
308  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
309 
311 }
void lookup_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier, GNUNET_MESSENGER_EgoLookupCallback lookup, void *cls)
Lookups an EGO which was registered to a store under a specific identifier.
static void callback_setup_handle_name(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
struct GNUNET_MESSENGER_EgoStore * get_service_ego_store(struct GNUNET_MESSENGER_Service *service)
Returns the used EGO-store of a given service.

References callback_setup_handle_name(), get_service_ego_store(), GNUNET_assert, handle, lookup_store_ego(), and name.

Referenced by handle_create().

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

◆ callback_update_handle()

static void callback_update_handle ( void *  cls,
const char *  name,
const struct GNUNET_MESSENGER_Ego ego 
)
static

Definition at line 314 of file gnunet-service-messenger_handle.c.

317 {
318  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
319 
320  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating handle...\n");
321 
322  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
323 
324  if (!ego)
325  create_store_ego(store, handle->name, handle);
326  else
327  change_handle_ego (handle, ego);
328 }
void create_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier, void *handle)
Creates a new EGO which will be registered to a store under a specific identifier.

References change_handle_ego(), create_store_ego(), get_service_ego_store(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and handle.

Referenced by update_handle().

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

◆ update_handle()

void update_handle ( struct GNUNET_MESSENGER_SrvHandle handle)

Tries to change the key pair of an EGO of a handle under the same name and informs all rooms about the change automatically.

Parameters
[in/out]handle Handle

Definition at line 331 of file gnunet-service-messenger_handle.c.

332 {
334 
335  if (!handle->name)
336  {
337  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating handle failed: Name is required!\n");
338  return;
339  }
340 
341  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
342 
344 }
static void callback_update_handle(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)

References callback_update_handle(), get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, handle, and lookup_store_ego().

Referenced by handle_update().

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

◆ callback_set_handle_name()

static void callback_set_handle_name ( void *  cls,
const char *  name,
const struct GNUNET_MESSENGER_Ego ego 
)
static

Definition at line 347 of file gnunet-service-messenger_handle.c.

350 {
351  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
352 
353  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Renaming handle...\n");
354 
355  if (ego)
356  {
357  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is occupied! (%s)\n", name);
358  return;
359  }
360 
361  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
362 
363  int rename_ego_in_store = handle->ego? GNUNET_YES : GNUNET_NO;
364 
365  char *old_dir;
366  get_handle_data_subdir (handle, handle->name, &old_dir);
367 
368  char *new_dir;
369  get_handle_data_subdir (handle, name, &new_dir);
370 
371  int result = 0;
372 
374  {
376 
377  result = rename (old_dir, new_dir);
378  }
379  else if (GNUNET_YES == GNUNET_DISK_directory_test (new_dir, GNUNET_NO))
380  result = -1;
381 
382  if (0 == result)
383  {
384  struct GNUNET_MESSENGER_MessageHandle msg_handle;
385 
386  msg_handle.handle = handle;
387  msg_handle.message = create_message_name (name);
388 
390 
391  destroy_message (msg_handle.message);
392 
394  }
395  else
396  rename_ego_in_store = GNUNET_NO;
397 
398  GNUNET_free(old_dir);
399  GNUNET_free(new_dir);
400 
401  if (GNUNET_YES == rename_ego_in_store)
402  rename_store_ego(store, handle->name, name);
403 }
static int result
Global testing status.
void rename_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *old_identifier, const char *new_identifier)
Updates the location of a registered EGO in a store to a different one under a specific new_identifie...
void get_handle_data_subdir(const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
Writes the path of the directory for a given handle using a specific name to the parameter dir.
struct GNUNET_MESSENGER_Message * create_message_name(const char *name)
Creates and allocates a new name message containing the name to change to.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:404
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
@ GNUNET_ERROR_TYPE_ERROR

References change_handle_name(), create_message_name(), destroy_message(), GNUNET_MESSENGER_SrvHandle::ego, get_handle_data_subdir(), get_service_ego_store(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_YES, handle, GNUNET_MESSENGER_MessageHandle::handle, iterate_send_message(), GNUNET_MESSENGER_MessageHandle::message, name, rename_store_ego(), and result.

Referenced by set_handle_name().

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

◆ set_handle_name()

void set_handle_name ( struct GNUNET_MESSENGER_SrvHandle handle,
const char *  name 
)

Tries to rename the handle which implies renaming the EGO its using and moving all related data into the directory fitting to the changed name.

The client connected to the handle will be informed afterwards automatically.

Parameters
[in/out]handle Handle
[in]nameNew name

Definition at line 406 of file gnunet-service-messenger_handle.c.

408 {
410 
411  if (!name)
412  {
413  if (handle->ego)
414  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is required!\n");
415  else
417 
418  return;
419  }
420 
421  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
422 
424 }
static void callback_set_handle_name(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)

References callback_set_handle_name(), change_handle_name(), get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, handle, lookup_store_ego(), and name.

Referenced by handle_get_name(), and handle_set_name().

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

◆ open_handle_room()

int open_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Makes a given handle a member of the room using a specific key and opens the room from the handles service.

Parameters
[in/out]handle Handle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 427 of file gnunet-service-messenger_handle.c.

429 {
430  GNUNET_assert((handle) && (key));
431 
433  return GNUNET_NO;
434 
435  return open_service_room (handle->service, handle, key);
436 }
static int create_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
const struct GNUNET_ShortHashCode * get_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns the member id of a given handle in a specific room.
int open_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to open a room using a given key for a service by a specific handle.

References create_handle_member_id(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, handle, key, and open_service_room().

Referenced by handle_room_open().

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

◆ entry_handle_room()

int entry_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_PeerIdentity door,
const struct GNUNET_HashCode key 
)

Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity).

Parameters
[in/out]handle Handle
[in]doorPeer identity
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 439 of file gnunet-service-messenger_handle.c.

442 {
443  GNUNET_assert((handle) && (door) && (key));
444 
446  return GNUNET_NO;
447 
448  return entry_service_room (handle->service, handle, door, key);
449 }
int entry_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Tries to enter a room using a given key for a service by a specific handle.

References create_handle_member_id(), entry_service_room(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, handle, and key.

Referenced by handle_room_entry().

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

◆ close_handle_room()

int close_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it.

Parameters
[in/out]handle Handle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 452 of file gnunet-service-messenger_handle.c.

454 {
455  GNUNET_assert((handle) && (key));
456 
458  return GNUNET_NO;
459 
460  return close_service_room (handle->service, handle, key);
461 }
int close_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to close a room using a given key for a service by a specific handle.

References close_service_room(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, handle, and key.

Referenced by handle_room_close().

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

◆ send_handle_message()

int send_handle_message ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_MESSENGER_Message message 
)

Sends a message from a given handle to the room using a specific key.

Parameters
[in/out]handle Handle
[in]keyKey of a room
[in]messageMessage
Returns
GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

Definition at line 464 of file gnunet-service-messenger_handle.c.

467 {
468  GNUNET_assert((handle) && (key) && (message));
469 
470  const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, key);
471 
472  if (!id)
473  {
474  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "It is required to be a member of a room to send messages!\n");
475  return GNUNET_NO;
476  }
477 
478  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service, key);
479 
480  if (!room)
481  {
482  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n", GNUNET_h2s (key));
483  return GNUNET_NO;
484  }
485 
486  struct GNUNET_MESSENGER_Message *msg = copy_message(message);
487 
488  GNUNET_memcpy(&(msg->header.sender_id), id, sizeof(*id));
489 
490  return send_room_message (room, handle, msg);
491 }
int send_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.
struct GNUNET_MESSENGER_SrvRoom * get_service_room(const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
Returns the room identified by a given key for a service.
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.

References copy_message(), get_handle_member_id(), get_service_room(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, handle, key, msg, and send_room_message().

Referenced by handle_send_message(), and iterate_send_message().

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

◆ get_next_member_session_contect()

static const struct GNUNET_HashCode* get_next_member_session_contect ( const struct GNUNET_MESSENGER_MemberSession session)
static

Definition at line 494 of file gnunet-service-messenger_handle.c.

495 {
496  if (session->next)
497  return get_next_member_session_contect (session->next);
498  else
499  return get_member_session_context(session);
500 }
static const struct GNUNET_HashCode * get_next_member_session_contect(const struct GNUNET_MESSENGER_MemberSession *session)
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
struct GNUNET_MESSENGER_MemberSession * next

References get_member_session_context(), and GNUNET_MESSENGER_MemberSession::next.

Referenced by notify_handle_message().

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

◆ get_handle_member_session()

static const struct GNUNET_MESSENGER_MemberSession* get_handle_member_session ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)
static

Definition at line 503 of file gnunet-service-messenger_handle.c.

505 {
506  GNUNET_assert((handle) && (key) && (handle->service));
507 
509  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room(handle->service, key);
510 
511  if ((!id) || (!room))
512  return NULL;
513 
515  struct GNUNET_MESSENGER_Member *member = get_store_member(store, id);
516 
517  const struct GNUNET_MESSENGER_Ego *ego = get_handle_ego(handle);
518 
519  if (!ego)
520  return NULL;
521 
522  return get_member_session(member, &(ego->pub));
523 }
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
struct GNUNET_MESSENGER_Member * get_store_member(const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Returns the member in a store identified by a given id.
struct GNUNET_MESSENGER_MemberStore * get_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
struct GNUNET_MESSENGER_MemberStore * store

References get_handle_ego(), get_handle_member_id(), get_member_session(), get_room_member_store(), get_service_room(), get_store_member(), GNUNET_assert, handle, key, GNUNET_MESSENGER_Ego::pub, GNUNET_MESSENGER_MemberStore::room, and GNUNET_MESSENGER_Member::store.

Referenced by notify_handle_message().

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

◆ notify_handle_message()

void notify_handle_message ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_MESSENGER_MemberSession session,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

Notifies the handle that a new message was received or sent.

Parameters
[in/out]handle Handle
[in]keyKey of room
[in]sessionMember session
[in]messageMessage
[in]hashHash of message

Definition at line 526 of file gnunet-service-messenger_handle.c.

531 {
532  GNUNET_assert((handle) && (key) && (session) && (message) && (hash));
533 
534  if ((!handle->mq) || (!get_handle_member_id (handle, key)))
535  {
536  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
537  return;
538  }
539 
540  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->contact);
541 
542  struct GNUNET_HashCode sender;
543  GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
544 
545  const struct GNUNET_HashCode *context = get_next_member_session_contect (session);
546 
547  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying client about message: %s\n", GNUNET_h2s (hash));
548 
549  struct GNUNET_MESSENGER_Message *private_message = NULL;
550 
551  if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
552  {
553  private_message = copy_message(message);
554 
555  if (GNUNET_YES != decrypt_message(private_message, &(get_handle_ego(handle)->priv)))
556  {
557  destroy_message(private_message);
558  private_message = NULL;
559  }
560  else
561  message = private_message;
562  }
563 
565  struct GNUNET_MQ_Envelope *env;
566 
567  uint16_t length = get_message_size (message, GNUNET_YES);
568 
570 
571  GNUNET_memcpy(&(msg->key), key, sizeof(msg->key));
572  GNUNET_memcpy(&(msg->sender), &sender, sizeof(msg->sender));
573  GNUNET_memcpy(&(msg->context), context, sizeof(msg->context));
574  GNUNET_memcpy(&(msg->hash), hash, sizeof(msg->hash));
575 
576  msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
577 
578  if (get_handle_member_session(handle, key) == session)
579  msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
580 
581  if (private_message)
582  msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PRIVATE;
583 
584  char *buffer = ((char*) msg) + sizeof(*msg);
585  encode_message (message, length, buffer, GNUNET_YES);
586 
587  if (private_message)
588  destroy_message(private_message);
589 
591 }
static pa_context * context
Pulseaudio context.
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
static const struct GNUNET_MESSENGER_MemberSession * get_handle_member_session(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
const struct GNUNET_IDENTITY_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given contact.
int decrypt_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key)
Decrypts a private message using a given private key and replaces its body and kind with the inner en...
uint16_t get_message_size(const struct GNUNET_MESSENGER_Message *message, int include_signature)
Returns the exact size in bytes to encode a given message.
void encode_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, int include_signature)
Encodes a given message into a buffer of a maximal length in bytes.
A 512-bit hashcode.
An identity key as per LSD0001.
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_MESSENGER_MessageHeader header
Header.
Message to receive something from a room.

References GNUNET_MESSENGER_MemberSession::contact, context, copy_message(), decrypt_message(), destroy_message(), encode_message(), env, get_contact_key(), get_handle_ego(), get_handle_member_id(), get_handle_member_session(), get_message_size(), get_next_member_session_contect(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_DNS_Handle::mq, msg, and pubkey.

Referenced by callback_found_message(), handle_service_message(), and notify_about_members().

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

◆ callback_scan_for_rooms()

static int callback_scan_for_rooms ( void *  cls,
const char *  filename 
)
static

Definition at line 594 of file gnunet-service-messenger_handle.c.

596 {
597  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
598 
600 
602  {
603  struct GNUNET_HashCode key;
604  struct GNUNET_ShortHashCode member_id;
605 
606  if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "key", &key, sizeof(key))) &&
607  (GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "member_id", &member_id, sizeof(member_id))))
608  change_handle_member_id (handle, &key, &member_id);
609  }
610 
612  return GNUNET_OK;
613 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * filename
int change_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_data(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, void *buf, size_t buf_size)
Get Crockford32-encoded fixed-size binary data from a configuration.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Parse a configuration file, add all of the options in the file to the configuration environment.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482

References cfg, change_handle_member_id(), filename, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_parse(), GNUNET_DISK_file_test(), GNUNET_OK, GNUNET_YES, handle, and key.

Referenced by load_handle_configuration().

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

◆ load_handle_configuration()

void load_handle_configuration ( struct GNUNET_MESSENGER_SrvHandle handle)

Loads member ids and other potential configuration from a given handle which depends on the given name the handle uses.

Parameters
[out]handleHandle

Definition at line 616 of file gnunet-service-messenger_handle.c.

617 {
619 
620  char *id_dir;
621  get_handle_data_subdir (handle, handle->name, &id_dir);
622 
624  {
625  char *scan_dir;
626  GNUNET_asprintf (&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
627 
630 
632  }
633 
634  GNUNET_free(id_dir);
635 }
static int callback_scan_for_rooms(void *cls, const char *filename)
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814

References callback_scan_for_rooms(), DIR_SEPARATOR, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_OK, GNUNET_YES, handle, and find_typedefs::scan_dir().

Referenced by callback_setup_handle_name().

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

◆ iterate_save_rooms()

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

Definition at line 638 of file gnunet-service-messenger_handle.c.

641 {
642  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
643  struct GNUNET_ShortHashCode *member_id = value;
644 
645  char *id_dir;
646  get_handle_data_subdir (handle, handle->name, &id_dir);
647 
648  char *filename;
649  GNUNET_asprintf (&filename, "%s%s%c%s.cfg", id_dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (key));
650 
651  GNUNET_free(id_dir);
652 
654 
655  char *key_data = GNUNET_STRINGS_data_to_string_alloc (key, sizeof(*key));
656 
657  if (key_data)
658  {
659  GNUNET_CONFIGURATION_set_value_string (cfg, "room", "key", key_data);
660 
661  GNUNET_free(key_data);
662  }
663 
664  char *member_id_data = GNUNET_STRINGS_data_to_string_alloc (member_id, sizeof(*member_id));
665 
666  if (member_id_data)
667  {
668  GNUNET_CONFIGURATION_set_value_string (cfg, "room", "member_id", member_id_data);
669 
670  GNUNET_free(member_id_data);
671  }
672 
675 
677 
678  return GNUNET_YES;
679 }
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:750

References cfg, DIR_SEPARATOR, filename, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_free, GNUNET_h2s(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, handle, key, and value.

Referenced by save_handle_configuration().

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

◆ save_handle_configuration()

void save_handle_configuration ( struct GNUNET_MESSENGER_SrvHandle handle)

Saves member ids and other potential configuration from a given handle which depends on the given name the handle uses.

Parameters
[in]handleHandle

Definition at line 682 of file gnunet-service-messenger_handle.c.

683 {
685 
686  char *id_dir;
687  get_handle_data_subdir (handle, handle->name, &id_dir);
688 
690  == GNUNET_DISK_directory_create (id_dir)))
691  {
692  char *save_dir;
693  GNUNET_asprintf (&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
694 
695  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
696  (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
698 
699  GNUNET_free(save_dir);
700  }
701 
702  GNUNET_free(id_dir);
703 }
static int iterate_save_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496

References DIR_SEPARATOR, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_YES, handle, and iterate_save_rooms().

Referenced by destroy_handle().

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