gnunet-conversation.c File Reference

conversation implementation More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_conversation_service.h"

Include dependency graph for gnunet-conversation.c:

Go to the source code of this file.

Data Structures
struct	CallList
	List of incoming calls. More...
struct	VoipCommand
	Structure which defines a command. More...

Macros
#define	MAX_MESSAGE_LENGTH   1024
	Maximum length allowed for the command line input. More...
#define	XSTRINGIFY(x)   STRINGIFY (x)
#define	STRINGIFY(x)   (#x)

Typedefs
typedef void(*	ActionFunction) (const char *arguments)
	Function declareation for executing a action. More...

Enumerations
enum	PhoneState {   PS_REGISTER = 0 , PS_READY , PS_LOOKUP_EGO , PS_LISTEN ,   PS_ACCEPTED , PS_ERROR }
	Possible states of the phone. More...
enum	CallState {   CS_LOOKUP = 0 , CS_RINGING , CS_ACTIVE , CS_SHUTDOWN ,   CS_SUSPENDED_CALLER , CS_SUSPENDED_CALLEE , CS_SUSPENDED_BOTH , CS_RESOLVING ,   CS_RINGING , CS_CONNECTED , CS_SUSPENDED }
	States for current outgoing call. More...

Functions
static void	phone_event_handler (void *cls, enum GNUNET_CONVERSATION_PhoneEventCode code, struct GNUNET_CONVERSATION_Caller *caller, const struct GNUNET_CRYPTO_PublicKey *caller_id)
	Function called with an event emitted by a phone. More...
static void	caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
	Function called with an event emitted by a caller. More...
static void	start_phone ()
	Start our phone. More...
static void	call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
	Function called with an event emitted by a call. More...
static void	do_help (const char *args)
	Action function to print help for the command shell. More...
static void	do_quit (const char *args)
	Terminate the client. More...
static void	do_unknown (const char *msg)
	Handler for unknown command. More...
static void	do_call (const char *arg)
	Initiating a new call. More...
static void	do_accept (const char *args)
	Accepting an incoming call. More...
static void	do_address (const char *args)
	Print address information for this phone. More...
static void	do_status (const char *args)
	Accepting an incoming call. More...
static void	do_suspend (const char *args)
	Suspending a call. More...
static void	do_resume (const char *args)
	Resuming a call. More...
static void	do_reject (const char *args)
	Rejecting a call. More...
static void	do_stop_task (void *cls)
	Task run during shutdown. More...
static void	handle_command_string (char *message, size_t str_len)
	Handle user command. More...
static void	handle_command (void *cls)
	Task to handle commands from the terminal. More...
static void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Function called by identity service with information about egos. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function to conversation. More...

Variables
static struct GNUNET_CONVERSATION_Phone *	phone
	Phone handle. More...
static struct GNUNET_CONVERSATION_Call *	call
	Call handle (for active outgoing call). More...
static struct CallList *	cl_active
	Caller handle (for active incoming call). More...
static struct CallList *	cl_head
	Head of calls waiting to be accepted. More...
static struct CallList *	cl_tail
	Tail of calls waiting to be accepted. More...
static char *	line
	Desired phone line (string to be converted to a hash). More...
static struct GNUNET_SCHEDULER_Task *	handle_cmd_task
	Task which handles the commands. More...
static struct GNUNET_SPEAKER_Handle *	speaker
	Our speaker. More...
static struct GNUNET_MICROPHONE_Handle *	mic
	Our microphone. More...
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...
static struct GNUNET_IDENTITY_Ego *	my_caller_id
	Our ego. More...
static struct GNUNET_IDENTITY_Handle *	id
	Handle to identity service. More...
static char *	ego_name
	Name of our ego. More...
static struct GNUNET_CRYPTO_PublicKey	peer_key
	Public key of active conversation partner (if any). More...
static char *	peer_name
	Name of active conversation partner (if any). More...
static struct GNUNET_DISK_FileHandle *	stdin_fh
	File handle for stdin. More...
static enum PhoneState	phone_state
	Our phone's current state. More...
static enum CallState	call_state
	Our call's current state. More...
static unsigned int	caller_num_gen
	Counts the number of incoming calls we have had so far. More...
static char *	address
	GNS address for this phone. More...
static int	verbose
	Be verbose. More...
static struct VoipCommand	commands []
	List of supported commands. More...

Detailed Description

conversation implementation

Author

Simon Dieterle

Andreas Fuchs

Definition in file gnunet-conversation.c.

Macro Definition Documentation

MAX_MESSAGE_LENGTH

#define MAX_MESSAGE_LENGTH   1024

Maximum length allowed for the command line input.

Definition at line 34 of file gnunet-conversation.c.

XSTRINGIFY

#define XSTRINGIFY

(

x

)

STRINGIFY (x)

Definition at line 36 of file gnunet-conversation.c.

STRINGIFY

#define STRINGIFY

(

x

)

