GNUnet 0.24.4-talerdev.1-13-g62dff6af1
 
Loading...
Searching...
No Matches
identity_api.c File Reference

api to interact with the identity service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_error_codes.h"
#include "gnunet_protocols.h"
#include "gnunet_identity_service.h"
#include "identity.h"
Include dependency graph for identity_api.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_IDENTITY_Operation
 Handle for an operation with the identity service. More...
 
struct  GNUNET_IDENTITY_Handle
 Handle for the service. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "identity-api", __VA_ARGS__)
 

Functions

struct GNUNET_IDENTITY_EgoGNUNET_IDENTITY_ego_get_anonymous ()
 Obtain the ego representing 'anonymous' users.
 
const char * GNUNET_IDENTITY_ego_get_name (const struct GNUNET_IDENTITY_Ego *ego)
 Obtain the name associated with an ego.
 
static void reconnect (void *cls)
 Try again to connect to the identity service.
 
static int free_ego (void *cls, const struct GNUNET_HashCode *key, void *value)
 Free ego from hash map.
 
static void reschedule_connect (struct GNUNET_IDENTITY_Handle *h)
 Reschedule a connect attempt to the service.
 
static void mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
 
static void handle_identity_result_code (void *cls, const struct ResultCodeMessage *rcm)
 We received a result code from the service.
 
static int check_identity_update (void *cls, const struct UpdateMessage *um)
 Check validity of identity update message.
 
static void handle_identity_update (void *cls, const struct UpdateMessage *um)
 Handle identity update message.
 
struct GNUNET_IDENTITY_HandleGNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
 Connect to the identity service.
 
const struct GNUNET_CRYPTO_PrivateKeyGNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego)
 Obtain the ECC key associated with a ego.
 
void GNUNET_IDENTITY_ego_get_public_key (struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_PublicKey *pk)
 Get the identifier (public key) of an ego.
 
static enum GNUNET_GenericReturnValue private_key_create (enum GNUNET_CRYPTO_KeyType ktype, struct GNUNET_CRYPTO_PrivateKey *key)
 
struct GNUNET_IDENTITY_OperationGNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h, const char *name, const struct GNUNET_CRYPTO_PrivateKey *privkey, enum GNUNET_CRYPTO_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
 Create a new ego with the given name.
 
struct GNUNET_IDENTITY_OperationGNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *h, const char *old_name, const char *new_name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
 Renames an existing identity.
 
struct GNUNET_IDENTITY_OperationGNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
 Delete an existing identity.
 
void GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op)
 Cancel an identity operation.
 
void GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
 Disconnect from identity service.
 

Detailed Description

api to interact with the identity service

Author
Christian Grothoff

Definition in file identity_api.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "identity-api", __VA_ARGS__)

Definition at line 34 of file identity_api.c.

Function Documentation

◆ reconnect()

static void reconnect ( void *  cls)
static

Try again to connect to the identity service.

Parameters
clshandle to the identity service.

Definition at line 446 of file identity_api.c.

447{
448 struct GNUNET_IDENTITY_Handle *h = cls;
450 GNUNET_MQ_hd_fixed_size (identity_result_code,
452 struct ResultCodeMessage,
453 h),
454 GNUNET_MQ_hd_var_size (identity_update,
456 struct UpdateMessage,
457 h),
459 };
460 struct GNUNET_MQ_Envelope *env;
462
463 h->reconnect_task = NULL;
465 "Connecting to identity service.\n");
466 GNUNET_assert (NULL == h->mq);
468 "identity",
469 handlers,
471 h);
472 if (NULL == h->mq)
473 return;
474 if (NULL != h->cb)
475 {
479 env);
480 }
481}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition 003.c:1
struct GNUNET_MessageHeader * msg
Definition 005.c:2
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition gnunet-arm.c:98
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition client.c:1060
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition mq.c:305
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_IDENTITY_START
First message send from identity client to service (to subscribe to updates).
#define GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE
Generic response from identity service with success and/or error message.
#define GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE
Update about identity status from service to clients.
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
#define LOG(kind,...)
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition arm_api.c:112
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition arm_api.c:147
Handle for the service.
Message handler for a specific message type.
Header for all communications.
Answer from service to client about last operation; GET_DEFAULT maybe answered with this message on f...
Definition identity.h:81
Service informs client about status of a pseudonym.
Definition identity.h:114

References GNUNET_ARM_Handle::cfg, env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MESSAGE_TYPE_IDENTITY_START, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), msg, and GNUNET_ARM_Handle::reconnect_task.

Here is the call graph for this function:

◆ free_ego()

static int free_ego ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Free ego from hash map.

Parameters
clsidentity service handle
keyunused
valueego to free
Returns
GNUNET_OK (continue to iterate)

Definition at line 203 of file identity_api.c.

