GNUnet  0.11.x
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
gnunet-conversation.c File Reference

conversation implementation More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_conversation_service.h"
#include "gnunet_namestore_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_EcdsaPublicKey *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_Phonephone
 Phone handle. More...
 
static struct GNUNET_CONVERSATION_Callcall
 Call handle (for active outgoing call). More...
 
static struct CallListcl_active
 Caller handle (for active incoming call). More...
 
static struct CallListcl_head
 Head of calls waiting to be accepted. More...
 
static struct CallListcl_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_Taskhandle_cmd_task
 Task which handles the commands. More...
 
static struct GNUNET_SPEAKER_Handlespeaker
 Our speaker. More...
 
static struct GNUNET_MICROPHONE_Handlemic
 Our microphone. More...
 
static struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_IDENTITY_Egomy_caller_id
 Our ego. More...
 
static struct GNUNET_IDENTITY_Handleid
 Handle to identity service. More...
 
static char * ego_name
 Name of our ego. More...
 
static struct GNUNET_CRYPTO_EcdsaPublicKey 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_FileHandlestdin_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 36 of file gnunet-conversation.c.

Referenced by handle_command().

◆ XSTRINGIFY

#define XSTRINGIFY (   x)    STRINGIFY (x)

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

◆ STRINGIFY

#define STRINGIFY (   x)    (#x)

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

Typedef Documentation

◆ ActionFunction

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

Function declareation for executing a action.

Parameters
argumentsarguments given to the function

Definition at line 446 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 45 of file gnunet-conversation.c.

46 {
51 
55  PS_LISTEN,
56 
61 
65  PS_ERROR
66 };
Internal error.
We're waiting for our own idenitty.
We accepted an incoming phone call.
We're listening for calls.

◆ 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 72 of file gnunet-conversation.c.

73 {
78 
82  CS_RINGING,
83 
88 
93 };
The other party accepted our call and we are now connected.
We are now ringing the other participant.
The call is currently suspended (by us).
We are looking up some other participant.

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_EcdsaPublicKey caller_id 
)
static

Function called with an event emitted by a phone.

Parameters
clsclosure
codetype of the event
callerhandle for the caller
caller_idpublic key of the caller (in GNS)

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

References _, CallList::caller, CallList::caller_id, CallList::caller_num, caller_num_gen, cl_active, 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().

