GNUnet 0.21.1
gnunet-service-identity.c File Reference

identity management service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_identity_service.h"
#include "identity.h"
Include dependency graph for gnunet-service-identity.c:

Go to the source code of this file.

Data Structures

struct  Ego
 Information we keep about each ego. More...
 
struct  RenameContext
 Closure for 'handle_ego_rename'. More...
 

Functions

static char * get_ego_filename (struct Ego *ego)
 Get the name of the file we use to store a given ego. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 Called whenever a client is disconnected. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Add a client to our list of active clients. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void send_result_code (struct GNUNET_SERVICE_Client *client, uint32_t result_code)
 Send a result code back to the client. More...
 
static struct GNUNET_MQ_Envelopecreate_update_message (struct Ego *ego)
 Create an update message with information about the current state of an ego. More...
 
static void handle_start_message (void *cls, const struct GNUNET_MessageHeader *message)
 Handler for START message from client, sends information about all identities to the client immediately and adds the client to the notification context for future updates. More...
 
static int check_lookup_message (void *cls, const struct LookupMessage *message)
 Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
 
static void handle_lookup_message (void *cls, const struct LookupMessage *message)
 Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
 
static int check_lookup_by_suffix_message (void *cls, const struct LookupMessage *message)
 Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
 
static void handle_lookup_by_suffix_message (void *cls, const struct LookupMessage *message)
 Handler for LOOKUP_BY_SUFFIX message from client, sends information about ONE identity to the client immediately. More...
 
static void notify_listeners (struct Ego *ego)
 Send an updated message for the given ego to all listeners. More...
 
static int check_create_message (void *cls, const struct CreateRequestMessage *msg)
 Checks a GNUNET_MESSAGE_TYPE_IDENTITY_CREATE message. More...
 
static void handle_create_message (void *cls, const struct CreateRequestMessage *crm)
 Handler for CREATE message from client, creates new identity. More...
 
static void handle_ego_rename (void *cls, const char *section)
 An ego was renamed; rename it in all subsystems where it is currently set as the default. More...
 
static int check_rename_message (void *cls, const struct RenameMessage *msg)
 Checks a GNUNET_MESSAGE_TYPE_IDENTITY_RENAME message. More...
 
static void handle_rename_message (void *cls, const struct RenameMessage *rm)
 Handler for RENAME message from client, creates new identity. More...
 
static void handle_ego_delete (void *cls, const char *section)
 An ego was removed, remove it from all subsystems where it is currently set as the default. More...
 
static int check_delete_message (void *cls, const struct DeleteMessage *msg)
 Checks a GNUNET_MESSAGE_TYPE_IDENTITY_DELETE message. More...
 
static void handle_delete_message (void *cls, const struct DeleteMessage *dm)
 Handler for DELETE message from client, creates new identity. More...
 
static int read_from_file (const char *filename, void *buf, size_t buf_size)
 
static int process_ego_file (void *cls, const char *filename)
 Process the given file from the "EGODIR". More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Handle network size estimate clients. More...
 
 GNUNET_SERVICE_MAIN ("identity", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(start_message, GNUNET_MESSAGE_TYPE_IDENTITY_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(lookup_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, struct LookupMessage, NULL), GNUNET_MQ_hd_var_size(lookup_by_suffix_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, struct LookupMessage, NULL), GNUNET_MQ_hd_var_size(create_message, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, struct CreateRequestMessage, NULL), GNUNET_MQ_hd_var_size(rename_message, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, struct RenameMessage, NULL), GNUNET_MQ_hd_var_size(delete_message, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, struct DeleteMessage, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Handle to our current configuration. More...
 
static struct GNUNET_CONFIGURATION_Handlesubsystem_cfg
 Handle to subsystem configuration which for each subsystem contains the name of the default ego. More...
 
static struct GNUNET_STATISTICS_Handlestats
 Handle to the statistics service. More...
 
static struct GNUNET_NotificationContextnc
 Notification context, simplifies client broadcasts. More...
 
static char * ego_directory
 Directory where we store the identities. More...
 
static char * subsystem_cfg_file
 Configuration file name where subsystem information is kept. More...
 
static struct Egoego_head
 Head of DLL of all egos. More...
 
static struct Egoego_tail
 Tail of DLL of all egos. More...
 

Detailed Description

identity management service

Author
Christian Grothoff

The purpose of this service is to manage private keys that represent the various egos/pseudonyms/identities of a GNUnet user.

Todo:

  • auto-initialze default egos; maybe trigger default initializations (such as gnunet-gns-import.sh?)

Definition in file gnunet-service-identity.c.

Function Documentation

◆ get_ego_filename()

static char * get_ego_filename ( struct Ego ego)
static

Get the name of the file we use to store a given ego.

Parameters
egoego for which we need the filename
Returns
full filename for the given ego

Definition at line 118 of file gnunet-service-identity.c.

119{
120 char *filename;
121
123 "%s%s%s",
126 ego->identifier);
127 return filename;
128}
static char * filename
static char * ego_directory
Directory where we store the identities.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define DIR_SEPARATOR_STR
Definition: platform.h:166
char * identifier
String identifier for the ego.

References DIR_SEPARATOR_STR, ego_directory, filename, GNUNET_asprintf(), and Ego::identifier.

Referenced by handle_create_message(), handle_delete_message(), and handle_rename_message().

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

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_ctx 
)
static

Called whenever a client is disconnected.

Parameters
clsclosure
clientidentification of the client
app_ctxclient

Definition at line 139 of file gnunet-service-identity.c.

142{
144 "Client %p disconnected\n",
145 client);
146}
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

