/**
* processor to call on verify result
*/
- GNUNET_CREDENTIAL_VerifyResultProcessor verify_proc;
+ GNUNET_CREDENTIAL_CredentialResultProcessor verify_proc;
/**
* @e verify_proc closure
/**
* Head of linked list of active verify requests.
*/
- struct GNUNET_CREDENTIAL_Request *verify_head;
+ struct GNUNET_CREDENTIAL_Request *request_head;
/**
* Tail of linked list of active verify requests.
*/
- struct GNUNET_CREDENTIAL_Request *verify_tail;
+ struct GNUNET_CREDENTIAL_Request *request_tail;
/**
* Reconnect task
force_reconnect (handle);
}
-
/**
* Check validity of message received from the CREDENTIAL service
*
*/
static int
check_result (void *cls,
- const struct VerifyResultMessage *vr_msg)
+ const struct DelegationChainResultMessage *vr_msg)
{
//TODO
return GNUNET_OK;
*/
static void
handle_result (void *cls,
- const struct VerifyResultMessage *vr_msg)
+ const struct DelegationChainResultMessage *vr_msg)
{
struct GNUNET_CREDENTIAL_Handle *handle = cls;
uint32_t r_id = ntohl (vr_msg->id);
uint32_t c_count = ntohl (vr_msg->c_count);
struct GNUNET_CREDENTIAL_Delegation d_chain[d_count];
struct GNUNET_CREDENTIAL_Credential creds[c_count];
- GNUNET_CREDENTIAL_VerifyResultProcessor proc;
+ GNUNET_CREDENTIAL_CredentialResultProcessor proc;
void *proc_cls;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received verify reply from CREDENTIAL service\n");
- for (vr = handle->verify_head; NULL != vr; vr = vr->next)
+ for (vr = handle->request_head; NULL != vr; vr = vr->next)
if (vr->r_id == r_id)
break;
if (NULL == vr)
return;
proc = vr->verify_proc;
proc_cls = vr->proc_cls;
- GNUNET_CONTAINER_DLL_remove (handle->verify_head,
- handle->verify_tail,
+ GNUNET_CONTAINER_DLL_remove (handle->request_head,
+ handle->request_tail,
vr);
GNUNET_MQ_discard (vr->env);
GNUNET_free (vr);
GNUNET_assert (GNUNET_OK ==
GNUNET_CREDENTIAL_delegation_chain_deserialize (mlen,
- (const char*) &vr_msg[1],
- d_count,
- d_chain,
- c_count,
- creds));
+ (const char*) &vr_msg[1],
+ d_count,
+ d_chain,
+ c_count,
+ creds));
if (GNUNET_NO == ntohl (vr_msg->cred_found))
{
proc (proc_cls,
struct GNUNET_MQ_MessageHandler handlers[] = {
GNUNET_MQ_hd_var_size (result,
GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY_RESULT,
- struct VerifyResultMessage,
+ struct DelegationChainResultMessage,
+ handle),
+ GNUNET_MQ_hd_var_size (result,
+ GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT_RESULT,
+ struct DelegationChainResultMessage,
handle),
GNUNET_MQ_handler_end ()
};
GNUNET_assert (NULL == handle->mq);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Trying to connect to CREDENTIAL\n");
- handle->mq = GNUNET_CLIENT_connecT (handle->cfg,
+ handle->mq = GNUNET_CLIENT_connect (handle->cfg,
"credential",
handlers,
&mq_error_handler,
handle);
if (NULL == handle->mq)
return;
- for (vr = handle->verify_head; NULL != vr; vr = vr->next)
+ for (vr = handle->request_head; NULL != vr; vr = vr->next)
GNUNET_MQ_send_copy (handle->mq,
vr->env);
}
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
handle->reconnect_task = NULL;
}
- GNUNET_assert (NULL == handle->verify_head);
+ GNUNET_assert (NULL == handle->request_head);
GNUNET_free (handle);
}
* @param lr the verify request to cancel
*/
void
-GNUNET_CREDENTIAL_verify_cancel (struct GNUNET_CREDENTIAL_Request *vr)
+GNUNET_CREDENTIAL_request_cancel (struct GNUNET_CREDENTIAL_Request *vr)
{
struct GNUNET_CREDENTIAL_Handle *handle = vr->credential_handle;
- GNUNET_CONTAINER_DLL_remove (handle->verify_head,
- handle->verify_tail,
+ GNUNET_CONTAINER_DLL_remove (handle->request_head,
+ handle->request_tail,
vr);
GNUNET_MQ_discard (vr->env);
GNUNET_free (vr);
}
+
+/**
+ * Performs attribute collection.
+ * Collects all credentials of subject to fulfill the
+ * attribute, if possible
+ *
+ * @param handle handle to the Credential service
+ * @param issuer_key the issuer public key
+ * @param issuer_attribute the issuer attribute
+ * @param subject_key the subject public key
+ * @param credential_count number of credentials provided
+ * @param credentials subject credentials
+ * @param proc function to call on result
+ * @param proc_cls closure for processor
+ * @return handle to the queued request
+ */
+struct GNUNET_CREDENTIAL_Request*
+GNUNET_CREDENTIAL_collect (struct GNUNET_CREDENTIAL_Handle *handle,
+ const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key,
+ const char *issuer_attribute,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key,
+ GNUNET_CREDENTIAL_CredentialResultProcessor proc,
+ void *proc_cls)
+{
+ /* IPC to shorten credential names, return shorten_handle */
+ struct CollectMessage *c_msg;
+ struct GNUNET_CREDENTIAL_Request *vr;
+ size_t nlen;
+
+ if (NULL == issuer_attribute)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
+ //DEBUG LOG
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Trying to collect `%s' in CREDENTIAL\n",
+ issuer_attribute);
+ nlen = strlen (issuer_attribute) + 1;
+ if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+ vr = GNUNET_new (struct GNUNET_CREDENTIAL_Request);
+ vr->credential_handle = handle;
+ vr->verify_proc = proc;
+ vr->proc_cls = proc_cls;
+ vr->r_id = handle->r_id_gen++;
+ vr->env = GNUNET_MQ_msg_extra (c_msg,
+ nlen,
+ GNUNET_MESSAGE_TYPE_CREDENTIAL_COLLECT);
+ c_msg->id = htonl (vr->r_id);
+ c_msg->subject_key = *subject_key;
+ c_msg->issuer_key = *issuer_key;
+ c_msg->issuer_attribute_len = htons(strlen(issuer_attribute));
+ GNUNET_memcpy (&c_msg[1],
+ issuer_attribute,
+ strlen (issuer_attribute));
+ GNUNET_CONTAINER_DLL_insert (handle->request_head,
+ handle->request_tail,
+ vr);
+ if (NULL != handle->mq)
+ GNUNET_MQ_send_copy (handle->mq,
+ vr->env);
+ return vr;
+}
/**
* Performs attribute verification.
* Checks if there is a delegation chain from
* @param issuer_key the issuer public key
* @param issuer_attribute the issuer attribute
* @param subject_key the subject public key
- * @param subject_attribute the attribute claimed by the subject
+ * @param credential_count number of credentials provided
+ * @param credentials subject credentials
* @param proc function to call on result
* @param proc_cls closure for processor
* @return handle to the queued request
const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key,
const char *issuer_attribute,
const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key,
- const char *subject_attribute,
- GNUNET_CREDENTIAL_VerifyResultProcessor proc,
+ uint32_t credential_count,
+ const struct GNUNET_CREDENTIAL_Credential *credentials,
+ GNUNET_CREDENTIAL_CredentialResultProcessor proc,
void *proc_cls)
{
/* IPC to shorten credential names, return shorten_handle */
struct VerifyMessage *v_msg;
struct GNUNET_CREDENTIAL_Request *vr;
size_t nlen;
+ size_t clen;
- if (NULL == issuer_attribute || NULL == subject_attribute)
+ if (NULL == issuer_attribute || NULL == credentials)
{
GNUNET_break (0);
return NULL;
}
+
+ clen = GNUNET_CREDENTIAL_credentials_get_size (credential_count,
+ credentials);
+
//DEBUG LOG
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Trying to verify `%s' in CREDENTIAL\n",
issuer_attribute);
- nlen = strlen (issuer_attribute) + strlen (subject_attribute) + 1;
- if (nlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (*vr))
+ nlen = strlen (issuer_attribute) + 1 + clen;
+ if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*vr))
{
GNUNET_break (0);
return NULL;
GNUNET_MESSAGE_TYPE_CREDENTIAL_VERIFY);
v_msg->id = htonl (vr->r_id);
v_msg->subject_key = *subject_key;
+ v_msg->c_count = htonl(credential_count);
v_msg->issuer_key = *issuer_key;
v_msg->issuer_attribute_len = htons(strlen(issuer_attribute));
- v_msg->subject_attribute_len = htons(strlen(subject_attribute));
GNUNET_memcpy (&v_msg[1],
issuer_attribute,
strlen (issuer_attribute));
- GNUNET_memcpy (((char*)&v_msg[1]) + strlen (issuer_attribute),
- subject_attribute,
- strlen (subject_attribute));
- GNUNET_CONTAINER_DLL_insert (handle->verify_head,
- handle->verify_tail,
+ GNUNET_CREDENTIAL_credentials_serialize (credential_count,
+ credentials,
+ clen,
+ ((char*)&v_msg[1])
+ + strlen (issuer_attribute) + 1);
+ GNUNET_CONTAINER_DLL_insert (handle->request_head,
+ handle->request_tail,
vr);
if (NULL != handle->mq)
GNUNET_MQ_send_copy (handle->mq,
projects / oweals / gnunet.git / blobdiff