GNUnet  0.10.x
Functions | Variables
gnunet-credential.c File Reference

command line tool to access command line Credential service More...

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_credential_service.h>
#include <gnunet_gnsrecord_lib.h>
#include "credential_misc.h"
#include "credential_serialization.h"
Include dependency graph for gnunet-credential.c:

Go to the source code of this file.

Functions

static void do_shutdown (void *cls)
 Task run on shutdown. More...
 
static void do_timeout (void *cls)
 Task run on timeout. More...
 
static void handle_collect_result (void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *dc, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
 
static void handle_verify_result (void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *dc, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
 
static void identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
 Callback invoked from identity service with ego information. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 Main function that will be run. More...
 
int main (int argc, char *const *argv)
 The main function for gnunet-gns. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Configuration we are using. More...
 
static struct GNUNET_IDENTITY_EgoLookupel
 EgoLookup. More...
 
static struct GNUNET_CREDENTIAL_Handlecredential
 Handle to Credential service. More...
 
static struct GNUNET_TIME_Relative timeout
 Desired timeout for the lookup (default is no timeout). More...
 
static struct GNUNET_CREDENTIAL_Requestverify_request
 Handle to verify request. More...
 
static struct GNUNET_CREDENTIAL_Requestcollect_request
 Handle to collect request. More...
 
static struct GNUNET_SCHEDULER_Tasktt
 Task scheduled to handle timeout. More...
 
static char * subject_key
 Subject pubkey string. More...
 
static char * subject_credential
 Subject credential string. More...
 
static char * expiration
 Credential TTL. More...
 
struct GNUNET_CRYPTO_EcdsaPublicKey subject_pkey
 Subject key. More...
 
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_pkey
 Issuer key. More...
 
static char * issuer_key
 Issuer pubkey string. More...
 
static char * ego_name
 ego More...
 
static char * issuer_attr
 Issuer attribute. More...
 
static int verify
 Verify mode. More...
 
static int create_cred
 Issue mode. More...
 
static int collect
 Collect mode. More...
 

Detailed Description

command line tool to access command line Credential service

Author
Martin Schanzenbach

Definition in file gnunet-credential.c.

Function Documentation

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Task run on shutdown.

Cleans up everything.

Parameters
clsunused

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

References GNUNET_CREDENTIAL_disconnect(), GNUNET_CREDENTIAL_request_cancel(), and GNUNET_SCHEDULER_cancel().

Referenced by run().

130 {
131  if (NULL != verify_request)
132  {
134  verify_request = NULL;
135  }
136  if (NULL != credential)
137  {
139  credential = NULL;
140  }
141  if (NULL != tt)
142  {
144  tt = NULL;
145  }
146 }
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
void GNUNET_CREDENTIAL_request_cancel(struct GNUNET_CREDENTIAL_Request *lr)
Cancel pending verify request.
static struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
void GNUNET_CREDENTIAL_disconnect(struct GNUNET_CREDENTIAL_Handle *handle)
Shutdown connection with the CREDENTIAL service.
static struct GNUNET_CREDENTIAL_Request * verify_request
Handle to verify request.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_timeout()

static void do_timeout ( void *  cls)
static

Task run on timeout.

Triggers shutdown.

Parameters
clsunused

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

References GNUNET_SCHEDULER_shutdown().

Referenced by run().

156 {
157  tt = NULL;
159 }
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_collect_result()

static void handle_collect_result ( void *  cls,
unsigned int  d_count,
struct GNUNET_CREDENTIAL_Delegation dc,
unsigned int  c_count,
struct GNUNET_CREDENTIAL_Credential cred 
)
static

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

References GNUNET_CREDENTIAL_credential_to_string(), GNUNET_free, GNUNET_SCHEDULER_shutdown(), and line.

Referenced by identity_cb().

167 {
168  int i;
169  char* line;
170 
171  verify_request = NULL;
172  if (NULL != cred)
173  {
174  for (i = 0; i < c_count; i++)
175  {
177  printf("%s\n",
178  line);
179  GNUNET_free(line);
180  }
181  }
182 
183 
185 }
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
static char * line
Desired phone line (string to be converted to a hash).
char * GNUNET_CREDENTIAL_credential_to_string(const struct GNUNET_CREDENTIAL_Credential *cred)
static struct GNUNET_CREDENTIAL_Request * verify_request
Handle to verify request.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_verify_result()

static void handle_verify_result ( void *  cls,
unsigned int  d_count,
struct GNUNET_CREDENTIAL_Delegation dc,
unsigned int  c_count,
struct GNUNET_CREDENTIAL_Credential cred 
)
static

Definition at line 189 of file gnunet-credential.c.

References GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_free, GNUNET_SCHEDULER_shutdown(), issuer_key, and subject_key.

Referenced by run().

194 {
195  int i;
196  char* iss_key;
197  char* sub_key;
198 
199  verify_request = NULL;
200  if (NULL == cred)
201  printf("Failed.\n");
202  else
203  {
204  printf("Delegation Chain:\n");
205  for (i = 0; i < d_count; i++)
206  {
209  if (0 != dc[i].subject_attribute_len)
210  {
211  printf("(%d) %s.%s <- %s.%s\n", i,
212  iss_key, dc[i].issuer_attribute,
213  sub_key, dc[i].subject_attribute);
214  }
215  else
216  {
217  printf("(%d) %s.%s <- %s\n", i,
218  iss_key, dc[i].issuer_attribute,
219  sub_key);
220  }
221  GNUNET_free(iss_key);
222  GNUNET_free(sub_key);
223  }
224  printf("\nCredentials:\n");
225  for (i = 0; i < c_count; i++)
226  {
229  printf("%s.%s <- %s\n",
230  iss_key, cred[i].issuer_attribute,
231  sub_key);
232  GNUNET_free(iss_key);
233  GNUNET_free(sub_key);
234  }
235  printf("Successful.\n");
236  }
237 
238 
240 }
static char * subject_key
Subject pubkey string.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:334
static char * issuer_key
Issuer pubkey string.
static struct GNUNET_CREDENTIAL_Request * verify_request
Handle to verify request.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ identity_cb()

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

Callback invoked from identity service with ego information.

An ego of NULL means the ego was not found.

Parameters
clsclosure with the configuration
egoan ego known to identity service, or NULL

Definition at line 250 of file gnunet-credential.c.

References _, collect, ego_name, expiration, GNUNET_CREDENTIAL_collect(), GNUNET_CREDENTIAL_credential_issue(), GNUNET_CREDENTIAL_credential_to_string(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_free, GNUNET_free_non_null, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, handle_collect_result(), issuer_attr, issuer_key, issuer_pkey, res, and subject_pkey.

Referenced by run().

252 {
253  const struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey;
254  struct GNUNET_CREDENTIAL_Credential *crd;
255  struct GNUNET_TIME_Absolute etime_abs;
256  struct GNUNET_TIME_Relative etime_rel;
257  char *res;
258 
259  el = NULL;
260  if (NULL == ego)
261  {
262  if (NULL != ego_name)
263  {
264  fprintf(stderr,
265  _("Ego `%s' not known to identity service\n"),
266  ego_name);
267  }
269  return;
270  }
271 
272  if (GNUNET_YES == collect)
273  {
274  if (GNUNET_OK !=
276  strlen(issuer_key),
277  &issuer_pkey))
278  {
279  fprintf(stderr,
280  _("Issuer public key `%s' is not well-formed\n"),
281  issuer_key);
283  }
285 
287  &issuer_pkey,
288  issuer_attr, //TODO argument
289  privkey,
291  NULL);
292  return;
293  }
294 
295  //Else issue
296 
297  if (NULL == expiration)
298  {
299  fprintf(stderr,
300  "Please specify a TTL\n");
302  return;
303  }
305  &etime_rel))
306  {
307  etime_abs = GNUNET_TIME_relative_to_absolute(etime_rel);
308  }
310  &etime_abs))
311  {
312  fprintf(stderr,
313  "%s is not a valid ttl!\n",
314  expiration);
316  return;
317  }
318 
319 
322  ego_name = NULL;
324  &subject_pkey,
325  issuer_attr,
326  &etime_abs);
327 
329  GNUNET_free(crd);
330  printf("%s\n", res);
332 }
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_pkey
Issuer key.
static void handle_collect_result(void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *dc, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
static char * expiration
Credential TTL.
static struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
static struct GNUNET_IDENTITY_EgoLookup * el
EgoLookup.
static int collect
Collect mode.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
int GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:350
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
int GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:401
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Private ECC key encoded for transmission.
static struct GNUNET_CREDENTIAL_Request * collect_request
Handle to collect request.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
struct GNUNET_CRYPTO_EcdsaPublicKey subject_pkey
Subject key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static int res
struct GNUNET_CREDENTIAL_Request * GNUNET_CREDENTIAL_collect(struct GNUNET_CREDENTIAL_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key, GNUNET_CREDENTIAL_CredentialResultProcessor proc, void *proc_cls)
Performs attribute collection.
char * GNUNET_CREDENTIAL_credential_to_string(const struct GNUNET_CREDENTIAL_Credential *cred)
static char * ego_name
ego
static char * issuer_key
Issuer pubkey string.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
struct GNUNET_CREDENTIAL_Credential * GNUNET_CREDENTIAL_credential_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, struct GNUNET_CRYPTO_EcdsaPublicKey *subject, const char *attribute, struct GNUNET_TIME_Absolute *expiration)
Issue an attribute to a subject.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
static char * issuer_attr
Issuer attribute.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
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.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cconfiguration

