#include "platform.h"
#include <stdio.h>
#include "gnunet_util_lib.h"
#include "gnunet_messenger_service.h"

Include dependency graph for gnunet-messenger.c:

Macros
#define	MAX_BUFFER_SIZE 60000

Functions
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. More...

static void	shutdown_hook (void *cls)
	Task to shut down this application. More...

static void	listen_stdio (void *cls)
	Wait for input on STDIO and send it out over the ch. More...

static int	iterate_send_private_message (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact *contact)

static void	read_stdio (void *cls)
	Task run in stdio mode, after some data is available at stdin. More...

static void	idle (void *cls)
	Initial task to startup application. More...

static void	on_identity (void cls, struct GNUNET_MESSENGER_Handle handle)
	Function called when an identity is retrieved. More...

static void	on_ego_lookup (void cls, struct GNUNET_IDENTITY_Ego ego)

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. More...

int	main (int argc, char **argv)
	The main function to obtain messenger information. More...

Variables
const struct GNUNET_CONFIGURATION_Handle *	config

struct GNUNET_MESSENGER_Handle *	messenger

struct GNUNET_SCHEDULER_Task *	read_task

struct GNUNET_IDENTITY_EgoLookup *	ego_lookup

int	private_mode

char *	door_id

char *	ego_name

char *	room_key

struct GNUNET_SCHEDULER_Task *	shutdown_task

Macro Definition Documentation

◆ MAX_BUFFER_SIZE

#define MAX_BUFFER_SIZE 60000

Definition at line 161 of file gnunet-messenger.c.

Function Documentation

◆ on_message()

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.

Parameters

[in,out]	cls	Closure
[in]	room	Room
[in]	sender	Sender of message
[in]	message	Message
[in]	hash	Hash of message
[in]	flags	Flags of message

Definition at line 46 of file gnunet-messenger.c.

{
  const char *sender_name = GNUNET_MESSENGER_contact_get_name (sender);
  const char *recipient_name = GNUNET_MESSENGER_contact_get_name (recipient);
 
  if (! sender_name)
    sender_name = "anonymous";
 
  if (! recipient_name)
    recipient_name = "anonymous";
 
  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 ("*( '%s' ) ", recipient_name);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    {
      printf ("* '%s' joined the room!\n", sender_name);
      break;
    }
  case GNUNET_MESSENGER_KIND_NAME:
    {
      printf ("* '%s' gets renamed to '%s'\n", sender_name,
              message->body.name.name);
      break;
    }
  case GNUNET_MESSENGER_KIND_LEAVE:
    {
      printf ("* '%s' leaves the room!\n", sender_name);
      break;
    }
  case GNUNET_MESSENGER_KIND_PEER:
    {
      printf ("* '%s' opened the room on: %s\n", sender_name,
              GNUNET_i2s_full (&(message->body.peer.peer)));
      break;
    }
  case GNUNET_MESSENGER_KIND_TEXT:
    {
      if (flags & GNUNET_MESSENGER_FLAG_SENT)
        printf (">");
      else
        printf ("<");
 
      printf (" '%s' says: \"%s\"\n", sender_name, message->body.text.text);
      break;
    }
  default:
    {
      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))
  {
    const char *name = GNUNET_MESSENGER_get_name (messenger);
 
    if (! name)
      return;
 
    struct GNUNET_MESSENGER_Message response;
    response.header.kind = GNUNET_MESSENGER_KIND_NAME;
    response.body.name.name = GNUNET_strdup (name);
 
    GNUNET_MESSENGER_send_message (room, &response, NULL);
 
    GNUNET_free (response.body.name.name);
  }
}