◆ client_connect_cb()

static void * client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

Add a client to our list of active clients.

Parameters
clsNULL
clientclient to add
mqmessage queue for client
Returns
internal namestore client structure for this client

Definition at line 158 of file gnunet-service-identity.c.

161{
162 return client;
163}

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 172 of file gnunet-service-identity.c.

173{
174 struct Ego *e;
175
176 if (NULL != nc)
177 {
179 nc = NULL;
180 }
181 if (NULL != stats)
182 {
184 stats = NULL;
185 }
187 subsystem_cfg = NULL;
189 subsystem_cfg_file = NULL;
191 ego_directory = NULL;
192 while (NULL != (e = ego_head))
193 {
195 ego_tail,
196 e);
198 GNUNET_free (e);
199 }
200}
static struct Ego * ego_tail
Tail of DLL of all egos.
static struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static struct GNUNET_NotificationContext * nc
Notification context, simplifies client broadcasts.
static char * subsystem_cfg_file
Configuration file name where subsystem information is kept.
static struct Ego * ego_head
Head of DLL of all egos.
static struct GNUNET_CONFIGURATION_Handle * subsystem_cfg
Handle to subsystem configuration which for each subsystem contains the name of the default ego.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
@ GNUNET_NO
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:138
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
Information we keep about each ego.

References ego_directory, ego_head, ego_tail, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_STATISTICS_destroy(), Ego::identifier, nc, stats, subsystem_cfg, and subsystem_cfg_file.

Referenced by run().

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

◆ send_result_code()

static void send_result_code ( struct GNUNET_SERVICE_Client client,
uint32_t  result_code 
)
static

Send a result code back to the client.

Parameters
clientclient that should receive the result code
result_codecode to transmit

Definition at line 210 of file gnunet-service-identity.c.

212{
213 struct ResultCodeMessage *rcm;
214 struct GNUNET_MQ_Envelope *env;
215
216 env =
218 rcm->result_code = htonl (result_code);
220 "Sending result %d (%s) to client\n",
221 (int) result_code,
222 GNUNET_ErrorCode_get_hint (result_code));
224}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:304
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE
Generic response from identity service with success and/or error message.
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2566
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
Answer from service to client about last operation; GET_DEFAULT maybe answered with this message on f...
Definition: identity.h:81
uint32_t result_code
Status code for the last operation, in NBO.
Definition: identity.h:91

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), and ResultCodeMessage::result_code.

Referenced by handle_create_message(), handle_delete_message(), handle_lookup_by_suffix_message(), handle_lookup_message(), and handle_rename_message().

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

◆ create_update_message()

static struct GNUNET_MQ_Envelope * create_update_message ( struct Ego ego)
static

Create an update message with information about the current state of an ego.

Parameters
egoego to create message for
Returns
corresponding update message

Definition at line 234 of file gnunet-service-identity.c.

235{
236 struct UpdateMessage *um;
237 struct GNUNET_MQ_Envelope *env;
238 size_t name_len;
239 ssize_t key_len;
240
242 name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1);
243 env = GNUNET_MQ_msg_extra (um, name_len + key_len,
245 um->name_len = htons (name_len);
246 um->end_of_list = htons (GNUNET_NO);
247 um->key_len = htons (key_len);
248 GNUNET_memcpy (&um[1], ego->identifier, name_len);
250 ((char*) &um[1]) + name_len,
251 key_len);
252 return env;
253}
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
ssize_t GNUNET_CRYPTO_write_private_key_to_buffer(const struct GNUNET_CRYPTO_PrivateKey *key, void *buffer, size_t len)
Writes a GNUNET_CRYPTO_PrivateKey to a compact buffer.
Definition: crypto_pkey.c:188
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE
Update about identity status from service to clients.
struct GNUNET_CRYPTO_PrivateKey pk
Private key of the ego.
Service informs client about status of a pseudonym.
Definition: identity.h:114
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
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