248 {
249  struct CallList *cl;
250 
251  (void) cls;
252  switch (code)
253  {
255  /*
256  * FIXME: we should be playing our ringtones from contrib/sounds now!
257  *
258  ring_my_bell();
259  *
260  * 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
261  */fprintf (
262  stdout,
263  _ (
264  "Incoming call from `%s'. Please /accept %u or /cancel %u the call.\n"),
265  GNUNET_GNSRECORD_pkey_to_zkey (caller_id),
268  cl = GNUNET_new (struct CallList);
269  cl->caller = caller;
270  cl->caller_id = *caller_id;
271  cl->caller_num = caller_num_gen++;
273  break;
274 
276  for (cl = cl_head; NULL != cl; cl = cl->next)
277  if (caller == cl->caller)
278  break;
279  if ((NULL == cl) && (caller == cl_active->caller))
280  cl = cl_active;
281  if (NULL == cl)
282  {
283  GNUNET_break (0);
284  return;
285  }
286  fprintf (stdout,
287  _ ("Call from `%s' terminated\n"),
289  if (cl == cl_active)
290  {
291  cl_active = NULL;
293  }
294  else
295  {
297  }
298  GNUNET_free (cl);
299  break;
300  }
301 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CallList * cl_tail
Tail of calls waiting to be accepted.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
List of incoming calls.
unsigned int caller_num
Unique number of the call.
static enum PhoneState phone_state
Our phone's current state.
static struct CallList * cl_head
Head of calls waiting to be accepted.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct CallList * next
A DLL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
The conversation was terminated by the caller.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
We're listening for calls.
We are the callee and the phone is ringing.
static struct CallList * cl_active
Caller handle (for active incoming call).
struct GNUNET_CONVERSATION_Caller * caller
Handle to hang up or activate.
static unsigned int caller_num_gen
Counts the number of incoming calls we have had so far.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Public key identifying the caller.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure with the struct CallList of the caller
codetype of the event issued by the caller

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

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

Referenced by do_accept().

312 {
313  struct CallList *cl = cls;
314 
315  switch (code)
316  {
318  fprintf (stdout,
319  _ ("Call from `%s' suspended by other user\n"),
321  break;
322 
324  fprintf (stdout,
325  _ ("Call from `%s' resumed by other user\n"),
327  break;
328  }
329 }
List of incoming calls.
We are the callee and the caller resumed the call.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
We are the callee and the caller suspended the call.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Public key identifying the caller.
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 336 of file gnunet-conversation.c.

References _, address, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, ego_name, GNUNET_assert, GNUNET_CONVERSATION_phone_create(), GNUNET_CONVERSATION_phone_get_record(), GNUNET_free_non_null, GNUNET_GNSRECORD_value_to_string(), phone_event_handler(), phone_state, PS_ERROR, PS_LISTEN, PS_LOOKUP_EGO, and GNUNET_GNSRECORD_Data::record_type.

Referenced by identity_cb().

337 {
338  struct GNUNET_GNSRECORD_Data rd;
339 
340  if (NULL == my_caller_id)
341  {
342  fprintf (stderr,
343  _ ("Ego `%s' no longer available, phone is now down.\n"),
344  ego_name);
346  return;
347  }
348  GNUNET_assert (NULL == phone);
350  my_caller_id,
352  NULL);
353  /* FIXME: get record and print full GNS record info later here... */
354  if (NULL == phone)
355  {
356  fprintf (stderr, "%s", _ ("Failed to setup phone (internal error)\n"));
358  }
359  else
360  {
363  address =
364  GNUNET_GNSRECORD_value_to_string (rd.record_type, rd.data, rd.data_size);
365  fprintf (
366  stdout,
367  _ (
368  "Phone active at `%s'. Type `/help' for a list of available commands\n"),
369  address);
371  }
372 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
Internal error.
We're waiting for our own idenitty.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static char * ego_name
Name of our ego.
static enum PhoneState phone_state
Our phone's current state.
void GNUNET_CONVERSATION_phone_get_record(struct GNUNET_CONVERSATION_Phone *phone, struct GNUNET_GNSRECORD_Data *rd)
Fill in a namestore record with the contact information for this phone.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_IDENTITY_Ego * my_caller_id
Our ego.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void phone_event_handler(void *cls, enum GNUNET_CONVERSATION_PhoneEventCode code, struct GNUNET_CONVERSATION_Caller *caller, const struct GNUNET_CRYPTO_EcdsaPublicKey *caller_id)
Function called with an event emitted by a phone.
We're listening for calls.
struct GNUNET_CONVERSATION_Phone * GNUNET_CONVERSATION_phone_create(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_IDENTITY_Ego *ego, GNUNET_CONVERSATION_PhoneEventHandler event_handler, void *event_handler_cls)
Create a new phone.
char * GNUNET_GNSRECORD_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the 'value' of a record to a string.
Definition: gnsrecord.c:143
static char * address
GNS address for this phone.
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
clsclosure, NULL
codetype of the event on the call

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

References _, 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().

383 {
384  (void) cls;
385 
386  switch (code)
387  {
390  fprintf (stdout,
391  _ ("Resolved address of `%s'. Now ringing other party.\n"),
392  peer_name);
394  break;
395 
398  fprintf (stdout, _ ("Connection established to `%s'\n"), peer_name);
400  break;
401 
404  fprintf (stdout, _ ("Failed to resolve `%s'\n"), peer_name);
406  peer_name = NULL;
407  call = NULL;
408  break;
409 
411  fprintf (stdout, _ ("Call to `%s' terminated\n"), peer_name);
413  peer_name = NULL;
414  call = NULL;
415  break;
416 
419  fprintf (stdout,
420  _ ("Connection to `%s' suspended (by other user)\n"),
421  peer_name);
422  break;
423 
426  fprintf (stdout,
427  _ ("Connection to `%s' resumed (by other user)\n"),
428  peer_name);
429  break;
430 
432  fprintf (stdout, _ ("Error with the call, restarting it\n"));
434  peer_name = NULL;
435  call = NULL;
436  break;
437  }
438 }
static enum CallState call_state
Our call's current state.
We are the caller and the callee suspended the call.
static char * peer_name
Name of active conversation partner (if any).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We are the caller and are now ready to talk as the callee picked up.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We are the caller and are now ringing the other party (GNS lookup succeeded).
We are the caller and the callee called GNUNET_CONVERSATION_caller_hang_up.
We are the caller and failed to locate a phone record in GNS.
The other party accepted our call and we are now connected.
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We are now ringing the other participant.
We are the caller and the callee suspended the call.
We had an error handing the call, and are now restarting it (back to lookup).
We are looking up some other participant.
#define GNUNET_free(ptr)
Wrapper around free.
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
argsarguments given to the command

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

References VoipCommand::Action, VoipCommand::command, gettext, and VoipCommand::helptext.

Referenced by do_call().

977 {
978  unsigned int i;
979 
980  i = 0;
981  while ((NULL != args) && (0 != strlen (args)) &&
982  (commands[i].Action != &do_help))
983  {
984  if (0 == strncasecmp (&args[1], &commands[i].command[1], strlen (args) - 1))
985  {
986  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
987  return;
988  }
989  i++;
990  }
991  i = 0;
992  fprintf (stdout, "%s", "Available commands:\n");
993  while (commands[i].Action != &do_help)
994  {
995  fprintf (stdout, "%s\n", gettext (commands[i].command));
996  i++;
997  }
998  fprintf (stdout, "%s", "\n");
999  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
1000 }
#define gettext(Msgid)
Definition: gettext.h:45
static struct VoipCommand commands[]
List of supported commands.
static void do_help(const char *args)
Action function to print help for the command shell.
Here is the caller graph for this function:

◆ do_quit()

static void do_quit ( const char *  args)
static

Terminate the client.

Parameters
argsarguments given to the command

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

References GNUNET_SCHEDULER_shutdown().

487 {
488  (void) args;
490 }
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
Here is the call graph for this function:

◆ do_unknown()

static void do_unknown ( const char *  msg)
static

Handler for unknown command.

Parameters
msgarguments given to the command

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

References _.

500 {
501  fprintf (stderr, _ ("Unknown command `%s'\n"), msg);
502 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define _(String)
GNU gettext support macro.
Definition: platform.h:181

◆ do_call()

static void do_call ( const char *  arg)
static

Initiating a new call.

Parameters
argarguments given to the command

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

References _, call_event_handler(), call_state, CS_RESOLVING, do_help(), ego_name, GNUNET_assert, GNUNET_CONVERSATION_call_start(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_strdup, peer_key, peer_name, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

512 {
513  if (NULL == my_caller_id)
514  {
515  fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
516  return;
517  }
518  if (NULL != call)
519  {
520  fprintf (stderr,
521  _ ("You are calling someone else already, hang up first!\n"));
522  return;
523  }
524  switch (phone_state)
525  {
526  case PS_LOOKUP_EGO:
527  fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
528  return;
529 
530  case PS_LISTEN:
531  /* ok to call! */
532  break;
533 
534  case PS_ACCEPTED:
535  fprintf (
536  stderr,
537  _ (
538  "You are answering call from `%s', hang up or suspend that call first!\n"),
540  return;
541 
542  case PS_ERROR:
543  /* ok to call */
544  break;
545  }
546  if (NULL == arg)
547  {
548  fprintf (stderr, _ ("Call recipient missing.\n"));
549  do_help ("/call");
550  return;
551  }
554  GNUNET_assert (NULL == call);
556  my_caller_id,
557  arg,
558  speaker,
559  mic,
561  NULL);
562 }
Internal error.
We're waiting for our own idenitty.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static enum CallState call_state
Our call's current state.
static char * ego_name
Name of our ego.
static enum PhoneState phone_state
Our phone's current state.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * peer_name
Name of active conversation partner (if any).
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We accepted an incoming phone call.
static struct GNUNET_IDENTITY_Ego * my_caller_id
Our ego.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
struct GNUNET_CONVERSATION_Call * GNUNET_CONVERSATION_call_start(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_IDENTITY_Ego *caller_id, const char *callee, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic, GNUNET_CONVERSATION_CallEventHandler event_handler, void *event_handler_cls)
Call the phone of another user.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
static struct GNUNET_CRYPTO_EcdsaPublicKey peer_key
Public key of active conversation partner (if any).
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
static void call_event_handler(void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
Function called with an event emitted by a call.
We are looking up some other participant.
static void do_help(const char *args)
Action function to print help for the command shell.
Here is the call graph for this function:

◆ do_accept()

static void do_accept ( const char *  args)
static

Accepting an incoming call.

Parameters
argsarguments given to the command

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

References _, buf, call_state, CallList::caller, caller_event_handler(), CallList::caller_id, CallList::caller_num, cl_head, CS_SUSPENDED, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONVERSATION_caller_pick_up(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_snprintf(), CallList::next, peer_key, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

572 {
573  struct CallList *cl;
574  char buf[32];
575 
576  if ((NULL != call) && (CS_SUSPENDED != call_state))
577  {
578  fprintf (stderr,
579  _ ("You are calling someone else already, hang up first!\n"));
580  return;
581  }
582  switch (phone_state)
583  {
584  case PS_LOOKUP_EGO:
585  GNUNET_break (0);
586  break;
587 
588  case PS_LISTEN:
589  /* this is the expected state */
590  break;
591 
592  case PS_ACCEPTED:
593  fprintf (
594  stderr,
595  _ (
596  "You are answering call from `%s', hang up or suspend that call first!\n"),
598  return;
599 
600  case PS_ERROR:
601  GNUNET_break (0);
602  break;
603  }
604  cl = cl_head;
605  if (NULL == cl)
606  {
607  fprintf (stderr, _ ("There is no incoming call to accept here!\n"));
608  return;
609  }
610  if ((NULL != cl->next) || (NULL != args))
611  {
612  for (cl = cl_head; NULL != cl; cl = cl->next)
613  {
614  GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
615  if (0 == strcmp (buf, args))
616  break;
617  }
618  }
619  if (NULL == cl)
620  {
621  fprintf (stderr,
622  _ ("There is no incoming call `%s' to accept right now!\n"),
623  args);
624  return;
625  }
627  cl_active = cl;
628  peer_key = cl->caller_id;
632  cl,
633  speaker,
634  mic);
635 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CallList * cl_tail
Tail of calls waiting to be accepted.
Internal error.
We're waiting for our own idenitty.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
List of incoming calls.
unsigned int caller_num
Unique number of the call.
static enum CallState call_state
Our call's current state.
static enum PhoneState phone_state
Our phone's current state.
static struct CallList * cl_head
Head of calls waiting to be accepted.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct CallList * next
A DLL.
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We accepted an incoming phone call.
static void caller_event_handler(void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
Function called with an event emitted by a caller.
static struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
static char buf[2048]
void GNUNET_CONVERSATION_caller_pick_up(struct GNUNET_CONVERSATION_Caller *caller, GNUNET_CONVERSATION_CallerEventHandler event_handler, void *event_handler_cls, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
Picks up a (ringing) phone.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
static struct GNUNET_CRYPTO_EcdsaPublicKey peer_key
Public key of active conversation partner (if any).
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
static struct CallList * cl_active
Caller handle (for active incoming call).
struct GNUNET_CONVERSATION_Caller * caller
Handle to hang up or activate.
The call is currently suspended (by us).
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Public key identifying the caller.
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
argsarguments given to the command

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

References _, and address.

645 {
646  (void) args;
647  if (NULL == address)
648  {
649  fprintf (stdout, "%s", _ ("We currently do not have an address.\n"));
650  return;
651  }
652  fprintf (stdout, "%s\n", address);
653 }
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * address
GNS address for this phone.

◆ do_status()

static void do_status ( const char *  args)
static

Accepting an incoming call.

Parameters
argsarguments given to the command

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

References _, call_state, CallList::caller_id, CallList::caller_num, 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.

663 {
664  struct CallList *cl;
665 
666  (void) args;
667  switch (phone_state)
668  {
669  case PS_LOOKUP_EGO:
670  fprintf (
671  stdout,
672  _ (
673  "We are currently trying to locate the private key for the ego `%s'.\n"),
674  ego_name);
675  break;
676 
677  case PS_LISTEN:
678  fprintf (stdout,
679  _ (
680  "We are listening for incoming calls for ego `%s' on line `%s'.\n"),
681  ego_name,
682  line);
683  break;
684 
685  case PS_ACCEPTED:
686  fprintf (stdout,
687  _ ("You are having a conversation with `%s'.\n"),
689  ;
690  break;
691 
692  case PS_ERROR:
693  fprintf (
694  stdout,
695  _ (
696  "We had an internal error setting up our phone line. You can still make calls.\n"));
697  break;
698  }
699  if (NULL != call)
700  {
701  switch (call_state)
702  {
703  case CS_RESOLVING:
704  fprintf (stdout,
705  _ ("We are trying to find the network address to call `%s'.\n"),
706  peer_name);
707  break;
708 
709  case CS_RINGING:
710  fprintf (stdout,
711  _ ("We are calling `%s', their phone should be ringing.\n"),
712  peer_name);
713  break;
714 
715  case CS_CONNECTED:
716  fprintf (stdout,
717  _ ("You are having a conversation with `%s'.\n"),
718  peer_name);
719  break;
720 
721  case CS_SUSPENDED:
722  /* ok to accept incoming call right now */
723  break;
724  }
725  }
726  if ((NULL != cl_head) && ((cl_head != cl_active) || (cl_head != cl_tail)))
727  {
728  fprintf (stdout, "%s", _ ("Calls waiting:\n"));
729  for (cl = cl_head; NULL != cl; cl = cl->next)
730  {
731  if (cl == cl_active)
732  continue;
733  fprintf (stdout,
734  _ ("#%u: `%s'\n"),
735  cl->caller_num,
737  }
738  fprintf (stdout, "%s", "\n");
739  }
740 }
static struct CallList * cl_tail
Tail of calls waiting to be accepted.
Internal error.
We're waiting for our own idenitty.
List of incoming calls.
unsigned int caller_num
Unique number of the call.
static enum CallState call_state
Our call's current state.
static char * ego_name
Name of our ego.
static enum PhoneState phone_state
Our phone's current state.
static struct CallList * cl_head
Head of calls waiting to be accepted.
static char * peer_name
Name of active conversation partner (if any).
struct CallList * next
A DLL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * line
Desired phone line (string to be converted to a hash).
We accepted an incoming phone call.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
static struct GNUNET_CRYPTO_EcdsaPublicKey peer_key
Public key of active conversation partner (if any).
The other party accepted our call and we are now connected.
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
We are now ringing the other participant.
static struct CallList * cl_active
Caller handle (for active incoming call).
The call is currently suspended (by us).
We are looking up some other participant.
struct GNUNET_CRYPTO_EcdsaPublicKey caller_id
Public key identifying the caller.
Here is the call graph for this function:

◆ do_suspend()

static void do_suspend ( const char *  args)
static

Suspending a call.

Parameters
argsarguments given to the command

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

References _, call_state, CallList::caller, 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.

750 {
751  (void) args;
752  if (NULL != call)
753  {
754  switch (call_state)
755  {
756  case CS_RESOLVING:
757  case CS_RINGING:
758  case CS_SUSPENDED:
759  fprintf (stderr,
760  "%s",
761  _ ("There is no call that could be suspended right now.\n"));
762  return;
763 
764  case CS_CONNECTED:
767  return;
768  }
769  }
770  switch (phone_state)
771  {
772  case PS_LOOKUP_EGO:
773  case PS_LISTEN:
774  case PS_ERROR:
775  fprintf (stderr,
776  "%s",
777  _ ("There is no call that could be suspended right now.\n"));
778  return;
779 
780  case PS_ACCEPTED:
781  /* expected state, do rejection logic */
782  break;
783  }
784  GNUNET_assert (NULL != cl_active);
786  cl_active = NULL;
788 }
Internal error.
We're waiting for our own idenitty.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static enum CallState call_state
Our call's current state.
static enum PhoneState phone_state
Our phone's current state.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We accepted an incoming phone call.
The other party accepted our call and we are now connected.
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
void GNUNET_CONVERSATION_caller_suspend(struct GNUNET_CONVERSATION_Caller *caller)
Pause conversation of an active call.
We are now ringing the other participant.
static struct CallList * cl_active
Caller handle (for active incoming call).
struct GNUNET_CONVERSATION_Caller * caller
Handle to hang up or activate.
The call is currently suspended (by us).
We are looking up some other participant.
void GNUNET_CONVERSATION_call_suspend(struct GNUNET_CONVERSATION_Call *call)
Pause a call.
Here is the call graph for this function:

◆ do_resume()

static void do_resume ( const char *  args)
static

Resuming a call.

Parameters
argsarguments given to the command

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

References _, buf, call_state, CallList::caller, CallList::caller_num, 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(), CallList::next, peer_key, phone_state, PS_ACCEPTED, PS_ERROR, PS_LISTEN, and PS_LOOKUP_EGO.

798 {
799  struct CallList *cl;
800  char buf[32];
801 
802  if (NULL != call)
803  {
804  switch (call_state)
805  {
806  case CS_RESOLVING:
807  case CS_RINGING:
808  case CS_CONNECTED:
809  fprintf (stderr,
810  "%s",
811  _ ("There is no call that could be resumed right now.\n"));
812  return;
813 
814  case CS_SUSPENDED:
817  return;
818  }
819  }
820  switch (phone_state)
821  {
822  case PS_LOOKUP_EGO:
823  case PS_ERROR:
824  fprintf (stderr,
825  "%s",
826  _ ("There is no call that could be resumed right now.\n"));
827  return;
828 
829  case PS_LISTEN:
830  /* expected state, do resume logic */
831  break;
832 
833  case PS_ACCEPTED:
834  fprintf (stderr,
835  _ ("Already talking with `%s', cannot resume a call right now.\n"),
837  return;
838  }
839  GNUNET_assert (NULL == cl_active);
840  cl = cl_head;
841  if (NULL == cl)
842  {
843  fprintf (stderr, _ ("There is no incoming call to resume here!\n"));
844  return;
845  }
846  if ((NULL != cl->next) || (NULL != args))
847  {
848  for (cl = cl_head; NULL != cl; cl = cl->next)
849  {
850  GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
851  if (0 == strcmp (buf, args))
852  break;
853  }
854  }
855  if (NULL == cl)
856  {
857  fprintf (stderr,
858  _ ("There is no incoming call `%s' to resume right now!\n"),
859  args);
860  return;
861  }
862  cl_active = cl;
865 }
Internal error.
We're waiting for our own idenitty.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
List of incoming calls.
unsigned int caller_num
Unique number of the call.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static enum CallState call_state
Our call's current state.
static enum PhoneState phone_state
Our phone's current state.
static struct CallList * cl_head
Head of calls waiting to be accepted.
struct CallList * next
A DLL.
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We accepted an incoming phone call.
static struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
void GNUNET_CONVERSATION_call_resume(struct GNUNET_CONVERSATION_Call *call, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
Resumes a call after GNUNET_CONVERSATION_call_suspend.
static char buf[2048]
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
static struct GNUNET_CRYPTO_EcdsaPublicKey peer_key
Public key of active conversation partner (if any).
The other party accepted our call and we are now connected.
void GNUNET_CONVERSATION_caller_resume(struct GNUNET_CONVERSATION_Caller *caller, struct GNUNET_SPEAKER_Handle *speaker, struct GNUNET_MICROPHONE_Handle *mic)
Resume suspended conversation of a phone.
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
We are now ringing the other participant.
static struct CallList * cl_active
Caller handle (for active incoming call).
struct GNUNET_CONVERSATION_Caller * caller
Handle to hang up or activate.
The call is currently suspended (by us).
We are looking up some other participant.
Here is the call graph for this function:

◆ do_reject()

static void do_reject ( const char *  args)
static

Rejecting a call.

Parameters
argsarguments given to the command

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

References _, buf, CallList::caller, CallList::caller_num, cl_head, 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.

875 {
876  struct CallList *cl;
877  char buf[32];
878 
879  if (NULL != call)
880  {
882  call = NULL;
883  return;
884  }
885  switch (phone_state)
886  {
887  case PS_LOOKUP_EGO:
888  case PS_ERROR:
889  fprintf (stderr,
890  "%s",
891  _ ("There is no call that could be cancelled right now.\n"));
892  return;
893 
894  case PS_LISTEN:
895  /* look for active incoming calls to refuse */
896  cl = cl_head;
897  if (NULL == cl)
898  {
899  fprintf (stderr, _ ("There is no incoming call to refuse here!\n"));
900  return;
901  }
902  if ((NULL != cl->next) || (NULL != args))
903  {
904  for (cl = cl_head; NULL != cl; cl = cl->next)
905  {
906  GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
907  if (0 == strcmp (buf, args))
908  break;
909  }
910  }
911  if (NULL == cl)
912  {
913  fprintf (stderr,
914  _ ("There is no incoming call `%s' to refuse right now!\n"),
915  args);
916  return;
917  }
920  GNUNET_free (cl);
921  break;
922 
923  case PS_ACCEPTED:
924  /* expected state, do rejection logic */
925  GNUNET_assert (NULL != cl_active);
927  cl_active = NULL;
929  break;
930  }
931 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CallList * cl_tail
Tail of calls waiting to be accepted.
Internal error.
We're waiting for our own idenitty.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
List of incoming calls.
unsigned int caller_num
Unique number of the call.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_CONVERSATION_caller_hang_up(struct GNUNET_CONVERSATION_Caller *caller)
Hang up up a (possibly ringing) phone.
static enum PhoneState phone_state
Our phone's current state.
static struct CallList * cl_head
Head of calls waiting to be accepted.
struct CallList * next
A DLL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
We accepted an incoming phone call.
static char buf[2048]
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
We're listening for calls.
void GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call)
Terminate a call.
static struct CallList * cl_active
Caller handle (for active incoming call).
struct GNUNET_CONVERSATION_Caller * caller
Handle to hang up or activate.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ do_stop_task()

static void do_stop_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsNULL

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

References ego_name, GNUNET_CONVERSATION_call_stop(), GNUNET_CONVERSATION_phone_destroy(), GNUNET_free, GNUNET_free_non_null, GNUNET_IDENTITY_disconnect(), GNUNET_MICROPHONE_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_SPEAKER_destroy(), peer_name, phone_state, and PS_ERROR.

Referenced by run().

1010 {
1011  (void) cls;
1012  if (NULL != call)
1013  {
1015  call = NULL;
1016  }
1017  if (NULL != phone)
1018  {
1020  phone = NULL;
1021  }
1022  if (NULL != handle_cmd_task)
1023  {
1025  handle_cmd_task = NULL;
1026  }
1027  if (NULL != id)
1028  {
1030  id = NULL;
1031  }
1033  speaker = NULL;
1035  mic = NULL;
1037  ego_name = NULL;
1039  peer_name = NULL;
1041 }
static struct GNUNET_CONVERSATION_Phone * phone
Phone handle.
Internal error.
static struct GNUNET_SCHEDULER_Task * handle_cmd_task
Task which handles the commands.
static char * ego_name
Name of our ego.
static enum PhoneState phone_state
Our phone's current state.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static char * peer_name
Name of active conversation partner (if any).
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
static struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
void GNUNET_CONVERSATION_phone_destroy(struct GNUNET_CONVERSATION_Phone *phone)
Destroys a phone.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:837
void GNUNET_SPEAKER_destroy(struct GNUNET_SPEAKER_Handle *speaker)
Destroy a speaker.
Definition: speaker.c:182
static struct GNUNET_CONVERSATION_Call * call
Call handle (for active outgoing call).
void GNUNET_MICROPHONE_destroy(struct GNUNET_MICROPHONE_Handle *microphone)
Destroy a microphone.
Definition: microphone.c:193
void GNUNET_CONVERSATION_call_stop(struct GNUNET_CONVERSATION_Call *call)
Terminate a call.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
messagecommand the user typed in
str_lennumber of bytes to process in message

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

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

Referenced by handle_command().

1052 {
1053  size_t i;
1054  const char *ptr;
1055 
1056  if (0 == str_len)
1057  return;
1058  if (message[str_len - 1] == '\n')
1059  message[str_len - 1] = '\0';
1060  if (message[str_len - 2] == '\r')
1061  message[str_len - 2] = '\0';
1062  if (0 == strlen (message))
1063  return;
1064  i = 0;
1065  while (
1066  (NULL != commands[i].command) &&
1067  (0 !=
1068  strncasecmp (commands[i].command, message, strlen (commands[i].command))))
1069  i++;
1070  ptr = &message[strlen (commands[i].command)];
1071  while (isspace ((unsigned char) *ptr))
1072  ptr++;
1073  if ('\0' == *ptr)
1074  ptr = NULL;
1075  commands[i].Action (ptr);
1076 }
static struct VoipCommand commands[]
List of supported commands.
ActionFunction Action
Function to call on 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
clsNULL

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

References GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_UNIT_FOREVER_REL, handle_command_string(), and MAX_MESSAGE_LENGTH.

Referenced by run().

1086 {
1087  char message[MAX_MESSAGE_LENGTH + 1];
1088 
1089  (void) cls;
1090  handle_cmd_task =
1092  stdin_fh,
1093  &handle_command,
1094  NULL);
1095  /* read message from command line and handle it */
1096  memset (message, 0, MAX_MESSAGE_LENGTH + 1);
1097  if (NULL == fgets (message, MAX_MESSAGE_LENGTH, stdin))
1098  return;
1099  handle_command_string (message, strlen (message));
1100 }
static void handle_command(void *cls)
Task to handle commands from the terminal.
static struct GNUNET_SCHEDULER_Task * handle_cmd_task
Task which handles the commands.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1636
static void handle_command_string(char *message, size_t str_len)
Handle user command.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static struct GNUNET_DISK_FileHandle * stdin_fh
File handle for stdin.
#define MAX_MESSAGE_LENGTH
Maximum length allowed for the command line input.
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
clsNULL
egoego handle
ctxunused
namename of the ego

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

References _, ego_name, GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_strdup, line, start_phone(), and verbose.

Referenced by run().

1116 {
1117  (void) cls;
1118  (void) ctx;
1119  if (NULL == name)
1120  return;
1121  if (ego == my_caller_id)
1122  {
1123  if (verbose)
1124  fprintf (stdout, _ ("Name of our ego changed to `%s'\n"), name);
1127  return;
1128  }
1129  if (0 != strcmp (name, ego_name))
1130  return;
1131  if (NULL == ego)
1132  {
1133  if (verbose)
1134  fprintf (stdout, _ ("Our ego `%s' was deleted!\n"), ego_name);
1135  my_caller_id = NULL;
1136  return;
1137  }
1138  my_caller_id = ego;
1139  GNUNET_CONFIGURATION_set_value_string (cfg, "CONVERSATION", "LINE", line);
1140  start_phone ();
1141 }
static char * ego_name
Name of our ego.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * line
Desired phone line (string to be converted to a hash).
static struct GNUNET_IDENTITY_Ego * my_caller_id
Our ego.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
static void start_phone()
Start our phone.
static int verbose
Be verbose.
const char * name
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cconfiguration

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

References _, 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_command(), and identity_cb().

Referenced by main().

1157 {
1158  (void) cls;
1159  (void) args;
1160  (void) cfgfile;
1164  if (NULL == ego_name)
1165  {
1166  fprintf (stderr, "%s", _ ("You must specify the NAME of an ego to use\n"));
1167  return;
1168  }
1169  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
1170  handle_cmd_task =
1172  &handle_command,
1173  NULL);
1175 }
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:527
static void handle_command(void *cls)
Task to handle commands from the terminal.
static struct GNUNET_SCHEDULER_Task * handle_cmd_task
Task which handles the commands.
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
struct GNUNET_SPEAKER_Handle * GNUNET_SPEAKER_create_from_hardware(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a speaker that corresponds to the speaker hardware of our system.
Definition: speaker.c:158
static char * ego_name
Name of our ego.
static struct GNUNET_MICROPHONE_Handle * mic
Our microphone.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:1207
Run with priority for interactive tasks.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_SPEAKER_Handle * speaker
Our speaker.
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.
static void do_stop_task(void *cls)
Task run during shutdown.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
struct GNUNET_MICROPHONE_Handle * GNUNET_MICROPHONE_create_from_hardware(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a microphone that corresponds to the microphone hardware of our system.
Definition: microphone.c:170
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
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

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

References ego_name, gettext_noop, GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_get_handle_from_int_fd(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_string(), GNUNET_log_strerror, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), line, ret, and run().

1187 {
1190  'e',
1191  "ego",
1192  "NAME",
1193  gettext_noop ("sets the NAME of the ego to use for the caller ID"),
1194  &ego_name),
1196  "phone",
1197  "LINE",
1198  gettext_noop (
1199  "sets the LINE to use for the phone"),
1200  &line),
1202  int ret;
1203 
1204  int flags;
1205  flags = fcntl (0, F_GETFL, 0);
1206  flags |= O_NONBLOCK;
1207  if (0 != fcntl (0, F_SETFL, flags))
1210 
1211  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1212  return 2;
1213  ret =
1214  GNUNET_PROGRAM_run (argc,
1215  argv,
1216  "gnunet-conversation",
1217  gettext_noop (
1218  "Enables having a conversation with other GNUnet users."),
1219  options,
1220  &run,
1221  NULL);
1222  GNUNET_free ((void *) argv);
1223  if (NULL != cfg)
1224  {
1226  cfg = NULL;
1227  }
1228  return (GNUNET_OK == ret) ? 0 : 1;
1229 }
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.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
static char * ego_name
Name of our ego.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Definition of a command line option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
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.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
static char * line
Desired phone line (string to be converted to a hash).
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
static struct GNUNET_DISK_FileHandle * stdin_fh
File handle for stdin.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1375
int 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, parse options).
Definition: program.c:367
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

Variable Documentation

◆ phone

struct GNUNET_CONVERSATION_Phone* phone
static

Phone handle.

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

◆ call

struct GNUNET_CONVERSATION_Call* call
static

◆ 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 142 of file gnunet-conversation.c.

Referenced by phone_event_handler().

◆ cl_head

struct CallList* cl_head
static

Head of calls waiting to be accepted.

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

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

◆ cl_tail

struct CallList* cl_tail
static

Tail of calls waiting to be accepted.

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

◆ line

char* line
static

◆ handle_cmd_task

struct GNUNET_SCHEDULER_Task* handle_cmd_task
static

Task which handles the commands.

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

◆ speaker

struct GNUNET_SPEAKER_Handle* speaker
static

Our speaker.

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

◆ mic

struct GNUNET_MICROPHONE_Handle* mic
static

◆ cfg

struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

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

◆ my_caller_id

struct GNUNET_IDENTITY_Ego* my_caller_id
static

Our ego.

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

◆ id

struct GNUNET_IDENTITY_Handle* id
static

◆ ego_name

char* ego_name
static

Name of our ego.

Definition at line 192 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_EcdsaPublicKey peer_key
static

Public key of active conversation partner (if any).

Definition at line 197 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 202 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 207 of file gnunet-conversation.c.

◆ phone_state

enum PhoneState phone_state
static

Our phone's current state.

Definition at line 212 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 217 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 222 of file gnunet-conversation.c.

Referenced by phone_event_handler().

◆ address

char* address
static

◆ verbose

int verbose
static

Be verbose.

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

Referenced by identity_cb().

◆ commands

struct VoipCommand commands[]
static

List of supported commands.

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