Definition at line 346 of file gnunet-credential.c.

References _, collect, create_cred, do_shutdown(), do_timeout(), ego_name, GNUNET_CREDENTIAL_connect(), GNUNET_CREDENTIAL_credential_from_string(), GNUNET_CREDENTIAL_verify(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_free, GNUNET_IDENTITY_ego_lookup(), GNUNET_memcpy, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_YES, handle_verify_result(), identity_cb(), issuer_attr, GNUNET_CREDENTIAL_Credential::issuer_attribute, issuer_key, issuer_pkey, subject_credential, subject_key, subject_pkey, timeout, and verify.

Referenced by main().

350 {
351  cfg = c;
352 
353 
355  &do_timeout, NULL);
357 
358  if (GNUNET_YES == collect)
359  {
360  if (NULL == issuer_key)
361  {
362  fprintf(stderr,
363  _("Issuer public key not well-formed\n"));
365  return;
366  }
367 
369 
370  if (NULL == credential)
371  {
372  fprintf(stderr,
373  _("Failed to connect to CREDENTIAL\n"));
375  return;
376  }
377  if (NULL == issuer_attr)
378  {
379  fprintf(stderr,
380  _("You must provide issuer the attribute\n"));
382  return;
383  }
384 
385  if (NULL == ego_name)
386  {
387  fprintf(stderr,
388  _("ego required\n"));
390  return;
391  }
393  ego_name,
394  &identity_cb,
395  (void *)cfg);
396  return;
397  }
398 
399  if (NULL == subject_key)
400  {
401  fprintf(stderr,
402  _("Subject public key needed\n"));
404  return;
405  }
406  if (GNUNET_OK !=
408  strlen(subject_key),
409  &subject_pkey))
410  {
411  fprintf(stderr,
412  _("Subject public key `%s' is not well-formed\n"),
413  subject_key);
415  return;
416  }
417  if (GNUNET_YES == verify)
418  {
419  if (NULL == issuer_key)
420  {
421  fprintf(stderr,
422  _("Issuer public key not well-formed\n"));
424  return;
425  }
426  if (GNUNET_OK !=
428  strlen(issuer_key),
429  &issuer_pkey))
430  {
431  fprintf(stderr,
432  _("Issuer public key `%s' is not well-formed\n"),
433  issuer_key);
435  return;
436  }
438 
439  if (NULL == credential)
440  {
441  fprintf(stderr,
442  _("Failed to connect to CREDENTIAL\n"));
444  return;
445  }
446  if (NULL == issuer_attr || NULL == subject_credential)
447  {
448  fprintf(stderr,
449  _("You must provide issuer and subject attributes\n"));
451  return;
452  }
453 
454  //Subject credentials are comma separated
455  char *tmp = GNUNET_strdup(subject_credential);
456  char *tok = strtok(tmp, ",");
457  if (NULL == tok)
458  {
459  fprintf(stderr,
460  "Invalid subject credentials\n");
461  GNUNET_free(tmp);
463  return;
464  }
465  int count = 1;
466  int i;
467  while (NULL != (tok = strtok(NULL, ",")))
468  count++;
469  struct GNUNET_CREDENTIAL_Credential credentials[count];
470  struct GNUNET_CREDENTIAL_Credential *cred;
471  GNUNET_free(tmp);
473  tok = strtok(tmp, ",");
474  for (i = 0; i < count; i++)
475  {
477  GNUNET_memcpy(&credentials[i],
478  cred,
479  sizeof(struct GNUNET_CREDENTIAL_Credential));
480  credentials[i].issuer_attribute = GNUNET_strdup(cred->issuer_attribute);
481  tok = strtok(NULL, ",");
482  GNUNET_free(cred);
483  }
484 
486  &issuer_pkey,
487  issuer_attr, //TODO argument
488  &subject_pkey,
489  count,
490  credentials,
492  NULL);
493  for (i = 0; i < count; i++)
494  {
495  GNUNET_free((char*)credentials[i].issuer_attribute);
496  }
497  GNUNET_free(tmp);
498  }
499  else if (GNUNET_YES == create_cred)
500  {
501  if (NULL == ego_name)
502  {
503  fprintf(stderr,
504  _("Issuer ego required\n"));
506  return;
507  }
509  ego_name,
510  &identity_cb,
511  (void *)cfg);
512  return;
513  }
514  else
515  {
516  fprintf(stderr,
517  _("Please specify name to lookup, subject key and issuer key!\n"));
519  }
520  return;
521 }
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_pkey
Issuer key.
static char * subject_credential
Subject credential string.
struct GNUNET_CREDENTIAL_Credential * GNUNET_CREDENTIAL_credential_from_string(const char *s)
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
static struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
static struct GNUNET_IDENTITY_EgoLookup * el
EgoLookup.
static void handle_verify_result(void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *dc, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
static int collect
Collect mode.
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:1284
static char * subject_key
Subject pubkey string.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static void identity_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
Callback invoked from identity service with ego information.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int create_cred
Issue mode.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
struct GNUNET_CRYPTO_EcdsaPublicKey subject_pkey
Subject key.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
static int verify
Verify mode.
struct GNUNET_CREDENTIAL_Handle * GNUNET_CREDENTIAL_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the CREDENTIAL service.
static void do_shutdown(void *cls)
Task run on shutdown.
static char * ego_name
ego
static char * issuer_key
Issuer pubkey string.
const char * issuer_attribute
The attribute.
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
static struct GNUNET_CREDENTIAL_Request * verify_request
Handle to verify request.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CREDENTIAL_Request * GNUNET_CREDENTIAL_verify(struct GNUNET_CREDENTIAL_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key, uint32_t credential_count, const struct GNUNET_CREDENTIAL_Credential *credentials, GNUNET_CREDENTIAL_CredentialResultProcessor proc, void *proc_cls)
Performs attribute verification.
static char * issuer_attr
Issuer attribute.
static void do_timeout(void *cls)
Task run on timeout.
#define GNUNET_free(ptr)
Wrapper around free.
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 for gnunet-gns.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 532 of file gnunet-credential.c.

References _, collect, create_cred, ego_name, expiration, gettext_noop, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_log_setup(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_TIME_UNIT_FOREVER_REL, issuer_attr, issuer_key, ret, run(), subject_credential, subject_key, timeout, and verify.

533 {
536  "issue",
537  gettext_noop("create credential"),
538  &create_cred),
540  "verify",
541  gettext_noop("verify credential against attribute"),
542  &verify),
544  "subject",
545  "PKEY",
546  gettext_noop("The public key of the subject to lookup the credential for"),
547  &subject_key),
549  "credential",
550  "CRED",
551  gettext_noop("The name of the credential presented by the subject"),
554  "issuer",
555  "PKEY",
556  gettext_noop("The public key of the authority to verify the credential against"),
557  &issuer_key),
559  "ego",
560  "EGO",
561  gettext_noop("The ego to use"),
562  &ego_name),
564  "attribute",
565  "ATTR",
566  gettext_noop("The issuer attribute to verify against or to issue"),
567  &issuer_attr),
569  "ttl",
570  "EXP",
571  gettext_noop("The time to live for the credential"),
572  &expiration),
574  "collect",
575  gettext_noop("collect credentials"),
576  &collect),
578  };
579  int ret;
580 
582  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
583  return 2;
584 
585  GNUNET_log_setup("gnunet-credential", "WARNING", NULL);
586  ret =
587  (GNUNET_OK ==
588  GNUNET_PROGRAM_run(argc, argv, "gnunet-credential",
589  _("GNUnet credential resolver tool"),
590  options,
591  &run, NULL)) ? 0 : 1;
592  GNUNET_free((void*)argv);
593  return ret;
594 }
static char * subject_credential
Subject credential string.
static char * expiration
Credential TTL.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static int collect
Collect mode.
static char * subject_key
Subject pubkey string.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1439
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int create_cred
Issue mode.
Definition of a command line option.
static int ret
Final status code.
Definition: gnunet-arm.c:89
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
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 _(String)
GNU gettext support macro.
Definition: platform.h:181
static int verify
Verify mode.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static char * ego_name
ego
static char * issuer_key
Issuer pubkey string.
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.
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
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
static char * issuer_attr
Issuer attribute.
#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

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Configuration we are using.

Definition at line 35 of file gnunet-credential.c.

◆ el

struct GNUNET_IDENTITY_EgoLookup* el
static

◆ credential

struct GNUNET_CREDENTIAL_Handle* credential
static

Handle to Credential service.

Definition at line 45 of file gnunet-credential.c.

◆ timeout

struct GNUNET_TIME_Relative timeout
static

Desired timeout for the lookup (default is no timeout).

Definition at line 50 of file gnunet-credential.c.

Referenced by main(), and run().

◆ verify_request

struct GNUNET_CREDENTIAL_Request* verify_request
static

Handle to verify request.

Definition at line 55 of file gnunet-credential.c.

◆ collect_request

struct GNUNET_CREDENTIAL_Request* collect_request
static

Handle to collect request.

Definition at line 60 of file gnunet-credential.c.

◆ tt

struct GNUNET_SCHEDULER_Task* tt
static

Task scheduled to handle timeout.

Definition at line 65 of file gnunet-credential.c.

Referenced by GNUNET_STRINGS_absolute_time_to_string().

◆ subject_key

char* subject_key
static

◆ subject_credential

char* subject_credential
static

Subject credential string.

Definition at line 75 of file gnunet-credential.c.

Referenced by main(), and run().

◆ expiration

char* expiration
static

◆ subject_pkey

struct GNUNET_CRYPTO_EcdsaPublicKey subject_pkey

◆ issuer_pkey

struct GNUNET_CRYPTO_EcdsaPublicKey issuer_pkey

◆ issuer_key

char* issuer_key
static

◆ ego_name

char* ego_name
static

ego

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

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

◆ issuer_attr

char* issuer_attr
static

Issuer attribute.

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

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

◆ verify

int verify
static

Verify mode.

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

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

◆ create_cred

int create_cred
static

Issue mode.

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

Referenced by main(), and run().

◆ collect

int collect
static

Collect mode.

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

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