for (dq_entry = ds_entry->queue_entries_head; NULL != dq_entry;
dq_entry = ds_entry->queue_entries_head) {
GNUNET_CONTAINER_DLL_remove (ds_entry->queue_entries_head,
- ds_entry->queue_entries_tail, dq_entry);
+ ds_entry->queue_entries_tail,
+ dq_entry);
for (child = dq_entry->set_entries_head; NULL != child;
child = dq_entry->set_entries_head) {
GNUNET_CONTAINER_DLL_remove (dq_entry->set_entries_head,
- dq_entry->set_entries_tail, child);
+ dq_entry->set_entries_tail,
+ child);
cleanup_delegation_set (child);
}
GNUNET_free (dq_entry);
GNUNET_free_non_null (vrh->issuer_attribute);
for (cr_entry = vrh->cred_chain_head; NULL != vrh->cred_chain_head;
cr_entry = vrh->cred_chain_head) {
- GNUNET_CONTAINER_DLL_remove (vrh->cred_chain_head, vrh->cred_chain_tail,
+ GNUNET_CONTAINER_DLL_remove (vrh->cred_chain_head,
+ vrh->cred_chain_tail,
cr_entry);
GNUNET_free_non_null (cr_entry->credential);
GNUNET_free (cr_entry);
}
tmp = cd;
cd = cd->next;
- GNUNET_CONTAINER_DLL_remove (vrh->cred_chain_head, vrh->cred_chain_tail,
+ GNUNET_CONTAINER_DLL_remove (vrh->cred_chain_head,
+ vrh->cred_chain_tail,
tmp);
GNUNET_free (tmp->credential);
GNUNET_free (tmp);
for (uint32_t i = 0; i < vrh->cred_chain_size; i++) {
cred[i].issuer_key = cd->credential->issuer_key;
cred[i].subject_key = cd->credential->subject_key;
- cred[i].issuer_attribute_len =
- strlen (cd->credential->issuer_attribute) + 1;
+ cred[i].issuer_attribute_len
+ = strlen (cd->credential->issuer_attribute) + 1;
cred[i].issuer_attribute = cd->credential->issuer_attribute;
cred[i].expiration = cd->credential->expiration;
cred[i].signature = cd->credential->signature;
cd = cd->next;
}
- size = GNUNET_CREDENTIAL_delegation_chain_get_size (
- vrh->delegation_chain_size, dd, vrh->cred_chain_size, cred);
- env = GNUNET_MQ_msg_extra (rmsg, size,
+ size
+ = GNUNET_CREDENTIAL_delegation_chain_get_size (vrh->delegation_chain_size,
+ dd,
+ vrh->cred_chain_size,
+ cred);
+ env = GNUNET_MQ_msg_extra (rmsg,
+ size,
GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY_RESULT);
// Assign id so that client can find associated request
rmsg->id = vrh->request_id;
else
rmsg->cred_found = htonl (GNUNET_NO);
- GNUNET_assert (-1 != GNUNET_CREDENTIAL_delegation_chain_serialize (
- vrh->delegation_chain_size, dd, vrh->cred_chain_size,
- cred, size, (char *)&rmsg[1]));
+ GNUNET_assert (
+ -1
+ != GNUNET_CREDENTIAL_delegation_chain_serialize (vrh->delegation_chain_size,
+ dd,
+ vrh->cred_chain_size,
+ cred,
+ size,
+ (char *)&rmsg[1]));
GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (vrh->client), env);
GNUNET_CONTAINER_DLL_remove (vrh_head, vrh_tail, vrh);
cleanup_handle (vrh);
- GNUNET_STATISTICS_update (statistics, "Completed verifications", 1,
+ GNUNET_STATISTICS_update (statistics,
+ "Completed verifications",
+ 1,
GNUNET_NO);
}
static void
-backward_resolution (void *cls, uint32_t rd_count,
+backward_resolution (void *cls,
+ uint32_t rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
sets = rd[i].data;
struct GNUNET_CREDENTIAL_DelegationSet set[ntohl (sets->set_count)];
GNUNET_log (
- GNUNET_ERROR_TYPE_DEBUG,
- "Found new attribute delegation with %d sets. Creating new Job...\n",
- ntohl (sets->set_count));
-
- if (GNUNET_OK != GNUNET_CREDENTIAL_delegation_set_deserialize (
- GNUNET_ntohll (sets->data_size),
- (const char *)&sets[1], ntohl (sets->set_count),
- set)) {
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Found new attribute delegation with %d sets. Creating new Job...\n",
+ ntohl (sets->set_count));
+
+ if (GNUNET_OK
+ != GNUNET_CREDENTIAL_delegation_set_deserialize (
+ GNUNET_ntohll (sets->data_size),
+ (const char *)&sets[1],
+ ntohl (sets->set_count),
+ set)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to deserialize!\n");
continue;
}
dq_entry->required_solutions = ntohl (sets->set_count);
dq_entry->parent_set = current_set;
GNUNET_CONTAINER_DLL_insert (current_set->queue_entries_head,
- current_set->queue_entries_tail, dq_entry);
+ current_set->queue_entries_tail,
+ dq_entry);
// Each AND
for (uint32_t j = 0; j < ntohl (sets->set_count); j++) {
ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
GNUNET_asprintf (&expanded_attr, "%s", current_set->attr_trailer);
} else {
- GNUNET_asprintf (&expanded_attr, "%s.%s", set[j].subject_attribute,
+ GNUNET_asprintf (&expanded_attr,
+ "%s.%s",
+ set[j].subject_attribute,
current_set->attr_trailer);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Expanded to %s\n", expanded_attr);
ds_entry->unresolved_attribute_delegation = expanded_attr;
} else {
if (0 != set[j].subject_attribute_len) {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not Expanding %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Not Expanding %s\n",
set[j].subject_attribute);
- ds_entry->unresolved_attribute_delegation =
- GNUNET_strdup (set[j].subject_attribute);
+ ds_entry->unresolved_attribute_delegation
+ = GNUNET_strdup (set[j].subject_attribute);
}
}
// Add a credential chain entry
- ds_entry->delegation_chain_entry =
- GNUNET_new (struct DelegationChainEntry);
+ ds_entry->delegation_chain_entry
+ = GNUNET_new (struct DelegationChainEntry);
ds_entry->delegation_chain_entry->subject_key = set[j].subject_key;
ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPublicKey);
- GNUNET_memcpy (ds_entry->issuer_key, &set[j].subject_key,
+ GNUNET_memcpy (ds_entry->issuer_key,
+ &set[j].subject_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
if (0 < set[j].subject_attribute_len)
- ds_entry->delegation_chain_entry->subject_attribute =
- GNUNET_strdup (set[j].subject_attribute);
+ ds_entry->delegation_chain_entry->subject_attribute
+ = GNUNET_strdup (set[j].subject_attribute);
ds_entry->delegation_chain_entry->issuer_key = *current_set->issuer_key;
- ds_entry->delegation_chain_entry->issuer_attribute =
- GNUNET_strdup (current_set->lookup_attribute);
+ ds_entry->delegation_chain_entry->issuer_attribute
+ = GNUNET_strdup (current_set->lookup_attribute);
ds_entry->parent_queue_entry = dq_entry; // current_delegation;
GNUNET_CONTAINER_DLL_insert (dq_entry->set_entries_head,
- dq_entry->set_entries_tail, ds_entry);
+ dq_entry->set_entries_tail,
+ ds_entry);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking for cred match\n");
/**
*/
for (cred_pointer = vrh->cred_chain_head; cred_pointer != NULL;
cred_pointer = cred_pointer->next) {
- if (0 != memcmp (&set->subject_key,
- &cred_pointer->credential->issuer_key,
- sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
+ if (0
+ != memcmp (&set->subject_key,
+ &cred_pointer->credential->issuer_key,
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
continue;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking if %s matches %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Checking if %s matches %s\n",
ds_entry->unresolved_attribute_delegation,
cred_pointer->credential->issuer_attribute);
- if (0 != strcmp (ds_entry->unresolved_attribute_delegation,
- cred_pointer->credential->issuer_attribute))
+ if (0
+ != strcmp (ds_entry->unresolved_attribute_delegation,
+ cred_pointer->credential->issuer_attribute))
continue;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found issuer\n");
"Building new lookup request from %s\n",
ds_entry->unresolved_attribute_delegation);
// Continue with backward resolution
- char issuer_attribute_name
- [strlen (ds_entry->unresolved_attribute_delegation) + 1];
+ char
+ issuer_attribute_name[strlen (ds_entry->unresolved_attribute_delegation)
+ + 1];
strcpy (issuer_attribute_name, ds_entry->unresolved_attribute_delegation);
char *next_attr = strtok (issuer_attribute_name, ".");
if (NULL == next_attr) {
}
GNUNET_asprintf (&lookup_attribute, "%s", next_attr);
GNUNET_asprintf (&ds_entry->lookup_attribute, "%s", next_attr);
- if (strlen (next_attr) ==
- strlen (ds_entry->unresolved_attribute_delegation)) {
+ if (strlen (next_attr)
+ == strlen (ds_entry->unresolved_attribute_delegation)) {
ds_entry->attr_trailer = NULL;
} else {
next_attr += strlen (next_attr) + 1;
ds_entry->attr_trailer = GNUNET_strdup (next_attr);
}
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Looking up %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Looking up %s\n",
ds_entry->lookup_attribute);
if (NULL != ds_entry->attr_trailer)
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s still to go...\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "%s still to go...\n",
ds_entry->attr_trailer);
vrh->pending_lookups++;
ds_entry->handle = vrh;
- ds_entry->lookup_request = GNUNET_GNS_lookup (
- gns, lookup_attribute,
- ds_entry->issuer_key, // issuer_key,
- GNUNET_GNSRECORD_TYPE_ATTRIBUTE, GNUNET_GNS_LO_DEFAULT,
- &backward_resolution, ds_entry);
+ ds_entry->lookup_request
+ = GNUNET_GNS_lookup (gns,
+ lookup_attribute,
+ ds_entry->issuer_key, // issuer_key,
+ GNUNET_GNSRECORD_TYPE_ATTRIBUTE,
+ GNUNET_GNS_LO_DEFAULT,
+ &backward_resolution,
+ ds_entry);
GNUNET_free (lookup_attribute);
}
}
for (cr_entry = vrh->cred_chain_head; cr_entry != NULL;
cr_entry = cr_entry->next) {
- if (0 != memcmp (&cr_entry->credential->issuer_key, &vrh->issuer_key,
- sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
+ if (0
+ != memcmp (&cr_entry->credential->issuer_key,
+ &vrh->issuer_key,
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
continue;
- if (0 !=
- strcmp (cr_entry->credential->issuer_attribute, vrh->issuer_attribute))
+ if (0
+ != strcmp (cr_entry->credential->issuer_attribute,
+ vrh->issuer_attribute))
continue;
cr_entry->refcount++;
// Found match prematurely
*/
char issuer_attribute_name[strlen (vrh->issuer_attribute) + 1];
strcpy (issuer_attribute_name, vrh->issuer_attribute);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Looking up %s\n",
issuer_attribute_name);
ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
ds_entry->issuer_key = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPublicKey);
- GNUNET_memcpy (ds_entry->issuer_key, &vrh->issuer_key,
+ GNUNET_memcpy (ds_entry->issuer_key,
+ &vrh->issuer_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
ds_entry->issuer_attribute = GNUNET_strdup (vrh->issuer_attribute);
ds_entry->handle = vrh;
vrh->root_set = ds_entry;
vrh->pending_lookups = 1;
// Start with backward resolution
- ds_entry->lookup_request =
- GNUNET_GNS_lookup (gns, issuer_attribute_name,
- &vrh->issuer_key, // issuer_key,
- GNUNET_GNSRECORD_TYPE_ATTRIBUTE, GNUNET_GNS_LO_DEFAULT,
- &backward_resolution, ds_entry);
+ ds_entry->lookup_request = GNUNET_GNS_lookup (gns,
+ issuer_attribute_name,
+ &vrh->issuer_key, // issuer_key,
+ GNUNET_GNSRECORD_TYPE_ATTRIBUTE,
+ GNUNET_GNS_LO_DEFAULT,
+ &backward_resolution,
+ ds_entry);
}
static int
* TODO: cleanup!
*/
credentials_count = ntohl (v_msg->c_count);
- credential_data_size = ntohs (v_msg->header.size) -
- sizeof (struct VerifyMessage) -
- ntohs (v_msg->issuer_attribute_len) - 1;
+ credential_data_size = ntohs (v_msg->header.size)
+ - sizeof (struct VerifyMessage)
+ - ntohs (v_msg->issuer_attribute_len) - 1;
struct GNUNET_CREDENTIAL_Credential credentials[credentials_count];
+ memset (credentials,
+ 0,
+ sizeof (struct GNUNET_CREDENTIAL_Credential) * credentials_count);
credential_data = (char *)&v_msg[1] + ntohs (v_msg->issuer_attribute_len) + 1;
- if (GNUNET_OK != GNUNET_CREDENTIAL_credentials_deserialize (
- credential_data_size, credential_data, credentials_count,
- credentials)) {
+ if (GNUNET_OK
+ != GNUNET_CREDENTIAL_credentials_deserialize (credential_data_size,
+ credential_data,
+ credentials_count,
+ credentials)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot deserialize credentials!\n");
send_lookup_response (vrh);
return;
for (uint32_t i = 0; i < credentials_count; i++) {
cr_entry = GNUNET_new (struct CredentialRecordEntry);
- cr_entry->credential =
- GNUNET_malloc (sizeof (struct GNUNET_CREDENTIAL_Credential) +
- credentials[i].issuer_attribute_len);
- GNUNET_memcpy (cr_entry->credential, &credentials[i],
+ cr_entry->credential
+ = GNUNET_malloc (sizeof (struct GNUNET_CREDENTIAL_Credential)
+ + credentials[i].issuer_attribute_len + 1);
+ GNUNET_memcpy (cr_entry->credential,
+ &credentials[i],
sizeof (struct GNUNET_CREDENTIAL_Credential));
- GNUNET_memcpy (&cr_entry->credential[1], credentials[i].issuer_attribute,
+ GNUNET_memcpy (&cr_entry->credential[1],
+ credentials[i].issuer_attribute,
credentials[i].issuer_attribute_len);
+ cr_entry->credential->issuer_attribute_len
+ = credentials[i].issuer_attribute_len;
cr_entry->credential->issuer_attribute = (char *)&cr_entry->credential[1];
GNUNET_CONTAINER_DLL_insert_tail (vrh->cred_chain_head,
- vrh->cred_chain_tail, cr_entry);
+ vrh->cred_chain_tail,
+ cr_entry);
vrh->cred_chain_size++;
}
static void
handle_cred_collection_cb (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
- const char *label, unsigned int rd_count,
+ const char *label,
+ unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct VerifyRequestHandle *vrh = cls;
if (GNUNET_GNSRECORD_TYPE_CREDENTIAL != rd[i].record_type)
continue;
cred_record_count++;
- crd =
- GNUNET_CREDENTIAL_credential_deserialize (rd[i].data, rd[i].data_size);
+ crd
+ = GNUNET_CREDENTIAL_credential_deserialize (rd[i].data, rd[i].data_size);
if (NULL == crd) {
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Invalid credential found\n");
continue;
cr_entry = GNUNET_new (struct CredentialRecordEntry);
cr_entry->credential = crd;
GNUNET_CONTAINER_DLL_insert_tail (vrh->cred_chain_head,
- vrh->cred_chain_tail, cr_entry);
+ vrh->cred_chain_tail,
+ cr_entry);
vrh->cred_chain_size++;
}
vrh->collect_next_task = GNUNET_SCHEDULER_add_now (&collect_next, vrh);
* First, get attribute from subject
*/
vrh->cred_collection_iter = GNUNET_NAMESTORE_zone_iteration_start (
- namestore, &c_msg->subject_key, &handle_cred_collection_error_cb, vrh,
- &handle_cred_collection_cb, vrh, &handle_cred_collection_finished_cb,
- vrh);
+ namestore,
+ &c_msg->subject_key,
+ &handle_cred_collection_error_cb,
+ vrh,
+ &handle_cred_collection_cb,
+ vrh,
+ &handle_cred_collection_finished_cb,
+ vrh);
GNUNET_SERVICE_client_continue (vrh->client);
}
}
attr = (const char *)&c_msg[1];
- if (('\0' != attr[msg_size - sizeof (struct CollectMessage) - 1]) ||
- (strlen (attr) > GNUNET_CREDENTIAL_MAX_LENGTH)) {
+ if (('\0' != attr[msg_size - sizeof (struct CollectMessage) - 1])
+ || (strlen (attr) > GNUNET_CREDENTIAL_MAX_LENGTH)) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
}
static void
-client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client,
+client_disconnect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
void *app_ctx)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
}
static void *
-client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client,
+client_connect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
struct GNUNET_MQ_Handle *mq)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
* @param handle service handle
*/
static void
-run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c,
+run (void *cls,
+ const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *handle)
{
* Define "main" method using service macro
*/
GNUNET_SERVICE_MAIN (
- "credential", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb,
- &client_disconnect_cb, NULL,
- GNUNET_MQ_hd_var_size (verify, GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY,
- struct VerifyMessage, NULL),
- GNUNET_MQ_hd_var_size (collect, GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT,
- struct CollectMessage, NULL),
- GNUNET_MQ_handler_end ());
+ "credential",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_var_size (verify,
+ GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY,
+ struct VerifyMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (collect,
+ GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT,
+ struct CollectMessage,
+ NULL),
+ GNUNET_MQ_handler_end ());
/* end of gnunet-service-credential.c */
projects / oweals / gnunet.git / commitdiff