GNUnet 0.21.2
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 <stdio.h>
27#include <unistd.h>
28
31#include "gnunet_util_lib.h"
32
35
36uint64_t waiting;
37
40
46static void
47delay_shutdown (void *cls)
48{
49 read_task = NULL;
50
51 if (waiting)
52 return;
53
55}
56
57static void
58idle (void *cls);
59
70void
71on_message (void *cls,
72 struct GNUNET_MESSENGER_Room *room,
73 const struct GNUNET_MESSENGER_Contact *sender,
74 const struct GNUNET_MESSENGER_Contact *recipient,
75 const struct GNUNET_MESSENGER_Message *message,
76 const struct GNUNET_HashCode *hash,
78{
79 const uint64_t waited = waiting;
80
81 if (GNUNET_YES == talk_mode)
82 {
84 {
86 {
87 waiting = waiting > message->body.talk.length?
88 waiting - message->body.talk.length : 0;
89 }
90 else
91 {
92 write (1, message->body.talk.data, message->body.talk.length);
93 fflush (stdout);
94 }
95 }
96
97 goto skip_printing;
98 }
99
100 const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
101 const char *recipient_name = GNUNET_MESSENGER_contact_get_name (recipient);
102
103 if (! sender_name)
104 sender_name = "anonymous";
105
106 if (! recipient_name)
107 recipient_name = "anonymous";
108
109 printf ("[%s ->", GNUNET_h2s (&(message->header.previous)));
110 printf (" %s]", GNUNET_h2s (hash));
111 printf ("[%s] ", GNUNET_sh2s (&(message->header.sender_id)));
112
114 printf ("*( '%s' ) ", recipient_name);
115
116 switch (message->header.kind)
117 {
119 {
120 printf ("* '%s' joined the room!\n", sender_name);
121 break;
122 }
124 {
125 printf ("* '%s' gets renamed to '%s'\n", sender_name,
126 message->body.name.name);
127 break;
128 }
130 {
131 printf ("* '%s' leaves the room!\n", sender_name);
132 break;
133 }
135 {
136 printf ("* '%s' opened the room on: %s\n", sender_name,
137 GNUNET_i2s_full (&(message->body.peer.peer)));
138 break;
139 }
141 {
142 const uint16_t len = strlen (message->body.text.text) + 1;
143
144 if (flags & GNUNET_MESSENGER_FLAG_SENT)
145 {
146 waiting = waiting > len? waiting - len : 0;
147
148 printf (">");
149 }
150 else
151 printf ("<");
152
153 printf (" '%s' says: \"%s\"\n", sender_name,
154 message->body.text.text);
155 break;
156 }
158 {
159 if (flags & GNUNET_MESSENGER_FLAG_SENT)
160 printf (">");
161 else
162 printf ("<");
163
164 printf(" '%s' shares: \"%s\"\n%s\n", sender_name,
165 message->body.file.name, message->body.file.uri);
166 break;
167 }
168 default:
169 {
170 printf ("~ message: %s\n",
172 break;
173 }
174 }
175
176skip_printing:
177 if ((! read_task) && (! waiting) && (waited))
180 delay_shutdown, NULL);
181
182 if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) &&
184 {
185 if (! read_task)
188 idle, room);
189
191
192 if (! name)
193 return;
194
197 response.body.name.name = GNUNET_strdup (name);
198
200
201 GNUNET_free (response.body.name.name);
202
203 if (GNUNET_YES != talk_mode)
204 return;
205
208 response.body.subscribe.time =
210
211 memset(&(response.body.subscribe.discourse), 0,
212 sizeof(response.body.subscribe.discourse));
213
215 }
216}
217
218
220
226static void
227shutdown_hook (void *cls)
228{
229 struct GNUNET_MESSENGER_Room *room = cls;
230
231 if (read_task)
233
234 if (room)
236
237 if (messenger)
239
240 if (ego_lookup)
242}
243
244
245static void
246listen_stdio (void *cls);
247
248#define MAX_BUFFER_SIZE 57345
249
250static int
252 struct GNUNET_MESSENGER_Room *room,
253 const struct GNUNET_MESSENGER_Contact *contact)
254{
255 struct GNUNET_MESSENGER_Message *message = cls;
256
258 GNUNET_MESSENGER_send_message (room, message, contact);
259
260 return GNUNET_YES;
261}
262
263
265
271static void
272read_stdio (void *cls)
273{
274 struct GNUNET_MESSENGER_Room *room = cls;
275 struct GNUNET_MESSENGER_Message message;
276
277 read_task = NULL;
278
279 char buffer[MAX_BUFFER_SIZE];
280 ssize_t length;
281
282 length = read (0, buffer, MAX_BUFFER_SIZE - 1);
283
284 if ((length <= 0) || (length >= MAX_BUFFER_SIZE))
285 {
286 delay_shutdown (NULL);
287 return;
288 }
289
290 waiting += length;
291
292 if (GNUNET_YES == talk_mode)
293 {
295 message.body.talk.length = length;
296 message.body.talk.data = buffer;
297
298 memset(&(message.body.talk.discourse), 0,
299 sizeof(message.body.talk.discourse));
300 }
301 else
302 {
303 if (buffer[length - 1] == '\n')
304 buffer[length - 1] = '\0';
305 else
306 buffer[length] = '\0';
307
309 message.body.text.text = buffer;
310 }
311
314 &message);
315 else
316 GNUNET_MESSENGER_send_message (room, &message, NULL);
317
319}
320
321
327static void
328listen_stdio (void *cls)
329{
330 read_task = NULL;
331
333
335
338 NULL, &read_stdio, cls);
339
341}
342
343
349static void
350idle (void *cls)
351{
352 struct GNUNET_MESSENGER_Room *room = cls;
353
354 if (GNUNET_YES != talk_mode)
355 printf ("* You joined the room.\n");
356
358}
359
360
364
366
373static void
374on_identity (void *cls,
376{
377 struct GNUNET_HashCode key;
378 memset (&key, 0, sizeof(key));
379
380 if (room_key)
382
383 struct GNUNET_PeerIdentity door_peer;
384 struct GNUNET_PeerIdentity *door = NULL;
385
386 if ((door_id) &&
388 strlen (
389 door_id),
390 &(door_peer.
391 public_key))))
392 door = &door_peer;
393
394 struct GNUNET_MESSENGER_Room *room;
395
396 if (GNUNET_YES == talk_mode)
397 goto skip_welcome;
398
399 const char *name = GNUNET_MESSENGER_get_name (handle);
400
401 if (! name)
402 name = "anonymous";
403
404 printf ("* Welcome to the messenger, '%s'!\n", name);
405
406skip_welcome:
407 if (door)
408 {
409 if (GNUNET_YES != talk_mode)
410 printf ("* You try to entry a room...\n");
411
413 }
414 else
415 {
416 if (GNUNET_YES != talk_mode)
417 printf ("* You try to open a room...\n");
418
420 }
421
423
425
426 waiting = 0;
427
428 if (! room)
430 else
431 read_task = NULL;
432}
433
434
435static void
436on_ego_lookup (void *cls,
437 struct GNUNET_IDENTITY_Ego *ego)
438{
439 ego_lookup = NULL;
440
441 const struct GNUNET_CRYPTO_PrivateKey *key;
442 key = ego ? GNUNET_IDENTITY_ego_get_private_key (ego) : NULL;
443
445 NULL);
446
447 on_identity (NULL, messenger);
448}
449
450
459static void
460run (void *cls,
461 char *const *args,
462 const char *cfgfile,
463 const struct GNUNET_CONFIGURATION_Handle *cfg)
464{
465 config = cfg;
466
467 if (ego_name)
468 {
470 NULL);
471 messenger = NULL;
472 }
473 else
474 {
475 ego_lookup = NULL;
476 messenger = GNUNET_MESSENGER_connect (cfg, NULL, NULL, &on_message, NULL);
477 }
478
480
481 if (messenger)
482 on_identity (NULL, messenger);
483}
484
485
493int
494main (int argc,
495 char **argv)
496{
497 const char *description =
498 "Open and connect to rooms using the MESSENGER to chat.";
499
501 GNUNET_GETOPT_option_string ('d', "door", "PEERIDENTITY",
502 "peer identity to entry into the room",
503 &door_id),
504 GNUNET_GETOPT_option_string ('e', "ego", "IDENTITY",
505 "identity to use for messaging",
506 &ego_name),
507 GNUNET_GETOPT_option_string ('r', "room", "ROOMKEY",
508 "key of the room to connect to",
509 &room_key),
510 GNUNET_GETOPT_option_flag ('p', "private", "flag to enable private mode",
511 &private_mode),
512 GNUNET_GETOPT_option_flag ('t', "talk", "flag to enable talk mode",
513 &talk_mode),
515 };
516
517 return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-messenger\0",
519 &run,
520 NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
521}
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:74
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.
static void delay_shutdown(void *cls)
Delay forced shutdown by input to wait for data processing.
int talk_mode
uint64_t waiting
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
Identity service; implements identity management for GNUnet.
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:43
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_FILE
The file kind.
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_SUBSCRIBE
The subscribe kind.
@ GNUNET_MESSENGER_KIND_TALK
The talk 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.
@ GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE
The keep alive 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:567
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:1836
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:1340
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
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:1305
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1232
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_second_(void)
Return relative time of 1s.
Definition: time.c:169
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:618
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_MessageTalk talk
struct GNUNET_MESSENGER_MessageFile file
struct GNUNET_MESSENGER_MessagePeer peer
char * uri
The uri of the encrypted file.
char name[NAME_MAX]
The name of the original file.
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.
uint16_t length
The length of the talk message data.
char * data
The data of the talk message.
struct GNUNET_ShortHashCode discourse
The hash of the discourse to talk.
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