gnunet-identity.c File Reference

IDENTITY management command line tool. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_identity_service.h"

Include dependency graph for gnunet-identity.c:

Go to the source code of this file.

Macros
#define	TIMEOUT_STATUS_CODE   40
	Return value from main on timeout. More...

Functions
static void	shutdown_task (void *cls)
	Task run on shutdown. More...
static void	test_finished (void)
	Test if we are finished yet. More...
static void	delete_finished (void *cls, enum GNUNET_ErrorCode ec)
	Deletion operation finished. More...
static void	create_finished (void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)
	Creation operation finished. More...
static void	write_encrypted_message (void)
	Encrypt a message given with -W, encrypted using public key of an identity given with -k. More...
static void	read_encrypted_message (struct GNUNET_IDENTITY_Ego *ego)
	Decrypt a message given with -R, encrypted using public key of ego and ephemeral key given with -k. More...
static void	print_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
	If listing is enabled, prints information about the egos. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function. More...

Variables
static struct GNUNET_IDENTITY_Handle *	sh
	Handle to IDENTITY service. More...
static int	list
	Was "list" specified? More...
static int	monitor
	Was "monitor" specified? More...
static int	private_keys
	Was "private" specified? More...
static unsigned int	verbose
	Was "verbose" specified? More...
static int	quiet
	Was "quiet" specified? More...
static int	type_eddsa
	Was "eddsa" specified? More...
static char *	write_msg
	-W option More...
static char *	read_msg
	-R option More...
static char *	create_ego
	-C option More...
static char *	delete_ego
	-D option More...
static char *	privkey_ego
	-P option More...
static char *	pubkey_msg
	-k option More...
static char *	set_ego
	-s option. More...
static struct GNUNET_IDENTITY_Operation *	set_op
	Operation handle for set operation. More...
static struct GNUNET_IDENTITY_Operation *	create_op
	Handle for create operation. More...
static struct GNUNET_IDENTITY_Operation *	delete_op
	Handle for delete operation. More...
struct GNUNET_IDENTITY_PrivateKey	pk
	Private key from command line option, or NULL. More...
static int	global_ret
	Value to return from main(). More...

Detailed Description

IDENTITY management command line tool.

Author

Christian Grothoff

Todo:

• add options to get default egos

Definition in file gnunet-identity.c.

Macro Definition Documentation

TIMEOUT_STATUS_CODE

#define TIMEOUT_STATUS_CODE   40

Return value from main on timeout.

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

Function Documentation

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run on shutdown.

Parameters

cls

NULL

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

{
  if (NULL != set_op)
  {
    GNUNET_IDENTITY_cancel (set_op);
    set_op = NULL;
  }
  if (NULL != create_op)
  {
    GNUNET_IDENTITY_cancel (create_op);
    create_op = NULL;
  }
  if (NULL != delete_op)
  {
    GNUNET_IDENTITY_cancel (delete_op);
    delete_op = NULL;
  }
  if (NULL != set_ego)
  {
    GNUNET_free (set_ego);
    set_ego = NULL;
  }
  GNUNET_IDENTITY_disconnect (sh);
  sh = NULL;
}

References create_op, delete_op, GNUNET_free, GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_disconnect(), set_ego, set_op, and sh.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

test_finished()

static void test_finished ( void  )

static

Test if we are finished yet.

Definition at line 171 of file gnunet-identity.c.

{
  if ( (NULL == create_op) &&
       (NULL == delete_op) &&
       (NULL == set_op) &&
       (NULL == write_msg) &&
       (NULL == read_msg) &&
       (! list) &&
       (! monitor))
  {
    if (TIMEOUT_STATUS_CODE == global_ret)
      global_ret = 0;
    GNUNET_SCHEDULER_shutdown ();
  }
}

References create_op, delete_op, global_ret, GNUNET_SCHEDULER_shutdown(), list, monitor, read_msg, set_op, TIMEOUT_STATUS_CODE, and write_msg.