References UpdateMessage::end_of_list, env, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_msg_extra, GNUNET_NO, Ego::identifier, UpdateMessage::key_len, UpdateMessage::name_len, and Ego::pk.

Referenced by handle_lookup_by_suffix_message(), handle_lookup_message(), and handle_start_message().

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

◆ handle_start_message()

static void handle_start_message ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handler for START message from client, sends information about all identities to the client immediately and adds the client to the notification context for future updates.

Parameters
clsa struct GNUNET_SERVICE_Client *
messagethe message received

Definition at line 266 of file gnunet-service-identity.c.

268{
269 struct GNUNET_SERVICE_Client *client = cls;
270
272 "Received START message from client\n");
277 for (struct Ego *ego = ego_head; NULL != ego; ego = ego->next)
278 {
281 }
282 {
283 struct UpdateMessage *ume;
284 struct GNUNET_MQ_Envelope *env;
285
287 0,
289 ume->end_of_list = htons (GNUNET_YES);
290 ume->name_len = htons (0);
291 ume->key_len = htons (0);
293 env);
294 }
296}
static struct GNUNET_MQ_Envelope * create_update_message(struct Ego *ego)
Create an update message with information about the current state of an ego.
@ GNUNET_YES
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:161
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the 'monitor' flag on this client.
Definition: service.c:2549
void GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c)
Disable the warning the server issues if a message is not acknowledged in a timely fashion.
Definition: service.c:2472
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
struct Ego * next
We keep egos in a DLL.
Handle to a client that is connected to a service.
Definition: service.c:246

References create_update_message(), ego_head, UpdateMessage::end_of_list, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SERVICE_client_get_mq(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_YES, UpdateMessage::key_len, UpdateMessage::name_len, nc, and Ego::next.

Here is the call graph for this function:

◆ check_lookup_message()

static int check_lookup_message ( void *  cls,
const struct LookupMessage message 
)
static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters
clsunused
messagethe message received
Returns
GNUNET_SYSERR if message was ill-formed

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

310{
312 return GNUNET_OK;
313}
@ GNUNET_OK
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...

References GNUNET_MQ_check_zero_termination, and GNUNET_OK.

◆ handle_lookup_message()

static void handle_lookup_message ( void *  cls,
const struct LookupMessage message 
)
static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters
clsa struct GNUNET_SERVICE_Client *
messagethe message received

Definition at line 324 of file gnunet-service-identity.c.

326{
327 struct GNUNET_SERVICE_Client *client = cls;
328 const char *name;
329 struct GNUNET_MQ_Envelope *env;
330 struct Ego *ego;
331
333 "Received LOOKUP message from client\n");
334 name = (const char *) &message[1];
335 for (ego = ego_head; NULL != ego; ego = ego->next)
336 {
337 if (0 != strcasecmp (name, ego->identifier))
338 continue;
342 return;
343 }
346}
static char * name
Name (label) of the records to list.
static void send_result_code(struct GNUNET_SERVICE_Client *client, uint32_t result_code)
Send a result code back to the client.
@ GNUNET_EC_IDENTITY_NOT_FOUND
Ego not found.

References create_update_message(), ego_head, env, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), Ego::identifier, name, Ego::next, and send_result_code().

Here is the call graph for this function:

◆ check_lookup_by_suffix_message()

static int check_lookup_by_suffix_message ( void *  cls,
const struct LookupMessage message 
)
static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters
clsunused
messagethe message received
Returns
GNUNET_SYSERR if message was ill-formed

Definition at line 358 of file gnunet-service-identity.c.

360{
362 return GNUNET_OK;
363}

References GNUNET_MQ_check_zero_termination, and GNUNET_OK.

◆ handle_lookup_by_suffix_message()

static void handle_lookup_by_suffix_message ( void *  cls,
const struct LookupMessage message 
)
static

Handler for LOOKUP_BY_SUFFIX message from client, sends information about ONE identity to the client immediately.

Parameters
clsa struct GNUNET_SERVICE_Client *
messagethe message received

