WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
* @author Martin Schanzenbach
*/
#include "platform.h"
+
#include "gnunet_util_lib.h"
-#include "gnunet_credential_service.h"
-#include "gnunet_statistics_service.h"
+
#include "credential.h"
#include "credential_serialization.h"
+#include "gnunet_credential_service.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
-
+#include "gnunet_statistics_service.h"
#include <gnunet_dnsparser_lib.h>
-#include <gnunet_identity_service.h>
+#include <gnunet_gns_service.h>
#include <gnunet_gnsrecord_lib.h>
+#include <gnunet_identity_service.h>
#include <gnunet_namestore_service.h>
-#include <gnunet_gns_service.h>
#define GNUNET_CREDENTIAL_MAX_LENGTH 255
*/
struct DelegationSetQueueEntry *prev;
- /**
+ /**
* GNS handle
*/
struct GNUNET_GNS_LookupRequest *lookup_request;
* The delegation chain entry
*/
struct DelegationChainEntry *delegation_chain_entry;
-
};
* Collect task
*/
struct GNUNET_SCHEDULER_Task *collect_next_task;
-
};
if (NULL == ds_entry)
return;
- for (dq_entry = ds_entry->queue_entries_head;
- NULL != dq_entry;
- dq_entry = ds_entry->queue_entries_head)
- {
+ 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);
- for (child = dq_entry->set_entries_head;
- NULL != child;
- child = dq_entry->set_entries_head)
- {
+ 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 (ds_entry->issuer_attribute);
GNUNET_free_non_null (ds_entry->unresolved_attribute_delegation);
GNUNET_free_non_null (ds_entry->attr_trailer);
- if (NULL != ds_entry->lookup_request)
- {
+ if (NULL != ds_entry->lookup_request) {
GNUNET_GNS_lookup_cancel (ds_entry->lookup_request);
ds_entry->lookup_request = NULL;
}
- if (NULL != ds_entry->delegation_chain_entry)
- {
+ if (NULL != ds_entry->delegation_chain_entry) {
GNUNET_free_non_null (ds_entry->delegation_chain_entry->subject_attribute);
GNUNET_free_non_null (ds_entry->delegation_chain_entry->issuer_attribute);
GNUNET_free (ds_entry->delegation_chain_entry);
cleanup_handle (struct VerifyRequestHandle *vrh)
{
struct CredentialRecordEntry *cr_entry;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Cleaning up...\n");
- if (NULL != vrh->lookup_request)
- {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up...\n");
+ if (NULL != vrh->lookup_request) {
GNUNET_GNS_lookup_cancel (vrh->lookup_request);
vrh->lookup_request = NULL;
}
cleanup_delegation_set (vrh->root_set);
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,
+ 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,
cr_entry);
GNUNET_free_non_null (cr_entry->credential);
GNUNET_free (cr_entry);
{
struct VerifyRequestHandle *vrh;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Shutting down!\n");
-
- while (NULL != (vrh = vrh_head))
- {
- //CREDENTIAL_resolver_lookup_cancel (clh->lookup);
- GNUNET_CONTAINER_DLL_remove (vrh_head,
- vrh_tail,
- vrh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down!\n");
+
+ while (NULL != (vrh = vrh_head)) {
+ // CREDENTIAL_resolver_lookup_cancel (clh->lookup);
+ GNUNET_CONTAINER_DLL_remove (vrh_head, vrh_tail, vrh);
cleanup_handle (vrh);
}
- if (NULL != gns)
- {
+ if (NULL != gns) {
GNUNET_GNS_disconnect (gns);
gns = NULL;
}
- if (NULL != namestore)
- {
+ if (NULL != namestore) {
GNUNET_NAMESTORE_disconnect (namestore);
namestore = NULL;
}
- if (NULL != statistics)
- {
- GNUNET_STATISTICS_destroy (statistics,
- GNUNET_NO);
+ if (NULL != statistics) {
+ GNUNET_STATISTICS_destroy (statistics, GNUNET_NO);
statistics = NULL;
}
-
}
-
static void
send_lookup_response (struct VerifyRequestHandle *vrh)
{
struct CredentialRecordEntry *tmp;
size_t size;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending response\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending response\n");
dce = vrh->delegation_chain_head;
- for (uint32_t i=0;i<vrh->delegation_chain_size;i++)
- {
+ for (uint32_t i = 0; i < vrh->delegation_chain_size; i++) {
dd[i].issuer_key = dce->issuer_key;
dd[i].subject_key = dce->subject_key;
dd[i].issuer_attribute = dce->issuer_attribute;
- dd[i].issuer_attribute_len = strlen (dce->issuer_attribute)+1;
+ dd[i].issuer_attribute_len = strlen (dce->issuer_attribute) + 1;
dd[i].subject_attribute_len = 0;
dd[i].subject_attribute = NULL;
- if (NULL != dce->subject_attribute)
- {
+ if (NULL != dce->subject_attribute) {
dd[i].subject_attribute = dce->subject_attribute;
- dd[i].subject_attribute_len = strlen(dce->subject_attribute)+1;
+ dd[i].subject_attribute_len = strlen (dce->subject_attribute) + 1;
}
dce = dce->next;
}
/**
* Remove all credentials not needed
*/
- for (cd = vrh->cred_chain_head; NULL != cd;)
- {
- if (cd->refcount > 0)
- {
+ for (cd = vrh->cred_chain_head; NULL != cd;) {
+ if (cd->refcount > 0) {
cd = cd->next;
continue;
}
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);
* Append at the end of rmsg
*/
cd = vrh->cred_chain_head;
- for (uint32_t i=0;i<vrh->cred_chain_size;i++)
- {
+ 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
+ // Assign id so that client can find associated request
rmsg->id = vrh->request_id;
rmsg->d_count = htonl (vrh->delegation_chain_size);
rmsg->c_count = htonl (vrh->cred_chain_size);
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_MQ_send (GNUNET_SERVICE_client_get_mq (vrh->client), env);
GNUNET_CONTAINER_DLL_remove (vrh_head, vrh_tail, vrh);
- cleanup_handle(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)
{
current_set->lookup_request = NULL;
vrh = current_set->handle;
vrh->pending_lookups--;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got %d attrs\n", rd_count);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got %d attrs\n", rd_count);
// Each OR
- for (uint32_t i=0; i < rd_count; i++)
- {
+ for (uint32_t i = 0; i < rd_count; i++) {
if (GNUNET_GNSRECORD_TYPE_ATTRIBUTE != rd[i].record_type)
continue;
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_log (GNUNET_ERROR_TYPE_ERROR,
- "Failed to deserialize!\n");
+ 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_log (GNUNET_ERROR_TYPE_ERROR, "Failed to deserialize!\n");
continue;
}
dq_entry = GNUNET_new (struct DelegationQueueEntry);
- dq_entry->required_solutions = ntohl(sets->set_count);
+ 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++)
- {
+ for (uint32_t j = 0; j < ntohl (sets->set_count); j++) {
ds_entry = GNUNET_new (struct DelegationSetQueueEntry);
- if (NULL != current_set->attr_trailer)
- {
- if (0 == set[j].subject_attribute_len)
- {
- GNUNET_asprintf (&expanded_attr,
- "%s",
- current_set->attr_trailer);
+ if (NULL != current_set->attr_trailer) {
+ if (0 == set[j].subject_attribute_len) {
+ 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);
+ 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", set[j].subject_attribute);
- ds_entry->unresolved_attribute_delegation = GNUNET_strdup (set[j].subject_attribute);
+ if (0 != set[j].subject_attribute_len) {
+ 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);
}
}
- //Add a credential chain entry
- ds_entry->delegation_chain_entry = GNUNET_new (struct DelegationChainEntry);
+ // Add a credential chain entry
+ 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;
+ 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");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking for cred match\n");
/**
* Check if this delegation already matches one of our credentials
*/
- 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)))
+ 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)))
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);
cred_pointer->credential->issuer_attribute))
continue;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Found issuer\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found issuer\n");
cred_pointer->refcount++;
- //Backtrack
- for (tmp_set = ds_entry;
- NULL != tmp_set->parent_queue_entry;
- tmp_set = tmp_set->parent_queue_entry->parent_set)
- {
+ // Backtrack
+ for (tmp_set = ds_entry; NULL != tmp_set->parent_queue_entry;
+ tmp_set = tmp_set->parent_queue_entry->parent_set) {
tmp_set->parent_queue_entry->required_solutions--;
- if (NULL != tmp_set->delegation_chain_entry)
- {
+ if (NULL != tmp_set->delegation_chain_entry) {
vrh->delegation_chain_size++;
GNUNET_CONTAINER_DLL_insert (vrh->delegation_chain_head,
vrh->delegation_chain_tail,
break;
}
- if (NULL == tmp_set->parent_queue_entry)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "All solutions found\n");
- //Found match
+ if (NULL == tmp_set->parent_queue_entry) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "All solutions found\n");
+ // Found match
send_lookup_response (vrh);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Not all solutions found yet.\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Not all solutions found yet.\n");
continue;
-
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"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];
- strcpy (issuer_attribute_name,
- ds_entry->unresolved_attribute_delegation);
+ // Continue with backward resolution
+ 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)
- {
+ if (NULL == next_attr) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse next attribute\n");
continue;
}
- GNUNET_asprintf (&lookup_attribute,
- "%s.gnu",
- next_attr);
- GNUNET_asprintf (&ds_entry->lookup_attribute,
- "%s",
- next_attr);
- if (strlen (next_attr) == strlen (ds_entry->unresolved_attribute_delegation))
- {
+ 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)) {
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_DEBUG,
- "Looking up %s\n", ds_entry->lookup_attribute);
+ 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_DEBUG,
- "%s still to go...\n", ds_entry->attr_trailer);
+ 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);
}
}
- if(0 == vrh->pending_lookups)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "We are all out of attributes...\n");
+ if (0 == vrh->pending_lookups) {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "We are all out of attributes...\n");
send_lookup_response (vrh);
return;
-
}
}
* @param cls the closure (our client lookup handle)
*/
static void
-delegation_chain_resolution_start (void* cls)
+delegation_chain_resolution_start (void *cls)
{
struct VerifyRequestHandle *vrh = cls;
struct DelegationSetQueueEntry *ds_entry;
struct CredentialRecordEntry *cr_entry;
vrh->lookup_request = NULL;
- if (0 == vrh->cred_chain_size)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No credentials found\n");
+ if (0 == vrh->cred_chain_size) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No credentials found\n");
send_lookup_response (vrh);
return;
}
- 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,
+ 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)))
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
+ // Found match prematurely
send_lookup_response (vrh);
return;
-
}
/**
* Check for attributes from the issuer and follow the chain
* till you get the required subject's attributes
*/
- char issuer_attribute_name[strlen (vrh->issuer_attribute) + strlen (".gnu") + 1];
- strcpy (issuer_attribute_name,
- vrh->issuer_attribute);
- strcpy (issuer_attribute_name + strlen (vrh->issuer_attribute),
- ".gnu");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Looking up %s\n", issuer_attribute_name);
+ 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",
+ 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;
ds_entry->lookup_attribute = GNUNET_strdup (vrh->issuer_attribute);
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);
+ // 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);
}
static int
-check_verify (void *cls,
- const struct VerifyMessage *v_msg)
+check_verify (void *cls, const struct VerifyMessage *v_msg)
{
size_t msg_size;
- const char* attr;
+ const char *attr;
msg_size = ntohs (v_msg->header.size);
- if (msg_size < sizeof (struct VerifyMessage))
- {
+ if (msg_size < sizeof (struct VerifyMessage)) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
- if (ntohs (v_msg->issuer_attribute_len) > GNUNET_CREDENTIAL_MAX_LENGTH)
- {
+ if (ntohs (v_msg->issuer_attribute_len) > GNUNET_CREDENTIAL_MAX_LENGTH) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
- attr = (const char *) &v_msg[1];
+ attr = (const char *)&v_msg[1];
- if ( strlen (attr) > GNUNET_CREDENTIAL_MAX_LENGTH)
- {
+ if (strlen (attr) > GNUNET_CREDENTIAL_MAX_LENGTH) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
}
static void
-handle_verify (void *cls,
- const struct VerifyMessage *v_msg)
+handle_verify (void *cls, const struct VerifyMessage *v_msg)
{
struct VerifyRequestHandle *vrh;
struct GNUNET_SERVICE_Client *client = cls;
char *credential_data;
const char *utf_in;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received VERIFY message\n");
- utf_in = (const char *) &v_msg[1];
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received VERIFY message\n");
+ utf_in = (const char *)&v_msg[1];
GNUNET_STRINGS_utf8_tolower (utf_in, attrptr);
- GNUNET_memcpy (issuer_attribute,
- attr,
- ntohs (v_msg->issuer_attribute_len));
+ GNUNET_memcpy (issuer_attribute, attr, ntohs (v_msg->issuer_attribute_len));
issuer_attribute[ntohs (v_msg->issuer_attribute_len)] = '\0';
vrh = GNUNET_new (struct VerifyRequestHandle);
GNUNET_CONTAINER_DLL_insert (vrh_head, vrh_tail, vrh);
vrh->issuer_key = v_msg->issuer_key;
vrh->subject_key = v_msg->subject_key;
vrh->issuer_attribute = GNUNET_strdup (issuer_attribute);
- if (0 == strlen (issuer_attribute))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No issuer attribute provided!\n");
+ GNUNET_SERVICE_client_continue (vrh->client);
+ if (0 == strlen (issuer_attribute)) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer attribute provided!\n");
send_lookup_response (vrh);
return;
}
* First, collect credentials
* 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;
+ 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;
struct GNUNET_CREDENTIAL_Credential credentials[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))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot deserialize credentials!\n");
+ 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)) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot deserialize credentials!\n");
send_lookup_response (vrh);
return;
}
- for (uint32_t i=0;i<credentials_count;i++) {
+ 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);
+ 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 = (char*)&cr_entry->credential[1];
+ 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++;
}
delegation_chain_resolution_start (vrh);
-
}
static void
struct VerifyRequestHandle *vrh = cls;
vrh->collect_next_task = NULL;
GNUNET_assert (NULL != vrh->cred_collection_iter);
- GNUNET_NAMESTORE_zone_iterator_next (vrh->cred_collection_iter,
- 1);
+ GNUNET_NAMESTORE_zone_iterator_next (vrh->cred_collection_iter, 1);
}
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;
int cred_record_count;
cred_record_count = 0;
- for (uint32_t i=0; i < rd_count; i++)
- {
+ for (uint32_t i = 0; i < rd_count; i++) {
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);
- if (NULL == crd)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Invalid credential found\n");
+ 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);
+ vrh->collect_next_task = GNUNET_SCHEDULER_add_now (&collect_next, vrh);
}
static void
handle_cred_collection_finished_cb (void *cls)
{
struct VerifyRequestHandle *vrh = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Done collecting credentials.\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done collecting credentials.\n");
vrh->cred_collection_iter = NULL;
delegation_chain_resolution_start (vrh);
}
static void
-handle_collect (void *cls,
- const struct CollectMessage *c_msg)
+handle_collect (void *cls, const struct CollectMessage *c_msg)
{
char attr[GNUNET_CREDENTIAL_MAX_LENGTH + 1];
char issuer_attribute[GNUNET_CREDENTIAL_MAX_LENGTH + 1];
char *attrptr = attr;
const char *utf_in;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received COLLECT message\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received COLLECT message\n");
- utf_in = (const char *) &c_msg[1];
+ utf_in = (const char *)&c_msg[1];
GNUNET_STRINGS_utf8_tolower (utf_in, attrptr);
- GNUNET_memcpy (issuer_attribute,
- attr,
- ntohs (c_msg->issuer_attribute_len));
+ GNUNET_memcpy (issuer_attribute, attr, ntohs (c_msg->issuer_attribute_len));
issuer_attribute[ntohs (c_msg->issuer_attribute_len)] = '\0';
vrh = GNUNET_new (struct VerifyRequestHandle);
GNUNET_CONTAINER_DLL_insert (vrh_head, vrh_tail, vrh);
vrh->client = client;
vrh->request_id = c_msg->id;
vrh->issuer_key = c_msg->issuer_key;
- GNUNET_CRYPTO_ecdsa_key_get_public (&c_msg->subject_key,
- &vrh->subject_key);
+ GNUNET_CRYPTO_ecdsa_key_get_public (&c_msg->subject_key, &vrh->subject_key);
vrh->issuer_attribute = GNUNET_strdup (issuer_attribute);
- if (0 == strlen (issuer_attribute))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No issuer attribute provided!\n");
+ if (0 == strlen (issuer_attribute)) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No issuer attribute provided!\n");
send_lookup_response (vrh);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Getting credentials for subject\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting credentials for subject\n");
/**
* 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);
+ 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);
+ GNUNET_SERVICE_client_continue (vrh->client);
}
static int
-check_collect (void *cls,
- const struct CollectMessage *c_msg)
+check_collect (void *cls, const struct CollectMessage *c_msg)
{
size_t msg_size;
- const char* attr;
+ const char *attr;
msg_size = ntohs (c_msg->header.size);
- if (msg_size < sizeof (struct CollectMessage))
- {
+ if (msg_size < sizeof (struct CollectMessage)) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
- if (ntohs (c_msg->issuer_attribute_len) > GNUNET_CREDENTIAL_MAX_LENGTH)
- {
+ if (ntohs (c_msg->issuer_attribute_len) > GNUNET_CREDENTIAL_MAX_LENGTH) {
GNUNET_break (0);
return GNUNET_SYSERR;
}
- attr = (const char *) &c_msg[1];
+ 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);
+ 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);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
return 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)
{
gns = GNUNET_GNS_connect (c);
- if (NULL == gns)
- {
- fprintf (stderr,
- _("Failed to connect to GNS\n"));
+ if (NULL == gns) {
+ fprintf (stderr, _ ("Failed to connect to GNS\n"));
}
namestore = GNUNET_NAMESTORE_connect (c);
- if (NULL == namestore)
- {
- fprintf (stderr,
- _("Failed to connect to namestore\n"));
+ if (NULL == namestore) {
+ fprintf (stderr, _ ("Failed to connect to namestore\n"));
}
statistics = GNUNET_STATISTICS_create ("credential", c);
/**
* 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());
+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 ());
/* end of gnunet-service-credential.c */
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
* @brief gnsrecord plugin to provide the API for CREDENTIAL records
* @author Martin Schanzenbach
*/
-
#include "platform.h"
+
#include "gnunet_util_lib.h"
-#include "gnunet_gnsrecord_lib.h"
+
+#include "credential_misc.h"
+#include "credential_serialization.h"
#include "gnunet_credential_service.h"
+#include "gnunet_gnsrecord_lib.h"
#include "gnunet_gnsrecord_plugin.h"
#include "gnunet_signatures.h"
-#include "credential_serialization.h"
-#include "credential_misc.h"
-
/**
* Convert the 'value' of a record to a string.
*
* @return NULL on error, otherwise human-readable representation of the value
*/
static char *
-credential_value_to_string (void *cls,
- uint32_t type,
- const void *data,
- size_t data_size)
+credential_value_to_string (void *cls, uint32_t type, const void *data,
+ size_t data_size)
{
const char *cdata;
- switch (type)
- {
- case GNUNET_GNSRECORD_TYPE_ATTRIBUTE:
- {
+ switch (type) {
+ case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
struct GNUNET_CREDENTIAL_DelegationRecord sets;
char *attr_str;
char *subject_pkey;
int i;
if (data_size < sizeof (struct GNUNET_CREDENTIAL_DelegationRecord))
return NULL; /* malformed */
- GNUNET_memcpy (&sets,
- data,
- sizeof (sets));
+ GNUNET_memcpy (&sets, data, sizeof (sets));
cdata = data;
- struct GNUNET_CREDENTIAL_DelegationSet set[ntohl(sets.set_count)];
- if (GNUNET_OK != GNUNET_CREDENTIAL_delegation_set_deserialize (GNUNET_ntohll (sets.data_size),
- &cdata[sizeof (sets)],
- ntohl (sets.set_count),
- set))
+ struct GNUNET_CREDENTIAL_DelegationSet set[ntohl (sets.set_count)];
+ if (GNUNET_OK != GNUNET_CREDENTIAL_delegation_set_deserialize (
+ GNUNET_ntohll (sets.data_size), &cdata[sizeof (sets)],
+ ntohl (sets.set_count), set))
return NULL;
- for (i=0;i<ntohl(sets.set_count);i++)
- {
- subject_pkey = GNUNET_CRYPTO_ecdsa_public_key_to_string (&set[i].subject_key);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "%d len attr\n", set[i].subject_attribute_len);
- if (0 == set[i].subject_attribute_len)
- {
- if (0 == i)
- {
- GNUNET_asprintf (&attr_str,
- "%s",
- subject_pkey);
+ for (i = 0; i < ntohl (sets.set_count); i++) {
+ subject_pkey =
+ GNUNET_CRYPTO_ecdsa_public_key_to_string (&set[i].subject_key);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d len attr\n",
+ set[i].subject_attribute_len);
+ if (0 == set[i].subject_attribute_len) {
+ if (0 == i) {
+ GNUNET_asprintf (&attr_str, "%s", subject_pkey);
} else {
- GNUNET_asprintf (&tmp_str,
- "%s,%s",
- attr_str,
- subject_pkey);
+ GNUNET_asprintf (&tmp_str, "%s,%s", attr_str, subject_pkey);
GNUNET_free (attr_str);
attr_str = tmp_str;
}
} else {
- if (0 == i)
- {
- GNUNET_asprintf (&attr_str,
- "%s %s",
- subject_pkey,
+ if (0 == i) {
+ GNUNET_asprintf (&attr_str, "%s %s", subject_pkey,
set[i].subject_attribute);
} else {
- GNUNET_asprintf (&tmp_str,
- "%s,%s %s",
- attr_str,
- subject_pkey,
+ GNUNET_asprintf (&tmp_str, "%s,%s %s", attr_str, subject_pkey,
set[i].subject_attribute);
GNUNET_free (attr_str);
attr_str = tmp_str;
GNUNET_free (subject_pkey);
}
return attr_str;
- }
- case GNUNET_GNSRECORD_TYPE_CREDENTIAL:
- {
- struct GNUNET_CREDENTIAL_Credential *cred;
- char *cred_str;
-
- cred = GNUNET_CREDENTIAL_credential_deserialize (data,
- data_size);
- cred_str = GNUNET_CREDENTIAL_credential_to_string (cred);
- GNUNET_free (cred);
- return cred_str;
- }
- case GNUNET_GNSRECORD_TYPE_POLICY:
- {
- return GNUNET_strndup (data,data_size);
- }
- default:
- return NULL;
+ }
+ case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
+ struct GNUNET_CREDENTIAL_Credential *cred;
+ char *cred_str;
+
+ cred = GNUNET_CREDENTIAL_credential_deserialize (data, data_size);
+ cred_str = GNUNET_CREDENTIAL_credential_to_string (cred);
+ GNUNET_free (cred);
+ return cred_str;
+ }
+ case GNUNET_GNSRECORD_TYPE_POLICY: {
+ return GNUNET_strndup (data, data_size);
+ }
+ default:
+ return NULL;
}
}
* @return #GNUNET_OK on success
*/
static int
-credential_string_to_value (void *cls,
- uint32_t type,
- const char *s,
- void **data,
- size_t *data_size)
+credential_string_to_value (void *cls, uint32_t type, const char *s,
+ void **data, size_t *data_size)
{
if (NULL == s)
return GNUNET_SYSERR;
- switch (type)
- {
- case GNUNET_GNSRECORD_TYPE_ATTRIBUTE:
- {
- struct GNUNET_CREDENTIAL_DelegationRecord *sets;
- char attr_str[253 + 1];
- char subject_pkey[52 + 1];
- char *token;
- char *tmp_str;
- int matches = 0;
- int entries;
- size_t tmp_data_size;
- int i;
-
- tmp_str = GNUNET_strdup (s);
- token = strtok (tmp_str, ",");
- entries = 0;
- tmp_data_size = 0;
- *data_size = sizeof (struct GNUNET_CREDENTIAL_DelegationRecord);
- while (NULL != token)
- {
- matches = SSCANF (token,
- "%s %s",
- subject_pkey,
- attr_str);
- if (0 == matches)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Unable to parse ATTR record string `%s'\n"),
- s);
- GNUNET_free (tmp_str);
- return GNUNET_SYSERR;
- }
- if (1 == matches) {
- tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet);
- } else if (2 == matches) {
- tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet) + strlen (attr_str) + 1;
- }
- entries++;
- token = strtok (NULL, ",");
- }
- GNUNET_free (tmp_str);
- tmp_str = GNUNET_strdup (s);
- token = strtok (tmp_str, ",");
- if (NULL == token)
- {
- GNUNET_free (tmp_str);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Malformed string %s\n", s);
- return GNUNET_SYSERR;
- }
- struct GNUNET_CREDENTIAL_DelegationSet set[entries];
- for (i=0;i<entries;i++)
- {
- matches = SSCANF (token,
- "%s %s",
- subject_pkey,
- attr_str);
- GNUNET_CRYPTO_ecdsa_public_key_from_string (subject_pkey,
- strlen (subject_pkey),
- &set[i].subject_key);
- if (2 == matches) {
- set[i].subject_attribute_len = strlen (attr_str) + 1;
- set[i].subject_attribute = GNUNET_strdup (attr_str);
- }
- token = strtok (NULL , ",");
- }
- tmp_data_size = GNUNET_CREDENTIAL_delegation_set_get_size (entries,
- set);
-
- if (-1 == tmp_data_size)
- {
- GNUNET_free (tmp_str);
- return GNUNET_SYSERR;
- }
- *data_size += tmp_data_size;
- *data = sets = GNUNET_malloc (*data_size);
- GNUNET_CREDENTIAL_delegation_set_serialize (entries,
- set,
- tmp_data_size,
- (char*)&sets[1]);
- for (i=0;i<entries;i++)
- {
- if (0 != set[i].subject_attribute_len)
- GNUNET_free ((char*)set[i].subject_attribute);
- }
- sets->set_count = htonl (entries);
- sets->data_size = GNUNET_htonll (tmp_data_size);
+ switch (type) {
+ case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
+ struct GNUNET_CREDENTIAL_DelegationRecord *sets;
+ char attr_str[253 + 1];
+ char subject_pkey[52 + 1];
+ char *token;
+ char *tmp_str;
+ int matches = 0;
+ int entries;
+ size_t tmp_data_size;
+ int i;
+ tmp_str = GNUNET_strdup (s);
+ token = strtok (tmp_str, ",");
+ entries = 0;
+ tmp_data_size = 0;
+ *data_size = sizeof (struct GNUNET_CREDENTIAL_DelegationRecord);
+ while (NULL != token) {
+ matches = SSCANF (token, "%s %s", subject_pkey, attr_str);
+ if (0 == matches) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("Unable to parse ATTR record string `%s'\n"), s);
GNUNET_free (tmp_str);
- return GNUNET_OK;
+ return GNUNET_SYSERR;
}
- case GNUNET_GNSRECORD_TYPE_CREDENTIAL:
- {
- struct GNUNET_CREDENTIAL_Credential *cred;
- cred = GNUNET_CREDENTIAL_credential_from_string (s);
-
- *data_size = GNUNET_CREDENTIAL_credential_serialize (cred,
- (char**)data);
- return GNUNET_OK;
+ if (1 == matches) {
+ tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet);
+ } else if (2 == matches) {
+ tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet) +
+ strlen (attr_str) + 1;
}
- case GNUNET_GNSRECORD_TYPE_POLICY:
- {
- *data_size = strlen (s);
- *data = GNUNET_strdup (s);
- return GNUNET_OK;
+ entries++;
+ token = strtok (NULL, ",");
+ }
+ GNUNET_free (tmp_str);
+ tmp_str = GNUNET_strdup (s);
+ token = strtok (tmp_str, ",");
+ if (NULL == token) {
+ GNUNET_free (tmp_str);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed string %s\n", s);
+ return GNUNET_SYSERR;
+ }
+ struct GNUNET_CREDENTIAL_DelegationSet set[entries];
+ memset (set, 0, sizeof (struct GNUNET_CREDENTIAL_DelegationSet) * entries);
+ for (i = 0; i < entries; i++) {
+ matches = SSCANF (token, "%s %s", subject_pkey, attr_str);
+ GNUNET_CRYPTO_ecdsa_public_key_from_string (
+ subject_pkey, strlen (subject_pkey), &set[i].subject_key);
+ if (2 == matches) {
+ set[i].subject_attribute_len = strlen (attr_str) + 1;
+ set[i].subject_attribute = GNUNET_strdup (attr_str);
}
- default:
+ token = strtok (NULL, ",");
+ }
+ tmp_data_size = GNUNET_CREDENTIAL_delegation_set_get_size (entries, set);
+
+ if (-1 == tmp_data_size) {
+ GNUNET_free (tmp_str);
return GNUNET_SYSERR;
+ }
+ *data_size += tmp_data_size;
+ *data = sets = GNUNET_malloc (*data_size);
+ GNUNET_CREDENTIAL_delegation_set_serialize (entries, set, tmp_data_size,
+ (char *)&sets[1]);
+ for (i = 0; i < entries; i++) {
+ if (0 != set[i].subject_attribute_len)
+ GNUNET_free ((char *)set[i].subject_attribute);
+ }
+ sets->set_count = htonl (entries);
+ sets->data_size = GNUNET_htonll (tmp_data_size);
+
+ GNUNET_free (tmp_str);
+ return GNUNET_OK;
+ }
+ case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
+ struct GNUNET_CREDENTIAL_Credential *cred;
+ cred = GNUNET_CREDENTIAL_credential_from_string (s);
+
+ *data_size = GNUNET_CREDENTIAL_credential_serialize (cred, (char **)data);
+ return GNUNET_OK;
+ }
+ case GNUNET_GNSRECORD_TYPE_POLICY: {
+ *data_size = strlen (s);
+ *data = GNUNET_strdup (s);
+ return GNUNET_OK;
+ }
+ default:
+ return GNUNET_SYSERR;
}
}
* Mapping of record type numbers to human-readable
* record type names.
*/
-static struct {
+static struct
+{
const char *name;
uint32_t number;
-} name_map[] = {
- { "CRED", GNUNET_GNSRECORD_TYPE_CREDENTIAL },
- { "ATTR", GNUNET_GNSRECORD_TYPE_ATTRIBUTE },
- { "POLICY", GNUNET_GNSRECORD_TYPE_POLICY },
- { NULL, UINT32_MAX }
-};
+} name_map[] = {{"CRED", GNUNET_GNSRECORD_TYPE_CREDENTIAL},
+ {"ATTR", GNUNET_GNSRECORD_TYPE_ATTRIBUTE},
+ {"POLICY", GNUNET_GNSRECORD_TYPE_POLICY},
+ {NULL, UINT32_MAX}};
/**
* @return corresponding number, UINT32_MAX on error
*/
static uint32_t
-credential_typename_to_number (void *cls,
- const char *gns_typename)
+credential_typename_to_number (void *cls, const char *gns_typename)
{
unsigned int i;
- i=0;
- while ( (name_map[i].name != NULL) &&
- (0 != strcasecmp (gns_typename, name_map[i].name)) )
+ i = 0;
+ while ((name_map[i].name != NULL) &&
+ (0 != strcasecmp (gns_typename, name_map[i].name)))
i++;
return name_map[i].number;
}
* @return corresponding typestring, NULL on error
*/
static const char *
-credential_number_to_typename (void *cls,
- uint32_t type)
+credential_number_to_typename (void *cls, uint32_t type)
{
unsigned int i;
- i=0;
- while ( (name_map[i].name != NULL) &&
- (type != name_map[i].number) )
+ i = 0;
+ while ((name_map[i].name != NULL) && (type != name_map[i].number))
i++;
return name_map[i].name;
}
projects / oweals / gnunet.git / commitdiff