GNUnet  0.19.2
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_Handlesh
 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_Operationset_op
 Operation handle for set operation. More...
 
static struct GNUNET_IDENTITY_Operationcreate_op
 Handle for create operation. More...
 
static struct GNUNET_IDENTITY_Operationdelete_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
clsNULL

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

141 {
142  if (NULL != set_op)
143  {
145  set_op = NULL;
146  }
147  if (NULL != create_op)
148  {
150  create_op = NULL;
151  }
152  if (NULL != delete_op)
153  {
155  delete_op = NULL;
156  }
157  if (NULL != set_ego)
158  {
160  set_ego = NULL;
161  }
163  sh = NULL;
164 }
static struct GNUNET_IDENTITY_Operation * set_op
Operation handle for set operation.
static struct GNUNET_IDENTITY_Operation * create_op
Handle for create operation.
static struct GNUNET_IDENTITY_Handle * sh
Handle to IDENTITY service.
static struct GNUNET_IDENTITY_Operation * delete_op
Handle for delete operation.
static char * set_ego
-s option.
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:740
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:757
#define GNUNET_free(ptr)
Wrapper around free.

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.

172 {
173  if ( (NULL == create_op) &&
174  (NULL == delete_op) &&
175  (NULL == set_op) &&
176  (NULL == write_msg) &&
177  (NULL == read_msg) &&
178  (! list) &&
179  (! monitor))
180  {
182  global_ret = 0;
184  }
185 }
#define TIMEOUT_STATUS_CODE
Return value from main on timeout.
static int global_ret
Value to return from main().
static int monitor
Was "monitor" specified?
static int list
Was "list" specified?
static char * read_msg
-R option
static char * write_msg
-W option
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:534

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
clspointer to operation handle
ecthe error code

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

197 {
198  struct GNUNET_IDENTITY_Operation **op = cls;
199 
200  *op = NULL;
201  if (GNUNET_EC_NONE != ec)
202  fprintf (stderr, "%s\n", GNUNET_ErrorCode_get_hint (ec));
203  test_finished ();
204 }
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
@ GNUNET_EC_NONE
No error (success).
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static void test_finished(void)
Test if we are finished yet.
Handle for an operation with the identity service.
Definition: identity_api.c:41
void * cls
Closure for cont or cb.
Definition: identity_api.c:89

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
clspointer to operation handle
pkprivate key of the ego, or NULL on error
ecthe error code

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

