* @brief API for the scalarproduct
* @author Christian Fuchs
* @author Gaurav Kukreja
- *
+ *
*/
#include "platform.h"
#include "gnunet_util_lib.h"
*** Datatype Declarations **********
**************************************************************/
+/**
+ * the abstraction function for our internal callback
+ */
+typedef void (*GNUNET_SCALARPRODUCT_ResponseMessageHandler) (void *cls,
+ const struct GNUNET_MessageHeader *msg,
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status);
+
/**
* Entry in the request queue per client
*/
/**
* The shared session key identifying this computation
*/
- struct GNUNET_HashCode * key;
+ struct GNUNET_HashCode key;
/**
* Current transmit handle.
union
{
- /**
- * Function to call after transmission of the request.
- */
- GNUNET_SCALARPRODUCT_ContinuationWithStatus cont_status;
-
- /**
- * Function to call after transmission of the request.
- */
- GNUNET_SCALARPRODUCT_DatumProcessor cont_datum;
+ /**
+ * Function to call after transmission of the request.
+ */
+ GNUNET_SCALARPRODUCT_ContinuationWithStatus cont_status;
+
+ /**
+ * Function to call after transmission of the request.
+ */
+ GNUNET_SCALARPRODUCT_DatumProcessor cont_datum;
};
/**
/**
- * Handles the RESULT received in reply of prepare_response from the
+ * Handles the RESULT received in reply of prepare_response from the
* service
- *
+ *
* @param cls Handle to the Master Context
* @param msg Pointer to the response received
*/
/**
- * Handles the RESULT received in reply of prepare_response from the
+ * Handles the RESULT received in reply of prepare_response from the
* service
- *
+ *
* @param cls Handle to the Master Context
* @param msg Pointer to the response received
*/
const struct GNUNET_SCALARPRODUCT_client_response *message =
(const struct GNUNET_SCALARPRODUCT_client_response *) msg;
gcry_mpi_t result = NULL;
+ gcry_error_t rc;
- if (GNUNET_SCALARPRODUCT_Status_Success == status
- && qe->cont_datum != NULL)
+ if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
size_t product_len = ntohl (message->product_length);
result = gcry_mpi_new (0);
gcry_mpi_t num;
size_t read = 0;
- if (0 != gcry_mpi_scan (&num, GCRYMPI_FMT_USG, &msg[1], product_len, &read))
+ if (0 != (rc = gcry_mpi_scan (&num, GCRYMPI_FMT_STD, &message[1], product_len, &read)))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, "Could not convert to mpi to value!\n");
+ LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
gcry_mpi_release (result);
result = NULL;
status = GNUNET_SCALARPRODUCT_Status_InvalidResponse;
}
else
{
- if (message->range > 0)
+ if (0 < message->range)
gcry_mpi_add (result, result, num);
- else
+ else if (0 > message->range)
gcry_mpi_sub (result, result, num);
gcry_mpi_release (num);
}
* Called when a response is received from the service. After basic check
* handler in qe->response_proc is called. This functions handles the response
* to the client which used the API.
- *
+ *
* @param cls Pointer to the Master Context
* @param msg Pointer to the data received in response
*/
if (qe->cont_datum != NULL)
qe->response_proc (qe, msg, status);
+ GNUNET_CONTAINER_DLL_remove (head, tail, qe);
GNUNET_free (qe);
}
/**
* Transmits the request to the VectorProduct Sevice
- *
+ *
* @param cls Closure
* @param size Size of the buffer
* @param buf Pointer to the buffer
- *
+ *
* @return Size of the message sent
*/
static size_t
// notify caller about the error, done here.
if (qe->cont_datum != NULL)
qe->response_proc (qe, NULL, GNUNET_SCALARPRODUCT_Status_Failure);
+
GNUNET_SCALARPRODUCT_cancel (cls);
return 0;
}
/**
- * Used by Bob's client to cooperate with Alice,
- *
+ * Used by Bob's client to cooperate with Alice,
+ *
* @param h handle to the master context
* @param key Session key - unique to the requesting client
* @param elements Array of elements of the vector
uint16_t size;
uint64_t i;
- GNUNET_assert (key);
- GNUNET_assert (elements);
- GNUNET_assert (cont);
- GNUNET_assert (element_count > 1);
GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_client_request)
- +element_count * sizeof (int32_t));
+ + element_count * sizeof (int32_t));
h = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle);
h->client = GNUNET_CLIENT_connect ("scalarproduct", cfg);
if (!h->client)
return NULL;
}
h->stats = GNUNET_STATISTICS_create ("scalarproduct-api", cfg);
- if (!h->th)
+ if (!h->stats)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_ ("Failed to send a message to the statistics service\n"));
return NULL;
}
- size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) +element_count * sizeof (int32_t);
+ size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) + element_count * sizeof (int32_t);
h->cont_status = cont;
h->cont_cls = cont_cls;
- h->response_proc = &process_result_message;
+ h->response_proc = &process_status_message;
h->cfg = cfg;
- h->msg = GNUNET_malloc (size);
memcpy (&h->key, key, sizeof (struct GNUNET_HashCode));
- msg = (struct GNUNET_SCALARPRODUCT_client_request*) h->msg;
+ msg = (struct GNUNET_SCALARPRODUCT_client_request*) GNUNET_malloc (size);
+ h->msg = msg;
msg->header.size = htons (size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB);
msg->element_count = htonl (element_count);
vector = (int32_t*) & msg[1];
/**
* Request by Alice's client for computing a scalar product
- *
+ *
* @param h handle to the master context
* @param key Session key - unique to the requesting client
* @param peer PeerID of the other peer
return NULL;
}
h->stats = GNUNET_STATISTICS_create ("scalarproduct-api", cfg);
- if (!h->th)
+ if (!h->stats)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_ ("Failed to send a message to the statistics service\n"));
return NULL;
}
- size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) +element_count * sizeof (int32_t) + mask_bytes;
+ size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) + element_count * sizeof (int32_t) + mask_bytes;
h->cont_datum = cont;
h->cont_cls = cont_cls;
- h->response_proc = &process_status_message;
+ h->response_proc = &process_result_message;
h->cfg = cfg;
- h->msg = GNUNET_malloc (size);
memcpy (&h->key, key, sizeof (struct GNUNET_HashCode));
- msg = (struct GNUNET_SCALARPRODUCT_client_request*) h->msg;
+ msg = (struct GNUNET_SCALARPRODUCT_client_request*) GNUNET_malloc (size);
+ h->msg = msg;
msg->header.size = htons (size);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE);
- msg->element_count = htons (element_count);
- msg->mask_length = htons (mask_bytes);
+ msg->element_count = htonl (element_count);
+ msg->mask_length = htonl (mask_bytes);
vector = (int32_t*) & msg[1];
// copy each element over to the message
/**
* Disconnect from the scalarproduct service.
- *
+ *
* @param h a computation handle to cancel
*/
void
if (qe == h)
{
GNUNET_CONTAINER_DLL_remove (head, tail, qe);
- LOG (GNUNET_ERROR_TYPE_INFO,
- "Disconnecting from VectorProduct\n");
- if (NULL == qe->th)
+ if (NULL != qe->th)
GNUNET_CLIENT_notify_transmit_ready_cancel (qe->th);
- GNUNET_CLIENT_disconnect (h->client);
- GNUNET_STATISTICS_destroy (h->stats, GNUNET_YES);
- GNUNET_free (qe->msg);
+ GNUNET_CLIENT_disconnect (qe->client);
+ GNUNET_STATISTICS_destroy (qe->stats, GNUNET_YES);
+ GNUNET_free_non_null (qe->msg);
GNUNET_free (qe);
break;
}
}
}
+/**
+ * Cancel ALL our ongoing scalar product computations and collaboration offers.
+ * Closes ALL connections to the service
+ */
+void
+GNUNET_SCALARPRODUCT_disconnect ()
+{
+ struct GNUNET_SCALARPRODUCT_ComputationHandle * qe;
+
+ LOG (GNUNET_ERROR_TYPE_INFO, "Disconnecting from VectorProduct\n");
+ for (qe = head; head != NULL; qe = head)
+ {
+ GNUNET_CONTAINER_DLL_remove (head, tail, qe);
+ if (NULL != qe->th)
+ GNUNET_CLIENT_notify_transmit_ready_cancel (qe->th);
+ GNUNET_CLIENT_disconnect (qe->client);
+ GNUNET_STATISTICS_destroy (qe->stats, GNUNET_YES);
+ GNUNET_free_non_null (qe->msg);
+ GNUNET_free (qe);
+ }
+}
/* end of ext_api.c */
projects / oweals / gnunet.git / blobdiff