Definition at line 374 of file gnunet-service-identity.c.

376{
377 struct GNUNET_SERVICE_Client *client = cls;
378 const char *name;
379 struct GNUNET_MQ_Envelope *env;
380 struct Ego *lprefix;
381
383 "Received LOOKUP_BY_SUFFIX message from client\n");
384 name = (const char *) &message[1];
385 lprefix = NULL;
386 for (struct Ego *ego = ego_head; NULL != ego; ego = ego->next)
387 {
388 if ((strlen (ego->identifier) <= strlen (name)) &&
389 (0 == strcmp (ego->identifier,
390 &name[strlen (name) - strlen (ego->identifier)])) &&
391 ((strlen (name) == strlen (ego->identifier)) ||
392 ('.' == name[strlen (name) - strlen (ego->identifier) - 1])) &&
393 ((NULL == lprefix) ||
394 (strlen (ego->identifier) > strlen (lprefix->identifier))))
395 {
396 /* found better match, update! */
397 lprefix = ego;
398 }
399 }
400 if (NULL != lprefix)
401 {
402 env = create_update_message (lprefix);
405 return;
406 }
409}

References create_update_message(), ego_head, env, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), Ego::identifier, name, Ego::next, and send_result_code().

Here is the call graph for this function:

◆ notify_listeners()

static void notify_listeners ( struct Ego ego)
static

Send an updated message for the given ego to all listeners.

Parameters
egoego to send the update for

Definition at line 418 of file gnunet-service-identity.c.

419{
420 struct UpdateMessage *um;
421 size_t name_len;
422 ssize_t key_len;
423
424 name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1);
426 um = GNUNET_malloc (sizeof(struct UpdateMessage) + name_len + key_len);
428 um->header.size = htons (sizeof(struct UpdateMessage) + name_len + key_len);
429 um->name_len = htons (name_len);
430 um->end_of_list = htons (GNUNET_NO);
431 um->key_len = htons (key_len);
432 GNUNET_memcpy (&um[1], ego->identifier, name_len);
434 ((char*) &um[1]) + name_len,
435 key_len);
437 GNUNET_free (um);
438}
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#define GNUNET_malloc(size)
Wrapper around malloc.
void GNUNET_notification_context_broadcast(struct GNUNET_NotificationContext *nc, const struct GNUNET_MessageHeader *msg, int can_drop)
Send a message to all subscribers of this context.
Definition: nc.c:190
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE.
Definition: identity.h:118

References UpdateMessage::end_of_list, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_NO, GNUNET_notification_context_broadcast(), UpdateMessage::header, Ego::identifier, UpdateMessage::key_len, UpdateMessage::name_len, nc, Ego::pk, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_create_message(), handle_delete_message(), and handle_rename_message().

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

◆ check_create_message()

static int check_create_message ( void *  cls,
const struct CreateRequestMessage msg 
)
static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_CREATE message.

Parameters
clsclient sending the message
msgmessage of type struct CreateRequestMessage
Returns
GNUNET_OK if msg is well-formed

Definition at line 449 of file gnunet-service-identity.c.

451{
452 uint16_t size;
453 uint16_t name_len;
454 size_t key_len;
455 const char *str;
456
457 size = ntohs (msg->header.size);
458 if (size <= sizeof(struct CreateRequestMessage))
459 {
460 GNUNET_break (0);
461 return GNUNET_SYSERR;
462 }
463 name_len = ntohs (msg->name_len);
464 key_len = ntohs (msg->key_len);
465 if (name_len + key_len + sizeof(struct CreateRequestMessage) != size)
466 {
467 GNUNET_break (0);
468 return GNUNET_SYSERR;
469 }
470 str = (const char *) &msg[1] + key_len;
471 if ('\0' != str[name_len - 1])
472 {
473 GNUNET_break (0);
474 return GNUNET_SYSERR;
475 }
476 return GNUNET_OK;
477}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
static unsigned int size
Size of the "table".
Definition: peer.c:68
Client requests creation of an identity.
Definition: identity.h:151

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

◆ handle_create_message()

static void handle_create_message ( void *  cls,
const struct CreateRequestMessage crm 
)
static

Handler for CREATE message from client, creates new identity.

Parameters
clsunused
crmthe message received

Definition at line 487 of file gnunet-service-identity.c.