(#x)

Definition at line 38 of file gnunet-conversation.c.

Typedef Documentation

ActionFunction

typedef void(* ActionFunction) (const char *arguments)

Function declareation for executing a action.

Parameters

arguments

arguments given to the function

Definition at line 444 of file gnunet-conversation.c.

Enumeration Type Documentation

PhoneState

enum PhoneState

Possible states of the phone.

Enumerator
PS_REGISTER	We still need to register the phone.
PS_READY	We are waiting for calls.
PS_LOOKUP_EGO	We're waiting for our own idenitty.
PS_LISTEN	We're listening for calls.
PS_ACCEPTED	We accepted an incoming phone call.
PS_ERROR	Internal error.

Definition at line 43 of file gnunet-conversation.c.

{
  PS_LOOKUP_EGO,
 
  PS_LISTEN,
 
  PS_ACCEPTED,
 
  PS_ERROR
};

CallState

enum CallState

States for current outgoing call.

Enumerator
CS_LOOKUP	We still need to lookup the callee.
CS_RINGING	The call is ringing.
CS_ACTIVE	The call is in an active conversation.
CS_SHUTDOWN	The call is in termination.
CS_SUSPENDED_CALLER	The call was suspended by the caller.
CS_SUSPENDED_CALLEE	The call was suspended by the callee.
CS_SUSPENDED_BOTH	The call was suspended by both caller and callee.
CS_RESOLVING	We are looking up some other participant.
CS_RINGING	We are now ringing the other participant.
CS_CONNECTED	The other party accepted our call and we are now connected.
CS_SUSPENDED	The call is currently suspended (by us).

Definition at line 70 of file gnunet-conversation.c.

{
  CS_RESOLVING,
 
  CS_RINGING,
 
  CS_CONNECTED,
 
  CS_SUSPENDED
};

Function Documentation

phone_event_handler()

static void phone_event_handler ( void *  cls, enum GNUNET_CONVERSATION_PhoneEventCode  code, struct GNUNET_CONVERSATION_Caller *  caller, const struct GNUNET_CRYPTO_PublicKey *  caller_id  )

static

Function called with an event emitted by a phone.

Parameters

cls	closure
code	type of the event
caller	handle for the caller
caller_id	public key of the caller (in GNS)

Definition at line 242 of file gnunet-conversation.c.

{
  struct CallList *cl;
 
  (void) cls;
  switch (code)
  {
  case GNUNET_CONVERSATION_EC_PHONE_RING:
    /*
     * FIXME: we should be playing our ringtones from contrib/sounds now!
     *
       ring_my_bell();
     *
     * see https://gstreamer.freedesktop.org/documentation/application-development/highlevel/playback-components.html on how to play a wav using the gst framework being used here
     */fprintf (
      stdout,
      _ (
        "Incoming call from `%s'. Please /accept %u or /cancel %u the call.\n"),
      GNUNET_GNSRECORD_pkey_to_zkey (caller_id),
      caller_num_gen,
      caller_num_gen);
    cl = GNUNET_new (struct CallList);
    cl->caller = caller;
    cl->caller_id = *caller_id;
    cl->caller_num = caller_num_gen++;
    GNUNET_CONTAINER_DLL_insert (cl_head, cl_tail, cl);
    break;
 
  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
    for (cl = cl_head; NULL != cl; cl = cl->next)
      if (caller == cl->caller)
        break;
    if ((NULL == cl) && (caller == cl_active->caller))
      cl = cl_active;
    if (NULL == cl)
    {
      GNUNET_break (0);
      return;
    }
    fprintf (stdout,
             _ ("Call from `%s' terminated\n"),
             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
    if (cl == cl_active)
    {
      cl_active = NULL;
      phone_state = PS_LISTEN;
    }
    else
    {
      GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
    }
    GNUNET_free (cl);
    break;
  }
}

References _, CallList::caller, CallList::caller_id, CallList::caller_num, caller_num_gen, cl_active, cl_head, cl_tail, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONVERSATION_EC_PHONE_HUNG_UP, GNUNET_CONVERSATION_EC_PHONE_RING, GNUNET_free, GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_new, CallList::next, phone_state, and PS_LISTEN.

Referenced by start_phone().

Here is the call graph for this function:

Here is the caller graph for this function:

caller_event_handler()

static void caller_event_handler ( void *  cls, enum GNUNET_CONVERSATION_CallerEventCode  code  )

static

Function called with an event emitted by a caller.

Parameters

cls	closure with the struct CallList of the caller
code	type of the event issued by the caller

Definition at line 309 of file gnunet-conversation.c.

{
  struct CallList *cl = cls;
 
  switch (code)
  {
  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
    fprintf (stdout,
             _ ("Call from `%s' suspended by other user\n"),
             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
    break;
 
  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
    fprintf (stdout,
             _ ("Call from `%s' resumed by other user\n"),
             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
    break;
  }
}

References _, CallList::caller_id, GNUNET_CONVERSATION_EC_CALLER_RESUME, GNUNET_CONVERSATION_EC_CALLER_SUSPEND, and GNUNET_GNSRECORD_pkey_to_zkey().

Referenced by do_accept().

Here is the call graph for this function:

Here is the caller graph for this function:

start_phone()

static void start_phone ( )

static

Start our phone.

Definition at line 334 of file gnunet-conversation.c.

{
  struct GNUNET_GNSRECORD_Data rd;
 
  if (NULL == my_caller_id)
  {
    fprintf (stderr,
             _ ("Ego `%s' no longer available, phone is now down.\n"),
             ego_name);
    phone_state = PS_LOOKUP_EGO;
    return;
  }
  GNUNET_assert (NULL == phone);
  phone = GNUNET_CONVERSATION_phone_create (cfg,
                                            my_caller_id,
                                            &phone_event_handler,
                                            NULL);
  /* FIXME: get record and print full GNS record info later here... */
  if (NULL == phone)
  {
    fprintf (stderr, "%s", _ ("Failed to setup phone (internal error)\n"));
    phone_state = PS_ERROR;
  }
  else
  {
    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
    GNUNET_free (address);
    address =
      GNUNET_GNSRECORD_value_to_string (rd.record_type, rd.data, rd.data_size);
    fprintf (
      stdout,
      _ (
        "Phone active at `%s'.  Type `/help' for a list of available commands\n"),
      address);
    phone_state = PS_LISTEN;
  }
}

References _, address, cfg, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, ego_name, GNUNET_assert, GNUNET_CONVERSATION_phone_create(), GNUNET_CONVERSATION_phone_get_record(), GNUNET_free, GNUNET_GNSRECORD_value_to_string(), my_caller_id, phone, phone_event_handler(), phone_state, PS_ERROR, PS_LISTEN, PS_LOOKUP_EGO, rd, and GNUNET_GNSRECORD_Data::record_type.

Referenced by identity_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

call_event_handler()

static void call_event_handler ( void *  cls, enum GNUNET_CONVERSATION_CallEventCode  code  )

static

Function called with an event emitted by a call.

Parameters

cls	closure, NULL
code	type of the event on the call

Definition at line 380 of file gnunet-conversation.c.

{
  (void) cls;
 
  switch (code)
  {
  case GNUNET_CONVERSATION_EC_CALL_RINGING:
    GNUNET_break (CS_RESOLVING == call_state);
    fprintf (stdout,
             _ ("Resolved address of `%s'. Now ringing other party.\n"),
             peer_name);
    call_state = CS_RINGING;
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
    GNUNET_break (CS_RINGING == call_state);
    fprintf (stdout, _ ("Connection established to `%s'\n"), peer_name);
    call_state = CS_CONNECTED;
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
    GNUNET_break (CS_RESOLVING == call_state);
    fprintf (stdout, _ ("Failed to resolve `%s'\n"), peer_name);
    GNUNET_free (peer_name);
    peer_name = NULL;
    call = NULL;
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
    fprintf (stdout, _ ("Call to `%s' terminated\n"), peer_name);
    GNUNET_free (peer_name);
    peer_name = NULL;
    call = NULL;
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
    GNUNET_break (CS_CONNECTED == call_state);
    fprintf (stdout,
             _ ("Connection to `%s' suspended (by other user)\n"),
             peer_name);
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
    GNUNET_break (CS_CONNECTED == call_state);
    fprintf (stdout,
             _ ("Connection to `%s' resumed (by other user)\n"),
             peer_name);
    break;
 
  case GNUNET_CONVERSATION_EC_CALL_ERROR:
    fprintf (stdout, _ ("Error with the call, restarting it\n"));
    GNUNET_free (peer_name);
    peer_name = NULL;
    call = NULL;
    break;
  }
}

References _, call, call_state, CS_CONNECTED, CS_RESOLVING, CS_RINGING, GNUNET_break, GNUNET_CONVERSATION_EC_CALL_ERROR, GNUNET_CONVERSATION_EC_CALL_GNS_FAIL, GNUNET_CONVERSATION_EC_CALL_HUNG_UP, GNUNET_CONVERSATION_EC_CALL_PICKED_UP, GNUNET_CONVERSATION_EC_CALL_RESUMED, GNUNET_CONVERSATION_EC_CALL_RINGING, GNUNET_CONVERSATION_EC_CALL_SUSPENDED, GNUNET_free, and peer_name.

Referenced by do_call().

Here is the caller graph for this function:

do_help()

static void do_help ( const char *  args )

static

Action function to print help for the command shell.

Parameters

args	arguments given to the command

Definition at line 974 of file gnunet-conversation.c.

{
  unsigned int i;
 
  i = 0;
  while ((NULL != args) && (0 != strlen (args)) &&
         (commands[i].Action != &do_help))
  {
    if (0 == strncasecmp (&args[1], &commands[i].command[1], strlen (args) - 1))
    {
      fprintf (stdout, "%s\n", gettext (commands[i].helptext));
      return;
    }
    i++;
  }
  i = 0;
  fprintf (stdout, "%s", "Available commands:\n");
  while (commands[i].Action != &do_help)
  {
    fprintf (stdout, "%s\n", gettext (commands[i].command));
    i++;
  }
  fprintf (stdout, "%s", "\n");
  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
}

References VoipCommand::Action, consensus-simulation::args, VoipCommand::command, commands, do_help(), gettext, and VoipCommand::helptext.

Referenced by do_call(), and do_help().

Here is the call graph for this function:

Here is the caller graph for this function:

do_quit()

static void do_quit ( const char *  args )

static

Terminate the client.

Parameters

args	arguments given to the command

Definition at line 484 of file gnunet-conversation.c.

{
  (void) args;
  GNUNET_SCHEDULER_shutdown ();
}

References consensus-simulation::args, and GNUNET_SCHEDULER_shutdown().

Here is the call graph for this function:

do_unknown()

static void do_unknown ( const char *  msg )

static

Handler for unknown command.

Parameters

msg	arguments given to the command

Definition at line 497 of file gnunet-conversation.c.

{
  fprintf (stderr, _ ("Unknown command `%s'\n"), msg);
}

References _, and msg.

do_call()

static void do_call ( const char *  arg )

static

Initiating a new call.

Parameters

arg	arguments given to the command

Definition at line 509 of file gnunet-conversation.c.

{
  if (NULL == my_caller_id)
  {
    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
    return;
  }
  if (NULL != call)
  {
    fprintf (stderr,
             _ ("You are calling someone else already, hang up first!\n"));
    return;
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
    return;
 
  case PS_LISTEN:
    /* ok to call! */
    break;
 
  case PS_ACCEPTED:
    fprintf (
      stderr,
      _ (
        "You are answering call from `%s', hang up or suspend that call first!\n"),
      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
    return;
 
  case PS_ERROR:
    /* ok to call */
    break;
  }
  if (NULL == arg)
  {
    fprintf (stderr, _ ("Call recipient missing.\n"));
    do_help ("/call");
    return;
  }
  peer_name = GNUNET_strdup (arg);
  call_state = CS_RESOLVING;
  GNUNET_assert (NULL == call);
  call = GNUNET_CONVERSATION_call_start (cfg,
                                         my_caller_id,
                                         arg,
                                         speaker,
                                         mic,
                                         &call_event_handler,
                                         NULL);
}

References _, find_typedefs::arg, call, call_event_handler(), call_state, cfg, CS_RESOLVING, do_help(), ego_name, GNUNET_assert, GNUNET_CONVERSATION_call_start(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_strdup, mic, my_caller_id, peer_key, peer_name, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, PS_LOOKUP_EGO, and speaker.

Here is the call graph for this function:

do_accept()

static void do_accept ( const char *  args )

static

Accepting an incoming call.

Parameters

args	arguments given to the command

Definition at line 569 of file gnunet-conversation.c.

{
  struct CallList *cl;
  char buf[32];
 
  if ((NULL != call) && (CS_SUSPENDED != call_state))
  {
    fprintf (stderr,
             _ ("You are calling someone else already, hang up first!\n"));
    return;
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    GNUNET_break (0);
    break;
 
  case PS_LISTEN:
    /* this is the expected state */
    break;
 
  case PS_ACCEPTED:
    fprintf (
      stderr,
      _ (
        "You are answering call from `%s', hang up or suspend that call first!\n"),
      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
    return;
 
  case PS_ERROR:
    GNUNET_break (0);
    break;
  }
  cl = cl_head;
  if (NULL == cl)
  {
    fprintf (stderr, _ ("There is no incoming call to accept here!\n"));
    return;
  }
  if ((NULL != cl->next) || (NULL != args))
  {
    for (cl = cl_head; NULL != cl; cl = cl->next)
    {
      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
      if (0 == strcmp (buf, args))
        break;
    }
  }
  if (NULL == cl)
  {
    fprintf (stderr,
             _ ("There is no incoming call `%s' to accept right now!\n"),
             args);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
  cl_active = cl;
  peer_key = cl->caller_id;
  phone_state = PS_ACCEPTED;
  GNUNET_CONVERSATION_caller_pick_up (cl->caller,
                                      &caller_event_handler,
                                      cl,
                                      speaker,
                                      mic);
}

References _, consensus-simulation::args, call, call_state, CallList::caller, caller_event_handler(), CallList::caller_id, CallList::caller_num, cl_active, cl_head, cl_tail, CS_SUSPENDED, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONVERSATION_caller_pick_up(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_snprintf(), mic, CallList::next, peer_key, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, PS_LOOKUP_EGO, and speaker.

Here is the call graph for this function:

do_address()

static void do_address ( const char *  args )

static

Print address information for this phone.

Parameters

args	arguments given to the command

Definition at line 642 of file gnunet-conversation.c.

{
  (void) args;
  if (NULL == address)
  {
    fprintf (stdout, "%s", _ ("We currently do not have an address.\n"));
    return;
  }
  fprintf (stdout, "%s\n", address);
}

References _, address, and consensus-simulation::args.

do_status()

static void do_status ( const char *  args )

static

Accepting an incoming call.

Parameters

args	arguments given to the command

Definition at line 660 of file gnunet-conversation.c.

{
  struct CallList *cl;
 
  (void) args;
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
    fprintf (
      stdout,
      _ (
        "We are currently trying to locate the private key for the ego `%s'.\n"),
      ego_name);
    break;
 
  case PS_LISTEN:
    fprintf (stdout,
             _ (
               "We are listening for incoming calls for ego `%s' on line `%s'.\n"),
             ego_name,
             line);
    break;
 
  case PS_ACCEPTED:
    fprintf (stdout,
             _ ("You are having a conversation with `%s'.\n"),
             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
    ;
    break;
 
  case PS_ERROR:
    fprintf (
      stdout,
      _ (
        "We had an internal error setting up our phone line. You can still make calls.\n"));
    break;
  }
  if (NULL != call)
  {
    switch (call_state)
    {
    case CS_RESOLVING:
      fprintf (stdout,
               _ ("We are trying to find the network address to call `%s'.\n"),
               peer_name);
      break;
 
    case CS_RINGING:
      fprintf (stdout,
               _ ("We are calling `%s', their phone should be ringing.\n"),
               peer_name);
      break;
 
    case CS_CONNECTED:
      fprintf (stdout,
               _ ("You are having a conversation with `%s'.\n"),
               peer_name);
      break;
 
    case CS_SUSPENDED:
      /* ok to accept incoming call right now */
      break;
    }
  }
  if ((NULL != cl_head) && ((cl_head != cl_active) || (cl_head != cl_tail)))
  {
    fprintf (stdout, "%s", _ ("Calls waiting:\n"));
    for (cl = cl_head; NULL != cl; cl = cl->next)
    {
      if (cl == cl_active)
        continue;
      fprintf (stdout,
               _ ("#%u: `%s'\n"),
               cl->caller_num,
               GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
    }
    fprintf (stdout, "%s", "\n");
  }
}

References _, consensus-simulation::args, call, call_state, CallList::caller_id, CallList::caller_num, cl_active, cl_head, cl_tail, CS_CONNECTED, CS_RESOLVING, CS_RINGING, CS_SUSPENDED, ego_name, GNUNET_GNSRECORD_pkey_to_zkey(), line, CallList::next, peer_key, peer_name, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

Here is the call graph for this function:

do_suspend()

static void do_suspend ( const char *  args )

static

Suspending a call.

Parameters

args	arguments given to the command

Definition at line 747 of file gnunet-conversation.c.

{
  (void) args;
  if (NULL != call)
  {
    switch (call_state)
    {
    case CS_RESOLVING:
    case CS_RINGING:
    case CS_SUSPENDED:
      fprintf (stderr,
               "%s",
               _ ("There is no call that could be suspended right now.\n"));
      return;
 
    case CS_CONNECTED:
      call_state = CS_SUSPENDED;
      GNUNET_CONVERSATION_call_suspend (call);
      return;
    }
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
  case PS_LISTEN:
  case PS_ERROR:
    fprintf (stderr,
             "%s",
             _ ("There is no call that could be suspended right now.\n"));
    return;
 
  case PS_ACCEPTED:
    /* expected state, do rejection logic */
    break;
  }
  GNUNET_assert (NULL != cl_active);
  GNUNET_CONVERSATION_caller_suspend (cl_active->caller);
  cl_active = NULL;
  phone_state = PS_LISTEN;
}

References _, consensus-simulation::args, call, call_state, CallList::caller, cl_active, CS_CONNECTED, CS_RESOLVING, CS_RINGING, CS_SUSPENDED, GNUNET_assert, GNUNET_CONVERSATION_call_suspend(), GNUNET_CONVERSATION_caller_suspend(), phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

Here is the call graph for this function:

do_resume()

static void do_resume ( const char *  args )

static

Resuming a call.

Parameters

args	arguments given to the command

Definition at line 795 of file gnunet-conversation.c.

{
  struct CallList *cl;
  char buf[32];
 
  if (NULL != call)
  {
    switch (call_state)
    {
    case CS_RESOLVING:
    case CS_RINGING:
    case CS_CONNECTED:
      fprintf (stderr,
               "%s",
               _ ("There is no call that could be resumed right now.\n"));
      return;
 
    case CS_SUSPENDED:
      call_state = CS_CONNECTED;
      GNUNET_CONVERSATION_call_resume (call, speaker, mic);
      return;
    }
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
  case PS_ERROR:
    fprintf (stderr,
             "%s",
             _ ("There is no call that could be resumed right now.\n"));
    return;
 
  case PS_LISTEN:
    /* expected state, do resume logic */
    break;
 
  case PS_ACCEPTED:
    fprintf (stderr,
             _ ("Already talking with `%s', cannot resume a call right now.\n"),
             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
    return;
  }
  GNUNET_assert (NULL == cl_active);
  cl = cl_head;
  if (NULL == cl)
  {
    fprintf (stderr, _ ("There is no incoming call to resume here!\n"));
    return;
  }
  if ((NULL != cl->next) || (NULL != args))
  {
    for (cl = cl_head; NULL != cl; cl = cl->next)
    {
      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
      if (0 == strcmp (buf, args))
        break;
    }
  }
  if (NULL == cl)
  {
    fprintf (stderr,
             _ ("There is no incoming call `%s' to resume right now!\n"),
             args);
    return;
  }
  cl_active = cl;
  GNUNET_CONVERSATION_caller_resume (cl_active->caller, speaker, mic);
  phone_state = PS_ACCEPTED;
}

References _, consensus-simulation::args, call, call_state, CallList::caller, CallList::caller_num, cl_active, cl_head, CS_CONNECTED, CS_RESOLVING, CS_RINGING, CS_SUSPENDED, GNUNET_assert, GNUNET_CONVERSATION_call_resume(), GNUNET_CONVERSATION_caller_resume(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_snprintf(), mic, CallList::next, peer_key, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, PS_LOOKUP_EGO, and speaker.

Here is the call graph for this function:

do_reject()

static void do_reject ( const char *  args )

static

Rejecting a call.

Parameters

args	arguments given to the command

Definition at line 872 of file gnunet-conversation.c.

{
  struct CallList *cl;
  char buf[32];
 
  if (NULL != call)
  {
    GNUNET_CONVERSATION_call_stop (call);
    call = NULL;
    return;
  }
  switch (phone_state)
  {
  case PS_LOOKUP_EGO:
  case PS_ERROR:
    fprintf (stderr,
             "%s",
             _ ("There is no call that could be cancelled right now.\n"));
    return;
 
  case PS_LISTEN:
    /* look for active incoming calls to refuse */
    cl = cl_head;
    if (NULL == cl)
    {
      fprintf (stderr, _ ("There is no incoming call to refuse here!\n"));
      return;
    }
    if ((NULL != cl->next) || (NULL != args))
    {
      for (cl = cl_head; NULL != cl; cl = cl->next)
      {
        GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
        if (0 == strcmp (buf, args))
          break;
      }
    }
    if (NULL == cl)
    {
      fprintf (stderr,
               _ ("There is no incoming call `%s' to refuse right now!\n"),
               args);
      return;
    }
    GNUNET_CONVERSATION_caller_hang_up (cl->caller);
    GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
    GNUNET_free (cl);
    break;
 
  case PS_ACCEPTED:
    /* expected state, do rejection logic */
    GNUNET_assert (NULL != cl_active);
    GNUNET_CONVERSATION_caller_hang_up (cl_active->caller);
    cl_active = NULL;
    phone_state = PS_LISTEN;
    break;
  }
}

References _, consensus-simulation::args, call, CallList::caller, CallList::caller_num, cl_active, cl_head, cl_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_caller_hang_up(), GNUNET_free, GNUNET_snprintf(), CallList::next, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

Here is the call graph for this function:

do_stop_task()

static void do_stop_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

NULL

Definition at line 1007 of file gnunet-conversation.c.

{
  (void) cls;
  if (NULL != call)
  {
    GNUNET_CONVERSATION_call_stop (call);
    call = NULL;
  }
  if (NULL != phone)
  {
    GNUNET_CONVERSATION_phone_destroy (phone);
    phone = NULL;
  }
  if (NULL != handle_cmd_task)
  {
    GNUNET_SCHEDULER_cancel (handle_cmd_task);
    handle_cmd_task = NULL;
  }
  if (NULL != id)
  {
    GNUNET_IDENTITY_disconnect (id);
    id = NULL;
  }
  GNUNET_SPEAKER_destroy (speaker);
  speaker = NULL;
  GNUNET_MICROPHONE_destroy (mic);
  mic = NULL;
  GNUNET_free (ego_name);
  ego_name = NULL;
  GNUNET_free (peer_name);
  peer_name = NULL;
  phone_state = PS_ERROR;
}

References call, ego_name, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_phone_destroy(), GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_MICROPHONE_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_SPEAKER_destroy(), handle_cmd_task, mic, peer_name, phone, phone_state, PS_ERROR, and speaker.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_command_string()

static void handle_command_string ( char *  message, size_t  str_len  )

static

Handle user command.

Parameters

message	command the user typed in
str_len	number of bytes to process in message

Definition at line 1049 of file gnunet-conversation.c.

{
  size_t i;
  const char *ptr;
 
  if (0 == str_len)
    return;
  if (message[str_len - 1] == '\n')
    message[str_len - 1] = '\0';
  if (message[str_len - 2] == '\r')
    message[str_len - 2] = '\0';
  if (0 == strlen (message))
    return;
  i = 0;
  while (
    (NULL != commands[i].command) &&
    (0 !=
     strncasecmp (commands[i].command, message, strlen (commands[i].command))))
    i++;
  ptr = &message[strlen (commands[i].command)];
  while (isspace ((unsigned char) *ptr))
    ptr++;
  if ('\0' == *ptr)
    ptr = NULL;
  commands[i].Action (ptr);
}

References VoipCommand::Action, VoipCommand::command, and commands.

Referenced by handle_command().

Here is the caller graph for this function:

handle_command()

static void handle_command ( void *  cls )

static

Task to handle commands from the terminal.

Parameters

cls

NULL

Definition at line 1083 of file gnunet-conversation.c.

{
  char message[MAX_MESSAGE_LENGTH + 1];
 
  (void) cls;
  handle_cmd_task =
    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                    stdin_fh,
                                    &handle_command,
                                    NULL);
  /* read message from command line and handle it */
  memset (message, 0, MAX_MESSAGE_LENGTH + 1);
  if (NULL == fgets (message, MAX_MESSAGE_LENGTH, stdin))
    return;
  handle_command_string (message, strlen (message));
}

References GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_UNIT_FOREVER_REL, handle_cmd_task, handle_command(), handle_command_string(), MAX_MESSAGE_LENGTH, and stdin_fh.

Referenced by handle_command(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

identity_cb()

static void identity_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Function called by identity service with information about egos.

Parameters

cls	NULL
ego	ego handle
ctx	unused
name	name of the ego

Definition at line 1110 of file gnunet-conversation.c.

{
  (void) cls;
  (void) ctx;
  if (NULL == name)
    return;
  if (ego == my_caller_id)
  {
    if (verbose)
      fprintf (stdout, _ ("Name of our ego changed to `%s'\n"), name);
    GNUNET_free (ego_name);
    ego_name = GNUNET_strdup (name);
    return;
  }
  if (0 != strcmp (name, ego_name))
    return;
  if (NULL == ego)
  {
    if (verbose)
      fprintf (stdout, _ ("Our ego `%s' was deleted!\n"), ego_name);
    my_caller_id = NULL;
    return;
  }
  my_caller_id = ego;
  GNUNET_CONFIGURATION_set_value_string (cfg, "CONVERSATION", "LINE", line);
  start_phone ();
}

References _, cfg, ctx, ego_name, GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_strdup, line, my_caller_id, name, start_phone(), and verbose.

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 *  c  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 1151 of file gnunet-conversation.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  cfg = GNUNET_CONFIGURATION_dup (c);
  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
  mic = GNUNET_MICROPHONE_create_from_hardware (cfg);
  if (NULL == ego_name)
  {
    fprintf (stderr, "%s", _ ("You must specify the NAME of an ego to use\n"));
    return;
  }
  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
  handle_cmd_task =
    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
                                        &handle_command,
                                        NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
}

References _, consensus-simulation::args, cfg, do_stop_task(), ego_name, GNUNET_CONFIGURATION_dup(), GNUNET_IDENTITY_connect(), GNUNET_MICROPHONE_create_from_hardware(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_UI, GNUNET_SPEAKER_create_from_hardware(), handle_cmd_task, handle_command(), identity_cb(), mic, and speaker.

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 *const *	argv
	)

The main function to conversation.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 1184 of file gnunet-conversation.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_string (
      'e',
      "ego",
      "NAME",
      gettext_noop ("sets the NAME of the ego to use for the caller ID"),
      &ego_name),
    GNUNET_GETOPT_option_string ('p',
                                 "phone",
                                 "LINE",
                                 gettext_noop (
                                   "sets the LINE to use for the phone"),
                                 &line),
    GNUNET_GETOPT_OPTION_END };
  int ret;
 
  int flags;
  flags = fcntl (0, F_GETFL, 0);
  flags |= O_NONBLOCK;
  if (0 != fcntl (0, F_SETFL, flags))
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
  stdin_fh = GNUNET_DISK_get_handle_from_int_fd (0);
 
  ret =
    GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet(),
                        argc,
                        argv,
                        "gnunet-conversation",
                        gettext_noop (
                          "Enables having a conversation with other GNUnet users."),
                        options,
                        &run,
                        NULL);
  if (NULL != cfg)
  {
    GNUNET_CONFIGURATION_destroy (cfg);
    cfg = NULL;
  }
  return (GNUNET_OK == ret) ? 0 : 1;
}

References cfg, ego_name, gettext_noop, GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_get_handle_from_int_fd(), GNUNET_ERROR_TYPE_WARNING, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_string(), GNUNET_log_strerror, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), line, options, ret, run(), and stdin_fh.

Here is the call graph for this function:

Variable Documentation

phone

struct GNUNET_CONVERSATION_Phone* phone

static

Phone handle.

Definition at line 129 of file gnunet-conversation.c.

Referenced by clean_up_callers(), do_stop_task(), find_caller(), GNUNET_CONVERSATION_caller_hang_up(), GNUNET_CONVERSATION_caller_pick_up(), GNUNET_CONVERSATION_caller_resume(), GNUNET_CONVERSATION_caller_suspend(), GNUNET_CONVERSATION_phone_create(), GNUNET_CONVERSATION_phone_destroy(), GNUNET_CONVERSATION_phone_get_record(), handle_phone_audio(), handle_phone_hangup(), handle_phone_resume(), handle_phone_ring(), handle_phone_suspend(), phone_error_handler(), reconnect_phone(), start_phone(), and transmit_phone_audio().

call

struct GNUNET_CONVERSATION_Call* call

static

Call handle (for active outgoing call).

Definition at line 134 of file gnunet-conversation.c.

Referenced by call_error_handler(), call_event_handler(), do_accept(), do_call(), do_reject(), do_resume(), do_status(), do_stop_task(), do_suspend(), fail_call(), GNUNET_CONVERSATION_call_resume(), GNUNET_CONVERSATION_call_start(), GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_call_suspend(), handle_call_audio(), handle_call_hangup(), handle_call_picked_up(), handle_call_resume(), handle_call_suspend(), handle_gns_response(), iterate_local_members(), iterate_room_members(), and transmit_call_audio().

cl_active

struct CallList* cl_active

static

Caller handle (for active incoming call).

This call handler is NOT in the cl_head / cl_tail list.

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

Referenced by do_accept(), do_reject(), do_resume(), do_status(), do_suspend(), and phone_event_handler().

cl_head

struct CallList* cl_head

static

Head of calls waiting to be accepted.

Definition at line 145 of file gnunet-conversation.c.

Referenced by do_accept(), do_reject(), do_resume(), do_status(), and phone_event_handler().

cl_tail

struct CallList* cl_tail

static

Tail of calls waiting to be accepted.

Definition at line 150 of file gnunet-conversation.c.

Referenced by do_accept(), do_reject(), do_status(), and phone_event_handler().

line

char* line

static

Desired phone line (string to be converted to a hash).

Definition at line 155 of file gnunet-conversation.c.

Referenced by block_create2(), clean_up_channel(), client_connect_cb(), client_disconnect_cb(), database_setup(), do_status(), extract_dns_server(), extract_hosts(), extract_search_domain(), find_channel_by_line(), gns_resolve_name(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONVERSATION_phone_create(), GNUNET_get_log_call_status(), GNUNET_hex2b(), GNUNET_REGEX_ipv4policy2regex(), GNUNET_REGEX_ipv6policy2regex(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), handle_cadet_suspend_message(), handle_client_audio_message(), handle_client_call_message(), handle_client_hangup_message(), handle_client_pickup_message(), handle_client_register_message(), handle_client_resume_message(), handle_client_suspend_message(), handle_collect_result(), identity_cb(), inbound_channel(), main(), parse_recordline(), parsehex(), process_map_output(), process_refresh_output(), process_unmap_output(), read_from_log(), store_and_free_entries(), trim(), try_ifconfig(), and try_ip().

handle_cmd_task

struct GNUNET_SCHEDULER_Task* handle_cmd_task

static

Task which handles the commands.

Definition at line 160 of file gnunet-conversation.c.

Referenced by do_stop_task(), handle_command(), and run().

speaker

struct GNUNET_SPEAKER_Handle* speaker

static

Our speaker.

Definition at line 165 of file gnunet-conversation.c.

Referenced by do_accept(), do_call(), do_resume(), do_stop_task(), and run().

mic

struct GNUNET_MICROPHONE_Handle* mic

static

Our microphone.

Definition at line 170 of file gnunet-conversation.c.

Referenced by destroy(), disable(), do_accept(), do_call(), do_resume(), do_stop_task(), enable(), GNUNET_CONVERSATION_call_resume(), GNUNET_CONVERSATION_call_start(), GNUNET_CONVERSATION_caller_pick_up(), GNUNET_CONVERSATION_caller_resume(), GNUNET_MICROPHONE_create_from_hardware(), process_record_messages(), and run().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 175 of file gnunet-conversation.c.

Referenced by do_call(), identity_cb(), main(), run(), and start_phone().

my_caller_id

struct GNUNET_IDENTITY_Ego* my_caller_id

static

Our ego.

Definition at line 180 of file gnunet-conversation.c.

Referenced by do_call(), identity_cb(), and start_phone().

id

struct GNUNET_IDENTITY_Handle* id

static

Handle to identity service.

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

ego_name

char* ego_name

static

Name of our ego.

Definition at line 190 of file gnunet-conversation.c.

Referenced by do_call(), do_status(), do_stop_task(), identity_cb(), main(), run(), and start_phone().

peer_key

struct GNUNET_CRYPTO_PublicKey peer_key

static

Public key of active conversation partner (if any).

Definition at line 195 of file gnunet-conversation.c.

Referenced by do_accept(), do_call(), do_resume(), and do_status().

peer_name

char* peer_name

static

Name of active conversation partner (if any).

Definition at line 200 of file gnunet-conversation.c.

Referenced by call_event_handler(), do_call(), do_status(), and do_stop_task().

stdin_fh

struct GNUNET_DISK_FileHandle* stdin_fh

static

File handle for stdin.

Definition at line 205 of file gnunet-conversation.c.

Referenced by handle_command(), and main().

phone_state

enum PhoneState phone_state

static

Our phone's current state.

Definition at line 210 of file gnunet-conversation.c.

Referenced by do_accept(), do_call(), do_reject(), do_resume(), do_status(), do_stop_task(), do_suspend(), phone_event_handler(), and start_phone().

call_state

enum CallState call_state

static

Our call's current state.

Definition at line 215 of file gnunet-conversation.c.

Referenced by call_event_handler(), do_accept(), do_call(), do_resume(), do_status(), and do_suspend().

caller_num_gen

unsigned int caller_num_gen

static

Counts the number of incoming calls we have had so far.

Definition at line 220 of file gnunet-conversation.c.

Referenced by phone_event_handler().

address

char* address

static

GNS address for this phone.

Definition at line 225 of file gnunet-conversation.c.

Referenced by address_cb(), allocation_cb(), check_address(), connect_peers_run(), create_address_entry(), create_channel_to_destination(), create_receiver(), do_address(), find_queue(), GDS_u_try_connect(), get_address_without_port(), get_destination_key_from_ip(), GNUNET_get_udp_socket(), GNUNET_HELLO_address_to_prefix(), GNUNET_HELLO_builder_add_address(), GNUNET_HELLO_builder_del_address(), GNUNET_HELLO_sign_address(), GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_connect(), GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(), gnunet_try_connect(), handle_add_address(), hello_for_client_cb(), hello_for_incoming_cb(), ip_try_connect(), main(), make_up_icmpv4_payload(), make_up_icmpv6_payload(), mq_init(), notify_monitor(), notify_monitors(), parser_add_address(), process_peer_iteration_cb(), process_peer_monitoring_cb(), process_peer_string(), read_send(), resolve_peer_address(), set_address4(), set_address6(), setup_sender(), sock_read(), sockaddr_to_udpaddr_string(), start_address_validation(), start_phone(), suggest_to_connect(), u_address_add(), udp_socket_notify(), and vpn_allocation_callback().

verbose

int verbose

static

Be verbose.

Definition at line 230 of file gnunet-conversation.c.

Referenced by identity_cb().

commands

struct VoipCommand commands[]

static

List of supported commands.

Definition at line 935 of file gnunet-conversation.c.

Referenced by do_help(), GNUNET_TESTING_main(), GNUNET_TESTING_make_plugin(), GNUNET_TESTING_run(), handle_command_string(), handle_helper_init(), main(), setup_is(), and start_testcase().