GNUnet 0.21.0
gnunet-messenger.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2020--2024 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
26#include "platform.h"
27#include <stdio.h>
28
29#include "gnunet_util_lib.h"
31
34
45void
46on_message (void *cls,
47 struct GNUNET_MESSENGER_Room *room,
48 const struct GNUNET_MESSENGER_Contact *sender,
49 const struct GNUNET_MESSENGER_Contact *recipient,
50 const struct GNUNET_MESSENGER_Message *message,
51 const struct GNUNET_HashCode *hash,
53{
54 const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
55 const char *recipient_name = GNUNET_MESSENGER_contact_get_name (recipient);
56
57 if (! sender_name)
58 sender_name = "anonymous";
59
60 if (! recipient_name)
61 recipient_name = "anonymous";
62
63 printf ("[%s ->", GNUNET_h2s (&(message->header.previous)));
64 printf (" %s]", GNUNET_h2s (hash));
65 printf ("[%s] ", GNUNET_sh2s (&(message->header.sender_id)));
66
68 printf ("*( '%s' ) ", recipient_name);
69
70 switch (message->header.kind)
71 {
73 {
74 printf ("* '%s' joined the room!\n", sender_name);
75 break;
76 }
78 {
79 printf ("* '%s' gets renamed to '%s'\n", sender_name,
80 message->body.name.name);
81 break;
82 }
84 {
85 printf ("* '%s' leaves the room!\n", sender_name);
86 break;
87 }
89 {
90 printf ("* '%s' opened the room on: %s\n", sender_name,
91 GNUNET_i2s_full (&(message->body.peer.peer)));
92 break;
93 }
95 {
97 printf (">");
98 else
99 printf ("<");
100
101 printf (" '%s' says: \"%s\"\n", sender_name, message->body.text.text);
102 break;
103 }
104 default:
105 {
106 printf ("~ message: %s\n",
108 break;
109 }
110 }
111
112 if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) &&
114 {
116
117 if (! name)
118 return;
119
122 response.body.name.name = GNUNET_strdup (name);
123
125
126 GNUNET_free (response.body.name.name);
127 }
128}
129
130
133
139static void
140shutdown_hook (void *cls)
141{
142 struct GNUNET_MESSENGER_Room *room = cls;
143
144 if (read_task)
146
147 if (room)
149
150 if (messenger)
152
153 if (ego_lookup)
155}
156
157
158static void
159listen_stdio (void *cls);
160
161#define MAX_BUFFER_SIZE 60000
162
163static int
165 struct GNUNET_MESSENGER_Room *room,
166 const struct GNUNET_MESSENGER_Contact *contact)
167{
168 struct GNUNET_MESSENGER_Message *message = cls;
169
171 GNUNET_MESSENGER_send_message (room, message, contact);
172
173 return GNUNET_YES;
174}
175
176
178
184static void
185read_stdio (void *cls)
186{
187 read_task = NULL;
188
189 char buffer[MAX_BUFFER_SIZE];
190 ssize_t length;
191
192 length = read (0, buffer, MAX_BUFFER_SIZE);
193
194 if ((length <= 0) || (length >= MAX_BUFFER_SIZE))
195 {
197 return;
198 }
199
200 if (buffer[length - 1] == '\n')
201 buffer[length - 1] = '\0';
202 else
203 buffer[length] = '\0';
204
205 struct GNUNET_MESSENGER_Room *room = cls;
206
207 struct GNUNET_MESSENGER_Message message;
209 message.body.text.text = buffer;
210
213 &message);
214 else
215 GNUNET_MESSENGER_send_message (room, &message, NULL);
216
218}
219
220
226static void
227listen_stdio (void *cls)
228{
229 read_task = NULL;
230
232
234
237 NULL, &read_stdio, cls);
238
240}
241
242
248static void
249idle (void *cls)
250{
251 struct GNUNET_MESSENGER_Room *room = cls;
252
253 printf ("* You joined the room.\n");
254
256}
257
258
262
264
271static void
272on_identity (void *cls,
274{
275 struct GNUNET_HashCode key;
276 memset (&key, 0, sizeof(key));
277
278 if (room_key)
280
281 struct GNUNET_PeerIdentity door_peer;
282 struct GNUNET_PeerIdentity *door = NULL;
283
284 if ((door_id) &&
286 strlen (
287 door_id),
288 &(door_peer.
289 public_key))))
290 door = &door_peer;
291
292 const char *name = GNUNET_MESSENGER_get_name (handle);
293
294 if (! name)
295 name = "anonymous";
296
297 printf ("* Welcome to the messenger, '%s'!\n", name);
298
299 struct GNUNET_MESSENGER_Room *room;
300
301 if (door)
302 {
303 printf ("* You try to entry a room...\n");
304
306 }
307 else
308 {
309 printf ("* You try to open a room...\n");
310
312 }
313
315
317
318 if (! room)
320 else
321 {
325 idle, room);
326 }
327}
328
329
330static void
331on_ego_lookup (void *cls,
332 struct GNUNET_IDENTITY_Ego *ego)
333{
334 ego_lookup = NULL;
335
336 const struct GNUNET_CRYPTO_PrivateKey *key;
337 key = ego ? GNUNET_IDENTITY_ego_get_private_key (ego) : NULL;
338
340 NULL);
341
342 on_identity (NULL, messenger);
343}
344
345
354static void
355run (void *cls,
356 char *const *args,
357 const char *cfgfile,
358 const struct GNUNET_CONFIGURATION_Handle *cfg)
359{
360 config = cfg;
361
362 if (ego_name)
363 {
365 NULL);
366 messenger = NULL;
367 }
368 else
369 {
370 ego_lookup = NULL;
371 messenger = GNUNET_MESSENGER_connect (cfg, NULL, NULL, &on_message, NULL);
372 }
373
375
376 if (messenger)
377 on_identity (NULL, messenger);
378}
379
380
388int
389main (int argc,
390 char **argv)
391{
392 const char *description =
393 "Open and connect to rooms using the MESSENGER to chat.";
394
396 GNUNET_GETOPT_option_string ('d', "door", "PEERIDENTITY",
397 "peer identity to entry into the room",
398 &door_id),
399 GNUNET_GETOPT_option_string ('e', "ego", "IDENTITY",
400 "identity to use for messaging",
401 &ego_name),
402 GNUNET_GETOPT_option_string ('r', "room", "ROOMKEY",
403 "key of the room to connect to",
404 &room_key),
405 GNUNET_GETOPT_option_flag ('p', "private", "flag to enable private mode",
406 &private_mode),
408 };
409
410 return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-messenger\0",
412 &run,
413 NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
414}
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:70
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static struct MHD_Response * response
Our canonical response.
struct GNUNET_HashCode key
The key used in the DHT.
static void on_identity(void *cls, struct GNUNET_MESSENGER_Handle *handle)
Function called when an identity is retrieved.
static void listen_stdio(void *cls)
Wait for input on STDIO and send it out over the ch.
int main(int argc, char **argv)
The main function to obtain messenger information.
static void idle(void *cls)
Initial task to startup application.
static void read_stdio(void *cls)
Task run in stdio mode, after some data is available at stdin.
struct GNUNET_MESSENGER_Handle * messenger
void on_message(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Contact *recipient, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_MessageFlags flags)
Function called whenever a message is received or sent.
char * door_id
char * ego_name
struct GNUNET_IDENTITY_EgoLookup * ego_lookup
struct GNUNET_SCHEDULER_Task * read_task
int private_mode
const struct GNUNET_CONFIGURATION_Handle * config
static int iterate_send_private_message(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
struct GNUNET_SCHEDULER_Task * shutdown_task
char * room_key
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run by the scheduler.
#define MAX_BUFFER_SIZE
static void on_ego_lookup(void *cls, struct GNUNET_IDENTITY_Ego *ego)
static void shutdown_hook(void *cls)
Task to shut down this application.
static char * name
Name (label) of the records to list.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
const struct GNUNET_CRYPTO_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:517
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
void GNUNET_IDENTITY_ego_lookup_cancel(struct GNUNET_IDENTITY_EgoLookup *el)
Abort ego lookup attempt.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:358
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_SCHEDULER_PRIORITY_DEFAULT
Run with the default priority (normal P2P operations).
@ GNUNET_OK
@ GNUNET_YES
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_open_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Open a room to send and receive messages.
int GNUNET_MESSENGER_iterate_members(struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
Iterates through all members of a given room and calls a selected callback for each of them with a pr...
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:42
GNUNET_MESSENGER_MessageFlags
Enum for the different supported flags used by message handling.
const char * GNUNET_MESSENGER_contact_get_name(const struct GNUNET_MESSENGER_Contact *contact)
Get the name used by the contact.
struct GNUNET_MESSENGER_Handle * GNUNET_MESSENGER_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, const struct GNUNET_CRYPTO_PrivateKey *key, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
Set up a handle for the messenger related functions and connects to all necessary services.
struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_enter_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Enter a room to send and receive messages through a door opened using GNUNET_MESSENGER_open_room.
const struct GNUNET_CRYPTO_PublicKey * GNUNET_MESSENGER_contact_get_key(const struct GNUNET_MESSENGER_Contact *contact)
Get the public key used by the contact or NULL if the anonymous key was used.
void GNUNET_MESSENGER_disconnect(struct GNUNET_MESSENGER_Handle *handle)
Disconnect all of the messengers used services and clears up its used memory.
const char * GNUNET_MESSENGER_get_name(const struct GNUNET_MESSENGER_Handle *handle)
Get the name (if specified, otherwise NULL) used by the messenger.
void GNUNET_MESSENGER_close_room(struct GNUNET_MESSENGER_Room *room)
Close a room which was entered, opened or both in various order and variety.
void GNUNET_MESSENGER_send_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_Contact *contact)
Send a message into a room.
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
@ GNUNET_MESSENGER_KIND_TEXT
The text kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1186
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1170
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1057
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1830
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1202
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_zero_(void)
Return relative time of 0ms.
Definition: time.c:133
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
A private key for an identity as per LSD0001.
Definition of a command line option.
const char * description
Help text for the option (description)
A 512-bit hashcode.
Handle for ego lookup.
Handle for an ego.
Definition: identity.h:37
struct GNUNET_MESSENGER_MessageText text
struct GNUNET_MESSENGER_MessageName name
struct GNUNET_MESSENGER_MessagePeer peer
struct GNUNET_HashCode previous
The hash of the previous message from the senders perspective.
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
char * name
The new name which replaces the current senders name.
struct GNUNET_PeerIdentity peer
The peer identity of the sender opening a room.
char * text
The containing text.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
collection of IO descriptors
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Entry in list of pending tasks.
Definition: scheduler.c:136