489{
490 struct GNUNET_CRYPTO_PrivateKey private_key;
491 struct GNUNET_SERVICE_Client *client = cls;
492 struct Ego *ego;
493 char *str;
494 char *fn;
495 size_t key_len;
496 size_t kb_read;
497
498 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREATE message from client\n");
499 key_len = ntohs (crm->key_len);
500 if ((GNUNET_SYSERR ==
502 key_len,
503 &private_key,
504 &kb_read)) ||
505 (kb_read != key_len))
506 {
508 return;
509 }
510 str = GNUNET_strdup ((const char *) &crm[1] + key_len);
511 GNUNET_STRINGS_utf8_tolower ((const char *) &crm[1] + key_len, str);
512 for (ego = ego_head; NULL != ego; ego = ego->next)
513 {
514 if (0 == strcmp (ego->identifier, str))
515 {
516 send_result_code (client,
519 GNUNET_free (str);
520 return;
521 }
522 }
523 ego = GNUNET_new (struct Ego);
524 ego->pk = private_key;
525 ego->identifier = GNUNET_strdup (str);
527 ego_tail,
528 ego);
530 fn = get_ego_filename (ego);
531 if (GNUNET_OK !=
533 &private_key,
534 sizeof(struct GNUNET_CRYPTO_PrivateKey),
538 GNUNET_free (fn);
539 GNUNET_free (str);
540 notify_listeners (ego);
542}
static void notify_listeners(struct Ego *ego)
Send an updated message for the given ego to all listeners.
static char * get_ego_filename(struct Ego *ego)
Get the name of the file we use to store a given ego.
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write(const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file atomically.
Definition: disk.c:725
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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.
Definition: crypto_pkey.c:163
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2484
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:450
@ GNUNET_EC_NONE
No error (success).
@ GNUNET_EC_IDENTITY_NAME_CONFLICT
Identifier already in use for another ego.
uint16_t key_len
Key length.
Definition: identity.h:165
A private key for an identity as per LSD0001.

References ego_head, ego_tail, get_ego_filename(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_EC_IDENTITY_NAME_CONFLICT, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_SYSERR, Ego::identifier, CreateRequestMessage::key_len, Ego::next, notify_listeners(), Ego::pk, and send_result_code().

Here is the call graph for this function:

◆ handle_ego_rename()

static void handle_ego_rename ( void *  cls,
const char *  section 
)
static

An ego was renamed; rename it in all subsystems where it is currently set as the default.

Parameters
clsthe 'struct RenameContext'
sectiona section in the configuration to process

Definition at line 569 of file gnunet-service-identity.c.

570{
571 struct RenameContext *rc = cls;
572 char *id;
573
575 section,
576 "DEFAULT_IDENTIFIER",
577 &id))
578 return;
579 if (0 != strcmp (id, rc->old_name))
580 {
581 GNUNET_free (id);
582 return;
583 }
585 section,
586 "DEFAULT_IDENTIFIER",
587 rc->new_name);
588 GNUNET_free (id);
589}
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
Closure for 'handle_ego_rename'.
const char * old_name
Old name.
const char * new_name
New name.

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, id, RenameContext::new_name, RenameContext::old_name, and subsystem_cfg.

Referenced by handle_rename_message().

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

◆ check_rename_message()

static int check_rename_message ( void *  cls,
const struct RenameMessage msg 
)
static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_RENAME message.

Parameters
clsclient sending the message
msgmessage of type struct RenameMessage
Returns
GNUNET_OK if msg is well-formed

Definition at line 600 of file gnunet-service-identity.c.

601{
602 uint16_t size;
603 uint16_t old_name_len;
604 uint16_t new_name_len;
605 const char *old_name;
606 const char *new_name;
607
608 size = ntohs (msg->header.size);
609 if (size <= sizeof(struct RenameMessage))
610 {
611 GNUNET_break (0);
612 return GNUNET_SYSERR;
613 }
614 old_name_len = ntohs (msg->old_name_len);
615 new_name_len = ntohs (msg->new_name_len);
616 old_name = (const char *) &msg[1];
617 new_name = &old_name[old_name_len];
618 if ((old_name_len + new_name_len + sizeof(struct RenameMessage) != size) ||
619 ('\0' != old_name[old_name_len - 1]) ||
620 ('\0' != new_name[new_name_len - 1]))
621 {
622 GNUNET_break (0);
623 return GNUNET_SYSERR;
624 }
625
626 return GNUNET_OK;
627}
Client requests renaming of an identity.
Definition: identity.h:178

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, RenameContext::new_name, RenameContext::old_name, GNUNET_MessageHeader::size, and size.

◆ handle_rename_message()