Referenced by create_finished(), delete_finished(), print_ego(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_finished()

static void delete_finished ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Deletion operation finished.

Parameters

cls	pointer to operation handle
ec	the error code

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

{
  struct GNUNET_IDENTITY_Operation **op = cls;
 
  *op = NULL;
  if (GNUNET_EC_NONE != ec)
    fprintf (stderr, "%s\n", GNUNET_ErrorCode_get_hint (ec));
  test_finished ();
}

References GNUNET_IDENTITY_Operation::cls, GNUNET_EC_NONE, GNUNET_ErrorCode_get_hint(), op, and test_finished().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

create_finished()

static void create_finished ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  pk, enum GNUNET_ErrorCode  ec  )

static

Creation operation finished.

Parameters

cls	pointer to operation handle
pk	private key of the ego, or NULL on error
ec	the error code

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

{
  struct GNUNET_IDENTITY_Operation **op = cls;
 
  *op = NULL;
  if (NULL == pk)
  {
    fprintf (stderr,
             _ ("Failed to create ego: %s\n"),
             GNUNET_ErrorCode_get_hint (ec));
    global_ret = 1;
  }
  else if (verbose)
  {
    struct GNUNET_IDENTITY_PublicKey pub;
    char *pubs;
 
    GNUNET_IDENTITY_key_get_public (pk, &pub);
    pubs = GNUNET_IDENTITY_public_key_to_string (&pub);
    if (private_keys)
    {
      char *privs;
 
      privs = GNUNET_IDENTITY_private_key_to_string (pk);
      fprintf (stdout, "%s - %s\n", pubs, privs);
      GNUNET_free (privs);
    }
    else
    {
      fprintf (stdout, "%s\n", pubs);
    }
    GNUNET_free (pubs);
  }
  test_finished ();
}

References _, GNUNET_IDENTITY_Operation::cls, global_ret, GNUNET_ErrorCode_get_hint(), GNUNET_free, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_private_key_to_string(), GNUNET_IDENTITY_public_key_to_string(), op, pk, private_keys, pub, test_finished(), and verbose.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

write_encrypted_message()

static void write_encrypted_message ( void  )

static

Encrypt a message given with -W, encrypted using public key of an identity given with -k.

Definition at line 259 of file gnunet-identity.c.

{
  struct GNUNET_IDENTITY_PublicKey recipient;
  if (GNUNET_IDENTITY_public_key_from_string (pubkey_msg, &recipient) !=
      GNUNET_SYSERR)
  {
    struct GNUNET_CRYPTO_EcdhePublicKey message_key;
    size_t msg_len = strlen (write_msg) + 1;
    ssize_t res = GNUNET_IDENTITY_encrypt (write_msg,
                                           msg_len,
                                           &recipient,
                                           &message_key,
                                           write_msg);
    if (-1 != res)
    {
      char *keystr;
      char *serialized_msg;
      keystr = GNUNET_STRINGS_data_to_string_alloc (&message_key,
                                                    sizeof(struct
                                                           GNUNET_CRYPTO_EcdhePublicKey));
      serialized_msg = GNUNET_STRINGS_data_to_string_alloc (write_msg,
                                                            msg_len);
      fprintf (stdout,
               "%s.%s\n",
               keystr, serialized_msg);
      GNUNET_free (keystr);
      GNUNET_free (serialized_msg);
    }
    else
    {
      fprintf (stderr, "Error during encryption.\n");
      global_ret = 1;
    }
  }
  else
  {
    fprintf (stderr, "Invalid recipient public key.\n");
    global_ret = 1;
  }
}

