[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnunet] 03/06: MESSENGER: Uncrustify code
|
From: |
gnunet |
|
Subject: |
[gnunet] 03/06: MESSENGER: Uncrustify code |
|
Date: |
Tue, 14 Nov 2023 17:59:16 +0100 |
This is an automated email from the git hooks/post-receive script.
thejackimonster pushed a commit to branch master
in repository gnunet.
commit e60834efb1e50717351e683142d0e57d6b537ee2
Author: TheJackiMonster <thejackimonster@gmail.com>
AuthorDate: Fri Nov 10 23:23:45 2023 +0100
MESSENGER: Uncrustify code
Signed-off-by: TheJackiMonster <thejackimonster@gmail.com>
---
src/messenger/gnunet-messenger.c | 92 ++-
src/messenger/gnunet-service-messenger.c | 71 ++-
src/messenger/gnunet-service-messenger_basement.c | 6 +-
src/messenger/gnunet-service-messenger_ego_store.c | 215 ++++---
src/messenger/gnunet-service-messenger_handle.c | 276 +++++----
src/messenger/gnunet-service-messenger_handle.h | 4 +-
.../gnunet-service-messenger_list_handles.c | 35 +-
.../gnunet-service-messenger_list_messages.c | 75 +--
src/messenger/gnunet-service-messenger_member.c | 168 ++++--
src/messenger/gnunet-service-messenger_member.h | 4 +-
.../gnunet-service-messenger_member_session.c | 507 +++++++++-------
.../gnunet-service-messenger_member_session.h | 40 +-
.../gnunet-service-messenger_member_store.c | 96 ++--
.../gnunet-service-messenger_member_store.h | 8 +-
.../gnunet-service-messenger_message_handle.c | 83 +--
.../gnunet-service-messenger_message_kind.c | 40 +-
.../gnunet-service-messenger_message_recv.c | 121 ++--
.../gnunet-service-messenger_message_send.c | 93 +--
.../gnunet-service-messenger_message_state.c | 40 +-
.../gnunet-service-messenger_message_state.h | 5 +-
.../gnunet-service-messenger_message_store.c | 324 +++++++----
src/messenger/gnunet-service-messenger_operation.c | 112 ++--
src/messenger/gnunet-service-messenger_operation.h | 4 +-
.../gnunet-service-messenger_operation_store.c | 104 ++--
src/messenger/gnunet-service-messenger_room.c | 636 +++++++++++++--------
src/messenger/gnunet-service-messenger_room.h | 25 +-
.../gnunet-service-messenger_sender_session.h | 6 +-
src/messenger/gnunet-service-messenger_service.c | 98 ++--
src/messenger/gnunet-service-messenger_tunnel.c | 155 +++--
src/messenger/messenger_api.c | 417 ++++++++------
src/messenger/messenger_api_contact.c | 38 +-
src/messenger/messenger_api_contact_store.c | 73 ++-
src/messenger/messenger_api_contact_store.h | 6 +-
src/messenger/messenger_api_handle.c | 80 ++-
src/messenger/messenger_api_list_tunnels.c | 104 ++--
src/messenger/messenger_api_message.c | 489 +++++++++-------
src/messenger/messenger_api_message.h | 7 +-
src/messenger/messenger_api_message_kind.c | 83 ++-
src/messenger/messenger_api_peer_store.c | 49 +-
src/messenger/messenger_api_peer_store.h | 2 +-
src/messenger/messenger_api_queue_messages.c | 12 +-
src/messenger/messenger_api_room.c | 199 ++++---
src/messenger/messenger_api_room.h | 9 +-
src/messenger/messenger_api_util.c | 50 +-
src/messenger/messenger_api_util.h | 8 +-
src/messenger/plugin_gnsrecord_messenger.c | 37 +-
src/messenger/test_messenger.c | 30 +-
src/messenger/test_messenger_anonymous.c | 20 +-
src/messenger/testing_messenger_barrier.c | 52 +-
src/messenger/testing_messenger_setup.c | 185 +++---
src/messenger/testing_messenger_setup.h | 4 +-
51 files changed, 3285 insertions(+), 2112 deletions(-)
diff --git a/src/messenger/gnunet-messenger.c b/src/messenger/gnunet-messenger.c
index 0fa706319..79c0d0b1e 100644
--- a/src/messenger/gnunet-messenger.c
+++ b/src/messenger/gnunet-messenger.c
@@ -52,12 +52,12 @@ on_message (void *cls,
{
const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
- if (!sender_name)
+ if (! sender_name)
sender_name = "anonymous";
- printf ("[%s ->", GNUNET_h2s(&(message->header.previous)));
- printf (" %s]", GNUNET_h2s(hash));
- printf ("[%s] ", GNUNET_sh2s(&(message->header.sender_id)));
+ printf ("[%s ->", GNUNET_h2s (&(message->header.previous)));
+ printf (" %s]", GNUNET_h2s (hash));
+ printf ("[%s] ", GNUNET_sh2s (&(message->header.sender_id)));
if (flags & GNUNET_MESSENGER_FLAG_PRIVATE)
printf ("*");
@@ -71,7 +71,8 @@ on_message (void *cls,
}
case GNUNET_MESSENGER_KIND_NAME:
{
- printf ("* '%s' gets renamed to '%s'\n", sender_name,
message->body.name.name);
+ printf ("* '%s' gets renamed to '%s'\n", sender_name,
+ message->body.name.name);
break;
}
case GNUNET_MESSENGER_KIND_LEAVE:
@@ -81,7 +82,8 @@ on_message (void *cls,
}
case GNUNET_MESSENGER_KIND_PEER:
{
- printf ("* '%s' opened the room on: %s\n", sender_name, GNUNET_i2s_full
(&(message->body.peer.peer)));
+ printf ("* '%s' opened the room on: %s\n", sender_name,
+ GNUNET_i2s_full (&(message->body.peer.peer)));
break;
}
case GNUNET_MESSENGER_KIND_TEXT:
@@ -96,16 +98,18 @@ on_message (void *cls,
}
default:
{
- printf ("~ message: %s\n",
GNUNET_MESSENGER_name_of_kind(message->header.kind));
+ printf ("~ message: %s\n",
+ GNUNET_MESSENGER_name_of_kind (message->header.kind));
break;
}
}
- if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) && (flags &
GNUNET_MESSENGER_FLAG_SENT))
+ if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) &&
+ (flags & GNUNET_MESSENGER_FLAG_SENT))
{
- const char* name = GNUNET_MESSENGER_get_name (messenger);
+ const char *name = GNUNET_MESSENGER_get_name (messenger);
- if (!name)
+ if (! name)
return;
struct GNUNET_MESSENGER_Message response;
@@ -118,6 +122,7 @@ on_message (void *cls,
}
}
+
struct GNUNET_SCHEDULER_Task *read_task;
struct GNUNET_IDENTITY_EgoLookup *ego_lookup;
@@ -139,11 +144,12 @@ shutdown_hook (void *cls)
if (messenger)
GNUNET_MESSENGER_disconnect (messenger);
-
+
if (ego_lookup)
GNUNET_IDENTITY_ego_lookup_cancel (ego_lookup);
}
+
static void
listen_stdio (void *cls);
@@ -156,12 +162,13 @@ iterate_send_private_message (void *cls,
{
struct GNUNET_MESSENGER_Message *message = cls;
- if (GNUNET_MESSENGER_contact_get_key(contact))
+ if (GNUNET_MESSENGER_contact_get_key (contact))
GNUNET_MESSENGER_send_message (room, message, contact);
return GNUNET_YES;
}
+
int private_mode;
/**
@@ -197,13 +204,15 @@ read_stdio (void *cls)
message.body.text.text = buffer;
if (GNUNET_YES == private_mode)
- GNUNET_MESSENGER_iterate_members(room, iterate_send_private_message,
&message);
+ GNUNET_MESSENGER_iterate_members (room, iterate_send_private_message,
+ &message);
else
GNUNET_MESSENGER_send_message (room, &message, NULL);
read_task = GNUNET_SCHEDULER_add_now (listen_stdio, cls);
}
+
/**
* Wait for input on STDIO and send it out over the #ch.
*
@@ -225,6 +234,7 @@ listen_stdio (void *cls)
GNUNET_NETWORK_fdset_destroy (rs);
}
+
/**
* Initial task to startup application.
*
@@ -240,6 +250,7 @@ idle (void *cls)
read_task = GNUNET_SCHEDULER_add_now (listen_stdio, room);
}
+
char *door_id;
char *ego_name;
char *room_key;
@@ -266,12 +277,16 @@ on_identity (void *cls,
struct GNUNET_PeerIdentity *door = NULL;
if ((door_id) &&
- (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string (door_id,
strlen (door_id), &(door_peer.public_key))))
+ (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string (door_id,
+ strlen (
+ door_id),
+ &(door_peer.
+
public_key))))
door = &door_peer;
const char *name = GNUNET_MESSENGER_get_name (handle);
- if (!name)
+ if (! name)
name = "anonymous";
printf ("* Welcome to the messenger, '%s'!\n", name);
@@ -295,15 +310,18 @@ on_identity (void *cls,
shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, room);
- if (!room)
+ if (! room)
GNUNET_SCHEDULER_shutdown ();
else
{
- GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_
(), GNUNET_SCHEDULER_PRIORITY_IDLE, idle,
- room);
+ GNUNET_SCHEDULER_add_delayed_with_priority (
+ GNUNET_TIME_relative_get_zero_ (),
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ idle, room);
}
}
+
static void
on_ego_lookup (void *cls,
struct GNUNET_IDENTITY_Ego *ego)
@@ -313,7 +331,8 @@ on_ego_lookup (void *cls,
const struct GNUNET_IDENTITY_PrivateKey *key;
key = ego ? GNUNET_IDENTITY_ego_get_private_key (ego) : NULL;
- messenger = GNUNET_MESSENGER_connect (config, ego_name, key, &on_message,
NULL);
+ messenger = GNUNET_MESSENGER_connect (config, ego_name, key, &on_message,
+ NULL);
on_identity (NULL, messenger);
}
@@ -329,7 +348,7 @@ on_ego_lookup (void *cls,
*/
static void
run (void *cls,
- char *const*args,
+ char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
@@ -337,7 +356,8 @@ run (void *cls,
if (ego_name)
{
- ego_lookup = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &on_ego_lookup,
NULL);
+ ego_lookup = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &on_ego_lookup,
+ NULL);
messenger = NULL;
}
else
@@ -352,6 +372,7 @@ run (void *cls,
on_identity (NULL, messenger);
}
+
/**
* The main function to obtain messenger information.
*
@@ -363,17 +384,26 @@ int
main (int argc,
char **argv)
{
- const char *description = "Open and connect to rooms using the MESSENGER to
chat.";
-
- struct GNUNET_GETOPT_CommandLineOption options[] =
- {
- GNUNET_GETOPT_option_string ('d', "door", "PEERIDENTITY", "peer identity
to entry into the room", &door_id),
- GNUNET_GETOPT_option_string ('e', "ego", "IDENTITY", "identity to use for
messaging", &ego_name),
- GNUNET_GETOPT_option_string ('r', "room", "ROOMKEY", "key of the room to
connect to", &room_key),
- GNUNET_GETOPT_option_flag ('p', "private", "flag to enable private mode",
&private_mode),
+ const char *description =
+ "Open and connect to rooms using the MESSENGER to chat.";
+
+ struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_option_string ('d', "door", "PEERIDENTITY",
+ "peer identity to entry into the room",
+ &door_id),
+ GNUNET_GETOPT_option_string ('e', "ego", "IDENTITY",
+ "identity to use for messaging",
+ &ego_name),
+ GNUNET_GETOPT_option_string ('r', "room", "ROOMKEY",
+ "key of the room to connect to",
+ &room_key),
+ GNUNET_GETOPT_option_flag ('p', "private", "flag to enable private mode",
+ &private_mode),
GNUNET_GETOPT_OPTION_END
};
- return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-messenger\0",
gettext_noop(description), options, &run,
- NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
+ return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-messenger\0",
+ gettext_noop (description), options,
+ &run,
+ NULL) ? EXIT_SUCCESS :
EXIT_FAILURE);
}
diff --git a/src/messenger/gnunet-service-messenger.c
b/src/messenger/gnunet-service-messenger.c
index 0b447f3cf..bebadb943 100644
--- a/src/messenger/gnunet-service-messenger.c
+++ b/src/messenger/gnunet-service-messenger.c
@@ -50,6 +50,7 @@ handle_create (void *cls,
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static void
handle_destroy (void *cls,
const struct GNUNET_MESSENGER_DestroyMessage *msg)
@@ -61,6 +62,7 @@ handle_destroy (void *cls,
GNUNET_SERVICE_client_drop (msg_client->client);
}
+
static int
check_room_initial_key (const struct GNUNET_MESSENGER_RoomMessage *msg)
{
@@ -78,12 +80,15 @@ check_room_initial_key (const struct
GNUNET_MESSENGER_RoomMessage *msg)
struct GNUNET_IDENTITY_PublicKey key;
size_t key_len;
- if (GNUNET_OK != GNUNET_IDENTITY_read_public_key_from_buffer(msg_buffer,
msg_length, &key, &key_len))
+ if (GNUNET_OK != GNUNET_IDENTITY_read_public_key_from_buffer (msg_buffer,
+ msg_length,
+ &key,
&key_len))
return GNUNET_NO;
return key_len == msg_length ? GNUNET_OK : GNUNET_NO;
}
+
static void
initialize_handle_via_key (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -99,15 +104,20 @@ initialize_handle_via_key (struct
GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_IDENTITY_PublicKey key;
size_t key_len;
- if (GNUNET_OK == GNUNET_IDENTITY_read_public_key_from_buffer(msg_buffer,
msg_length, &key, &key_len))
- set_srv_handle_key(handle, &key);
+ if (GNUNET_OK == GNUNET_IDENTITY_read_public_key_from_buffer (msg_buffer,
+ msg_length,
+ &key,
+ &key_len))
+ set_srv_handle_key (handle, &key);
else
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Initialization failed while
reading invalid key!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Initialization failed while reading invalid key!\n");
}
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Initialization is missing key!\n");
}
+
static int
check_room_open (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -115,6 +125,7 @@ check_room_open (void *cls,
return check_room_initial_key (msg);
}
+
static void
handle_room_open (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -148,6 +159,7 @@ handle_room_open (void *cls,
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static int
check_room_entry (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -155,6 +167,7 @@ check_room_entry (void *cls,
return check_room_initial_key (msg);
}
+
static void
handle_room_entry (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -191,6 +204,7 @@ handle_room_entry (void *cls,
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static void
handle_room_close (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -219,6 +233,7 @@ handle_room_close (void *cls,
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static int
check_send_message (void *cls,
const struct GNUNET_MESSENGER_SendMessage *msg)
@@ -233,10 +248,12 @@ check_send_message (void *cls,
struct GNUNET_MESSENGER_Message message;
- if (msg_length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
GNUNET_YES))
+ if (msg_length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ GNUNET_YES))
return GNUNET_NO;
- if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer,
GNUNET_YES,
+ if (GNUNET_YES != decode_message (&message, msg_length, msg_buffer,
+ GNUNET_YES,
NULL))
return GNUNET_NO;
@@ -246,6 +263,7 @@ check_send_message (void *cls,
return GNUNET_SYSERR != allowed? GNUNET_OK : GNUNET_NO;
}
+
static void
handle_send_message (void *cls,
const struct GNUNET_MESSENGER_SendMessage *msg)
@@ -269,12 +287,13 @@ handle_send_message (void *cls,
GNUNET_MESSENGER_name_of_kind (message.header.kind),
GNUNET_h2s (key));
- end_handling:
+end_handling:
cleanup_message (&message);
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static void
callback_found_message (void *cls,
struct GNUNET_MESSENGER_SrvRoom *room,
@@ -283,14 +302,15 @@ callback_found_message (void *cls,
{
struct GNUNET_MESSENGER_Client *msg_client = cls;
- if (!message)
+ if (! message)
{
struct GNUNET_MESSENGER_GetMessage *response;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg (response,
GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
- GNUNET_memcpy(&(response->key), &(room->key), sizeof(room->key));
- GNUNET_memcpy(&(response->hash), hash, sizeof(*hash));
+ env = GNUNET_MQ_msg (response,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
+ GNUNET_memcpy (&(response->key), &(room->key), sizeof(room->key));
+ GNUNET_memcpy (&(response->hash), hash, sizeof(*hash));
GNUNET_MQ_send (msg_client->handle->mq, env);
return;
}
@@ -303,15 +323,17 @@ callback_found_message (void *cls,
session.peer = get_store_peer_of (store, message, hash);
- if (!session.peer)
+ if (! session.peer)
return;
}
else
{
- struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store
(room);
- struct GNUNET_MESSENGER_Member *member = get_store_member_of (store,
message);
+ struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store (
+ room);
+ struct GNUNET_MESSENGER_Member *member = get_store_member_of (store,
+ message);
- if (!member)
+ if (! member)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sender of message (%s) unknown!\n",
GNUNET_h2s (hash));
@@ -320,7 +342,7 @@ callback_found_message (void *cls,
session.member = get_member_session_of (member, message, hash);
- if (!session.member)
+ if (! session.member)
return;
}
@@ -328,6 +350,7 @@ callback_found_message (void *cls,
hash);
}
+
static void
handle_get_message (void *cls,
const struct GNUNET_MESSENGER_GetMessage *msg)
@@ -364,7 +387,8 @@ handle_get_message (void *cls,
goto end_handling;
}
- const struct GNUNET_IDENTITY_PublicKey* pubkey =
get_srv_handle_key(msg_client->handle);
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (
+ msg_client->handle);
if (! pubkey)
{
@@ -386,10 +410,11 @@ handle_get_message (void *cls,
request_srv_room_message (room, &(msg->hash), session,
callback_found_message,
msg_client);
- end_handling:
+end_handling:
GNUNET_SERVICE_client_continue (msg_client->client);
}
+
static void*
callback_client_connect (void *cls,
struct GNUNET_SERVICE_Client *client,
@@ -404,6 +429,7 @@ callback_client_connect (void *cls,
return msg_client;
}
+
static void
callback_client_disconnect (void *cls,
struct GNUNET_SERVICE_Client *client,
@@ -416,6 +442,7 @@ callback_client_disconnect (void *cls,
GNUNET_free (msg_client);
}
+
/**
* Setup MESSENGER internals.
*
@@ -434,6 +461,7 @@ run (void *cls,
GNUNET_SCHEDULER_shutdown ();
}
+
/**
* Define "main" method using service macro.
*/
@@ -445,16 +473,17 @@ GNUNET_SERVICE_MAIN (
&callback_client_disconnect,
NULL,
GNUNET_MQ_hd_fixed_size (create,
- GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE,
struct
+ GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE,
+ struct
GNUNET_MESSENGER_CreateMessage, NULL),
GNUNET_MQ_hd_fixed_size (destroy,
GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY,
struct
GNUNET_MESSENGER_DestroyMessage, NULL),
GNUNET_MQ_hd_var_size (room_open, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
- struct GNUNET_MESSENGER_RoomMessage, NULL),
+ struct GNUNET_MESSENGER_RoomMessage, NULL),
GNUNET_MQ_hd_var_size (room_entry, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
- struct GNUNET_MESSENGER_RoomMessage, NULL),
+ struct GNUNET_MESSENGER_RoomMessage, NULL),
GNUNET_MQ_hd_fixed_size (room_close,
GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
struct GNUNET_MESSENGER_RoomMessage, NULL),
GNUNET_MQ_hd_var_size (send_message,
diff --git a/src/messenger/gnunet-service-messenger_basement.c
b/src/messenger/gnunet-service-messenger_basement.c
index ae0dcaa62..d4de28c4c 100644
--- a/src/messenger/gnunet-service-messenger_basement.c
+++ b/src/messenger/gnunet-service-messenger_basement.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -29,7 +29,7 @@
size_t
count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels *tunnels)
{
- GNUNET_assert(tunnels);
+ GNUNET_assert (tunnels);
const struct GNUNET_MESSENGER_ListTunnel *element;
size_t count = 0;
@@ -40,6 +40,7 @@ count_of_tunnels (const struct GNUNET_MESSENGER_ListTunnels
*tunnels)
return count;
}
+
int
should_connect_tunnel_to (size_t count,
size_t src,
@@ -51,6 +52,7 @@ should_connect_tunnel_to (size_t count,
return GNUNET_NO;
}
+
int
required_connection_between (size_t count,
size_t src,
diff --git a/src/messenger/gnunet-service-messenger_ego_store.c
b/src/messenger/gnunet-service-messenger_ego_store.c
index 3eb313b08..eb094cfd7 100644
--- a/src/messenger/gnunet-service-messenger_ego_store.c
+++ b/src/messenger/gnunet-service-messenger_ego_store.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2022 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -34,7 +34,7 @@ callback_update_ego (void *cls,
void **ctx,
const char *identifier)
{
- if ((!ctx) || (!identifier))
+ if ((! ctx) || (! identifier))
return;
struct GNUNET_MESSENGER_EgoStore *store = cls;
@@ -42,7 +42,8 @@ callback_update_ego (void *cls,
if (ego)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New ego in use: '%s'\n", identifier);
- update_store_ego (store, identifier, GNUNET_IDENTITY_ego_get_private_key
(ego));
+ update_store_ego (store, identifier,
+ GNUNET_IDENTITY_ego_get_private_key (ego));
}
else
{
@@ -51,14 +52,16 @@ callback_update_ego (void *cls,
}
}
+
void
-init_ego_store(struct GNUNET_MESSENGER_EgoStore *store,
- const struct GNUNET_CONFIGURATION_Handle *config)
+init_ego_store (struct GNUNET_MESSENGER_EgoStore *store,
+ const struct GNUNET_CONFIGURATION_Handle *config)
{
GNUNET_assert ((store) && (config));
store->cfg = config;
- store->identity = GNUNET_IDENTITY_connect (config, &callback_update_ego,
store);
+ store->identity = GNUNET_IDENTITY_connect (config, &callback_update_ego,
+ store);
store->egos = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
store->handles = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
@@ -69,18 +72,20 @@ init_ego_store(struct GNUNET_MESSENGER_EgoStore *store,
store->op_end = NULL;
}
+
static int
iterate_destroy_egos (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct GNUNET_MESSENGER_Ego *ego = value;
- GNUNET_free(ego);
+ GNUNET_free (ego);
return GNUNET_YES;
}
+
void
-clear_ego_store(struct GNUNET_MESSENGER_EgoStore *store)
+clear_ego_store (struct GNUNET_MESSENGER_EgoStore *store)
{
GNUNET_assert (store);
@@ -105,18 +110,19 @@ clear_ego_store(struct GNUNET_MESSENGER_EgoStore *store)
{
lu = store->lu_start;
- GNUNET_IDENTITY_ego_lookup_cancel(lu->lookup);
+ GNUNET_IDENTITY_ego_lookup_cancel (lu->lookup);
GNUNET_CONTAINER_DLL_remove (store->lu_start, store->lu_end, lu);
if (lu->identifier)
- GNUNET_free(lu->identifier);
+ GNUNET_free (lu->identifier);
GNUNET_free (lu);
}
- GNUNET_CONTAINER_multihashmap_iterate (store->egos, iterate_destroy_egos,
NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->egos,
+ iterate_destroy_egos,
+ NULL);
GNUNET_CONTAINER_multihashmap_destroy (store->egos);
-
GNUNET_CONTAINER_multihashmap_destroy (store->handles);
if (store->identity)
@@ -127,6 +133,7 @@ clear_ego_store(struct GNUNET_MESSENGER_EgoStore *store)
}
}
+
static int
iterate_create_ego (void *cls,
const struct GNUNET_HashCode *key,
@@ -137,6 +144,7 @@ iterate_create_ego (void *cls,
return GNUNET_YES;
}
+
static void
callback_ego_create (void *cls,
const struct GNUNET_IDENTITY_PrivateKey *key,
@@ -156,12 +164,16 @@ callback_ego_create (void *cls,
if (key)
{
- struct GNUNET_MESSENGER_Ego *msg_ego = update_store_ego (store,
element->identifier, key);
+ struct GNUNET_MESSENGER_Ego *msg_ego = update_store_ego (store,
+
element->identifier,
+ key);
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier),
&hash);
+ GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier),
+ &hash);
- GNUNET_CONTAINER_multihashmap_get_multiple (store->handles, &hash,
iterate_create_ego, msg_ego);
+ GNUNET_CONTAINER_multihashmap_get_multiple (store->handles, &hash,
+ iterate_create_ego, msg_ego);
}
else
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Creating ego failed!\n");
@@ -171,15 +183,17 @@ callback_ego_create (void *cls,
GNUNET_free (element);
}
+
void
create_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier)
{
GNUNET_assert ((store) && (identifier));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store create ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store create ego: %s\n", identifier);
- struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
GNUNET_MESSENGER_EgoOperation);
+ struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
+
GNUNET_MESSENGER_EgoOperation);
element->store = store;
element->cls = NULL;
@@ -187,17 +201,18 @@ create_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
element->identifier = GNUNET_strdup (identifier);
element->operation = GNUNET_IDENTITY_create (
- store->identity,
- identifier,
- NULL,
- GNUNET_IDENTITY_TYPE_ECDSA,
- callback_ego_create,
- element
- );
+ store->identity,
+ identifier,
+ NULL,
+ GNUNET_IDENTITY_TYPE_ECDSA,
+ callback_ego_create,
+ element
+ );
GNUNET_CONTAINER_DLL_insert (store->op_start, store->op_end, element);
}
+
void
bind_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier,
@@ -205,19 +220,23 @@ bind_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
{
GNUNET_assert ((store) && (identifier) && (handle));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store bind ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store bind ego: %s\n", identifier);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
- if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_contains_value(store->handles, &hash, handle))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains_value (
+ store->handles, &hash, handle))
return;
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(store->handles, &hash,
handle,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Putting handle binding to ego store
failed!\n");
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->handles, &hash,
+ handle,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Putting handle binding to ego store failed!\n");
}
+
void
unbind_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier,
@@ -225,18 +244,22 @@ unbind_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
{
GNUNET_assert ((store) && (identifier) && (handle));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store unbind ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store unbind ego: %s\n", identifier);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
- if (GNUNET_YES !=
GNUNET_CONTAINER_multihashmap_contains_value(store->handles, &hash, handle))
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains_value (
+ store->handles, &hash, handle))
return;
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(store->handles,
&hash, handle))
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Removing handle binding from ego
store failed!\n");
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->handles,
&hash,
+ handle))
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Removing handle binding from ego store failed!\n");
}
+
static void
callback_ego_lookup (void *cls,
struct GNUNET_IDENTITY_Ego *ego)
@@ -250,50 +273,55 @@ callback_ego_lookup (void *cls,
if (ego)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New ego looked up: '%s'\n",
element->identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New ego looked up: '%s'\n",
+ element->identifier);
msg_ego = update_store_ego (
- store,
- element->identifier,
- GNUNET_IDENTITY_ego_get_private_key(ego)
- );
+ store,
+ element->identifier,
+ GNUNET_IDENTITY_ego_get_private_key (ego)
+ );
}
else
{
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier),
&hash);
+ GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier),
+ &hash);
if (GNUNET_CONTAINER_multihashmap_get (store->egos, &hash))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looked up ego got deleted:
'%s'\n", element->identifier);
- delete_store_ego(store, element->identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looked up ego got deleted: '%s'\n",
+ element->identifier);
+ delete_store_ego (store, element->identifier);
}
}
if (element->cb)
- element->cb(element->cls, element->identifier, msg_ego);
+ element->cb (element->cls, element->identifier, msg_ego);
GNUNET_CONTAINER_DLL_remove (store->lu_start, store->lu_end, element);
GNUNET_free (element->identifier);
GNUNET_free (element);
}
+
void
-lookup_store_ego(struct GNUNET_MESSENGER_EgoStore *store,
- const char *identifier,
- GNUNET_MESSENGER_EgoLookupCallback lookup,
- void *cls)
+lookup_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
+ const char *identifier,
+ GNUNET_MESSENGER_EgoLookupCallback lookup,
+ void *cls)
{
GNUNET_assert (store);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store lookup ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store lookup ego: %s\n", identifier);
- if (!identifier)
+ if (! identifier)
{
- lookup(cls, identifier, NULL);
+ lookup (cls, identifier, NULL);
return;
}
- struct GNUNET_MESSENGER_EgoLookup *element = GNUNET_new (struct
GNUNET_MESSENGER_EgoLookup);
+ struct GNUNET_MESSENGER_EgoLookup *element = GNUNET_new (struct
+
GNUNET_MESSENGER_EgoLookup);
element->store = store;
@@ -302,11 +330,13 @@ lookup_store_ego(struct GNUNET_MESSENGER_EgoStore *store,
element->identifier = GNUNET_strdup (identifier);
- element->lookup = GNUNET_IDENTITY_ego_lookup(store->cfg, identifier,
callback_ego_lookup, element);
+ element->lookup = GNUNET_IDENTITY_ego_lookup (store->cfg, identifier,
+ callback_ego_lookup, element);
GNUNET_CONTAINER_DLL_insert (store->lu_start, store->lu_end, element);
}
+
struct GNUNET_MESSENGER_Ego*
update_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier,
@@ -314,55 +344,62 @@ update_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
{
GNUNET_assert ((store) && (identifier) && (key));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store update ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store update ego: %s\n", identifier);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
- struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get
(store->egos, &hash);
+ struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (
+ store->egos, &hash);
- if (!ego)
+ if (! ego)
{
- ego = GNUNET_new(struct GNUNET_MESSENGER_Ego);
- GNUNET_CONTAINER_multihashmap_put (store->egos, &hash, ego,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ ego = GNUNET_new (struct GNUNET_MESSENGER_Ego);
+ GNUNET_CONTAINER_multihashmap_put (store->egos, &hash, ego,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}
- GNUNET_memcpy(&(ego->priv), key, sizeof(*key));
+ GNUNET_memcpy (&(ego->priv), key, sizeof(*key));
if (GNUNET_OK != GNUNET_IDENTITY_key_get_public (key, &(ego->pub)))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating invalid ego key
failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Updating invalid ego key failed!\n");
return ego;
}
+
void
delete_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier)
{
GNUNET_assert ((store) && (identifier));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store delete ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store delete ego: %s\n", identifier);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
- struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get
(store->egos, &hash);
+ struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (
+ store->egos, &hash);
if (ego)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Ego is not stored!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ego is not stored!\n");
return;
}
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->egos, &hash,
ego))
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->egos, &hash,
+ ego))
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Removing ego from store failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Removing ego from store failed!\n");
return;
}
- GNUNET_free(ego);
+ GNUNET_free (ego);
}
+
static void
callback_ego_rename (void *cls,
enum GNUNET_ErrorCode ec)
@@ -382,14 +419,16 @@ callback_ego_rename (void *cls,
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (element->identifier, strlen (element->identifier),
&hash);
- struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get
(store->egos, &hash);
+ struct GNUNET_MESSENGER_Ego *ego = GNUNET_CONTAINER_multihashmap_get (
+ store->egos, &hash);
- if (!ego)
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Ego is not stored!\n");
+ if (! ego)
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ego is not stored!\n");
char *identifier = (char*) element->cls;
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->egos, &hash,
ego))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->egos, &hash,
+ ego))
{
GNUNET_CRYPTO_hash (identifier, strlen (identifier), &hash);
@@ -397,7 +436,7 @@ callback_ego_rename (void *cls,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}
else
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Renaming ego failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Renaming ego failed!\n");
GNUNET_free (identifier);
@@ -406,6 +445,7 @@ callback_ego_rename (void *cls,
GNUNET_free (element);
}
+
void
rename_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *old_identifier,
@@ -413,9 +453,11 @@ rename_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
{
GNUNET_assert ((store) && (old_identifier) && (new_identifier));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store rename ego: %s -> %s\n",
old_identifier, new_identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store rename ego: %s -> %s\n",
+ old_identifier, new_identifier);
- struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
GNUNET_MESSENGER_EgoOperation);
+ struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
+
GNUNET_MESSENGER_EgoOperation);
element->store = store;
element->cls = GNUNET_strdup (new_identifier);
@@ -423,16 +465,17 @@ rename_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
element->identifier = GNUNET_strdup (old_identifier);
element->operation = GNUNET_IDENTITY_rename (
- store->identity,
- old_identifier,
- new_identifier,
- callback_ego_rename,
- element
- );
+ store->identity,
+ old_identifier,
+ new_identifier,
+ callback_ego_rename,
+ element
+ );
GNUNET_CONTAINER_DLL_insert (store->op_start, store->op_end, element);
}
+
static void
callback_ego_delete (void *cls,
enum GNUNET_ErrorCode ec)
@@ -456,27 +499,29 @@ callback_ego_delete (void *cls,
GNUNET_free (element);
}
+
void
renew_store_ego (struct GNUNET_MESSENGER_EgoStore *store,
const char *identifier)
{
GNUNET_assert ((store) && (identifier));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Store renew ego: %s\n", identifier);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Store renew ego: %s\n", identifier);
- struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
GNUNET_MESSENGER_EgoOperation);
+ struct GNUNET_MESSENGER_EgoOperation *element = GNUNET_new (struct
+
GNUNET_MESSENGER_EgoOperation);
element->store = store;
element->cls = NULL;
element->identifier = GNUNET_strdup (identifier);
- element->operation = GNUNET_IDENTITY_delete(
- store->identity,
- identifier,
- callback_ego_delete,
- element
- );
+ element->operation = GNUNET_IDENTITY_delete (
+ store->identity,
+ identifier,
+ callback_ego_delete,
+ element
+ );
GNUNET_CONTAINER_DLL_insert (store->op_start, store->op_end, element);
}
diff --git a/src/messenger/gnunet-service-messenger_handle.c
b/src/messenger/gnunet-service-messenger_handle.c
index ddb437b7e..8d572013e 100644
--- a/src/messenger/gnunet-service-messenger_handle.c
+++ b/src/messenger/gnunet-service-messenger_handle.c
@@ -40,9 +40,10 @@ struct GNUNET_MESSENGER_SrvHandle*
create_srv_handle (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MQ_Handle *mq)
{
- GNUNET_assert((service) && (mq));
+ GNUNET_assert ((service) && (mq));
- struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct
GNUNET_MESSENGER_SrvHandle);
+ struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new (struct
+
GNUNET_MESSENGER_SrvHandle);
handle->service = service;
handle->mq = mq;
@@ -55,65 +56,72 @@ create_srv_handle (struct GNUNET_MESSENGER_Service *service,
return handle;
}
+
int
iterate_free_member_ids (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
- GNUNET_free(value);
+ GNUNET_free (value);
return GNUNET_YES;
}
+
void
destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
if (handle->notify)
- GNUNET_SCHEDULER_cancel(handle->notify);
+ GNUNET_SCHEDULER_cancel (handle->notify);
- GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
iterate_free_member_ids, NULL);
- GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids,
iterate_free_member_ids, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+ iterate_free_member_ids, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids,
+ iterate_free_member_ids, NULL);
GNUNET_CONTAINER_multihashmap_destroy (handle->next_ids);
GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);
- GNUNET_free(handle);
+ GNUNET_free (handle);
}
+
void
set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_IDENTITY_PublicKey *key)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
- if ((handle->key) && (!key))
+ if ((handle->key) && (! key))
{
- GNUNET_free(handle->key);
+ GNUNET_free (handle->key);
handle->key = NULL;
}
- else if (!handle->key)
- handle->key = GNUNET_new(struct GNUNET_IDENTITY_PublicKey);
+ else if (! handle->key)
+ handle->key = GNUNET_new (struct GNUNET_IDENTITY_PublicKey);
if (key)
- memcpy(handle->key, key, sizeof(struct GNUNET_IDENTITY_PublicKey));
+ memcpy (handle->key, key, sizeof(struct GNUNET_IDENTITY_PublicKey));
}
+
const struct GNUNET_IDENTITY_PublicKey*
get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
return handle->key;
}
+
void
get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle,
const char *name,
char **dir)
{
- GNUNET_assert((handle) && (dir));
+ GNUNET_assert ((handle) && (dir));
if (name)
GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
@@ -123,75 +131,88 @@ get_srv_handle_data_subdir (const struct
GNUNET_MESSENGER_SrvHandle *handle,
DIR_SEPARATOR);
}
+
static int
create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct
GNUNET_ShortHashCode);
+ struct GNUNET_ShortHashCode *random_id = GNUNET_new (struct
+ GNUNET_ShortHashCode);
- if (!random_id)
+ if (! random_id)
return GNUNET_NO;
generate_free_member_id (random_id, NULL);
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
random_id,
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
+ random_id,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
- GNUNET_free(random_id);
+ GNUNET_free (random_id);
return GNUNET_NO;
}
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room:
%s\n", GNUNET_sh2s (random_id),
- GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (
+ random_id),
+ GNUNET_h2s (key));
return GNUNET_YES;
}
+
const struct GNUNET_ShortHashCode*
get_srv_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
}
+
int
change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key,
const struct GNUNET_ShortHashCode *unique_id)
{
- GNUNET_assert((handle) && (key) && (unique_id));
+ GNUNET_assert ((handle) && (key) && (unique_id));
- struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get
(handle->member_ids, key);
+ struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (
+ handle->member_ids, key);
- if (!member_id)
+ if (! member_id)
{
- member_id = GNUNET_new(struct GNUNET_ShortHashCode);
- GNUNET_memcpy(member_id, unique_id, sizeof(*member_id));
+ member_id = GNUNET_new (struct GNUNET_ShortHashCode);
+ GNUNET_memcpy (member_id, unique_id, sizeof(*member_id));
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids,
key, member_id,
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids,
key,
+ member_id,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
- GNUNET_free(member_id);
+ GNUNET_free (member_id);
return GNUNET_SYSERR;
}
}
- if (0 == GNUNET_memcmp(unique_id, member_id))
+ if (0 == GNUNET_memcmp (unique_id, member_id))
return GNUNET_OK;
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room
(%s).\n", GNUNET_sh2s (member_id),
- GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (
+ member_id),
+ GNUNET_h2s (key));
- GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
+ GNUNET_memcpy (member_id, unique_id, sizeof(*unique_id));
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n",
GNUNET_sh2s (unique_id));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n",
+ GNUNET_sh2s (unique_id));
return GNUNET_OK;
}
+
struct RoomInitializationClosure
{
struct GNUNET_MESSENGER_SrvHandle *handle;
@@ -206,160 +227,185 @@ find_member_session_in_room (void *cls,
{
struct RoomInitializationClosure *init = cls;
- if (!public_key)
+ if (! public_key)
return GNUNET_YES;
- const struct GNUNET_IDENTITY_PublicKey *pubkey =
get_srv_handle_key(init->handle);
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (
+ init->handle);
- if (0 != GNUNET_memcmp(pubkey, public_key))
+ if (0 != GNUNET_memcmp (pubkey, public_key))
return GNUNET_YES;
- const struct GNUNET_ShortHashCode *id = get_member_session_id(session);
+ const struct GNUNET_ShortHashCode *id = get_member_session_id (session);
- if (!id)
+ if (! id)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialitation: Missing member id!");
return GNUNET_NO;
}
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Initialitation: Matching member found
(%s)!\n",
- GNUNET_sh2s(id));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Initialitation: Matching member found (%s)!\n",
+ GNUNET_sh2s (id));
- change_srv_handle_member_id(init->handle, init->key, id);
+ change_srv_handle_member_id (init->handle, init->key, id);
return GNUNET_NO;
}
+
static void
-initialize_srv_handle_via_matching_member (struct GNUNET_MESSENGER_SrvHandle
*handle,
+initialize_srv_handle_via_matching_member (struct
+ GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- struct GNUNET_MESSENGER_SrvRoom *room = get_service_room(handle->service,
key);
- if (!room)
+ struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+ key);
+ if (! room)
return;
- struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store(room);
- if (!store)
+ struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store
(room);
+ if (! store)
return;
- const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key(handle);
- if ((!pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key())))
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (handle);
+ if ((! pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key ())))
return;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialize member id of handle via
matching member in room!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Initialize member id of handle via matching member in room!\n");
struct RoomInitializationClosure init;
init.handle = handle;
init.key = key;
init.pubkey = pubkey;
- iterate_store_members(store, find_member_session_in_room, &init);
+ iterate_store_members (store, find_member_session_in_room, &init);
}
+
int
open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
initialize_srv_handle_via_matching_member (handle, key);
- if ((!get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
create_handle_member_id (handle, key)))
+ if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
+ create_handle_member_id (
+ handle, key)))
return GNUNET_NO;
return open_service_room (handle->service, handle, key);
}
+
int
entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_PeerIdentity *door,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (door) && (key));
+ GNUNET_assert ((handle) && (door) && (key));
initialize_srv_handle_via_matching_member (handle, key);
- if ((!get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
create_handle_member_id (handle, key)))
+ if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
+ create_handle_member_id (
+ handle, key)))
return GNUNET_NO;
return entry_service_room (handle->service, handle, door, key);
}
+
int
close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key,
iterate_free_member_ids, NULL);
+ GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key,
+ iterate_free_member_ids, NULL);
GNUNET_CONTAINER_multihashmap_remove_all (handle->next_ids, key);
- if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size
(handle->next_ids)))
+ if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
+ handle->next_ids)))
{
- GNUNET_SCHEDULER_cancel(handle->notify);
+ GNUNET_SCHEDULER_cancel (handle->notify);
handle->notify = NULL;
}
- if (!get_srv_handle_member_id (handle, key))
+ if (! get_srv_handle_member_id (handle, key))
return GNUNET_NO;
return close_service_room (handle->service, handle, key);
}
+
int
send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key,
const struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert((handle) && (key) && (message));
+ GNUNET_assert ((handle) && (key) && (message));
- const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
key);
+ const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+ key);
- if (!id)
+ if (! id)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "It is required to be a member of a
room to send messages!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "It is required to be a member of a room to send messages!\n");
return GNUNET_NO;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
GNUNET_sh2s (id));
- if (0 != GNUNET_memcmp(id, &(message->header.sender_id)))
+ if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Member id does not match with
handle!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Member id does not match with handle!\n");
return GNUNET_NO;
}
- struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
key);
+ struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+ key);
- if (!room)
+ if (! room)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
+ GNUNET_h2s (key));
return GNUNET_NO;
}
- struct GNUNET_MESSENGER_Message *msg = copy_message(message);
+ struct GNUNET_MESSENGER_Message *msg = copy_message (message);
return send_srv_room_message (room, handle, msg);
}
+
static const struct GNUNET_HashCode*
-get_next_member_session_context(const struct GNUNET_MESSENGER_MemberSession
*session)
+get_next_member_session_context (const struct
+ GNUNET_MESSENGER_MemberSession *session)
{
if (session->next)
return get_next_member_session_context (session->next);
else
- return get_member_session_context(session);
+ return get_member_session_context (session);
}
+
static const struct GNUNET_MESSENGER_MemberSession*
get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (room) && (key) && (handle->service));
+ GNUNET_assert ((handle) && (room) && (key) && (handle->service));
- const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id(handle,
key);
+ const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+ key);
- if (!id)
+ if (! id)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Handle is missing a member id for its member session! (%s)\n",
@@ -367,12 +413,12 @@ get_handle_member_session (struct
GNUNET_MESSENGER_SrvHandle *handle,
return NULL;
}
- struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = get_store_member(store, id);
+ struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store
(room);
+ struct GNUNET_MESSENGER_Member *member = get_store_member (store, id);
- const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key(handle);
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (handle);
- if (!pubkey)
+ if (! pubkey)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Handle is missing a public key for its member session!
(%s)\n",
@@ -380,9 +426,10 @@ get_handle_member_session (struct
GNUNET_MESSENGER_SrvHandle *handle,
return NULL;
}
- return get_member_session(member, pubkey);
+ return get_member_session (member, pubkey);
}
+
void
notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_SrvRoom *room,
@@ -390,13 +437,14 @@ notify_srv_handle_message (struct
GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((handle) && (room) && (session) && (message) && (hash));
+ GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
- const struct GNUNET_HashCode *key = get_srv_room_key(room);
+ const struct GNUNET_HashCode *key = get_srv_room_key (room);
- if ((!handle->mq) || (!get_srv_handle_member_id (handle, key)))
+ if ((! handle->mq) || (! get_srv_handle_member_id (handle, key)))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message
requires membership!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Notifying client about message requires membership!\n");
return;
}
@@ -406,37 +454,40 @@ notify_srv_handle_message (struct
GNUNET_MESSENGER_SrvHandle *handle,
if (GNUNET_YES == is_peer_message (message))
{
const struct GNUNET_PeerIdentity *identity = session->peer;
- GNUNET_CRYPTO_hash(identity, sizeof(*identity), &sender);
+ GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
context = &sender;
}
else
{
- const struct GNUNET_IDENTITY_PublicKey *pubkey =
get_contact_key(session->member->contact);
- GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key (
+ session->member->contact);
+ GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
context = get_next_member_session_context (session->member);
}
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Notifying client about message: %s\n",
GNUNET_h2s (hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Notifying client about message: %s\n",
+ GNUNET_h2s (hash));
struct GNUNET_MESSENGER_RecvMessage *msg;
struct GNUNET_MQ_Envelope *env;
uint16_t length = get_message_size (message, GNUNET_YES);
- env = GNUNET_MQ_msg_extra(msg, length,
GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
+ env = GNUNET_MQ_msg_extra (msg, length,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
- GNUNET_memcpy(&(msg->key), key, sizeof(msg->key));
- GNUNET_memcpy(&(msg->sender), &sender, sizeof(msg->sender));
- GNUNET_memcpy(&(msg->context), context, sizeof(msg->context));
- GNUNET_memcpy(&(msg->hash), hash, sizeof(msg->hash));
+ GNUNET_memcpy (&(msg->key), key, sizeof(msg->key));
+ GNUNET_memcpy (&(msg->sender), &sender, sizeof(msg->sender));
+ GNUNET_memcpy (&(msg->context), context, sizeof(msg->context));
+ GNUNET_memcpy (&(msg->hash), hash, sizeof(msg->hash));
msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
if (GNUNET_YES == is_peer_message (message))
msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
- else if (get_handle_member_session(handle, room, key) == session->member)
+ else if (get_handle_member_session (handle, room, key) == session->member)
msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
char *buffer = ((char*) msg) + sizeof(*msg);
@@ -445,6 +496,7 @@ notify_srv_handle_message (struct
GNUNET_MESSENGER_SrvHandle *handle,
GNUNET_MQ_send (handle->mq, env);
}
+
static int
iterate_next_member_ids (void *cls,
const struct GNUNET_HashCode *key,
@@ -456,10 +508,10 @@ iterate_next_member_ids (void *cls,
struct GNUNET_MESSENGER_MemberMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+ env = GNUNET_MQ_msg (msg,
GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
- GNUNET_memcpy(&(msg->key), key, sizeof(*key));
- GNUNET_memcpy(&(msg->id), &(next->id), sizeof(next->id));
+ GNUNET_memcpy (&(msg->key), key, sizeof(*key));
+ GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
msg->reset = (uint32_t) next->reset;
GNUNET_MQ_send (handle->mq, env);
@@ -468,26 +520,30 @@ iterate_next_member_ids (void *cls,
return GNUNET_YES;
}
+
static void
task_notify_srv_handle_member_id (void *cls)
{
struct GNUNET_MESSENGER_SrvHandle *handle = cls;
handle->notify = NULL;
- GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
iterate_next_member_ids, handle);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+ iterate_next_member_ids, handle);
GNUNET_CONTAINER_multihashmap_clear (handle->next_ids);
}
+
void
notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_ShortHashCode *member_id,
enum GNUNET_GenericReturnValue reset)
{
- GNUNET_assert((handle) && (room) && (member_id));
+ GNUNET_assert ((handle) && (room) && (member_id));
- struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
GNUNET_MESSENGER_NextMemberId);
- if (!next)
+ struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
+
GNUNET_MESSENGER_NextMemberId);
+ if (! next)
{
return;
}
@@ -495,10 +551,13 @@ notify_srv_handle_member_id (struct
GNUNET_MESSENGER_SrvHandle *handle,
GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
next->reset = reset;
- const struct GNUNET_HashCode *key = get_srv_room_key(room);
+ const struct GNUNET_HashCode *key = get_srv_room_key (room);
- struct GNUNET_MESSENGER_NextMemberId *prev =
GNUNET_CONTAINER_multihashmap_get(handle->next_ids, key);
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put(handle->next_ids, key,
next, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
+ struct GNUNET_MESSENGER_NextMemberId *prev =
+ GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put (handle->next_ids, key,
+ next,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
{
return;
}
@@ -506,6 +565,7 @@ notify_srv_handle_member_id (struct
GNUNET_MESSENGER_SrvHandle *handle,
if (prev)
GNUNET_free (prev);
- if (!handle->notify)
- handle->notify = GNUNET_SCHEDULER_add_now
(task_notify_srv_handle_member_id, handle);
+ if (! handle->notify)
+ handle->notify = GNUNET_SCHEDULER_add_now
(task_notify_srv_handle_member_id,
+ handle);
}
diff --git a/src/messenger/gnunet-service-messenger_handle.h
b/src/messenger/gnunet-service-messenger_handle.h
index 4a68ff276..ecd58afe6 100644
--- a/src/messenger/gnunet-service-messenger_handle.h
+++ b/src/messenger/gnunet-service-messenger_handle.h
@@ -97,8 +97,8 @@ get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle
*handle);
*/
void
get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle,
- const char *name,
- char **dir);
+ const char *name,
+ char **dir);
/**
* Returns the member id of a given <i>handle</i> in a specific <i>room</i>.
diff --git a/src/messenger/gnunet-service-messenger_list_handles.c
b/src/messenger/gnunet-service-messenger_list_handles.c
index 0703c2de6..826e1f4ed 100644
--- a/src/messenger/gnunet-service-messenger_list_handles.c
+++ b/src/messenger/gnunet-service-messenger_list_handles.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2022 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -31,48 +31,52 @@
void
init_list_handles (struct GNUNET_MESSENGER_ListHandles *handles)
{
- GNUNET_assert(handles);
+ GNUNET_assert (handles);
handles->head = NULL;
handles->tail = NULL;
}
+
void
clear_list_handles (struct GNUNET_MESSENGER_ListHandles *handles)
{
- GNUNET_assert(handles);
+ GNUNET_assert (handles);
while (handles->head)
{
struct GNUNET_MESSENGER_ListHandle *element = handles->head;
- GNUNET_CONTAINER_DLL_remove(handles->head, handles->tail, element);
+ GNUNET_CONTAINER_DLL_remove (handles->head, handles->tail, element);
destroy_srv_handle (element->handle);
- GNUNET_free(element);
+ GNUNET_free (element);
}
handles->head = NULL;
handles->tail = NULL;
}
+
void
add_list_handle (struct GNUNET_MESSENGER_ListHandles *handles,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert((handles) && (handle));
+ GNUNET_assert ((handles) && (handle));
- struct GNUNET_MESSENGER_ListHandle *element = GNUNET_new(struct
GNUNET_MESSENGER_ListHandle);
+ struct GNUNET_MESSENGER_ListHandle *element = GNUNET_new (struct
+
GNUNET_MESSENGER_ListHandle);
element->handle = handle;
- GNUNET_CONTAINER_DLL_insert_tail(handles->head, handles->tail, element);
+ GNUNET_CONTAINER_DLL_insert_tail (handles->head, handles->tail, element);
}
+
int
remove_list_handle (struct GNUNET_MESSENGER_ListHandles *handles,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert((handles) && (handle));
+ GNUNET_assert ((handles) && (handle));
struct GNUNET_MESSENGER_ListHandle *element;
@@ -80,25 +84,28 @@ remove_list_handle (struct GNUNET_MESSENGER_ListHandles
*handles,
if (element->handle == handle)
break;
- if (!element)
+ if (! element)
return GNUNET_NO;
- GNUNET_CONTAINER_DLL_remove(handles->head, handles->tail, element);
- GNUNET_free(element);
+ GNUNET_CONTAINER_DLL_remove (handles->head, handles->tail, element);
+ GNUNET_free (element);
return GNUNET_YES;
}
+
struct GNUNET_MESSENGER_SrvHandle*
find_list_handle_by_member (const struct GNUNET_MESSENGER_ListHandles *handles,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handles) && (key));
+ GNUNET_assert ((handles) && (key));
struct GNUNET_MESSENGER_ListHandle *element;
for (element = handles->head; element; element = element->next)
- if (get_srv_handle_member_id ((struct GNUNET_MESSENGER_SrvHandle*)
element->handle, key))
+ if (get_srv_handle_member_id ((struct
+ GNUNET_MESSENGER_SrvHandle*)
element->handle,
+ key))
return element->handle;
return NULL;
diff --git a/src/messenger/gnunet-service-messenger_list_messages.c
b/src/messenger/gnunet-service-messenger_list_messages.c
index 5bab52806..063e1ebfc 100644
--- a/src/messenger/gnunet-service-messenger_list_messages.c
+++ b/src/messenger/gnunet-service-messenger_list_messages.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -29,47 +29,51 @@
void
init_list_messages (struct GNUNET_MESSENGER_ListMessages *messages)
{
- GNUNET_assert(messages);
+ GNUNET_assert (messages);
messages->head = NULL;
messages->tail = NULL;
}
+
void
clear_list_messages (struct GNUNET_MESSENGER_ListMessages *messages)
{
- GNUNET_assert(messages);
+ GNUNET_assert (messages);
while (messages->head)
{
struct GNUNET_MESSENGER_ListMessage *element = messages->head;
- GNUNET_CONTAINER_DLL_remove(messages->head, messages->tail, element);
- GNUNET_free(element);
+ GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+ GNUNET_free (element);
}
messages->head = NULL;
messages->tail = NULL;
}
+
void
add_to_list_messages (struct GNUNET_MESSENGER_ListMessages *messages,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((messages) && (hash));
+ GNUNET_assert ((messages) && (hash));
- struct GNUNET_MESSENGER_ListMessage *element = GNUNET_new(struct
GNUNET_MESSENGER_ListMessage);
+ struct GNUNET_MESSENGER_ListMessage *element = GNUNET_new (struct
+
GNUNET_MESSENGER_ListMessage);
- GNUNET_memcpy(&(element->hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&(element->hash), hash, sizeof(struct GNUNET_HashCode));
- GNUNET_CONTAINER_DLL_insert_tail(messages->head, messages->tail, element);
+ GNUNET_CONTAINER_DLL_insert_tail (messages->head, messages->tail, element);
}
+
void
copy_list_messages (struct GNUNET_MESSENGER_ListMessages *messages,
const struct GNUNET_MESSENGER_ListMessages *origin)
{
- GNUNET_assert((messages) && (origin));
+ GNUNET_assert ((messages) && (origin));
struct GNUNET_MESSENGER_ListMessage *element;
@@ -77,80 +81,85 @@ copy_list_messages (struct GNUNET_MESSENGER_ListMessages
*messages,
add_to_list_messages (messages, &(element->hash));
}
+
void
remove_from_list_messages (struct GNUNET_MESSENGER_ListMessages *messages,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((messages) && (hash));
+ GNUNET_assert ((messages) && (hash));
struct GNUNET_MESSENGER_ListMessage *element;
for (element = messages->head; element; element = element->next)
if (0 == GNUNET_CRYPTO_hash_cmp (&(element->hash), hash))
{
- GNUNET_CONTAINER_DLL_remove(messages->head, messages->tail, element);
- GNUNET_free(element);
+ GNUNET_CONTAINER_DLL_remove (messages->head, messages->tail, element);
+ GNUNET_free (element);
break;
}
}
+
void
load_list_messages (struct GNUNET_MESSENGER_ListMessages *messages,
const char *path)
{
- GNUNET_assert((messages) && (path));
+ GNUNET_assert ((messages) && (path));
if (GNUNET_YES != GNUNET_DISK_file_test (path))
return;
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_READ, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_READ, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
struct GNUNET_HashCode hash;
ssize_t len;
do {
- len = GNUNET_DISK_file_read(handle, &hash, sizeof(hash));
+ len = GNUNET_DISK_file_read (handle, &hash, sizeof(hash));
if (len != sizeof(hash))
break;
- add_to_list_messages(messages, &hash);
+ add_to_list_messages (messages, &hash);
} while (len == sizeof(hash));
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_close (handle);
}
+
void
save_list_messages (const struct GNUNET_MESSENGER_ListMessages *messages,
const char *path)
{
- GNUNET_assert((messages) && (path));
+ GNUNET_assert ((messages) && (path));
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
struct GNUNET_MESSENGER_ListMessage *element;
for (element = messages->head; element; element = element->next)
- GNUNET_DISK_file_write(handle, &(element->hash), sizeof(element->hash));
+ GNUNET_DISK_file_write (handle, &(element->hash), sizeof(element->hash));
- GNUNET_DISK_file_sync(handle);
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_sync (handle);
+ GNUNET_DISK_file_close (handle);
}
diff --git a/src/messenger/gnunet-service-messenger_member.c
b/src/messenger/gnunet-service-messenger_member.c
index b483f315b..1bb3a9969 100644
--- a/src/messenger/gnunet-service-messenger_member.c
+++ b/src/messenger/gnunet-service-messenger_member.c
@@ -34,44 +34,50 @@ create_member (struct GNUNET_MESSENGER_MemberStore *store,
{
GNUNET_assert (store);
- struct GNUNET_MESSENGER_Member *member = GNUNET_new(struct
GNUNET_MESSENGER_Member);
+ struct GNUNET_MESSENGER_Member *member = GNUNET_new (struct
+
GNUNET_MESSENGER_Member);
member->store = store;
if (id)
- GNUNET_memcpy(&(member->id), id, sizeof(member->id));
- else if (GNUNET_YES != generate_free_member_id(&(member->id),
store->members))
+ GNUNET_memcpy (&(member->id), id, sizeof(member->id));
+ else if (GNUNET_YES != generate_free_member_id (&(member->id),
+ store->members))
{
GNUNET_free (member);
return NULL;
}
- member->sessions = GNUNET_CONTAINER_multihashmap_create(2, GNUNET_NO);
+ member->sessions = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO);
return member;
}
+
static int
iterate_destroy_session (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct GNUNET_MESSENGER_MemberSession *session = value;
- destroy_member_session(session);
+ destroy_member_session (session);
return GNUNET_YES;
}
+
void
destroy_member (struct GNUNET_MESSENGER_Member *member)
{
- GNUNET_assert((member) && (member->sessions));
+ GNUNET_assert ((member) && (member->sessions));
- GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
iterate_destroy_session, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_destroy_session, NULL);
GNUNET_CONTAINER_multihashmap_destroy (member->sessions);
GNUNET_free (member);
}
+
const struct GNUNET_ShortHashCode*
get_member_id (const struct GNUNET_MESSENGER_Member *member)
{
@@ -80,6 +86,7 @@ get_member_id (const struct GNUNET_MESSENGER_Member *member)
return &(member->id);
}
+
static int
callback_scan_for_sessions (void *cls,
const char *filename)
@@ -92,13 +99,14 @@ callback_scan_for_sessions (void *cls,
GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR);
- load_member_session(member, directory);
+ load_member_session (member, directory);
GNUNET_free (directory);
}
return GNUNET_OK;
}
+
void
load_member (struct GNUNET_MESSENGER_MemberStore *store,
const char *directory)
@@ -113,7 +121,8 @@ load_member (struct GNUNET_MESSENGER_MemberStore *store,
if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
goto free_config;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n",
config_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load member configuration: %s\n",
+ config_file);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
@@ -121,10 +130,11 @@ load_member (struct GNUNET_MESSENGER_MemberStore *store,
{
struct GNUNET_ShortHashCode id;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id,
sizeof(id)))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "member", "id", &id,
+ sizeof(id)))
goto destroy_config;
- member = add_store_member(store, &id);
+ member = add_store_member (store, &id);
}
destroy_config:
@@ -132,9 +142,9 @@ destroy_config:
GNUNET_CONFIGURATION_destroy (cfg);
free_config:
- GNUNET_free(config_file);
+ GNUNET_free (config_file);
- if (!member)
+ if (! member)
return;
char *scan_dir;
@@ -143,18 +153,20 @@ free_config:
if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_sessions, member);
- GNUNET_free(scan_dir);
+ GNUNET_free (scan_dir);
}
+
static int
iterate_load_next_session (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
- const char* sessions_directory = cls;
+ const char *sessions_directory = cls;
- char* load_dir;
- GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key),
DIR_SEPARATOR);
+ char *load_dir;
+ GNUNET_asprintf (&load_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key),
+ DIR_SEPARATOR);
struct GNUNET_MESSENGER_MemberSession *session = value;
@@ -165,29 +177,33 @@ iterate_load_next_session (void *cls,
return GNUNET_YES;
}
+
void
load_member_next_sessions (const struct GNUNET_MESSENGER_Member *member,
const char *directory)
{
GNUNET_assert ((member) && (directory));
- char* load_dir;
+ char *load_dir;
GNUNET_asprintf (&load_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
- GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
iterate_load_next_session, load_dir);
+ GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_load_next_session, load_dir);
- GNUNET_free(load_dir);
+ GNUNET_free (load_dir);
}
+
static int
iterate_save_session (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
- const char* sessions_directory = cls;
+ const char *sessions_directory = cls;
- char* save_dir;
- GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s(key),
DIR_SEPARATOR);
+ char *save_dir;
+ GNUNET_asprintf (&save_dir, "%s%s%c", sessions_directory, GNUNET_h2s (key),
+ DIR_SEPARATOR);
struct GNUNET_MESSENGER_MemberSession *session = value;
@@ -199,6 +215,7 @@ iterate_save_session (void *cls,
return GNUNET_YES;
}
+
void
save_member (struct GNUNET_MESSENGER_Member *member,
const char *directory)
@@ -208,39 +225,43 @@ save_member (struct GNUNET_MESSENGER_Member *member,
char *config_file;
GNUNET_asprintf (&config_file, "%s%s", directory, "member.cfg");
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n",
config_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save member configuration: %s\n",
+ config_file);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
- char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id),
sizeof(member->id));
+ char *id_data = GNUNET_STRINGS_data_to_string_alloc (&(member->id),
+ sizeof(member->id));
if (id_data)
{
GNUNET_CONFIGURATION_set_value_string (cfg, "member", "id", id_data);
- GNUNET_free(id_data);
+ GNUNET_free (id_data);
}
GNUNET_CONFIGURATION_write (cfg, config_file);
GNUNET_CONFIGURATION_destroy (cfg);
- GNUNET_free(config_file);
+ GNUNET_free (config_file);
- char* save_dir;
+ char *save_dir;
GNUNET_asprintf (&save_dir, "%s%s%c", directory, "sessions", DIR_SEPARATOR);
if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
(GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
- GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
iterate_save_session, save_dir);
+ GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_save_session, save_dir);
- GNUNET_free(save_dir);
+ GNUNET_free (save_dir);
}
+
static void
sync_session_contact_from_next (struct GNUNET_MESSENGER_MemberSession *session,
struct GNUNET_MESSENGER_MemberSession *next)
{
- GNUNET_assert((session) && (next));
+ GNUNET_assert ((session) && (next));
if (session == next)
return;
@@ -251,6 +272,7 @@ sync_session_contact_from_next (struct
GNUNET_MESSENGER_MemberSession *session,
session->contact = next->contact;
}
+
static int
iterate_sync_session_contact (void *cls,
const struct GNUNET_HashCode *key,
@@ -264,14 +286,17 @@ iterate_sync_session_contact (void *cls,
return GNUNET_YES;
}
+
void
sync_member_contacts (struct GNUNET_MESSENGER_Member *member)
{
GNUNET_assert ((member) && (member->sessions));
- GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
iterate_sync_session_contact, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_sync_session_contact, NULL);
}
+
struct GNUNET_MESSENGER_MemberSession*
get_member_session (const struct GNUNET_MESSENGER_Member *member,
const struct GNUNET_IDENTITY_PublicKey *public_key)
@@ -279,12 +304,14 @@ get_member_session (const struct GNUNET_MESSENGER_Member
*member,
GNUNET_assert ((member) && (public_key));
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+ GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
- return GNUNET_CONTAINER_multihashmap_get(member->sessions, &hash);
+ return GNUNET_CONTAINER_multihashmap_get (member->sessions, &hash);
}
-struct GNUNET_MESSENGER_ClosureSearchSession {
+
+struct GNUNET_MESSENGER_ClosureSearchSession
+{
const struct GNUNET_MESSENGER_Message *message;
const struct GNUNET_HashCode *hash;
@@ -296,43 +323,48 @@ iterate_search_session (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
- struct GNUNET_MESSENGER_ClosureSearchSession* search = cls;
+ struct GNUNET_MESSENGER_ClosureSearchSession *search = cls;
struct GNUNET_MESSENGER_MemberSession *session = value;
- if (GNUNET_OK != verify_member_session_as_sender(session, search->message,
search->hash))
+ if (GNUNET_OK != verify_member_session_as_sender (session, search->message,
+ search->hash))
return GNUNET_YES;
search->match = session;
return GNUNET_NO;
}
+
static struct GNUNET_MESSENGER_MemberSession*
try_member_session (struct GNUNET_MESSENGER_Member *member,
const struct GNUNET_IDENTITY_PublicKey *public_key)
{
- struct GNUNET_MESSENGER_MemberSession* session = get_member_session(member,
public_key);
+ struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member,
+
public_key);
if (session)
return session;
- session = create_member_session(member, public_key);
+ session = create_member_session (member, public_key);
if (session)
- add_member_session(member, session);
+ add_member_session (member, session);
return session;
}
+
struct GNUNET_MESSENGER_MemberSession*
get_member_session_of (struct GNUNET_MESSENGER_Member *member,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
GNUNET_assert ((member) && (message) && (hash) &&
- (0 == GNUNET_memcmp(&(member->id),
&(message->header.sender_id))));
+ (0 == GNUNET_memcmp (&(member->id),
+ &(message->header.sender_id))));
if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
- return try_member_session(member, &(message->body.join.key));
+ return try_member_session (member, &(message->body.join.key));
struct GNUNET_MESSENGER_ClosureSearchSession search;
@@ -340,49 +372,59 @@ get_member_session_of (struct GNUNET_MESSENGER_Member
*member,
search.hash = hash;
search.match = NULL;
- GNUNET_CONTAINER_multihashmap_iterate(member->sessions,
iterate_search_session, &search);
+ GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_search_session, &search);
return search.match;
}
+
void
add_member_session (struct GNUNET_MESSENGER_Member *member,
struct GNUNET_MESSENGER_MemberSession *session)
{
- if (!session)
+ if (! session)
return;
- GNUNET_assert((member) && (session->member == member));
+ GNUNET_assert ((member) && (session->member == member));
- const struct GNUNET_IDENTITY_PublicKey *public_key =
get_member_session_public_key(session);
+ const struct GNUNET_IDENTITY_PublicKey *public_key =
+ get_member_session_public_key (session);
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
-
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
- member->sessions, &hash, session,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Adding a member session failed:
%s\n",
- GNUNET_h2s(&hash));
+ GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
+
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
+ member->sessions, &hash, session,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Adding a member session failed: %s\n",
+ GNUNET_h2s (&hash));
}
+
void
remove_member_session (struct GNUNET_MESSENGER_Member *member,
struct GNUNET_MESSENGER_MemberSession *session)
{
GNUNET_assert ((member) && (session) && (session->member == member));
- const struct GNUNET_IDENTITY_PublicKey *public_key =
get_member_session_public_key(session);
+ const struct GNUNET_IDENTITY_PublicKey *public_key =
+ get_member_session_public_key (session);
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+ GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(member->sessions,
&hash, session))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Removing a member session failed:
%s\n",
- GNUNET_h2s(&hash));
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (member->sessions,
+ &hash, session))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Removing a member session failed: %s\n",
+ GNUNET_h2s (&hash));
}
-struct GNUNET_MESSENGER_ClosureIterateSessions {
+
+struct GNUNET_MESSENGER_ClosureIterateSessions
+{
GNUNET_MESSENGER_MemberIteratorCallback it;
void *cls;
};
@@ -395,9 +437,11 @@ iterate_member_sessions_it (void *cls,
struct GNUNET_MESSENGER_ClosureIterateSessions *iterate = cls;
struct GNUNET_MESSENGER_MemberSession *session = value;
- return iterate->it (iterate->cls, get_member_session_public_key(session),
session);
+ return iterate->it (iterate->cls, get_member_session_public_key (session),
+ session);
}
+
int
iterate_member_sessions (struct GNUNET_MESSENGER_Member *member,
GNUNET_MESSENGER_MemberIteratorCallback it,
@@ -410,5 +454,7 @@ iterate_member_sessions (struct GNUNET_MESSENGER_Member
*member,
iterate.it = it;
iterate.cls = cls;
- return GNUNET_CONTAINER_multihashmap_iterate(member->sessions,
iterate_member_sessions_it, &iterate);
+ return GNUNET_CONTAINER_multihashmap_iterate (member->sessions,
+ iterate_member_sessions_it,
+ &iterate);
}
diff --git a/src/messenger/gnunet-service-messenger_member.h
b/src/messenger/gnunet-service-messenger_member.h
index 0c5870fd3..dc3643727 100644
--- a/src/messenger/gnunet-service-messenger_member.h
+++ b/src/messenger/gnunet-service-messenger_member.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -175,6 +175,6 @@ remove_member_session (struct GNUNET_MESSENGER_Member
*member,
int
iterate_member_sessions (struct GNUNET_MESSENGER_Member *member,
GNUNET_MESSENGER_MemberIteratorCallback it,
- void* cls);
+ void *cls);
#endif //GNUNET_SERVICE_MESSENGER_MEMBER_H
diff --git a/src/messenger/gnunet-service-messenger_member_session.c
b/src/messenger/gnunet-service-messenger_member_session.c
index 2e26fd228..361fb9966 100644
--- a/src/messenger/gnunet-service-messenger_member_session.c
+++ b/src/messenger/gnunet-service-messenger_member_session.c
@@ -35,44 +35,46 @@ struct GNUNET_MESSENGER_MemberSession*
create_member_session (struct GNUNET_MESSENGER_Member *member,
const struct GNUNET_IDENTITY_PublicKey *pubkey)
{
- if ((!member) || (!pubkey) || (!(member->store)))
+ if ((! member) || (! pubkey) || (! (member->store)))
return NULL;
- struct GNUNET_MESSENGER_MemberSession *session = GNUNET_new(struct
GNUNET_MESSENGER_MemberSession);
+ struct GNUNET_MESSENGER_MemberSession *session = GNUNET_new (struct
+
GNUNET_MESSENGER_MemberSession);
session->member = member;
- GNUNET_memcpy(&(session->public_key), pubkey, sizeof(session->public_key));
+ GNUNET_memcpy (&(session->public_key), pubkey, sizeof(session->public_key));
get_context_from_member (
- get_member_session_key (session),
- get_member_session_id (session),
- &(session->context)
- );
+ get_member_session_key (session),
+ get_member_session_id (session),
+ &(session->context)
+ );
- struct GNUNET_MESSENGER_ContactStore *store =
get_member_contact_store(session->member->store);
+ struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store (
+ session->member->store);
- session->contact = get_store_contact(
- store,
- get_member_session_context (session),
- get_member_session_public_key (session)
- );
+ session->contact = get_store_contact (
+ store,
+ get_member_session_context (session),
+ get_member_session_public_key (session)
+ );
- if (!(session->contact))
+ if (! (session->contact))
{
- GNUNET_free(session);
+ GNUNET_free (session);
return NULL;
}
increase_contact_rc (session->contact);
- session->history = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
+ session->history = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
- init_list_messages(&(session->messages));
+ init_list_messages (&(session->messages));
session->prev = NULL;
session->next = NULL;
- session->start = GNUNET_TIME_absolute_get();
+ session->start = GNUNET_TIME_absolute_get ();
session->closed = GNUNET_NO;
session->completed = GNUNET_NO;
@@ -80,32 +82,35 @@ create_member_session (struct GNUNET_MESSENGER_Member
*member,
return session;
}
+
static void
check_member_session_completion (struct GNUNET_MESSENGER_MemberSession
*session)
{
GNUNET_assert (session);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Check session history (%s) for
completion.\n",
- GNUNET_sh2s(get_member_session_id(session)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Check session history (%s) for completion.\n",
+ GNUNET_sh2s (get_member_session_id (session)));
- if (!session->messages.tail)
+ if (! session->messages.tail)
{
session->completed = GNUNET_YES;
goto completion;
}
- const struct GNUNET_HashCode* start = &(session->messages.head->hash);
- const struct GNUNET_HashCode* end = &(session->messages.tail->hash);
+ const struct GNUNET_HashCode *start = &(session->messages.head->hash);
+ const struct GNUNET_HashCode *end = &(session->messages.tail->hash);
struct GNUNET_MESSENGER_ListMessages level;
- init_list_messages(&level);
+ init_list_messages (&level);
- add_to_list_messages(&level, end);
+ add_to_list_messages (&level, end);
- struct GNUNET_MESSENGER_MessageStore *store =
get_srv_room_message_store(session->member->store->room);
+ struct GNUNET_MESSENGER_MessageStore *store = get_srv_room_message_store (
+ session->member->store->room);
struct GNUNET_MESSENGER_ListMessages list;
- init_list_messages(&list);
+ init_list_messages (&list);
while (level.head)
{
@@ -113,57 +118,61 @@ check_member_session_completion (struct
GNUNET_MESSENGER_MemberSession *session)
for (element = level.head; element; element = element->next)
{
- const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link(
- store, &(element->hash), GNUNET_NO
- );
+ const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link
(
+ store, &(element->hash), GNUNET_NO
+ );
- if (!link)
+ if (! link)
continue;
- add_to_list_messages(&list, &(link->first));
+ add_to_list_messages (&list, &(link->first));
if (GNUNET_YES == link->multiple)
- add_to_list_messages(&list, &(link->second));
+ add_to_list_messages (&list, &(link->second));
}
- clear_list_messages(&level);
+ clear_list_messages (&level);
for (element = list.head; element; element = element->next)
- if (GNUNET_YES == check_member_session_history(session,
&(element->hash), GNUNET_YES))
+ if (GNUNET_YES == check_member_session_history (session,
&(element->hash),
+ GNUNET_YES))
break;
if (element)
- if (0 != GNUNET_CRYPTO_hash_cmp(&(element->hash), start))
- add_to_list_messages(&level, &(element->hash));
+ if (0 != GNUNET_CRYPTO_hash_cmp (&(element->hash), start))
+ add_to_list_messages (&level, &(element->hash));
else
session->completed = GNUNET_YES;
else
- copy_list_messages(&level, &list);
+ copy_list_messages (&level, &list);
- clear_list_messages(&list);
+ clear_list_messages (&list);
}
completion:
- if (GNUNET_YES == is_member_session_completed(session))
+ if (GNUNET_YES == is_member_session_completed (session))
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
- GNUNET_sh2s(get_member_session_id(session)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
+ GNUNET_sh2s (get_member_session_id (session)));
GNUNET_CONTAINER_multihashmap_clear (session->history);
- struct GNUNET_MESSENGER_ContactStore *store =
get_member_contact_store(session->member->store);
+ struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store (
+ session->member->store);
- if ((session->contact) && (GNUNET_YES == decrease_contact_rc
(session->contact)))
+ if ((session->contact) && (GNUNET_YES == decrease_contact_rc (
+ session->contact)))
remove_store_contact (
- store,
- session->contact,
- get_member_session_context(session)
- );
+ store,
+ session->contact,
+ get_member_session_context (session)
+ );
session->contact = NULL;
}
}
+
static int
iterate_copy_history (void *cls,
const struct GNUNET_HashCode *key,
@@ -171,73 +180,79 @@ iterate_copy_history (void *cls,
{
struct GNUNET_MESSENGER_MemberSession *next = cls;
- GNUNET_CONTAINER_multihashmap_put(next->history, key, (value? next : NULL),
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ GNUNET_CONTAINER_multihashmap_put (next->history, key, (value? next : NULL),
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
return GNUNET_YES;
}
+
struct GNUNET_MESSENGER_MemberSession*
switch_member_session (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- if ((!session) || (!message) || (!hash))
+ if ((! session) || (! message) || (! hash))
return NULL;
- GNUNET_assert((GNUNET_MESSENGER_KIND_ID == message->header.kind) ||
- (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
+ GNUNET_assert ((GNUNET_MESSENGER_KIND_ID == message->header.kind) ||
+ (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
- struct GNUNET_MESSENGER_MemberSession *next = GNUNET_new(struct
GNUNET_MESSENGER_MemberSession);
+ struct GNUNET_MESSENGER_MemberSession *next = GNUNET_new (struct
+
GNUNET_MESSENGER_MemberSession);
if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
- next->member = add_store_member(session->member->store,
&(message->body.id.id));
+ next->member = add_store_member (session->member->store,
+ &(message->body.id.id));
else
next->member = session->member;
if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
- GNUNET_memcpy(&(next->public_key), &(message->body.key.key),
sizeof(next->public_key));
+ GNUNET_memcpy (&(next->public_key), &(message->body.key.key),
+ sizeof(next->public_key));
else
- GNUNET_memcpy(&(next->public_key), get_member_session_public_key(session),
sizeof(next->public_key));
+ GNUNET_memcpy (&(next->public_key), get_member_session_public_key
(session),
+ sizeof(next->public_key));
get_context_from_member (
- get_member_session_key (next),
- get_member_session_id (next),
- &(next->context)
- );
-
- update_store_contact(
- get_member_contact_store(next->member->store),
- get_member_session_contact(session),
- get_member_session_context(session),
- get_member_session_context(next),
- get_member_session_public_key(next)
- );
-
- next->contact = get_member_session_contact(session);
-
- if (!(next->contact))
+ get_member_session_key (next),
+ get_member_session_id (next),
+ &(next->context)
+ );
+
+ update_store_contact (
+ get_member_contact_store (next->member->store),
+ get_member_session_contact (session),
+ get_member_session_context (session),
+ get_member_session_context (next),
+ get_member_session_public_key (next)
+ );
+
+ next->contact = get_member_session_contact (session);
+
+ if (! (next->contact))
{
- GNUNET_free(next);
+ GNUNET_free (next);
return NULL;
}
increase_contact_rc (next->contact);
- next->history = GNUNET_CONTAINER_multihashmap_create(
- GNUNET_CONTAINER_multihashmap_size(session->history), GNUNET_NO
- );
+ next->history = GNUNET_CONTAINER_multihashmap_create (
+ GNUNET_CONTAINER_multihashmap_size (session->history), GNUNET_NO
+ );
- GNUNET_CONTAINER_multihashmap_iterate(session->history,
iterate_copy_history, next);
+ GNUNET_CONTAINER_multihashmap_iterate (session->history,
iterate_copy_history,
+ next);
- init_list_messages(&(next->messages));
- copy_list_messages(&(next->messages), &(session->messages));
+ init_list_messages (&(next->messages));
+ copy_list_messages (&(next->messages), &(session->messages));
session->next = next;
next->prev = session;
next->next = NULL;
- next->start = GNUNET_TIME_absolute_get();
+ next->start = GNUNET_TIME_absolute_get ();
session->closed = GNUNET_YES;
next->closed = GNUNET_NO;
@@ -248,8 +263,9 @@ switch_member_session (struct
GNUNET_MESSENGER_MemberSession *session,
return next;
}
+
void
-destroy_member_session(struct GNUNET_MESSENGER_MemberSession* session)
+destroy_member_session (struct GNUNET_MESSENGER_MemberSession *session)
{
GNUNET_assert (session);
@@ -257,32 +273,35 @@ destroy_member_session(struct
GNUNET_MESSENGER_MemberSession* session)
clear_list_messages (&(session->messages));
- struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact
(session);
+ struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (
+ session);
if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
remove_store_contact (
- get_member_contact_store(session->member->store),
- contact,
- get_member_session_context(session)
- );
+ get_member_contact_store (session->member->store),
+ contact,
+ get_member_session_context (session)
+ );
- GNUNET_free(session);
+ GNUNET_free (session);
}
+
int
-reset_member_session (struct GNUNET_MESSENGER_MemberSession* session,
+reset_member_session (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash)
{
GNUNET_assert ((session) && (hash));
- struct GNUNET_MESSENGER_ContactStore *store =
get_member_contact_store(session->member->store);
- struct GNUNET_MESSENGER_Contact *contact = get_store_contact(
- store,
- get_member_session_context (session),
- get_member_session_public_key (session)
- );
+ struct GNUNET_MESSENGER_ContactStore *store = get_member_contact_store (
+ session->member->store);
+ struct GNUNET_MESSENGER_Contact *contact = get_store_contact (
+ store,
+ get_member_session_context (session),
+ get_member_session_public_key (session)
+ );
- if (!contact)
+ if (! contact)
return GNUNET_SYSERR;
if (contact == session->contact)
@@ -292,8 +311,8 @@ reset_member_session (struct
GNUNET_MESSENGER_MemberSession* session,
increase_contact_rc (session->contact);
clear_messages:
- clear_list_messages(&(session->messages));
- add_to_list_messages(&(session->messages), hash);
+ clear_list_messages (&(session->messages));
+ add_to_list_messages (&(session->messages), hash);
session->next = NULL;
session->closed = GNUNET_NO;
@@ -302,8 +321,9 @@ clear_messages:
return GNUNET_OK;
}
+
void
-close_member_session (struct GNUNET_MESSENGER_MemberSession* session)
+close_member_session (struct GNUNET_MESSENGER_MemberSession *session)
{
GNUNET_assert (session);
@@ -311,132 +331,158 @@ close_member_session (struct
GNUNET_MESSENGER_MemberSession* session)
check_member_session_completion (session);
}
+
int
-is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession* session)
+is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
return session->closed;
}
+
int
-is_member_session_completed (const struct GNUNET_MESSENGER_MemberSession*
session)
+is_member_session_completed (const struct
+ GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
return session->completed;
}
+
struct GNUNET_TIME_Absolute
-get_member_session_start (const struct GNUNET_MESSENGER_MemberSession* session)
+get_member_session_start (const struct GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
if (session->prev)
- return get_member_session_start(session->prev);
+ return get_member_session_start (session->prev);
return session->start;
}
+
const struct GNUNET_HashCode*
-get_member_session_key (const struct GNUNET_MESSENGER_MemberSession* session)
+get_member_session_key (const struct GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert((session) && (session->member));
+ GNUNET_assert ((session) && (session->member));
- return get_member_store_key(session->member->store);
+ return get_member_store_key (session->member->store);
}
+
const struct GNUNET_ShortHashCode*
-get_member_session_id (const struct GNUNET_MESSENGER_MemberSession* session)
+get_member_session_id (const struct GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
- return get_member_id(session->member);
+ return get_member_id (session->member);
}
+
const struct GNUNET_IDENTITY_PublicKey*
-get_member_session_public_key (const struct GNUNET_MESSENGER_MemberSession*
session)
+get_member_session_public_key (const struct
+ GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
return &(session->public_key);
}
+
const struct GNUNET_HashCode*
-get_member_session_context (const struct GNUNET_MESSENGER_MemberSession*
session)
+get_member_session_context (const struct
+ GNUNET_MESSENGER_MemberSession *session)
{
- GNUNET_assert(session);
+ GNUNET_assert (session);
return &(session->context);
}
+
struct GNUNET_MESSENGER_Contact*
-get_member_session_contact (struct GNUNET_MESSENGER_MemberSession* session)
+get_member_session_contact (struct GNUNET_MESSENGER_MemberSession *session)
{
GNUNET_assert (session);
return session->contact;
}
-int verify_member_session_as_sender (const struct
GNUNET_MESSENGER_MemberSession *session,
- const struct GNUNET_MESSENGER_Message
*message,
- const struct GNUNET_HashCode *hash)
+
+int
+verify_member_session_as_sender (const struct
+ GNUNET_MESSENGER_MemberSession *session,
+ const struct GNUNET_MESSENGER_Message
*message,
+ const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((session) && (message) && (hash));
+ GNUNET_assert ((session) && (message) && (hash));
if (GNUNET_YES == is_member_session_completed (session))
return GNUNET_SYSERR;
- if (0 != GNUNET_memcmp (get_member_session_id (session),
&(message->header.sender_id)))
+ if (0 != GNUNET_memcmp (get_member_session_id (session),
+ &(message->header.sender_id)))
return GNUNET_SYSERR;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
GNUNET_h2s (hash),
- GNUNET_IDENTITY_public_key_to_string
(get_member_session_public_key (session)));
+ GNUNET_IDENTITY_public_key_to_string (
+ get_member_session_public_key (session)));
- return verify_message (message, hash, get_member_session_public_key
(session));
+ return verify_message (message, hash, get_member_session_public_key (
+ session));
}
+
int
-check_member_session_history (const struct GNUNET_MESSENGER_MemberSession
*session,
+check_member_session_history (const struct
+ GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash, int
ownership)
{
- GNUNET_assert((session) && (hash));
+ GNUNET_assert ((session) && (hash));
if (GNUNET_YES == ownership)
- return (NULL != GNUNET_CONTAINER_multihashmap_get(session->history, hash)?
GNUNET_YES : GNUNET_NO);
+ return (NULL != GNUNET_CONTAINER_multihashmap_get (session->history, hash)?
+ GNUNET_YES : GNUNET_NO);
else
- return GNUNET_CONTAINER_multihashmap_contains(session->history, hash);
+ return GNUNET_CONTAINER_multihashmap_contains (session->history, hash);
}
+
static void
update_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash, int ownership)
{
GNUNET_assert ((session) && (hash));
- if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(session->history, hash,
(GNUNET_YES == ownership? session : NULL),
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) && (session->next))
+ if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (session->history, hash,
+ (GNUNET_YES ==
ownership?
+ session : NULL),
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ && (session->next))
update_member_chain_history (session->next, hash, ownership);
}
+
void
update_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((session) && (message) && (hash));
+ GNUNET_assert ((session) && (message) && (hash));
- if (GNUNET_YES == is_member_session_completed(session))
+ if (GNUNET_YES == is_member_session_completed (session))
return;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating sessions history (%s) +=
(%s)\n",
- GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Updating sessions history (%s) += (%s)\n",
+ GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s
(hash));
if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
{
if (GNUNET_YES == is_message_session_bound (message))
- add_to_list_messages(&(session->messages), hash);
+ add_to_list_messages (&(session->messages), hash);
update_member_chain_history (session, hash, GNUNET_YES);
}
@@ -444,28 +490,32 @@ update_member_session_history (struct
GNUNET_MESSENGER_MemberSession *session,
update_member_chain_history (session, hash, GNUNET_NO);
if (GNUNET_YES == session->closed)
- check_member_session_completion(session);
+ check_member_session_completion (session);
}
+
static void
clear_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash)
{
GNUNET_assert ((session) && (hash));
- if ((0 < GNUNET_CONTAINER_multihashmap_remove_all(session->history, hash))
&& (session->next))
- clear_member_session_history(session->next, hash);
+ if ((0 < GNUNET_CONTAINER_multihashmap_remove_all (session->history, hash))
&&
+ (session->next))
+ clear_member_session_history (session->next, hash);
}
+
void
clear_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((session) && (hash));
+ GNUNET_assert ((session) && (hash));
clear_member_chain_history (session, hash);
}
+
struct GNUNET_MESSENGER_MemberSessionHistoryEntry
{
struct GNUNET_HashCode hash;
@@ -476,21 +526,22 @@ static void
load_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
const char *path)
{
- GNUNET_assert((session) && (path));
+ GNUNET_assert ((session) && (path));
if (GNUNET_YES != GNUNET_DISK_file_test (path))
return;
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_READ, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_READ, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
struct GNUNET_MESSENGER_MemberSessionHistoryEntry entry;
ssize_t len;
@@ -498,23 +549,27 @@ load_member_session_history (struct
GNUNET_MESSENGER_MemberSession *session,
int status;
do {
- len = GNUNET_DISK_file_read(handle, &(entry.hash), sizeof(entry.hash));
+ len = GNUNET_DISK_file_read (handle, &(entry.hash), sizeof(entry.hash));
if (len != sizeof(entry.hash))
break;
- len = GNUNET_DISK_file_read(handle, &(entry.ownership),
sizeof(entry.ownership));
+ len = GNUNET_DISK_file_read (handle, &(entry.ownership),
+ sizeof(entry.ownership));
if (len != sizeof(entry.ownership))
break;
- status = GNUNET_CONTAINER_multihashmap_put(session->history,
&(entry.hash), (entry.ownership? session : NULL),
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ status = GNUNET_CONTAINER_multihashmap_put (session->history,
&(entry.hash),
+ (entry.ownership? session :
+ NULL),
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
} while (status == GNUNET_OK);
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_close (handle);
}
+
void
load_member_session (struct GNUNET_MESSENGER_Member *member,
const char *directory)
@@ -529,7 +584,8 @@ load_member_session (struct GNUNET_MESSENGER_Member *member,
if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
goto free_config;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load session configuration of member:
%s\n", config_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Load session configuration of member: %s\n", config_file);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
@@ -537,61 +593,71 @@ load_member_session (struct GNUNET_MESSENGER_Member
*member,
{
char *key_data;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session",
"key", &key_data))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "session",
+ "key", &key_data))
goto destroy_config;
struct GNUNET_IDENTITY_PublicKey key;
- enum GNUNET_GenericReturnValue key_return =
GNUNET_IDENTITY_public_key_from_string(key_data, &key);
+ enum GNUNET_GenericReturnValue key_return =
+ GNUNET_IDENTITY_public_key_from_string (key_data, &key);
- GNUNET_free(key_data);
+ GNUNET_free (key_data);
if (GNUNET_OK != key_return)
goto destroy_config;
- session = create_member_session(member, &key);
+ session = create_member_session (member, &key);
unsigned long long numeric_value;
- if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session",
"start", &numeric_value))
+ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
+ "start",
+ &numeric_value))
session->start.abs_value_us = numeric_value;
- if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session",
"closed", &numeric_value))
+ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
+ "closed",
+ &numeric_value))
session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
- if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session",
"completed", &numeric_value))
- session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
GNUNET_NO);
+ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
+ "completed",
+ &numeric_value))
+ session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
+ GNUNET_NO);
}
destroy_config:
GNUNET_CONFIGURATION_destroy (cfg);
free_config:
- GNUNET_free(config_file);
+ GNUNET_free (config_file);
- if (!session)
+ if (! session)
return;
char *history_file;
GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
load_member_session_history (session, history_file);
- GNUNET_free(history_file);
+ GNUNET_free (history_file);
char *messages_file;
GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
- load_list_messages(&(session->messages), messages_file);
- GNUNET_free(messages_file);
+ load_list_messages (&(session->messages), messages_file);
+ GNUNET_free (messages_file);
- add_member_session(member, session);
+ add_member_session (member, session);
}
+
static struct GNUNET_MESSENGER_MemberSession*
get_cycle_safe_next_session (struct GNUNET_MESSENGER_MemberSession *session,
struct GNUNET_MESSENGER_MemberSession *next)
{
- if (!next)
+ if (! next)
return NULL;
struct GNUNET_MESSENGER_MemberSession *check = next;
@@ -606,6 +672,7 @@ get_cycle_safe_next_session (struct
GNUNET_MESSENGER_MemberSession *session,
return next;
}
+
void
load_member_session_next (struct GNUNET_MESSENGER_MemberSession *session,
const char *directory)
@@ -618,7 +685,8 @@ load_member_session_next (struct
GNUNET_MESSENGER_MemberSession *session,
if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
goto free_config;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load next session configuration of
member: %s\n", config_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Load next session configuration of member: %s\n", config_file);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
@@ -626,28 +694,33 @@ load_member_session_next (struct
GNUNET_MESSENGER_MemberSession *session,
{
char *key_data;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session",
"next_key", &key_data))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "session",
+ "next_key",
+ &key_data))
goto destroy_config;
struct GNUNET_IDENTITY_PublicKey next_key;
- enum GNUNET_GenericReturnValue key_return =
GNUNET_IDENTITY_public_key_from_string(key_data, &next_key);
+ enum GNUNET_GenericReturnValue key_return =
+ GNUNET_IDENTITY_public_key_from_string (key_data, &next_key);
- GNUNET_free(key_data);
+ GNUNET_free (key_data);
if (GNUNET_OK != key_return)
goto destroy_config;
struct GNUNET_ShortHashCode next_id;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
&next_id, sizeof(next_id)))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
+ &next_id, sizeof(next_id)))
goto destroy_config;
- struct GNUNET_MESSENGER_Member *member =
get_store_member(session->member->store, &next_id);
+ struct GNUNET_MESSENGER_Member *member = get_store_member (
+ session->member->store, &next_id);
- session->next = get_cycle_safe_next_session(
- session, member? get_member_session (member, &next_key) : NULL
- );
+ session->next = get_cycle_safe_next_session (
+ session, member? get_member_session (member, &next_key) : NULL
+ );
if (session->next)
session->next->prev = session;
@@ -657,9 +730,10 @@ destroy_config:
GNUNET_CONFIGURATION_destroy (cfg);
free_config:
- GNUNET_free(config_file);
+ GNUNET_free (config_file);
}
+
static int
iterate_save_member_session_history_hentries (void *cls,
const struct GNUNET_HashCode
*key,
@@ -668,39 +742,42 @@ iterate_save_member_session_history_hentries (void *cls,
struct GNUNET_DISK_FileHandle *handle = cls;
unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
- GNUNET_DISK_file_write(handle, key, sizeof(*key));
- GNUNET_DISK_file_write(handle, &ownership, sizeof(ownership));
+ GNUNET_DISK_file_write (handle, key, sizeof(*key));
+ GNUNET_DISK_file_write (handle, &ownership, sizeof(ownership));
return GNUNET_YES;
}
+
static void
save_member_session_history (struct GNUNET_MESSENGER_MemberSession *session,
const char *path)
{
- GNUNET_assert((session) && (path));
+ GNUNET_assert ((session) && (path));
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
- GNUNET_CONTAINER_multihashmap_iterate(
- session->history,
- iterate_save_member_session_history_hentries,
- handle
- );
+ GNUNET_CONTAINER_multihashmap_iterate (
+ session->history,
+ iterate_save_member_session_history_hentries,
+ handle
+ );
- GNUNET_DISK_file_sync(handle);
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_sync (handle);
+ GNUNET_DISK_file_close (handle);
}
+
void
save_member_session (struct GNUNET_MESSENGER_MemberSession *session,
const char *directory)
@@ -710,61 +787,71 @@ save_member_session (struct
GNUNET_MESSENGER_MemberSession *session,
char *config_file;
GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save session configuration of member:
%s\n", config_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Save session configuration of member: %s\n", config_file);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
- char *key_data =
GNUNET_IDENTITY_public_key_to_string(get_member_session_public_key(session));
+ char *key_data = GNUNET_IDENTITY_public_key_to_string (
+ get_member_session_public_key (session));
if (key_data)
{
GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
- GNUNET_free(key_data);
+ GNUNET_free (key_data);
}
if (session->next)
{
- const struct GNUNET_ShortHashCode *next_id =
get_member_session_id(session->next);
+ const struct GNUNET_ShortHashCode *next_id = get_member_session_id (
+ session->next);
- char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
sizeof(*next_id));
+ char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
+
sizeof(*next_id));
if (next_id_data)
{
- GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
next_id_data);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
+ next_id_data);
- GNUNET_free(next_id_data);
+ GNUNET_free (next_id_data);
}
- key_data =
GNUNET_IDENTITY_public_key_to_string(get_member_session_public_key(session->next));
+ key_data = GNUNET_IDENTITY_public_key_to_string (
+ get_member_session_public_key (session->next));
if (key_data)
{
- GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
key_data);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
+ key_data);
- GNUNET_free(key_data);
+ GNUNET_free (key_data);
}
}
- GNUNET_CONFIGURATION_set_value_number(cfg, "session", "start",
session->start.abs_value_us);
+ GNUNET_CONFIGURATION_set_value_number (cfg, "session", "start",
+ session->start.abs_value_us);
- GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
session->closed);
- GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
session->completed);
+ GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
+ session->closed);
+ GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
+ session->completed);
GNUNET_CONFIGURATION_write (cfg, config_file);
GNUNET_CONFIGURATION_destroy (cfg);
- GNUNET_free(config_file);
+ GNUNET_free (config_file);
char *history_file;
GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
save_member_session_history (session, history_file);
- GNUNET_free(history_file);
+ GNUNET_free (history_file);
char *messages_file;
GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
- save_list_messages(&(session->messages), messages_file);
- GNUNET_free(messages_file);
+ save_list_messages (&(session->messages), messages_file);
+ GNUNET_free (messages_file);
}
diff --git a/src/messenger/gnunet-service-messenger_member_session.h
b/src/messenger/gnunet-service-messenger_member_session.h
index 9b4065d05..8a4143058 100644
--- a/src/messenger/gnunet-service-messenger_member_session.h
+++ b/src/messenger/gnunet-service-messenger_member_session.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -35,7 +35,8 @@
#include "messenger_api_contact.h"
-struct GNUNET_MESSENGER_MemberSession {
+struct GNUNET_MESSENGER_MemberSession
+{
struct GNUNET_MESSENGER_Member *member;
struct GNUNET_IDENTITY_PublicKey public_key;
@@ -46,8 +47,8 @@ struct GNUNET_MESSENGER_MemberSession {
struct GNUNET_CONTAINER_MultiHashMap *history;
struct GNUNET_MESSENGER_ListMessages messages;
- struct GNUNET_MESSENGER_MemberSession* prev;
- struct GNUNET_MESSENGER_MemberSession* next;
+ struct GNUNET_MESSENGER_MemberSession *prev;
+ struct GNUNET_MESSENGER_MemberSession *next;
struct GNUNET_TIME_Absolute start;
@@ -92,7 +93,7 @@ switch_member_session (struct GNUNET_MESSENGER_MemberSession
*session,
* @param[in,out] session Member session
*/
void
-destroy_member_session(struct GNUNET_MESSENGER_MemberSession* session);
+destroy_member_session (struct GNUNET_MESSENGER_MemberSession *session);
/**
* Resets a given member <i>session</i> which re-opens a member
@@ -105,7 +106,7 @@ destroy_member_session(struct
GNUNET_MESSENGER_MemberSession* session);
* @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
*/
int
-reset_member_session (struct GNUNET_MESSENGER_MemberSession* session,
+reset_member_session (struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash);
/**
@@ -118,7 +119,7 @@ reset_member_session (struct
GNUNET_MESSENGER_MemberSession* session,
* @param[in,out] session Member session
*/
void
-close_member_session (struct GNUNET_MESSENGER_MemberSession* session);
+close_member_session (struct GNUNET_MESSENGER_MemberSession *session);
/**
* Returns if the given member <i>session</i> has been closed.
@@ -127,7 +128,7 @@ close_member_session (struct
GNUNET_MESSENGER_MemberSession* session);
* @return #GNUNET_YES or #GNUNET_NO
*/
int
-is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession*
session);
+is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession
*session);
/**
* Returns if the given member <i>session</i> has been completed.
@@ -139,7 +140,8 @@ is_member_session_closed (const struct
GNUNET_MESSENGER_MemberSession* session);
* @return #GNUNET_YES or #GNUNET_NO
*/
int
-is_member_session_completed (const struct GNUNET_MESSENGER_MemberSession*
session);
+is_member_session_completed (const struct
+ GNUNET_MESSENGER_MemberSession *session);
/**
* Returns the timestamp of the member <i>session</i>'s start.
@@ -148,7 +150,7 @@ is_member_session_completed (const struct
GNUNET_MESSENGER_MemberSession* sessio
* @return Absolute timestamp
*/
struct GNUNET_TIME_Absolute
-get_member_session_start (const struct GNUNET_MESSENGER_MemberSession*
session);
+get_member_session_start (const struct GNUNET_MESSENGER_MemberSession
*session);
/**
* Returns the key of the room a given member <i>session</i> belongs to.
@@ -157,7 +159,7 @@ get_member_session_start (const struct
GNUNET_MESSENGER_MemberSession* session);
* @return Key of room
*/
const struct GNUNET_HashCode*
-get_member_session_key (const struct GNUNET_MESSENGER_MemberSession* session);
+get_member_session_key (const struct GNUNET_MESSENGER_MemberSession *session);
/**
* Returns the member id of a given member <i>session</i>.
@@ -166,7 +168,7 @@ get_member_session_key (const struct
GNUNET_MESSENGER_MemberSession* session);
* @return Member id
*/
const struct GNUNET_ShortHashCode*
-get_member_session_id (const struct GNUNET_MESSENGER_MemberSession* session);
+get_member_session_id (const struct GNUNET_MESSENGER_MemberSession *session);
/**
* Returns the public key from an EGO of a given member <i>session</i>.
@@ -175,7 +177,8 @@ get_member_session_id (const struct
GNUNET_MESSENGER_MemberSession* session);
* @return Public key of EGO
*/
const struct GNUNET_IDENTITY_PublicKey*
-get_member_session_public_key (const struct GNUNET_MESSENGER_MemberSession*
session);
+get_member_session_public_key (const struct
+ GNUNET_MESSENGER_MemberSession *session);
/**
* Returns the member context of a given member <i>session</i>.
@@ -184,7 +187,8 @@ get_member_session_public_key (const struct
GNUNET_MESSENGER_MemberSession* sess
* @return Member context as hash
*/
const struct GNUNET_HashCode*
-get_member_session_context (const struct GNUNET_MESSENGER_MemberSession*
session);
+get_member_session_context (const struct
+ GNUNET_MESSENGER_MemberSession *session);
/**
* Returns the contact which is connected to a given member <i>session</i>.
@@ -193,7 +197,7 @@ get_member_session_context (const struct
GNUNET_MESSENGER_MemberSession* session
* @return Contact
*/
struct GNUNET_MESSENGER_Contact*
-get_member_session_contact (struct GNUNET_MESSENGER_MemberSession* session);
+get_member_session_contact (struct GNUNET_MESSENGER_MemberSession *session);
/**
* Verifies a given member <i>session</i> as sender of a selected
<i>message</i> and
@@ -208,7 +212,8 @@ get_member_session_contact (struct
GNUNET_MESSENGER_MemberSession* session);
* @return #GNUNET_OK on success, otherwise #GNUNET_SYSERR
*/
int
-verify_member_session_as_sender (const struct GNUNET_MESSENGER_MemberSession
*session,
+verify_member_session_as_sender (const struct
+ GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_MESSENGER_Message
*message,
const struct GNUNET_HashCode *hash);
@@ -223,7 +228,8 @@ verify_member_session_as_sender (const struct
GNUNET_MESSENGER_MemberSession *se
* @return #GNUNET_YES if found, otherwise #GNUNET_NO
*/
int
-check_member_session_history (const struct GNUNET_MESSENGER_MemberSession
*session,
+check_member_session_history (const struct
+ GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash,
int ownership);
diff --git a/src/messenger/gnunet-service-messenger_member_store.c
b/src/messenger/gnunet-service-messenger_member_store.c
index 8b2bd7ac8..e7876b382 100644
--- a/src/messenger/gnunet-service-messenger_member_store.c
+++ b/src/messenger/gnunet-service-messenger_member_store.c
@@ -37,25 +37,28 @@ init_member_store (struct GNUNET_MESSENGER_MemberStore
*store,
GNUNET_assert ((store) && (room));
store->room = room;
- store->members = GNUNET_CONTAINER_multishortmap_create(8, GNUNET_NO);
+ store->members = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
}
+
static int
iterate_destroy_members (void *cls,
const struct GNUNET_ShortHashCode *key,
void *value)
{
struct GNUNET_MESSENGER_Member *member = value;
- destroy_member(member);
+ destroy_member (member);
return GNUNET_YES;
}
+
void
clear_member_store (struct GNUNET_MESSENGER_MemberStore *store)
{
GNUNET_assert ((store) && (store->members));
- GNUNET_CONTAINER_multishortmap_iterate (store->members,
iterate_destroy_members, NULL);
+ GNUNET_CONTAINER_multishortmap_iterate (store->members,
+ iterate_destroy_members, NULL);
GNUNET_CONTAINER_multishortmap_destroy (store->members);
}
@@ -67,17 +70,20 @@ get_member_contact_store (struct
GNUNET_MESSENGER_MemberStore *store)
struct GNUNET_MESSENGER_SrvRoom *room = store->room;
- return get_service_contact_store(room->service);
+ return get_service_contact_store (room->service);
}
+
const struct GNUNET_HashCode*
get_member_store_key (const struct GNUNET_MESSENGER_MemberStore *store)
{
GNUNET_assert (store);
- return get_srv_room_key((const struct GNUNET_MESSENGER_SrvRoom*)
store->room);
+ return get_srv_room_key ((const struct
+ GNUNET_MESSENGER_SrvRoom*) store->room);
}
+
static int
callback_scan_for_members (void *cls,
const char *filename)
@@ -90,14 +96,15 @@ callback_scan_for_members (void *cls,
GNUNET_asprintf (&directory, "%s%c", filename, DIR_SEPARATOR);
- load_member(store, directory);
+ load_member (store, directory);
- GNUNET_free(directory);
+ GNUNET_free (directory);
}
return GNUNET_OK;
}
+
static int
iterate_load_next_member_sessions (void *cls,
const struct GNUNET_ShortHashCode *id,
@@ -107,19 +114,21 @@ iterate_load_next_member_sessions (void *cls,
struct GNUNET_MESSENGER_Member *member = value;
- if (!member)
+ if (! member)
return GNUNET_YES;
char *member_dir;
- GNUNET_asprintf (&member_dir, "%s%s%c", sync_dir, GNUNET_sh2s(id),
DIR_SEPARATOR);
+ GNUNET_asprintf (&member_dir, "%s%s%c", sync_dir, GNUNET_sh2s (id),
+ DIR_SEPARATOR);
if (GNUNET_YES == GNUNET_DISK_directory_test (member_dir, GNUNET_YES))
load_member_next_sessions (member, member_dir);
- GNUNET_free(member_dir);
+ GNUNET_free (member_dir);
return GNUNET_YES;
}
+
static int
iterate_sync_member_contacts (void *cls,
const struct GNUNET_ShortHashCode *id,
@@ -127,13 +136,14 @@ iterate_sync_member_contacts (void *cls,
{
struct GNUNET_MESSENGER_Member *member = value;
- if (!member)
+ if (! member)
return GNUNET_YES;
sync_member_contacts (member);
return GNUNET_YES;
}
+
void
load_member_store (struct GNUNET_MESSENGER_MemberStore *store,
const char *directory)
@@ -146,12 +156,16 @@ load_member_store (struct GNUNET_MESSENGER_MemberStore
*store,
if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_members, store);
- GNUNET_CONTAINER_multishortmap_iterate(store->members,
iterate_load_next_member_sessions, scan_dir);
- GNUNET_CONTAINER_multishortmap_iterate(store->members,
iterate_sync_member_contacts, NULL);
+ GNUNET_CONTAINER_multishortmap_iterate (store->members,
+ iterate_load_next_member_sessions,
+ scan_dir);
+ GNUNET_CONTAINER_multishortmap_iterate (store->members,
+ iterate_sync_member_contacts, NULL);
- GNUNET_free(scan_dir);
+ GNUNET_free (scan_dir);
}
+
static int
iterate_save_members (void *cls,
const struct GNUNET_ShortHashCode *id,
@@ -161,36 +175,40 @@ iterate_save_members (void *cls,
struct GNUNET_MESSENGER_Member *member = value;
- if (!member)
+ if (! member)
return GNUNET_YES;
char *member_dir;
- GNUNET_asprintf (&member_dir, "%s%s%c", save_dir, GNUNET_sh2s(id),
DIR_SEPARATOR);
+ GNUNET_asprintf (&member_dir, "%s%s%c", save_dir, GNUNET_sh2s (id),
+ DIR_SEPARATOR);
if ((GNUNET_YES == GNUNET_DISK_directory_test (member_dir, GNUNET_NO)) ||
(GNUNET_OK == GNUNET_DISK_directory_create (member_dir)))
- save_member(member, member_dir);
+ save_member (member, member_dir);
- GNUNET_free(member_dir);
+ GNUNET_free (member_dir);
return GNUNET_YES;
}
+
void
save_member_store (struct GNUNET_MESSENGER_MemberStore *store,
const char *directory)
{
GNUNET_assert ((store) && (directory));
- char* save_dir;
+ char *save_dir;
GNUNET_asprintf (&save_dir, "%s%s%c", directory, "members", DIR_SEPARATOR);
if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
(GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
- GNUNET_CONTAINER_multishortmap_iterate(store->members,
iterate_save_members, save_dir);
+ GNUNET_CONTAINER_multishortmap_iterate (store->members,
+ iterate_save_members, save_dir);
- GNUNET_free(save_dir);
+ GNUNET_free (save_dir);
}
+
struct GNUNET_MESSENGER_Member*
get_store_member (const struct GNUNET_MESSENGER_MemberStore *store,
const struct GNUNET_ShortHashCode *id)
@@ -200,48 +218,55 @@ get_store_member (const struct
GNUNET_MESSENGER_MemberStore *store,
return GNUNET_CONTAINER_multishortmap_get (store->members, id);
}
+
struct GNUNET_MESSENGER_Member*
get_store_member_of (struct GNUNET_MESSENGER_MemberStore *store,
const struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert((store) && (message));
+ GNUNET_assert ((store) && (message));
- if (GNUNET_YES == is_peer_message(message))
+ if (GNUNET_YES == is_peer_message (message))
return NULL;
if (GNUNET_MESSENGER_KIND_JOIN == message->header.kind)
- return add_store_member(store, &(message->header.sender_id));
+ return add_store_member (store, &(message->header.sender_id));
else
- return get_store_member(store, &(message->header.sender_id));
+ return get_store_member (store, &(message->header.sender_id));
}
+
struct GNUNET_MESSENGER_Member*
add_store_member (struct GNUNET_MESSENGER_MemberStore *store,
const struct GNUNET_ShortHashCode *id)
{
GNUNET_assert ((store) && (store->members));
- struct GNUNET_MESSENGER_Member *member = id? get_store_member(store, id) :
NULL;
+ struct GNUNET_MESSENGER_Member *member = id? get_store_member (store, id) :
+ NULL;
if (member)
return member;
- member = create_member(store, id);
+ member = create_member (store, id);
- if (!member)
+ if (! member)
return NULL;
- if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (store->members,
get_member_id(member), member,
+ if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (store->members,
+ get_member_id (member),
+ member,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
- destroy_member(member);
+ destroy_member (member);
return NULL;
}
return member;
}
-struct GNUNET_MESSENGER_ClosureIterateMembers {
+
+struct GNUNET_MESSENGER_ClosureIterateMembers
+{
GNUNET_MESSENGER_MemberIteratorCallback it;
void *cls;
};
@@ -254,13 +279,14 @@ iterate_store_members_it (void *cls,
struct GNUNET_MESSENGER_ClosureIterateMembers *iterate = cls;
struct GNUNET_MESSENGER_Member *member = value;
- return iterate_member_sessions(member, iterate->it, iterate->cls);
+ return iterate_member_sessions (member, iterate->it, iterate->cls);
}
+
int
iterate_store_members (struct GNUNET_MESSENGER_MemberStore *store,
GNUNET_MESSENGER_MemberIteratorCallback it,
- void* cls)
+ void *cls)
{
GNUNET_assert ((store) && (store->members) && (it));
@@ -269,5 +295,7 @@ iterate_store_members (struct GNUNET_MESSENGER_MemberStore
*store,
iterate.it = it;
iterate.cls = cls;
- return GNUNET_CONTAINER_multishortmap_iterate(store->members,
iterate_store_members_it, &iterate);
+ return GNUNET_CONTAINER_multishortmap_iterate (store->members,
+ iterate_store_members_it,
+ &iterate);
}
diff --git a/src/messenger/gnunet-service-messenger_member_store.h
b/src/messenger/gnunet-service-messenger_member_store.h
index 3dc39114b..54c5e4588 100644
--- a/src/messenger/gnunet-service-messenger_member_store.h
+++ b/src/messenger/gnunet-service-messenger_member_store.h
@@ -44,9 +44,9 @@ struct GNUNET_MESSENGER_MemberStore
};
typedef int (*GNUNET_MESSENGER_MemberIteratorCallback) (
- void *cls,
- const struct GNUNET_IDENTITY_PublicKey *public_key,
- struct GNUNET_MESSENGER_MemberSession *session);
+ void *cls,
+ const struct GNUNET_IDENTITY_PublicKey *public_key,
+ struct GNUNET_MESSENGER_MemberSession *session);
/**
* Initializes a member <i>store</i> as fully empty connected to a <i>room</i>.
@@ -154,6 +154,6 @@ add_store_member (struct GNUNET_MESSENGER_MemberStore
*store,
int
iterate_store_members (struct GNUNET_MESSENGER_MemberStore *store,
GNUNET_MESSENGER_MemberIteratorCallback it,
- void* cls);
+ void *cls);
#endif //GNUNET_SERVICE_MESSENGER_MEMBER_STORE_H
diff --git a/src/messenger/gnunet-service-messenger_message_handle.c
b/src/messenger/gnunet-service-messenger_message_handle.c
index 57b758fa4..77466b599 100644
--- a/src/messenger/gnunet-service-messenger_message_handle.c
+++ b/src/messenger/gnunet-service-messenger_message_handle.c
@@ -31,58 +31,67 @@ handle_member_session_switch (struct
GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_MemberSession *next = switch_member_session(session,
message, hash);
+ struct GNUNET_MESSENGER_MemberSession *next = switch_member_session (session,
+ message,
+ hash);
if (next != session)
- add_member_session(next->member, next);
+ add_member_session (next->member, next);
}
+
void
handle_message_join (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member (%s) joins room (%s).\n",
- GNUNET_sh2s (&(message->header.sender_id)),
GNUNET_h2s(get_srv_room_key(room)));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member (%s) joins room (%s).\n",
+ GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s (
+ get_srv_room_key (room)));
- if (GNUNET_OK != reset_member_session(session->member, hash))
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Resetting member session failed!\n");
+ if (GNUNET_OK != reset_member_session (session->member, hash))
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Resetting member session failed!\n");
solve_srv_room_member_collisions (
- room,
- &(message->body.join.key),
- &(message->header.sender_id),
- GNUNET_TIME_absolute_ntoh(message->header.timestamp)
- );
+ room,
+ &(message->body.join.key),
+ &(message->header.sender_id),
+ GNUNET_TIME_absolute_ntoh (message->header.timestamp)
+ );
}
+
void
handle_message_leave (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member (%s) leaves room (%s).\n",
- GNUNET_sh2s (&(message->header.sender_id)),
GNUNET_h2s(get_srv_room_key(room)));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member (%s) leaves room (%s).\n",
+ GNUNET_sh2s (&(message->header.sender_id)), GNUNET_h2s (
+ get_srv_room_key (room)));
- close_member_session(session->member);
+ close_member_session (session->member);
}
+
void
handle_message_name (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_Contact *contact =
get_member_session_contact(session->member);
+ struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (
+ session->member);
- if (!contact)
+ if (! contact)
return;
set_contact_name (contact, message->body.name.name);
}
+
void
handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
@@ -92,6 +101,7 @@ handle_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
handle_member_session_switch (session->member, message, hash);
}
+
void
handle_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
@@ -100,16 +110,18 @@ handle_message_peer (struct GNUNET_MESSENGER_SrvRoom
*room,
{
struct GNUNET_MESSENGER_PeerStore *store = get_srv_room_peer_store (room);
- if (0 == GNUNET_memcmp(session->peer, &(message->body.peer.peer)))
- update_store_peer(store, &(message->body.peer.peer));
+ if (0 == GNUNET_memcmp (session->peer, &(message->body.peer.peer)))
+ update_store_peer (store, &(message->body.peer.peer));
- if (GNUNET_NO == contains_list_tunnels (&(room->basement),
&(message->body.peer.peer)))
+ if (GNUNET_NO == contains_list_tunnels (&(room->basement),
+ &(message->body.peer.peer)))
add_to_list_tunnels (&(room->basement), &(message->body.peer.peer), hash);
if (room->peer_message)
rebuild_srv_room_basement_structure (room);
}
+
void
handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
@@ -119,13 +131,14 @@ handle_message_id (struct GNUNET_MESSENGER_SrvRoom *room,
handle_member_session_switch (session->member, message, hash);
solve_srv_room_member_collisions (
- room,
- get_member_session_public_key(session->member),
- &(message->body.id.id),
- GNUNET_TIME_absolute_ntoh(message->header.timestamp)
- );
+ room,
+ get_member_session_public_key (session->member),
+ &(message->body.id.id),
+ GNUNET_TIME_absolute_ntoh (message->header.timestamp)
+ );
}
+
void
handle_message_miss (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
@@ -134,12 +147,13 @@ handle_message_miss (struct GNUNET_MESSENGER_SrvRoom
*room,
{
struct GNUNET_MESSENGER_PeerStore *store = get_srv_room_peer_store (room);
- if (0 == GNUNET_memcmp(session->peer, &(message->body.miss.peer)))
- remove_store_peer(store, &(message->body.miss.peer));
+ if (0 == GNUNET_memcmp (session->peer, &(message->body.miss.peer)))
+ remove_store_peer (store, &(message->body.miss.peer));
- struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels
(&(room->basement), &(message->body.miss.peer), NULL);
+ struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (
+ &(room->basement), &(message->body.miss.peer), NULL);
- if (!element)
+ if (! element)
return;
remove_from_list_tunnels (&(room->basement), element);
@@ -148,17 +162,22 @@ handle_message_miss (struct GNUNET_MESSENGER_SrvRoom
*room,
rebuild_srv_room_basement_structure (room);
}
+
void
handle_message_delete (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SenderSession *session,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_TIME_Relative delay = GNUNET_TIME_relative_ntoh
(message->body.deletion.delay);
- struct GNUNET_TIME_Absolute action = GNUNET_TIME_absolute_ntoh
(message->header.timestamp);
+ struct GNUNET_TIME_Relative delay = GNUNET_TIME_relative_ntoh (
+ message->body.deletion.delay);
+ struct GNUNET_TIME_Absolute action = GNUNET_TIME_absolute_ntoh (
+ message->header.timestamp);
action = GNUNET_TIME_absolute_add (action, delay);
- delay = GNUNET_TIME_absolute_get_difference (GNUNET_TIME_absolute_get (),
action);
+ delay = GNUNET_TIME_absolute_get_difference (GNUNET_TIME_absolute_get (),
+ action);
- delete_srv_room_message (room, session->member,
&(message->body.deletion.hash), delay);
+ delete_srv_room_message (room, session->member,
+ &(message->body.deletion.hash), delay);
}
diff --git a/src/messenger/gnunet-service-messenger_message_kind.c
b/src/messenger/gnunet-service-messenger_message_kind.c
index 688dd2fd9..0cc3afeaf 100644
--- a/src/messenger/gnunet-service-messenger_message_kind.c
+++ b/src/messenger/gnunet-service-messenger_message_kind.c
@@ -31,12 +31,13 @@
struct GNUNET_MESSENGER_Message*
create_message_info (struct GNUNET_MESSENGER_Service *service)
{
- if (!service)
+ if (! service)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_INFO);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_INFO);
- if (!message)
+ if (! message)
return NULL;
message->body.info.messenger_version = GNUNET_MESSENGER_VERSION;
@@ -44,18 +45,21 @@ create_message_info (struct GNUNET_MESSENGER_Service
*service)
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_peer (struct GNUNET_MESSENGER_Service *service)
{
- if (!service)
+ if (! service)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_PEER);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_PEER);
- if (!message)
+ if (! message)
return NULL;
- if (GNUNET_OK == get_service_peer_identity (service,
&(message->body.peer.peer)))
+ if (GNUNET_OK == get_service_peer_identity (service,
+ &(message->body.peer.peer)))
return message;
else
{
@@ -64,36 +68,42 @@ create_message_peer (struct GNUNET_MESSENGER_Service
*service)
}
}
+
struct GNUNET_MESSENGER_Message*
create_message_miss (const struct GNUNET_PeerIdentity *peer)
{
- if (!peer)
+ if (! peer)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_MISS);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_MISS);
- if (!message)
+ if (! message)
{
return NULL;
}
- GNUNET_memcpy(&(message->body.miss.peer), peer, sizeof(struct
GNUNET_PeerIdentity));
+ GNUNET_memcpy (&(message->body.miss.peer), peer, sizeof(struct
+
GNUNET_PeerIdentity));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_merge (const struct GNUNET_HashCode *previous)
{
- if (!previous)
+ if (! previous)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_MERGE);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_MERGE);
- if (!message)
+ if (! message)
return NULL;
- GNUNET_memcpy(&(message->body.merge.previous), previous, sizeof(struct
GNUNET_HashCode));
+ GNUNET_memcpy (&(message->body.merge.previous), previous, sizeof(struct
+
GNUNET_HashCode));
return message;
}
diff --git a/src/messenger/gnunet-service-messenger_message_recv.c
b/src/messenger/gnunet-service-messenger_message_recv.c
index 3b545cfa4..e445c4e79 100644
--- a/src/messenger/gnunet-service-messenger_message_recv.c
+++ b/src/messenger/gnunet-service-messenger_message_recv.c
@@ -38,25 +38,31 @@ forward_about_members (struct GNUNET_MESSENGER_SrvRoom
*room,
if (session->prev)
forward_about_members (room, tunnel, session->prev, map);
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
struct GNUNET_MESSENGER_ListMessage *element;
for (element = session->messages.head; element; element = element->next)
{
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(map,
&(element->hash)))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map,
+
&(element->hash)))
continue;
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(map, &(element->hash),
NULL,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Forwarding of session message
could be duplicated!\n");
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (map, &(element->hash),
+ NULL,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Forwarding of session message could be duplicated!\n");
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, &(element->hash));
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, &(element->hash));
if (message)
- forward_tunnel_message(tunnel, message, &(element->hash));
+ forward_tunnel_message (tunnel, message, &(element->hash));
}
}
+
static int
iterate_forward_members (void *cls,
const struct GNUNET_IDENTITY_PublicKey *public_key,
@@ -64,68 +70,77 @@ iterate_forward_members (void *cls,
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
- if (GNUNET_YES == is_member_session_completed(session))
+ if (GNUNET_YES == is_member_session_completed (session))
return GNUNET_YES;
- struct GNUNET_CONTAINER_MultiHashMap *map =
GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
+ struct GNUNET_CONTAINER_MultiHashMap *map =
+ GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
forward_about_members (tunnel->room, tunnel, session, map);
- GNUNET_CONTAINER_multihashmap_destroy(map);
+ GNUNET_CONTAINER_multihashmap_destroy (map);
return GNUNET_YES;
}
+
int
recv_message_info (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvTunnel *tunnel,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- const uint32_t version = get_tunnel_messenger_version(tunnel);
+ const uint32_t version = get_tunnel_messenger_version (tunnel);
- if (GNUNET_OK != update_tunnel_messenger_version(tunnel,
message->body.info.messenger_version))
+ if (GNUNET_OK != update_tunnel_messenger_version (tunnel,
+ message->body.info.
+ messenger_version))
{
- disconnect_tunnel(tunnel);
+ disconnect_tunnel (tunnel);
return GNUNET_NO;
}
- if (version == get_tunnel_messenger_version(tunnel))
+ if (version == get_tunnel_messenger_version (tunnel))
return GNUNET_NO;
if (room->host)
- send_tunnel_message (tunnel, room->host, create_message_info
(room->service));
+ send_tunnel_message (tunnel, room->host, create_message_info (
+ room->service));
struct GNUNET_PeerIdentity peer;
- get_tunnel_peer_identity(tunnel, &peer);
+ get_tunnel_peer_identity (tunnel, &peer);
- if (GNUNET_YES != contains_list_tunnels(&(room->basement), &peer))
+ if (GNUNET_YES != contains_list_tunnels (&(room->basement), &peer))
{
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
struct GNUNET_MESSENGER_ListTunnel *element;
for (element = room->basement.head; element; element = element->next)
{
- if (!element->hash)
+ if (! element->hash)
continue;
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, element->hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, element->hash);
if (message)
- forward_tunnel_message(tunnel, message, element->hash);
+ forward_tunnel_message (tunnel, message, element->hash);
}
}
- if (GNUNET_YES != contains_list_tunnels(&(room->basement), &peer))
+ if (GNUNET_YES != contains_list_tunnels (&(room->basement), &peer))
{
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
- iterate_store_members(member_store, iterate_forward_members, tunnel);
+ iterate_store_members (member_store, iterate_forward_members, tunnel);
}
- check_srv_room_peer_status(room, tunnel);
+ check_srv_room_peer_status (room, tunnel);
return GNUNET_NO;
}
+
int
recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvTunnel *tunnel,
@@ -135,18 +150,19 @@ recv_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_PeerIdentity peer;
GNUNET_PEER_resolve (tunnel->peer, &peer);
- if (0 == GNUNET_memcmp(&peer, &(message->body.peer.peer)))
+ if (0 == GNUNET_memcmp (&peer, &(message->body.peer.peer)))
{
- if (!tunnel->peer_message)
- tunnel->peer_message = GNUNET_new(struct GNUNET_HashCode);
+ if (! tunnel->peer_message)
+ tunnel->peer_message = GNUNET_new (struct GNUNET_HashCode);
- GNUNET_memcpy(tunnel->peer_message, &hash, sizeof(hash));
+ GNUNET_memcpy (tunnel->peer_message, &hash, sizeof(hash));
}
- update_to_list_tunnels(&(room->basement), &(message->body.peer.peer), hash);
+ update_to_list_tunnels (&(room->basement), &(message->body.peer.peer), hash);
return GNUNET_YES;
}
+
static void
callback_found_message (void *cls,
struct GNUNET_MESSENGER_SrvRoom *room,
@@ -155,21 +171,23 @@ callback_found_message (void *cls,
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = tunnel;
- if (!message)
+ if (! message)
{
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(room);
-
- use_store_operation(
- operation_store,
- hash,
- GNUNET_MESSENGER_OP_REQUEST,
- GNUNET_MESSENGER_REQUEST_DELAY
- );
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (room);
+
+ use_store_operation (
+ operation_store,
+ hash,
+ GNUNET_MESSENGER_OP_REQUEST,
+ GNUNET_MESSENGER_REQUEST_DELAY
+ );
}
else
forward_tunnel_message (tunnel, message, hash);
}
+
/*
* Function returns GNUNET_NO to drop forwarding the request.
* It will only be forwarded if it can't be answered!
@@ -180,20 +198,31 @@ recv_message_request (struct GNUNET_MESSENGER_SrvRoom
*room,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store,
message);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_Member *member = get_store_member_of (member_store,
+ message);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Request for message (%s)\n", GNUNET_h2s
(hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Request for message (%s)\n",
+ GNUNET_h2s (hash));
- if (!member)
+ if (! member)
return GNUNET_NO;
- struct GNUNET_MESSENGER_MemberSession *session =
get_member_session_of(member, message, hash);
+ struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of (
+ member, message, hash);
- if ((!session) || (GNUNET_YES != check_member_session_history(session,
&(message->body.request.hash), GNUNET_NO)))
+ if ((! session) || (GNUNET_YES != check_member_session_history (session,
+ &(message->
+
body.request
+ .hash),
+ GNUNET_NO)))
return GNUNET_NO;
- if (GNUNET_NO == request_srv_room_message(room,
&(message->body.request.hash), session, callback_found_message, tunnel))
+ if (GNUNET_NO == request_srv_room_message (room,
+ &(message->body.request.hash),
+ session, callback_found_message,
+ tunnel))
return GNUNET_YES;
return GNUNET_NO;
diff --git a/src/messenger/gnunet-service-messenger_message_send.c
b/src/messenger/gnunet-service-messenger_message_send.c
index 40ff95cef..5c3f9ecc5 100644
--- a/src/messenger/gnunet-service-messenger_message_send.c
+++ b/src/messenger/gnunet-service-messenger_message_send.c
@@ -48,68 +48,86 @@ notify_about_members (struct GNUNET_MESSENGER_MemberNotify
*notify,
if (session->prev)
notify_about_members (notify, session->prev, map, GNUNET_YES);
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(notify->room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (notify->room);
struct GNUNET_MESSENGER_ListMessage *element;
for (element = session->messages.head; element; element = element->next)
{
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(map,
&(element->hash)))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map,
+
&(element->hash)))
continue;
if ((GNUNET_YES == check_permission) &&
- (GNUNET_YES != check_member_session_history(notify->session,
&(element->hash), GNUNET_NO)))
+ (GNUNET_YES != check_member_session_history (notify->session,
+ &(element->hash),
+ GNUNET_NO)))
continue;
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(map, &(element->hash),
NULL,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notification of session message
could be duplicated!\n");
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (map, &(element->hash),
+ NULL,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Notification of session message could be duplicated!\n");
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, &(element->hash));
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, &(element->hash));
- if ((!message) || (GNUNET_YES == is_peer_message (message)))
+ if ((! message) || (GNUNET_YES == is_peer_message (message)))
continue;
struct GNUNET_MESSENGER_SenderSession sender;
sender.member = session;
- notify_srv_handle_message (notify->handle, notify->room, &sender, message,
&(element->hash));
+ notify_srv_handle_message (notify->handle, notify->room, &sender, message,
+ &(element->hash));
}
}
+
static int
iterate_notify_about_members (void *cls,
- const struct GNUNET_IDENTITY_PublicKey
*public_key,
+ const struct
+ GNUNET_IDENTITY_PublicKey *public_key,
struct GNUNET_MESSENGER_MemberSession *session)
{
struct GNUNET_MESSENGER_MemberNotify *notify = cls;
- if ((notify->session == session) || (GNUNET_YES ==
is_member_session_completed(session)))
+ if ((notify->session == session) || (GNUNET_YES ==
+ is_member_session_completed (session)))
return GNUNET_YES;
- struct GNUNET_CONTAINER_MultiHashMap *map =
GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
+ struct GNUNET_CONTAINER_MultiHashMap *map =
+ GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
notify_about_members (notify, session, map, GNUNET_NO);
- GNUNET_CONTAINER_multihashmap_destroy(map);
+ GNUNET_CONTAINER_multihashmap_destroy (map);
return GNUNET_YES;
}
+
void
send_message_join (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- set_srv_handle_key(handle, &(message->body.join.key));
+ set_srv_handle_key (handle, &(message->body.join.key));
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = add_store_member(member_store,
&(message->header.sender_id));
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+ &(message->header.
+ sender_id));
- struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of
(member, message, hash);
+ struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of (
+ member, message, hash);
- if (!session)
+ if (! session)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "A valid session is required to join
a room!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "A valid session is required to join a room!\n");
goto skip_member_notification;
}
@@ -119,54 +137,61 @@ send_message_join (struct GNUNET_MESSENGER_SrvRoom *room,
notify.handle = handle;
notify.session = session;
- iterate_store_members(get_srv_room_member_store(room),
iterate_notify_about_members, ¬ify);
+ iterate_store_members (get_srv_room_member_store (room),
+ iterate_notify_about_members, ¬ify);
skip_member_notification:
- check_srv_room_peer_status(room, NULL);
+ check_srv_room_peer_status (room, NULL);
}
+
void
send_message_key (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- set_srv_handle_key(handle, &(message->body.key.key));
+ set_srv_handle_key (handle, &(message->body.key.key));
}
+
void
send_message_peer (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- if (!room->peer_message)
- room->peer_message = GNUNET_new(struct GNUNET_HashCode);
+ if (! room->peer_message)
+ room->peer_message = GNUNET_new (struct GNUNET_HashCode);
- GNUNET_memcpy(room->peer_message, hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (room->peer_message, hash, sizeof(struct GNUNET_HashCode));
}
+
void
send_message_id (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- change_srv_handle_member_id (handle, get_srv_room_key(room),
&(message->body.id.id));
+ change_srv_handle_member_id (handle, get_srv_room_key (room),
+ &(message->body.id.id));
}
+
void
send_message_request (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(room);
-
- use_store_operation(
- operation_store,
- &(message->body.request.hash),
- GNUNET_MESSENGER_OP_REQUEST,
- GNUNET_MESSENGER_REQUEST_DELAY
- );
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (room);
+
+ use_store_operation (
+ operation_store,
+ &(message->body.request.hash),
+ GNUNET_MESSENGER_OP_REQUEST,
+ GNUNET_MESSENGER_REQUEST_DELAY
+ );
}
diff --git a/src/messenger/gnunet-service-messenger_message_state.c
b/src/messenger/gnunet-service-messenger_message_state.c
index b2328588e..112f03032 100644
--- a/src/messenger/gnunet-service-messenger_message_state.c
+++ b/src/messenger/gnunet-service-messenger_message_state.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -29,35 +29,38 @@
void
init_message_state (struct GNUNET_MESSENGER_MessageState *state)
{
- GNUNET_assert(state);
+ GNUNET_assert (state);
init_list_messages (&(state->last_messages));
}
+
void
clear_message_state (struct GNUNET_MESSENGER_MessageState *state)
{
- GNUNET_assert(state);
+ GNUNET_assert (state);
clear_list_messages (&(state->last_messages));
}
+
void
get_message_state_chain_hash (const struct GNUNET_MESSENGER_MessageState
*state,
struct GNUNET_HashCode *hash)
{
- GNUNET_assert((state) && (hash));
+ GNUNET_assert ((state) && (hash));
if (state->last_messages.head)
- GNUNET_memcpy(hash, &(state->last_messages.head->hash), sizeof(*hash));
+ GNUNET_memcpy (hash, &(state->last_messages.head->hash), sizeof(*hash));
else
memset (hash, 0, sizeof(*hash));
}
+
const struct GNUNET_HashCode*
get_message_state_merge_hash (const struct GNUNET_MESSENGER_MessageState
*state)
{
- GNUNET_assert(state);
+ GNUNET_assert (state);
if (state->last_messages.head == state->last_messages.tail)
return NULL;
@@ -65,13 +68,14 @@ get_message_state_merge_hash (const struct
GNUNET_MESSENGER_MessageState *state)
return &(state->last_messages.tail->hash);
}
+
void
update_message_state (struct GNUNET_MESSENGER_MessageState *state,
int requested,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((state) && (message) && (hash));
+ GNUNET_assert ((state) && (message) && (hash));
if ((GNUNET_YES == requested) ||
(GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
@@ -79,36 +83,38 @@ update_message_state (struct GNUNET_MESSENGER_MessageState
*state,
return;
if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
- remove_from_list_messages(&(state->last_messages),
&(message->body.merge.previous));
- remove_from_list_messages(&(state->last_messages),
&(message->header.previous));
+ remove_from_list_messages (&(state->last_messages),
+ &(message->body.merge.previous));
+ remove_from_list_messages (&(state->last_messages),
+ &(message->header.previous));
add_to_list_messages (&(state->last_messages), hash);
}
+
void
load_message_state (struct GNUNET_MESSENGER_MessageState *state,
const char *path)
{
- GNUNET_assert((state) && (path));
+ GNUNET_assert ((state) && (path));
char *last_messages_file;
GNUNET_asprintf (&last_messages_file, "%s%s", path, "last_messages.list");
- load_list_messages(&(state->last_messages), last_messages_file);
- GNUNET_free(last_messages_file);
+ load_list_messages (&(state->last_messages), last_messages_file);
+ GNUNET_free (last_messages_file);
}
+
void
save_message_state (const struct GNUNET_MESSENGER_MessageState *state,
const char *path)
{
- GNUNET_assert((state) && (path));
+ GNUNET_assert ((state) && (path));
char *last_messages_file;
GNUNET_asprintf (&last_messages_file, "%s%s", path, "last_messages.list");
- save_list_messages(&(state->last_messages), last_messages_file);
- GNUNET_free(last_messages_file);
+ save_list_messages (&(state->last_messages), last_messages_file);
+ GNUNET_free (last_messages_file);
}
-
-
diff --git a/src/messenger/gnunet-service-messenger_message_state.h
b/src/messenger/gnunet-service-messenger_message_state.h
index 10e6a2c46..f6a1a41b9 100644
--- a/src/messenger/gnunet-service-messenger_message_state.h
+++ b/src/messenger/gnunet-service-messenger_message_state.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -48,7 +48,8 @@ get_message_state_chain_hash (const struct
GNUNET_MESSENGER_MessageState *state,
struct GNUNET_HashCode *hash);
const struct GNUNET_HashCode*
-get_message_state_merge_hash (const struct GNUNET_MESSENGER_MessageState
*state);
+get_message_state_merge_hash (const struct
+ GNUNET_MESSENGER_MessageState *state);
void
update_message_state (struct GNUNET_MESSENGER_MessageState *state,
diff --git a/src/messenger/gnunet-service-messenger_message_store.c
b/src/messenger/gnunet-service-messenger_message_store.c
index e137e9d93..d4bccca5c 100644
--- a/src/messenger/gnunet-service-messenger_message_store.c
+++ b/src/messenger/gnunet-service-messenger_message_store.c
@@ -30,7 +30,7 @@
void
init_message_store (struct GNUNET_MESSENGER_MessageStore *store)
{
- GNUNET_assert(store);
+ GNUNET_assert (store);
store->storage_messages = NULL;
@@ -42,6 +42,7 @@ init_message_store (struct GNUNET_MESSENGER_MessageStore
*store)
store->write_links = GNUNET_NO;
}
+
static int
iterate_destroy_entries (void *cls,
const struct GNUNET_HashCode *key,
@@ -49,11 +50,12 @@ iterate_destroy_entries (void *cls,
{
struct GNUNET_MESSENGER_MessageEntry *entry = value;
- GNUNET_free(entry);
+ GNUNET_free (entry);
return GNUNET_YES;
}
+
static int
iterate_destroy_messages (void *cls,
const struct GNUNET_HashCode *key,
@@ -66,6 +68,7 @@ iterate_destroy_messages (void *cls,
return GNUNET_YES;
}
+
static int
iterate_destroy_links (void *cls,
const struct GNUNET_HashCode *key,
@@ -73,15 +76,16 @@ iterate_destroy_links (void *cls,
{
struct GNUNET_HashCode *previous = value;
- GNUNET_free(previous);
+ GNUNET_free (previous);
return GNUNET_YES;
}
+
void
clear_message_store (struct GNUNET_MESSENGER_MessageStore *store)
{
- GNUNET_assert(store);
+ GNUNET_assert (store);
if (store->storage_messages)
{
@@ -90,15 +94,19 @@ clear_message_store (struct GNUNET_MESSENGER_MessageStore
*store)
store->storage_messages = NULL;
}
- GNUNET_CONTAINER_multihashmap_iterate (store->entries,
iterate_destroy_entries, NULL);
- GNUNET_CONTAINER_multihashmap_iterate (store->messages,
iterate_destroy_messages, NULL);
- GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_destroy_links,
NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->entries,
+ iterate_destroy_entries, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->messages,
+ iterate_destroy_messages, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_destroy_links,
+ NULL);
GNUNET_CONTAINER_multihashmap_destroy (store->entries);
GNUNET_CONTAINER_multihashmap_destroy (store->messages);
GNUNET_CONTAINER_multihashmap_destroy (store->links);
}
+
struct GNUNET_MESSENGER_MessageEntryStorage
{
struct GNUNET_HashCode hash;
@@ -106,10 +114,12 @@ struct GNUNET_MESSENGER_MessageEntryStorage
};
#define load_message_store_attribute_failed(file, attribute) \
- sizeof(attribute) != GNUNET_DISK_file_read(file, &(attribute),
sizeof(attribute))
+ sizeof(attribute) != GNUNET_DISK_file_read (file, &(attribute), \
+ sizeof(attribute))
#define save_message_store_attribute_failed(file, attribute) \
- sizeof(attribute) != GNUNET_DISK_file_write(file, &(attribute),
sizeof(attribute))
+ sizeof(attribute) != GNUNET_DISK_file_write (file, &(attribute), \
+ sizeof(attribute))
static void
load_message_store_entries (struct GNUNET_MESSENGER_MessageStore *store,
@@ -117,31 +127,36 @@ load_message_store_entries (struct
GNUNET_MESSENGER_MessageStore *store,
{
enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ);
- struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename,
GNUNET_DISK_OPEN_READ, permission);
+ struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename,
+
GNUNET_DISK_OPEN_READ,
+ permission);
- if (!entries)
+ if (! entries)
return;
struct GNUNET_MESSENGER_MessageEntryStorage storage;
struct GNUNET_MESSENGER_MessageEntry *entry;
- memset(&storage, 0, sizeof(storage));
+ memset (&storage, 0, sizeof(storage));
do
{
entry = NULL;
- if ((load_message_store_attribute_failed(entries, storage.hash)) ||
- (load_message_store_attribute_failed(entries, storage.entry.offset)) ||
- (load_message_store_attribute_failed(entries, storage.entry.length)))
+ if ((load_message_store_attribute_failed (entries, storage.hash)) ||
+ (load_message_store_attribute_failed (entries, storage.entry.offset))
||
+ (load_message_store_attribute_failed (entries, storage.entry.length)))
break;
- entry = GNUNET_new(struct GNUNET_MESSENGER_MessageEntry);
+ entry = GNUNET_new (struct GNUNET_MESSENGER_MessageEntry);
- GNUNET_memcpy(entry, &(storage.entry), sizeof(*entry));
+ GNUNET_memcpy (entry, &(storage.entry), sizeof(*entry));
- if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->entries,
&(storage.hash))) ||
- (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->entries,
&(storage.hash), entry,
+ if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->entries,
+
&(storage.hash)))
+ ||
+ (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->entries,
+ &(storage.hash),
entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
{
store->rewrite_entries = GNUNET_YES;
@@ -151,11 +166,12 @@ load_message_store_entries (struct
GNUNET_MESSENGER_MessageStore *store,
while (entry);
if (entry)
- GNUNET_free(entry);
+ GNUNET_free (entry);
GNUNET_DISK_file_close (entries);
}
+
struct GNUNET_MESSENGER_MessageLinkStorage
{
struct GNUNET_HashCode hash;
@@ -168,51 +184,59 @@ load_message_store_links (struct
GNUNET_MESSENGER_MessageStore *store,
{
enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ);
- struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename,
GNUNET_DISK_OPEN_READ, permission);
+ struct GNUNET_DISK_FileHandle *entries = GNUNET_DISK_file_open (filename,
+
GNUNET_DISK_OPEN_READ,
+ permission);
- if (!entries)
+ if (! entries)
return;
struct GNUNET_MESSENGER_MessageLinkStorage storage;
struct GNUNET_MESSENGER_MessageLink *link;
- memset(&storage, 0, sizeof(storage));
+ memset (&storage, 0, sizeof(storage));
do
{
link = NULL;
- if ((load_message_store_attribute_failed(entries, storage.hash)) ||
- (load_message_store_attribute_failed(entries, storage.link.multiple))
||
- (load_message_store_attribute_failed(entries, storage.link.first)) ||
+ if ((load_message_store_attribute_failed (entries, storage.hash)) ||
+ (load_message_store_attribute_failed (entries,
+ storage.link.multiple)) ||
+ (load_message_store_attribute_failed (entries, storage.link.first)) ||
((GNUNET_YES == storage.link.multiple) &&
- (load_message_store_attribute_failed(entries, storage.link.second))))
+ (load_message_store_attribute_failed (entries, storage.link.second))))
break;
- link = GNUNET_new(struct GNUNET_MESSENGER_MessageLink);
+ link = GNUNET_new (struct GNUNET_MESSENGER_MessageLink);
- GNUNET_memcpy(link, &(storage.link), sizeof(*link));
+ GNUNET_memcpy (link, &(storage.link), sizeof(*link));
- if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->links,
&(storage.hash))) ||
- (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->links,
&(storage.hash), link,
+ if ((GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->links,
+
&(storage.hash)))
+ ||
+ (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->links,
+ &(storage.hash), link,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
break;
}
while (link);
if (link)
- GNUNET_free(link);
+ GNUNET_free (link);
GNUNET_DISK_file_close (entries);
}
+
void
load_message_store (struct GNUNET_MESSENGER_MessageStore *store,
const char *directory)
{
- GNUNET_assert((store) && (directory));
+ GNUNET_assert ((store) && (directory));
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
if (store->storage_messages)
GNUNET_DISK_file_close (store->storage_messages);
@@ -221,30 +245,33 @@ load_message_store (struct GNUNET_MESSENGER_MessageStore
*store,
GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
if (GNUNET_YES == GNUNET_DISK_file_test (filename))
- store->storage_messages = GNUNET_DISK_file_open (filename,
GNUNET_DISK_OPEN_READWRITE, permission);
+ store->storage_messages = GNUNET_DISK_file_open (filename,
+
GNUNET_DISK_OPEN_READWRITE,
+ permission);
else
store->storage_messages = NULL;
- GNUNET_free(filename);
+ GNUNET_free (filename);
- if (!store->storage_messages)
+ if (! store->storage_messages)
return;
GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
if (GNUNET_YES == GNUNET_DISK_file_test (filename))
- load_message_store_entries(store, filename);
+ load_message_store_entries (store, filename);
- GNUNET_free(filename);
+ GNUNET_free (filename);
GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
if (GNUNET_YES == GNUNET_DISK_file_test (filename))
- load_message_store_links(store, filename);
+ load_message_store_links (store, filename);
- GNUNET_free(filename);
+ GNUNET_free (filename);
}
+
struct GNUNET_MESSENGER_ClosureMessageSave
{
struct GNUNET_MESSENGER_MessageStore *store;
@@ -261,12 +288,15 @@ iterate_save_entries (void *cls,
struct GNUNET_MESSENGER_MessageEntry *entry = value;
GNUNET_DISK_file_write (save->storage, key, sizeof(*key));
- GNUNET_DISK_file_write (save->storage, &(entry->offset),
sizeof(entry->offset));
- GNUNET_DISK_file_write (save->storage, &(entry->length),
sizeof(entry->length));
+ GNUNET_DISK_file_write (save->storage, &(entry->offset),
+ sizeof(entry->offset));
+ GNUNET_DISK_file_write (save->storage, &(entry->length),
+ sizeof(entry->length));
return GNUNET_YES;
}
+
static int
iterate_save_messages (void *cls,
const struct GNUNET_HashCode *key,
@@ -274,36 +304,42 @@ iterate_save_messages (void *cls,
{
struct GNUNET_MESSENGER_ClosureMessageSave *save = cls;
- if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains
(save->store->entries, key))
+ if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains
(save->store->entries,
+ key))
return GNUNET_YES;
struct GNUNET_MESSENGER_Message *message = value;
struct GNUNET_MESSENGER_MessageEntryStorage storage;
- GNUNET_memcpy(&(storage.hash), key, sizeof(storage.hash));
+ GNUNET_memcpy (&(storage.hash), key, sizeof(storage.hash));
storage.entry.length = get_message_size (message, GNUNET_YES);
- storage.entry.offset = GNUNET_DISK_file_seek (save->store->storage_messages,
0, GNUNET_DISK_SEEK_END);
+ storage.entry.offset = GNUNET_DISK_file_seek (save->store->storage_messages,
+ 0, GNUNET_DISK_SEEK_END);
if ((GNUNET_SYSERR == storage.entry.offset) ||
- (save_message_store_attribute_failed(save->storage, storage.hash)) ||
- (save_message_store_attribute_failed(save->storage,
storage.entry.offset)) ||
- (save_message_store_attribute_failed(save->storage,
storage.entry.length)))
+ (save_message_store_attribute_failed (save->storage, storage.hash)) ||
+ (save_message_store_attribute_failed (save->storage,
+ storage.entry.offset)) ||
+ (save_message_store_attribute_failed (save->storage,
+ storage.entry.length)))
return GNUNET_YES;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Storing message with hash: %s\n",
- GNUNET_h2s (&(storage.hash)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message with hash: %s\n",
+ GNUNET_h2s (&(storage.hash)));
- char *buffer = GNUNET_malloc(storage.entry.length);
+ char *buffer = GNUNET_malloc (storage.entry.length);
encode_message (message, storage.entry.length, buffer, GNUNET_YES);
- GNUNET_DISK_file_write (save->store->storage_messages, buffer,
storage.entry.length);
+ GNUNET_DISK_file_write (save->store->storage_messages, buffer,
+ storage.entry.length);
- GNUNET_free(buffer);
+ GNUNET_free (buffer);
return GNUNET_YES;
}
+
static int
iterate_save_links (void *cls,
const struct GNUNET_HashCode *key,
@@ -313,24 +349,28 @@ iterate_save_links (void *cls,
struct GNUNET_MESSENGER_MessageLink *link = value;
GNUNET_DISK_file_write (save->storage, key, sizeof(*key));
- GNUNET_DISK_file_write (save->storage, &(link->multiple),
sizeof(link->multiple));
+ GNUNET_DISK_file_write (save->storage, &(link->multiple),
+ sizeof(link->multiple));
GNUNET_DISK_file_write (save->storage, &(link->first), sizeof(link->first));
if (GNUNET_YES == link->multiple)
- GNUNET_DISK_file_write (save->storage, &(link->second),
sizeof(link->second));
+ GNUNET_DISK_file_write (save->storage, &(link->second),
+ sizeof(link->second));
return GNUNET_YES;
}
+
void
save_message_store (struct GNUNET_MESSENGER_MessageStore *store,
const char *directory)
{
- GNUNET_assert((store) && (directory));
+ GNUNET_assert ((store) && (directory));
struct GNUNET_MESSENGER_ClosureMessageSave save;
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
char *filename;
@@ -340,17 +380,20 @@ save_message_store (struct GNUNET_MESSENGER_MessageStore
*store,
GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
save.store = store;
- save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE |
GNUNET_DISK_OPEN_CREATE, permission);
+ save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE
+ | GNUNET_DISK_OPEN_CREATE, permission);
- GNUNET_free(filename);
+ GNUNET_free (filename);
- if (!save.storage)
+ if (! save.storage)
goto save_entries;
- if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
GNUNET_DISK_SEEK_SET))
+ if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
+ GNUNET_DISK_SEEK_SET))
goto close_links;
- GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_save_links,
&save);
+ GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_save_links,
+ &save);
store->write_links = GNUNET_NO;
close_links:
@@ -360,22 +403,26 @@ save_entries:
GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
save.store = store;
- save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE |
GNUNET_DISK_OPEN_CREATE, permission);
+ save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE
+ | GNUNET_DISK_OPEN_CREATE, permission);
- GNUNET_free(filename);
+ GNUNET_free (filename);
- if (!save.storage)
+ if (! save.storage)
return;
if (GNUNET_YES == store->rewrite_entries)
{
- if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
GNUNET_DISK_SEEK_SET))
+ if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
+ GNUNET_DISK_SEEK_SET))
goto close_entries;
- GNUNET_CONTAINER_multihashmap_iterate (store->entries,
iterate_save_entries, &save);
+ GNUNET_CONTAINER_multihashmap_iterate (store->entries,
iterate_save_entries,
+ &save);
store->rewrite_entries = GNUNET_NO;
}
- else if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
GNUNET_DISK_SEEK_END))
+ else if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0,
+ GNUNET_DISK_SEEK_END))
goto close_entries;
if (store->storage_messages)
@@ -383,14 +430,17 @@ save_entries:
GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
- store->storage_messages = GNUNET_DISK_file_open (filename,
GNUNET_DISK_OPEN_READWRITE | GNUNET_DISK_OPEN_CREATE,
+ store->storage_messages = GNUNET_DISK_file_open (filename,
+ GNUNET_DISK_OPEN_READWRITE
+ | GNUNET_DISK_OPEN_CREATE,
permission);
- GNUNET_free(filename);
+ GNUNET_free (filename);
if (store->storage_messages)
{
- GNUNET_CONTAINER_multihashmap_iterate (store->messages,
iterate_save_messages, &save);
+ GNUNET_CONTAINER_multihashmap_iterate (store->messages,
+ iterate_save_messages, &save);
GNUNET_DISK_file_sync (store->storage_messages);
GNUNET_DISK_file_sync (save.storage);
@@ -400,80 +450,94 @@ close_entries:
GNUNET_DISK_file_close (save.storage);
}
+
int
contains_store_message (const struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->messages,
hash))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->messages,
+ hash))
return GNUNET_YES;
return GNUNET_CONTAINER_multihashmap_contains (store->entries, hash);
}
+
const struct GNUNET_MESSENGER_Message*
get_store_message (struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- struct GNUNET_MESSENGER_Message *message = GNUNET_CONTAINER_multihashmap_get
(store->messages, hash);
+ struct GNUNET_MESSENGER_Message *message = GNUNET_CONTAINER_multihashmap_get
(
+ store->messages, hash);
if (message)
return message;
- if (!store->storage_messages)
+ if (! store->storage_messages)
return NULL;
- const struct GNUNET_MESSENGER_MessageEntry *entry =
GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
+ const struct GNUNET_MESSENGER_MessageEntry *entry =
+ GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
- if (!entry)
+ if (! entry)
return NULL;
- if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages,
entry->offset, GNUNET_DISK_SEEK_SET))
+ if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages,
+ entry->offset,
+ GNUNET_DISK_SEEK_SET))
return message;
- char *buffer = GNUNET_malloc(entry->length);
+ char *buffer = GNUNET_malloc (entry->length);
- if (!buffer)
+ if (! buffer)
return NULL;
- if ((GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length)
!= entry->length) ||
- (entry->length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN,
GNUNET_YES)))
+ if ((GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length)
!=
+ entry->length) ||
+ (entry->length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ GNUNET_YES)))
goto free_buffer;
message = create_message (GNUNET_MESSENGER_KIND_UNKNOWN);
- const int decoding = decode_message (message, entry->length, buffer,
GNUNET_YES, NULL);
+ const int decoding = decode_message (message, entry->length, buffer,
+ GNUNET_YES, NULL);
struct GNUNET_HashCode check;
hash_message (message, entry->length, buffer, &check);
if ((GNUNET_YES != decoding) || (GNUNET_CRYPTO_hash_cmp (hash, &check) != 0))
{
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->entries,
hash, entry))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Corrupted entry could not be
removed from store: %s\n",
- GNUNET_h2s(hash));
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->entries,
+ hash, entry))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Corrupted entry could not be removed from store: %s\n",
+ GNUNET_h2s (hash));
store->rewrite_entries = GNUNET_YES;
goto free_message;
}
- if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (store->messages, hash,
message,
+ if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (store->messages, hash,
+ message,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
goto free_buffer;
-free_message: destroy_message (message);
+ free_message : destroy_message (message);
message = NULL;
free_buffer:
- GNUNET_free(buffer);
+ GNUNET_free (buffer);
return message;
}
+
const struct GNUNET_MESSENGER_MessageLink*
get_store_message_link (struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash,
@@ -482,21 +546,26 @@ get_store_message_link (struct
GNUNET_MESSENGER_MessageStore *store,
if (deleted_only)
goto get_link;
- const struct GNUNET_MESSENGER_Message *message = get_store_message(store,
hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (store,
+ hash);
- if (!message)
+ if (! message)
goto get_link;
static struct GNUNET_MESSENGER_MessageLink link;
- GNUNET_memcpy(&(link.first), &(message->header.previous),
sizeof(link.first));
+ GNUNET_memcpy (&(link.first), &(message->header.previous),
+ sizeof(link.first));
- link.multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind?
GNUNET_YES : GNUNET_NO;
+ link.multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind?
+ GNUNET_YES : GNUNET_NO;
if (GNUNET_YES == link.multiple)
- GNUNET_memcpy(&(link.second), &(message->body.merge.previous),
sizeof(link.second));
+ GNUNET_memcpy (&(link.second), &(message->body.merge.previous),
+ sizeof(link.second));
else
- GNUNET_memcpy(&(link.second), &(message->header.previous),
sizeof(link.second));
+ GNUNET_memcpy (&(link.second), &(message->header.previous),
+ sizeof(link.second));
return &link;
@@ -504,78 +573,95 @@ get_link:
return GNUNET_CONTAINER_multihashmap_get (store->links, hash);
}
+
int
put_store_message (struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash,
struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert((store) && (hash) && (message));
+ GNUNET_assert ((store) && (hash) && (message));
return GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}
+
static void
add_link (struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash,
const struct GNUNET_MESSENGER_Message *message)
{
- struct GNUNET_MESSENGER_MessageLink *link = GNUNET_new(struct
GNUNET_MESSENGER_MessageLink);
+ struct GNUNET_MESSENGER_MessageLink *link = GNUNET_new (struct
+
GNUNET_MESSENGER_MessageLink);
- GNUNET_memcpy(&(link->first), &(message->header.previous),
sizeof(link->first));
+ GNUNET_memcpy (&(link->first), &(message->header.previous),
+ sizeof(link->first));
- link->multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind?
GNUNET_YES : GNUNET_NO;
+ link->multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind?
+ GNUNET_YES : GNUNET_NO;
if (GNUNET_YES == link->multiple)
- GNUNET_memcpy(&(link->second), &(message->body.merge.previous),
sizeof(link->second));
+ GNUNET_memcpy (&(link->second), &(message->body.merge.previous),
+ sizeof(link->second));
else
- GNUNET_memcpy(&(link->second), &(message->header.previous),
sizeof(link->second));
+ GNUNET_memcpy (&(link->second), &(message->header.previous),
+ sizeof(link->second));
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(store->links, hash, link,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
- GNUNET_free(link);
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->links, hash, link,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ GNUNET_free (link);
}
+
int
delete_store_message (struct GNUNET_MESSENGER_MessageStore *store,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- const struct GNUNET_MESSENGER_MessageEntry *entry =
GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
+ const struct GNUNET_MESSENGER_MessageEntry *entry =
+ GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
- if (!entry)
+ if (! entry)
goto clear_memory;
- const struct GNUNET_MESSENGER_Message *message = get_store_message(store,
hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (store,
+ hash);
if (message)
add_link (store, hash, message);
- if (!store->storage_messages)
+ if (! store->storage_messages)
goto clear_entry;
- if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages,
entry->offset, GNUNET_DISK_SEEK_SET))
+ if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages,
+ entry->offset,
+ GNUNET_DISK_SEEK_SET))
return GNUNET_SYSERR;
- char *clear_buffer = GNUNET_malloc(entry->length);
+ char *clear_buffer = GNUNET_malloc (entry->length);
- if (!clear_buffer)
+ if (! clear_buffer)
return GNUNET_SYSERR;
GNUNET_CRYPTO_zero_keys (clear_buffer, entry->length);
- if ((entry->length != GNUNET_DISK_file_write (store->storage_messages,
clear_buffer, entry->length)) || (GNUNET_OK
- != GNUNET_DISK_file_sync (store->storage_messages)))
+ if ((entry->length != GNUNET_DISK_file_write (store->storage_messages,
+ clear_buffer, entry->length))
||
+ (GNUNET_OK
+ !=
+ GNUNET_DISK_file_sync (
+ store->storage_messages)))
{
- GNUNET_free(clear_buffer);
+ GNUNET_free (clear_buffer);
return GNUNET_SYSERR;
}
- GNUNET_free(clear_buffer);
+ GNUNET_free (clear_buffer);
clear_entry:
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->entries,
hash, entry))
+ if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->entries, hash,
+ entry))
store->rewrite_entries = GNUNET_YES;
clear_memory:
diff --git a/src/messenger/gnunet-service-messenger_operation.c
b/src/messenger/gnunet-service-messenger_operation.c
index 9c4201fdf..f13db7de0 100644
--- a/src/messenger/gnunet-service-messenger_operation.c
+++ b/src/messenger/gnunet-service-messenger_operation.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -31,30 +31,33 @@
struct GNUNET_MESSENGER_Operation*
create_operation (const struct GNUNET_HashCode *hash)
{
- GNUNET_assert(hash);
+ GNUNET_assert (hash);
- struct GNUNET_MESSENGER_Operation *op = GNUNET_new(struct
GNUNET_MESSENGER_Operation);
+ struct GNUNET_MESSENGER_Operation *op = GNUNET_new (struct
+
GNUNET_MESSENGER_Operation);
op->type = GNUNET_MESSENGER_OP_UNKNOWN;
- GNUNET_memcpy(&(op->hash), hash, sizeof(*hash));
- op->timestamp = GNUNET_TIME_absolute_get_zero_();
+ GNUNET_memcpy (&(op->hash), hash, sizeof(*hash));
+ op->timestamp = GNUNET_TIME_absolute_get_zero_ ();
op->store = NULL;
op->task = NULL;
return op;
}
+
void
destroy_operation (struct GNUNET_MESSENGER_Operation *op)
{
- GNUNET_assert(op);
+ GNUNET_assert (op);
if (op->task)
- GNUNET_SCHEDULER_cancel(op->task);
+ GNUNET_SCHEDULER_cancel (op->task);
- GNUNET_free(op);
+ GNUNET_free (op);
}
+
static void
callback_operation (void *cls);
@@ -62,25 +65,28 @@ struct GNUNET_MESSENGER_Operation*
load_operation (struct GNUNET_MESSENGER_OperationStore *store,
const char *path)
{
- GNUNET_assert((store) && (path));
+ GNUNET_assert ((store) && (path));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load operation configuration: %s\n",
path);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load operation configuration: %s\n",
+ path);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
- struct GNUNET_MESSENGER_Operation* op = NULL;
+ struct GNUNET_MESSENGER_Operation *op = NULL;
- if (GNUNET_OK != GNUNET_CONFIGURATION_parse(cfg, path))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, path))
goto destroy_config;
struct GNUNET_HashCode hash;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation", "hash",
&hash, sizeof(hash)))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation", "hash",
+ &hash, sizeof(hash)))
goto destroy_config;
- op = create_operation(&hash);
+ op = create_operation (&hash);
unsigned long long type_number;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, "operation",
"type", &type_number))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "operation",
+ "type",
&type_number))
switch (type_number)
{
case GNUNET_MESSENGER_OP_REQUEST:
@@ -97,21 +103,25 @@ load_operation (struct GNUNET_MESSENGER_OperationStore
*store,
}
if ((GNUNET_MESSENGER_OP_UNKNOWN == op->type) ||
- (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation",
"timestamp", &(op->timestamp), sizeof(op->timestamp))))
+ (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation",
+ "timestamp",
+ &(op->timestamp),
+ sizeof(op->timestamp))))
{
- destroy_operation(op);
+ destroy_operation (op);
op = NULL;
goto destroy_config;
}
- const struct GNUNET_TIME_Relative delay =
GNUNET_TIME_absolute_get_remaining(op->timestamp);
+ const struct GNUNET_TIME_Relative delay = GNUNET_TIME_absolute_get_remaining
(
+ op->timestamp);
- op->task = GNUNET_SCHEDULER_add_delayed_with_priority(
- delay,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
- callback_operation,
- op
- );
+ op->task = GNUNET_SCHEDULER_add_delayed_with_priority (
+ delay,
+ GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ callback_operation,
+ op
+ );
op->store = store;
@@ -121,42 +131,48 @@ destroy_config:
return op;
}
+
void
save_operation (const struct GNUNET_MESSENGER_Operation *op,
const char *path)
{
- GNUNET_assert((path) && (op));
+ GNUNET_assert ((path) && (op));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save operation configuration: %s\n",
path);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save operation configuration: %s\n",
+ path);
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
char *hash_data;
- hash_data = GNUNET_STRINGS_data_to_string_alloc (&(op->hash),
sizeof(op->hash));
+ hash_data = GNUNET_STRINGS_data_to_string_alloc (&(op->hash),
+ sizeof(op->hash));
if (hash_data)
{
GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "hash",
hash_data);
- GNUNET_free(hash_data);
+ GNUNET_free (hash_data);
}
- GNUNET_CONFIGURATION_set_value_number(cfg, "operation", "type", op->type);
+ GNUNET_CONFIGURATION_set_value_number (cfg, "operation", "type", op->type);
char *timestamp_data;
- timestamp_data = GNUNET_STRINGS_data_to_string_alloc (&(op->timestamp),
sizeof(op->timestamp));
+ timestamp_data = GNUNET_STRINGS_data_to_string_alloc (&(op->timestamp),
+ sizeof(op->timestamp));
if (timestamp_data)
{
- GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "timestamp",
timestamp_data);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "timestamp",
+ timestamp_data);
- GNUNET_free(timestamp_data);
+ GNUNET_free (timestamp_data);
}
GNUNET_CONFIGURATION_write (cfg, path);
GNUNET_CONFIGURATION_destroy (cfg);
}
+
extern void
callback_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
enum GNUNET_MESSENGER_OperationType type,
@@ -172,28 +188,29 @@ callback_operation (void *cls)
callback_store_operation (op->store, op->type, &(op->hash));
}
+
int
start_operation (struct GNUNET_MESSENGER_Operation *op,
enum GNUNET_MESSENGER_OperationType type,
struct GNUNET_MESSENGER_OperationStore *store,
struct GNUNET_TIME_Relative delay)
{
- GNUNET_assert((op) && (store));
+ GNUNET_assert ((op) && (store));
if (op->task)
return GNUNET_SYSERR;
- const struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_add(
- GNUNET_TIME_absolute_get(),
- delay
- );
+ const struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_add (
+ GNUNET_TIME_absolute_get (),
+ delay
+ );
- op->task = GNUNET_SCHEDULER_add_delayed_with_priority(
- delay,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
- callback_operation,
- op
- );
+ op->task = GNUNET_SCHEDULER_add_delayed_with_priority (
+ delay,
+ GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ callback_operation,
+ op
+ );
op->type = type;
op->timestamp = timestamp;
@@ -202,19 +219,20 @@ start_operation (struct GNUNET_MESSENGER_Operation *op,
return GNUNET_OK;
}
+
int
stop_operation (struct GNUNET_MESSENGER_Operation *op)
{
- GNUNET_assert(op);
+ GNUNET_assert (op);
- if (!op->task)
+ if (! op->task)
return GNUNET_SYSERR;
- GNUNET_SCHEDULER_cancel(op->task);
+ GNUNET_SCHEDULER_cancel (op->task);
op->task = NULL;
op->type = GNUNET_MESSENGER_OP_UNKNOWN;
- op->timestamp = GNUNET_TIME_absolute_get_zero_();
+ op->timestamp = GNUNET_TIME_absolute_get_zero_ ();
op->store = NULL;
return GNUNET_OK;
diff --git a/src/messenger/gnunet-service-messenger_operation.h
b/src/messenger/gnunet-service-messenger_operation.h
index b93282d24..6631693cf 100644
--- a/src/messenger/gnunet-service-messenger_operation.h
+++ b/src/messenger/gnunet-service-messenger_operation.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -51,7 +51,7 @@ struct GNUNET_MESSENGER_Operation
struct GNUNET_TIME_Absolute timestamp;
struct GNUNET_MESSENGER_OperationStore *store;
- struct GNUNET_SCHEDULER_Task* task;
+ struct GNUNET_SCHEDULER_Task *task;
};
/**
diff --git a/src/messenger/gnunet-service-messenger_operation_store.c
b/src/messenger/gnunet-service-messenger_operation_store.c
index 6a639d69e..670d5cdf5 100644
--- a/src/messenger/gnunet-service-messenger_operation_store.c
+++ b/src/messenger/gnunet-service-messenger_operation_store.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -33,12 +33,13 @@ void
init_operation_store (struct GNUNET_MESSENGER_OperationStore *store,
struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert((store) && (room));
+ GNUNET_assert ((store) && (room));
store->room = room;
- store->operations = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO);
+ store->operations = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
}
+
static int
iterate_destroy_operations (void *cls,
const struct GNUNET_HashCode *key,
@@ -46,20 +47,23 @@ iterate_destroy_operations (void *cls,
{
struct GNUNET_MESSENGER_Operation *op = value;
- destroy_operation(op);
+ destroy_operation (op);
return GNUNET_YES;
}
+
void
clear_operation_store (struct GNUNET_MESSENGER_OperationStore *store)
{
- GNUNET_assert(store);
+ GNUNET_assert (store);
- GNUNET_CONTAINER_multihashmap_iterate (store->operations,
iterate_destroy_operations, NULL);
- GNUNET_CONTAINER_multihashmap_destroy(store->operations);
+ GNUNET_CONTAINER_multihashmap_iterate (store->operations,
+ iterate_destroy_operations, NULL);
+ GNUNET_CONTAINER_multihashmap_destroy (store->operations);
}
+
static int
callback_scan_for_operations (void *cls,
const char *filename)
@@ -69,37 +73,40 @@ callback_scan_for_operations (void *cls,
if (GNUNET_YES != GNUNET_DISK_file_test (filename))
return GNUNET_OK;
- if ((strlen(filename) <= 4) || (0 != strcmp(filename + strlen(filename) - 4,
".cfg")))
+ if ((strlen (filename) <= 4) || (0 != strcmp (filename + strlen (filename)
+ - 4, ".cfg")))
return GNUNET_OK;
- struct GNUNET_MESSENGER_Operation *op = load_operation(store, filename);
+ struct GNUNET_MESSENGER_Operation *op = load_operation (store, filename);
- if ((op) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
- store->operations,
- &(op->hash), op,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+ if ((op) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
+ store->operations,
+ &(op->hash), op,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
{
- destroy_operation(op);
+ destroy_operation (op);
}
return GNUNET_OK;
}
+
void
load_operation_store (struct GNUNET_MESSENGER_OperationStore *store,
const char *directory)
{
GNUNET_assert ((store) && (directory));
- char* load_dir;
+ char *load_dir;
GNUNET_asprintf (&load_dir, "%s%s%c", directory, "operations",
DIR_SEPARATOR);
if (GNUNET_OK == GNUNET_DISK_directory_test (load_dir, GNUNET_YES))
GNUNET_DISK_directory_scan (load_dir, callback_scan_for_operations, store);
- GNUNET_free(load_dir);
+ GNUNET_free (load_dir);
}
+
static int
iterate_save_operations (void *cls,
const struct GNUNET_HashCode *key,
@@ -109,65 +116,73 @@ iterate_save_operations (void *cls,
struct GNUNET_MESSENGER_Operation *op = value;
- if (!op)
+ if (! op)
return GNUNET_YES;
char *op_dir;
- GNUNET_asprintf (&op_dir, "%s%s.cfg", save_dir, GNUNET_h2s(key));
- save_operation(op, op_dir);
+ GNUNET_asprintf (&op_dir, "%s%s.cfg", save_dir, GNUNET_h2s (key));
+ save_operation (op, op_dir);
- GNUNET_free(op_dir);
+ GNUNET_free (op_dir);
return GNUNET_YES;
}
+
void
save_operation_store (const struct GNUNET_MESSENGER_OperationStore *store,
const char *directory)
{
GNUNET_assert ((store) && (directory));
- char* save_dir;
+ char *save_dir;
GNUNET_asprintf (&save_dir, "%s%s%c", directory, "operations",
DIR_SEPARATOR);
if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
(GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
- GNUNET_CONTAINER_multihashmap_iterate (store->operations,
iterate_save_operations, save_dir);
+ GNUNET_CONTAINER_multihashmap_iterate (store->operations,
+ iterate_save_operations, save_dir);
- GNUNET_free(save_dir);
+ GNUNET_free (save_dir);
}
+
enum GNUNET_MESSENGER_OperationType
get_store_operation_type (const struct GNUNET_MESSENGER_OperationStore *store,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- struct GNUNET_MESSENGER_Operation *op =
GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+ struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get (
+ store->operations, hash);
- if (!op)
+ if (! op)
return GNUNET_MESSENGER_OP_UNKNOWN;
return op->type;
}
+
int
use_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
const struct GNUNET_HashCode *hash,
enum GNUNET_MESSENGER_OperationType type,
struct GNUNET_TIME_Relative delay)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- struct GNUNET_MESSENGER_Operation *op =
GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+ struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get (
+ store->operations, hash);
if (op)
goto use_op;
- op = create_operation(hash);
+ op = create_operation (hash);
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(store->operations, hash,
op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (store->operations, hash,
+ op,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
- destroy_operation(op);
+ destroy_operation (op);
return GNUNET_SYSERR;
}
@@ -177,29 +192,34 @@ use_op:
(type == GNUNET_MESSENGER_OP_DELETE))
stop_operation (op);
- return start_operation(op, type, store, delay);
+ return start_operation (op, type, store, delay);
}
+
void
cancel_store_operation (struct GNUNET_MESSENGER_OperationStore *store,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
- struct GNUNET_MESSENGER_Operation *op =
GNUNET_CONTAINER_multihashmap_get(store->operations, hash);
+ struct GNUNET_MESSENGER_Operation *op = GNUNET_CONTAINER_multihashmap_get (
+ store->operations, hash);
- if (!op)
+ if (! op)
return;
- stop_operation(op);
+ stop_operation (op);
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove(store->operations,
hash, op))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Canceled operation could not be
removed: %s\n",
- GNUNET_h2s(hash));
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->operations,
+ hash, op))
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Canceled operation could not be removed: %s\n",
+ GNUNET_h2s (hash));
- destroy_operation(op);
+ destroy_operation (op);
}
+
extern void
callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *hash);
@@ -213,10 +233,10 @@ callback_store_operation (struct
GNUNET_MESSENGER_OperationStore *store,
enum GNUNET_MESSENGER_OperationType type,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((store) && (hash));
+ GNUNET_assert ((store) && (hash));
struct GNUNET_HashCode op_hash;
- GNUNET_memcpy(&op_hash, hash, sizeof(op_hash));
+ GNUNET_memcpy (&op_hash, hash, sizeof(op_hash));
cancel_store_operation (store, &op_hash);
struct GNUNET_MESSENGER_SrvRoom *room = store->room;
diff --git a/src/messenger/gnunet-service-messenger_room.c
b/src/messenger/gnunet-service-messenger_room.c
index 4e1f2ad87..12d21b814 100644
--- a/src/messenger/gnunet-service-messenger_room.c
+++ b/src/messenger/gnunet-service-messenger_room.c
@@ -49,15 +49,16 @@ struct GNUNET_MESSENGER_SrvRoom*
create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_MESSENGER_SrvRoom *room = GNUNET_new(struct
GNUNET_MESSENGER_SrvRoom);
+ struct GNUNET_MESSENGER_SrvRoom *room = GNUNET_new (struct
+
GNUNET_MESSENGER_SrvRoom);
room->service = handle->service;
room->host = handle;
room->port = NULL;
- GNUNET_memcpy(&(room->key), key, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
room->tunnels = GNUNET_CONTAINER_multipeermap_create (8, GNUNET_NO);
@@ -67,7 +68,7 @@ create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
init_operation_store (get_srv_room_operation_store (room), room);
init_list_tunnels (&(room->basement));
- init_message_state(&(room->state));
+ init_message_state (&(room->state));
room->peer_message = NULL;
@@ -77,11 +78,13 @@ create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
if (room->service->dir)
load_srv_room (room);
- room->idle = GNUNET_SCHEDULER_add_with_priority
(GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
+ room->idle = GNUNET_SCHEDULER_add_with_priority (
+ GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
return room;
}
+
static int
iterate_destroy_tunnels (void *cls,
const struct GNUNET_PeerIdentity *key,
@@ -92,6 +95,7 @@ iterate_destroy_tunnels (void *cls,
return GNUNET_YES;
}
+
static void
handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room);
@@ -99,7 +103,7 @@ void
destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
int deletion)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
if (room->idle)
{
@@ -110,10 +114,11 @@ destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
if (room->port)
GNUNET_CADET_close_port (room->port);
- GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
iterate_destroy_tunnels, NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
iterate_destroy_tunnels,
+ NULL);
handle_room_messages (room);
- if (!(room->service->dir))
+ if (! (room->service->dir))
goto skip_saving;
if (GNUNET_YES == deletion)
@@ -137,49 +142,56 @@ skip_saving:
GNUNET_free (room);
}
+
struct GNUNET_MESSENGER_PeerStore*
get_srv_room_peer_store (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return &(room->peer_store);
}
+
struct GNUNET_MESSENGER_MemberStore*
get_srv_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return &(room->member_store);
}
+
struct GNUNET_MESSENGER_MessageStore*
get_srv_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return &(room->message_store);
}
+
struct GNUNET_MESSENGER_OperationStore*
get_srv_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return &(room->operation_store);
}
+
static int
send_room_info (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- if ((!handle) || (!is_tunnel_connected (tunnel)))
+ if ((! handle) || (! is_tunnel_connected (tunnel)))
return GNUNET_NO;
- return send_tunnel_message (tunnel, handle, create_message_info
(room->service));
+ return send_tunnel_message (tunnel, handle, create_message_info (
+ room->service));
}
+
static void*
callback_room_connect (void *cls,
struct GNUNET_CADET_Channel *channel,
@@ -190,62 +202,72 @@ callback_room_connect (void *cls,
struct GNUNET_MESSENGER_SrvTunnel *tunnel = create_tunnel (room, source);
if ((tunnel) &&
- (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, source,
tunnel,
+ (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, source,
+ tunnel,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
{
destroy_tunnel (tunnel);
tunnel = NULL;
}
- if (!tunnel)
+ if (! tunnel)
{
delayed_disconnect_channel (channel);
return NULL;
}
- bind_tunnel(tunnel, channel);
+ bind_tunnel (tunnel, channel);
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "New tunnel in room (%s) established to
peer: %s\n",
- GNUNET_h2s(get_srv_room_key(room)), GNUNET_i2s (source));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "New tunnel in room (%s) established to peer: %s\n",
+ GNUNET_h2s (get_srv_room_key (room)), GNUNET_i2s (source));
if (GNUNET_YES == send_room_info (room, room->host, tunnel))
return tunnel;
disconnect_tunnel (tunnel);
- if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (room->tunnels,
source, tunnel))
+ if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (room->tunnels,
source,
+ tunnel))
destroy_tunnel (tunnel);
return NULL;
}
+
static int
join_room (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_Member *member)
{
- GNUNET_assert((room) && (handle) && (member));
+ GNUNET_assert ((room) && (handle) && (member));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s
(get_srv_room_key (room)),
- GNUNET_sh2s (get_member_id(member)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (
+ get_srv_room_key (room)),
+ GNUNET_sh2s (get_member_id (member)));
- const struct GNUNET_ShortHashCode *member_id = get_member_id(member);
+ const struct GNUNET_ShortHashCode *member_id = get_member_id (member);
- if (GNUNET_OK != change_srv_handle_member_id (handle,
get_srv_room_key(room), member_id))
+ if (GNUNET_OK != change_srv_handle_member_id (handle, get_srv_room_key
(room),
+ member_id))
return GNUNET_NO;
notify_srv_handle_member_id (handle, room, member_id, GNUNET_YES);
return GNUNET_YES;
}
+
static int
join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id
(handle, get_srv_room_key(room));
+ const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
+ handle, get_srv_room_key (room));
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = add_store_member(member_store,
member_id);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+ member_id);
if (GNUNET_NO == join_room (room, handle, member))
return GNUNET_NO;
@@ -253,6 +275,7 @@ join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room,
return GNUNET_YES;
}
+
extern int
check_tunnel_message (void *cls,
const struct GNUNET_MessageHeader *header);
@@ -269,7 +292,7 @@ int
open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert((room) && (handle));
+ GNUNET_assert ((room) && (handle));
if (room->port)
return join_room_locally (room, handle);
@@ -277,30 +300,39 @@ open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_CADET_Handle *cadet = get_srv_room_cadet (room);
const struct GNUNET_HashCode *key = get_srv_room_key (room);
- struct GNUNET_MQ_MessageHandler handlers[] = {
GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
- struct
GNUNET_MessageHeader, NULL),
- GNUNET_MQ_handler_end() };
+ struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size (
+ tunnel_message,
+
GNUNET_MESSAGE_TYPE_CADET_CLI,
+ struct
+ GNUNET_MessageHeader, NULL),
+ GNUNET_MQ_handler_end () };
struct GNUNET_HashCode port;
- convert_messenger_key_to_port(key, &port);
- room->port = GNUNET_CADET_open_port (cadet, &port, callback_room_connect,
room, NULL, callback_tunnel_disconnect,
+ convert_messenger_key_to_port (key, &port);
+ room->port = GNUNET_CADET_open_port (cadet, &port, callback_room_connect,
+ room, NULL, callback_tunnel_disconnect,
handlers);
if (room->port)
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Port of room (%s) was opened!\n",
- GNUNET_h2s(get_srv_room_key(room)));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Port of room (%s) was opened!\n",
+ GNUNET_h2s (get_srv_room_key (room)));
else
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Port of room (%s) could not be
opened!\n",
- GNUNET_h2s(get_srv_room_key(room)));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Port of room (%s) could not be opened!\n",
+ GNUNET_h2s (get_srv_room_key (room)));
- const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id
(handle, get_srv_room_key(room));
+ const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
+ handle, get_srv_room_key (room));
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = add_store_member(member_store,
member_id);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
+ member_id);
if ((GNUNET_NO == join_room (room, handle, member)) && (room->port))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not join the room,
therefore it keeps closed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "You could not join the room, therefore it keeps closed!\n");
GNUNET_CADET_close_port (room->port);
room->port = NULL;
@@ -308,35 +340,40 @@ open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
return GNUNET_NO;
}
- if (!room->port)
+ if (! room->port)
return GNUNET_NO;
- return send_srv_room_message (room, handle, create_message_peer
(room->service));
+ return send_srv_room_message (room, handle, create_message_peer (
+ room->service));
}
+
int
enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_PeerIdentity *door)
{
- GNUNET_assert((room) && (handle) && (door));
+ GNUNET_assert ((room) && (handle) && (door));
struct GNUNET_PeerIdentity peer;
if ((GNUNET_OK == get_service_peer_identity (room->service, &peer)) &&
- (0 == GNUNET_memcmp(&peer, door)))
+ (0 == GNUNET_memcmp (&peer, door)))
return join_room_locally (room, handle);
- struct GNUNET_MESSENGER_SrvTunnel *tunnel =
GNUNET_CONTAINER_multipeermap_get (room->tunnels, door);
+ struct GNUNET_MESSENGER_SrvTunnel *tunnel =
+ GNUNET_CONTAINER_multipeermap_get (room->tunnels, door);
- if (!tunnel)
+ if (! tunnel)
{
tunnel = create_tunnel (room, door);
- if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, door,
tunnel,
+ if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, door,
+ tunnel,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not connect to that
door!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "You could not connect to that door!\n");
destroy_tunnel (tunnel);
return GNUNET_NO;
}
@@ -344,7 +381,8 @@ enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room,
if (GNUNET_SYSERR == connect_tunnel (tunnel))
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connection failure during
entrance!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Connection failure during entrance!\n");
GNUNET_CONTAINER_multipeermap_remove (room->tunnels, door, tunnel);
destroy_tunnel (tunnel);
return GNUNET_NO;
@@ -353,20 +391,22 @@ enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room,
return join_room_locally (room, handle);
}
+
static void
sign_srv_room_message_by_peer (const void *cls,
- struct GNUNET_MESSENGER_Message *message,
- uint16_t length,
- char *buffer,
- const struct GNUNET_HashCode *hash)
+ struct GNUNET_MESSENGER_Message *message,
+ uint16_t length,
+ char *buffer,
+ const struct GNUNET_HashCode *hash)
{
const struct GNUNET_MESSENGER_SrvHandle *handle = cls;
- GNUNET_assert((handle) && (handle->service));
+ GNUNET_assert ((handle) && (handle->service));
- sign_message_by_peer(message, length, buffer, hash, handle->service->config);
+ sign_message_by_peer (message, length, buffer, hash,
handle->service->config);
}
+
struct GNUNET_MQ_Envelope*
pack_srv_room_message (const struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_MESSENGER_SrvHandle *handle,
@@ -374,27 +414,31 @@ pack_srv_room_message (const struct
GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_HashCode *hash,
int mode)
{
- GNUNET_assert((room) && (handle) && (message) && (hash));
+ GNUNET_assert ((room) && (handle) && (message) && (hash));
- if (GNUNET_YES != is_peer_message(message))
+ if (GNUNET_YES != is_peer_message (message))
return pack_message (message, hash, NULL, mode, NULL);
- message->header.timestamp = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_get ());
+ message->header.timestamp = GNUNET_TIME_absolute_hton (
+ GNUNET_TIME_absolute_get ());
struct GNUNET_PeerIdentity peer;
- if (GNUNET_OK != get_service_peer_identity(handle->service, &peer))
+ if (GNUNET_OK != get_service_peer_identity (handle->service, &peer))
return NULL;
- convert_peer_identity_to_id(&peer, &(message->header.sender_id));
+ convert_peer_identity_to_id (&peer, &(message->header.sender_id));
get_message_state_chain_hash (&(room->state), &(message->header.previous));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packing message with peer signature:
%s\n",
- GNUNET_sh2s (&(message->header.sender_id)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Packing message with peer signature: %s\n",
+ GNUNET_sh2s (&(message->header.sender_id)));
message->header.signature.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA);
- return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
handle);
+ return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
+ handle);
}
+
struct GNUNET_MESSENGER_ClosureSendRoom
{
struct GNUNET_MESSENGER_SrvRoom *room;
@@ -412,8 +456,8 @@ iterate_send_room_message (void *cls,
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
- if ((!is_tunnel_connected (tunnel)) ||
- (get_tunnel_messenger_version(tunnel) < GNUNET_MESSENGER_VERSION))
+ if ((! is_tunnel_connected (tunnel)) ||
+ (get_tunnel_messenger_version (tunnel) < GNUNET_MESSENGER_VERSION))
return GNUNET_YES;
struct GNUNET_MESSENGER_ClosureSendRoom *closure = cls;
@@ -425,14 +469,16 @@ iterate_send_room_message (void *cls,
if (closure->packed == GNUNET_NO)
{
- env = pack_srv_room_message (closure->room, closure->handle,
closure->message, closure->hash,
- GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
+ env = pack_srv_room_message (closure->room, closure->handle,
+ closure->message, closure->hash,
+ GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
if (env)
closure->packed = GNUNET_YES;
}
else
- env = pack_message(closure->message, NULL, NULL,
GNUNET_MESSENGER_PACK_MODE_ENVELOPE, NULL);
+ env = pack_message (closure->message, NULL, NULL,
+ GNUNET_MESSENGER_PACK_MODE_ENVELOPE, NULL);
if (env)
send_tunnel_envelope (tunnel, env, closure->hash);
@@ -440,6 +486,7 @@ iterate_send_room_message (void *cls,
return GNUNET_YES;
}
+
int
update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_Message *message,
@@ -455,16 +502,17 @@ send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
struct GNUNET_MESSENGER_SrvHandle *handle,
struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert((room) && (handle));
+ GNUNET_assert ((room) && (handle));
- if (!message)
+ if (! message)
return GNUNET_NO;
- if (GNUNET_YES == is_message_session_bound(message))
- merge_srv_room_last_messages(room, handle);
+ if (GNUNET_YES == is_message_session_bound (message))
+ merge_srv_room_last_messages (room, handle);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message from handle in room:
%s (%s)\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending message from handle in room: %s (%s)\n",
GNUNET_h2s (&(room->key)),
GNUNET_MESSENGER_name_of_kind (message->header.kind));
@@ -478,10 +526,12 @@ send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
closure.hash = &hash;
closure.packed = GNUNET_NO;
- GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
iterate_send_room_message, &closure);
+ GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
+ iterate_send_room_message, &closure);
if (GNUNET_NO == closure.packed)
- pack_srv_room_message (room, handle, message, &hash,
GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
+ pack_srv_room_message (room, handle, message, &hash,
+ GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
const int new_message = update_room_message (room, message, &hash);
@@ -513,21 +563,22 @@ send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
return GNUNET_YES;
}
+
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)
{
- GNUNET_assert((room) && (tunnel));
+ GNUNET_assert ((room) && (tunnel));
- if (!message)
+ if (! message)
return;
struct GNUNET_MESSENGER_ClosureSendRoom closure;
struct GNUNET_HashCode message_hash;
- GNUNET_memcpy(&message_hash, hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&message_hash, hash, sizeof(struct GNUNET_HashCode));
closure.room = room;
closure.handle = NULL;
@@ -536,38 +587,43 @@ forward_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
closure.hash = &message_hash;
closure.packed = GNUNET_YES;
- GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
iterate_send_room_message, &closure);
+ GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
+ iterate_send_room_message, &closure);
}
+
void
check_srv_room_peer_status (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- if (!room->peer_message)
+ if (! room->peer_message)
return;
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, room->peer_message);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, room->peer_message);
- if (!message)
+ if (! message)
{
- GNUNET_free(room->peer_message);
+ GNUNET_free (room->peer_message);
room->peer_message = NULL;
return;
}
if (tunnel)
- forward_tunnel_message(tunnel, message, room->peer_message);
+ forward_tunnel_message (tunnel, message, room->peer_message);
}
+
void
merge_srv_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
- if (!handle)
+ if (! handle)
return;
const struct GNUNET_HashCode *hash;
@@ -575,132 +631,154 @@ merge_srv_room_last_messages (struct
GNUNET_MESSENGER_SrvRoom *room,
merge_next:
hash = get_message_state_merge_hash (&(room->state));
- if (!hash)
+ if (! hash)
return;
send_srv_room_message (room, handle, create_message_merge (hash));
goto merge_next;
}
+
void
callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *hash)
{
- if (GNUNET_OK != delete_store_message (get_srv_room_message_store(room),
hash))
+ if (GNUNET_OK != delete_store_message (get_srv_room_message_store (room),
+ hash))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Deletion of message failed!
(%s)\n", GNUNET_h2s(hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deletion of message failed!
(%s)\n",
+ GNUNET_h2s (hash));
return;
}
}
+
void
callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *hash)
{
- if (!room->host)
+ if (! room->host)
return;
send_srv_room_message (room, room->host, create_message_merge (hash));
}
+
int
delete_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_MemberSession *session,
const struct GNUNET_HashCode *hash,
const struct GNUNET_TIME_Relative delay)
{
- GNUNET_assert((room) && (session) && (hash));
+ GNUNET_assert ((room) && (session) && (hash));
- const struct GNUNET_TIME_Relative forever =
GNUNET_TIME_relative_get_forever_ ();
+ const struct GNUNET_TIME_Relative forever =
+ GNUNET_TIME_relative_get_forever_ ();
- if (0 == GNUNET_memcmp(&forever, &delay))
+ if (0 == GNUNET_memcmp (&forever, &delay))
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Deletion is delayed forever: operation
is impossible!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Deletion is delayed forever: operation is impossible!\n");
return GNUNET_SYSERR;
}
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, hash);
- if (!message)
+ if (! message)
return GNUNET_YES;
- if (GNUNET_YES != check_member_session_history(session, hash, GNUNET_YES))
+ if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_YES))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unpermitted request for deletion by
member (%s) of message (%s)!\n",
- GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Unpermitted request for deletion by member (%s) of message
(%s)!\n",
+ GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (
+ hash));
return GNUNET_NO;
}
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(room);
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (room);
- if (GNUNET_OK != use_store_operation(operation_store, hash,
GNUNET_MESSENGER_OP_DELETE, delay))
+ if (GNUNET_OK != use_store_operation (operation_store, hash,
+ GNUNET_MESSENGER_OP_DELETE, delay))
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Deletion has failed: operation
denied!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Deletion has failed: operation denied!\n");
return GNUNET_SYSERR;
}
return GNUNET_YES;
}
+
struct GNUNET_CADET_Handle*
get_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return room->service->cadet;
}
+
const struct GNUNET_HashCode*
get_srv_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
return &(room->key);
}
+
const struct GNUNET_MESSENGER_SrvTunnel*
get_srv_room_tunnel (const struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_PeerIdentity *peer)
{
- GNUNET_assert((room) && (peer));
+ GNUNET_assert ((room) && (peer));
return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
}
+
static int
request_room_message_step (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *hash,
const struct GNUNET_MESSENGER_MemberSession
*session,
GNUNET_MESSENGER_MessageRequestCallback callback,
- void* cls)
+ void *cls)
{
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
- const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link(
- message_store, hash, GNUNET_YES
- );
+ const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link (
+ message_store, hash, GNUNET_YES
+ );
- if (!link)
+ if (! link)
goto forward;
- int result = request_room_message_step(room, &(link->first), session,
callback, cls);
+ int result = request_room_message_step (room, &(link->first), session,
+ callback, cls);
if ((GNUNET_YES == link->multiple) &&
- (GNUNET_YES == request_room_message_step(room, &(link->second), session,
callback, cls)))
+ (GNUNET_YES == request_room_message_step (room, &(link->second), session,
+ callback, cls)))
return GNUNET_YES;
else
return result;
forward:
- if (GNUNET_YES != check_member_session_history(session, hash, GNUNET_NO))
+ if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_NO))
return GNUNET_YES;
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, hash);
- if (!message)
+ if (! message)
return GNUNET_NO;
if (callback)
@@ -709,14 +787,15 @@ forward:
return GNUNET_YES;
}
+
int
request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_HashCode *hash,
const struct GNUNET_MESSENGER_MemberSession *session,
GNUNET_MESSENGER_MessageRequestCallback callback,
- void* cls)
+ void *cls)
{
- GNUNET_assert((room) && (hash));
+ GNUNET_assert ((room) && (hash));
int result = request_room_message_step (room, hash, session, callback, cls);
@@ -726,26 +805,31 @@ request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
return result;
}
+
void
callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room,
void *cls)
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
- if (!room->host)
+ if (! room->host)
return;
struct GNUNET_PeerIdentity identity;
- get_tunnel_peer_identity(tunnel, &identity);
+ get_tunnel_peer_identity (tunnel, &identity);
- if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels,
&identity, tunnel)) ||
- (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(room->tunnels,
&identity)))
+ if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels,
+ &identity,
+ tunnel)) ||
+ (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (room->tunnels,
+ &identity)))
return;
if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
send_srv_room_message (room, room->host, create_message_miss (&identity));
}
+
int
callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
void *cls,
@@ -754,32 +838,40 @@ callback_verify_room_message (struct
GNUNET_MESSENGER_SrvRoom *room,
{
if (GNUNET_MESSENGER_KIND_UNKNOWN == message->header.kind)
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Message error: Kind is unknown!
(%d)\n", message->header.kind);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Message error: Kind is unknown! (%d)\n",
message->header.kind);
return GNUNET_SYSERR;
}
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
- const struct GNUNET_MESSENGER_Message *previous =
get_store_message(message_store, &(message->header.previous));
+ const struct GNUNET_MESSENGER_Message *previous = get_store_message (
+ message_store, &(message->header.previous));
- if (!previous)
+ if (! previous)
goto skip_time_comparison;
- struct GNUNET_TIME_Absolute timestamp =
GNUNET_TIME_absolute_ntoh(message->header.timestamp);
- struct GNUNET_TIME_Absolute last =
GNUNET_TIME_absolute_ntoh(previous->header.timestamp);
+ struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_ntoh (
+ message->header.timestamp);
+ struct GNUNET_TIME_Absolute last = GNUNET_TIME_absolute_ntoh (
+ previous->header.timestamp);
- if (GNUNET_TIME_relative_get_zero_().rel_value_us !=
GNUNET_TIME_absolute_get_difference(timestamp, last).rel_value_us)
+ if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
+ GNUNET_TIME_absolute_get_difference (timestamp, last).rel_value_us)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message warning: Timestamp does not
check out!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Message warning: Timestamp does not check out!\n");
}
skip_time_comparison:
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
- GNUNET_MESSENGER_name_of_kind(message->header.kind));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
+ GNUNET_MESSENGER_name_of_kind (message->header.kind));
return GNUNET_OK;
}
+
static void
idle_request_room_messages (void *cls)
{
@@ -787,63 +879,74 @@ idle_request_room_messages (void *cls)
room->idle = NULL;
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(room);
- const struct GNUNET_HashCode *hash =
get_message_state_merge_hash(&(room->state));
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (room);
+ const struct GNUNET_HashCode *hash = get_message_state_merge_hash (
+ &(room->state));
if ((hash) &&
- (GNUNET_MESSENGER_OP_UNKNOWN ==
get_store_operation_type(operation_store, hash)))
- use_store_operation(
- operation_store,
- hash,
- GNUNET_MESSENGER_OP_MERGE,
- GNUNET_MESSENGER_MERGE_DELAY
- );
+ (GNUNET_MESSENGER_OP_UNKNOWN == get_store_operation_type
(operation_store,
+ hash)))
+ use_store_operation (
+ operation_store,
+ hash,
+ GNUNET_MESSENGER_OP_MERGE,
+ GNUNET_MESSENGER_MERGE_DELAY
+ );
room->idle = GNUNET_SCHEDULER_add_delayed_with_priority (
- GNUNET_MESSENGER_IDLE_DELAY,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
- idle_request_room_messages,
- cls
- );
+ GNUNET_MESSENGER_IDLE_DELAY,
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ idle_request_room_messages,
+ cls
+ );
}
+
void
solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room,
- const struct GNUNET_IDENTITY_PublicKey
*public_key,
+ const struct
+ GNUNET_IDENTITY_PublicKey *public_key,
const struct GNUNET_ShortHashCode *member_id,
struct GNUNET_TIME_Absolute timestamp)
{
GNUNET_assert ((room) && (public_key) && (member_id));
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store(room);
- struct GNUNET_MESSENGER_Member *member = get_store_member(member_store,
member_id);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_Member *member = get_store_member (member_store,
+ member_id);
- if ((!member) || (1 >= GNUNET_CONTAINER_multihashmap_size(member->sessions)))
+ if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
+ member->sessions)))
return;
struct GNUNET_MESSENGER_ListHandles *handles = &(room->service->handles);
- struct GNUNET_MESSENGER_ListHandle* element;
+ struct GNUNET_MESSENGER_ListHandle *element;
const struct GNUNET_IDENTITY_PublicKey *pubkey;
for (element = handles->head; element; element = element->next)
{
- if (0 != GNUNET_memcmp(member_id,
get_srv_handle_member_id(element->handle, get_srv_room_key(room))))
+ if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
+ element->handle, get_srv_room_key (room))))
continue;
- pubkey = get_srv_handle_key(element->handle);
+ pubkey = get_srv_handle_key (element->handle);
- if (0 == GNUNET_memcmp(public_key, pubkey))
+ if (0 == GNUNET_memcmp (public_key, pubkey))
continue;
- struct GNUNET_MESSENGER_MemberSession *session =
get_member_session(member, pubkey);
+ struct GNUNET_MESSENGER_MemberSession *session = get_member_session
(member,
+
pubkey);
- if (!session)
+ if (! session)
continue;
- struct GNUNET_TIME_Absolute start = get_member_session_start(session);
+ struct GNUNET_TIME_Absolute start = get_member_session_start (session);
- if (GNUNET_TIME_relative_get_zero_().rel_value_us !=
GNUNET_TIME_absolute_get_difference(start, timestamp).rel_value_us)
+ if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
+ GNUNET_TIME_absolute_get_difference (start, timestamp).rel_value_us)
continue;
struct GNUNET_ShortHashCode random_id;
@@ -853,16 +956,17 @@ solve_srv_room_member_collisions (struct
GNUNET_MESSENGER_SrvRoom *room,
}
}
+
void
rebuild_srv_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
struct GNUNET_PeerIdentity peer;
size_t src;
if ((GNUNET_OK != get_service_peer_identity (room->service, &peer)) ||
- (!find_list_tunnels (&(room->basement), &peer, &src)))
+ (! find_list_tunnels (&(room->basement), &peer, &src)))
return;
size_t count = count_of_tunnels (&(room->basement));
@@ -878,7 +982,7 @@ rebuild_srv_room_basement_structure (struct
GNUNET_MESSENGER_SrvRoom *room)
tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, &peer);
- if (!tunnel)
+ if (! tunnel)
{
element = remove_from_list_tunnels (&(room->basement), element);
continue;
@@ -900,20 +1004,25 @@ rebuild_srv_room_basement_structure (struct
GNUNET_MESSENGER_SrvRoom *room)
}
}
+
static void
handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
{
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store (room);
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store (room);
- struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store
(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store (
+ room);
while (room->handling.head)
{
struct GNUNET_MESSENGER_ListMessage *element = room->handling.head;
- const struct GNUNET_MESSENGER_Message *message = get_store_message
(message_store, &(element->hash));
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, &(element->hash));
- if (!message)
+ if (! message)
goto finish_handling;
struct GNUNET_MESSENGER_SenderSession session;
@@ -922,62 +1031,73 @@ handle_room_messages (struct GNUNET_MESSENGER_SrvRoom
*room)
{
session.peer = get_store_peer_of (peer_store, message, &(element->hash));
- if (!session.peer)
+ if (! session.peer)
goto finish_handling;
}
else
{
- struct GNUNET_MESSENGER_Member *member = get_store_member_of
(member_store, message);
+ struct GNUNET_MESSENGER_Member *member = get_store_member_of (
+ member_store, message);
- if (!member)
+ if (! member)
goto finish_handling;
- session.member = get_member_session_of (member, message,
&(element->hash));
+ session.member = get_member_session_of (member, message,
+ &(element->hash));
- if (!session.member)
+ if (! session.member)
goto finish_handling;
}
- handle_service_message (room->service, room, &session, message,
&(element->hash));
+ handle_service_message (room->service, room, &session, message,
+ &(element->hash));
finish_handling:
- GNUNET_CONTAINER_DLL_remove(room->handling.head, room->handling.tail,
element);
- GNUNET_free(element);
+ GNUNET_CONTAINER_DLL_remove (room->handling.head, room->handling.tail,
+ element);
+ GNUNET_free (element);
}
}
+
int
update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((room) && (message) && (hash));
+ GNUNET_assert ((room) && (message) && (hash));
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(room);
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (room);
- const int requested = (GNUNET_MESSENGER_OP_REQUEST ==
get_store_operation_type(operation_store, hash)?
- GNUNET_YES : GNUNET_NO
- );
+ const int requested = (GNUNET_MESSENGER_OP_REQUEST ==
+ get_store_operation_type (operation_store, hash)?
+ GNUNET_YES : GNUNET_NO
+ );
if (GNUNET_YES == requested)
- cancel_store_operation(operation_store, hash);
+ cancel_store_operation (operation_store, hash);
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (room);
- const struct GNUNET_MESSENGER_Message *old_message = get_store_message
(message_store, hash);
+ const struct GNUNET_MESSENGER_Message *old_message = get_store_message (
+ message_store, hash);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
GNUNET_h2s (get_srv_room_key(room)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
+ GNUNET_h2s (get_srv_room_key (room)));
- if ((old_message) || (GNUNET_OK != put_store_message (message_store, hash,
message)))
+ if ((old_message) || (GNUNET_OK != put_store_message (message_store, hash,
+ message)))
{
if (old_message != message)
- destroy_message(message);
+ destroy_message (message);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
return GNUNET_NO;
}
- update_message_state(&(room->state), requested, message, hash);
+ update_message_state (&(room->state), requested, message, hash);
if ((GNUNET_YES == requested) ||
(GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
@@ -985,15 +1105,20 @@ update_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
return GNUNET_YES;
if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
- (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type(operation_store,
&(message->body.merge.previous))))
- cancel_store_operation(operation_store, &(message->body.merge.previous));
+ (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
+ &(message->body.
+
merge.previous))))
+ cancel_store_operation (operation_store, &(message->body.merge.previous));
- if (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type(operation_store,
&(message->header.previous)))
- cancel_store_operation(operation_store, &(message->header.previous));
+ if (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
+ &(message->header.
+ previous)))
+ cancel_store_operation (operation_store, &(message->header.previous));
return GNUNET_YES;
}
+
struct GNUNET_MESSENGER_MemberSessionCompletion
{
struct GNUNET_MESSENGER_MemberSessionCompletion *prev;
@@ -1013,27 +1138,29 @@ struct GNUNET_MESSENGER_MemberUpdate
static int
iterate_update_member_sessions (void *cls,
- const struct GNUNET_IDENTITY_PublicKey
*public_key,
+ const struct
+ GNUNET_IDENTITY_PublicKey *public_key,
struct GNUNET_MESSENGER_MemberSession *session)
{
struct GNUNET_MESSENGER_MemberUpdate *update = cls;
- update_member_session_history(session, update->message, update->hash);
+ update_member_session_history (session, update->message, update->hash);
- if (GNUNET_YES == is_member_session_completed(session))
+ if (GNUNET_YES == is_member_session_completed (session))
{
- struct GNUNET_MESSENGER_MemberSessionCompletion *element = GNUNET_new(
- struct GNUNET_MESSENGER_MemberSessionCompletion
- );
+ struct GNUNET_MESSENGER_MemberSessionCompletion *element = GNUNET_new (
+ struct GNUNET_MESSENGER_MemberSessionCompletion
+ );
element->session = session;
- GNUNET_CONTAINER_DLL_insert_tail(update->head, update->tail, element);
+ GNUNET_CONTAINER_DLL_insert_tail (update->head, update->tail, element);
}
return GNUNET_YES;
}
+
static void
remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_MemberSession *session);
@@ -1043,10 +1170,12 @@ callback_room_handle_message (struct
GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((room) && (message) && (hash));
+ GNUNET_assert ((room) && (message) && (hash));
- struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store
(room);
- struct GNUNET_MESSENGER_MemberStore *member_store =
get_srv_room_member_store (room);
+ struct GNUNET_MESSENGER_PeerStore *peer_store = get_srv_room_peer_store (
+ room);
+ struct GNUNET_MESSENGER_MemberStore *member_store =
+ get_srv_room_member_store (room);
struct GNUNET_MESSENGER_SenderSession session;
@@ -1054,29 +1183,34 @@ callback_room_handle_message (struct
GNUNET_MESSENGER_SrvRoom *room,
{
session.peer = get_store_peer_of (peer_store, message, hash);
- if (!session.peer)
+ if (! session.peer)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message handling dropped: Peer is
missing!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Message handling dropped: Peer is missing!\n");
return;
}
}
else
{
- struct GNUNET_MESSENGER_Member *member = get_store_member_of
(member_store, message);
+ struct GNUNET_MESSENGER_Member *member = get_store_member_of (member_store,
+ message);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
GNUNET_h2s (hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
+ GNUNET_h2s (hash));
- if (!member)
+ if (! member)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message handling dropped: Member
is missing!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Message handling dropped: Member is missing!\n");
return;
}
session.member = get_member_session_of (member, message, hash);
- if (!session.member)
+ if (! session.member)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Message handling dropped: Session
is missing!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Message handling dropped: Session is missing!\n");
return;
}
}
@@ -1088,7 +1222,7 @@ callback_room_handle_message (struct
GNUNET_MESSENGER_SrvRoom *room,
update.head = NULL;
update.tail = NULL;
- iterate_store_members(member_store, iterate_update_member_sessions, &update);
+ iterate_store_members (member_store, iterate_update_member_sessions,
&update);
while (update.head)
{
@@ -1096,7 +1230,7 @@ callback_room_handle_message (struct
GNUNET_MESSENGER_SrvRoom *room,
remove_room_member_session (room, element->session);
- GNUNET_CONTAINER_DLL_remove(update.head, update.tail, element);
+ GNUNET_CONTAINER_DLL_remove (update.head, update.tail, element);
GNUNET_free (element);
}
@@ -1138,45 +1272,50 @@ callback_room_handle_message (struct
GNUNET_MESSENGER_SrvRoom *room,
handle_room_messages (room);
}
+
static void
get_room_data_subdir (struct GNUNET_MESSENGER_SrvRoom *room,
char **dir)
{
- GNUNET_assert((room) && (dir));
+ GNUNET_assert ((room) && (dir));
- GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms",
DIR_SEPARATOR, GNUNET_h2s (get_srv_room_key(room)), DIR_SEPARATOR);
+ GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms",
+ DIR_SEPARATOR, GNUNET_h2s (get_srv_room_key (room)),
+ DIR_SEPARATOR);
}
+
void
load_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
char *room_dir;
get_room_data_subdir (room, &room_dir);
if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
{
- load_member_store (get_srv_room_member_store(room), room_dir);
- load_message_store (get_srv_room_message_store(room), room_dir);
- load_operation_store(get_srv_room_operation_store(room), room_dir);
+ load_member_store (get_srv_room_member_store (room), room_dir);
+ load_message_store (get_srv_room_message_store (room), room_dir);
+ load_operation_store (get_srv_room_operation_store (room), room_dir);
char *basement_file;
GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
- load_list_tunnels(&(room->basement), basement_file);
- GNUNET_free(basement_file);
+ load_list_tunnels (&(room->basement), basement_file);
+ GNUNET_free (basement_file);
- load_message_state(&(room->state), room_dir);
+ load_message_state (&(room->state), room_dir);
}
- GNUNET_free(room_dir);
+ GNUNET_free (room_dir);
}
+
void
save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
char *room_dir;
get_room_data_subdir (room, &room_dir);
@@ -1184,36 +1323,38 @@ save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
(GNUNET_OK == GNUNET_DISK_directory_create (room_dir)))
{
- save_member_store(get_srv_room_member_store(room), room_dir);
- save_message_store (get_srv_room_message_store(room), room_dir);
- save_operation_store(get_srv_room_operation_store(room), room_dir);
+ save_member_store (get_srv_room_member_store (room), room_dir);
+ save_message_store (get_srv_room_message_store (room), room_dir);
+ save_operation_store (get_srv_room_operation_store (room), room_dir);
char *basement_file;
GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
- save_list_tunnels(&(room->basement), basement_file);
- GNUNET_free(basement_file);
+ save_list_tunnels (&(room->basement), basement_file);
+ GNUNET_free (basement_file);
- save_message_state(&(room->state), room_dir);
+ save_message_state (&(room->state), room_dir);
}
- GNUNET_free(room_dir);
+ GNUNET_free (room_dir);
}
+
void
remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
char *room_dir;
get_room_data_subdir (room, &room_dir);
if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
- GNUNET_DISK_directory_remove(room_dir);
+ GNUNET_DISK_directory_remove (room_dir);
- GNUNET_free(room_dir);
+ GNUNET_free (room_dir);
}
+
static void
remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_MemberSession *session)
@@ -1222,27 +1363,28 @@ remove_room_member_session (struct
GNUNET_MESSENGER_SrvRoom *room,
remove_member_session (session->member, session);
- const struct GNUNET_IDENTITY_PublicKey *public_key =
get_member_session_public_key(session);
+ const struct GNUNET_IDENTITY_PublicKey *public_key =
+ get_member_session_public_key (session);
struct GNUNET_HashCode hash;
- GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
+ GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
char *room_dir;
get_room_data_subdir (room, &room_dir);
- char* session_dir;
+ char *session_dir;
GNUNET_asprintf (
- &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
- "members", DIR_SEPARATOR,
- GNUNET_sh2s(get_member_session_id(session)), DIR_SEPARATOR,
- "sessions", DIR_SEPARATOR,
- GNUNET_h2s(&hash), DIR_SEPARATOR
- );
+ &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
+ "members", DIR_SEPARATOR,
+ GNUNET_sh2s (get_member_session_id (session)), DIR_SEPARATOR,
+ "sessions", DIR_SEPARATOR,
+ GNUNET_h2s (&hash), DIR_SEPARATOR
+ );
GNUNET_free (room_dir);
- GNUNET_DISK_directory_remove(session_dir);
+ GNUNET_DISK_directory_remove (session_dir);
GNUNET_free (session_dir);
- destroy_member_session(session);
+ destroy_member_session (session);
}
diff --git a/src/messenger/gnunet-service-messenger_room.h
b/src/messenger/gnunet-service-messenger_room.h
index f0bb33f80..a4a76645d 100644
--- a/src/messenger/gnunet-service-messenger_room.h
+++ b/src/messenger/gnunet-service-messenger_room.h
@@ -45,13 +45,13 @@
#include "gnunet-service-messenger_operation_store.h"
#define GNUNET_MESSENGER_IDLE_DELAY GNUNET_TIME_relative_multiply \
- (GNUNET_TIME_relative_get_second_ (), 5)
+ (GNUNET_TIME_relative_get_second_ (), 5)
#define GNUNET_MESSENGER_REQUEST_DELAY GNUNET_TIME_relative_multiply \
- (GNUNET_TIME_relative_get_minute_ (), 5)
+ (GNUNET_TIME_relative_get_minute_ (), 5)
#define GNUNET_MESSENGER_MERGE_DELAY GNUNET_TIME_relative_multiply \
- (GNUNET_TIME_relative_get_second_ (), 30)
+ (GNUNET_TIME_relative_get_second_ (), 30)
struct GNUNET_MESSENGER_SrvTunnel;
struct GNUNET_MESSENGER_MemberSession;
@@ -89,7 +89,7 @@ struct GNUNET_MESSENGER_SrvRoom
*/
struct GNUNET_MESSENGER_SrvRoom*
create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
- const struct GNUNET_HashCode *key);
+ const struct GNUNET_HashCode *key);
/**
* Destroys a room and frees its memory fully.
@@ -102,7 +102,7 @@ create_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle,
*/
void
destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room,
- int deletion);
+ int deletion);
/**
* Returns the used peer store of a given <i>room</i>.
@@ -307,11 +307,11 @@ get_srv_room_tunnel (const struct
GNUNET_MESSENGER_SrvRoom *room,
* @param[in] hash Hash of message
*/
typedef void (GNUNET_MESSENGER_MessageRequestCallback) (
- void *cls,
- struct GNUNET_MESSENGER_SrvRoom *room,
- const struct GNUNET_MESSENGER_Message *message,
- const struct GNUNET_HashCode *hash
-);
+ void *cls,
+ struct GNUNET_MESSENGER_SrvRoom *room,
+ const struct GNUNET_MESSENGER_Message *message,
+ const struct GNUNET_HashCode *hash
+ );
/**
* Requests a message from a <i>room</i> identified by a given <i>hash</i>. If
the message is found,
@@ -333,7 +333,7 @@ request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
const struct GNUNET_HashCode *hash,
const struct GNUNET_MESSENGER_MemberSession *session,
GNUNET_MESSENGER_MessageRequestCallback callback,
- void* cls);
+ void *cls);
/**
* Checks for potential collisions with member ids and solves them changing
active handles ids if they
@@ -346,7 +346,8 @@ request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom
*room,
*/
void
solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room,
- const struct GNUNET_IDENTITY_PublicKey
*public_key,
+ const struct
+ GNUNET_IDENTITY_PublicKey *public_key,
const struct GNUNET_ShortHashCode *member_id,
struct GNUNET_TIME_Absolute timestamp);
diff --git a/src/messenger/gnunet-service-messenger_sender_session.h
b/src/messenger/gnunet-service-messenger_sender_session.h
index b137da11a..6eb287607 100644
--- a/src/messenger/gnunet-service-messenger_sender_session.h
+++ b/src/messenger/gnunet-service-messenger_sender_session.h
@@ -31,8 +31,10 @@
#include "gnunet-service-messenger_member_session.h"
-struct GNUNET_MESSENGER_SenderSession {
- union {
+struct GNUNET_MESSENGER_SenderSession
+{
+ union
+ {
struct GNUNET_MESSENGER_MemberSession *member;
struct GNUNET_PeerIdentity *peer;
};
diff --git a/src/messenger/gnunet-service-messenger_service.c
b/src/messenger/gnunet-service-messenger_service.c
index 2f4d7bf80..b72bbd201 100644
--- a/src/messenger/gnunet-service-messenger_service.c
+++ b/src/messenger/gnunet-service-messenger_service.c
@@ -41,37 +41,43 @@ callback_shutdown_service (void *cls)
}
}
+
struct GNUNET_MESSENGER_Service*
create_service (const struct GNUNET_CONFIGURATION_Handle *config,
struct GNUNET_SERVICE_Handle *service_handle)
{
- GNUNET_assert((config) && (service_handle));
+ GNUNET_assert ((config) && (service_handle));
- struct GNUNET_MESSENGER_Service *service = GNUNET_new(struct
GNUNET_MESSENGER_Service);
+ struct GNUNET_MESSENGER_Service *service = GNUNET_new (struct
+
GNUNET_MESSENGER_Service);
service->config = config;
service->service = service_handle;
- service->shutdown = GNUNET_SCHEDULER_add_shutdown
(&callback_shutdown_service, service);
+ service->shutdown = GNUNET_SCHEDULER_add_shutdown
(&callback_shutdown_service,
+ service);
service->peer = NULL;
service->dir = NULL;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (service->config,
- GNUNET_MESSENGER_SERVICE_NAME,
- "MESSENGER_DIR",
&(service->dir)))
+
GNUNET_MESSENGER_SERVICE_NAME,
+ "MESSENGER_DIR",
+ &(service->dir)))
{
if (service->dir)
- GNUNET_free(service->dir);
+ GNUNET_free (service->dir);
service->dir = NULL;
}
else
{
- if ((GNUNET_YES != GNUNET_DISK_directory_test (service->dir, GNUNET_YES))
&& (GNUNET_OK
- != GNUNET_DISK_directory_create (service->dir)))
+ if ((GNUNET_YES != GNUNET_DISK_directory_test (service->dir, GNUNET_YES))
&&
+ (GNUNET_OK
+ !=
+ GNUNET_DISK_directory_create (service->dir)))
{
- GNUNET_free(service->dir);
+ GNUNET_free (service->dir);
service->dir = NULL;
}
@@ -88,6 +94,7 @@ create_service (const struct GNUNET_CONFIGURATION_Handle
*config,
return service;
}
+
static int
iterate_destroy_rooms (void *cls,
const struct GNUNET_HashCode *key,
@@ -98,10 +105,11 @@ iterate_destroy_rooms (void *cls,
return GNUNET_YES;
}
+
void
destroy_service (struct GNUNET_MESSENGER_Service *service)
{
- GNUNET_assert(service);
+ GNUNET_assert (service);
if (service->shutdown)
{
@@ -112,7 +120,8 @@ destroy_service (struct GNUNET_MESSENGER_Service *service)
clear_list_handles (&(service->handles));
- GNUNET_CONTAINER_multihashmap_iterate (service->rooms,
iterate_destroy_rooms, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (service->rooms, iterate_destroy_rooms,
+ NULL);
GNUNET_CONTAINER_multihashmap_destroy (service->rooms);
clear_contact_store (get_service_contact_store (service));
@@ -126,36 +135,38 @@ destroy_service (struct GNUNET_MESSENGER_Service *service)
if (service->dir)
{
- GNUNET_free(service->dir);
+ GNUNET_free (service->dir);
service->dir = NULL;
}
if (service->peer)
{
- GNUNET_free(service->peer);
+ GNUNET_free (service->peer);
service->peer = NULL;
}
GNUNET_SERVICE_shutdown (service->service);
- GNUNET_free(service);
+ GNUNET_free (service);
}
+
struct GNUNET_MESSENGER_ContactStore*
get_service_contact_store (struct GNUNET_MESSENGER_Service *service)
{
- GNUNET_assert(service);
+ GNUNET_assert (service);
return &(service->contact_store);
}
+
struct GNUNET_MESSENGER_SrvHandle*
add_service_handle (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MQ_Handle *mq)
{
- GNUNET_assert((service) && (mq));
+ GNUNET_assert ((service) && (mq));
struct GNUNET_MESSENGER_SrvHandle *handle = create_srv_handle (service, mq);
@@ -167,58 +178,62 @@ add_service_handle (struct GNUNET_MESSENGER_Service
*service,
return handle;
}
+
void
remove_service_handle (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MESSENGER_SrvHandle *handle)
{
- GNUNET_assert((service) && (handle));
+ GNUNET_assert ((service) && (handle));
- if (!handle)
+ if (! handle)
return;
if (GNUNET_YES == remove_list_handle (&(service->handles), handle))
destroy_srv_handle (handle);
}
+
int
get_service_peer_identity (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_PeerIdentity *peer)
{
- GNUNET_assert((service) && (peer));
+ GNUNET_assert ((service) && (peer));
if (service->peer)
{
- GNUNET_memcpy(peer, service->peer, sizeof(struct GNUNET_PeerIdentity));
+ GNUNET_memcpy (peer, service->peer, sizeof(struct GNUNET_PeerIdentity));
return GNUNET_OK;
}
- int result = GNUNET_CRYPTO_get_peer_identity(service->config, peer);
+ int result = GNUNET_CRYPTO_get_peer_identity (service->config, peer);
if (GNUNET_OK != result)
return result;
- if (!service->peer)
- service->peer = GNUNET_new(struct GNUNET_PeerIdentity);
+ if (! service->peer)
+ service->peer = GNUNET_new (struct GNUNET_PeerIdentity);
- GNUNET_memcpy(service->peer, peer, sizeof(struct GNUNET_PeerIdentity));
+ GNUNET_memcpy (service->peer, peer, sizeof(struct GNUNET_PeerIdentity));
return result;
}
+
struct GNUNET_MESSENGER_SrvRoom*
get_service_room (const struct GNUNET_MESSENGER_Service *service,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((service) && (key));
+ GNUNET_assert ((service) && (key));
return GNUNET_CONTAINER_multihashmap_get (service->rooms, key);
}
+
int
open_service_room (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((service) && (handle) && (key));
+ GNUNET_assert ((service) && (handle) && (key));
struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
@@ -237,13 +252,14 @@ open_service_room (struct GNUNET_MESSENGER_Service
*service,
return GNUNET_NO;
}
+
int
entry_service_room (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_PeerIdentity *door,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((service) && (handle) && (door) && (key));
+ GNUNET_assert ((service) && (handle) && (door) && (key));
struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
@@ -272,31 +288,38 @@ entry_service_room (struct GNUNET_MESSENGER_Service
*service,
}
+
int
close_service_room (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MESSENGER_SrvHandle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((service) && (handle) && (key));
+ GNUNET_assert ((service) && (handle) && (key));
struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (service, key);
- if (!room)
+ if (! room)
return GNUNET_NO;
- const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
key);
+ const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+ key);
- GNUNET_assert(id);
+ GNUNET_assert (id);
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (handle->member_ids,
key, id))
+ if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (handle->member_ids,
+ key, id))
return GNUNET_NO;
- struct GNUNET_MESSENGER_SrvHandle *member_handle = (struct
GNUNET_MESSENGER_SrvHandle*) find_list_handle_by_member (
- &(service->handles), key);
+ struct GNUNET_MESSENGER_SrvHandle *member_handle = (struct
+
GNUNET_MESSENGER_SrvHandle
+ *)
+
find_list_handle_by_member (
+ &(service->handles), key);
- if (!member_handle)
+ if (! member_handle)
{
- if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (service->rooms,
key, room))
+ if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (service->rooms, key,
+ room))
{
destroy_srv_room (room, GNUNET_YES);
return GNUNET_YES;
@@ -311,6 +334,7 @@ close_service_room (struct GNUNET_MESSENGER_Service
*service,
return GNUNET_YES;
}
+
void
handle_service_message (struct GNUNET_MESSENGER_Service *service,
struct GNUNET_MESSENGER_SrvRoom *room,
@@ -318,7 +342,7 @@ handle_service_message (struct GNUNET_MESSENGER_Service
*service,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((service) && (room) && (session) && (message) && (hash));
+ GNUNET_assert ((service) && (room) && (session) && (message) && (hash));
struct GNUNET_MESSENGER_ListHandle *element = service->handles.head;
diff --git a/src/messenger/gnunet-service-messenger_tunnel.c
b/src/messenger/gnunet-service-messenger_tunnel.c
index c82a42cd0..5262ba79b 100644
--- a/src/messenger/gnunet-service-messenger_tunnel.c
+++ b/src/messenger/gnunet-service-messenger_tunnel.c
@@ -37,9 +37,10 @@ struct GNUNET_MESSENGER_SrvTunnel*
create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room,
const struct GNUNET_PeerIdentity *door)
{
- GNUNET_assert((room) && (door));
+ GNUNET_assert ((room) && (door));
- struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_new(struct
GNUNET_MESSENGER_SrvTunnel);
+ struct GNUNET_MESSENGER_SrvTunnel *tunnel = GNUNET_new (struct
+
GNUNET_MESSENGER_SrvTunnel);
tunnel->room = room;
tunnel->channel = NULL;
@@ -50,15 +51,16 @@ create_tunnel (struct GNUNET_MESSENGER_SrvRoom *room,
tunnel->peer_message = NULL;
- init_message_state(&(tunnel->state));
+ init_message_state (&(tunnel->state));
return tunnel;
}
+
void
destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
if (tunnel->channel)
GNUNET_CADET_channel_destroy (tunnel->channel);
@@ -66,18 +68,19 @@ destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
GNUNET_PEER_change_rc (tunnel->peer, -1);
if (tunnel->peer_message)
- GNUNET_free(tunnel->peer_message);
+ GNUNET_free (tunnel->peer_message);
- clear_message_state(&(tunnel->state));
+ clear_message_state (&(tunnel->state));
- GNUNET_free(tunnel);
+ GNUNET_free (tunnel);
}
+
void
bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
struct GNUNET_CADET_Channel *channel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
if (tunnel->channel)
delayed_disconnect_channel (tunnel->channel);
@@ -85,6 +88,7 @@ bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
tunnel->channel = channel;
}
+
extern void
callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room,
void *cls);
@@ -103,6 +107,7 @@ callback_tunnel_disconnect (void *cls,
}
}
+
extern int
callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
void *cls,
@@ -115,7 +120,7 @@ check_tunnel_message (void *cls,
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
- if (!tunnel)
+ if (! tunnel)
return GNUNET_SYSERR;
const uint16_t length = ntohs (header->size) - sizeof(*header);
@@ -123,17 +128,20 @@ check_tunnel_message (void *cls,
struct GNUNET_MESSENGER_Message message;
- if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN,
GNUNET_YES))
+ if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ GNUNET_YES))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Message too short!
(%d)\n", length);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Tunnel error: Message too short! (%d)\n", length);
return GNUNET_SYSERR;
}
uint16_t padding = 0;
- if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
&padding))
+ if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
+ &padding))
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
return GNUNET_SYSERR;
}
@@ -143,6 +151,7 @@ check_tunnel_message (void *cls,
return callback_verify_room_message (tunnel->room, cls, &message, &hash);
}
+
extern int
update_room_message (struct GNUNET_MESSENGER_SrvRoom *room,
struct GNUNET_MESSENGER_Message *message,
@@ -157,26 +166,31 @@ static void
update_tunnel_last_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_OperationStore *operation_store =
get_srv_room_operation_store(tunnel->room);
+ struct GNUNET_MESSENGER_OperationStore *operation_store =
+ get_srv_room_operation_store (tunnel->room);
- const int requested = (GNUNET_MESSENGER_OP_REQUEST ==
get_store_operation_type(operation_store, hash)?
- GNUNET_YES : GNUNET_NO
- );
+ const int requested = (GNUNET_MESSENGER_OP_REQUEST ==
+ get_store_operation_type (operation_store, hash)?
+ GNUNET_YES : GNUNET_NO
+ );
- struct GNUNET_MESSENGER_MessageStore *message_store =
get_srv_room_message_store(tunnel->room);
+ struct GNUNET_MESSENGER_MessageStore *message_store =
+ get_srv_room_message_store (tunnel->room);
- const struct GNUNET_MESSENGER_Message *message =
get_store_message(message_store, hash);
+ const struct GNUNET_MESSENGER_Message *message = get_store_message (
+ message_store, hash);
if (message)
- update_message_state(&(tunnel->state), requested, message, hash);
+ update_message_state (&(tunnel->state), requested, message, hash);
}
+
void
handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
- if (!tunnel)
+ if (! tunnel)
return;
const uint16_t length = ntohs (header->size) - sizeof(*header);
@@ -190,12 +204,12 @@ handle_tunnel_message (void *cls, const struct
GNUNET_MessageHeader *header)
decode_message (&message, length, buffer, GNUNET_YES, &padding);
hash_message (&message, length - padding, buffer, &hash);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
- GNUNET_MESSENGER_name_of_kind(message.header.kind));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
+ GNUNET_MESSENGER_name_of_kind (message.header.kind));
const int new_message = update_room_message (
- tunnel->room, copy_message (&message), &hash
- );
+ tunnel->room, copy_message (&message), &hash
+ );
if (GNUNET_YES != new_message)
goto receive_done;
@@ -213,7 +227,8 @@ handle_tunnel_message (void *cls, const struct
GNUNET_MessageHeader *header)
forward_message = recv_message_peer (tunnel->room, tunnel, &message,
&hash);
break;
case GNUNET_MESSENGER_KIND_REQUEST:
- forward_message = recv_message_request (tunnel->room, tunnel, &message,
&hash);
+ forward_message = recv_message_request (tunnel->room, tunnel, &message,
+ &hash);
break;
default:
break;
@@ -226,15 +241,16 @@ handle_tunnel_message (void *cls, const struct
GNUNET_MessageHeader *header)
}
receive_done:
- cleanup_message(&message);
+ cleanup_message (&message);
GNUNET_CADET_receive_done (tunnel->channel);
}
+
int
connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
if (tunnel->channel)
return GNUNET_NO;
@@ -244,21 +260,28 @@ connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
struct GNUNET_CADET_Handle *cadet = get_srv_room_cadet (tunnel->room);
const struct GNUNET_HashCode *key = get_srv_room_key (tunnel->room);
- struct GNUNET_MQ_MessageHandler handlers[] = {
GNUNET_MQ_hd_var_size(tunnel_message, GNUNET_MESSAGE_TYPE_CADET_CLI,
- struct
GNUNET_MessageHeader, NULL),
- GNUNET_MQ_handler_end() };
+ struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size (
+ tunnel_message,
+
GNUNET_MESSAGE_TYPE_CADET_CLI,
+ struct
+ GNUNET_MessageHeader, NULL),
+ GNUNET_MQ_handler_end () };
struct GNUNET_HashCode port;
- convert_messenger_key_to_port(key, &port);
- tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port,
NULL, callback_tunnel_disconnect, handlers);
+ convert_messenger_key_to_port (key, &port);
+ tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port,
+ NULL,
+ callback_tunnel_disconnect,
+ handlers);
return GNUNET_YES;
}
+
void
disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
if (tunnel->channel)
{
@@ -268,14 +291,16 @@ disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel
*tunnel)
}
}
+
int
is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
}
+
struct GNUNET_MESSENGER_MessageSent
{
struct GNUNET_MESSENGER_SrvTunnel *tunnel;
@@ -290,21 +315,23 @@ callback_tunnel_sent (void *cls)
if (sent->tunnel)
update_tunnel_last_message (sent->tunnel, &(sent->hash));
- GNUNET_free(sent);
+ GNUNET_free (sent);
}
+
void
send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
struct GNUNET_MQ_Envelope *env,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((tunnel) && (env) && (hash));
+ GNUNET_assert ((tunnel) && (env) && (hash));
struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (tunnel->channel);
- struct GNUNET_MESSENGER_MessageSent *sent = GNUNET_new(struct
GNUNET_MESSENGER_MessageSent);
+ struct GNUNET_MESSENGER_MessageSent *sent = GNUNET_new (struct
+
GNUNET_MESSENGER_MessageSent);
- GNUNET_memcpy(&(sent->hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&(sent->hash), hash, sizeof(struct GNUNET_HashCode));
sent->tunnel = tunnel;
@@ -312,85 +339,93 @@ send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel
*tunnel,
GNUNET_MQ_send (mq, env);
}
+
int
send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
void *handle,
struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert((tunnel) && (handle));
+ GNUNET_assert ((tunnel) && (handle));
- if (!message)
+ if (! message)
return GNUNET_NO;
struct GNUNET_HashCode hash;
struct GNUNET_MQ_Envelope *env = pack_srv_room_message (
- tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
- message, &hash, GNUNET_MESSENGER_PACK_MODE_ENVELOPE
- );
+ tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
+ message, &hash, GNUNET_MESSENGER_PACK_MODE_ENVELOPE
+ );
- destroy_message(message);
+ destroy_message (message);
- if (!env)
+ if (! env)
return GNUNET_NO;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
- GNUNET_h2s(&hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
+ GNUNET_h2s (&hash));
send_tunnel_envelope (tunnel, env, &hash);
return GNUNET_YES;
}
+
void
forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((tunnel) && (message) && (hash));
+ GNUNET_assert ((tunnel) && (message) && (hash));
- struct GNUNET_MESSENGER_Message *copy = copy_message(message);
- struct GNUNET_MQ_Envelope *env = pack_message (copy, NULL, NULL,
GNUNET_MESSENGER_PACK_MODE_ENVELOPE, NULL);
+ struct GNUNET_MESSENGER_Message *copy = copy_message (message);
+ struct GNUNET_MQ_Envelope *env = pack_message (copy, NULL, NULL,
+
GNUNET_MESSENGER_PACK_MODE_ENVELOPE,
+ NULL);
- destroy_message(copy);
+ destroy_message (copy);
- if (!env)
+ if (! env)
return;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
- GNUNET_h2s(hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
+ GNUNET_h2s (hash));
send_tunnel_envelope (tunnel, env, hash);
}
+
const struct GNUNET_HashCode*
get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
return tunnel->peer_message;
}
+
void
get_tunnel_peer_identity (const struct GNUNET_MESSENGER_SrvTunnel *tunnel,
struct GNUNET_PeerIdentity *peer)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
- GNUNET_PEER_resolve(tunnel->peer, peer);
+ GNUNET_PEER_resolve (tunnel->peer, peer);
}
+
uint32_t
get_tunnel_messenger_version (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
return tunnel->messenger_version;
}
+
int
update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel,
uint32_t version)
{
- GNUNET_assert(tunnel);
+ GNUNET_assert (tunnel);
if (version != GNUNET_MESSENGER_VERSION)
return GNUNET_SYSERR;
diff --git a/src/messenger/messenger_api.c b/src/messenger/messenger_api.c
index 82fc0d1eb..fe99e0e8d 100644
--- a/src/messenger/messenger_api.c
+++ b/src/messenger/messenger_api.c
@@ -75,6 +75,7 @@ GNUNET_MESSENGER_name_of_kind (enum
GNUNET_MESSENGER_MessageKind kind)
}
}
+
static enum GNUNET_GenericReturnValue
dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room);
@@ -86,7 +87,7 @@ handle_room_open (void *cls,
const struct GNUNET_HashCode *key = &(msg->key);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
open_handle_room (handle, key);
@@ -96,6 +97,7 @@ handle_room_open (void *cls,
dequeue_messages_from_room (room);
}
+
static void
handle_room_entry (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -115,6 +117,7 @@ handle_room_entry (void *cls,
dequeue_messages_from_room (room);
}
+
static void
handle_room_close (void *cls,
const struct GNUNET_MESSENGER_RoomMessage *msg)
@@ -133,6 +136,7 @@ handle_room_close (void *cls,
close_handle_room (handle, key);
}
+
static void
enqueue_message_to_room (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Message *message);
@@ -147,13 +151,15 @@ handle_member_id (void *cls,
const struct GNUNET_ShortHashCode *id = &(msg->id);
const uint32_t reset = msg->reset;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Changed member id in room: %s\n",
GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Changed member id in room: %s\n",
+ GNUNET_h2s (key));
struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
- if (!room)
+ if (! room)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Room is unknown to handle: %s\n",
GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Room is unknown to handle: %s\n",
+ GNUNET_h2s (key));
return;
}
@@ -161,7 +167,7 @@ handle_member_id (void *cls,
switch (reset)
{
case GNUNET_YES:
- set_room_sender_id(room, id);
+ set_room_sender_id (room, id);
message = create_message_join (get_handle_key (handle));
break;
case GNUNET_NO:
@@ -171,13 +177,14 @@ handle_member_id (void *cls,
break;
}
- if (!message)
+ if (! message)
return;
enqueue_message_to_room (room, message);
destroy_message (message);
}
+
static int
check_recv_message (void *cls,
const struct GNUNET_MESSENGER_RecvMessage *msg)
@@ -186,7 +193,8 @@ check_recv_message (void *cls,
if (full_length < sizeof(*msg))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Receiving failed: Message
invalid!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Receiving failed: Message invalid!\n");
return GNUNET_NO;
}
@@ -195,22 +203,26 @@ check_recv_message (void *cls,
struct GNUNET_MESSENGER_Message message;
- if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN,
GNUNET_YES))
+ if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ GNUNET_YES))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Receiving failed: Message too
short!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Receiving failed: Message too short!\n");
return GNUNET_NO;
}
if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
NULL))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Receiving failed: Message decoding
failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Receiving failed: Message decoding failed!\n");
return GNUNET_NO;
}
- cleanup_message(&message);
+ cleanup_message (&message);
return GNUNET_OK;
}
+
static void
handle_recv_message (void *cls,
const struct GNUNET_MESSENGER_RecvMessage *msg)
@@ -223,8 +235,8 @@ handle_recv_message (void *cls,
const struct GNUNET_HashCode *hash = &(msg->hash);
enum GNUNET_MESSENGER_MessageFlags flags = (
- (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
- );
+ (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
+ );
const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
const char *buffer = ((const char*) msg) + sizeof(*msg);
@@ -235,11 +247,12 @@ handle_recv_message (void *cls,
struct GNUNET_MESSENGER_Message *private_message = NULL;
if (GNUNET_MESSENGER_KIND_PRIVATE == message.header.kind)
{
- private_message = copy_message(&message);
+ private_message = copy_message (&message);
- if (GNUNET_YES != decrypt_message(private_message, get_handle_key(handle)))
+ if (GNUNET_YES != decrypt_message (private_message, get_handle_key (
+ handle)))
{
- destroy_message(private_message);
+ destroy_message (private_message);
private_message = NULL;
}
}
@@ -248,37 +261,46 @@ handle_recv_message (void *cls,
flags |= GNUNET_MESSENGER_FLAG_PRIVATE;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n",
- GNUNET_MESSENGER_name_of_kind (private_message ?
private_message->header.kind : message.header.kind));
+ GNUNET_MESSENGER_name_of_kind (private_message ?
+ private_message->header.kind :
+ message.header.kind));
- struct GNUNET_MESSENGER_Room *room = get_handle_room(handle, key);
+ struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
if (room)
{
- struct GNUNET_MESSENGER_ContactStore *store =
get_handle_contact_store(handle);
+ struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+ handle);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Raw contact from sender and context:
(%s : %s)\n",
- GNUNET_h2s(sender), GNUNET_h2s_full(context));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Raw contact from sender and context: (%s : %s)\n",
+ GNUNET_h2s (sender), GNUNET_h2s_full (context));
- struct GNUNET_MESSENGER_Contact *contact = get_store_contact_raw(
- store, context, sender
- );
+ struct GNUNET_MESSENGER_Contact *contact = get_store_contact_raw (
+ store, context, sender
+ );
- contact = handle_room_message (room, contact, private_message ?
private_message : &message, hash, flags);
+ contact = handle_room_message (room, contact, private_message ?
+ private_message : &message, hash, flags);
- const struct GNUNET_MESSENGER_Message *stored_message =
get_room_message(room, hash);
+ const struct GNUNET_MESSENGER_Message *stored_message = get_room_message (
+ room, hash);
if (handle->msg_callback)
- handle->msg_callback (handle->msg_cls, room, contact, stored_message,
hash, flags);
+ handle->msg_callback (handle->msg_cls, room, contact, stored_message,
+ hash, flags);
}
else
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n",
GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n",
+ GNUNET_h2s (key));
- cleanup_message(&message);
+ cleanup_message (&message);
if (private_message)
- destroy_message(private_message);
+ destroy_message (private_message);
}
+
static void
handle_miss_message (void *cls,
const struct GNUNET_MESSENGER_GetMessage *msg)
@@ -288,27 +310,30 @@ handle_miss_message (void *cls,
const struct GNUNET_HashCode *key = &(msg->key);
const struct GNUNET_HashCode *hash = &(msg->hash);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Missing message in room: %s\n",
GNUNET_h2s (hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Missing message in room: %s\n",
+ GNUNET_h2s (hash));
- struct GNUNET_MESSENGER_Room *room = get_handle_room(handle, key);
+ struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
- if (!room)
+ if (! room)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Miss in unknown room for this
client: %s\n", GNUNET_h2s (key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Miss in unknown room for this client: %s\n", GNUNET_h2s
(key));
return;
}
- if (!get_room_sender_id(room))
+ if (! get_room_sender_id (room))
return;
struct GNUNET_MESSENGER_Message *message = create_message_request (hash);
- if (!message)
+ if (! message)
return;
enqueue_message_to_room (room, message);
destroy_message (message);
}
+
static void
reconnect (struct GNUNET_MESSENGER_Handle *handle);
@@ -316,34 +341,37 @@ static void
send_open_room (struct GNUNET_MESSENGER_Handle *handle,
struct GNUNET_MESSENGER_Room *room)
{
- const struct GNUNET_IDENTITY_PublicKey *key = get_handle_pubkey(handle);
+ const struct GNUNET_IDENTITY_PublicKey *key = get_handle_pubkey (handle);
struct GNUNET_MESSENGER_RoomMessage *msg;
struct GNUNET_MQ_Envelope *env;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Open room (%s) by member using key:
%s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Open room (%s) by member using key: %s\n",
GNUNET_h2s (&(room->key)),
GNUNET_IDENTITY_public_key_to_string (key));
- const ssize_t len = GNUNET_IDENTITY_public_key_get_length(key);
+ const ssize_t len = GNUNET_IDENTITY_public_key_get_length (key);
- env = GNUNET_MQ_msg_extra(msg, len > 0 ? len : 0,
GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
- GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
+ env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
+ GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
char *msg_buffer = ((char*) msg) + sizeof(*msg);
if (len > 0)
- GNUNET_IDENTITY_write_public_key_to_buffer(key, msg_buffer, len);
+ GNUNET_IDENTITY_write_public_key_to_buffer (key, msg_buffer, len);
GNUNET_MQ_send (handle->mq, env);
}
+
static void
send_enter_room (struct GNUNET_MESSENGER_Handle *handle,
struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_PeerIdentity *door)
{
- const struct GNUNET_IDENTITY_PublicKey *key = get_handle_pubkey(handle);
+ const struct GNUNET_IDENTITY_PublicKey *key = get_handle_pubkey (handle);
struct GNUNET_MESSENGER_RoomMessage *msg;
struct GNUNET_MQ_Envelope *env;
@@ -353,20 +381,22 @@ send_enter_room (struct GNUNET_MESSENGER_Handle *handle,
GNUNET_i2s (door),
GNUNET_IDENTITY_public_key_to_string (key));
- const ssize_t len = GNUNET_IDENTITY_public_key_get_length(key);
+ const ssize_t len = GNUNET_IDENTITY_public_key_get_length (key);
- env = GNUNET_MQ_msg_extra(msg, len > 0 ? len : 0,
GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
- GNUNET_memcpy(&(msg->door), door, sizeof(*door));
- GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
+ env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
+ GNUNET_memcpy (&(msg->door), door, sizeof(*door));
+ GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
char *msg_buffer = ((char*) msg) + sizeof(*msg);
if (len > 0)
- GNUNET_IDENTITY_write_public_key_to_buffer(key, msg_buffer, len);
+ GNUNET_IDENTITY_write_public_key_to_buffer (key, msg_buffer, len);
GNUNET_MQ_send (handle->mq, env);
}
+
static void
send_close_room (struct GNUNET_MESSENGER_Handle *handle,
struct GNUNET_MESSENGER_Room *room)
@@ -377,11 +407,12 @@ send_close_room (struct GNUNET_MESSENGER_Handle *handle,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Close room (%s)!\n",
GNUNET_h2s (&(room->key)));
- env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
- GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
+ GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
GNUNET_MQ_send (handle->mq, env);
}
+
static int
iterate_reset_room (void *cls,
const struct GNUNET_HashCode *key,
@@ -409,21 +440,24 @@ iterate_reset_room (void *cls,
return GNUNET_YES;
}
+
static void
callback_reconnect (void *cls)
{
struct GNUNET_MESSENGER_Handle *handle = cls;
handle->reconnect_task = NULL;
- handle->reconnect_time = GNUNET_TIME_STD_BACKOFF(handle->reconnect_time);
+ handle->reconnect_time = GNUNET_TIME_STD_BACKOFF (handle->reconnect_time);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnect messenger!\n");
reconnect (handle);
- GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_reset_room,
handle);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_reset_room,
+ handle);
}
+
static int
iterate_close_room (void *cls,
const struct GNUNET_HashCode *key,
@@ -437,15 +471,17 @@ iterate_close_room (void *cls,
return GNUNET_YES;
}
+
static void
callback_mq_error (void *cls,
enum GNUNET_MQ_Error error)
{
struct GNUNET_MESSENGER_Handle *handle = cls;
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
- GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_close_room,
handle);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_close_room,
+ handle);
if (handle->mq)
{
@@ -453,50 +489,55 @@ callback_mq_error (void *cls,
handle->mq = NULL;
}
- handle->reconnect_task = GNUNET_SCHEDULER_add_delayed
(handle->reconnect_time, &callback_reconnect, handle);
+ handle->reconnect_task = GNUNET_SCHEDULER_add_delayed
(handle->reconnect_time,
+ &callback_reconnect,
+ handle);
}
+
static void
reconnect (struct GNUNET_MESSENGER_Handle *handle)
{
- const struct GNUNET_MQ_MessageHandler handlers[] =
- {
- GNUNET_MQ_hd_fixed_size(
- member_id,
- GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
- struct GNUNET_MESSENGER_MemberMessage, handle
- ),
- GNUNET_MQ_hd_fixed_size(
- room_open,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
- struct GNUNET_MESSENGER_RoomMessage, handle
- ),
- GNUNET_MQ_hd_fixed_size(
- room_entry,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
- struct GNUNET_MESSENGER_RoomMessage, handle
- ),
- GNUNET_MQ_hd_fixed_size(
- room_close,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
- struct GNUNET_MESSENGER_RoomMessage, handle
- ),
- GNUNET_MQ_hd_var_size(
- recv_message,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
- struct GNUNET_MESSENGER_RecvMessage, handle
- ),
- GNUNET_MQ_hd_fixed_size(
- miss_message,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE,
- struct GNUNET_MESSENGER_GetMessage, handle
- ),
- GNUNET_MQ_handler_end()
+ const struct GNUNET_MQ_MessageHandler handlers[] = {
+ GNUNET_MQ_hd_fixed_size (
+ member_id,
+ GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
+ struct GNUNET_MESSENGER_MemberMessage, handle
+ ),
+ GNUNET_MQ_hd_fixed_size (
+ room_open,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
+ struct GNUNET_MESSENGER_RoomMessage, handle
+ ),
+ GNUNET_MQ_hd_fixed_size (
+ room_entry,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
+ struct GNUNET_MESSENGER_RoomMessage, handle
+ ),
+ GNUNET_MQ_hd_fixed_size (
+ room_close,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
+ struct GNUNET_MESSENGER_RoomMessage, handle
+ ),
+ GNUNET_MQ_hd_var_size (
+ recv_message,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
+ struct GNUNET_MESSENGER_RecvMessage, handle
+ ),
+ GNUNET_MQ_hd_fixed_size (
+ miss_message,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE,
+ struct GNUNET_MESSENGER_GetMessage, handle
+ ),
+ GNUNET_MQ_handler_end ()
};
- handle->mq = GNUNET_CLIENT_connect (handle->cfg,
GNUNET_MESSENGER_SERVICE_NAME, handlers, &callback_mq_error, handle);
+ handle->mq = GNUNET_CLIENT_connect (handle->cfg,
+ GNUNET_MESSENGER_SERVICE_NAME, handlers,
+ &callback_mq_error, handle);
}
+
struct GNUNET_MESSENGER_Handle*
GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *name,
@@ -504,7 +545,8 @@ GNUNET_MESSENGER_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_MESSENGER_MessageCallback msg_callback,
void *msg_cls)
{
- struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, msg_callback,
msg_cls);
+ struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, msg_callback,
+ msg_cls);
reconnect (handle);
@@ -512,13 +554,13 @@ GNUNET_MESSENGER_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
{
set_handle_name (handle, name);
- if ((!key) || (0 < GNUNET_IDENTITY_private_key_get_length (key)))
+ if ((! key) || (0 < GNUNET_IDENTITY_private_key_get_length (key)))
set_handle_key (handle, key);
struct GNUNET_MESSENGER_CreateMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
GNUNET_MQ_send (handle->mq, env);
return handle;
}
@@ -529,21 +571,23 @@ GNUNET_MESSENGER_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
}
}
+
void
GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
{
- if (!handle)
+ if (! handle)
return;
struct GNUNET_MESSENGER_DestroyMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY);
GNUNET_MQ_send (handle->mq, env);
destroy_handle (handle);
}
+
static void
send_message_to_room (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Message *message,
@@ -551,10 +595,13 @@ send_message_to_room (struct GNUNET_MESSENGER_Room *room,
{
const struct GNUNET_ShortHashCode *sender_id = get_room_sender_id (room);
- message->header.timestamp = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_get ());
+ message->header.timestamp = GNUNET_TIME_absolute_hton (
+ GNUNET_TIME_absolute_get ());
- GNUNET_memcpy (&(message->header.sender_id), sender_id,
sizeof(message->header.sender_id));
- GNUNET_memcpy (&(message->header.previous), &(room->last_message),
sizeof(message->header.previous));
+ GNUNET_memcpy (&(message->header.sender_id), sender_id,
+ sizeof(message->header.sender_id));
+ GNUNET_memcpy (&(message->header.previous), &(room->last_message),
+ sizeof(message->header.previous));
message->header.signature.type = key->type;
@@ -563,12 +610,12 @@ send_message_to_room (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_SendMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg_extra(
- msg, msg_length,
- GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
- );
+ env = GNUNET_MQ_msg_extra (
+ msg, msg_length,
+ GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
+ );
- GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
+ GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
char *msg_buffer = ((char*) msg) + sizeof(*msg);
encode_message (message, msg_length, msg_buffer, GNUNET_YES);
@@ -582,6 +629,7 @@ send_message_to_room (struct GNUNET_MESSENGER_Room *room,
GNUNET_MQ_send (room->handle->mq, env);
}
+
static void
enqueue_message_to_room (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Message *message)
@@ -594,9 +642,10 @@ enqueue_message_to_room (struct GNUNET_MESSENGER_Room
*room,
send_message_to_room (room, message, key);
}
else
- enqueue_to_messages(&(room->queue), key, message);
+ enqueue_to_messages (&(room->queue), key, message);
}
+
static enum GNUNET_GenericReturnValue
dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room)
{
@@ -608,28 +657,30 @@ dequeue_messages_from_room (struct GNUNET_MESSENGER_Room
*room)
do {
if (message)
- destroy_message(message);
+ destroy_message (message);
- message = dequeue_from_messages(&(room->queue), &key);
+ message = dequeue_from_messages (&(room->queue), &key);
if (message)
- send_message_to_room(room, message, &key);
+ send_message_to_room (room, message, &key);
} while (message);
return GNUNET_YES;
}
+
const char*
GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
{
- if (!handle)
+ if (! handle)
return NULL;
return get_handle_name (handle);
}
+
static int
-iterate_send_name_to_room (void* cls,
+iterate_send_name_to_room (void *cls,
struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_MESSENGER_Contact *contact)
{
@@ -638,14 +689,14 @@ iterate_send_name_to_room (void* cls,
if (GNUNET_YES != room->use_handle_name)
return GNUNET_YES;
- const char *name = get_handle_name(handle);
+ const char *name = get_handle_name (handle);
- if (!name)
+ if (! name)
return GNUNET_YES;
struct GNUNET_MESSENGER_Message *message = create_message_name (name);
- if (!message)
+ if (! message)
return GNUNET_NO;
enqueue_message_to_room (room, message);
@@ -653,11 +704,12 @@ iterate_send_name_to_room (void* cls,
return GNUNET_YES;
}
+
int
GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle,
const char *name)
{
- if (!handle)
+ if (! handle)
return GNUNET_SYSERR;
set_handle_name (handle, strlen (name) > 0 ? name : NULL);
@@ -665,26 +717,29 @@ GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle
*handle,
return GNUNET_YES;
}
+
static const struct GNUNET_IDENTITY_PublicKey*
-get_non_anonymous_key (const struct GNUNET_IDENTITY_PublicKey* public_key)
+get_non_anonymous_key (const struct GNUNET_IDENTITY_PublicKey *public_key)
{
- if (0 == GNUNET_memcmp(public_key, get_anonymous_public_key ()))
+ if (0 == GNUNET_memcmp (public_key, get_anonymous_public_key ()))
return NULL;
return public_key;
}
+
const struct GNUNET_IDENTITY_PublicKey*
GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
{
- if (!handle)
+ if (! handle)
return NULL;
return get_non_anonymous_key (get_handle_pubkey (handle));
}
+
static int
-iterate_send_key_to_room (void* cls,
+iterate_send_key_to_room (void *cls,
struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_MESSENGER_Contact *contact)
{
@@ -692,7 +747,7 @@ iterate_send_key_to_room (void* cls,
struct GNUNET_MESSENGER_Message *message = create_message_key (key);
- if (!message)
+ if (! message)
return GNUNET_NO;
enqueue_message_to_room (room, message);
@@ -700,14 +755,15 @@ iterate_send_key_to_room (void* cls,
return GNUNET_YES;
}
+
int
GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_IDENTITY_PrivateKey *key)
{
- if (!handle)
+ if (! handle)
return GNUNET_SYSERR;
-
- if (!key)
+
+ if (! key)
{
GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, NULL);
set_handle_key (handle, NULL);
@@ -725,20 +781,23 @@ GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle
*handle,
return GNUNET_YES;
}
+
struct GNUNET_MESSENGER_Room*
GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- if ((!handle) || (!key))
+ if ((! handle) || (! key))
return NULL;
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
- if (!room)
+ if (! room)
{
room = create_room (handle, key);
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
room,
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
+ room,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
destroy_room (room);
@@ -750,21 +809,24 @@ GNUNET_MESSENGER_open_room (struct
GNUNET_MESSENGER_Handle *handle,
return room;
}
+
struct GNUNET_MESSENGER_Room*
GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_PeerIdentity *door,
const struct GNUNET_HashCode *key)
{
- if ((!handle) || (!door) || (!key))
+ if ((! handle) || (! door) || (! key))
return NULL;
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
- if (!room)
+ if (! room)
{
room = create_room (handle, key);
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
room,
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
+ room,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
destroy_room (room);
@@ -776,13 +838,14 @@ GNUNET_MESSENGER_enter_room (struct
GNUNET_MESSENGER_Handle *handle,
return room;
}
+
void
GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
{
- if (!room)
+ if (! room)
return;
- struct GNUNET_MESSENGER_Message *message = create_message_leave();
+ struct GNUNET_MESSENGER_Message *message = create_message_leave ();
if (message)
{
@@ -793,6 +856,7 @@ GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room
*room)
send_close_room (room->handle, room);
}
+
struct GNUNET_MESSENGER_RoomFind
{
const struct GNUNET_MESSENGER_Contact *contact;
@@ -802,33 +866,37 @@ struct GNUNET_MESSENGER_RoomFind
};
static int
-iterate_find_room (void* cls,
+iterate_find_room (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct GNUNET_MESSENGER_RoomFind *find = cls;
struct GNUNET_MESSENGER_Room *room = value;
- if ((find->counter > 0) && ((!find->contact) || (GNUNET_YES ==
find_room_member(room, find->contact))))
+ if ((find->counter > 0) && ((! find->contact) || (GNUNET_YES ==
+ find_room_member (room,
+ find->
+
contact))))
{
find->counter--;
- if (!find->callback)
+ if (! find->callback)
return GNUNET_YES;
- return find->callback(find->cls, room, find->contact);
+ return find->callback (find->cls, room, find->contact);
}
else
return GNUNET_NO;
}
+
int
GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_MESSENGER_Contact *contact,
GNUNET_MESSENGER_MemberCallback callback,
void *cls)
{
- if (!handle)
+ if (! handle)
return GNUNET_SYSERR;
struct GNUNET_MESSENGER_RoomFind find;
@@ -838,79 +906,91 @@ GNUNET_MESSENGER_find_rooms (const struct
GNUNET_MESSENGER_Handle *handle,
find.counter = (contact? contact->rc : SIZE_MAX);
find.cls = cls;
- return GNUNET_CONTAINER_multihashmap_iterate(handle->rooms,
iterate_find_room, &find);
+ return GNUNET_CONTAINER_multihashmap_iterate (handle->rooms,
+ iterate_find_room, &find);
}
+
const struct GNUNET_HashCode*
GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
{
- if (!room)
+ if (! room)
return NULL;
return &(room->key);
}
+
const struct GNUNET_MESSENGER_Contact*
GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_HashCode *hash)
{
- if ((!room) || (!hash))
+ if ((! room) || (! hash))
return NULL;
- return get_room_sender(room, hash);
+ return get_room_sender (room, hash);
}
+
const char*
-GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact
*contact)
+GNUNET_MESSENGER_contact_get_name (const struct
+ GNUNET_MESSENGER_Contact *contact)
{
- if (!contact)
+ if (! contact)
return NULL;
return get_contact_name (contact);
}
+
const struct GNUNET_IDENTITY_PublicKey*
-GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact
*contact)
+GNUNET_MESSENGER_contact_get_key (const struct
+ GNUNET_MESSENGER_Contact *contact)
{
- if (!contact)
+ if (! contact)
return NULL;
return get_non_anonymous_key (get_contact_key (contact));
}
+
void
GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_MESSENGER_Contact *contact)
{
- if ((!room) || (!message))
+ if ((! room) || (! message))
return;
switch (filter_message_sending (message))
{
case GNUNET_SYSERR:
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message aborted: This kind of
message is reserved for the service!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Sending message aborted: This kind of message is reserved for
the service!\n");
return;
case GNUNET_NO:
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: This kind
of message could cause issues!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Sending message aborted: This kind of message could cause
issues!\n");
return;
default:
break;
}
- char* original_name;
- char* changed_name = NULL;
+ char *original_name;
+ char *changed_name = NULL;
if (GNUNET_MESSENGER_KIND_NAME != message->header.kind)
goto skip_naming;
original_name = message->body.name.name;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Apply rule for using handle name in
room: %s\n", GNUNET_h2s (&(room->key)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Apply rule for using handle name in room: %s\n", GNUNET_h2s (
+ &(room->key)));
- const char* handle_name = get_handle_name (room->handle);
+ const char *handle_name = get_handle_name (room->handle);
if ((handle_name) && (GNUNET_YES == room->use_handle_name) &&
- ((!original_name) || (0 == strlen (original_name))))
+ ((! original_name) || (0 == strlen (original_name))))
{
changed_name = GNUNET_strdup (handle_name);
message->body.name.name = changed_name;
@@ -920,23 +1000,25 @@ skip_naming:
if (contact)
{
const struct GNUNET_IDENTITY_PublicKey *public_key = get_non_anonymous_key
(
- get_contact_key (contact)
- );
+ get_contact_key (contact)
+ );
- if (!public_key)
+ if (! public_key)
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: Invalid
key!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Sending message aborted: Invalid key!\n");
goto reset_naming;
}
struct GNUNET_MESSENGER_Message *original = message;
- message = copy_message(original);
+ message = copy_message (original);
if (GNUNET_YES != encrypt_message (message, public_key))
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message aborted: Encryption
failed!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Sending message aborted: Encryption failed!\n");
- destroy_message(message);
+ destroy_message (message);
message = original;
goto reset_naming;
@@ -955,36 +1037,39 @@ reset_naming:
message->body.name.name = original_name;
}
+
const struct GNUNET_MESSENGER_Message*
GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_HashCode *hash)
{
- if ((!room) || (!hash))
+ if ((! room) || (! hash))
return NULL;
- const struct GNUNET_MESSENGER_Message *message = get_room_message (room,
hash);
+ const struct GNUNET_MESSENGER_Message *message = get_room_message (room,
+ hash);
- if (!message)
+ if (! message)
{
struct GNUNET_MESSENGER_GetMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
- GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
- GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
+ GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
+ GNUNET_memcpy (&(msg->hash), hash, sizeof(*hash));
GNUNET_MQ_send (room->handle->mq, env);
}
return message;
}
+
int
GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room,
GNUNET_MESSENGER_MemberCallback callback,
void *cls)
{
- if (!room)
+ if (! room)
return GNUNET_SYSERR;
- return iterate_room_members(room, callback, cls);
+ return iterate_room_members (room, callback, cls);
}
diff --git a/src/messenger/messenger_api_contact.c
b/src/messenger/messenger_api_contact.c
index a284c3b08..6f5dc7ead 100644
--- a/src/messenger/messenger_api_contact.c
+++ b/src/messenger/messenger_api_contact.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -29,69 +29,76 @@
struct GNUNET_MESSENGER_Contact*
create_contact (const struct GNUNET_IDENTITY_PublicKey *key)
{
- GNUNET_assert(key);
+ GNUNET_assert (key);
- struct GNUNET_MESSENGER_Contact *contact = GNUNET_new(struct
GNUNET_MESSENGER_Contact);
+ struct GNUNET_MESSENGER_Contact *contact = GNUNET_new (struct
+
GNUNET_MESSENGER_Contact);
contact->name = NULL;
contact->rc = 0;
- GNUNET_memcpy(&(contact->public_key), key, sizeof(contact->public_key));
+ GNUNET_memcpy (&(contact->public_key), key, sizeof(contact->public_key));
return contact;
}
+
void
destroy_contact (struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
if (contact->name)
- GNUNET_free(contact->name);
+ GNUNET_free (contact->name);
- GNUNET_free(contact);
+ GNUNET_free (contact);
}
+
const char*
get_contact_name (const struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
return contact->name;
}
+
void
set_contact_name (struct GNUNET_MESSENGER_Contact *contact,
const char *name)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
if (contact->name)
- GNUNET_free(contact->name);
+ GNUNET_free (contact->name);
- contact->name = name ? GNUNET_strdup(name) : NULL;
+ contact->name = name ? GNUNET_strdup (name) : NULL;
}
+
const struct GNUNET_IDENTITY_PublicKey*
get_contact_key (const struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
return &(contact->public_key);
}
+
void
increase_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
contact->rc++;
}
+
int
decrease_contact_rc (struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(contact);
+ GNUNET_assert (contact);
if (contact->rc > 0)
contact->rc--;
@@ -99,12 +106,13 @@ decrease_contact_rc (struct GNUNET_MESSENGER_Contact
*contact)
return contact->rc ? GNUNET_NO : GNUNET_YES;
}
+
void
get_context_from_member (const struct GNUNET_HashCode *key,
const struct GNUNET_ShortHashCode *id,
struct GNUNET_HashCode *context)
{
- GNUNET_assert((key) && (id) && (context));
+ GNUNET_assert ((key) && (id) && (context));
GNUNET_CRYPTO_hash (id, sizeof(*id), context);
GNUNET_CRYPTO_hash_xor (key, context, context);
diff --git a/src/messenger/messenger_api_contact_store.c
b/src/messenger/messenger_api_contact_store.c
index d42155e20..520e6cdd1 100644
--- a/src/messenger/messenger_api_contact_store.c
+++ b/src/messenger/messenger_api_contact_store.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -38,6 +38,7 @@ init_contact_store (struct GNUNET_MESSENGER_ContactStore
*store)
store->contacts = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
}
+
static int
iterate_destroy_contacts (void *cls,
const struct GNUNET_HashCode *key,
@@ -48,37 +49,43 @@ iterate_destroy_contacts (void *cls,
return GNUNET_YES;
}
+
void
clear_contact_store (struct GNUNET_MESSENGER_ContactStore *store)
{
GNUNET_assert ((store) && (store->contacts));
- GNUNET_CONTAINER_multihashmap_iterate (store->anonymous,
iterate_destroy_contacts, NULL);
- GNUNET_CONTAINER_multihashmap_iterate (store->contacts,
iterate_destroy_contacts, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->anonymous,
+ iterate_destroy_contacts, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (store->contacts,
+ iterate_destroy_contacts, NULL);
GNUNET_CONTAINER_multihashmap_destroy (store->anonymous);
GNUNET_CONTAINER_multihashmap_destroy (store->contacts);
}
+
static struct GNUNET_CONTAINER_MultiHashMap*
select_store_contact_map (struct GNUNET_MESSENGER_ContactStore *store,
const struct GNUNET_HashCode *context,
struct GNUNET_HashCode *hash)
{
- const struct GNUNET_IDENTITY_PublicKey *anonymous = get_anonymous_public_key
();
+ const struct GNUNET_IDENTITY_PublicKey *anonymous =
+ get_anonymous_public_key ();
struct GNUNET_HashCode anonHash;
GNUNET_CRYPTO_hash (anonymous, sizeof(*anonymous), &anonHash);
- if ((context) && (0 == GNUNET_CRYPTO_hash_cmp(hash, &anonHash)))
+ if ((context) && (0 == GNUNET_CRYPTO_hash_cmp (hash, &anonHash)))
{
- GNUNET_memcpy(hash, context, sizeof(*context));
+ GNUNET_memcpy (hash, context, sizeof(*context));
return store->anonymous;
}
else
return store->contacts;
}
+
struct GNUNET_MESSENGER_Contact*
get_store_contact_raw (struct GNUNET_MESSENGER_ContactStore *store,
const struct GNUNET_HashCode *context,
@@ -87,15 +94,16 @@ get_store_contact_raw (struct GNUNET_MESSENGER_ContactStore
*store,
GNUNET_assert ((store) && (store->contacts) && (context) && (key_hash));
struct GNUNET_HashCode hash;
- GNUNET_memcpy(&hash, key_hash, sizeof(*key_hash));
+ GNUNET_memcpy (&hash, key_hash, sizeof(*key_hash));
struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
- store, context, &hash
- );
+ store, context, &hash
+ );
return GNUNET_CONTAINER_multihashmap_get (map, &hash);
}
+
struct GNUNET_MESSENGER_Contact*
get_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
const struct GNUNET_HashCode *context,
@@ -107,17 +115,20 @@ get_store_contact (struct GNUNET_MESSENGER_ContactStore
*store,
GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
- store, context, &hash
- );
+ store, context, &hash
+ );
- struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multihashmap_get
(map, &hash);
+ struct GNUNET_MESSENGER_Contact *contact = GNUNET_CONTAINER_multihashmap_get
(
+ map, &hash);
if (contact)
{
- if (0 != GNUNET_memcmp(pubkey, get_contact_key(contact)))
+ if (0 != GNUNET_memcmp (pubkey, get_contact_key (contact)))
{
- char* str = GNUNET_IDENTITY_public_key_to_string
(get_contact_key(contact));
- GNUNET_log (GNUNET_ERROR_TYPE_INVALID, "Contact in store uses wrong key:
%s\n", str);
+ char *str = GNUNET_IDENTITY_public_key_to_string (get_contact_key (
+ contact));
+ GNUNET_log (GNUNET_ERROR_TYPE_INVALID,
+ "Contact in store uses wrong key: %s\n", str);
GNUNET_free (str);
return NULL;
}
@@ -135,60 +146,62 @@ get_store_contact (struct GNUNET_MESSENGER_ContactStore
*store,
return NULL;
}
+
void
update_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
- struct GNUNET_MESSENGER_Contact* contact,
+ struct GNUNET_MESSENGER_Contact *contact,
const struct GNUNET_HashCode *context,
const struct GNUNET_HashCode *next_context,
const struct GNUNET_IDENTITY_PublicKey *pubkey)
{
GNUNET_assert ((store) && (store->contacts) && (contact) && (pubkey));
- const struct GNUNET_IDENTITY_PublicKey* oldkey = get_contact_key (contact);
+ const struct GNUNET_IDENTITY_PublicKey *oldkey = get_contact_key (contact);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (oldkey, sizeof(*oldkey), &hash);
struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
- store, context, &hash
- );
+ store, context, &hash
+ );
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (map, &hash, contact))
{
- GNUNET_memcpy(&(contact->public_key), pubkey, sizeof(*pubkey));
+ GNUNET_memcpy (&(contact->public_key), pubkey, sizeof(*pubkey));
GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
map = select_store_contact_map (
- store, next_context, &hash
- );
+ store, next_context, &hash
+ );
if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (map, &hash, contact,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating a contact failed: %s\n",
- GNUNET_h2s(&hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Updating a contact failed: %s\n",
+ GNUNET_h2s (&hash));
}
}
+
void
remove_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
- struct GNUNET_MESSENGER_Contact* contact,
+ struct GNUNET_MESSENGER_Contact *contact,
const struct GNUNET_HashCode *context)
{
GNUNET_assert ((store) && (store->contacts) && (contact));
- const struct GNUNET_IDENTITY_PublicKey* pubkey = get_contact_key(contact);
+ const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key (contact);
struct GNUNET_HashCode hash;
GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &hash);
struct GNUNET_CONTAINER_MultiHashMap *map = select_store_contact_map (
- store, context, &hash
- );
+ store, context, &hash
+ );
if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (map, &hash, contact))
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Removing a contact failed: %s\n",
- GNUNET_h2s(&hash));
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Removing a contact failed: %s\n",
+ GNUNET_h2s (&hash));
destroy_contact (contact);
}
diff --git a/src/messenger/messenger_api_contact_store.h
b/src/messenger/messenger_api_contact_store.h
index c74a67740..b61ef7f12 100644
--- a/src/messenger/messenger_api_contact_store.h
+++ b/src/messenger/messenger_api_contact_store.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -105,7 +105,7 @@ get_store_contact (struct GNUNET_MESSENGER_ContactStore
*store,
*/
void
update_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
- struct GNUNET_MESSENGER_Contact* contact,
+ struct GNUNET_MESSENGER_Contact *contact,
const struct GNUNET_HashCode *context,
const struct GNUNET_HashCode *next_context,
const struct GNUNET_IDENTITY_PublicKey *pubkey);
@@ -120,7 +120,7 @@ update_store_contact (struct GNUNET_MESSENGER_ContactStore
*store,
*/
void
remove_store_contact (struct GNUNET_MESSENGER_ContactStore *store,
- struct GNUNET_MESSENGER_Contact* contact,
+ struct GNUNET_MESSENGER_Contact *contact,
const struct GNUNET_HashCode *context);
#endif //GNUNET_MESSENGER_API_CONTACT_STORE_H
diff --git a/src/messenger/messenger_api_handle.c
b/src/messenger/messenger_api_handle.c
index abede8e21..7d5b55a06 100644
--- a/src/messenger/messenger_api_handle.c
+++ b/src/messenger/messenger_api_handle.c
@@ -34,9 +34,10 @@ create_handle (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_MESSENGER_MessageCallback msg_callback,
void *msg_cls)
{
- GNUNET_assert(cfg);
+ GNUNET_assert (cfg);
- struct GNUNET_MESSENGER_Handle *handle = GNUNET_new(struct
GNUNET_MESSENGER_Handle);
+ struct GNUNET_MESSENGER_Handle *handle = GNUNET_new (struct
+
GNUNET_MESSENGER_Handle);
handle->cfg = cfg;
handle->mq = NULL;
@@ -53,11 +54,12 @@ create_handle (const struct GNUNET_CONFIGURATION_Handle
*cfg,
handle->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
- init_contact_store(get_handle_contact_store(handle));
+ init_contact_store (get_handle_contact_store (handle));
return handle;
}
+
static int
iterate_destroy_room (void *cls,
const struct GNUNET_HashCode *key,
@@ -70,10 +72,11 @@ iterate_destroy_room (void *cls,
return GNUNET_YES;
}
+
void
destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
if (handle->reconnect_task)
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
@@ -82,26 +85,28 @@ destroy_handle (struct GNUNET_MESSENGER_Handle *handle)
GNUNET_MQ_destroy (handle->mq);
if (handle->name)
- GNUNET_free(handle->name);
+ GNUNET_free (handle->name);
if (handle->key)
- GNUNET_free(handle->key);
+ GNUNET_free (handle->key);
if (handle->pubkey)
- GNUNET_free(handle->pubkey);
+ GNUNET_free (handle->pubkey);
if (handle->rooms)
{
- GNUNET_CONTAINER_multihashmap_iterate (handle->rooms,
iterate_destroy_room, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_destroy_room,
+ NULL);
GNUNET_CONTAINER_multihashmap_destroy (handle->rooms);
}
- clear_contact_store(get_handle_contact_store(handle));
+ clear_contact_store (get_handle_contact_store (handle));
- GNUNET_free(handle);
+ GNUNET_free (handle);
}
+
void
set_handle_name (struct GNUNET_MESSENGER_Handle *handle,
const char *name)
@@ -114,21 +119,23 @@ set_handle_name (struct GNUNET_MESSENGER_Handle *handle,
handle->name = name ? GNUNET_strdup (name) : NULL;
}
+
const char*
get_handle_name (const struct GNUNET_MESSENGER_Handle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
return handle->name;
}
+
void
set_handle_key (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_IDENTITY_PrivateKey *key)
{
GNUNET_assert (handle);
- if (!key)
+ if (! key)
{
if (handle->key)
GNUNET_free (handle->key);
@@ -141,31 +148,33 @@ set_handle_key (struct GNUNET_MESSENGER_Handle *handle,
return;
}
- if (!handle->key)
+ if (! handle->key)
handle->key = GNUNET_new (struct GNUNET_IDENTITY_PrivateKey);
- if (!handle->pubkey)
+ if (! handle->pubkey)
handle->pubkey = GNUNET_new (struct GNUNET_IDENTITY_PublicKey);
GNUNET_memcpy (handle->key, key, sizeof(*key));
GNUNET_IDENTITY_key_get_public (key, handle->pubkey);
}
+
const struct GNUNET_IDENTITY_PrivateKey*
get_handle_key (const struct GNUNET_MESSENGER_Handle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
if (handle->key)
return handle->key;
- return get_anonymous_private_key();
+ return get_anonymous_private_key ();
}
+
const struct GNUNET_IDENTITY_PublicKey*
get_handle_pubkey (const struct GNUNET_MESSENGER_Handle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
if (handle->pubkey)
return handle->pubkey;
@@ -173,28 +182,31 @@ get_handle_pubkey (const struct GNUNET_MESSENGER_Handle
*handle)
return get_anonymous_public_key ();
}
+
struct GNUNET_MESSENGER_ContactStore*
get_handle_contact_store (struct GNUNET_MESSENGER_Handle *handle)
{
- GNUNET_assert(handle);
+ GNUNET_assert (handle);
return &(handle->contact_store);
}
+
struct GNUNET_MESSENGER_Contact*
get_handle_contact (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
- if (!room)
+ if (! room)
return NULL;
const struct GNUNET_ShortHashCode *contact_id = get_room_sender_id (room);
- if (!contact_id)
+ if (! contact_id)
return NULL;
struct GNUNET_HashCode context;
@@ -204,48 +216,56 @@ get_handle_contact (struct GNUNET_MESSENGER_Handle
*handle,
get_handle_pubkey (handle));
}
+
void
open_handle_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
if (room)
room->opened = GNUNET_YES;
}
+
void
entry_handle_room_at (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_PeerIdentity *door,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (door) && (key));
+ GNUNET_assert ((handle) && (door) && (key));
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
if (room)
add_to_list_tunnels (&(room->entries), door, NULL);
}
+
void
close_handle_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get
(handle->rooms, key);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
+ handle->rooms, key);
- if ((room) && (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove
(handle->rooms, key, room)))
+ if ((room) && (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
+ handle->rooms, key, room)))
destroy_room (room);
}
+
struct GNUNET_MESSENGER_Room*
get_handle_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
return GNUNET_CONTAINER_multihashmap_get (handle->rooms, key);
}
diff --git a/src/messenger/messenger_api_list_tunnels.c
b/src/messenger/messenger_api_list_tunnels.c
index 4d0deb95d..b2513370c 100644
--- a/src/messenger/messenger_api_list_tunnels.c
+++ b/src/messenger/messenger_api_list_tunnels.c
@@ -29,24 +29,27 @@
void
init_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels)
{
- GNUNET_assert(tunnels);
+ GNUNET_assert (tunnels);
tunnels->head = NULL;
tunnels->tail = NULL;
}
+
void
clear_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels)
{
- GNUNET_assert(tunnels);
+ GNUNET_assert (tunnels);
struct GNUNET_MESSENGER_ListTunnel *element;
- for (element = tunnels->head; element; element =
remove_from_list_tunnels(tunnels, element))
+ for (element = tunnels->head; element; element = remove_from_list_tunnels (
+ tunnels, element))
- tunnels->head = NULL;
+ tunnels->head = NULL;
tunnels->tail = NULL;
}
+
static int
compare_list_tunnels (void *cls,
struct GNUNET_MESSENGER_ListTunnel *element0,
@@ -55,28 +58,33 @@ compare_list_tunnels (void *cls,
return ((int) element0->peer) - ((int) element1->peer);
}
+
void
add_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((tunnels) && (peer));
+ GNUNET_assert ((tunnels) && (peer));
- struct GNUNET_MESSENGER_ListTunnel *element = GNUNET_new(struct
GNUNET_MESSENGER_ListTunnel);
+ struct GNUNET_MESSENGER_ListTunnel *element = GNUNET_new (struct
+
GNUNET_MESSENGER_ListTunnel);
element->peer = GNUNET_PEER_intern (peer);
- element->hash = hash ? GNUNET_memdup(hash, sizeof(struct GNUNET_HashCode)) :
NULL;
+ element->hash = hash ? GNUNET_memdup (hash, sizeof(struct GNUNET_HashCode)) :
+ NULL;
- GNUNET_CONTAINER_DLL_insert_sorted(struct GNUNET_MESSENGER_ListTunnel,
compare_list_tunnels, NULL, tunnels->head,
- tunnels->tail, element);
+ GNUNET_CONTAINER_DLL_insert_sorted (struct GNUNET_MESSENGER_ListTunnel,
+ compare_list_tunnels, NULL,
tunnels->head,
+ tunnels->tail, element);
}
+
struct GNUNET_MESSENGER_ListTunnel*
find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const struct GNUNET_PeerIdentity *peer,
size_t *index)
{
- GNUNET_assert((tunnels) && (peer));
+ GNUNET_assert ((tunnels) && (peer));
struct GNUNET_MESSENGER_ListTunnel *element;
struct GNUNET_PeerIdentity pid;
@@ -88,7 +96,7 @@ find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels
*tunnels,
{
GNUNET_PEER_resolve (element->peer, &pid);
- if (0 == GNUNET_memcmp(&pid, peer))
+ if (0 == GNUNET_memcmp (&pid, peer))
return element;
if (index)
@@ -98,111 +106,121 @@ find_list_tunnels (struct GNUNET_MESSENGER_ListTunnels
*tunnels,
return NULL;
}
+
void
update_to_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((tunnels) && (peer));
+ GNUNET_assert ((tunnels) && (peer));
- struct GNUNET_MESSENGER_ListTunnel* element = find_list_tunnels(tunnels,
peer, NULL);
- if (!element)
+ struct GNUNET_MESSENGER_ListTunnel *element = find_list_tunnels (tunnels,
+ peer,
+ NULL);
+ if (! element)
return;
if (element->hash)
{
if (hash)
- GNUNET_memcpy(element->hash, hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (element->hash, hash, sizeof(struct GNUNET_HashCode));
else
{
- GNUNET_free(element->hash);
+ GNUNET_free (element->hash);
element->hash = NULL;
}
}
else if (hash)
- element->hash = GNUNET_memdup(hash, sizeof(struct GNUNET_HashCode));
+ element->hash = GNUNET_memdup (hash, sizeof(struct GNUNET_HashCode));
}
+
int
contains_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const struct GNUNET_PeerIdentity *peer)
{
- GNUNET_assert((tunnels) && (peer));
+ GNUNET_assert ((tunnels) && (peer));
- return find_list_tunnels (tunnels, peer, NULL) != NULL ? GNUNET_YES :
GNUNET_NO;
+ return find_list_tunnels (tunnels, peer, NULL) != NULL ? GNUNET_YES :
+ GNUNET_NO;
}
+
struct GNUNET_MESSENGER_ListTunnel*
remove_from_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
struct GNUNET_MESSENGER_ListTunnel *element)
{
- GNUNET_assert((tunnels) && (element));
+ GNUNET_assert ((tunnels) && (element));
struct GNUNET_MESSENGER_ListTunnel *next = element->next;
if ((tunnels->head) && (tunnels->tail))
- GNUNET_CONTAINER_DLL_remove(tunnels->head, tunnels->tail, element);
+ GNUNET_CONTAINER_DLL_remove (tunnels->head, tunnels->tail, element);
if (element->hash)
- GNUNET_free(element->hash);
+ GNUNET_free (element->hash);
GNUNET_PEER_change_rc (element->peer, -1);
- GNUNET_free(element);
+ GNUNET_free (element);
return next;
}
+
void
load_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const char *path)
{
- GNUNET_assert((tunnels) && (path));
+ GNUNET_assert ((tunnels) && (path));
if (GNUNET_YES != GNUNET_DISK_file_test (path))
return;
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_READ, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_READ, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
struct GNUNET_PeerIdentity peer;
ssize_t len;
do {
- len = GNUNET_DISK_file_read(handle, &peer, sizeof(peer));
+ len = GNUNET_DISK_file_read (handle, &peer, sizeof(peer));
if (len != sizeof(peer))
break;
- add_to_list_tunnels(tunnels, &peer, NULL);
+ add_to_list_tunnels (tunnels, &peer, NULL);
} while (len == sizeof(peer));
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_close (handle);
}
+
void
save_list_tunnels (struct GNUNET_MESSENGER_ListTunnels *tunnels,
const char *path)
{
- GNUNET_assert((tunnels) && (path));
+ GNUNET_assert ((tunnels) && (path));
- enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
| GNUNET_DISK_PERM_USER_WRITE);
+ enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ
+ |
GNUNET_DISK_PERM_USER_WRITE);
- struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open(
- path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
- );
+ struct GNUNET_DISK_FileHandle *handle = GNUNET_DISK_file_open (
+ path, GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, permission
+ );
- if (!handle)
+ if (! handle)
return;
- GNUNET_DISK_file_seek(handle, 0, GNUNET_DISK_SEEK_SET);
+ GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
struct GNUNET_MESSENGER_ListTunnel *element;
struct GNUNET_PeerIdentity pid;
@@ -211,9 +229,9 @@ save_list_tunnels (struct GNUNET_MESSENGER_ListTunnels
*tunnels,
{
GNUNET_PEER_resolve (element->peer, &pid);
- GNUNET_DISK_file_write(handle, &pid, sizeof(pid));
+ GNUNET_DISK_file_write (handle, &pid, sizeof(pid));
}
- GNUNET_DISK_file_sync(handle);
- GNUNET_DISK_file_close(handle);
+ GNUNET_DISK_file_sync (handle);
+ GNUNET_DISK_file_close (handle);
}
diff --git a/src/messenger/messenger_api_message.c
b/src/messenger/messenger_api_message.c
index 3d9e125a4..881b18bb5 100644
--- a/src/messenger/messenger_api_message.c
+++ b/src/messenger/messenger_api_message.c
@@ -41,7 +41,8 @@ struct GNUNET_MESSENGER_ShortMessage
struct GNUNET_MESSENGER_Message*
create_message (enum GNUNET_MESSENGER_MessageKind kind)
{
- struct GNUNET_MESSENGER_Message *message = GNUNET_new(struct
GNUNET_MESSENGER_Message);
+ struct GNUNET_MESSENGER_Message *message = GNUNET_new (struct
+
GNUNET_MESSENGER_Message);
message->header.kind = kind;
@@ -67,32 +68,36 @@ create_message (enum GNUNET_MESSENGER_MessageKind kind)
return message;
}
+
struct GNUNET_MESSENGER_Message*
copy_message (const struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
- struct GNUNET_MESSENGER_Message *copy = GNUNET_new(struct
GNUNET_MESSENGER_Message);
+ struct GNUNET_MESSENGER_Message *copy = GNUNET_new (struct
+
GNUNET_MESSENGER_Message);
- GNUNET_memcpy(copy, message, sizeof(struct GNUNET_MESSENGER_Message));
+ GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message));
switch (message->header.kind)
{
case GNUNET_MESSENGER_KIND_NAME:
- copy->body.name.name = GNUNET_strdup(message->body.name.name);
+ copy->body.name.name = GNUNET_strdup (message->body.name.name);
break;
case GNUNET_MESSENGER_KIND_TEXT:
- copy->body.text.text = GNUNET_strdup(message->body.text.text);
+ copy->body.text.text = GNUNET_strdup (message->body.text.text);
break;
case GNUNET_MESSENGER_KIND_FILE:
- copy->body.file.uri = GNUNET_strdup(message->body.file.uri);
+ copy->body.file.uri = GNUNET_strdup (message->body.file.uri);
break;
case GNUNET_MESSENGER_KIND_PRIVATE:
- copy->body.privacy.data = copy->body.privacy.length ?
GNUNET_malloc(copy->body.privacy.length) : NULL;
+ copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc (
+ copy->body.privacy.length) : NULL;
if (copy->body.privacy.data)
{
- GNUNET_memcpy(copy->body.privacy.data, message->body.privacy.data,
copy->body.privacy.length);
+ GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data,
+ copy->body.privacy.length);
}
break;
@@ -103,6 +108,7 @@ copy_message (const struct GNUNET_MESSENGER_Message
*message)
return copy;
}
+
static void
destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind,
struct GNUNET_MESSENGER_MessageBody *body)
@@ -110,44 +116,47 @@ destroy_message_body (enum GNUNET_MESSENGER_MessageKind
kind,
switch (kind)
{
case GNUNET_MESSENGER_KIND_NAME:
- GNUNET_free(body->name.name);
+ GNUNET_free (body->name.name);
break;
case GNUNET_MESSENGER_KIND_TEXT:
- GNUNET_free(body->text.text);
+ GNUNET_free (body->text.text);
break;
case GNUNET_MESSENGER_KIND_FILE:
- GNUNET_free(body->file.uri);
+ GNUNET_free (body->file.uri);
break;
case GNUNET_MESSENGER_KIND_PRIVATE:
- GNUNET_free(body->privacy.data);
+ GNUNET_free (body->privacy.data);
break;
default:
break;
}
}
+
void
cleanup_message (struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
destroy_message_body (message->header.kind, &(message->body));
}
+
void
destroy_message (struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
destroy_message_body (message->header.kind, &(message->body));
- GNUNET_free(message);
+ GNUNET_free (message);
}
+
int
is_message_session_bound (const struct GNUNET_MESSENGER_Message *message)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) ||
(GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) ||
@@ -159,15 +168,18 @@ is_message_session_bound (const struct
GNUNET_MESSENGER_Message *message)
return GNUNET_NO;
}
+
static void
fold_short_message (const struct GNUNET_MESSENGER_Message *message,
struct GNUNET_MESSENGER_ShortMessage *shortened)
{
shortened->kind = message->header.kind;
- GNUNET_memcpy(&(shortened->body), &(message->body), sizeof(struct
GNUNET_MESSENGER_MessageBody));
+ GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct
+
GNUNET_MESSENGER_MessageBody));
}
+
static void
unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened,
struct GNUNET_MESSENGER_Message *message)
@@ -176,9 +188,11 @@ unfold_short_message (struct GNUNET_MESSENGER_ShortMessage
*shortened,
message->header.kind = shortened->kind;
- GNUNET_memcpy(&(message->body), &(shortened->body), sizeof(struct
GNUNET_MESSENGER_MessageBody));
+ GNUNET_memcpy (&(message->body), &(shortened->body), sizeof(struct
+
GNUNET_MESSENGER_MessageBody));
}
+
#define member_size(type, member) sizeof(((type*) NULL)->member)
static uint16_t
@@ -189,40 +203,43 @@ get_message_body_kind_size (enum
GNUNET_MESSENGER_MessageKind kind)
switch (kind)
{
case GNUNET_MESSENGER_KIND_INFO:
- length += member_size(struct GNUNET_MESSENGER_Message,
body.info.messenger_version);
+ length += member_size (struct GNUNET_MESSENGER_Message,
+ body.info.messenger_version);
break;
case GNUNET_MESSENGER_KIND_PEER:
- length += member_size(struct GNUNET_MESSENGER_Message, body.peer.peer);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.peer.peer);
break;
case GNUNET_MESSENGER_KIND_ID:
- length += member_size(struct GNUNET_MESSENGER_Message, body.id.id);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.id.id);
break;
case GNUNET_MESSENGER_KIND_MISS:
- length += member_size(struct GNUNET_MESSENGER_Message, body.miss.peer);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer);
break;
case GNUNET_MESSENGER_KIND_MERGE:
- length += member_size(struct GNUNET_MESSENGER_Message,
body.merge.previous);
+ length += member_size (struct GNUNET_MESSENGER_Message,
+ body.merge.previous);
break;
case GNUNET_MESSENGER_KIND_REQUEST:
- length += member_size(struct GNUNET_MESSENGER_Message, body.request.hash);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash);
break;
case GNUNET_MESSENGER_KIND_INVITE:
- length += member_size(struct GNUNET_MESSENGER_Message, body.invite.door);
- length += member_size(struct GNUNET_MESSENGER_Message, body.invite.key);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key);
break;
case GNUNET_MESSENGER_KIND_TEXT:
break;
case GNUNET_MESSENGER_KIND_FILE:
- length += member_size(struct GNUNET_MESSENGER_Message, body.file.key);
- length += member_size(struct GNUNET_MESSENGER_Message, body.file.hash);
- length += member_size(struct GNUNET_MESSENGER_Message, body.file.name);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.file.key);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.file.hash);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.file.name);
break;
case GNUNET_MESSENGER_KIND_PRIVATE:
- length += member_size(struct GNUNET_MESSENGER_Message, body.privacy.key);
+ length += member_size (struct GNUNET_MESSENGER_Message, body.privacy.key);
break;
case GNUNET_MESSENGER_KIND_DELETE:
- length += member_size(struct GNUNET_MESSENGER_Message, body.deletion.hash);
- length += member_size(struct GNUNET_MESSENGER_Message,
body.deletion.delay);
+ length += member_size (struct GNUNET_MESSENGER_Message,
body.deletion.hash);
+ length += member_size (struct GNUNET_MESSENGER_Message,
+ body.deletion.delay);
break;
default:
break;
@@ -231,6 +248,7 @@ get_message_body_kind_size (enum
GNUNET_MESSENGER_MessageKind kind)
return length;
}
+
typedef uint32_t kind_t;
uint16_t
@@ -241,9 +259,9 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind
kind,
if (GNUNET_YES == include_header)
{
- length += member_size(struct GNUNET_MESSENGER_Message, header.timestamp);
- length += member_size(struct GNUNET_MESSENGER_Message, header.sender_id);
- length += member_size(struct GNUNET_MESSENGER_Message, header.previous);
+ length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp);
+ length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id);
+ length += member_size (struct GNUNET_MESSENGER_Message, header.previous);
}
length += sizeof(kind_t);
@@ -251,6 +269,7 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind
kind,
return length + get_message_body_kind_size (kind);
}
+
static uint16_t
get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind,
const struct GNUNET_MESSENGER_MessageBody *body)
@@ -260,13 +279,13 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind
kind,
switch (kind)
{
case GNUNET_MESSENGER_KIND_JOIN:
- length += GNUNET_IDENTITY_public_key_get_length(&(body->join.key));
+ length += GNUNET_IDENTITY_public_key_get_length (&(body->join.key));
break;
case GNUNET_MESSENGER_KIND_NAME:
length += (body->name.name ? strlen (body->name.name) : 0);
break;
case GNUNET_MESSENGER_KIND_KEY:
- length += GNUNET_IDENTITY_public_key_get_length(&(body->key.key));
+ length += GNUNET_IDENTITY_public_key_get_length (&(body->key.key));
break;
case GNUNET_MESSENGER_KIND_TEXT:
length += strlen (body->text.text);
@@ -284,16 +303,18 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind
kind,
return length;
}
+
uint16_t
get_message_size (const struct GNUNET_MESSENGER_Message *message,
int include_header)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
uint16_t length = 0;
if (GNUNET_YES == include_header)
- length +=
GNUNET_IDENTITY_signature_get_length(&(message->header.signature));
+ length += GNUNET_IDENTITY_signature_get_length (
+ &(message->header.signature));
length += get_message_kind_size (message->header.kind, include_header);
length += get_message_body_size (message->header.kind, &(message->body));
@@ -301,6 +322,7 @@ get_message_size (const struct GNUNET_MESSENGER_Message
*message,
return length;
}
+
static uint16_t
get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message,
int include_body)
@@ -309,19 +331,24 @@ get_short_message_size (const struct
GNUNET_MESSENGER_ShortMessage *message,
if (message)
return minimum_size + get_message_body_kind_size (message->kind)
- + (include_body == GNUNET_YES? get_message_body_size
(message->kind, &(message->body)) : 0);
+ + (include_body == GNUNET_YES? get_message_body_size (message->kind,
+
&(message->body))
+ : 0);
else
return minimum_size;
}
+
static uint16_t
calc_usual_padding ()
{
uint16_t padding = 0;
uint16_t kind_size;
- for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) {
- kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i,
GNUNET_YES);
+ for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++)
+ {
+ kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i,
+ GNUNET_YES);
if (kind_size > padding)
padding = kind_size;
@@ -330,6 +357,7 @@ calc_usual_padding ()
return padding + GNUNET_MESSENGER_PADDING_MIN;
}
+
#define max(x, y) (x > y? x : y)
static uint16_t
@@ -337,13 +365,13 @@ calc_padded_length (uint16_t length)
{
static uint16_t usual_padding = 0;
- if (!usual_padding)
- usual_padding = calc_usual_padding();
+ if (! usual_padding)
+ usual_padding = calc_usual_padding ();
- const uint16_t padded_length = max(
- length + GNUNET_MESSENGER_PADDING_MIN,
- usual_padding
- );
+ const uint16_t padded_length = max (
+ length + GNUNET_MESSENGER_PADDING_MIN,
+ usual_padding
+ );
if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0)
return GNUNET_MESSENGER_PADDING_LEVEL0;
@@ -358,35 +386,36 @@ calc_padded_length (uint16_t length)
}
+
#define min(x, y) (x < y? x : y)
#define encode_step_ext(dst, offset, src, size) do { \
- GNUNET_memcpy(dst + offset, src, size); \
- offset += size; \
+ GNUNET_memcpy (dst + offset, src, size); \
+ offset += size; \
} while (0)
#define encode_step(dst, offset, src) do { \
- encode_step_ext(dst, offset, src, sizeof(*src)); \
+ encode_step_ext (dst, offset, src, sizeof(*src)); \
} while (0)
#define encode_step_key(dst, offset, src, length) do { \
- ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer( \
- src, dst + offset, length - offset \
- ); \
- if (result < 0) \
- GNUNET_break (0); \
- else \
- offset += result; \
+ ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer ( \
+ src, dst + offset, length - offset \
+ ); \
+ if (result < 0) \
+ GNUNET_break (0); \
+ else \
+ offset += result; \
} while (0)
#define encode_step_signature(dst, offset, src, length) do { \
- ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer( \
- src, dst + offset, length - offset \
- ); \
- if (result < 0) \
- GNUNET_break (0); \
- else \
- offset += result; \
+ ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer ( \
+ src, dst + offset, length - offset \
+ ); \
+ if (result < 0) \
+ GNUNET_break (0); \
+ else \
+ offset += result; \
} while (0)
static void
@@ -400,55 +429,63 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind
kind,
switch (kind)
{
case GNUNET_MESSENGER_KIND_INFO:
- version = GNUNET_htobe32(body->info.messenger_version);
+ version = GNUNET_htobe32 (body->info.messenger_version);
- encode_step(buffer, offset, &version);
+ encode_step (buffer, offset, &version);
break;
case GNUNET_MESSENGER_KIND_JOIN:
- encode_step_key(buffer, offset, &(body->join.key), length);
+ encode_step_key (buffer, offset, &(body->join.key), length);
break;
case GNUNET_MESSENGER_KIND_NAME:
if (body->name.name)
- encode_step_ext(buffer, offset, body->name.name, min(length - offset,
strlen(body->name.name)));
+ encode_step_ext (buffer, offset, body->name.name, min (length - offset,
+ strlen (
+
body->name.name)));
break;
case GNUNET_MESSENGER_KIND_KEY:
- encode_step_key(buffer, offset, &(body->key.key), length);
+ encode_step_key (buffer, offset, &(body->key.key), length);
break;
case GNUNET_MESSENGER_KIND_PEER:
- encode_step(buffer, offset, &(body->peer.peer));
+ encode_step (buffer, offset, &(body->peer.peer));
break;
case GNUNET_MESSENGER_KIND_ID:
- encode_step(buffer, offset, &(body->id.id));
+ encode_step (buffer, offset, &(body->id.id));
break;
case GNUNET_MESSENGER_KIND_MISS:
- encode_step(buffer, offset, &(body->miss.peer));
+ encode_step (buffer, offset, &(body->miss.peer));
break;
case GNUNET_MESSENGER_KIND_MERGE:
- encode_step(buffer, offset, &(body->merge.previous));
+ encode_step (buffer, offset, &(body->merge.previous));
break;
case GNUNET_MESSENGER_KIND_REQUEST:
- encode_step(buffer, offset, &(body->request.hash));
+ encode_step (buffer, offset, &(body->request.hash));
break;
case GNUNET_MESSENGER_KIND_INVITE:
- encode_step(buffer, offset, &(body->invite.door));
- encode_step(buffer, offset, &(body->invite.key));
+ encode_step (buffer, offset, &(body->invite.door));
+ encode_step (buffer, offset, &(body->invite.key));
break;
case GNUNET_MESSENGER_KIND_TEXT:
- encode_step_ext(buffer, offset, body->text.text, min(length - offset,
strlen(body->text.text)));
+ encode_step_ext (buffer, offset, body->text.text, min (length - offset,
+ strlen (
+
body->text.text)));
break;
case GNUNET_MESSENGER_KIND_FILE:
- encode_step(buffer, offset, &(body->file.key));
- encode_step(buffer, offset, &(body->file.hash));
- encode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name));
- encode_step_ext(buffer, offset, body->file.uri, min(length - offset,
strlen(body->file.uri)));
+ encode_step (buffer, offset, &(body->file.key));
+ encode_step (buffer, offset, &(body->file.hash));
+ encode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
+ encode_step_ext (buffer, offset, body->file.uri, min (length - offset,
+ strlen (
+ body->file.uri)));
break;
case GNUNET_MESSENGER_KIND_PRIVATE:
- encode_step(buffer, offset, &(body->privacy.key));
- encode_step_ext(buffer, offset, body->privacy.data, min(length - offset,
body->privacy.length));
+ encode_step (buffer, offset, &(body->privacy.key));
+ encode_step_ext (buffer, offset, body->privacy.data, min (length - offset,
+ body->privacy.
+ length));
break;
case GNUNET_MESSENGER_KIND_DELETE:
- encode_step(buffer, offset, &(body->deletion.hash));
- encode_step(buffer, offset, &(body->deletion.delay));
+ encode_step (buffer, offset, &(body->deletion.hash));
+ encode_step (buffer, offset, &(body->deletion.delay));
break;
default:
break;
@@ -460,43 +497,48 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind
kind,
const uint16_t padding = length - offset;
const uint16_t used_padding = sizeof(padding) + sizeof(char);
- GNUNET_assert(padding >= used_padding);
+ GNUNET_assert (padding >= used_padding);
buffer[offset++] = '\0';
if (padding > used_padding)
- GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset,
padding - used_padding);
+ GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset,
+ padding - used_padding);
- GNUNET_memcpy(buffer + length - sizeof(padding), &padding, sizeof(padding));
+ GNUNET_memcpy (buffer + length - sizeof(padding), &padding, sizeof(padding));
}
+
void
encode_message (const struct GNUNET_MESSENGER_Message *message,
uint16_t length,
char *buffer,
int include_header)
{
- GNUNET_assert((message) && (buffer));
+ GNUNET_assert ((message) && (buffer));
uint16_t offset = 0;
if (GNUNET_YES == include_header)
- encode_step_signature(buffer, offset, &(message->header.signature),
length);
+ encode_step_signature (buffer, offset, &(message->header.signature),
+ length);
- const kind_t kind = GNUNET_htobe32((kind_t) message->header.kind);
+ const kind_t kind = GNUNET_htobe32 ((kind_t) message->header.kind);
if (GNUNET_YES == include_header)
{
- encode_step(buffer, offset, &(message->header.timestamp));
- encode_step(buffer, offset, &(message->header.sender_id));
- encode_step(buffer, offset, &(message->header.previous));
+ encode_step (buffer, offset, &(message->header.timestamp));
+ encode_step (buffer, offset, &(message->header.sender_id));
+ encode_step (buffer, offset, &(message->header.previous));
}
- encode_step(buffer, offset, &kind);
+ encode_step (buffer, offset, &kind);
- encode_message_body (message->header.kind, &(message->body), length, buffer,
offset);
+ encode_message_body (message->header.kind, &(message->body), length, buffer,
+ offset);
}
+
static void
encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message,
uint16_t length,
@@ -505,46 +547,47 @@ encode_short_message (const struct
GNUNET_MESSENGER_ShortMessage *message,
struct GNUNET_HashCode hash;
uint16_t offset = sizeof(hash);
- const kind_t kind = GNUNET_htobe32((kind_t) message->kind);
+ const kind_t kind = GNUNET_htobe32 ((kind_t) message->kind);
- encode_step(buffer, offset, &kind);
+ encode_step (buffer, offset, &kind);
encode_message_body (message->kind, &(message->body), length, buffer,
offset);
- GNUNET_CRYPTO_hash(
- buffer + sizeof(hash),
- length - sizeof(hash),
- &hash
- );
+ GNUNET_CRYPTO_hash (
+ buffer + sizeof(hash),
+ length - sizeof(hash),
+ &hash
+ );
- GNUNET_memcpy(buffer, &hash, sizeof(hash));
+ GNUNET_memcpy (buffer, &hash, sizeof(hash));
}
+
#define decode_step_ext(src, offset, dst, size) do { \
- GNUNET_memcpy(dst, src + offset, size); \
- offset += size; \
+ GNUNET_memcpy (dst, src + offset, size); \
+ offset += size; \
} while (0)
-#define decode_step(src, offset, dst) do { \
- decode_step_ext(src, offset, dst, sizeof(*dst)); \
+#define decode_step(src, offset, dst) do { \
+ decode_step_ext (src, offset, dst, sizeof(*dst)); \
} while (0)
-#define decode_step_malloc(src, offset, dst, size, zero) do { \
- dst = GNUNET_malloc(size + zero); \
- if (zero) dst[size] = 0;
\
- decode_step_ext(src, offset, dst, size);
\
+#define decode_step_malloc(src, offset, dst, size, zero) do { \
+ dst = GNUNET_malloc (size + zero); \
+ if (zero) dst[size] = 0; \
+ decode_step_ext (src, offset, dst, size); \
} while (0)
#define decode_step_key(src, offset, dst, length) do { \
- enum GNUNET_GenericReturnValue result; \
- size_t read; \
- result = GNUNET_IDENTITY_read_public_key_from_buffer( \
- src + offset, length - offset, dst, &read \
- ); \
- if (GNUNET_SYSERR == result) \
- GNUNET_break(0); \
- else \
- offset += read; \
+ enum GNUNET_GenericReturnValue result; \
+ size_t read; \
+ result = GNUNET_IDENTITY_read_public_key_from_buffer ( \
+ src + offset, length - offset, dst, &read \
+ ); \
+ if (GNUNET_SYSERR == result) \
+ GNUNET_break (0); \
+ else \
+ offset += read; \
} while (0)
static uint16_t
@@ -556,7 +599,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind
*kind,
{
uint16_t padding = 0;
- GNUNET_memcpy(&padding, buffer + length - sizeof(padding), sizeof(padding));
+ GNUNET_memcpy (&padding, buffer + length - sizeof(padding), sizeof(padding));
if (padding > length - offset)
padding = 0;
@@ -572,59 +615,59 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind
*kind,
switch (*kind)
{
case GNUNET_MESSENGER_KIND_INFO: {
- decode_step(buffer, offset, &version);
-
- body->info.messenger_version = GNUNET_be32toh(version);
- break;
- } case GNUNET_MESSENGER_KIND_JOIN: {
- decode_step_key(buffer, offset, &(body->join.key), length);
- break;
- } case GNUNET_MESSENGER_KIND_NAME:
+ decode_step (buffer, offset, &version);
+
+ body->info.messenger_version = GNUNET_be32toh (version);
+ break;
+ } case GNUNET_MESSENGER_KIND_JOIN: {
+ decode_step_key (buffer, offset, &(body->join.key), length);
+ break;
+ } case GNUNET_MESSENGER_KIND_NAME:
if (length - offset > 0)
- decode_step_malloc(buffer, offset, body->name.name, length - offset, 1);
+ decode_step_malloc (buffer, offset, body->name.name, length - offset, 1);
else
body->name.name = NULL;
break;
case GNUNET_MESSENGER_KIND_KEY:
- decode_step_key(buffer, offset, &(body->key.key), length);
+ decode_step_key (buffer, offset, &(body->key.key), length);
break;
case GNUNET_MESSENGER_KIND_PEER:
- decode_step(buffer, offset, &(body->peer.peer));
+ decode_step (buffer, offset, &(body->peer.peer));
break;
case GNUNET_MESSENGER_KIND_ID:
- decode_step(buffer, offset, &(body->id.id));
+ decode_step (buffer, offset, &(body->id.id));
break;
case GNUNET_MESSENGER_KIND_MISS:
- decode_step(buffer, offset, &(body->miss.peer));
+ decode_step (buffer, offset, &(body->miss.peer));
break;
case GNUNET_MESSENGER_KIND_MERGE:
- decode_step(buffer, offset, &(body->merge.previous));
+ decode_step (buffer, offset, &(body->merge.previous));
break;
case GNUNET_MESSENGER_KIND_REQUEST:
- decode_step(buffer, offset, &(body->request.hash));
+ decode_step (buffer, offset, &(body->request.hash));
break;
case GNUNET_MESSENGER_KIND_INVITE:
- decode_step(buffer, offset, &(body->invite.door));
- decode_step(buffer, offset, &(body->invite.key));
+ decode_step (buffer, offset, &(body->invite.door));
+ decode_step (buffer, offset, &(body->invite.key));
break;
case GNUNET_MESSENGER_KIND_TEXT:
- decode_step_malloc(buffer, offset, body->text.text, length - offset, 1);
+ decode_step_malloc (buffer, offset, body->text.text, length - offset, 1);
break;
case GNUNET_MESSENGER_KIND_FILE:
- decode_step(buffer, offset, &(body->file.key));
- decode_step(buffer, offset, &(body->file.hash));
- decode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name));
- decode_step_malloc(buffer, offset, body->file.uri, length - offset, 1);
+ decode_step (buffer, offset, &(body->file.key));
+ decode_step (buffer, offset, &(body->file.hash));
+ decode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
+ decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1);
break;
case GNUNET_MESSENGER_KIND_PRIVATE:
- decode_step(buffer, offset, &(body->privacy.key));
+ decode_step (buffer, offset, &(body->privacy.key));
body->privacy.length = (length - offset);
- decode_step_malloc(buffer, offset, body->privacy.data, length - offset, 0);
+ decode_step_malloc (buffer, offset, body->privacy.data, length - offset,
0);
break;
case GNUNET_MESSENGER_KIND_DELETE:
- decode_step(buffer, offset, &(body->deletion.hash));
- decode_step(buffer, offset, &(body->deletion.delay));
+ decode_step (buffer, offset, &(body->deletion.hash));
+ decode_step (buffer, offset, &(body->deletion.delay));
break;
default:
*kind = GNUNET_MESSENGER_KIND_UNKNOWN;
@@ -634,6 +677,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind
*kind,
return padding;
}
+
int
decode_message (struct GNUNET_MESSENGER_Message *message,
uint16_t length,
@@ -641,19 +685,20 @@ decode_message (struct GNUNET_MESSENGER_Message *message,
int include_header,
uint16_t *padding)
{
- GNUNET_assert(
- (message) &&
- (buffer) &&
- (length >= get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN,
include_header))
- );
+ GNUNET_assert (
+ (message) &&
+ (buffer) &&
+ (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ include_header))
+ );
uint16_t offset = 0;
if (GNUNET_YES == include_header)
{
- ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer(
- &(message->header.signature), buffer, length - offset
- );
+ ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer (
+ &(message->header.signature), buffer, length - offset
+ );
if (result < 0)
return GNUNET_NO;
@@ -663,26 +708,30 @@ decode_message (struct GNUNET_MESSENGER_Message *message,
const uint16_t count = length - offset;
- if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
include_header))
+ if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
+ include_header))
return GNUNET_NO;
kind_t kind;
if (GNUNET_YES == include_header)
{
- decode_step(buffer, offset, &(message->header.timestamp));
- decode_step(buffer, offset, &(message->header.sender_id));
- decode_step(buffer, offset, &(message->header.previous));
+ decode_step (buffer, offset, &(message->header.timestamp));
+ decode_step (buffer, offset, &(message->header.sender_id));
+ decode_step (buffer, offset, &(message->header.previous));
}
- decode_step(buffer, offset, &kind);
+ decode_step (buffer, offset, &kind);
- message->header.kind = (enum GNUNET_MESSENGER_MessageKind)
GNUNET_be32toh(kind);
+ message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (
+ kind);
if (count < get_message_kind_size (message->header.kind, include_header))
return GNUNET_NO;
- const uint16_t result = decode_message_body (&(message->header.kind),
&(message->body), length, buffer, offset);
+ const uint16_t result = decode_message_body (&(message->header.kind),
+ &(message->body), length,
buffer,
+ offset);
if (padding)
*padding = result;
@@ -690,6 +739,7 @@ decode_message (struct GNUNET_MESSENGER_Message *message,
return GNUNET_YES;
}
+
static int
decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message,
uint16_t length,
@@ -701,27 +751,28 @@ decode_short_message (struct
GNUNET_MESSENGER_ShortMessage *message,
if (length < get_short_message_size (NULL, GNUNET_NO))
return GNUNET_NO;
- GNUNET_memcpy(&hash, buffer, sizeof(hash));
+ GNUNET_memcpy (&hash, buffer, sizeof(hash));
- GNUNET_CRYPTO_hash(
- buffer + sizeof(hash),
- length - sizeof(hash),
- &expected
- );
+ GNUNET_CRYPTO_hash (
+ buffer + sizeof(hash),
+ length - sizeof(hash),
+ &expected
+ );
- if (0 != GNUNET_CRYPTO_hash_cmp(&hash, &expected))
+ if (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected))
return GNUNET_NO;
kind_t kind;
- decode_step(buffer, offset, &kind);
+ decode_step (buffer, offset, &kind);
- message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh(kind);
+ message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (kind);
if (length < get_short_message_size (message, GNUNET_NO))
return GNUNET_NO;
- decode_message_body (&(message->kind), &(message->body), length, buffer,
offset);
+ decode_message_body (&(message->kind), &(message->body), length, buffer,
+ offset);
if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind)
return GNUNET_NO;
@@ -729,21 +780,23 @@ decode_short_message (struct
GNUNET_MESSENGER_ShortMessage *message,
return GNUNET_YES;
}
+
void
hash_message (const struct GNUNET_MESSENGER_Message *message,
uint16_t length,
const char *buffer,
struct GNUNET_HashCode *hash)
{
- GNUNET_assert((message) && (buffer) && (hash));
+ GNUNET_assert ((message) && (buffer) && (hash));
- const ssize_t offset = GNUNET_IDENTITY_signature_get_length(
- &(message->header.signature)
- );
+ const ssize_t offset = GNUNET_IDENTITY_signature_get_length (
+ &(message->header.signature)
+ );
GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash);
}
+
void
sign_message (struct GNUNET_MESSENGER_Message *message,
uint16_t length,
@@ -751,7 +804,7 @@ sign_message (struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash,
const struct GNUNET_IDENTITY_PrivateKey *key)
{
- GNUNET_assert((message) && (buffer) && (hash) && (key));
+ GNUNET_assert ((message) && (buffer) && (hash) && (key));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n",
GNUNET_h2s (hash));
@@ -761,23 +814,24 @@ sign_message (struct GNUNET_MESSENGER_Message *message,
signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
signature.purpose.size = htonl (sizeof(signature));
- GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
- GNUNET_IDENTITY_sign(key, &signature, &(message->header.signature));
+ GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_IDENTITY_sign (key, &signature, &(message->header.signature));
message->header.signature.type = key->type;
uint16_t offset = 0;
- encode_step_signature(buffer, offset, &(message->header.signature), length);
+ encode_step_signature (buffer, offset, &(message->header.signature), length);
}
+
void
sign_message_by_peer (struct GNUNET_MESSENGER_Message *message,
uint16_t length,
char *buffer,
const struct GNUNET_HashCode *hash,
- const struct GNUNET_CONFIGURATION_Handle* cfg)
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- GNUNET_assert((message) && (buffer) && (hash) && (cfg));
+ GNUNET_assert ((message) && (buffer) && (hash) && (cfg));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n",
GNUNET_h2s (hash));
@@ -787,21 +841,24 @@ sign_message_by_peer (struct GNUNET_MESSENGER_Message
*message,
signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
signature.purpose.size = htonl (sizeof(signature));
- GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
- GNUNET_CRYPTO_sign_by_peer_identity(cfg, &signature.purpose,
&(message->header.signature.eddsa_signature));
+ GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_CRYPTO_sign_by_peer_identity (cfg, &signature.purpose,
+ &(message->header.signature.
+ eddsa_signature));
message->header.signature.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA);
uint16_t offset = 0;
- encode_step_signature(buffer, offset, &(message->header.signature), length);
+ encode_step_signature (buffer, offset, &(message->header.signature), length);
}
+
int
verify_message (const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash,
const struct GNUNET_IDENTITY_PublicKey *key)
{
- GNUNET_assert((message) && (hash) && (key));
+ GNUNET_assert ((message) && (hash) && (key));
if (key->type != message->header.signature.type)
return GNUNET_SYSERR;
@@ -811,18 +868,20 @@ verify_message (const struct GNUNET_MESSENGER_Message
*message,
signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
signature.purpose.size = htonl (sizeof(signature));
- GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
- return GNUNET_IDENTITY_signature_verify
(GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
- &(message->header.signature), key);
+ return GNUNET_IDENTITY_signature_verify (
+ GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
+ &(message->header.signature), key);
}
+
int
verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash,
const struct GNUNET_PeerIdentity *identity)
{
- GNUNET_assert((message) && (hash) && (identity));
+ GNUNET_assert ((message) && (hash) && (identity));
if (ntohl (GNUNET_IDENTITY_TYPE_EDDSA) != message->header.signature.type)
return GNUNET_SYSERR;
@@ -832,19 +891,22 @@ verify_message_by_peer (const struct
GNUNET_MESSENGER_Message *message,
signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
signature.purpose.size = htonl (sizeof(signature));
- GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
+ GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
- return GNUNET_CRYPTO_verify_peer_identity
(GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature.purpose,
-
&(message->header.signature.eddsa_signature), identity);
+ return GNUNET_CRYPTO_verify_peer_identity (
+ GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature.purpose,
+ &(message->header.signature.
+ eddsa_signature), identity);
}
+
int
encrypt_message (struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_IDENTITY_PublicKey *key)
{
- GNUNET_assert((message) && (key));
+ GNUNET_assert ((message) && (key));
- if (GNUNET_YES == is_service_message(message))
+ if (GNUNET_YES == is_service_message (message))
return GNUNET_NO;
struct GNUNET_MESSENGER_ShortMessage shortened;
@@ -854,7 +916,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message,
const uint16_t length = get_short_message_size (&shortened, GNUNET_YES);
const uint16_t padded_length = calc_padded_length (
length + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
- );
+ );
message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
message->body.privacy.data = GNUNET_malloc (padded_length);
@@ -862,7 +924,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message,
const uint16_t encoded_length = (
padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
- );
+ );
encode_short_message (&shortened, encoded_length,
message->body.privacy.data);
@@ -882,6 +944,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message,
return GNUNET_YES;
}
+
int
decrypt_message (struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_IDENTITY_PrivateKey *key)
@@ -900,7 +963,7 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message,
const uint16_t encoded_length = (
padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
- );
+ );
if (GNUNET_OK != GNUNET_IDENTITY_decrypt (message->body.privacy.data,
padded_length,
@@ -929,6 +992,7 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message,
return GNUNET_YES;
}
+
struct GNUNET_MQ_Envelope*
pack_message (struct GNUNET_MESSENGER_Message *message,
struct GNUNET_HashCode *hash,
@@ -936,22 +1000,24 @@ pack_message (struct GNUNET_MESSENGER_Message *message,
int mode,
const void *cls)
{
- GNUNET_assert(message);
+ GNUNET_assert (message);
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Packing message kind=%u and sender:
%s\n",
- message->header.kind, GNUNET_sh2s(&(message->header.sender_id)));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Packing message kind=%u and sender: %s\n",
+ message->header.kind, GNUNET_sh2s
(&(message->header.sender_id)));
struct GNUNET_MessageHeader *header;
const uint16_t length = get_message_size (message, GNUNET_YES);
- const uint16_t padded_length = calc_padded_length(length);
+ const uint16_t padded_length = calc_padded_length (length);
struct GNUNET_MQ_Envelope *env;
char *buffer;
if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
{
- env = GNUNET_MQ_msg_extra(header, padded_length,
GNUNET_MESSAGE_TYPE_CADET_CLI);
+ env = GNUNET_MQ_msg_extra (header, padded_length,
+ GNUNET_MESSAGE_TYPE_CADET_CLI);
buffer = (char*) &(header[1]);
}
@@ -959,7 +1025,7 @@ pack_message (struct GNUNET_MESSENGER_Message *message,
{
env = NULL;
- buffer = GNUNET_malloc(padded_length);
+ buffer = GNUNET_malloc (padded_length);
}
encode_message (message, padded_length, buffer, GNUNET_YES);
@@ -973,11 +1039,12 @@ pack_message (struct GNUNET_MESSENGER_Message *message,
}
if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
- GNUNET_free(buffer);
+ GNUNET_free (buffer);
return env;
}
+
int
is_peer_message (const struct GNUNET_MESSENGER_Message *message)
{
@@ -993,10 +1060,11 @@ is_peer_message (const struct GNUNET_MESSENGER_Message
*message)
}
}
+
int
is_service_message (const struct GNUNET_MESSENGER_Message *message)
{
- if (GNUNET_YES == is_peer_message(message))
+ if (GNUNET_YES == is_peer_message (message))
return GNUNET_YES;
switch (message->header.kind)
@@ -1036,10 +1104,11 @@ is_service_message (const struct
GNUNET_MESSENGER_Message *message)
}
}
+
int
filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
{
- if (GNUNET_YES == is_peer_message(message))
+ if (GNUNET_YES == is_peer_message (message))
return GNUNET_SYSERR; // Requires signature of peer rather than ego!
switch (message->header.kind)
diff --git a/src/messenger/messenger_api_message.h
b/src/messenger/messenger_api_message.h
index 3544993f9..1d3c12ff3 100644
--- a/src/messenger/messenger_api_message.h
+++ b/src/messenger/messenger_api_message.h
@@ -33,7 +33,8 @@
#include "gnunet_messenger_service.h"
-#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE (GNUNET_MAX_MESSAGE_SIZE -
GNUNET_MIN_MESSAGE_SIZE)
+#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE (GNUNET_MAX_MESSAGE_SIZE \
+ - GNUNET_MIN_MESSAGE_SIZE)
#define GNUNET_MESSENGER_PADDING_MIN (sizeof(uint16_t) + sizeof(char))
#define GNUNET_MESSENGER_PADDING_LEVEL0 (512)
@@ -188,7 +189,7 @@ sign_message_by_peer (struct GNUNET_MESSENGER_Message
*message,
uint16_t length,
char *buffer,
const struct GNUNET_HashCode *hash,
- const struct GNUNET_CONFIGURATION_Handle* cfg);
+ const struct GNUNET_CONFIGURATION_Handle *cfg);
/**
* Verifies the signature of a given <i>message</i> and its <i>hash</i> with a
specific
@@ -252,7 +253,7 @@ typedef void (*GNUNET_MESSENGER_SignFunction)(
uint16_t length,
char *buffer,
const struct GNUNET_HashCode *hash
-);
+ );
#define GNUNET_MESSENGER_PACK_MODE_ENVELOPE 0x1
#define GNUNET_MESSENGER_PACK_MODE_UNKNOWN 0x0
diff --git a/src/messenger/messenger_api_message_kind.c
b/src/messenger/messenger_api_message_kind.c
index 97eaa061b..5a13620cc 100644
--- a/src/messenger/messenger_api_message_kind.c
+++ b/src/messenger/messenger_api_message_kind.c
@@ -31,74 +31,84 @@
struct GNUNET_MESSENGER_Message*
create_message_join (const struct GNUNET_IDENTITY_PrivateKey *key)
{
- if (!key)
+ if (! key)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_JOIN);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_JOIN);
- if (!message)
+ if (! message)
return NULL;
GNUNET_IDENTITY_key_get_public (key, &(message->body.join.key));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_leave ()
{
return create_message (GNUNET_MESSENGER_KIND_LEAVE);
}
+
struct GNUNET_MESSENGER_Message*
create_message_name (const char *name)
{
- if (!name)
+ if (! name)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_NAME);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_NAME);
- if (!message)
+ if (! message)
return NULL;
- message->body.name.name = GNUNET_strdup(name);
+ message->body.name.name = GNUNET_strdup (name);
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key)
{
- if (!key)
+ if (! key)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_KEY);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_KEY);
- if (!message)
+ if (! message)
return NULL;
GNUNET_IDENTITY_key_get_public (key, &(message->body.key.key));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_id (const struct GNUNET_ShortHashCode *unique_id)
{
- if (!unique_id)
+ if (! unique_id)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_ID);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_ID);
- if (!message)
+ if (! message)
return NULL;
- GNUNET_memcpy(&(message->body.id.id), unique_id, sizeof(struct
GNUNET_ShortHashCode));
+ GNUNET_memcpy (&(message->body.id.id), unique_id, sizeof(struct
+
GNUNET_ShortHashCode));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_request (const struct GNUNET_HashCode *hash)
{
- if (!hash)
+ if (! hash)
return NULL;
struct GNUNET_HashCode zero;
@@ -107,62 +117,73 @@ create_message_request (const struct GNUNET_HashCode
*hash)
if (0 == GNUNET_CRYPTO_hash_cmp (hash, &zero))
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_REQUEST);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_REQUEST);
- if (!message)
+ if (! message)
return NULL;
- GNUNET_memcpy(&(message->body.request.hash), hash, sizeof(struct
GNUNET_HashCode));
+ GNUNET_memcpy (&(message->body.request.hash), hash, sizeof(struct
+ GNUNET_HashCode));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_invite (const struct GNUNET_PeerIdentity *door,
const struct GNUNET_HashCode *key)
{
- if ((!door) || (!key))
+ if ((! door) || (! key))
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_INVITE);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_INVITE);
- if (!message)
+ if (! message)
return NULL;
- GNUNET_memcpy(&(message->body.invite.door), door, sizeof(struct
GNUNET_PeerIdentity));
- GNUNET_memcpy(&(message->body.invite.key), key, sizeof(struct
GNUNET_HashCode));
+ GNUNET_memcpy (&(message->body.invite.door), door, sizeof(struct
+
GNUNET_PeerIdentity));
+ GNUNET_memcpy (&(message->body.invite.key), key, sizeof(struct
+ GNUNET_HashCode));
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_text (const char *text)
{
- if (!text)
+ if (! text)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_TEXT);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_TEXT);
- if (!message)
+ if (! message)
return NULL;
- message->body.text.text = GNUNET_strdup(text);
+ message->body.text.text = GNUNET_strdup (text);
return message;
}
+
struct GNUNET_MESSENGER_Message*
create_message_delete (const struct GNUNET_HashCode *hash,
const struct GNUNET_TIME_Relative delay)
{
- if (!hash)
+ if (! hash)
return NULL;
- struct GNUNET_MESSENGER_Message *message = create_message
(GNUNET_MESSENGER_KIND_DELETE);
+ struct GNUNET_MESSENGER_Message *message = create_message (
+ GNUNET_MESSENGER_KIND_DELETE);
- if (!message)
+ if (! message)
return NULL;
- GNUNET_memcpy(&(message->body.deletion.hash), hash, sizeof(struct
GNUNET_HashCode));
+ GNUNET_memcpy (&(message->body.deletion.hash), hash, sizeof(struct
+
GNUNET_HashCode));
message->body.deletion.delay = GNUNET_TIME_relative_hton (delay);
return message;
diff --git a/src/messenger/messenger_api_peer_store.c
b/src/messenger/messenger_api_peer_store.c
index f0b9eb0bb..949510960 100644
--- a/src/messenger/messenger_api_peer_store.c
+++ b/src/messenger/messenger_api_peer_store.c
@@ -37,25 +37,30 @@ init_peer_store (struct GNUNET_MESSENGER_PeerStore *store)
store->peers = GNUNET_CONTAINER_multishortmap_create (4, GNUNET_NO);
}
+
static enum GNUNET_GenericReturnValue
-iterate_destroy_peers (void *cls, const struct GNUNET_ShortHashCode *id, void
*value)
+iterate_destroy_peers (void *cls, const struct GNUNET_ShortHashCode *id,
+ void *value)
{
- struct GNUNET_PeerIdentity* peer = value;
+ struct GNUNET_PeerIdentity *peer = value;
GNUNET_free (peer);
return GNUNET_YES;
}
+
void
clear_peer_store (struct GNUNET_MESSENGER_PeerStore *store)
{
GNUNET_assert ((store) && (store->peers));
- GNUNET_CONTAINER_multishortmap_iterate (store->peers, iterate_destroy_peers,
NULL);
+ GNUNET_CONTAINER_multishortmap_iterate (store->peers, iterate_destroy_peers,
+ NULL);
GNUNET_CONTAINER_multishortmap_destroy (store->peers);
store->peers = NULL;
}
+
struct GNUNET_MESSENGER_ClosureVerifyPeer
{
const struct GNUNET_MESSENGER_Message *message;
@@ -64,12 +69,14 @@ struct GNUNET_MESSENGER_ClosureVerifyPeer
};
static enum GNUNET_GenericReturnValue
-verify_store_peer(void *cls, const struct GNUNET_ShortHashCode *id, void
*value)
+verify_store_peer (void *cls, const struct GNUNET_ShortHashCode *id,
+ void *value)
{
struct GNUNET_MESSENGER_ClosureVerifyPeer *verify = cls;
- struct GNUNET_PeerIdentity* peer = value;
+ struct GNUNET_PeerIdentity *peer = value;
- if ((peer) && (GNUNET_OK == verify_message_by_peer (verify->message,
verify->hash, peer)))
+ if ((peer) && (GNUNET_OK == verify_message_by_peer (verify->message,
+ verify->hash, peer)))
{
verify->sender = peer;
return GNUNET_NO;
@@ -78,6 +85,7 @@ verify_store_peer(void *cls, const struct
GNUNET_ShortHashCode *id, void *value)
return GNUNET_YES;
}
+
struct GNUNET_PeerIdentity*
get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
const struct GNUNET_MESSENGER_Message *message,
@@ -89,7 +97,8 @@ get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
return NULL;
if ((GNUNET_MESSENGER_KIND_PEER == message->header.kind) &&
- (GNUNET_OK == verify_message_by_peer (message, hash,
&(message->body.peer.peer))))
+ (GNUNET_OK == verify_message_by_peer (message, hash,
+ &(message->body.peer.peer))))
{
struct GNUNET_ShortHashCode peer_id;
convert_peer_identity_to_id (&(message->body.peer.peer), &peer_id);
@@ -97,7 +106,8 @@ get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
if (0 == GNUNET_memcmp (&peer_id, &(message->header.sender_id)))
update_store_peer (store, &(message->body.peer.peer));
else
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Sender id does not match peer
identity\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Sender id does not match peer identity\n");
}
struct GNUNET_MESSENGER_ClosureVerifyPeer verify;
@@ -105,12 +115,14 @@ get_store_peer_of (struct GNUNET_MESSENGER_PeerStore
*store,
verify.hash = hash;
verify.sender = NULL;
- GNUNET_CONTAINER_multishortmap_get_multiple (store->peers,
&(message->header.sender_id),
+ GNUNET_CONTAINER_multishortmap_get_multiple (store->peers,
+ &(message->header.sender_id),
verify_store_peer, &verify);
return verify.sender;
}
+
struct GNUNET_MESSENGER_ClosureFindPeer
{
const struct GNUNET_PeerIdentity *requested;
@@ -118,10 +130,10 @@ struct GNUNET_MESSENGER_ClosureFindPeer
};
static enum GNUNET_GenericReturnValue
-find_store_peer(void *cls, const struct GNUNET_ShortHashCode *id, void *value)
+find_store_peer (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
{
struct GNUNET_MESSENGER_ClosureFindPeer *find = cls;
- struct GNUNET_PeerIdentity* peer = value;
+ struct GNUNET_PeerIdentity *peer = value;
if ((peer) && (0 == GNUNET_memcmp (find->requested, peer)))
{
@@ -132,9 +144,10 @@ find_store_peer(void *cls, const struct
GNUNET_ShortHashCode *id, void *value)
return GNUNET_YES;
}
+
void
update_store_peer (struct GNUNET_MESSENGER_PeerStore *store,
- const struct GNUNET_PeerIdentity* peer)
+ const struct GNUNET_PeerIdentity *peer)
{
GNUNET_assert ((store) && (store->peers) && (peer));
@@ -151,11 +164,13 @@ update_store_peer (struct GNUNET_MESSENGER_PeerStore
*store,
if (find.match)
return;
- struct GNUNET_PeerIdentity* copy = GNUNET_memdup (peer, sizeof (struct
GNUNET_PeerIdentity));
+ struct GNUNET_PeerIdentity *copy = GNUNET_memdup (peer, sizeof (struct
+
GNUNET_PeerIdentity));
GNUNET_CONTAINER_multishortmap_put (store->peers, &peer_id, copy,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}
+
void
remove_store_peer (struct GNUNET_MESSENGER_PeerStore *store,
const struct GNUNET_PeerIdentity *peer)
@@ -172,9 +187,11 @@ remove_store_peer (struct GNUNET_MESSENGER_PeerStore
*store,
GNUNET_CONTAINER_multishortmap_get_multiple (store->peers, &peer_id,
find_store_peer, &find);
- if (!find.match)
+ if (! find.match)
return;
- if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (store->peers,
&peer_id, find.match))
- GNUNET_free(find.match);
+ if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (store->peers,
+ &peer_id,
+ find.match))
+ GNUNET_free (find.match);
}
diff --git a/src/messenger/messenger_api_peer_store.h
b/src/messenger/messenger_api_peer_store.h
index 526a1ca57..f4f948cb9 100644
--- a/src/messenger/messenger_api_peer_store.h
+++ b/src/messenger/messenger_api_peer_store.h
@@ -78,7 +78,7 @@ get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store,
*/
void
update_store_peer (struct GNUNET_MESSENGER_PeerStore *store,
- const struct GNUNET_PeerIdentity* peer);
+ const struct GNUNET_PeerIdentity *peer);
/**
* Removes a <i>peer</i> identity from the <i>store</i> entirely.
diff --git a/src/messenger/messenger_api_queue_messages.c
b/src/messenger/messenger_api_queue_messages.c
index bd99698cd..415fa6a3e 100644
--- a/src/messenger/messenger_api_queue_messages.c
+++ b/src/messenger/messenger_api_queue_messages.c
@@ -34,6 +34,7 @@ init_queue_messages (struct GNUNET_MESSENGER_QueueMessages
*messages)
messages->tail = NULL;
}
+
void
clear_queue_messages (struct GNUNET_MESSENGER_QueueMessages *messages)
{
@@ -55,6 +56,7 @@ clear_queue_messages (struct GNUNET_MESSENGER_QueueMessages
*messages)
messages->tail = NULL;
}
+
void
enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
const struct GNUNET_IDENTITY_PrivateKey *sender,
@@ -62,9 +64,10 @@ enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages
*messages,
{
GNUNET_assert ((messages) && (message));
- struct GNUNET_MESSENGER_QueueMessage *element = GNUNET_new (struct
GNUNET_MESSENGER_QueueMessage);
+ struct GNUNET_MESSENGER_QueueMessage *element = GNUNET_new (struct
+
GNUNET_MESSENGER_QueueMessage);
- if (!element)
+ if (! element)
return;
element->message = copy_message (message);
@@ -72,7 +75,7 @@ enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages
*messages,
if (sender)
GNUNET_memcpy (&(element->sender), sender, sizeof (element->sender));
- if (!element->message)
+ if (! element->message)
{
GNUNET_free (element);
return;
@@ -81,6 +84,7 @@ enqueue_to_messages (struct GNUNET_MESSENGER_QueueMessages
*messages,
GNUNET_CONTAINER_DLL_insert_tail (messages->head, messages->tail, element);
}
+
struct GNUNET_MESSENGER_Message*
dequeue_from_messages (struct GNUNET_MESSENGER_QueueMessages *messages,
struct GNUNET_IDENTITY_PrivateKey *sender)
@@ -89,7 +93,7 @@ dequeue_from_messages (struct GNUNET_MESSENGER_QueueMessages
*messages,
struct GNUNET_MESSENGER_QueueMessage *element = messages->head;
- if (!element)
+ if (! element)
return NULL;
struct GNUNET_MESSENGER_Message *message = element->message;
diff --git a/src/messenger/messenger_api_room.c
b/src/messenger/messenger_api_room.c
index fb4e11fd4..2c8b27bf8 100644
--- a/src/messenger/messenger_api_room.c
+++ b/src/messenger/messenger_api_room.c
@@ -32,14 +32,15 @@ struct GNUNET_MESSENGER_Room*
create_room (struct GNUNET_MESSENGER_Handle *handle,
const struct GNUNET_HashCode *key)
{
- GNUNET_assert((handle) && (key));
+ GNUNET_assert ((handle) && (key));
- struct GNUNET_MESSENGER_Room *room = GNUNET_new(struct
GNUNET_MESSENGER_Room);
+ struct GNUNET_MESSENGER_Room *room = GNUNET_new (struct
+ GNUNET_MESSENGER_Room);
room->handle = handle;
- GNUNET_memcpy(&(room->key), key, sizeof(*key));
+ GNUNET_memcpy (&(room->key), key, sizeof(*key));
- memset(&(room->last_message), 0, sizeof(room->last_message));
+ memset (&(room->last_message), 0, sizeof(room->last_message));
room->opened = GNUNET_NO;
room->use_handle_name = GNUNET_YES;
@@ -55,6 +56,7 @@ create_room (struct GNUNET_MESSENGER_Handle *handle,
return room;
}
+
static int
iterate_destroy_message (void *cls,
const struct GNUNET_HashCode *key,
@@ -63,22 +65,24 @@ iterate_destroy_message (void *cls,
struct GNUNET_MESSENGER_RoomMessageEntry *entry = value;
destroy_message (entry->message);
- GNUNET_free(entry);
+ GNUNET_free (entry);
return GNUNET_YES;
}
+
void
destroy_room (struct GNUNET_MESSENGER_Room *room)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
- clear_queue_messages(&(room->queue));
+ clear_queue_messages (&(room->queue));
clear_list_tunnels (&(room->entries));
if (room->messages)
{
- GNUNET_CONTAINER_multihashmap_iterate (room->messages,
iterate_destroy_message, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (room->messages,
+ iterate_destroy_message, NULL);
GNUNET_CONTAINER_multihashmap_destroy (room->messages);
}
@@ -87,17 +91,18 @@ destroy_room (struct GNUNET_MESSENGER_Room *room)
GNUNET_CONTAINER_multishortmap_destroy (room->members);
if (room->sender_id)
- GNUNET_free(room->sender_id);
+ GNUNET_free (room->sender_id);
- GNUNET_free(room);
+ GNUNET_free (room);
}
+
enum GNUNET_GenericReturnValue
is_room_available (const struct GNUNET_MESSENGER_Room *room)
{
GNUNET_assert (room);
- if (!get_room_sender_id(room))
+ if (! get_room_sender_id (room))
return GNUNET_NO;
if ((GNUNET_YES == room->opened) || (room->entries.head))
@@ -106,6 +111,7 @@ is_room_available (const struct GNUNET_MESSENGER_Room *room)
return GNUNET_NO;
}
+
const struct GNUNET_ShortHashCode*
get_room_sender_id (const struct GNUNET_MESSENGER_Room *room)
{
@@ -114,15 +120,17 @@ get_room_sender_id (const struct GNUNET_MESSENGER_Room
*room)
return room->sender_id;
}
+
void
set_room_sender_id (struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_ShortHashCode *id)
{
GNUNET_assert (room);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
GNUNET_h2s (&(room->key)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set member id for room: %s\n",
+ GNUNET_h2s (&(room->key)));
- if (!id)
+ if (! id)
{
if (room->sender_id)
GNUNET_free (room->sender_id);
@@ -131,76 +139,92 @@ set_room_sender_id (struct GNUNET_MESSENGER_Room *room,
return;
}
- if (!room->sender_id)
+ if (! room->sender_id)
room->sender_id = GNUNET_new (struct GNUNET_ShortHashCode);
GNUNET_memcpy (room->sender_id, id, sizeof(struct GNUNET_ShortHashCode));
}
+
const struct GNUNET_MESSENGER_Message*
get_room_message (const struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((room) && (hash));
+ GNUNET_assert ((room) && (hash));
- struct GNUNET_MESSENGER_RoomMessageEntry *entry =
GNUNET_CONTAINER_multihashmap_get (
+ struct GNUNET_MESSENGER_RoomMessageEntry *entry =
+ GNUNET_CONTAINER_multihashmap_get (
room->messages, hash
- );
+ );
return (entry? entry->message : NULL);
}
+
struct GNUNET_MESSENGER_Contact*
get_room_sender (const struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_HashCode *hash)
{
- GNUNET_assert((room) && (hash));
+ GNUNET_assert ((room) && (hash));
- struct GNUNET_MESSENGER_RoomMessageEntry *entry =
GNUNET_CONTAINER_multihashmap_get (
+ struct GNUNET_MESSENGER_RoomMessageEntry *entry =
+ GNUNET_CONTAINER_multihashmap_get (
room->messages, hash
- );
+ );
return (entry? entry->sender : NULL);
}
+
static struct GNUNET_MESSENGER_Contact*
handle_join_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- if (!sender)
+ if (! sender)
{
- struct GNUNET_MESSENGER_ContactStore *store =
get_handle_contact_store(room->handle);
+ struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+ room->handle);
struct GNUNET_HashCode context;
- get_context_from_member(&(room->key), &(message->header.sender_id),
&context);
+ get_context_from_member (&(room->key), &(message->header.sender_id),
+ &context);
- sender = get_store_contact(store, &context, &(message->body.join.key));
+ sender = get_store_contact (store, &context, &(message->body.join.key));
}
- if ((GNUNET_YES !=
GNUNET_CONTAINER_multishortmap_contains_value(room->members,
&(message->header.sender_id), sender)) &&
- (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put(room->members,
&(message->header.sender_id), sender,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
- increase_contact_rc(sender);
+ if ((GNUNET_YES != GNUNET_CONTAINER_multishortmap_contains_value (
+ room->members, &(message->header.sender_id), sender)) &&
+ (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (room->members,
+ &(message->header.
+ sender_id), sender,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+ increase_contact_rc (sender);
return sender;
}
+
static void
handle_leave_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- if ((!sender) ||
- (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove(room->members,
&(message->header.sender_id), sender)))
+ if ((! sender) ||
+ (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
+ &(message->header.
+ sender_id),
+ sender)))
return;
- if (GNUNET_YES == decrease_contact_rc(sender))
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "A contact does not share any room
with you anymore!\n");
+ if (GNUNET_YES == decrease_contact_rc (sender))
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "A contact does not share any room with you anymore!\n");
}
+
static void
handle_name_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
@@ -210,37 +234,44 @@ handle_name_message (struct GNUNET_MESSENGER_Room *room,
{
if (GNUNET_MESSENGER_FLAG_SENT & flags)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set rule for using handle name in
room: %s\n", GNUNET_h2s (&(room->key)));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Set rule for using handle name in room: %s\n",
+ GNUNET_h2s (&(room->key)));
- const char* handle_name = get_handle_name (room->handle);
+ const char *handle_name = get_handle_name (room->handle);
if ((handle_name) && (0 == strcmp (handle_name, message->body.name.name)))
room->use_handle_name = GNUNET_YES;
}
- if (!sender)
+ if (! sender)
return;
set_contact_name (sender, message->body.name.name);
}
+
static void
handle_key_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- if (!sender)
+ if (! sender)
return;
struct GNUNET_HashCode context;
- get_context_from_member(&(room->key), &(message->header.sender_id),
&context);
+ get_context_from_member (&(room->key), &(message->header.sender_id),
+ &context);
- struct GNUNET_MESSENGER_ContactStore *store =
get_handle_contact_store(room->handle);
+ struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+ room->handle);
- update_store_contact(store, sender, &context, &context,
&(message->body.key.key));
+ update_store_contact (store, sender, &context, &context,
+ &(message->body.key.key));
}
+
static void
handle_id_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
@@ -251,21 +282,30 @@ handle_id_message (struct GNUNET_MESSENGER_Room *room,
if (GNUNET_MESSENGER_FLAG_SENT & flags)
set_room_sender_id (room, &(message->body.id.id));
- if ((!sender) ||
- (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove(room->members,
&(message->header.sender_id), sender)) ||
- (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put(room->members,
&(message->body.id.id), sender,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
+ if ((! sender) ||
+ (GNUNET_YES != GNUNET_CONTAINER_multishortmap_remove (room->members,
+ &(message->header.
+ sender_id),
+ sender)) ||
+ (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (room->members,
+ &(message->body.id.id),
+ sender,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
return;
struct GNUNET_HashCode context, next_context;
- get_context_from_member(&(room->key), &(message->header.sender_id),
&context);
- get_context_from_member(&(room->key), &(message->body.id.id), &next_context);
+ get_context_from_member (&(room->key), &(message->header.sender_id),
+ &context);
+ get_context_from_member (&(room->key), &(message->body.id.id),
&next_context);
- struct GNUNET_MESSENGER_ContactStore *store =
get_handle_contact_store(room->handle);
+ struct GNUNET_MESSENGER_ContactStore *store = get_handle_contact_store (
+ room->handle);
- update_store_contact(store, sender, &context, &next_context,
get_contact_key(sender));
+ update_store_contact (store, sender, &context, &next_context,
+ get_contact_key (sender));
}
+
static void
handle_miss_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
@@ -275,31 +315,40 @@ handle_miss_message (struct GNUNET_MESSENGER_Room *room,
{
if (GNUNET_MESSENGER_FLAG_SENT & flags)
{
- struct GNUNET_MESSENGER_ListTunnel *match = find_list_tunnels
(&(room->entries), &(message->body.miss.peer), NULL);
+ struct GNUNET_MESSENGER_ListTunnel *match = find_list_tunnels (
+ &(room->entries), &(message->body.miss.peer), NULL);
if (match)
remove_from_list_tunnels (&(room->entries), match);
}
}
+
static void
handle_delete_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
const struct GNUNET_MESSENGER_Message *message,
const struct GNUNET_HashCode *hash)
{
- struct GNUNET_MESSENGER_RoomMessageEntry *entry =
GNUNET_CONTAINER_multihashmap_get (
+ struct GNUNET_MESSENGER_RoomMessageEntry *entry =
+ GNUNET_CONTAINER_multihashmap_get (
room->messages, &(message->body.deletion.hash)
- );
-
- if ((entry) && ((entry->sender == sender) || (get_handle_contact
(room->handle, &(room->key)) == sender)) &&
- (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->messages,
&(message->body.deletion.hash), entry)))
+ );
+
+ if ((entry) && ((entry->sender == sender) || (get_handle_contact (
+ room->handle, &(room->key))
==
+ sender)) &&
+ (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (room->messages,
+ &(message->body.
+ deletion.hash),
+ entry)))
{
destroy_message (entry->message);
- GNUNET_free(entry);
+ GNUNET_free (entry);
}
}
+
struct GNUNET_MESSENGER_Contact*
handle_room_message (struct GNUNET_MESSENGER_Room *room,
struct GNUNET_MESSENGER_Contact *sender,
@@ -307,7 +356,8 @@ handle_room_message (struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_HashCode *hash,
enum GNUNET_MESSENGER_MessageFlags flags)
{
- if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->messages,
hash))
+ if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (room->messages,
+ hash))
return sender;
switch (message->header.kind)
@@ -337,25 +387,28 @@ handle_room_message (struct GNUNET_MESSENGER_Room *room,
break;
}
- struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_new(struct
GNUNET_MESSENGER_RoomMessageEntry);
+ struct GNUNET_MESSENGER_RoomMessageEntry *entry = GNUNET_new (struct
+
GNUNET_MESSENGER_RoomMessageEntry);
- if (!entry)
+ if (! entry)
return sender;
entry->sender = sender;
entry->message = copy_message (message);
- if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash,
entry,
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->messages, hash,
+ entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
destroy_message (entry->message);
- GNUNET_free(entry);
+ GNUNET_free (entry);
}
GNUNET_memcpy (&(room->last_message), hash, sizeof(room->last_message));
return sender;
}
+
struct GNUNET_MESSENGER_MemberCall
{
struct GNUNET_MESSENGER_Room *room;
@@ -364,25 +417,26 @@ struct GNUNET_MESSENGER_MemberCall
};
static int
-iterate_local_members (void* cls,
+iterate_local_members (void *cls,
const struct GNUNET_ShortHashCode *key,
void *value)
{
struct GNUNET_MESSENGER_MemberCall *call = cls;
struct GNUNET_MESSENGER_Contact *contact = value;
- return call->callback(call->cls, call->room, contact);
+ return call->callback (call->cls, call->room, contact);
}
+
int
iterate_room_members (struct GNUNET_MESSENGER_Room *room,
GNUNET_MESSENGER_MemberCallback callback,
- void* cls)
+ void *cls)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
- if (!callback)
- return GNUNET_CONTAINER_multishortmap_iterate(room->members, NULL, NULL);
+ if (! callback)
+ return GNUNET_CONTAINER_multishortmap_iterate (room->members, NULL, NULL);
struct GNUNET_MESSENGER_MemberCall call;
@@ -390,11 +444,14 @@ iterate_room_members (struct GNUNET_MESSENGER_Room *room,
call.callback = callback;
call.cls = cls;
- GNUNET_assert(callback);
+ GNUNET_assert (callback);
- return GNUNET_CONTAINER_multishortmap_iterate(room->members,
iterate_local_members, &call);
+ return GNUNET_CONTAINER_multishortmap_iterate (room->members,
+ iterate_local_members,
+ &call);
}
+
struct GNUNET_MESSENGER_MemberFind
{
const struct GNUNET_MESSENGER_Contact *contact;
@@ -402,7 +459,7 @@ struct GNUNET_MESSENGER_MemberFind
};
static int
-iterate_find_member (void* cls,
+iterate_find_member (void *cls,
const struct GNUNET_ShortHashCode *key,
void *value)
{
@@ -418,18 +475,20 @@ iterate_find_member (void* cls,
return GNUNET_YES;
}
+
int
find_room_member (const struct GNUNET_MESSENGER_Room *room,
const struct GNUNET_MESSENGER_Contact *contact)
{
- GNUNET_assert(room);
+ GNUNET_assert (room);
struct GNUNET_MESSENGER_MemberFind find;
find.contact = contact;
find.result = GNUNET_NO;
- GNUNET_CONTAINER_multishortmap_iterate(room->members, iterate_find_member,
&find);
+ GNUNET_CONTAINER_multishortmap_iterate (room->members, iterate_find_member,
+ &find);
return find.result;
}
diff --git a/src/messenger/messenger_api_room.h
b/src/messenger/messenger_api_room.h
index 62e4711d0..c9d36a410 100644
--- a/src/messenger/messenger_api_room.h
+++ b/src/messenger/messenger_api_room.h
@@ -36,9 +36,10 @@
#include "messenger_api_message.h"
#include "messenger_api_queue_messages.h"
-struct GNUNET_MESSENGER_RoomMessageEntry {
- struct GNUNET_MESSENGER_Contact* sender;
- struct GNUNET_MESSENGER_Message* message;
+struct GNUNET_MESSENGER_RoomMessageEntry
+{
+ struct GNUNET_MESSENGER_Contact *sender;
+ struct GNUNET_MESSENGER_Message *message;
};
struct GNUNET_MESSENGER_Room
@@ -165,7 +166,7 @@ handle_room_message (struct GNUNET_MESSENGER_Room *room,
int
iterate_room_members (struct GNUNET_MESSENGER_Room *room,
GNUNET_MESSENGER_MemberCallback callback,
- void* cls);
+ void *cls);
/**
* Checks through all members of a given <i>room</i> if a specific
<i>contact</i> is found and
diff --git a/src/messenger/messenger_api_util.c
b/src/messenger/messenger_api_util.c
index 2fc58ed75..bac9d0a05 100644
--- a/src/messenger/messenger_api_util.c
+++ b/src/messenger/messenger_api_util.c
@@ -35,29 +35,34 @@ callback_close_channel (void *cls)
GNUNET_CADET_channel_destroy (channel);
}
+
void
delayed_disconnect_channel (struct GNUNET_CADET_Channel *channel)
{
- GNUNET_assert(channel);
+ GNUNET_assert (channel);
GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_get_zero_
(),
GNUNET_SCHEDULER_PRIORITY_URGENT,
callback_close_channel, channel);
}
+
int
generate_free_member_id (struct GNUNET_ShortHashCode *id,
const struct GNUNET_CONTAINER_MultiShortmap *members)
{
- GNUNET_assert(id);
+ GNUNET_assert (id);
- size_t counter = 1 + (members ? GNUNET_CONTAINER_multishortmap_size
(members) : 0);
+ size_t counter = 1 + (members ? GNUNET_CONTAINER_multishortmap_size (
+ members) : 0);
do
{
- GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, id,
sizeof(struct GNUNET_ShortHashCode));
+ GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, id, sizeof(struct
+
GNUNET_ShortHashCode));
- if ((members) && (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains
(members, id)))
+ if ((members) && (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
+ members, id)))
counter--;
else
break;
@@ -70,48 +75,53 @@ generate_free_member_id (struct GNUNET_ShortHashCode *id,
return GNUNET_NO;
}
+
const struct GNUNET_IDENTITY_PrivateKey*
get_anonymous_private_key ()
{
- const struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous();
- return GNUNET_IDENTITY_ego_get_private_key(ego);
+ const struct GNUNET_IDENTITY_Ego *ego = GNUNET_IDENTITY_ego_get_anonymous ();
+ return GNUNET_IDENTITY_ego_get_private_key (ego);
}
+
const struct GNUNET_IDENTITY_PublicKey*
get_anonymous_public_key ()
{
static struct GNUNET_IDENTITY_PublicKey public_key;
- static struct GNUNET_IDENTITY_Ego* ego = NULL;
+ static struct GNUNET_IDENTITY_Ego *ego = NULL;
- if (!ego)
+ if (! ego)
{
- ego = GNUNET_IDENTITY_ego_get_anonymous();
- GNUNET_IDENTITY_ego_get_public_key(ego, &public_key);
+ ego = GNUNET_IDENTITY_ego_get_anonymous ();
+ GNUNET_IDENTITY_ego_get_public_key (ego, &public_key);
}
return &public_key;
}
+
void
-convert_messenger_key_to_port(const struct GNUNET_HashCode *key,
- struct GNUNET_HashCode *port)
+convert_messenger_key_to_port (const struct GNUNET_HashCode *key,
+ struct GNUNET_HashCode *port)
{
static uint32_t version_value = 0;
static struct GNUNET_HashCode version;
- if (!version_value) {
+ if (! version_value)
+ {
version_value = (uint32_t) (GNUNET_MESSENGER_VERSION);
version_value = ((version_value >> 16) & 0xFFFF);
- version_value = GNUNET_htole32(version_value);
- GNUNET_CRYPTO_hash(&version_value, sizeof(version_value), &version);
+ version_value = GNUNET_htole32 (version_value);
+ GNUNET_CRYPTO_hash (&version_value, sizeof(version_value), &version);
}
- GNUNET_CRYPTO_hash_sum(key, &version, port);
+ GNUNET_CRYPTO_hash_sum (key, &version, port);
}
+
void
-convert_peer_identity_to_id(const struct GNUNET_PeerIdentity *identity,
- struct GNUNET_ShortHashCode *id)
+convert_peer_identity_to_id (const struct GNUNET_PeerIdentity *identity,
+ struct GNUNET_ShortHashCode *id)
{
- GNUNET_memcpy(id, identity, sizeof(struct GNUNET_ShortHashCode));
+ GNUNET_memcpy (id, identity, sizeof(struct GNUNET_ShortHashCode));
}
diff --git a/src/messenger/messenger_api_util.h
b/src/messenger/messenger_api_util.h
index f50abf445..6a7b4df89 100644
--- a/src/messenger/messenger_api_util.h
+++ b/src/messenger/messenger_api_util.h
@@ -81,8 +81,8 @@ get_anonymous_public_key ();
* @param[out] port CADET service port
*/
void
-convert_messenger_key_to_port(const struct GNUNET_HashCode *key,
- struct GNUNET_HashCode *port);
+convert_messenger_key_to_port (const struct GNUNET_HashCode *key,
+ struct GNUNET_HashCode *port);
/**
* Converts a peers identity to a short hash code which can be used
@@ -92,7 +92,7 @@ convert_messenger_key_to_port(const struct GNUNET_HashCode
*key,
* @param[out] id Short peer id
*/
void
-convert_peer_identity_to_id(const struct GNUNET_PeerIdentity *identity,
- struct GNUNET_ShortHashCode *id);
+convert_peer_identity_to_id (const struct GNUNET_PeerIdentity *identity,
+ struct GNUNET_ShortHashCode *id);
#endif //GNUNET_SERVICE_MESSENGER_UTIL_H
diff --git a/src/messenger/plugin_gnsrecord_messenger.c
b/src/messenger/plugin_gnsrecord_messenger.c
index e09a0330d..ed675dd1d 100644
--- a/src/messenger/plugin_gnsrecord_messenger.c
+++ b/src/messenger/plugin_gnsrecord_messenger.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021--2022 GNUnet e.V.
+ Copyright (C) 2021--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -59,8 +59,11 @@ messenger_value_to_string (void *cls,
const struct GNUNET_MESSENGER_RoomEntryRecord *record = data;
- char *door = GNUNET_CRYPTO_eddsa_public_key_to_string
(&(record->door.public_key));
- char *key = GNUNET_STRINGS_data_to_string_alloc (&(record->key),
sizeof(struct GNUNET_HashCode));
+ char *door = GNUNET_CRYPTO_eddsa_public_key_to_string (
+ &(record->door.public_key));
+ char *key = GNUNET_STRINGS_data_to_string_alloc (&(record->key),
+ sizeof(struct
+
GNUNET_HashCode));
char *ret;
GNUNET_asprintf (&ret, "%s-%s", key, door);
@@ -78,8 +81,9 @@ messenger_value_to_string (void *cls,
const struct GNUNET_MESSENGER_RoomDetailsRecord *record = data;
- char *name = GNUNET_strndup(record->name, 256);
- char *flags = GNUNET_STRINGS_data_to_string_alloc (&(record->flags),
sizeof(uint32_t));
+ char *name = GNUNET_strndup (record->name, 256);
+ char *flags = GNUNET_STRINGS_data_to_string_alloc (&(record->flags),
+ sizeof(uint32_t));
char *ret;
GNUNET_asprintf (&ret, "%s-%s", flags, name);
@@ -122,15 +126,17 @@ messenger_string_to_value (void *cls,
{
case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY:
{
- char key [103];
+ char key[103];
const char *dash;
struct GNUNET_PeerIdentity door;
if ((NULL == (dash = strchr (s, '-'))) ||
(1 != sscanf (s, "%103s-", key)) ||
(GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
- strlen
(dash + 1),
-
&(door.public_key))))
+ strlen (
+ dash +
1),
+ &(door.
+
public_key))))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
@@ -139,13 +145,14 @@ messenger_string_to_value (void *cls,
}
struct GNUNET_MESSENGER_RoomEntryRecord *record = GNUNET_new (
- struct GNUNET_MESSENGER_RoomEntryRecord
- );
+ struct GNUNET_MESSENGER_RoomEntryRecord
+ );
if (GNUNET_OK != GNUNET_STRINGS_string_to_data (key,
strlen (key),
&(record->key),
- sizeof(struct
GNUNET_HashCode)))
+ sizeof(struct
+ GNUNET_HashCode)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
@@ -161,7 +168,7 @@ messenger_string_to_value (void *cls,
}
case GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS:
{
- char flags [7];
+ char flags[7];
const char *dash;
if ((NULL == (dash = strchr (s, '-'))) ||
@@ -175,8 +182,8 @@ messenger_string_to_value (void *cls,
}
struct GNUNET_MESSENGER_RoomDetailsRecord *record = GNUNET_new (
- struct GNUNET_MESSENGER_RoomDetailsRecord
- );
+ struct GNUNET_MESSENGER_RoomDetailsRecord
+ );
if (GNUNET_OK != GNUNET_STRINGS_string_to_data (flags,
strlen (flags),
@@ -190,7 +197,7 @@ messenger_string_to_value (void *cls,
return GNUNET_SYSERR;
}
- GNUNET_memcpy(record->name, dash + 1, strlen(dash + 1));
+ GNUNET_memcpy (record->name, dash + 1, strlen (dash + 1));
*data = record;
*data_size = sizeof(struct GNUNET_MESSENGER_RoomDetailsRecord);
diff --git a/src/messenger/test_messenger.c b/src/messenger/test_messenger.c
index 9958ce19e..716105380 100644
--- a/src/messenger/test_messenger.c
+++ b/src/messenger/test_messenger.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -77,6 +77,7 @@ end (void *cls)
status = 0;
}
+
static void
end_badly (void *cls)
{
@@ -86,12 +87,15 @@ end_badly (void *cls)
status = 1;
}
+
static void
end_operation (void *cls)
{
op_task = NULL;
- fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const char*)
cls : "unknown");
+ fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const
+ char*) cls :
+ "unknown");
if (die_task)
GNUNET_SCHEDULER_cancel (die_task);
@@ -100,6 +104,7 @@ end_operation (void *cls)
status = 1;
}
+
static int identity_counter = 0;
/**
@@ -122,18 +127,23 @@ on_iteration (void *cls)
const char *name = GNUNET_MESSENGER_get_name (handle);
- if ((!name) || (0 != strcmp (name, TESTER_NAME)))
+ if ((! name) || (0 != strcmp (name, TESTER_NAME)))
{
op_task = GNUNET_SCHEDULER_add_now (&end_operation, "name");
return;
}
- const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key
(handle);
+ const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key (
+ handle);
struct GNUNET_IDENTITY_PublicKey pubkey;
- GNUNET_IDENTITY_key_get_public(&identity, &pubkey);
+ GNUNET_IDENTITY_key_get_public (&identity, &pubkey);
- if (((!identity_counter) && (key)) || ((identity_counter) && ((!key) || (0
!= GNUNET_memcmp (key, &pubkey)))))
+ if (((! identity_counter) && (key)) || ((identity_counter) && ((! key) ||
+ (0 !=
+
GNUNET_memcmp (
+ key,
+
&pubkey)))))
{
op_task = GNUNET_SCHEDULER_add_now (&end_operation, "key");
return;
@@ -159,6 +169,7 @@ on_iteration (void *cls)
it_task = GNUNET_SCHEDULER_add_now (&on_iteration, handle);
}
+
/**
* Main function for testcase.
*
@@ -175,7 +186,8 @@ run (void *cls,
identity_counter = 0;
- op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation,
"connect");
+ op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation,
+ "connect");
messenger = GNUNET_MESSENGER_connect (cfg, TESTER_NAME, NULL, NULL, NULL);
identity.type = htonl (GNUNET_IDENTITY_TYPE_ECDSA);
@@ -185,6 +197,7 @@ run (void *cls,
it_task = GNUNET_SCHEDULER_add_now (&on_iteration, messenger);
}
+
/**
* The main function.
*
@@ -196,7 +209,8 @@ int
main (int argc,
char **argv)
{
- if (0 != GNUNET_TESTING_peer_run ("test-messenger",
"test_messenger_api.conf", &run, NULL))
+ if (0 != GNUNET_TESTING_peer_run ("test-messenger",
"test_messenger_api.conf",
+ &run, NULL))
return 1;
return status;
diff --git a/src/messenger/test_messenger_anonymous.c
b/src/messenger/test_messenger_anonymous.c
index 8431d186f..1bb8e14da 100644
--- a/src/messenger/test_messenger_anonymous.c
+++ b/src/messenger/test_messenger_anonymous.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -73,6 +73,7 @@ end (void *cls)
status = 0;
}
+
static void
end_badly (void *cls)
{
@@ -82,12 +83,15 @@ end_badly (void *cls)
status = 1;
}
+
static void
end_operation (void *cls)
{
op_task = NULL;
- fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const char*)
cls : "unknown");
+ fprintf (stderr, "Testcase failed (operation: '%s').\n", cls ? (const
+ char*) cls :
+ "unknown");
if (die_task)
GNUNET_SCHEDULER_cancel (die_task);
@@ -96,6 +100,7 @@ end_operation (void *cls)
status = 1;
}
+
/**
* Function called when an identity is retrieved.
*
@@ -123,7 +128,8 @@ on_iteration (void *cls)
return;
}
- const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key
(handle);
+ const struct GNUNET_IDENTITY_PublicKey *key = GNUNET_MESSENGER_get_key (
+ handle);
if (key)
{
@@ -141,6 +147,7 @@ on_iteration (void *cls)
die_task = GNUNET_SCHEDULER_add_now (&end, NULL);
}
+
/**
* Main function for testcase.
*
@@ -155,13 +162,15 @@ run (void *cls,
{
die_task = GNUNET_SCHEDULER_add_delayed (TOTAL_TIMEOUT, &end_badly, NULL);
- op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation,
"connect");
+ op_task = GNUNET_SCHEDULER_add_delayed (BASE_TIMEOUT, &end_operation,
+ "connect");
messenger = GNUNET_MESSENGER_connect (cfg, NULL, NULL, NULL, NULL);
if (messenger)
it_task = GNUNET_SCHEDULER_add_now (&on_iteration, messenger);
}
+
/**
* The main function.
*
@@ -173,7 +182,8 @@ int
main (int argc,
char **argv)
{
- if (0 != GNUNET_TESTING_peer_run ("test-messenger",
"test_messenger_api.conf", &run, NULL))
+ if (0 != GNUNET_TESTING_peer_run ("test-messenger",
"test_messenger_api.conf",
+ &run, NULL))
return 1;
return status;
diff --git a/src/messenger/testing_messenger_barrier.c
b/src/messenger/testing_messenger_barrier.c
index 60d1fc0fe..ecebe1582 100644
--- a/src/messenger/testing_messenger_barrier.c
+++ b/src/messenger/testing_messenger_barrier.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -35,7 +35,7 @@ struct GNUNET_BarrierHandle
struct GNUNET_BarrierWaitHandle *head;
struct GNUNET_BarrierWaitHandle *tail;
- struct GNUNET_SCHEDULER_Task* task;
+ struct GNUNET_SCHEDULER_Task *task;
};
struct GNUNET_BarrierHandle*
@@ -46,9 +46,10 @@ GNUNET_init_barrier (unsigned int requirement,
if (0 == requirement)
return NULL;
- struct GNUNET_BarrierHandle *barrier = GNUNET_new(struct
GNUNET_BarrierHandle);
+ struct GNUNET_BarrierHandle *barrier = GNUNET_new (struct
+ GNUNET_BarrierHandle);
- if (!barrier)
+ if (! barrier)
return NULL;
barrier->requirement = requirement;
@@ -61,6 +62,7 @@ GNUNET_init_barrier (unsigned int requirement,
return barrier;
}
+
static void
exit_status (struct GNUNET_BarrierHandle *barrier,
int status);
@@ -71,21 +73,24 @@ cancel_barrier (void *cls)
exit_status ((struct GNUNET_BarrierHandle*) cls, GNUNET_SYSERR);
}
+
static void
complete_barrier (void *cls)
{
exit_status ((struct GNUNET_BarrierHandle*) cls, GNUNET_OK);
}
+
void
GNUNET_cancel_barrier (struct GNUNET_BarrierHandle *barrier)
{
- if ((!barrier) || (barrier->task))
+ if ((! barrier) || (barrier->task))
return;
- barrier->task = GNUNET_SCHEDULER_add_now(cancel_barrier, barrier);
+ barrier->task = GNUNET_SCHEDULER_add_now (cancel_barrier, barrier);
}
+
struct GNUNET_BarrierWaitHandle
{
GNUNET_BarrierWaitStatusCallback cb;
@@ -107,31 +112,33 @@ exit_status (struct GNUNET_BarrierHandle *barrier,
struct GNUNET_BarrierWaitHandle *current = waiting;
if (current->cb)
- current->cb(current->cls, current, status);
+ current->cb (current->cls, current, status);
waiting = waiting->next;
- GNUNET_CONTAINER_DLL_remove(barrier->head, barrier->tail, current);
- GNUNET_free(current);
+ GNUNET_CONTAINER_DLL_remove (barrier->head, barrier->tail, current);
+ GNUNET_free (current);
}
if (barrier->cb)
- barrier->cb(barrier->cls, barrier, status);
+ barrier->cb (barrier->cls, barrier, status);
- GNUNET_free(barrier);
+ GNUNET_free (barrier);
}
+
struct GNUNET_BarrierWaitHandle*
GNUNET_wait_barrier (struct GNUNET_BarrierHandle *barrier,
GNUNET_BarrierWaitStatusCallback cb,
void *cb_cls)
{
- if ((!barrier) || (0 == barrier->requirement))
+ if ((! barrier) || (0 == barrier->requirement))
return NULL;
- struct GNUNET_BarrierWaitHandle *waiting = GNUNET_new(struct
GNUNET_BarrierWaitHandle);
+ struct GNUNET_BarrierWaitHandle *waiting = GNUNET_new (struct
+
GNUNET_BarrierWaitHandle);
- if (!waiting)
+ if (! waiting)
return NULL;
waiting->cb = cb;
@@ -140,34 +147,35 @@ GNUNET_wait_barrier (struct GNUNET_BarrierHandle *barrier,
waiting->next = NULL;
waiting->barrier = barrier;
- GNUNET_CONTAINER_DLL_insert_tail(barrier->head, barrier->tail, waiting);
+ GNUNET_CONTAINER_DLL_insert_tail (barrier->head, barrier->tail, waiting);
barrier->requirement--;
- if ((barrier->requirement == 0) && (!barrier->task))
- barrier->task = GNUNET_SCHEDULER_add_now(complete_barrier, barrier);
+ if ((barrier->requirement == 0) && (! barrier->task))
+ barrier->task = GNUNET_SCHEDULER_add_now (complete_barrier, barrier);
return waiting;
}
+
void
GNUNET_cancel_wait_barrier (struct GNUNET_BarrierWaitHandle *waiting)
{
- if (!waiting)
+ if (! waiting)
return;
struct GNUNET_BarrierHandle *barrier = waiting->barrier;
- if (!barrier)
+ if (! barrier)
return;
if ((barrier->requirement == 0) && (barrier->task))
{
- GNUNET_SCHEDULER_cancel(barrier->task);
+ GNUNET_SCHEDULER_cancel (barrier->task);
barrier->task = NULL;
}
barrier->requirement++;
- GNUNET_CONTAINER_DLL_remove(barrier->head, barrier->tail, waiting);
+ GNUNET_CONTAINER_DLL_remove (barrier->head, barrier->tail, waiting);
- GNUNET_free(waiting);
+ GNUNET_free (waiting);
}
diff --git a/src/messenger/testing_messenger_setup.c
b/src/messenger/testing_messenger_setup.c
index 29db25bd8..e4dfa203f 100644
--- a/src/messenger/testing_messenger_setup.c
+++ b/src/messenger/testing_messenger_setup.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2020--2021 GNUnet e.V.
+ Copyright (C) 2020--2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -39,7 +39,8 @@
struct test_properties;
-struct test_peer {
+struct test_peer
+{
struct test_properties *props;
unsigned int num;
@@ -58,7 +59,8 @@ struct test_peer {
const char *message;
};
-struct test_properties {
+struct test_properties
+{
const struct test_configuration *cfg;
unsigned int num_hosts;
@@ -83,10 +85,10 @@ shutdown_cb (void *cls)
{
struct test_peer *peer = &properties->peers[i];
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
if (peer->op_task)
- GNUNET_SCHEDULER_cancel(peer->op_task);
+ GNUNET_SCHEDULER_cancel (peer->op_task);
peer->op_task = NULL;
@@ -96,7 +98,7 @@ shutdown_cb (void *cls)
peer->op = NULL;
if (peer->wait)
- GNUNET_cancel_wait_barrier(peer->wait);
+ GNUNET_cancel_wait_barrier (peer->wait);
peer->wait = NULL;
@@ -115,23 +117,24 @@ shutdown_cb (void *cls)
}
if (properties->die_task)
- GNUNET_SCHEDULER_cancel(properties->die_task);
+ GNUNET_SCHEDULER_cancel (properties->die_task);
properties->die_task = NULL;
properties->end_task = NULL;
if (properties->barrier)
- GNUNET_cancel_barrier(properties->barrier);
+ GNUNET_cancel_barrier (properties->barrier);
properties->barrier = NULL;
}
+
static void
end_cb (void *cls)
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
properties->die_task = NULL;
@@ -141,15 +144,17 @@ end_cb (void *cls)
{
struct test_peer *peer = &properties->peers[i];
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
- const int members = GNUNET_MESSENGER_iterate_members(peer->room, NULL,
NULL);
+ const int members = GNUNET_MESSENGER_iterate_members (peer->room, NULL,
+ NULL);
GNUNET_assert (members >= 0);
if (peer->props->num_peer != (unsigned int) members)
{
- fprintf (stderr, "Testcase failed (members: %d/%u).\n", members,
peer->props->num_peer);
+ fprintf (stderr, "Testcase failed (members: %d/%u).\n", members,
+ peer->props->num_peer);
status = 1;
break;
}
@@ -160,12 +165,13 @@ end_cb (void *cls)
properties->status = status;
}
+
static void
end_badly_cb (void *cls)
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
fprintf (stderr, "Testcase failed (timeout).\n");
@@ -174,12 +180,13 @@ end_badly_cb (void *cls)
properties->status = 1;
}
+
static void
end_operation_cb (void *cls)
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
peer->op_task = NULL;
@@ -188,12 +195,13 @@ end_operation_cb (void *cls)
GNUNET_SCHEDULER_shutdown ();
}
+
static void
end_error_cb (void *cls)
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
peer->op_task = NULL;
@@ -203,6 +211,7 @@ end_error_cb (void *cls)
GNUNET_SCHEDULER_shutdown ();
}
+
static void
barrier2_wait_cb (void *cls,
struct GNUNET_BarrierWaitHandle *waiting,
@@ -210,12 +219,13 @@ barrier2_wait_cb (void *cls,
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
if (peer->wait == waiting)
peer->wait = NULL;
}
+
static void
barrier_wait_cb (void *cls,
struct GNUNET_BarrierWaitHandle *waiting,
@@ -223,7 +233,7 @@ barrier_wait_cb (void *cls,
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
if (peer->wait == waiting)
peer->wait = NULL;
@@ -233,7 +243,8 @@ barrier_wait_cb (void *cls,
unsigned int door = peer->props->cfg->doors[peer->num - 1];
if (door == 0)
- door = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
peer->props->cfg->count);
+ door = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ peer->props->cfg->count);
else
door = door - 1;
@@ -241,17 +252,20 @@ barrier_wait_cb (void *cls,
GNUNET_CRYPTO_hash (TEST_ROOM, sizeof(TEST_ROOM), &hash);
struct GNUNET_MESSENGER_Room *room;
- room = GNUNET_MESSENGER_enter_room(peer->handle,
&(peer->props->peers[door].peer_id), &hash);
+ room = GNUNET_MESSENGER_enter_room (peer->handle,
+ &(peer->props->peers[door].peer_id),
+ &hash);
if (peer->room)
- GNUNET_assert(room == peer->room);
+ GNUNET_assert (room == peer->room);
else
- GNUNET_assert(room != NULL);
+ GNUNET_assert (room != NULL);
peer->room = room;
}
}
+
/**
* Function called whenever a message is received or sent.
*
@@ -272,44 +286,48 @@ on_message (void *cls,
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
fprintf (stderr, "Peer: %s; [%s] Message: %s (%s)\n",
- GNUNET_i2s(&(peer->peer_id)),
- GNUNET_sh2s(&(message->header.sender_id)),
- GNUNET_MESSENGER_name_of_kind(message->header.kind),
- GNUNET_h2s(hash));
+ GNUNET_i2s (&(peer->peer_id)),
+ GNUNET_sh2s (&(message->header.sender_id)),
+ GNUNET_MESSENGER_name_of_kind (message->header.kind),
+ GNUNET_h2s (hash));
if (GNUNET_MESSENGER_KIND_PEER == message->header.kind)
- GNUNET_CONTAINER_multipeermap_put (peer->map, &(message->body.peer.peer),
NULL,
+ GNUNET_CONTAINER_multipeermap_put (peer->map, &(message->body.peer.peer),
+ NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
- const int members = GNUNET_MESSENGER_iterate_members(peer->room, NULL, NULL);
+ const int members = GNUNET_MESSENGER_iterate_members (peer->room, NULL,
NULL);
const uint32_t num_peers = GNUNET_CONTAINER_multipeermap_size (peer->map);
- if ((members == peer->props->num_peer) && (peer->props->num_hosts ==
num_peers))
- peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier2_wait_cb,
peer);
+ if ((members == peer->props->num_peer) && (peer->props->num_hosts ==
+ num_peers))
+ peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier2_wait_cb,
+ peer);
else if (peer->props->num_hosts < num_peers)
{
if (peer->wait)
- GNUNET_cancel_wait_barrier(peer->wait);
+ GNUNET_cancel_wait_barrier (peer->wait);
peer->wait = NULL;
if (peer->op_task)
- GNUNET_SCHEDULER_cancel(peer->op_task);
+ GNUNET_SCHEDULER_cancel (peer->op_task);
peer->message = "peer";
peer->op_task = GNUNET_SCHEDULER_add_now (&end_operation_cb, peer);
}
}
+
static void
second_stage (void *cls)
{
struct test_peer *peer = cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
peer->op_task = NULL;
@@ -322,9 +340,9 @@ second_stage (void *cls)
room = GNUNET_MESSENGER_open_room (peer->handle, &hash);
if (peer->room)
- GNUNET_assert(room == peer->room);
+ GNUNET_assert (room == peer->room);
else
- GNUNET_assert(room != NULL);
+ GNUNET_assert (room != NULL);
peer->room = room;
}
@@ -334,22 +352,26 @@ second_stage (void *cls)
unsigned int door = peer->props->cfg->doors[peer->num - 1];
if (door == 0)
- door = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
peer->props->cfg->count);
+ door = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ peer->props->cfg->count);
else
door = door - 1;
struct GNUNET_MESSENGER_Room *room;
- room = GNUNET_MESSENGER_enter_room(peer->handle,
&(peer->props->peers[door].peer_id), &hash);
+ room = GNUNET_MESSENGER_enter_room (peer->handle,
+ &(peer->props->peers[door].peer_id),
+ &hash);
if (peer->room)
- GNUNET_assert(room == peer->room);
+ GNUNET_assert (room == peer->room);
else
- GNUNET_assert(room != NULL);
+ GNUNET_assert (room != NULL);
peer->room = room;
}
}
+
static void
on_peer (void *cb_cls,
struct GNUNET_TESTBED_Operation *op,
@@ -358,16 +380,16 @@ on_peer (void *cb_cls,
{
struct test_peer *peer = cb_cls;
- GNUNET_assert(peer != NULL);
+ GNUNET_assert (peer != NULL);
if (emsg)
{
- peer->message = GNUNET_strdup(emsg);
+ peer->message = GNUNET_strdup (emsg);
peer->op_task = GNUNET_SCHEDULER_add_now (&end_error_cb, peer);
return;
}
- if (!pinfo)
+ if (! pinfo)
{
peer->message = "info";
peer->op_task = GNUNET_SCHEDULER_add_now (&end_operation_cb, peer);
@@ -381,11 +403,12 @@ on_peer (void *cb_cls,
return;
}
- peer->handle = GNUNET_MESSENGER_connect (pinfo->result.cfg, TEST_NAME, NULL,
&on_message, peer);
+ peer->handle = GNUNET_MESSENGER_connect (pinfo->result.cfg, TEST_NAME, NULL,
+ &on_message, peer);
- GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_get_peer_identity(
- pinfo->result.cfg, &(peer->peer_id)
- ));
+ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (
+ pinfo->result.cfg, &(peer->peer_id)
+ ));
if (0 != (peer->props->cfg->stages[peer->num - 1] & 0x01))
{
@@ -394,14 +417,16 @@ on_peer (void *cb_cls,
peer->room = GNUNET_MESSENGER_open_room (peer->handle, &hash);
- GNUNET_assert(peer->room != NULL);
+ GNUNET_assert (peer->room != NULL);
}
else
peer->room = NULL;
- peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier_wait_cb,
peer);
+ peer->wait = GNUNET_wait_barrier (peer->props->barrier, &barrier_wait_cb,
+ peer);
}
+
/**
* Main function for a peer of the testcase.
*
@@ -414,7 +439,7 @@ run (void *cls,
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
if (GNUNET_TESTBED_ET_PEER_START != event->type)
{
@@ -430,11 +455,15 @@ run (void *cls,
peer->num = properties->num_peer;
peer->peer = event->details.peer_start.peer;
- peer->op = GNUNET_TESTBED_peer_get_information (peer->peer,
GNUNET_TESTBED_PIT_CONFIGURATION, on_peer, peer);
+ peer->op = GNUNET_TESTBED_peer_get_information (peer->peer,
+
GNUNET_TESTBED_PIT_CONFIGURATION,
+ on_peer, peer);
- peer->map = GNUNET_CONTAINER_multipeermap_create(peer->props->num_hosts,
GNUNET_NO);
+ peer->map = GNUNET_CONTAINER_multipeermap_create (peer->props->num_hosts,
+ GNUNET_NO);
}
+
static void
barrier2_cb (void *cls,
struct GNUNET_BarrierHandle *barrier,
@@ -442,7 +471,7 @@ barrier2_cb (void *cls,
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
if (properties->barrier == barrier)
properties->barrier = NULL;
@@ -457,15 +486,17 @@ barrier2_cb (void *cls,
else if (GNUNET_OK == status)
{
if (properties->die_task)
- GNUNET_SCHEDULER_cancel(properties->die_task);
+ GNUNET_SCHEDULER_cancel (properties->die_task);
properties->die_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
properties->cfg->count),
- &end_cb, properties
- );
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+ properties->cfg->count),
+ &end_cb, properties
+ );
}
}
+
static void
barrier_cb (void *cls,
struct GNUNET_BarrierHandle *barrier,
@@ -473,11 +504,11 @@ barrier_cb (void *cls,
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
if (properties->barrier == barrier)
properties->barrier = NULL;
- else if (!properties->barrier)
+ else if (! properties->barrier)
return;
if (properties->num_peer != properties->cfg->count)
@@ -497,13 +528,17 @@ barrier_cb (void *cls,
}
else if (GNUNET_OK == status)
{
- properties->barrier = GNUNET_init_barrier (properties->num_peer,
&barrier2_cb, properties);
+ properties->barrier = GNUNET_init_barrier (properties->num_peer,
+ &barrier2_cb, properties);
for (unsigned int i = 0; i < properties->num_peer; i++)
- properties->peers[i].op_task = GNUNET_SCHEDULER_add_now (&second_stage,
&(properties->peers[i]));
+ properties->peers[i].op_task = GNUNET_SCHEDULER_add_now (&second_stage,
+ &(properties->
+ peers[i]));
}
}
+
static void
init (void *cls,
struct GNUNET_TESTBED_RunHandle *h,
@@ -514,40 +549,46 @@ init (void *cls,
{
struct test_properties *properties = cls;
- GNUNET_assert(properties != NULL);
+ GNUNET_assert (properties != NULL);
- properties->end_task = GNUNET_SCHEDULER_add_shutdown(&shutdown_cb,
properties);
+ properties->end_task = GNUNET_SCHEDULER_add_shutdown (&shutdown_cb,
+ properties);
properties->die_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
properties->cfg->count * 5),
- &end_badly_cb, properties
- );
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+ properties->cfg->count * 5),
+ &end_badly_cb, properties
+ );
}
+
int
-GNUNET_run_messenger_setup (const char* test_name,
+GNUNET_run_messenger_setup (const char *test_name,
const struct test_configuration *cfg)
{
struct test_properties properties;
- memset(&properties, 0, sizeof(properties));
+ memset (&properties, 0, sizeof(properties));
properties.cfg = cfg;
- properties.peers = GNUNET_new_array(cfg->count, struct test_peer);
+ properties.peers = GNUNET_new_array (cfg->count, struct test_peer);
for (unsigned int i = 0; i < cfg->count; i++)
if (0 != (cfg->stages[i] & 0x11))
properties.num_hosts++;
properties.status = 1;
- properties.barrier = GNUNET_init_barrier (cfg->count, &barrier_cb,
&properties);
+ properties.barrier = GNUNET_init_barrier (cfg->count, &barrier_cb,
+ &properties);
- if (GNUNET_OK != GNUNET_TESTBED_test_run (test_name,
"test_messenger_api.conf",
+ if (GNUNET_OK != GNUNET_TESTBED_test_run (test_name,
+ "test_messenger_api.conf",
cfg->count,
- (1LL <<
GNUNET_TESTBED_ET_PEER_START),
+ (1LL <<
+ GNUNET_TESTBED_ET_PEER_START),
&run, &properties,
&init, &properties))
return 1;
- GNUNET_free(properties.peers);
+ GNUNET_free (properties.peers);
return properties.status;
}
diff --git a/src/messenger/testing_messenger_setup.h
b/src/messenger/testing_messenger_setup.h
index e5ae0c151..d2e72b51f 100644
--- a/src/messenger/testing_messenger_setup.h
+++ b/src/messenger/testing_messenger_setup.h
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2021 GNUnet e.V.
+ Copyright (C) 2021, 2023 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
@@ -34,7 +34,7 @@ struct test_configuration
};
int
-GNUNET_run_messenger_setup (const char* test_name,
+GNUNET_run_messenger_setup (const char *test_name,
const struct test_configuration *cfg);
#endif /* GNUNET_TESTING_MESSENGER_SETUP_H_ */
--
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.
- [gnunet] branch master updated (8e8c3f1e1 -> b8672206e), gnunet, 2023/11/14
- [gnunet] 04/06: -minor additional cleanup, gnunet, 2023/11/14
- [gnunet] 02/06: MESSENGER: Fix remaining test failure, gnunet, 2023/11/14
- [gnunet] 05/06: MESSENGER: Reduce priority of enqueued messages to start with initial join message, gnunet, 2023/11/14
- [gnunet] 03/06: MESSENGER: Uncrustify code,
gnunet <=
- [gnunet] 01/06: MESSENGER: Separate peer and member signed messages, gnunet, 2023/11/14
- [gnunet] 06/06: Merge branch 'master' of ssh://git.gnunet.org/gnunet, gnunet, 2023/11/14