static void handle_rename_message ( void *  cls,
const struct RenameMessage rm 
)
static

Handler for RENAME message from client, creates new identity.

Parameters
clsunused
rmthe message received

Definition at line 638 of file gnunet-service-identity.c.

639{
640 uint16_t old_name_len;
641 struct Ego *ego;
642 char *old_name;
643 char *new_name;
644 struct RenameContext rename_ctx;
645 struct GNUNET_SERVICE_Client *client = cls;
646 char *fn_old;
647 char *fn_new;
648 const char *old_name_tmp;
649
650 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received RENAME message from client\n");
651 old_name_len = ntohs (rm->old_name_len);
652 old_name_tmp = (const char *) &rm[1];
653 old_name = GNUNET_strdup (old_name_tmp);
654 GNUNET_STRINGS_utf8_tolower (old_name_tmp, old_name);
655 new_name = GNUNET_strdup (&old_name_tmp[old_name_len]);
656 GNUNET_STRINGS_utf8_tolower (&old_name_tmp[old_name_len], new_name);
657
658 /* check if new name is already in use */
659 for (ego = ego_head; NULL != ego; ego = ego->next)
660 {
661 if (0 == strcmp (ego->identifier, new_name))
662 {
665 GNUNET_free (old_name);
666 GNUNET_free (new_name);
667 return;
668 }
669 }
670
671 /* locate old name and, if found, perform rename */
672 for (ego = ego_head; NULL != ego; ego = ego->next)
673 {
674 if (0 == strcmp (ego->identifier, old_name))
675 {
676 fn_old = get_ego_filename (ego);
677 GNUNET_free (ego->identifier);
678 rename_ctx.old_name = old_name;
679 rename_ctx.new_name = new_name;
682 &rename_ctx);
683 if (GNUNET_OK !=
685 GNUNET_log (
687 _ ("Failed to write subsystem default identifier map to `%s'.\n"),
689 ego->identifier = GNUNET_strdup (new_name);
690 fn_new = get_ego_filename (ego);
691 if (0 != rename (fn_old, fn_new))
693 GNUNET_free (fn_old);
694 GNUNET_free (fn_new);
695 GNUNET_free (old_name);
696 GNUNET_free (new_name);
697 notify_listeners (ego);
700 return;
701 }
702 }
703
704 /* failed to locate old name */
706 GNUNET_free (old_name);
707 GNUNET_free (new_name);
709}
static void handle_ego_rename(void *cls, const char *section)
An ego was renamed; rename it in all subsystems where it is currently set as the default.
void GNUNET_CONFIGURATION_iterate_sections(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_SectionIterator iter, void *iter_cls)
Iterate over all sections in the configuration.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
@ GNUNET_ERROR_TYPE_WARNING
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
uint16_t old_name_len
Number of characters in the old name including 0-termination, in NBO.
Definition: identity.h:187

References _, ego_head, get_ego_filename(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_EC_IDENTITY_NAME_CONFLICT, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle_ego_rename(), Ego::identifier, RenameContext::new_name, Ego::next, notify_listeners(), RenameContext::old_name, RenameMessage::old_name_len, send_result_code(), subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

◆ handle_ego_delete()

static void handle_ego_delete ( void *  cls,
const char *  section 
)
static

An ego was removed, remove it from all subsystems where it is currently set as the default.

Parameters
clsname of the removed ego (const char *)
sectiona section in the configuration to process

Definition at line 720 of file gnunet-service-identity.c.

721{
722 const char *identifier = cls;
723 char *id;
724
726 section,
727 "DEFAULT_IDENTIFIER",
728 &id))
729 return;
730 if (0 != strcmp (id, identifier))
731 {
732 GNUNET_free (id);
733 return;
734 }
736 section,
737 "DEFAULT_IDENTIFIER",
738 NULL);
739 GNUNET_free (id);
740}

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, id, and subsystem_cfg.

Referenced by handle_delete_message().

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

◆ check_delete_message()

static int check_delete_message ( void *  cls,
const struct DeleteMessage msg 
)
static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_DELETE message.

Parameters
clsclient sending the message
msgmessage of type struct DeleteMessage
Returns
GNUNET_OK if msg is well-formed

Definition at line 751 of file gnunet-service-identity.c.