Referenced by on_ego_lookup(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shutdown_hook()

static void shutdown_hook ( void * cls )

static

Task to shut down this application.

Parameters

[in,out] cls Closure

Definition at line 140 of file gnunet-messenger.c.

{
  struct GNUNET_MESSENGER_Room *room = cls;
 
  if (read_task)
    GNUNET_SCHEDULER_cancel (read_task);
 
  if (room)
    GNUNET_MESSENGER_close_room (room);
 
  if (messenger)
    GNUNET_MESSENGER_disconnect (messenger);
 
  if (ego_lookup)
    GNUNET_IDENTITY_ego_lookup_cancel (ego_lookup);
}

References ego_lookup, GNUNET_IDENTITY_ego_lookup_cancel(), GNUNET_MESSENGER_close_room(), GNUNET_MESSENGER_disconnect(), GNUNET_SCHEDULER_cancel(), messenger, and read_task.

Referenced by on_identity(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ listen_stdio()

static void listen_stdio ( void * cls )

static

Wait for input on STDIO and send it out over the ch.

Parameters

[in,out] cls Closure

Definition at line 227 of file gnunet-messenger.c.

{
  read_task = NULL;
 
  struct GNUNET_NETWORK_FDSet *rs = GNUNET_NETWORK_fdset_create ();
 
  GNUNET_NETWORK_fdset_set_native (rs, 0);
 
  read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                           GNUNET_TIME_UNIT_FOREVER_REL, rs,
                                           NULL, &read_stdio, cls);
 
  GNUNET_NETWORK_fdset_destroy (rs);
}

References GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set_native(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, read_stdio(), and read_task.

Referenced by idle(), and read_stdio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_send_private_message()

static int iterate_send_private_message	(	void *	cls,
		struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 164 of file gnunet-messenger.c.

{
  struct GNUNET_MESSENGER_Message *message = cls;
 
  if (GNUNET_MESSENGER_contact_get_key (contact))
    GNUNET_MESSENGER_send_message (room, message, contact);
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_contact_get_key(), GNUNET_MESSENGER_send_message(), and GNUNET_YES.

Referenced by read_stdio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_stdio()

static void read_stdio ( void * cls )

static

Task run in stdio mode, after some data is available at stdin.

Parameters

[in,out] cls Closure

Definition at line 185 of file gnunet-messenger.c.

{
  read_task = NULL;
 
  char buffer[MAX_BUFFER_SIZE];
  ssize_t length;
 
  length = read (0, buffer, MAX_BUFFER_SIZE);
 
  if ((length <= 0) || (length >= MAX_BUFFER_SIZE))
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  if (buffer[length - 1] == '\n')
    buffer[length - 1] = '\0';
  else
    buffer[length] = '\0';
 
  struct GNUNET_MESSENGER_Room *room = cls;
 
  struct GNUNET_MESSENGER_Message message;
  message.header.kind = GNUNET_MESSENGER_KIND_TEXT;
  message.body.text.text = buffer;
 
  if (GNUNET_YES == private_mode)
    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);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_iterate_members(), GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_send_message(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, GNUNET_MESSENGER_Message::header, iterate_send_private_message(), GNUNET_MESSENGER_MessageHeader::kind, listen_stdio(), MAX_BUFFER_SIZE, private_mode, read_task, GNUNET_MESSENGER_MessageText::text, and GNUNET_MESSENGER_MessageBody::text.

Referenced by listen_stdio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ idle()

static void idle ( void * cls )

static

Initial task to startup application.

Parameters

[in,out] cls Closure

Definition at line 249 of file gnunet-messenger.c.

{
  struct GNUNET_MESSENGER_Room *room = cls;
 
  printf ("* You joined the room.\n");
 
  read_task = GNUNET_SCHEDULER_add_now (listen_stdio, room);
}

References GNUNET_SCHEDULER_add_now(), listen_stdio(), and read_task.

Referenced by on_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_identity()

static void on_identity	(	void *	cls,
		struct GNUNET_MESSENGER_Handle *	handle
	)

static

Function called when an identity is retrieved.

Parameters

[in,out]	cls	Closure
[in,out]	handle	Handle of messenger service

Definition at line 272 of file gnunet-messenger.c.

{
  struct GNUNET_HashCode key;
  memset (&key, 0, sizeof(key));
 
  if (room_key)
    GNUNET_CRYPTO_hash (room_key, strlen (room_key), &key);
 
  struct GNUNET_PeerIdentity door_peer;
  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))))
    door = &door_peer;
 
  const char *name = GNUNET_MESSENGER_get_name (handle);
 
  if (! name)
    name = "anonymous";
 
  printf ("* Welcome to the messenger, '%s'!\n", name);
 
  struct GNUNET_MESSENGER_Room *room;
 
  if (door)
  {
    printf ("* You try to entry a room...\n");
 
    room = GNUNET_MESSENGER_enter_room (messenger, door, &key);
  }
  else
  {
    printf ("* You try to open a room...\n");
 
    room = GNUNET_MESSENGER_open_room (messenger, &key);
  }
 
  GNUNET_SCHEDULER_cancel (shutdown_task);
 
  shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, room);
 
  if (! room)
    GNUNET_SCHEDULER_shutdown ();
  else
  {
    GNUNET_SCHEDULER_add_delayed_with_priority (
      GNUNET_TIME_relative_get_zero_ (),
      GNUNET_SCHEDULER_PRIORITY_IDLE,
      idle, room);
  }
}

References door_id, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_MESSENGER_enter_room(), GNUNET_MESSENGER_get_name(), GNUNET_MESSENGER_open_room(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_relative_get_zero_(), handle, idle(), key, messenger, name, GNUNET_PeerIdentity::public_key, room_key, shutdown_hook(), and shutdown_task.

Referenced by on_ego_lookup(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_ego_lookup()

static void on_ego_lookup	(	void *	cls,
		struct GNUNET_IDENTITY_Ego *	ego
	)

static

Definition at line 331 of file gnunet-messenger.c.

{
  ego_lookup = NULL;
 
  const struct GNUNET_CRYPTO_PrivateKey *key;
  key = ego ? GNUNET_IDENTITY_ego_get_private_key (ego) : NULL;
 
  messenger = GNUNET_MESSENGER_connect (config, ego_name, key, &on_message,
                                        NULL);
 
  on_identity (NULL, messenger);
}

References config, ego_lookup, ego_name, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_MESSENGER_connect(), key, messenger, on_identity(), and on_message().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Main function that will be run by the scheduler.

Parameters

	[in/out]	cls closure
[in]	args	remaining command-line arguments
[in]	cfgfile	name of the configuration file used (for saving, can be NULL!)
[in]	cfg	configuration

Definition at line 355 of file gnunet-messenger.c.

{
  config = cfg;
 
  if (ego_name)
  {
    ego_lookup = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &on_ego_lookup,
                                             NULL);
    messenger = NULL;
  }
  else
  {
    ego_lookup = NULL;
    messenger = GNUNET_MESSENGER_connect (cfg, NULL, NULL, &on_message, NULL);
  }
 
  shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, NULL);
 
  if (messenger)
    on_identity (NULL, messenger);
}

References cfg, config, ego_lookup, ego_name, GNUNET_IDENTITY_ego_lookup(), GNUNET_MESSENGER_connect(), GNUNET_SCHEDULER_add_shutdown(), messenger, on_ego_lookup(), on_identity(), on_message(), shutdown_hook(), and shutdown_task.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char **	argv
	)

The main function to obtain messenger information.

Parameters

[in]	argc	number of arguments from the command line
[in]	argv	command line arguments

Returns: #EXIT_SUCCESS ok, #EXIT_FAILURE on error

Definition at line 389 of file gnunet-messenger.c.

{
  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);
}