218 {
219  struct GNUNET_IDENTITY_Operation **op = cls;
220 
221  *op = NULL;
222  if (NULL == pk)
223  {
224  fprintf (stderr,
225  _ ("Failed to create ego: %s\n"),
227  global_ret = 1;
228  }
229  else if (verbose)
230  {
232  char *pubs;
233 
236  if (private_keys)
237  {
238  char *privs;
239 
241  fprintf (stdout, "%s - %s\n", pubs, privs);
242  GNUNET_free (privs);
243  }
244  else
245  {
246  fprintf (stdout, "%s\n", pubs);
247  }
248  GNUNET_free (pubs);
249  }
250  test_finished ();
251 }
static unsigned int verbose
Was "verbose" specified?
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
static int private_keys
Was "private" specified?
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:47
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:179
char * GNUNET_IDENTITY_private_key_to_string(const struct GNUNET_IDENTITY_PrivateKey *key)
Creates a (Base32) string representation of the private key.
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
An identity key as per LSD0001.

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.

260 {
261  struct GNUNET_IDENTITY_PublicKey recipient;
264  {
265  struct GNUNET_CRYPTO_EcdhePublicKey message_key;
266  size_t msg_len = strlen (write_msg) + 1;
268  msg_len,
269  &recipient,
270  &message_key,
271  write_msg);
272  if (-1 != res)
273  {
274  char *keystr;
275  char *serialized_msg;
276  keystr = GNUNET_STRINGS_data_to_string_alloc (&message_key,
277  sizeof(struct
280  msg_len);
281  fprintf (stdout,
282  "%s.%s\n",
283  keystr, serialized_msg);
284  GNUNET_free (keystr);
285  GNUNET_free (serialized_msg);
286  }
287  else
288  {
289  fprintf (stderr, "Error during encryption.\n");
290  global_ret = 1;
291  }
292  }
293  else
294  {
295  fprintf (stderr, "Invalid recipient public key.\n");
296  global_ret = 1;
297  }
298 }
static int res
static char * pubkey_msg
-k option
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
ssize_t GNUNET_IDENTITY_encrypt(const void *block, size_t size, const struct GNUNET_IDENTITY_PublicKey *pub, struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is re...
@ GNUNET_SYSERR
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:763
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and encr...

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
egoego whose private key is used for decryption

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

309 {
310  // message contains ECDHE key and ciphertext divided by ".", so split up first
311  char delim[2] = ".";
312  char *key_msg = strtok (read_msg, delim);
313  char *cipher;
314  if (NULL == key_msg)
315  {
316  fprintf (stderr, "Invalid message format.\n");
317  global_ret = 1;
318  return;
319  }
320  cipher = strtok (NULL, delim);
321  if (NULL == cipher)
322  {
323  fprintf (stderr, "Invalid message format, text missing.\n");
324  global_ret = 1;
325  return;
326  }
327 
328  if (NULL != strtok (NULL, delim))
329  {
330  fprintf (stderr,
331  "Invalid message format, expecting only key and cipher components.\n");
332  global_ret = 1;
333  return;
334  }
335 
336  struct GNUNET_CRYPTO_EcdhePublicKey message_key;
337  if (GNUNET_OK == GNUNET_STRINGS_string_to_data (key_msg, strlen (
338  key_msg),
339  &message_key,
340  sizeof(message_key)))
341  {
342  char *deserialized_msg;
343  size_t msg_len;
344  if (GNUNET_OK == GNUNET_STRINGS_string_to_data_alloc (cipher, strlen (
345  cipher),
346  (void **) &
347  deserialized_msg,
348  &msg_len))
349  {
350  ssize_t res = GNUNET_IDENTITY_decrypt (deserialized_msg,
351  msg_len,
353  ego),
354  &message_key,
355  deserialized_msg);
356  if (-1 != res)
357  {
358  deserialized_msg[res - 1] = '\0';
359  fprintf (stdout,
360  "%s\n",
361  deserialized_msg);
362  }
363  else
364  {
365  fprintf (stderr, "Failed to decrypt message.\n");
366  global_ret = 1;
367  }
368  GNUNET_free (deserialized_msg);
369  }
370  else
371  {
372  fprintf (stderr, "Invalid message format.\n");
373  global_ret = 1;
374  }
375  }
376  else
377  {
378  fprintf (stderr, "Invalid message ephemeral key.\n");
379  global_ret = 1;
380  }
381 }
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:560
ssize_t GNUNET_IDENTITY_decrypt(const void *block, size_t size, const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ...
@ GNUNET_OK
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data_alloc(const char *enc, size_t enclen, void **out, size_t *out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:854
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:788

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
clsclosure
egoego handle
ctxcontext for application to store data for this ego (during the lifetime of this process, initially NULL)
identifieridentifier 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.

421 {
423  char *s;
424  char *privs;
425 
426  if ( (NULL == ego) &&
427  (NULL != set_ego) &&
428  (NULL != read_msg) )
429  {
430  fprintf (stderr,
431  "Ego `%s' is not known, cannot decrypt message.\n",
432  set_ego);
434  read_msg = NULL;
436  set_ego = NULL;
437  }
438  if ((NULL == ego) && (! monitor))
439  {
440  list = 0;
441  test_finished ();
442  return;
443  }
444  if (! (list | monitor) && (NULL == read_msg))
445  return;
446  if ( (NULL == ego) ||
447  (NULL == identifier) )
448  return;
449  if ( (NULL != set_ego) &&
450  (0 != strcmp (identifier,
451  set_ego)) )
452  return;
457  if ((NULL != read_msg) && (NULL != set_ego))
458  {
459  // due to the check above, set_ego and the identifier are equal
462  read_msg = NULL;
463  }
464  else if ((monitor) || (NULL != identifier))
465  {
466  if (quiet)
467  {
468  if (private_keys)
469  fprintf (stdout, "%s - %s\n", s, privs);
470  else
471  fprintf (stdout, "%s\n", s);
472  }
473  else
474  {
475  if (private_keys)
476  fprintf (stdout, "%s - %s - %s - %s\n",
477  identifier, s, privs,
478  (ntohl (pk.type) == GNUNET_IDENTITY_TYPE_ECDSA) ?
479  "ECDSA" : "EdDSA");
480  else
481  fprintf (stdout, "%s - %s - %s\n",
482  identifier, s,
483  (ntohl (pk.type) == GNUNET_IDENTITY_TYPE_ECDSA) ?
484  "ECDSA" : "EdDSA");
485 
486  }
487  }
488  GNUNET_free (privs);
489  GNUNET_free (s);
490 }
static int quiet
Was "quiet" specified?
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.
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:573
@ GNUNET_IDENTITY_TYPE_ECDSA
The identity type.
uint32_t type
Type of public key.

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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

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

506 {
507  if ((NULL != read_msg) && (NULL == set_ego))
508  {
509  fprintf (stderr,
510  "Option -R requires options -e to be specified as well.\n");
511  return;
512  }
513 
514  if ((NULL != write_msg) && (NULL == pubkey_msg))
515  {
516  fprintf (stderr, "Option -W requires option -k to be specified as well.\n");
517  return;
518  }
520  (monitor | list) ||
521  (NULL != set_ego)
522  ? &print_ego
523  : NULL,
524  NULL);
525  if (NULL != write_msg)
526  {
529  write_msg = NULL;
530  }
531  // read message is handled in ego callback (print_ego)
532  if (NULL != delete_ego)
533  delete_op =
535  delete_ego,
537  &delete_op);
538  if (NULL != create_ego)
539  {
540  if (NULL != privkey_ego)
541  {
543  strlen (privkey_ego),
544  &pk,
545  sizeof(struct
547  create_op =
549  create_ego,
550  &pk,
551  0, // Ignored
553  &create_op);
554  }
555  else
556  create_op =
558  create_ego,
559  NULL,
560  (type_eddsa) ?
564  &create_op);
565  }
567  NULL);
568  test_finished ();
569 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static void create_finished(void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)
Creation operation finished.
static void write_encrypted_message(void)
Encrypt a message given with -W, encrypted using public key of an identity given with -k.
static char * privkey_ego
-P option
static void shutdown_task(void *cls)
Task run on shutdown.
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.
static char * delete_ego
-D option
static char * create_ego
-C option
static int type_eddsa
Was "eddsa" specified?
static void delete_finished(void *cls, enum GNUNET_ErrorCode ec)
Deletion operation finished.
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_create(struct GNUNET_IDENTITY_Handle *h, const char *name, const struct GNUNET_IDENTITY_PrivateKey *privkey, enum GNUNET_IDENTITY_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
Create a new ego with the given name.
Definition: identity_api.c:586
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:531
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_delete(struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Delete an existing identity.
Definition: identity_api.c:699
@ GNUNET_IDENTITY_TYPE_EDDSA
EDDSA identity.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1303
A private key for an identity as per LSD0001.

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
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

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

581 {
584  "create",
585  "NAME",
586  gettext_noop ("create ego NAME"),
587  &create_ego),
589  "delete",
590  "NAME",
591  gettext_noop ("delete ego NAME "),
592  &delete_ego),
594  "privkey",
595  "PRIVATE_KEY",
596  gettext_noop (
597  "set the private key for the identity to PRIVATE_KEY (use together with -C)"),
598  &privkey_ego),
600  "read",
601  "MESSAGE",
602  gettext_noop (
603  "Read and decrypt message encrypted for the given ego (use together with -e EGO)"),
604  &read_msg),
606  "write",
607  "MESSAGE",
608  gettext_noop (
609  "Encrypt and write message for recipient identity PULBIC_KEY, (use together with -k RECIPIENT_PUBLIC_KEY)"),
610  &write_msg),
612  "eddsa",
613  gettext_noop (
614  "generate an EdDSA identity. (use together with -C) EXPERIMENTAL"),
615  &type_eddsa),
617  "display",
618  gettext_noop ("display all egos"),
619  &list),
621  "quiet",
622  gettext_noop ("reduce output"),
623  &quiet),
625  'e',
626  "ego",
627  "NAME",
628  gettext_noop (
629  "restrict results to NAME (use together with -d) or read and decrypt a message for NAME (use together with -R)"),
630  &set_ego),
632  "key",
633  "PUBLIC_KEY",
634  gettext_noop (
635  "The public key of the recipient (with -W)"),
636  &pubkey_msg),
638  "monitor",
639  gettext_noop ("run in monitor mode egos"),
640  &monitor),
642  "private-keys",
643  gettext_noop ("display private keys as well"),
644  &private_keys),
647  };
648  int res;
649 
650  if (GNUNET_OK !=
651  GNUNET_STRINGS_get_utf8_args (argc, argv,
652  &argc, &argv))
653  return 4;
654  global_ret = TIMEOUT_STATUS_CODE; /* timeout */
655  res = GNUNET_PROGRAM_run (argc,
656  argv,
657  "gnunet-identity",
658  gettext_noop ("Maintain egos"),
659  options,
660  &run,
661  NULL);
662  GNUNET_free_nz ((void *) argv);
663 
664  if (GNUNET_OK != res)
665  return 3;
666  return global_ret;
667 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:70
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.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_verbose(unsigned int *level)
Define the '-V' verbosity option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define GNUNET_free_nz(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1222
Definition of a command line option.

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

◆ global_ret

int global_ret
static