752{
753 uint16_t size;
754 uint16_t name_len;
755 const char *name;
756
757 size = ntohs (msg->header.size);
758 if (size <= sizeof(struct DeleteMessage))
759 {
760 GNUNET_break (0);
761 return GNUNET_SYSERR;
762 }
763 name = (const char *) &msg[1];
764 name_len = ntohs (msg->name_len);
765 if ((name_len + sizeof(struct DeleteMessage) != size) ||
766 (0 != ntohs (msg->reserved)) || ('\0' != name[name_len - 1]))
767 {
768 GNUNET_break (0);
769 return GNUNET_SYSERR;
770 }
771 return GNUNET_OK;
772}
Client requests deletion of an identity.
Definition: identity.h:204

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, name, GNUNET_MessageHeader::size, and size.

◆ handle_delete_message()

static void handle_delete_message ( void *  cls,
const struct DeleteMessage dm 
)
static

Handler for DELETE message from client, creates new identity.

Parameters
clsunused
dmthe message received

Definition at line 783 of file gnunet-service-identity.c.

784{
785 struct Ego *ego;
786 char *name;
787 char *fn;
788 struct GNUNET_SERVICE_Client *client = cls;
789
790 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received DELETE message from client\n");
791 name = GNUNET_strdup ((const char *) &dm[1]);
792 GNUNET_STRINGS_utf8_tolower ((const char *) &dm[1], name);
793
794 for (ego = ego_head; NULL != ego; ego = ego->next)
795 {
796 if (0 == strcmp (ego->identifier, name))
797 {
801 ego->identifier);
802 if (GNUNET_OK !=
804 GNUNET_log (
806 _ ("Failed to write subsystem default identifier map to `%s'.\n"),
808 fn = get_ego_filename (ego);
809 if (0 != unlink (fn))
811 GNUNET_free (fn);
812 GNUNET_free (ego->identifier);
813 ego->identifier = NULL;
814 notify_listeners (ego);
815 GNUNET_free (ego);
819 return;
820 }
821 }
822
826}
static void handle_ego_delete(void *cls, const char *section)
An ego was removed, remove it from all subsystems where it is currently set as the default.

References _, ego_head, ego_tail, get_ego_filename(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_DLL_remove, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle_ego_delete(), Ego::identifier, name, Ego::next, notify_listeners(), send_result_code(), subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

◆ read_from_file()

static int read_from_file ( const char *  filename,
void *  buf,
size_t  buf_size 
)
static

Definition at line 830 of file gnunet-service-identity.c.

833{
834 int fd;
835 struct stat sb;
836
837 fd = open (filename,
838 O_RDONLY);
839 if (-1 == fd)
840 {
841 memset (buf,
842 0,
843 buf_size);
844 return GNUNET_SYSERR;
845 }
846 if (0 != fstat (fd,
847 &sb))
848 {
850 "stat",
851 filename);
852 GNUNET_assert (0 == close (fd));
853 memset (buf,
854 0,
855 buf_size);
856 return GNUNET_SYSERR;
857 }
858 if (sb.st_size != buf_size)
859 {
861 "File `%s' has wrong size (%llu), expected %llu bytes\n",
862 filename,
863 (unsigned long long) sb.st_size,
864 (unsigned long long) buf_size);
865 GNUNET_assert (0 == close (fd));
866 memset (buf,
867 0,
868 buf_size);
869 return GNUNET_SYSERR;
870 }
871 if (buf_size !=
872 read (fd,
873 buf,
874 buf_size))
875 {
877 "read",
878 filename);
879 GNUNET_assert (0 == close (fd));
880 memset (buf,
881 0,
882 buf_size);
883 return GNUNET_SYSERR;
884 }
885 GNUNET_assert (0 == close (fd));
886 return GNUNET_OK;
887}
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References filename, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, and GNUNET_SYSERR.

Referenced by process_ego_file().

Here is the caller graph for this function:

◆ process_ego_file()

static int process_ego_file ( void *  cls,
const char *  filename 
)
static

Process the given file from the "EGODIR".

Parses the file and creates the respective 'struct Ego' in memory.

Parameters
clsNULL
filenamename of the file to parse
Returns
GNUNET_OK to continue to iterate, GNUNET_NO to stop iteration with no error, GNUNET_SYSERR to abort iteration with error!

Definition at line 901 of file gnunet-service-identity.c.