206{
207 struct GNUNET_IDENTITY_Handle *h = cls;
208 struct GNUNET_IDENTITY_Ego *ego = value;
209
210 if (NULL != h->cb)
211 h->cb (h->cb_cls, ego,
212 &ego->ctx,
213 NULL);
214 GNUNET_free (ego->name);
217 key,
218 value));
219 GNUNET_free (ego);
220 return GNUNET_OK;
221}
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_OK
@ GNUNET_YES
#define GNUNET_free(ptr)
Wrapper around free.
Handle for an ego.
Definition identity.h:37
void * ctx
Client context associated with this ego.
Definition identity.h:61
char * name
Current name associated with this ego.
Definition identity.h:56

References GNUNET_IDENTITY_Ego::ctx, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_OK, GNUNET_YES, h, key, GNUNET_IDENTITY_Ego::name, and value.

Referenced by GNUNET_IDENTITY_disconnect(), and reschedule_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reschedule_connect()

static void reschedule_connect ( struct GNUNET_IDENTITY_Handle h)
static

Reschedule a connect attempt to the service.

Parameters
htransport service to reconnect

Definition at line 230 of file identity_api.c.

231{
233
234 GNUNET_assert (NULL == h->reconnect_task);
235
236 if (NULL != h->mq)
237 {
239 h->mq = NULL;
240 }
241 while (NULL != (op = h->op_head))
242 {
244 h->op_tail,
245 op);
246 if (NULL != op->cont)
247 op->cont (op->cls,
249 else if (NULL != op->cb)
250 op->cb (op->cls, NULL, NULL, NULL);
251 else if (NULL != op->create_cont)
252 op->create_cont (op->cls,
253 NULL,
255 GNUNET_free (op);
256 }
258 &free_ego,
259 h);
261 "Scheduling task to reconnect to identity service in %s.\n",
263 GNUNET_YES));
265 GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
266 &reconnect,
267 h);
268 h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
269}
static struct GNUNET_ARM_Operation * op
Current operation.
Definition gnunet-arm.c:143
@ GNUNET_EC_SERVICE_COMMUNICATION_FAILED
Communication with service failed.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition mq.c:700
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:1277
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition strings.c:599
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static int free_ego(void *cls, const struct GNUNET_HashCode *key, void *value)
Free ego from hash map.
static void reconnect(void)
Adjust exponential back-off and reconnect to the service.
Handle for an operation with the identity service.