References global_ret, GNUNET_free, GNUNET_IDENTITY_encrypt(), GNUNET_IDENTITY_public_key_from_string(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_SYSERR, pubkey_msg, res, and write_msg.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

read_encrypted_message()

static void read_encrypted_message ( struct GNUNET_IDENTITY_Ego *  ego )

static

Decrypt a message given with -R, encrypted using public key of ego and ephemeral key given with -k.

Parameters

ego	ego whose private key is used for decryption

Definition at line 308 of file gnunet-identity.c.

{
  // message contains ECDHE key and ciphertext divided by ".", so split up first
  char delim[2] = ".";
  char *key_msg = strtok (read_msg, delim);
  char *cipher;
  if (NULL == key_msg)
  {
    fprintf (stderr, "Invalid message format.\n");
    global_ret = 1;
    return;
  }
  cipher = strtok (NULL, delim);
  if (NULL == cipher)
  {
    fprintf (stderr, "Invalid message format, text missing.\n");
    global_ret = 1;
    return;
  }
 
  if (NULL != strtok (NULL, delim))
  {
    fprintf (stderr,
             "Invalid message format, expecting only key and cipher components.\n");
    global_ret = 1;
    return;
  }
 
  struct GNUNET_CRYPTO_EcdhePublicKey message_key;
  if (GNUNET_OK == GNUNET_STRINGS_string_to_data (key_msg, strlen (
                                                    key_msg),
                                                  &message_key,
                                                  sizeof(message_key)))
  {
    char *deserialized_msg;
    size_t msg_len;
    if (GNUNET_OK == GNUNET_STRINGS_string_to_data_alloc (cipher, strlen (
                                                            cipher),
                                                          (void **) &
                                                          deserialized_msg,
                                                          &msg_len))
    {
      ssize_t res = GNUNET_IDENTITY_decrypt (deserialized_msg,
                                             msg_len,
                                             GNUNET_IDENTITY_ego_get_private_key (
                                               ego),
                                             &message_key,
                                             deserialized_msg);
      if (-1 != res)
      {
        deserialized_msg[res - 1] = '\0';
        fprintf (stdout,
                 "%s\n",
                 deserialized_msg);
      }
      else
      {
        fprintf (stderr, "Failed to decrypt message.\n");
        global_ret = 1;
      }
      GNUNET_free (deserialized_msg);
    }
    else
    {
      fprintf (stderr, "Invalid message format.\n");
      global_ret = 1;
    }
  }
  else
  {
    fprintf (stderr, "Invalid message ephemeral key.\n");
    global_ret = 1;
  }
}

References global_ret, GNUNET_free, GNUNET_IDENTITY_decrypt(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_string_to_data_alloc(), read_msg, and res.

Referenced by print_ego().

Here is the call graph for this function:

Here is the caller graph for this function:

print_ego()

static void print_ego ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  identifier  )

static

If listing is enabled, prints information about the egos.

This function is initially called for all egos and then again whenever a ego's identifier changes or if it is deleted. At the end of the initial pass over all egos, the function is once called with 'NULL' for 'ego'. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get', this function is only called ONCE, and 'NULL' being passed in 'ego' does indicate an error (for example because name is taken or no default value is known). If 'ego' is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of 'GNUNET_IDENTITY_connect' (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW identifier.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the 'identifier'. In this case, the 'ego' is henceforth invalid (and the 'ctx' should also be cleaned up).

Parameters

cls	closure
ego	ego handle
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
identifier	identifier assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 417 of file gnunet-identity.c.

{
  struct GNUNET_IDENTITY_PublicKey pk;
  char *s;
  char *privs;
 
  if ( (NULL == ego) &&
       (NULL != set_ego) &&
       (NULL != read_msg) )
  {
    fprintf (stderr,
             "Ego `%s' is not known, cannot decrypt message.\n",
             set_ego);
    GNUNET_free (read_msg);
    read_msg = NULL;
    GNUNET_free (set_ego);
    set_ego = NULL;
  }
  if ((NULL == ego) && (! monitor))
  {
    list = 0;
    test_finished ();
    return;
  }
  if (! (list | monitor) && (NULL == read_msg))
    return;
  if ( (NULL == ego) ||
       (NULL == identifier) )
    return;
  if ( (NULL != set_ego) &&
       (0 != strcmp (identifier,
                     set_ego)) )
    return;
  GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
  s = GNUNET_IDENTITY_public_key_to_string (&pk);
  privs = GNUNET_IDENTITY_private_key_to_string (
    GNUNET_IDENTITY_ego_get_private_key (ego));
  if ((NULL != read_msg) && (NULL != set_ego))
  {
    // due to the check above, set_ego and the identifier are equal
    read_encrypted_message (ego);
    GNUNET_free (read_msg);
    read_msg = NULL;
  }
  else if ((monitor) || (NULL != identifier))
  {
    if (quiet)
    {
      if (private_keys)
        fprintf (stdout, "%s - %s\n", s, privs);
      else
        fprintf (stdout, "%s\n", s);
    }
    else
    {
      if (private_keys)
        fprintf (stdout, "%s - %s - %s - %s\n",
                 identifier, s, privs,
                 (ntohl (pk.type) == GNUNET_IDENTITY_TYPE_ECDSA) ?
                 "ECDSA" : "EdDSA");
      else
        fprintf (stdout, "%s - %s - %s\n",
                 identifier, s,
                 (ntohl (pk.type) == GNUNET_IDENTITY_TYPE_ECDSA) ?
                 "ECDSA" : "EdDSA");
 
    }
  }
  GNUNET_free (privs);
  GNUNET_free (s);
}

References GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_IDENTITY_private_key_to_string(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_IDENTITY_TYPE_ECDSA, list, monitor, pk, private_keys, quiet, read_encrypted_message(), read_msg, set_ego, test_finished(), and GNUNET_IDENTITY_PrivateKey::type.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

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

static

Main function that will be run by the scheduler.

Parameters

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

Definition at line 502 of file gnunet-identity.c.

{
  if ((NULL != read_msg) && (NULL == set_ego))
  {
    fprintf (stderr,
             "Option -R requires options -e to be specified as well.\n");
    return;
  }
 
  if ((NULL != write_msg) && (NULL == pubkey_msg))
  {
    fprintf (stderr, "Option -W requires option -k to be specified as well.\n");
    return;
  }
  sh = GNUNET_IDENTITY_connect (cfg,
                                (monitor | list) ||
                                (NULL != set_ego)
                                ? &print_ego
                                : NULL,
                                NULL);
  if (NULL != write_msg)
  {
    write_encrypted_message ();
    GNUNET_free (write_msg);
    write_msg = NULL;
  }
  // read message is handled in ego callback (print_ego)
  if (NULL != delete_ego)
    delete_op =
      GNUNET_IDENTITY_delete (sh,
                              delete_ego,
                              &delete_finished,
                              &delete_op);
  if (NULL != create_ego)
  {
    if (NULL != privkey_ego)
    {
      GNUNET_STRINGS_string_to_data (privkey_ego,
                                     strlen (privkey_ego),
                                     &pk,
                                     sizeof(struct
                                            GNUNET_IDENTITY_PrivateKey));
      create_op =
        GNUNET_IDENTITY_create (sh,
                                create_ego,
                                &pk,
                                0, // Ignored
                                &create_finished,
                                &create_op);
    }
    else
      create_op =
        GNUNET_IDENTITY_create (sh,
                                create_ego,
                                NULL,
                                (type_eddsa) ?
                                GNUNET_IDENTITY_TYPE_EDDSA :
                                GNUNET_IDENTITY_TYPE_ECDSA,
                                &create_finished,
                                &create_op);
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  test_finished ();
}

References cfg, create_ego, create_finished(), create_op, delete_ego, delete_finished(), delete_op, GNUNET_free, GNUNET_IDENTITY_connect(), GNUNET_IDENTITY_create(), GNUNET_IDENTITY_delete(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_IDENTITY_TYPE_EDDSA, GNUNET_SCHEDULER_add_shutdown(), GNUNET_STRINGS_string_to_data(), list, monitor, pk, print_ego(), privkey_ego, pubkey_msg, read_msg, set_ego, sh, shutdown_task(), test_finished(), type_eddsa, write_encrypted_message(), and write_msg.

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.

Parameters

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

Returns

0 ok, 1 on error

Definition at line 580 of file gnunet-identity.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('C',
                                 "create",
                                 "NAME",
                                 gettext_noop ("create ego NAME"),
                                 &create_ego),
    GNUNET_GETOPT_option_string ('D',
                                 "delete",
                                 "NAME",
                                 gettext_noop ("delete ego NAME "),
                                 &delete_ego),
    GNUNET_GETOPT_option_string ('P',
                                 "privkey",
                                 "PRIVATE_KEY",
                                 gettext_noop (
                                   "set the private key for the identity to PRIVATE_KEY (use together with -C)"),
                                 &privkey_ego),
    GNUNET_GETOPT_option_string ('R',
                                 "read",
                                 "MESSAGE",
                                 gettext_noop (
                                   "Read and decrypt message encrypted for the given ego (use together with -e EGO)"),
                                 &read_msg),
    GNUNET_GETOPT_option_string ('W',
                                 "write",
                                 "MESSAGE",
                                 gettext_noop (
                                   "Encrypt and write message for recipient identity PULBIC_KEY, (use together with -k RECIPIENT_PUBLIC_KEY)"),
                                 &write_msg),
    GNUNET_GETOPT_option_flag ('X',
                               "eddsa",
                               gettext_noop (
                                 "generate an EdDSA identity. (use together with -C) EXPERIMENTAL"),
                               &type_eddsa),
    GNUNET_GETOPT_option_flag ('d',
                               "display",
                               gettext_noop ("display all egos"),
                               &list),
    GNUNET_GETOPT_option_flag ('q',
                               "quiet",
                               gettext_noop ("reduce output"),
                               &quiet),
    GNUNET_GETOPT_option_string (
      'e',
      "ego",
      "NAME",
      gettext_noop (
        "restrict results to NAME (use together with -d) or read and decrypt a message for NAME (use together with -R)"),
      &set_ego),
    GNUNET_GETOPT_option_string ('k',
                                 "key",
                                 "PUBLIC_KEY",
                                 gettext_noop (
                                   "The public key of the recipient (with -W)"),
                                 &pubkey_msg),
    GNUNET_GETOPT_option_flag ('m',
                               "monitor",
                               gettext_noop ("run in monitor mode egos"),
                               &monitor),
    GNUNET_GETOPT_option_flag ('p',
                               "private-keys",
                               gettext_noop ("display private keys as well"),
                               &private_keys),
    GNUNET_GETOPT_option_verbose (&verbose),
    GNUNET_GETOPT_OPTION_END
  };
  int res;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return 4;
  global_ret = TIMEOUT_STATUS_CODE; /* timeout */
  res = GNUNET_PROGRAM_run (argc,
                            argv,
                            "gnunet-identity",
                            gettext_noop ("Maintain egos"),
                            options,
                            &run,
                            NULL);
  GNUNET_free_nz ((void *) argv);
 
  if (GNUNET_OK != res)
    return 3;
  return global_ret;
}

References create_ego, delete_ego, gettext_noop, global_ret, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), list, monitor, options, private_keys, privkey_ego, pubkey_msg, quiet, read_msg, res, run(), set_ego, TIMEOUT_STATUS_CODE, type_eddsa, verbose, and write_msg.

Here is the call graph for this function:

Variable Documentation

sh

struct GNUNET_IDENTITY_Handle* sh

static

Handle to IDENTITY service.

Definition at line 41 of file gnunet-identity.c.

Referenced by run(), and shutdown_task().

list

int list

static

Was "list" specified?

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

Referenced by main(), print_ego(), run(), and test_finished().

monitor

int monitor

static

Was "monitor" specified?

Definition at line 51 of file gnunet-identity.c.

Referenced by main(), print_ego(), run(), and test_finished().

private_keys

int private_keys

static

Was "private" specified?

Definition at line 56 of file gnunet-identity.c.

Referenced by create_finished(), main(), and print_ego().

verbose

unsigned int verbose

static

Was "verbose" specified?

Definition at line 61 of file gnunet-identity.c.

Referenced by create_finished(), and main().

quiet

int quiet

static

Was "quiet" specified?

Definition at line 66 of file gnunet-identity.c.

Referenced by main(), and print_ego().

type_eddsa

int type_eddsa

static

Was "eddsa" specified?

Definition at line 71 of file gnunet-identity.c.

Referenced by main(), and run().

write_msg

char* write_msg

static

-W option

Definition at line 76 of file gnunet-identity.c.

Referenced by main(), run(), test_finished(), and write_encrypted_message().

read_msg

char* read_msg

static

-R option

Definition at line 81 of file gnunet-identity.c.

Referenced by main(), print_ego(), read_encrypted_message(), run(), and test_finished().

create_ego

char* create_ego

static

-C option

Definition at line 86 of file gnunet-identity.c.

Referenced by main(), and run().

delete_ego

char* delete_ego

static

-D option

Definition at line 91 of file gnunet-identity.c.

Referenced by main(), and run().

privkey_ego

char* privkey_ego

static

-P option

Definition at line 96 of file gnunet-identity.c.

Referenced by main(), and run().

pubkey_msg

char* pubkey_msg

static

-k option

Definition at line 101 of file gnunet-identity.c.

Referenced by main(), run(), and write_encrypted_message().

set_ego

char* set_ego

static

-s option.

Definition at line 106 of file gnunet-identity.c.

Referenced by main(), print_ego(), run(), and shutdown_task().

set_op

struct GNUNET_IDENTITY_Operation* set_op

static

Operation handle for set operation.

Definition at line 111 of file gnunet-identity.c.

Referenced by shutdown_task(), and test_finished().

create_op

struct GNUNET_IDENTITY_Operation* create_op

static

Handle for create operation.

Definition at line 116 of file gnunet-identity.c.

Referenced by run(), shutdown_task(), and test_finished().

delete_op

struct GNUNET_IDENTITY_Operation* delete_op

static

Handle for delete operation.

Definition at line 121 of file gnunet-identity.c.

Referenced by run(), shutdown_task(), and test_finished().

pk

struct GNUNET_IDENTITY_PrivateKey pk

Private key from command line option, or NULL.

Definition at line 121 of file gnunet-identity.c.

Referenced by check_pkey(), check_signature(), clean_rsa_pub(), clean_rsa_public_key(), create_finished(), create_hostkeys(), create_keys(), create_response(), directory_trim_complete(), do_finished_create(), ego_create(), extract_rsa_pub(), get_ego(), gns_string_to_value(), gns_value_to_string(), GNUNET_CRYPTO_ecdhe_key_clear(), GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_ecdsa_key_clear(), GNUNET_CRYPTO_ecdsa_key_create(), GNUNET_CRYPTO_eddsa_key_clear(), GNUNET_CRYPTO_eddsa_key_create(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_edx25519_key_clear(), GNUNET_CRYPTO_edx25519_key_create(), GNUNET_CRYPTO_edx25519_key_create_from_seed(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_IDENTITY_encrypt(), GNUNET_JSON_from_rsa_public_key(), GNUNET_REVOCATION_proof_get_size(), GNUNET_TESTING_peer_configure(), GNUNET_TRANSPORT_application_suggest(), GSC_KX_init(), id_connect_cb(), list_ego(), origin_create_cb(), post_extract_rsa_public_key(), print_ego(), read_service_conf(), run(), and uri_ksk_continuation().

global_ret

int global_ret

static

Value to return from main().

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

Referenced by create_finished(), main(), read_encrypted_message(), test_finished(), and write_encrypted_message().