903{
904 struct Ego *ego;
905 const char *fn;
906
907 fn = strrchr (filename, (int) DIR_SEPARATOR);
908 if (NULL == fn)
909 {
910 GNUNET_break (0);
911 return GNUNET_OK;
912 }
913 ego = GNUNET_new (struct Ego);
914 if (GNUNET_OK !=
916 &ego->pk,
917 sizeof (ego->pk)))
918 {
919 GNUNET_free (ego);
921 _ ("Failed to parse ego information in `%s'\n"),
922 filename);
923 return GNUNET_OK;
924 }
926 "Loaded ego `%s'\n",
927 fn + 1);
928 ego->identifier = GNUNET_strdup (fn + 1);
930 return GNUNET_OK;
931}
static int read_from_file(const char *filename, void *buf, size_t buf_size)
#define DIR_SEPARATOR
Definition: platform.h:165

References _, DIR_SEPARATOR, ego_head, ego_tail, filename, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_strdup, Ego::identifier, Ego::pk, and read_from_file().

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,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Handle network size estimate clients.

Parameters
clsclosure
serverthe initialized server
cconfiguration to use

Definition at line 942 of file gnunet-service-identity.c.

945{
946 cfg = c;
949 "identity",
950 "EGODIR",
952 {
955 return;
956 }
957 if (GNUNET_OK !=
959 "identity",
960 "SUBSYSTEM_CFG",
962 {
964 "identity",
965 "SUBSYSTEM_CFG");
967 return;
968 }
970 "Loading subsystem configuration `%s'\n",
974 (GNUNET_OK !=
976 {
978 _ (
979 "Failed to parse subsystem identity configuration file `%s'\n"),
982 return;
983 }
984 stats = GNUNET_STATISTICS_create ("identity", cfg);
986 {
988 _ ("Failed to create directory `%s' for storing egos\n"),
990 }
993 NULL);
995}
static const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our current configuration.
static void shutdown_task(void *cls)
Task run during shutdown.
static int process_ego_file(void *cls, const char *filename)
Process the given file from the "EGODIR".
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Parse a configuration file, add all of the options in the file to the configuration environment.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:122
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567
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:1340
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.

References _, cfg, ego_directory, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_parse(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_scan(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_config_missing(), GNUNET_notification_context_create(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_YES, nc, process_ego_file(), shutdown_task(), stats, subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "identity"  ,
GNUNET_SERVICE_OPTION_NONE  ,
run,
client_connect_cb,
client_disconnect_cb,
NULL  ,
GNUNET_MQ_hd_fixed_size(start_message, GNUNET_MESSAGE_TYPE_IDENTITY_START, struct GNUNET_MessageHeader, NULL)  ,
GNUNET_MQ_hd_var_size(lookup_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, struct LookupMessage, NULL)  ,
GNUNET_MQ_hd_var_size(lookup_by_suffix_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, struct LookupMessage, NULL)  ,
GNUNET_MQ_hd_var_size(create_message, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, struct CreateRequestMessage, NULL)  ,
GNUNET_MQ_hd_var_size(rename_message, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, struct RenameMessage, NULL)  ,
GNUNET_MQ_hd_var_size(delete_message, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, struct DeleteMessage, NULL)  ,
GNUNET_MQ_handler_end()   
)

Define "main" method using service macro.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Handle to our current configuration.

Definition at line 72 of file gnunet-service-identity.c.

Referenced by run().

◆ subsystem_cfg

struct GNUNET_CONFIGURATION_Handle* subsystem_cfg
static

Handle to subsystem configuration which for each subsystem contains the name of the default ego.

Definition at line 78 of file gnunet-service-identity.c.

Referenced by handle_delete_message(), handle_ego_delete(), handle_ego_rename(), handle_rename_message(), run(), and shutdown_task().

◆ stats

struct GNUNET_STATISTICS_Handle* stats
static

Handle to the statistics service.

Definition at line 83 of file gnunet-service-identity.c.

Referenced by run(), and shutdown_task().

◆ nc

struct GNUNET_NotificationContext* nc
static

Notification context, simplifies client broadcasts.

Definition at line 88 of file gnunet-service-identity.c.

Referenced by handle_start_message(), notify_listeners(), run(), and shutdown_task().

◆ ego_directory

char* ego_directory
static

Directory where we store the identities.

Definition at line 93 of file gnunet-service-identity.c.

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

◆ subsystem_cfg_file

char* subsystem_cfg_file
static

Configuration file name where subsystem information is kept.

Definition at line 98 of file gnunet-service-identity.c.

Referenced by handle_delete_message(), handle_rename_message(), run(), and shutdown_task().

◆ ego_head

◆ ego_tail

struct Ego* ego_tail
static

Tail of DLL of all egos.

Definition at line 108 of file gnunet-service-identity.c.

Referenced by handle_create_message(), handle_delete_message(), process_ego_file(), and shutdown_task().