References free_ego(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_EC_SERVICE_COMMUNICATION_FAILED, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, GNUNET_ARM_Handle::mq, op, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by handle_identity_result_code(), handle_identity_update(), and mq_error_handler().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_error_handler()

static void mq_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsclosure with the struct GNUNET_IDENTITY_Handle *
errorerror code

Definition at line 281 of file identity_api.c.

283{
284 struct GNUNET_IDENTITY_Handle *h = cls;
285
287}
static void reschedule_connect(struct GNUNET_IDENTITY_Handle *h)
Reschedule a connect attempt to the service.

References h, and reschedule_connect().

Referenced by reconnect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_identity_result_code()

static void handle_identity_result_code ( void *  cls,
const struct ResultCodeMessage rcm 
)
static

We received a result code from the service.

Parameters
clsclosure
rcmresult message received

Definition at line 297 of file identity_api.c.

299{
300 struct GNUNET_IDENTITY_Handle *h = cls;
302 enum GNUNET_ErrorCode ec = ntohl (rcm->result_code);
303
304 op = h->op_head;
305 if (NULL == op)
306 {
307 GNUNET_break (0);
309 return;
310 }
311 GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
312 if (NULL != op->cont)
313 op->cont (op->cls, ec);
314 else if (NULL != op->cb)
315 op->cb (op->cls, NULL, NULL, NULL);
316 else if (NULL != op->create_cont)
317 op->create_cont (op->cls, (GNUNET_EC_NONE == ec) ? &op->pk : NULL, ec);
318 GNUNET_free (op);
319}
GNUNET_ErrorCode
Taler error codes.
@ GNUNET_EC_NONE
No error (success).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
uint32_t result_code
Status code for the last operation, in NBO.
Definition identity.h:91

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_EC_NONE, GNUNET_free, h, op, reschedule_connect(), and ResultCodeMessage::result_code.

Here is the call graph for this function:

◆ check_identity_update()

static int check_identity_update ( void *  cls,
const struct UpdateMessage um 
)
static

Check validity of identity update message.

Parameters
clsclosure
ummessage received
Returns
GNUNET_OK if the message is well-formed

Definition at line 330 of file identity_api.c.

332{
333 uint16_t size = ntohs (um->header.size);
334 uint16_t name_len = ntohs (um->name_len);
335 const char *str = (const char *) &um[1];
336
337 if ((size < name_len + sizeof(struct UpdateMessage)) ||
338 ((0 != name_len) && ('\0' != str[name_len - 1])))
339 {
340 GNUNET_break (0);
341 return GNUNET_SYSERR;
342 }
343 return GNUNET_OK;
344}
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SYSERR
static unsigned int size
Size of the "table".
Definition peer.c:68
uint16_t name_len
Number of bytes in ego name string including 0-termination, in NBO; 0 if the ego was deleted.
Definition identity.h:124
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE.
Definition identity.h:118

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, UpdateMessage::header, UpdateMessage::name_len, GNUNET_MessageHeader::size, and size.

◆ handle_identity_update()

static void handle_identity_update ( void *  cls,
const struct UpdateMessage um 
)
static

Handle identity update message.

Parameters
clsclosure
ummessage received

Definition at line 354 of file identity_api.c.

356{
357 struct GNUNET_IDENTITY_Handle *h = cls;
358 uint16_t name_len = ntohs (um->name_len);
359 const char *str;
360 size_t key_len;
361 size_t kb_read;
362 struct GNUNET_HashCode id;
363 struct GNUNET_IDENTITY_Ego *ego;
364 struct GNUNET_CRYPTO_PrivateKey private_key;
365 const char *tmp;
366
367 if (GNUNET_YES == ntohs (um->end_of_list))
368 {
369 /* end of initial list of data */
370 if (NULL != h->cb)
371 h->cb (h->cb_cls, NULL, NULL, NULL);
372 return;
373 }
374 tmp = (const char*) &um[1];
375 str = (0 == name_len) ? NULL : tmp;
376 memset (&private_key, 0, sizeof (private_key));
377 key_len = ntohs (um->key_len);
380 key_len,
381 &private_key,
382 &kb_read));
384 GNUNET_CRYPTO_hash (&private_key,
386 &id);
388 &id);
389 if (NULL == ego)
390 {
391 /* ego was created */
392 if (NULL == str)
393 {
394 /* deletion of unknown ego? not allowed */
395 GNUNET_break (0);
397 return;
398 }
399 ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
401 ego->pk = private_key;
402 ego->name = GNUNET_strdup (str);
403 ego->id = id;
406 h->egos,
407 &ego->id,
408 ego,
410 }
411 if (NULL == str)
412 {
413 /* ego was deleted */
416 &ego->id,
417 ego));
418 }
419 else
420 {
421 /* ego changed name */
422 GNUNET_free (ego->name);
423 ego->name = GNUNET_strdup (str);
424 }
425 /* inform application about change */
426 if (NULL != h->cb)
427 h->cb (h->cb_cls,
428 ego,
429 &ego->ctx,
430 str);
431 /* complete deletion */
432 if (NULL == str)
433 {
434 GNUNET_free (ego->name);
435 GNUNET_free (ego);
436 }
437}
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition crypto_hash.c:41
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
ssize_t GNUNET_CRYPTO_private_key_get_length(const struct GNUNET_CRYPTO_PrivateKey *key)
Get the compacted length of a GNUNET_CRYPTO_PrivateKey.
Definition crypto_pkey.c:64
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_read_private_key_from_buffer(const void *buffer, size_t len, struct GNUNET_CRYPTO_PrivateKey *key, size_t *read)
Reads a GNUNET_CRYPTO_PrivateKey from a compact buffer.
@ GNUNET_NO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A private key for an identity as per LSD0001.
A 512-bit hashcode.
bool pub_initialized
Set to true once pub was initialized.
Definition identity.h:66
struct GNUNET_CRYPTO_PrivateKey pk
The identity key pair.
Definition identity.h:51
struct GNUNET_HashCode id
Hash of the private key of this ego.
Definition identity.h:41
uint16_t end_of_list
Usually GNUNET_NO, GNUNET_YES to signal end of list.
Definition identity.h:129
uint16_t key_len
Key length.
Definition identity.h:134

References GNUNET_IDENTITY_Ego::ctx, UpdateMessage::end_of_list, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, h, id, GNUNET_IDENTITY_Ego::id, UpdateMessage::key_len, GNUNET_IDENTITY_Ego::name, UpdateMessage::name_len, GNUNET_IDENTITY_Ego::pk, GNUNET_IDENTITY_Ego::pub_initialized, and reschedule_connect().

Here is the call graph for this function:

◆ private_key_create()

static enum GNUNET_GenericReturnValue private_key_create ( enum GNUNET_CRYPTO_KeyType  ktype,
struct GNUNET_CRYPTO_PrivateKey key 
)
static

Definition at line 548 of file identity_api.c.

550{
551 key->type = htonl (ktype);
552 switch (ktype)
553 {
556 break;
559 break;
560 default:
561 GNUNET_break (0);
562 return GNUNET_SYSERR;
563 }
564 return GNUNET_OK;
565}
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition crypto_ecc.c:480
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition crypto_ecc.c:465
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
@ GNUNET_PUBLIC_KEY_TYPE_ECDSA
The identity type.

References GNUNET_break, GNUNET_CRYPTO_ecdsa_key_create(), GNUNET_CRYPTO_eddsa_key_create(), GNUNET_OK, GNUNET_PUBLIC_KEY_TYPE_ECDSA, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SYSERR, and key.

Referenced by GNUNET_IDENTITY_create().

Here is the call graph for this function:
Here is the caller graph for this function: