commit 5a0e57891c7f33f03bb25a3ab6b83d0f0b26a05e
parent 33b89b07e0ea833955f64d07b7e54e64aab500e9
Author: Christian Grothoff <christian@grothoff.org>
Date: Fri, 23 Aug 2013 13:43:02 +0000
-more vector -> scalar renaming
Diffstat:
12 files changed, 442 insertions(+), 442 deletions(-)
diff --git a/src/include/gnunet_applications.h b/src/include/gnunet_applications.h
@@ -82,9 +82,9 @@ extern "C"
#define GNUNET_APPLICATION_TYPE_SET 19
/**
- * Vectorproduct. Used for two-peer vectorproduct operations
+ * Vectorproduct. Used for two-peer scalarproduct operations
*/
-#define GNUNET_APPLICATION_TYPE_VECTORPRODUCT 20
+#define GNUNET_APPLICATION_TYPE_SCALARPRODUCT 20
#if 0 /* keep Emacsens' auto-indent happy */
{
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
@@ -1906,33 +1906,33 @@ extern "C"
/*******************************************************************************
- * VECTORPRODUCT message types
+ * SCALARPRODUCT message types
******************************************************************************/
/**
* Client -> Vector-Product Service request message
*/
-#define GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_ALICE 640
+#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE 640
/**
* Client -> Vector-Product Service request message
*/
-#define GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_BOB 641
+#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB 641
/**
* Vector-Product Service request -> remote VP Service
*/
-#define GNUNET_MESSAGE_TYPE_VECTORPRODUCT_ALICE_TO_BOB 642
+#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB 642
/**
* remote Vector-Product Service response -> requesting VP Service
*/
-#define GNUNET_MESSAGE_TYPE_VECTORPRODUCT_BOB_TO_ALICE 643
+#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE 643
/**
* Vector-Product Service response -> Client
*/
-#define GNUNET_MESSAGE_TYPE_VECTORPRODUCT_SERVICE_TO_CLIENT 644
+#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT 644
diff --git a/src/include/gnunet_scalarproduct_service.h b/src/include/gnunet_scalarproduct_service.h
@@ -19,13 +19,13 @@
*/
/**
- * @file include/gnunet_vectorproduct_service.h
- * @brief API to the vectorproduct service
+ * @file include/gnunet_scalarproduct_service.h
+ * @brief API to the scalarproduct service
* @author Christian M. Fuchs
* @author Gaurav Kukreja
*/
-#ifndef GNUNET_VECTORPRODUCT_SERVICE_H
-#define GNUNET_VECTORPRODUCT_SERVICE_H
+#ifndef GNUNET_SCALARPRODUCT_SERVICE_H
+#define GNUNET_SCALARPRODUCT_SERVICE_H
#define GCRYPT_NO_DEPRECATED
// including gcrypt crashes netbeans after the next restart...
#include <gcrypt.h>
@@ -38,15 +38,15 @@ extern "C" {
#endif
/**
- * Version of the vectorproduct API.
+ * Version of the scalarproduct API.
*/
-#define GNUNET_VECTORPRODUCT_VERSION 0x00000042
+#define GNUNET_SCALARPRODUCT_VERSION 0x00000042
/**
* Message type passed from client to service
* to initiate a request or responder role
*/
-struct GNUNET_VECTORPRODUCT_client_request {
+struct GNUNET_SCALARPRODUCT_client_request {
/**
* GNUNET message header
*/
@@ -81,7 +81,7 @@ struct GNUNET_VECTORPRODUCT_client_request {
* Message type passed from service client
* to finalize a session as requester or responder
*/
-struct GNUNET_VECTORPRODUCT_client_response {
+struct GNUNET_SCALARPRODUCT_client_response {
/**
* GNUNET message header
*/
@@ -107,22 +107,22 @@ struct GNUNET_VECTORPRODUCT_client_response {
*/
};
-enum GNUNET_VECTORPRODUCT_ResponseStatus {
- GNUNET_VECTORPRODUCT_Status_Success = 0,
- GNUNET_VECTORPRODUCT_Status_Failure,
- GNUNET_VECTORPRODUCT_Status_Timeout,
- GNUNET_VECTORPRODUCT_Status_InvalidResponse,
- GNUNET_VECTORPRODUCT_Status_ServiceDisconnected
+enum GNUNET_SCALARPRODUCT_ResponseStatus {
+ GNUNET_SCALARPRODUCT_Status_Success = 0,
+ GNUNET_SCALARPRODUCT_Status_Failure,
+ GNUNET_SCALARPRODUCT_Status_Timeout,
+ GNUNET_SCALARPRODUCT_Status_InvalidResponse,
+ GNUNET_SCALARPRODUCT_Status_ServiceDisconnected
};
-struct GNUNET_VECTORPRODUCT_Handle {
+struct GNUNET_SCALARPRODUCT_Handle {
/**
* Our configuration.
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
- * Current connection to the vectorproduct service.
+ * Current connection to the scalarproduct service.
*/
struct GNUNET_CLIENT_Connection *client;
@@ -134,12 +134,12 @@ struct GNUNET_VECTORPRODUCT_Handle {
/**
* Current head of priority queue.
*/
- struct GNUNET_VECTORPRODUCT_QueueEntry *queue_head;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *queue_head;
/**
* Current tail of priority queue.
*/
- struct GNUNET_VECTORPRODUCT_QueueEntry *queue_tail;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *queue_tail;
/**
* Are we currently trying to receive from the service?
@@ -156,9 +156,9 @@ struct GNUNET_VECTORPRODUCT_Handle {
*/
};
-typedef void (*GNUNET_VECTORPRODUCT_ResponseMessageHandler) (void *cls,
+typedef void (*GNUNET_SCALARPRODUCT_ResponseMessageHandler) (void *cls,
const struct GNUNET_MessageHeader *msg,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status);
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status);
/**
* Continuation called to notify client about result of the
@@ -170,11 +170,11 @@ typedef void (*GNUNET_VECTORPRODUCT_ResponseMessageHandler) (void *cls,
* GNUNET_YES (or other positive value) on success
* @param msg NULL on success, otherwise an error message
*/
-typedef void (*GNUNET_VECTORPRODUCT_ContinuationWithStatus) (void *cls,
+typedef void (*GNUNET_SCALARPRODUCT_ContinuationWithStatus) (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status);
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status);
/**
- * Process a datum that was stored in the vectorproduct.
+ * Process a datum that was stored in the scalarproduct.
*
* @param cls closure
* @param key Sessioon key
@@ -184,11 +184,11 @@ typedef void (*GNUNET_VECTORPRODUCT_ContinuationWithStatus) (void *cls,
* @param data Pointer to the data
* @param type Type of data
*/
-typedef void (*GNUNET_VECTORPRODUCT_DatumProcessor) (void *cls,
+typedef void (*GNUNET_SCALARPRODUCT_DatumProcessor) (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- const struct GNUNET_VECTORPRODUCT_client_response *msg);
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ const struct GNUNET_SCALARPRODUCT_client_response *msg);
/**
* Request the Scalar Product Evaluation
@@ -204,15 +204,15 @@ typedef void (*GNUNET_VECTORPRODUCT_DatumProcessor) (void *cls,
* @param cont Callback function
* @param cont_cls Closure for the callback function
*/
-struct GNUNET_VECTORPRODUCT_QueueEntry *
-GNUNET_VECTORPRODUCT_request(struct GNUNET_VECTORPRODUCT_Handle *h,
+struct GNUNET_SCALARPRODUCT_QueueEntry *
+GNUNET_SCALARPRODUCT_request(struct GNUNET_SCALARPRODUCT_Handle *h,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity *peer,
uint16_t element_count,
uint16_t mask_bytes,
int32_t * elements, const unsigned char * mask,
struct GNUNET_TIME_Relative timeout,
- GNUNET_VECTORPRODUCT_DatumProcessor cont,
+ GNUNET_SCALARPRODUCT_DatumProcessor cont,
void *cont_cls);
/**
@@ -228,31 +228,31 @@ GNUNET_VECTORPRODUCT_request(struct GNUNET_VECTORPRODUCT_Handle *h,
* @param cont Callback function
* @param cont_cls Closure for the callback function
*/
-struct GNUNET_VECTORPRODUCT_QueueEntry *
-GNUNET_VECTORPRODUCT_prepare_response(struct GNUNET_VECTORPRODUCT_Handle *h,
+struct GNUNET_SCALARPRODUCT_QueueEntry *
+GNUNET_SCALARPRODUCT_prepare_response(struct GNUNET_SCALARPRODUCT_Handle *h,
const struct GNUNET_HashCode * key,
uint16_t element_count,
int32_t* elements,
struct GNUNET_TIME_Relative timeout,
- GNUNET_VECTORPRODUCT_ContinuationWithStatus cont,
+ GNUNET_SCALARPRODUCT_ContinuationWithStatus cont,
void *cont_cls);
/**
- * Connect to the vectorproduct service.
+ * Connect to the scalarproduct service.
*
* @param cfg configuration to use
* @return handle to use to access the service
*/
-struct GNUNET_VECTORPRODUCT_Handle *
-GNUNET_VECTORPRODUCT_connect(const struct GNUNET_CONFIGURATION_Handle * cfg);
+struct GNUNET_SCALARPRODUCT_Handle *
+GNUNET_SCALARPRODUCT_connect(const struct GNUNET_CONFIGURATION_Handle * cfg);
/**
- * Disconnect from the vectorproduct service.
+ * Disconnect from the scalarproduct service.
*
- * @param h handle to the vectorproduct
+ * @param h handle to the scalarproduct
*/
void
-GNUNET_VECTORPRODUCT_disconnect(struct GNUNET_VECTORPRODUCT_Handle * h);
+GNUNET_SCALARPRODUCT_disconnect(struct GNUNET_SCALARPRODUCT_Handle * h);
#if 0 /* keep Emacsens' auto-indent happy */
diff --git a/src/scalarproduct/gnunet-scalarproduct.c b/src/scalarproduct/gnunet-scalarproduct.c
@@ -19,8 +19,8 @@
*/
/**
- * @file vectorproduct/gnunet-vectorproduct.c
- * @brief vectorproduct client
+ * @file scalarproduct/gnunet-scalarproduct.c
+ * @brief scalarproduct client
* @author Christian M. Fuchs
*/
#define GCRYPT_NO_DEPRECATED
@@ -29,10 +29,10 @@
#include "platform.h"
#include "gnunet_util_lib.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "gnunet-vectorproduct",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "gnunet-scalarproduct",__VA_ARGS__)
/**
* Option -p: destination peer identity for checking message-ids with
*/
@@ -44,12 +44,12 @@ static char *input_peer_id = NULL;
static char *input_key = NULL;
/**
- * Option -e: vector to calculate a vectorproduct with
+ * Option -e: vector to calculate a scalarproduct with
*/
static char *input_elements = NULL;
/**
- * Option -m: message-ids to calculate a vectorproduct with
+ * Option -m: message-ids to calculate a scalarproduct with
*/
static char *input_mask = NULL;
@@ -89,21 +89,21 @@ struct GNUNET_PeerIdentity peer;
struct GNUNET_HashCode key;
/**
- * Pointer to the GNUNET_VECTORPRODUCT_Handle
+ * Pointer to the GNUNET_SCALARPRODUCT_Handle
*/
-struct GNUNET_VECTORPRODUCT_Handle *handle;
+struct GNUNET_SCALARPRODUCT_Handle *handle;
/**
* Global return value
*/
static int ret;
-struct GNUNET_VECTORPRODUCT_TestCls
+struct GNUNET_SCALARPRODUCT_TestCls
{
- struct GNUNET_VECTORPRODUCT_Handle * h;
+ struct GNUNET_SCALARPRODUCT_Handle * h;
};
-struct GNUNET_VECTORPRODUCT_TestCls test_cls;
+struct GNUNET_SCALARPRODUCT_TestCls test_cls;
/**
@@ -115,32 +115,32 @@ struct GNUNET_VECTORPRODUCT_TestCls test_cls;
static void
responder_callback (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
ret = -1;
switch (status)
{
- case GNUNET_VECTORPRODUCT_Status_Success:
+ case GNUNET_SCALARPRODUCT_Status_Success:
ret = 0;
LOG (GNUNET_ERROR_TYPE_INFO, "Session %s concluded.\n", GNUNET_h2s (key));
break;
- case GNUNET_VECTORPRODUCT_Status_InvalidResponse:
+ case GNUNET_SCALARPRODUCT_Status_InvalidResponse:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: invalid response\n", GNUNET_h2s (key));
break;
- case GNUNET_VECTORPRODUCT_Status_Timeout:
+ case GNUNET_SCALARPRODUCT_Status_Timeout:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: timeout\n", GNUNET_h2s (key));
break;
- case GNUNET_VECTORPRODUCT_Status_Failure:
+ case GNUNET_SCALARPRODUCT_Status_Failure:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: service failure\n", GNUNET_h2s (key));
- case GNUNET_VECTORPRODUCT_Status_ServiceDisconnected:
+ case GNUNET_SCALARPRODUCT_Status_ServiceDisconnected:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: service disconnect!!\n", GNUNET_h2s (key));
break;
default:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: return code %d\n", GNUNET_h2s (key), (int) status);
}
- GNUNET_VECTORPRODUCT_disconnect (handle);
+ GNUNET_SCALARPRODUCT_disconnect (handle);
GNUNET_SCHEDULER_shutdown ();
}
@@ -160,15 +160,15 @@ static void
requester_callback (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- const struct GNUNET_VECTORPRODUCT_client_response *msg)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ const struct GNUNET_SCALARPRODUCT_client_response *msg)
{
uint32_t product_len;
ret = -1;
switch (status)
{
- case GNUNET_VECTORPRODUCT_Status_Success:
+ case GNUNET_SCALARPRODUCT_Status_Success:
product_len = ntohl (msg->product_length);
LOG (GNUNET_ERROR_TYPE_INFO, "Session %s concluded.\n", GNUNET_h2s (key));
@@ -194,21 +194,21 @@ requester_callback (void *cls,
LOG (GNUNET_ERROR_TYPE_ERROR, "Service-side error in session %s, return code: %d\n", GNUNET_h2s (key), product_len);
}
break;
- case GNUNET_VECTORPRODUCT_Status_InvalidResponse:
+ case GNUNET_SCALARPRODUCT_Status_InvalidResponse:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: invalid response\n", GNUNET_h2s (key));
break;
- case GNUNET_VECTORPRODUCT_Status_Timeout:
+ case GNUNET_SCALARPRODUCT_Status_Timeout:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: timeout\n", GNUNET_h2s (key));
break;
- case GNUNET_VECTORPRODUCT_Status_Failure:
+ case GNUNET_SCALARPRODUCT_Status_Failure:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: service failure\n", GNUNET_h2s (key));
- case GNUNET_VECTORPRODUCT_Status_ServiceDisconnected:
+ case GNUNET_SCALARPRODUCT_Status_ServiceDisconnected:
LOG (GNUNET_ERROR_TYPE_ERROR, "Disconnected from service.\n", GNUNET_h2s (key));
break;
default:
LOG (GNUNET_ERROR_TYPE_ERROR, "Session %s failed: return code %d\n", GNUNET_h2s (key), (int) status);
}
- GNUNET_VECTORPRODUCT_disconnect (handle);
+ GNUNET_SCALARPRODUCT_disconnect (handle);
GNUNET_SCHEDULER_shutdown ();
}
@@ -342,7 +342,7 @@ run (void *cls,
mask[i] = UCHAR_MAX; // all 1's
}
- handle = GNUNET_VECTORPRODUCT_connect (cfg);
+ handle = GNUNET_SCALARPRODUCT_connect (cfg);
if (handle == NULL)
{
FPRINTF (stderr, _ ("Could not connect to the GNUNET Vector Product Service\n"));
@@ -351,7 +351,7 @@ run (void *cls,
test_cls.h = handle;
- if (input_peer_id && !GNUNET_VECTORPRODUCT_request (handle,
+ if (input_peer_id && !GNUNET_SCALARPRODUCT_request (handle,
&key,
&peer,
element_count,
@@ -361,7 +361,7 @@ run (void *cls,
&requester_callback,
(void *) &test_cls))
return;
- if ( !input_peer_id && !GNUNET_VECTORPRODUCT_prepare_response (handle,
+ if ( !input_peer_id && !GNUNET_SCALARPRODUCT_prepare_response (handle,
&key,
element_count,
elements,
@@ -375,7 +375,7 @@ run (void *cls,
/**
- * The main function to the vectorproduct client.
+ * The main function to the scalarproduct client.
*
* @param argc number of arguments from the command line
* @param argv command line arguments
@@ -392,7 +392,7 @@ main (int argc, char *const *argv)
gettext_noop ("A comma separated mask to select which elements should actually be compared."),
1, &GNUNET_GETOPT_set_string, &input_mask},
{'p', "peer", "PEERID",
- gettext_noop ("[Optional] peer to calculate our vectorproduct with. If this parameter is not given, the service will wait for a remote peer to compute the request."),
+ gettext_noop ("[Optional] peer to calculate our scalarproduct with. If this parameter is not given, the service will wait for a remote peer to compute the request."),
1, &GNUNET_GETOPT_set_string, &input_peer_id},
{'k', "key", "TRANSACTION_ID",
gettext_noop ("Transaction ID shared with peer."),
@@ -403,7 +403,7 @@ main (int argc, char *const *argv)
return (GNUNET_OK ==
GNUNET_PROGRAM_run (argc,
argv,
- "gnunet-vectorproduct",
+ "gnunet-scalarproduct",
gettext_noop ("Calculate the Vectorproduct with a GNUnet peer."),
options, &run, NULL)) ? ret : 1;
}
diff --git a/src/scalarproduct/gnunet-service-scalarproduct.c b/src/scalarproduct/gnunet-service-scalarproduct.c
@@ -19,8 +19,8 @@
*/
/**
- * @file vectorproduct/gnunet-service-vectorproduct.c
- * @brief vectorproduct service implementation
+ * @file scalarproduct/gnunet-service-scalarproduct.c
+ * @brief scalarproduct service implementation
* @author Christian M. Fuchs
*/
#include <limits.h>
@@ -30,8 +30,8 @@
#include "gnunet_mesh_service.h"
#include "gnunet_applications.h"
#include "gnunet_protocols.h"
-#include "gnunet_vectorproduct_service.h"
-#include "gnunet_vectorproduct.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_scalarproduct.h"
///////////////////////////////////////////////////////////////////////////////
// Global Variables
@@ -610,16 +610,16 @@ prepare_client_end_notification (void * cls,
const struct GNUNET_SCHEDULER_TaskContext * tc)
{
struct ServiceSession * session = cls;
- struct GNUNET_VECTORPRODUCT_client_response * msg;
+ struct GNUNET_SCALARPRODUCT_client_response * msg;
struct MessageObject * msg_obj;
GNUNET_assert (NULL != session);
- msg = GNUNET_new (struct GNUNET_VECTORPRODUCT_client_response);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_SERVICE_TO_CLIENT);
+ msg = GNUNET_new (struct GNUNET_SCALARPRODUCT_client_response);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT);
memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
memcpy (&msg->peer, &session->peer, sizeof ( struct GNUNET_PeerIdentity));
- msg->header.size = htons (sizeof (struct GNUNET_VECTORPRODUCT_client_response));
+ msg->header.size = htons (sizeof (struct GNUNET_SCALARPRODUCT_client_response));
// 0 size and the first char in the product is 0, which should never be zero if encoding is used.
msg->product_length = htonl (0);
@@ -630,7 +630,7 @@ prepare_client_end_notification (void * cls,
//transmit this message to our client
session->client_transmit_handle =
GNUNET_SERVER_notify_transmit_ready (session->client,
- sizeof (struct GNUNET_VECTORPRODUCT_client_response),
+ sizeof (struct GNUNET_SCALARPRODUCT_client_response),
GNUNET_TIME_UNIT_FOREVER_REL,
&do_send_message,
msg_obj);
@@ -679,7 +679,7 @@ prepare_service_response (gcry_mpi_t * kp,
struct ServiceSession * request,
struct ServiceSession * response)
{
- struct GNUNET_VECTORPRODUCT_service_response * msg;
+ struct GNUNET_SCALARPRODUCT_service_response * msg;
uint16_t msg_length = 0;
unsigned char * current = NULL;
unsigned char * element_exported = NULL;
@@ -688,14 +688,14 @@ prepare_service_response (gcry_mpi_t * kp,
GNUNET_assert (request);
- msg_length = sizeof (struct GNUNET_VECTORPRODUCT_service_response)
+ msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
+ 2 * request->used_element_count * PAILLIER_ELEMENT_LENGTH // kp, kq
+ 2 * PAILLIER_ELEMENT_LENGTH; // s, stick
msg = GNUNET_malloc (msg_length);
GNUNET_assert (msg);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_BOB_TO_ALICE);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE);
msg->header.size = htons (msg_length);
msg->element_count = htons (request->element_count);
msg->used_element_count = htons (request->used_element_count);
@@ -1033,7 +1033,7 @@ prepare_service_request (void *cls,
{
struct ServiceSession * session = cls;
unsigned char * current;
- struct GNUNET_VECTORPRODUCT_service_request * msg;
+ struct GNUNET_SCALARPRODUCT_service_request * msg;
struct MessageObject * msg_obj;
unsigned int i;
unsigned int j;
@@ -1047,12 +1047,12 @@ prepare_service_request (void *cls,
GNUNET_assert (NULL != peer);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Successfully created new tunnel to peer (%s)!\n"), GNUNET_i2s (peer));
- msg_length = sizeof (struct GNUNET_VECTORPRODUCT_service_request)
+ msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request)
+ session->used_element_count * PAILLIER_ELEMENT_LENGTH
+ session->mask_length
+ my_pubkey_external_length;
- if (GNUNET_SERVER_MAX_MESSAGE_SIZE < sizeof (struct GNUNET_VECTORPRODUCT_service_request)
+ if (GNUNET_SERVER_MAX_MESSAGE_SIZE < sizeof (struct GNUNET_SCALARPRODUCT_service_request)
+ session->used_element_count * PAILLIER_ELEMENT_LENGTH
+ session->mask_length
+ my_pubkey_external_length)
@@ -1067,7 +1067,7 @@ prepare_service_request (void *cls,
}
msg = GNUNET_malloc (msg_length);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_ALICE_TO_BOB);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB);
memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
msg->mask_length = htons (session->mask_length);
msg->pk_length = htons (my_pubkey_external_length);
@@ -1207,7 +1207,7 @@ handle_client_request (void *cls,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
- struct GNUNET_VECTORPRODUCT_client_request * msg = (struct GNUNET_VECTORPRODUCT_client_request *) message;
+ struct GNUNET_SCALARPRODUCT_client_request * msg = (struct GNUNET_SCALARPRODUCT_client_request *) message;
struct ServiceSession * session;
uint16_t element_count;
uint16_t mask_length;
@@ -1218,7 +1218,7 @@ handle_client_request (void *cls,
GNUNET_assert (message);
//we need at least a peer and one message id to compare
- if (sizeof (struct GNUNET_VECTORPRODUCT_client_request) > ntohs (msg->header.size))
+ if (sizeof (struct GNUNET_SCALARPRODUCT_client_request) > ntohs (msg->header.size))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Too short message received from client!\n"));
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -1230,7 +1230,7 @@ handle_client_request (void *cls,
mask_length = ntohs (msg->mask_length);
//sanity check: is the message as long as the message_count fields suggests?
- if (( ntohs (msg->header.size) != (sizeof (struct GNUNET_VECTORPRODUCT_client_request) + element_count * sizeof (int32_t) + mask_length))
+ if (( ntohs (msg->header.size) != (sizeof (struct GNUNET_SCALARPRODUCT_client_request) + element_count * sizeof (int32_t) + mask_length))
|| (0 == element_count))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Invalid message received from client, session information incorrect!\n"));
@@ -1259,7 +1259,7 @@ handle_client_request (void *cls,
session->vector = GNUNET_malloc (sizeof (int32_t) * element_count);
vector = (int32_t *) & msg[1];
- if (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_ALICE == msg_type)
+ if (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE == msg_type)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Got client-request-session with key %s, preparing tunnel to remote service.\n"), GNUNET_h2s (&session->key));
@@ -1537,7 +1537,7 @@ prepare_client_response (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ServiceSession * session = cls;
- struct GNUNET_VECTORPRODUCT_client_response * msg;
+ struct GNUNET_SCALARPRODUCT_client_response * msg;
unsigned char * product_exported = NULL;
size_t product_length = 0;
uint16_t msg_length = 0;
@@ -1556,11 +1556,11 @@ prepare_client_response (void *cls,
session->product = NULL;
}
- msg_length = sizeof (struct GNUNET_VECTORPRODUCT_client_response) +product_length;
+ msg_length = sizeof (struct GNUNET_SCALARPRODUCT_client_response) +product_length;
msg = GNUNET_malloc (msg_length);
memcpy (&msg[1], product_exported, product_length);
GNUNET_free_non_null (product_exported);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_SERVICE_TO_CLIENT);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT);
msg->header.size = htons (msg_length);
memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode));
memcpy (&msg->peer, &session->peer, sizeof ( struct GNUNET_PeerIdentity));
@@ -1593,7 +1593,7 @@ prepare_client_response (void *cls,
/**
- * Handle a request from another service to calculate a vectorproduct with us.
+ * Handle a request from another service to calculate a scalarproduct with us.
*
* @param cls closure (set from GNUNET_MESH_connect)
* @param tunnel connection to the other end
@@ -1613,7 +1613,7 @@ handle_service_request (void *cls,
const struct GNUNET_ATS_Information * atsi)
{
struct ServiceSession * session;
- struct GNUNET_VECTORPRODUCT_service_request * msg = (struct GNUNET_VECTORPRODUCT_service_request *) message;
+ struct GNUNET_SCALARPRODUCT_service_request * msg = (struct GNUNET_SCALARPRODUCT_service_request *) message;
uint16_t mask_length;
uint16_t pk_length;
uint16_t used_elements;
@@ -1651,7 +1651,7 @@ handle_service_request (void *cls,
}
//we need at least a peer and one message id to compare
- if (ntohs (msg->header.size) < sizeof (struct GNUNET_VECTORPRODUCT_service_request))
+ if (ntohs (msg->header.size) < sizeof (struct GNUNET_SCALARPRODUCT_service_request))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Too short message received from peer!\n"));
GNUNET_free (session);
@@ -1661,7 +1661,7 @@ handle_service_request (void *cls,
pk_length = ntohs (msg->pk_length);
used_elements = ntohs (msg->used_element_count);
element_count = ntohs (msg->element_count);
- msg_length = sizeof (struct GNUNET_VECTORPRODUCT_service_request)
+ msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request)
+ mask_length + pk_length + used_elements * PAILLIER_ELEMENT_LENGTH;
//sanity check: is the message as long as the message_count fields suggests?
@@ -1720,7 +1720,7 @@ handle_service_request (void *cls,
session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * used_elements);
- if (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_VECTORPRODUCT_service_request)
+ if (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_service_request)
+pk_length
+ mask_length
+ used_elements * PAILLIER_ELEMENT_LENGTH)
@@ -1788,7 +1788,7 @@ except:
/**
- * Handle a response we got from another service we wanted to calculate a vectorproduct with.
+ * Handle a response we got from another service we wanted to calculate a scalarproduct with.
*
* @param cls closure (set from GNUNET_MESH_connect)
* @param tunnel connection to the other end
@@ -1809,7 +1809,7 @@ handle_service_response (void *cls,
{
struct ServiceSession * session;
- struct GNUNET_VECTORPRODUCT_service_response * msg = (struct GNUNET_VECTORPRODUCT_service_response *) message;
+ struct GNUNET_SCALARPRODUCT_service_response * msg = (struct GNUNET_SCALARPRODUCT_service_response *) message;
unsigned char * current;
uint16_t count;
gcry_mpi_t s = NULL;
@@ -1835,13 +1835,13 @@ handle_service_response (void *cls,
goto invalid_msg;
}
//we need at least a peer and one message id to compare
- if (sizeof (struct GNUNET_VECTORPRODUCT_service_response) > ntohs (msg->header.size))
+ if (sizeof (struct GNUNET_SCALARPRODUCT_service_response) > ntohs (msg->header.size))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Too short message received from peer!\n"));
goto invalid_msg;
}
used_element_count = ntohs (msg->used_element_count);
- msg_size = sizeof (struct GNUNET_VECTORPRODUCT_service_response)
+ msg_size = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
+ 2 * used_element_count * PAILLIER_ELEMENT_LENGTH
+ 2 * PAILLIER_ELEMENT_LENGTH;
//sanity check: is the message as long as the message_count fields suggests?
@@ -1997,20 +1997,20 @@ run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c)
{
static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
- {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_ALICE, 0},
- {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_BOB, 0},
+ {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, 0},
+ {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, 0},
{NULL, NULL, 0, 0}
};
static const struct GNUNET_MESH_MessageHandler mesh_handlers[] = {
- { &handle_service_request, GNUNET_MESSAGE_TYPE_VECTORPRODUCT_ALICE_TO_BOB, 0},
- { &handle_service_response, GNUNET_MESSAGE_TYPE_VECTORPRODUCT_BOB_TO_ALICE, 0},
+ { &handle_service_request, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB, 0},
+ { &handle_service_response, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE, 0},
{NULL, 0, 0}
};
static const struct GNUNET_CORE_MessageHandler core_handlers[] = {
{NULL, 0, 0}
};
static GNUNET_MESH_ApplicationType mesh_types[] = {
- GNUNET_APPLICATION_TYPE_VECTORPRODUCT,
+ GNUNET_APPLICATION_TYPE_SCALARPRODUCT,
GNUNET_APPLICATION_TYPE_END
};
@@ -2048,7 +2048,7 @@ run (void *cls,
/**
- * The main function for the vectorproduct service.
+ * The main function for the scalarproduct service.
*
* @param argc number of arguments from the command line
* @param argv command line arguments
@@ -2059,7 +2059,7 @@ main (int argc, char *const *argv)
{
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc, argv,
- "vectorproduct",
+ "scalarproduct",
GNUNET_SERVICE_OPTION_NONE,
&run, NULL)) ? 0 : 1;
}
diff --git a/src/scalarproduct/gnunet_scalarproduct.h b/src/scalarproduct/gnunet_scalarproduct.h
@@ -19,13 +19,13 @@
*/
/**
- * @file include/gnunet_vectorproduct.h
- * @brief API to the vectorproduct service
+ * @file include/gnunet_scalarproduct.h
+ * @brief API to the scalarproduct service
* @author Christian M. Fuchs
*/
-#ifndef GNUNET_VECTORPRODUCT_H
-#define GNUNET_VECTORPRODUCT_H
+#ifndef GNUNET_SCALARPRODUCT_H
+#define GNUNET_SCALARPRODUCT_H
///////////////////////////////////////////////////////////////////////////////
// Defines
@@ -57,7 +57,7 @@ extern "C"
* Message type passed from requesting service Alice to responding service Bob
* to initiate a request and make bob participate in our protocol
*/
-struct GNUNET_VECTORPRODUCT_service_request {
+struct GNUNET_SCALARPRODUCT_service_request {
/**
* GNUNET message header
*/
@@ -97,7 +97,7 @@ struct GNUNET_VECTORPRODUCT_service_request {
* Message type passed from responding service Bob to responding service Alice
* to complete a request and allow Alice to compute the result
*/
-struct GNUNET_VECTORPRODUCT_service_response {
+struct GNUNET_SCALARPRODUCT_service_response {
/**
* GNUNET message header
*/
@@ -148,7 +148,7 @@ enum PeerRole
BOB
};
/**
- * A vectorproduct session which tracks:
+ * A scalarproduct session which tracks:
*
* a request form the client to our final response.
* or
@@ -270,5 +270,5 @@ struct MessageObject
}
#endif
-#endif /* GNUNET_VECTORPRODUCT_H */
+#endif /* GNUNET_SCALARPRODUCT_H */
diff --git a/src/scalarproduct/scalarproduct_api.c b/src/scalarproduct/scalarproduct_api.c
@@ -19,8 +19,8 @@
*/
/**
- * @file vectorproduct/vectorproduct_api.c
- * @brief API for the vectorproduct
+ * @file scalarproduct/scalarproduct_api.c
+ * @brief API for the scalarproduct
* @author Christian Fuchs
* @author Gaurav Kukreja
*
@@ -28,10 +28,10 @@
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "vectorproduct-api",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "scalarproduct-api",__VA_ARGS__)
/**************************************************************
*** Datatype Declarations **********
@@ -40,22 +40,22 @@
/**
* Entry in the request queue per client
*/
-struct GNUNET_VECTORPRODUCT_QueueEntry
+struct GNUNET_SCALARPRODUCT_QueueEntry
{
/**
* This is a linked list.
*/
- struct GNUNET_VECTORPRODUCT_QueueEntry *next;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *next;
/**
* This is a linked list.
*/
- struct GNUNET_VECTORPRODUCT_QueueEntry *prev;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *prev;
/**
* Handle to the master context.
*/
- struct GNUNET_VECTORPRODUCT_Handle *h;
+ struct GNUNET_SCALARPRODUCT_Handle *h;
/**
* Size of the message
@@ -63,21 +63,21 @@ struct GNUNET_VECTORPRODUCT_QueueEntry
uint16_t message_size;
/**
- * Message to be sent to the vectorproduct service
+ * Message to be sent to the scalarproduct service
*/
- struct GNUNET_VECTORPRODUCT_client_request* msg;
+ struct GNUNET_SCALARPRODUCT_client_request* msg;
union
{
/**
* Function to call after transmission of the request.
*/
- GNUNET_VECTORPRODUCT_ContinuationWithStatus cont_status;
+ GNUNET_SCALARPRODUCT_ContinuationWithStatus cont_status;
/**
* Function to call after transmission of the request.
*/
- GNUNET_VECTORPRODUCT_DatumProcessor cont_datum;
+ GNUNET_SCALARPRODUCT_DatumProcessor cont_datum;
};
/**
@@ -107,7 +107,7 @@ struct GNUNET_VECTORPRODUCT_QueueEntry
* Response Processor for response from the service. This function calls the
* continuation function provided by the client.
*/
- GNUNET_VECTORPRODUCT_ResponseMessageHandler response_proc;
+ GNUNET_SCALARPRODUCT_ResponseMessageHandler response_proc;
};
/**************************************************************
@@ -121,16 +121,16 @@ struct GNUNET_VECTORPRODUCT_QueueEntry
*
* @return pointer to the entry
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
-make_queue_entry (struct GNUNET_VECTORPRODUCT_Handle *h);
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
+make_queue_entry (struct GNUNET_SCALARPRODUCT_Handle *h);
/**
* Removes the head entry from the queue
*
* @param h Handle to the master context
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
-free_queue_head_entry (struct GNUNET_VECTORPRODUCT_Handle * h);
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
+free_queue_head_entry (struct GNUNET_SCALARPRODUCT_Handle * h);
/**
* Triggered when timeout occurs for a request in queue
@@ -170,7 +170,7 @@ static size_t transmit_request (void *cls, size_t size,
* @param h handle to the master context
*/
static void
-process_queue (struct GNUNET_VECTORPRODUCT_Handle *h);
+process_queue (struct GNUNET_SCALARPRODUCT_Handle *h);
/**************************************************************
*** Static Function Declarations **********
@@ -184,12 +184,12 @@ process_queue (struct GNUNET_VECTORPRODUCT_Handle *h);
*
* @return pointer to the entry
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
-make_queue_entry (struct GNUNET_VECTORPRODUCT_Handle *h)
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
+make_queue_entry (struct GNUNET_SCALARPRODUCT_Handle *h)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
- qe = GNUNET_new (struct GNUNET_VECTORPRODUCT_QueueEntry);
+ qe = GNUNET_new (struct GNUNET_SCALARPRODUCT_QueueEntry);
// if queue empty
if (NULL == h->queue_head && NULL == h->queue_tail)
@@ -215,10 +215,10 @@ make_queue_entry (struct GNUNET_VECTORPRODUCT_Handle *h)
*
* @param h Handle to the master context
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
-free_queue_head_entry (struct GNUNET_VECTORPRODUCT_Handle * h)
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
+free_queue_head_entry (struct GNUNET_SCALARPRODUCT_Handle * h)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry * qe = NULL;
+ struct GNUNET_SCALARPRODUCT_QueueEntry * qe = NULL;
GNUNET_assert (NULL != h);
if (NULL == h->queue_head && NULL == h->queue_tail)
@@ -255,7 +255,7 @@ free_queue_head_entry (struct GNUNET_VECTORPRODUCT_Handle * h)
static void
timeout_queue_entry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry * qe = cls;
+ struct GNUNET_SCALARPRODUCT_QueueEntry * qe = cls;
// Update Statistics
GNUNET_STATISTICS_update (qe->h->stats,
@@ -273,7 +273,7 @@ timeout_queue_entry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
// remove the queue_entry for the queue
GNUNET_CONTAINER_DLL_remove (qe->h->queue_head, qe->h->queue_tail, qe);
- qe->response_proc (qe, NULL, GNUNET_VECTORPRODUCT_Status_Timeout);
+ qe->response_proc (qe, NULL, GNUNET_SCALARPRODUCT_Status_Timeout);
}
@@ -287,9 +287,9 @@ timeout_queue_entry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
static void
process_status_message (void *cls,
const struct GNUNET_MessageHeader *msg,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe = cls;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe = cls;
GNUNET_assert (qe != NULL);
@@ -308,9 +308,9 @@ process_status_message (void *cls,
static void
process_result_message (void *cls,
const struct GNUNET_MessageHeader *msg,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe = cls;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe = cls;
GNUNET_assert (qe != NULL);
@@ -320,7 +320,7 @@ process_result_message (void *cls,
}
if (qe->cont_datum != NULL)
{
- qe->cont_datum (qe->cont_cls, &qe->msg->key, &qe->msg->peer, status, (struct GNUNET_VECTORPRODUCT_client_response *) msg);
+ qe->cont_datum (qe->cont_cls, &qe->msg->key, &qe->msg->peer, status, (struct GNUNET_SCALARPRODUCT_client_response *) msg);
}
}
@@ -336,11 +336,11 @@ process_result_message (void *cls,
static void
receive_cb (void *cls, const struct GNUNET_MessageHeader *msg)
{
- struct GNUNET_VECTORPRODUCT_Handle *h = cls;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_Handle *h = cls;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
int16_t was_transmitted;
- struct GNUNET_VECTORPRODUCT_client_response *message =
- (struct GNUNET_VECTORPRODUCT_client_response *) msg;
+ struct GNUNET_SCALARPRODUCT_client_response *message =
+ (struct GNUNET_SCALARPRODUCT_client_response *) msg;
h->in_receive = GNUNET_NO;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received reply from VectorProduct\n");
@@ -376,12 +376,12 @@ receive_cb (void *cls, const struct GNUNET_MessageHeader *msg)
if (msg == NULL)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Service responded with NULL!\n");
- qe->response_proc (qe, NULL, GNUNET_VECTORPRODUCT_Status_Failure);
+ qe->response_proc (qe, NULL, GNUNET_SCALARPRODUCT_Status_Failure);
}
- else if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_VECTORPRODUCT_SERVICE_TO_CLIENT))
+ else if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SERVICE_TO_CLIENT))
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid Message Received\n");
- qe->response_proc (qe, msg, GNUNET_VECTORPRODUCT_Status_InvalidResponse);
+ qe->response_proc (qe, msg, GNUNET_SCALARPRODUCT_Status_InvalidResponse);
}
else if (ntohl (message->product_length) == 0)
{
@@ -391,7 +391,7 @@ receive_cb (void *cls, const struct GNUNET_MessageHeader *msg)
GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received message from service without product attached.\n");
- qe->response_proc (qe, msg, GNUNET_VECTORPRODUCT_Status_Success);
+ qe->response_proc (qe, msg, GNUNET_SCALARPRODUCT_Status_Success);
}
else if (ntohl (message->product_length) > 0)
{
@@ -401,7 +401,7 @@ receive_cb (void *cls, const struct GNUNET_MessageHeader *msg)
GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received message from requester service for requester client.\n");
- qe->response_proc (qe, msg, GNUNET_VECTORPRODUCT_Status_Success);
+ qe->response_proc (qe, msg, GNUNET_SCALARPRODUCT_Status_Success);
}
GNUNET_free (qe);
@@ -422,8 +422,8 @@ static size_t
transmit_request (void *cls, size_t size,
void *buf)
{
- struct GNUNET_VECTORPRODUCT_Handle *h = cls;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_Handle *h = cls;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
size_t msize;
if (NULL == (qe = h->queue_head))
@@ -440,11 +440,11 @@ transmit_request (void *cls, size_t size,
return 0; /* no entry in queue */
if (buf == NULL)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to transmit request to VECTORPRODUCT.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to transmit request to SCALARPRODUCT.\n");
GNUNET_STATISTICS_update (h->stats,
gettext_noop ("# transmission request failures"),
1, GNUNET_NO);
- GNUNET_VECTORPRODUCT_disconnect (h);
+ GNUNET_SCALARPRODUCT_disconnect (h);
return 0;
}
if (size < (msize = qe->message_size))
@@ -452,7 +452,7 @@ transmit_request (void *cls, size_t size,
process_queue (h);
return 0;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting %u byte request to VECTORPRODUCT\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting %u byte request to SCALARPRODUCT\n",
msize);
memcpy (buf, qe->msg, size);
@@ -467,7 +467,7 @@ transmit_request (void *cls, size_t size,
#if INSANE_STATISTICS
GNUNET_STATISTICS_update (h->stats,
- gettext_noop ("# bytes sent to vectorproduct"), 1,
+ gettext_noop ("# bytes sent to scalarproduct"), 1,
GNUNET_NO);
#endif
return size;
@@ -480,9 +480,9 @@ transmit_request (void *cls, size_t size,
* @param h handle to the master context
*/
static void
-process_queue (struct GNUNET_VECTORPRODUCT_Handle *h)
+process_queue (struct GNUNET_SCALARPRODUCT_Handle *h)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
if (NULL == (qe = h->queue_head))
{
@@ -519,7 +519,7 @@ process_queue (struct GNUNET_VECTORPRODUCT_Handle *h)
if (h->th == NULL)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _ ("Failed to send a message to the vectorproduct service\n"));
+ _ ("Failed to send a message to the scalarproduct service\n"));
return;
}
@@ -547,28 +547,28 @@ process_queue (struct GNUNET_VECTORPRODUCT_Handle *h)
* @param cont Callback function
* @param cont_cls Closure for the callback function
*/
-struct GNUNET_VECTORPRODUCT_QueueEntry *
-GNUNET_VECTORPRODUCT_prepare_response (struct GNUNET_VECTORPRODUCT_Handle *h,
+struct GNUNET_SCALARPRODUCT_QueueEntry *
+GNUNET_SCALARPRODUCT_prepare_response (struct GNUNET_SCALARPRODUCT_Handle *h,
const struct GNUNET_HashCode * key,
uint16_t element_count,
int32_t * elements,
struct GNUNET_TIME_Relative timeout,
- GNUNET_VECTORPRODUCT_ContinuationWithStatus cont,
+ GNUNET_SCALARPRODUCT_ContinuationWithStatus cont,
void *cont_cls)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe = make_queue_entry (h);
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe = make_queue_entry (h);
int32_t * vector;
uint16_t size;
unsigned int i;
- GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_VECTORPRODUCT_client_request)
+ GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_client_request)
+element_count * sizeof (int32_t));
- size = sizeof (struct GNUNET_VECTORPRODUCT_client_request) +element_count * sizeof (int32_t);
+ size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) +element_count * sizeof (int32_t);
qe->message_size = size;
qe->msg = GNUNET_malloc (size);
qe->msg->header.size = htons (size);
- qe->msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_BOB);
+ qe->msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB);
qe->msg->element_count = htons (element_count);
qe->msg->mask_length = htons (0);
memcpy (&qe->msg->key, key, sizeof (struct GNUNET_HashCode));
@@ -603,8 +603,8 @@ GNUNET_VECTORPRODUCT_prepare_response (struct GNUNET_VECTORPRODUCT_Handle *h,
* @param cont Callback function
* @param cont_cls Closure for the callback function
*/
-struct GNUNET_VECTORPRODUCT_QueueEntry *
-GNUNET_VECTORPRODUCT_request (struct GNUNET_VECTORPRODUCT_Handle *h,
+struct GNUNET_SCALARPRODUCT_QueueEntry *
+GNUNET_SCALARPRODUCT_request (struct GNUNET_SCALARPRODUCT_Handle *h,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
uint16_t element_count,
@@ -612,23 +612,23 @@ GNUNET_VECTORPRODUCT_request (struct GNUNET_VECTORPRODUCT_Handle *h,
int32_t * elements,
const unsigned char * mask,
struct GNUNET_TIME_Relative timeout,
- GNUNET_VECTORPRODUCT_DatumProcessor cont,
+ GNUNET_SCALARPRODUCT_DatumProcessor cont,
void *cont_cls)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe = make_queue_entry (h);
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe = make_queue_entry (h);
int32_t * vector;
uint16_t size;
unsigned int i;
- GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_VECTORPRODUCT_client_request)
+ GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_client_request)
+element_count * sizeof (int32_t)
+ mask_length);
- size = sizeof (struct GNUNET_VECTORPRODUCT_client_request) +element_count * sizeof (int32_t) + mask_length;
+ size = sizeof (struct GNUNET_SCALARPRODUCT_client_request) +element_count * sizeof (int32_t) + mask_length;
qe->message_size = size;
qe->msg = GNUNET_malloc (size);
qe->msg->header.size = htons (size);
- qe->msg->header.type = htons (GNUNET_MESSAGE_TYPE_VECTORPRODUCT_CLIENT_TO_ALICE);
+ qe->msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE);
memcpy (&qe->msg->peer, peer, sizeof (struct GNUNET_PeerIdentity));
qe->msg->element_count = htons (element_count);
qe->msg->mask_length = htons (mask_length);
@@ -654,44 +654,44 @@ GNUNET_VECTORPRODUCT_request (struct GNUNET_VECTORPRODUCT_Handle *h,
/**
- * Connect to the vectorproduct service.
+ * Connect to the scalarproduct service.
*
* @param cfg configuration to use
* @return handle to use to access the service
*/
-struct GNUNET_VECTORPRODUCT_Handle *
-GNUNET_VECTORPRODUCT_connect (const struct GNUNET_CONFIGURATION_Handle * cfg)
+struct GNUNET_SCALARPRODUCT_Handle *
+GNUNET_SCALARPRODUCT_connect (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
struct GNUNET_CLIENT_Connection *client;
- struct GNUNET_VECTORPRODUCT_Handle *h;
+ struct GNUNET_SCALARPRODUCT_Handle *h;
- client = GNUNET_CLIENT_connect ("vectorproduct", cfg);
+ client = GNUNET_CLIENT_connect ("scalarproduct", cfg);
if (NULL == client)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _ ("Failed to connect to the vectorproduct service\n"));
+ _ ("Failed to connect to the scalarproduct service\n"));
return NULL;
}
- h = GNUNET_malloc (sizeof (struct GNUNET_VECTORPRODUCT_Handle) +
+ h = GNUNET_malloc (sizeof (struct GNUNET_SCALARPRODUCT_Handle) +
GNUNET_SERVER_MAX_MESSAGE_SIZE - 1);
h->client = client;
h->cfg = cfg;
- h->stats = GNUNET_STATISTICS_create ("vectorproduct-api", cfg);
+ h->stats = GNUNET_STATISTICS_create ("scalarproduct-api", cfg);
return h;
}
/**
- * Disconnect from the vectorproduct service.
+ * Disconnect from the scalarproduct service.
*
- * @param h handle to the vectorproduct
+ * @param h handle to the scalarproduct
*/
void
-GNUNET_VECTORPRODUCT_disconnect (struct GNUNET_VECTORPRODUCT_Handle * h)
+GNUNET_SCALARPRODUCT_disconnect (struct GNUNET_SCALARPRODUCT_Handle * h)
{
- struct GNUNET_VECTORPRODUCT_QueueEntry * qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry * qe;
LOG (GNUNET_ERROR_TYPE_INFO,
"Disconnecting from VectorProduct\n");
@@ -699,7 +699,7 @@ GNUNET_VECTORPRODUCT_disconnect (struct GNUNET_VECTORPRODUCT_Handle * h)
while (NULL != h->queue_head)
{
GNUNET_assert (NULL != (qe = free_queue_head_entry (h)));
- qe->response_proc (qe, NULL, GNUNET_VECTORPRODUCT_Status_ServiceDisconnected);
+ qe->response_proc (qe, NULL, GNUNET_SCALARPRODUCT_Status_ServiceDisconnected);
}
if (h->client != NULL)
diff --git a/src/scalarproduct/test_scalarproduct_api.c b/src/scalarproduct/test_scalarproduct_api.c
@@ -19,7 +19,7 @@
*/
/**
- * Aim of test_vectorproduct_api : This test creates two peers. Peer1 is the
+ * Aim of test_scalarproduct_api : This test creates two peers. Peer1 is the
* responder peer, Bob and Peer2 is the initiator peer, Alice. Both peers
* connect to VectorProduct Service, and use the API to issue requests to
* service. Test passes, when the expected scalar product is received from the
@@ -27,7 +27,7 @@
*/
/**
- * @file vectorproduct/testbed_vectorproduct_api.c
+ * @file scalarproduct/testbed_scalarproduct_api.c
* @brief VectorProduct API testing between 4 peers using testing API
* @author Gaurav Kukreja
* @author Christian Fuchs
@@ -40,12 +40,12 @@
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_common.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
#define NUM_PEERS 2
-#define LOG(kind,...) GNUNET_log_from (kind, "test-vectorproduct-api",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "test-scalarproduct-api",__VA_ARGS__)
/**
* Structure for holding peer's sockets and IO Handles
@@ -70,7 +70,7 @@ struct PeerData
/**
* Pointer to Vector Product Handle
*/
- struct GNUNET_VECTORPRODUCT_Handle *vh;
+ struct GNUNET_SCALARPRODUCT_Handle *vh;
};
/**
@@ -91,12 +91,12 @@ enum SetupState
/**
* Connect to stream service of peer 1
*/
- PEER1_VECTORPRODUCT_CONNECT,
+ PEER1_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 2
*/
- PEER2_VECTORPRODUCT_CONNECT
+ PEER2_SCALARPRODUCT_CONNECT
};
@@ -236,7 +236,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
LOG (GNUNET_ERROR_TYPE_INFO, "Disconnecting Peer2\n\n");
// peer->op contains handle to the TESTBED_connect_service operation
- // calling operation done, leads to call to vectorproduct_da
+ // calling operation done, leads to call to scalarproduct_da
if (peer->op != NULL)
{
GNUNET_TESTBED_operation_done (peer->op);
@@ -275,8 +275,8 @@ controller_event_cb (void *cls,
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- case PEER2_VECTORPRODUCT_CONNECT:
+ case PEER1_SCALARPRODUCT_CONNECT:
+ case PEER2_SCALARPRODUCT_CONNECT:
GNUNET_assert (NULL == event->details.operation_finished.emsg);
break;
default:
@@ -288,30 +288,30 @@ controller_event_cb (void *cls,
static void
responder_callback (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status failure\n");
responder_ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status invalid response\n");
responder_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received timeout occured\n");
responder_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received service disconnected!!\n");
responder_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_INFO, "Responder Client expected response received!\n");
responder_ok = 1;
@@ -332,37 +332,37 @@ static void
requester_callback (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- const struct GNUNET_VECTORPRODUCT_client_response *msg)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ const struct GNUNET_SCALARPRODUCT_client_response *msg)
{
uint32_t product_len;
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status failure\n");
requester_ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status invalid response\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client timeout occured\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client service disconnected!!\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success != status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success != status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client Status = %d\n", (int) status);
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_INFO, "Requester Client expected response received!\n");
product_len = ntohl(msg->product_length);
@@ -453,10 +453,10 @@ requester_callback (void *cls,
}
/**
- * Prepare the message to be sent by peer2 to its vectorproduct service, to
+ * Prepare the message to be sent by peer2 to its scalarproduct service, to
* initiate a request to peer1.
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
requester_request ()
{
unsigned int i;
@@ -465,7 +465,7 @@ requester_request ()
char * begin = input_elements_peer2;
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
GNUNET_assert (peer2.vh != NULL);
@@ -549,7 +549,7 @@ requester_request ()
mask_peer2[i] = UCHAR_MAX; // all 1's
}
- qe = GNUNET_VECTORPRODUCT_request (peer2.vh,
+ qe = GNUNET_SCALARPRODUCT_request (peer2.vh,
&key,
&peer1.our_id,
element_count_peer2,
@@ -561,7 +561,7 @@ requester_request ()
if (qe == NULL)
{
- LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to vectorproduct service! Exitting!");
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to scalarproduct service! Exitting!");
ok = -1;
return NULL;
}
@@ -571,10 +571,10 @@ requester_request ()
/**
- * Function prepares the message to be sent by peer1 to its vectorproduct service
+ * Function prepares the message to be sent by peer1 to its scalarproduct service
* to prepare response, and wait for a request session to be initiated by peer1
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
responder_prepare_response ()
{
GNUNET_assert (peer1.vh != NULL);
@@ -582,7 +582,7 @@ responder_prepare_response ()
char * begin = input_elements_peer1;
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
GNUNET_CRYPTO_hash (input_key, strlen (input_key), &key);
@@ -617,7 +617,7 @@ responder_prepare_response ()
GNUNET_assert (elements_peer1 != NULL);
GNUNET_assert (element_count_peer1 >= 1);
- qe = GNUNET_VECTORPRODUCT_prepare_response (peer1.vh,
+ qe = GNUNET_SCALARPRODUCT_prepare_response (peer1.vh,
&key,
element_count_peer1,
elements_peer1,
@@ -627,7 +627,7 @@ responder_prepare_response ()
if (qe == NULL)
{
- LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to vectorproduct service! Exitting!");
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to scalarproduct service! Exitting!");
ok = -1;
return NULL;
}
@@ -677,11 +677,11 @@ prepare_response_task(void *cls,
* @param op_result service handle returned from the connect adapter
*/
static void
-vectorproduct_da (void *cls, void *op_result)
+scalarproduct_da (void *cls, void *op_result)
{
struct PeerData* peer = (struct PeerData*) cls;
- GNUNET_VECTORPRODUCT_disconnect (peer->vh);
+ GNUNET_SCALARPRODUCT_disconnect (peer->vh);
return;
}
@@ -697,7 +697,7 @@ vectorproduct_da (void *cls, void *op_result)
* @return service handle to return in 'op_result', NULL on error
*/
static void *
-vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+scalarproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct PeerData *p = cls;
@@ -706,22 +706,22 @@ vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- /* Connect peer 2 to vectorproduct service */
+ case PEER1_SCALARPRODUCT_CONNECT:
+ /* Connect peer 2 to scalarproduct service */
{
- peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer2);
- setup_state = PEER2_VECTORPRODUCT_CONNECT;
+ peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer2);
+ setup_state = PEER2_SCALARPRODUCT_CONNECT;
}
- /* Actually connect peer 1 to vectorproduct service */
- peer1.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ /* Actually connect peer 1 to scalarproduct service */
+ peer1.vh = GNUNET_SCALARPRODUCT_connect (cfg);
return peer1.vh;
- case PEER2_VECTORPRODUCT_CONNECT:
- /* Actually connect peer 2 to vectorproduct service */
- peer2.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ case PEER2_SCALARPRODUCT_CONNECT:
+ /* Actually connect peer 2 to scalarproduct service */
+ peer2.vh = GNUNET_SCALARPRODUCT_connect (cfg);
/* Schedule tasks to initiate request from peer2 and prepare_response from peer1 */
if(peer1.vh != NULL && peer2.vh != NULL)
@@ -780,11 +780,11 @@ peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op_,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", GNUNET_i2s_full
(&peer2.our_id));
- /* Connect peer 1 to vectorproduct service */
- peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer1);
- setup_state = PEER1_VECTORPRODUCT_CONNECT;
+ /* Connect peer 1 to scalarproduct service */
+ peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer1);
+ setup_state = PEER1_SCALARPRODUCT_CONNECT;
}
break;
default:
@@ -837,8 +837,8 @@ main (int argc, char **argv)
max_mids = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_MessageHeader))
/ sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1;
- (void) GNUNET_TESTBED_test_run ("test_vectorproduct_api",
- "test_vectorproduct_api_data.conf",
+ (void) GNUNET_TESTBED_test_run ("test_scalarproduct_api",
+ "test_scalarproduct_api_data.conf",
NUM_PEERS, event_mask, &controller_event_cb,
NULL,
&test_master, NULL);
diff --git a/src/scalarproduct/test_scalarproduct_api_4peers.c b/src/scalarproduct/test_scalarproduct_api_4peers.c
@@ -28,7 +28,7 @@
*
* To test this, we create 4 peers. peer1 and peer2 are designated responders,
* and peer3 and peer4 are designated as requesters. Each peer calls API for the
- * vectorproduct service accordingly.
+ * scalarproduct service accordingly.
*
* * peer1 tells the service to prepare response for requests with keys
* input_key_p1_p3(shared key b/w peer1 and peer3) and input_key_p1_p4.
@@ -45,7 +45,7 @@
/**
- * @file vectorproduct/test_vectorproduct_api_4peers.c
+ * @file scalarproduct/test_scalarproduct_api_4peers.c
* @brief Vectorproduct API testing between 4 peers using testing API
* @author Gaurav Kukreja
* @author Christian Fuchs
@@ -58,10 +58,10 @@
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_common.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "test-vectorproduct-api-4peers",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "test-scalarproduct-api-4peers",__VA_ARGS__)
#define NUM_PEERS 4
@@ -88,7 +88,7 @@ struct PeerData
/**
* Pointer to Vector Product Handle
*/
- struct GNUNET_VECTORPRODUCT_Handle *vh;
+ struct GNUNET_SCALARPRODUCT_Handle *vh;
/**
* Input elements for peer
@@ -151,22 +151,22 @@ enum SetupState
/**
* Connect to stream service of peer 1
*/
- PEER1_VECTORPRODUCT_CONNECT,
+ PEER1_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 2
*/
- PEER2_VECTORPRODUCT_CONNECT,
+ PEER2_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 3
*/
- PEER3_VECTORPRODUCT_CONNECT,
+ PEER3_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 4
*/
- PEER4_VECTORPRODUCT_CONNECT
+ PEER4_SCALARPRODUCT_CONNECT
};
@@ -335,7 +335,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down Peer 4!!! \n");
// peer->op contains handle to the TESTBED_connect_service operation
- // calling operation done, leads to call to vectorproduct_da
+ // calling operation done, leads to call to scalarproduct_da
GNUNET_TESTBED_operation_done (peer->op);
peer->op = NULL;
@@ -372,8 +372,8 @@ controller_event_cb (void *cls,
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- case PEER2_VECTORPRODUCT_CONNECT:
+ case PEER1_SCALARPRODUCT_CONNECT:
+ case PEER2_SCALARPRODUCT_CONNECT:
GNUNET_assert (NULL == event->details.operation_finished.emsg);
break;
default:
@@ -389,7 +389,7 @@ controller_event_cb (void *cls,
static void
responder_callback (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
struct PeerData * peer = cls;
@@ -407,27 +407,27 @@ responder_callback (void *cls,
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester callback received, but peer is neither peer1 nor peer2!!!\n");
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Responder Client received status failure\n");
ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Responder Client received status invalid response\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Responder Client received timeout occured\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Responder Client received service disconnected!!\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Responder Client expected response received!\n");
ok = 1;
@@ -448,8 +448,8 @@ static void
requester_callback (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- const struct GNUNET_VECTORPRODUCT_client_response *msg)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ const struct GNUNET_SCALARPRODUCT_client_response *msg)
{
struct PeerData * peer_ = cls;
uint32_t product_len;
@@ -468,32 +468,32 @@ requester_callback (void *cls,
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester callback received, but peer is neither peer3 nor peer4!!!\n");
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester Client received status failure\n");
ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester Client received status invalid response\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester Client timeout occured\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester Client service disconnected!!\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success != status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success != status)
{
LOG (GNUNET_ERROR_TYPE_ERROR, "Requester Client Status = %d\n", (int) status);
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Requester client received status successful!\n");
product_len = ntohl (msg->product_length);
@@ -529,7 +529,7 @@ requester_callback (void *cls,
}
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
requester_request (char * input_elements,
char * input_mask,
char * input_key,
@@ -544,7 +544,7 @@ requester_request (char * input_elements,
uint16_t mask_length = 0;
unsigned char * mask = NULL;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
int exit_loop;
char * begin = input_elements;
@@ -633,7 +633,7 @@ requester_request (char * input_elements,
mask[i] = UCHAR_MAX; // all 1's
}
- qe = GNUNET_VECTORPRODUCT_request (peer->vh,
+ qe = GNUNET_SCALARPRODUCT_request (peer->vh,
&key,
&to_peer->our_id,
element_count,
@@ -645,7 +645,7 @@ requester_request (char * input_elements,
if (qe == NULL)
{
- LOG(GNUNET_ERROR_TYPE_WARNING, "Could not send request to vectorproduct service! Exitting!");
+ LOG(GNUNET_ERROR_TYPE_WARNING, "Could not send request to scalarproduct service! Exitting!");
ok = -1;
return NULL;
}
@@ -655,10 +655,10 @@ requester_request (char * input_elements,
/**
- * Function prepares the message to be sent by peer1 to its vectorproduct service
+ * Function prepares the message to be sent by peer1 to its scalarproduct service
* to prepare response, and wait for a request session to be initiated by peer1
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
responder_prepare_response (char * input_elements,
char * input_mask,
char * input_key,
@@ -672,7 +672,7 @@ responder_prepare_response (char * input_elements,
unsigned short mask_length = 0;
unsigned char * mask = NULL;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
int exit_loop;
char * begin;
@@ -758,7 +758,7 @@ responder_prepare_response (char * input_elements,
mask[i] = UCHAR_MAX; // all 1's
}
- qe = GNUNET_VECTORPRODUCT_prepare_response (peer->vh,
+ qe = GNUNET_SCALARPRODUCT_prepare_response (peer->vh,
&key,
element_count,
elements,
@@ -768,7 +768,7 @@ responder_prepare_response (char * input_elements,
if (qe == NULL)
{
- LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to vectorproduct service! Exitting!");
+ LOG(GNUNET_ERROR_TYPE_ERROR, "Could not send request to scalarproduct service! Exitting!");
ok = -1;
return NULL;
}
@@ -813,11 +813,11 @@ prepare_response_task (void *cls,
* @param op_result service handle returned from the connect adapter
*/
static void
-vectorproduct_da (void *cls, void *op_result)
+scalarproduct_da (void *cls, void *op_result)
{
struct PeerData* peer = (struct PeerData*) cls;
- GNUNET_VECTORPRODUCT_disconnect (peer->vh);
+ GNUNET_SCALARPRODUCT_disconnect (peer->vh);
return;
GNUNET_assert (0);
@@ -835,7 +835,7 @@ vectorproduct_da (void *cls, void *op_result)
* @return service handle to return in 'op_result', NULL on error
*/
static void *
-vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+scalarproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct PeerData *p = cls;
@@ -844,44 +844,44 @@ vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- /* Connect peer 2 to vectorproduct service */
+ case PEER1_SCALARPRODUCT_CONNECT:
+ /* Connect peer 2 to scalarproduct service */
{
- peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer2);
- setup_state = PEER2_VECTORPRODUCT_CONNECT;
+ peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer2);
+ setup_state = PEER2_SCALARPRODUCT_CONNECT;
}
- peer1.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ peer1.vh = GNUNET_SCALARPRODUCT_connect (cfg);
return peer1.vh;
- case PEER2_VECTORPRODUCT_CONNECT:
- /* Connect peer 3 to vectorproduct service */
+ case PEER2_SCALARPRODUCT_CONNECT:
+ /* Connect peer 3 to scalarproduct service */
{
- peer3.op = GNUNET_TESTBED_service_connect (&peer3, peer3.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer3);
- setup_state = PEER3_VECTORPRODUCT_CONNECT;
+ peer3.op = GNUNET_TESTBED_service_connect (&peer3, peer3.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer3);
+ setup_state = PEER3_SCALARPRODUCT_CONNECT;
}
- peer2.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ peer2.vh = GNUNET_SCALARPRODUCT_connect (cfg);
return peer2.vh;
- case PEER3_VECTORPRODUCT_CONNECT:
- /* Connect peer 4 to vectorproduct service */
+ case PEER3_SCALARPRODUCT_CONNECT:
+ /* Connect peer 4 to scalarproduct service */
{
- peer4.op = GNUNET_TESTBED_service_connect (&peer4, peer4.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer4);
- setup_state = PEER4_VECTORPRODUCT_CONNECT;
+ peer4.op = GNUNET_TESTBED_service_connect (&peer4, peer4.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer4);
+ setup_state = PEER4_SCALARPRODUCT_CONNECT;
}
- peer3.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ peer3.vh = GNUNET_SCALARPRODUCT_connect (cfg);
return peer3.vh;
- case PEER4_VECTORPRODUCT_CONNECT:
- peer4.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ case PEER4_SCALARPRODUCT_CONNECT:
+ peer4.vh = GNUNET_SCALARPRODUCT_connect (cfg);
/* Schedule the tasks to issue prepare_response calls from peer1 and peer2
* for peer3 and peer4.
@@ -982,11 +982,11 @@ peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op_,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", GNUNET_i2s_full
(&peer2.our_id));
- /* Connect peer 1 to vectorproduct service */
- peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer1);
- setup_state = PEER1_VECTORPRODUCT_CONNECT;
+ /* Connect peer 1 to scalarproduct service */
+ peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer1);
+ setup_state = PEER1_SCALARPRODUCT_CONNECT;
}
break;
default:
@@ -1073,8 +1073,8 @@ main (int argc, char **argv)
event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
max_mids = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_MessageHeader))
/ sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1;
- (void) GNUNET_TESTBED_test_run ("test_vectorproduct_api_4peers",
- "test_vectorproduct_api_data.conf",
+ (void) GNUNET_TESTBED_test_run ("test_scalarproduct_api_4peers",
+ "test_scalarproduct_api_data.conf",
NUM_PEERS, event_mask, &controller_event_cb,
NULL,
&test_master, NULL);
diff --git a/src/scalarproduct/test_scalarproduct_api_regression.c b/src/scalarproduct/test_scalarproduct_api_regression.c
@@ -20,7 +20,7 @@
*/
/**
- * @file vectorproduct/test_vectorproduct_api_regression.c
+ * @file scalarproduct/test_scalarproduct_api_regression.c
* @brief VectorProduct API regression test
* @author Gaurav Kukreja
* @author Christian Fuchs
@@ -47,10 +47,10 @@
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_common.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "test-vectorproduct-api-regression",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "test-scalarproduct-api-regression",__VA_ARGS__)
#define NUM_PEERS 2
/**
@@ -76,7 +76,7 @@ struct PeerData
/**
* Pointer to Vector Product Handle
*/
- struct GNUNET_VECTORPRODUCT_Handle *vh;
+ struct GNUNET_SCALARPRODUCT_Handle *vh;
};
/**
@@ -97,12 +97,12 @@ enum SetupState
/**
* Connect to stream service of peer 1
*/
- PEER1_VECTORPRODUCT_CONNECT,
+ PEER1_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 2
*/
- PEER2_VECTORPRODUCT_CONNECT
+ PEER2_SCALARPRODUCT_CONNECT
};
@@ -250,7 +250,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting Peer2\n\n");
// peer->op contains handle to the TESTBED_connect_service operation
- // calling operation done, leads to call to vectorproduct_da
+ // calling operation done, leads to call to scalarproduct_da
if (peer->op != NULL)
{
GNUNET_TESTBED_operation_done (peer->op);
@@ -290,8 +290,8 @@ controller_event_cb (void *cls,
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- case PEER2_VECTORPRODUCT_CONNECT:
+ case PEER1_SCALARPRODUCT_CONNECT:
+ case PEER2_SCALARPRODUCT_CONNECT:
GNUNET_assert (NULL == event->details.operation_finished.emsg);
break;
default:
@@ -314,29 +314,29 @@ controller_event_cb (void *cls,
static void
responder_callback (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status failure\n");
ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status invalid response\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received timeout occured\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received service disconnected!!\n");
ok = 1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Responder Client expected response received!\n");
ok = -1;
@@ -369,37 +369,37 @@ static void
requester_callback (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- const struct GNUNET_VECTORPRODUCT_client_response *msg)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ const struct GNUNET_SCALARPRODUCT_client_response *msg)
{
uint32_t product_len;
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status failure\n");
ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status invalid response\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client timeout occured\n");
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client service disconnected!!\n");
ok = 1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success != status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success != status)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Requester Client Status = %d\n", (int) status);
ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
product_len = ntohl (msg->product_length);
@@ -452,7 +452,7 @@ requester_request (void *cls,
char * begin = input_elements_peer2;
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
int exit_loop = 0;
@@ -537,7 +537,7 @@ requester_request (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Responder peer key %s\n", &peer1.our_id);
- qe = GNUNET_VECTORPRODUCT_request (peer2.vh,
+ qe = GNUNET_SCALARPRODUCT_request (peer2.vh,
&key,
&peer1.our_id,
element_count,
@@ -549,7 +549,7 @@ requester_request (void *cls,
if (qe == NULL)
{
- FPRINTF (stderr, "%s", _ ("Could not send request to vectorproduct service! Exitting!"));
+ FPRINTF (stderr, "%s", _ ("Could not send request to scalarproduct service! Exitting!"));
ok = -1;
return;
}
@@ -566,7 +566,7 @@ requester_request (void *cls,
/**
- * Function prepares the message to be sent by peer1 to its vectorproduct service
+ * Function prepares the message to be sent by peer1 to its scalarproduct service
* to prepare response, and wait for a request session to be initiated by peer1
*/
static void
@@ -580,7 +580,7 @@ responder_prepare_response (void *cls,
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
GNUNET_CRYPTO_hash (input_key, strlen (input_key), &key);
@@ -616,7 +616,7 @@ responder_prepare_response (void *cls,
GNUNET_assert (elements_peer1 != NULL);
GNUNET_assert (element_count >= 1);
- qe = GNUNET_VECTORPRODUCT_prepare_response (peer1.vh,
+ qe = GNUNET_SCALARPRODUCT_prepare_response (peer1.vh,
&key,
element_count,
elements_peer1,
@@ -626,13 +626,13 @@ responder_prepare_response (void *cls,
if (qe == NULL)
{
- FPRINTF (stderr, "%s", _ ("Could not send request to vectorproduct service! Exitting!"));
+ FPRINTF (stderr, "%s", _ ("Could not send request to scalarproduct service! Exitting!"));
ok = -1;
return;
}
// connect the second peer
- setup_state = PEER2_VECTORPRODUCT_CONNECT;
+ setup_state = PEER2_SCALARPRODUCT_CONNECT;
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), &connect_peer, &peer2);
// while the service is waiting for a matching request, disconnect the test client
@@ -652,11 +652,11 @@ responder_prepare_response (void *cls,
* @param op_result service handle returned from the connect adapter
*/
static void
-vectorproduct_da (void *cls, void *op_result)
+scalarproduct_da (void *cls, void *op_result)
{
struct PeerData* peer = (struct PeerData*) cls;
- GNUNET_VECTORPRODUCT_disconnect (peer->vh);
+ GNUNET_SCALARPRODUCT_disconnect (peer->vh);
peer->vh = NULL;
return;
}
@@ -673,7 +673,7 @@ vectorproduct_da (void *cls, void *op_result)
* @return service handle to return in 'op_result', NULL on error
*/
static void *
-vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+scalarproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct PeerData *p = cls;
@@ -682,8 +682,8 @@ vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- peer1.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ case PEER1_SCALARPRODUCT_CONNECT:
+ peer1.vh = GNUNET_SCALARPRODUCT_connect (cfg);
if (peer1.vh != NULL)
{
@@ -698,9 +698,9 @@ vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
return peer1.vh;
- case PEER2_VECTORPRODUCT_CONNECT:
- /* Actually connect peer 2 to vectorproduct service */
- peer2.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ case PEER2_SCALARPRODUCT_CONNECT:
+ /* Actually connect peer 2 to scalarproduct service */
+ peer2.vh = GNUNET_SCALARPRODUCT_connect (cfg);
if (peer2.vh != NULL)
{
@@ -732,9 +732,9 @@ connect_peer (void *cls,
{
struct PeerData *peer = cls;
- peer->op = GNUNET_TESTBED_service_connect (peer, peer->peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, peer);
+ peer->op = GNUNET_TESTBED_service_connect (peer, peer->peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, peer);
}
@@ -783,8 +783,8 @@ peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op_,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", GNUNET_i2s_full
(&peer2.our_id));
- /* Connect peer 1 to vectorproduct service */
- setup_state = PEER1_VECTORPRODUCT_CONNECT;
+ /* Connect peer 1 to scalarproduct service */
+ setup_state = PEER1_SCALARPRODUCT_CONNECT;
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, &connect_peer, &peer1);
}
break;
@@ -838,8 +838,8 @@ main (int argc, char **argv)
max_mids = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_MessageHeader))
/ sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1;
- (void) GNUNET_TESTBED_test_run ("test_vectorproduct_api_regression",
- "test_vectorproduct_api_data.conf",
+ (void) GNUNET_TESTBED_test_run ("test_scalarproduct_api_regression",
+ "test_scalarproduct_api_data.conf",
NUM_PEERS, event_mask, &controller_event_cb,
NULL,
&test_master, NULL);
diff --git a/src/scalarproduct/test_scalarproduct_api_regression2.c b/src/scalarproduct/test_scalarproduct_api_regression2.c
@@ -19,7 +19,7 @@
*/
/**
- * @file vectorproduct/test_vectorproduct_api_regression2.c
+ * @file scalarproduct/test_scalarproduct_api_regression2.c
* @brief Regression test, destroys requester service before receiving response
* responder service
* @author Gaurav Kukreja
@@ -33,10 +33,10 @@
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_common.h"
-#include "gnunet_vectorproduct_service.h"
+#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "test-vectorproduct-api-regression2",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "test-scalarproduct-api-regression2",__VA_ARGS__)
#define NUM_PEERS 2
/**
@@ -62,7 +62,7 @@ struct PeerData
/**
* Pointer to Vector Product Handle
*/
- struct GNUNET_VECTORPRODUCT_Handle *vh;
+ struct GNUNET_SCALARPRODUCT_Handle *vh;
};
/**
@@ -83,12 +83,12 @@ enum SetupState
/**
* Connect to stream service of peer 1
*/
- PEER1_VECTORPRODUCT_CONNECT,
+ PEER1_SCALARPRODUCT_CONNECT,
/**
* Connect to stream service of peer 2
*/
- PEER2_VECTORPRODUCT_CONNECT
+ PEER2_SCALARPRODUCT_CONNECT
};
@@ -241,7 +241,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
struct PeerData* peer = (struct PeerData*) cls;
// peer->op contains handle to the TESTBED_connect_service operation
- // calling operation done, leads to call to vectorproduct_da
+ // calling operation done, leads to call to scalarproduct_da
if (peer->op != NULL)
{
if (peer == &peer1)
@@ -287,8 +287,8 @@ controller_event_cb (void *cls,
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- case PEER2_VECTORPRODUCT_CONNECT:
+ case PEER1_SCALARPRODUCT_CONNECT:
+ case PEER2_SCALARPRODUCT_CONNECT:
GNUNET_assert (NULL == event->details.operation_finished.emsg);
break;
default:
@@ -304,31 +304,31 @@ controller_event_cb (void *cls,
static void
responder_callback (void *cls,
const struct GNUNET_HashCode * key,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status)
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status)
{
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status failure\n");
responder_ok = -1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received status invalid response\n");
responder_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received timeout occured\n");
// In this regression test, requester is supposed to fail due to timeout
// therefore responder_ok is set to 1, to make regression test pass
responder_ok = 1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Responder Client received service disconnected!!\n");
responder_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Responder Client expected response received!\n");
responder_ok = 1;
@@ -349,40 +349,40 @@ static void
requester_callback (void *cls,
const struct GNUNET_HashCode * key,
const struct GNUNET_PeerIdentity * peer,
- enum GNUNET_VECTORPRODUCT_ResponseStatus status,
- uint16_t size, struct GNUNET_VECTORPRODUCT_client_response *msg,
+ enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+ uint16_t size, struct GNUNET_SCALARPRODUCT_client_response *msg,
uint16_t type)
{
uint32_t product_len;
- if (status == GNUNET_VECTORPRODUCT_Status_Failure)
+ if (status == GNUNET_SCALARPRODUCT_Status_Failure)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status failure\n");
// In this regression test, requester is supposed to receive status failure
// therefore requester_ok is set to 1, to make regression test pass
requester_ok = 1;
}
- else if (status == GNUNET_VECTORPRODUCT_Status_InvalidResponse)
+ else if (status == GNUNET_SCALARPRODUCT_Status_InvalidResponse)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client received status invalid response\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Timeout == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Timeout == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client timeout occured\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_ServiceDisconnected == status)
+ else if (GNUNET_SCALARPRODUCT_Status_ServiceDisconnected == status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client service disconnected!!\n");
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success != status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success != status)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Requester Client Status = %d\n", (int) status);
requester_ok = -1;
}
- else if (GNUNET_VECTORPRODUCT_Status_Success == status)
+ else if (GNUNET_SCALARPRODUCT_Status_Success == status)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Requester Client expected response received!\n");
@@ -475,7 +475,7 @@ requester_callback (void *cls,
}
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
requester_request ()
{
GNUNET_assert (peer2.vh != NULL);
@@ -487,7 +487,7 @@ requester_request ()
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
GNUNET_CRYPTO_hash (input_key, strlen (input_key), &key);
@@ -573,7 +573,7 @@ requester_request ()
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Responder peer key %s\n", &peer1.our_id);
// TODO : Create the mask array
- qe = GNUNET_VECTORPRODUCT_request (peer2.vh,
+ qe = GNUNET_SCALARPRODUCT_request (peer2.vh,
&key,
&peer1.our_id,
element_count_peer2,
@@ -585,7 +585,7 @@ requester_request ()
if (qe == NULL)
{
- FPRINTF (stderr, "%s", _ ("Could not send request to vectorproduct service! Exitting!"));
+ FPRINTF (stderr, "%s", _ ("Could not send request to scalarproduct service! Exitting!"));
ok = -1;
return NULL;
}
@@ -595,10 +595,10 @@ requester_request ()
/**
- * Function prepares the message to be sent by peer1 to its vectorproduct service
+ * Function prepares the message to be sent by peer1 to its scalarproduct service
* to prepare response, and wait for a request session to be initiated by peer1
*/
-static struct GNUNET_VECTORPRODUCT_QueueEntry *
+static struct GNUNET_SCALARPRODUCT_QueueEntry *
responder_prepare_response ()
{
GNUNET_assert (peer1.vh != NULL);
@@ -609,7 +609,7 @@ responder_prepare_response ()
char * end;
int32_t element;
- struct GNUNET_VECTORPRODUCT_QueueEntry *qe;
+ struct GNUNET_SCALARPRODUCT_QueueEntry *qe;
struct GNUNET_HashCode key;
GNUNET_CRYPTO_hash (input_key, strlen (input_key), &key);
@@ -648,7 +648,7 @@ responder_prepare_response ()
GNUNET_assert (elements_peer1 != NULL);
GNUNET_assert (element_count_peer1 >= 1);
- qe = GNUNET_VECTORPRODUCT_prepare_response (peer1.vh,
+ qe = GNUNET_SCALARPRODUCT_prepare_response (peer1.vh,
&key,
element_count_peer1,
elements_peer1,
@@ -658,7 +658,7 @@ responder_prepare_response ()
if (qe == NULL)
{
- FPRINTF (stderr, "%s", _ ("Could not send request to vectorproduct service! Exitting!"));
+ FPRINTF (stderr, "%s", _ ("Could not send request to scalarproduct service! Exitting!"));
ok = -1;
return NULL;
}
@@ -737,11 +737,11 @@ destroy_server (void *cls,
* @param op_result service handle returned from the connect adapter
*/
static void
-vectorproduct_da (void *cls, void *op_result)
+scalarproduct_da (void *cls, void *op_result)
{
struct PeerData* peer = (struct PeerData*) cls;
- GNUNET_VECTORPRODUCT_disconnect (peer->vh);
+ GNUNET_SCALARPRODUCT_disconnect (peer->vh);
return;
}
@@ -757,7 +757,7 @@ vectorproduct_da (void *cls, void *op_result)
* @return service handle to return in 'op_result', NULL on error
*/
static void *
-vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+scalarproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct PeerData *p = cls;
@@ -766,23 +766,23 @@ vectorproduct_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
switch (setup_state)
{
- case PEER1_VECTORPRODUCT_CONNECT:
- /* Connect peer 2 to vectorproduct service */
- /* The connect adapter vectorproduct_ca will be called to perform the actual connection */
+ case PEER1_SCALARPRODUCT_CONNECT:
+ /* Connect peer 2 to scalarproduct service */
+ /* The connect adapter scalarproduct_ca will be called to perform the actual connection */
{
- peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer2);
- setup_state = PEER2_VECTORPRODUCT_CONNECT;
+ peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer2);
+ setup_state = PEER2_SCALARPRODUCT_CONNECT;
}
- /* Actually connect peer 1 to vectorproduct service */
- peer1.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ /* Actually connect peer 1 to scalarproduct service */
+ peer1.vh = GNUNET_SCALARPRODUCT_connect (cfg);
return peer1.vh;
- case PEER2_VECTORPRODUCT_CONNECT:
- /* Actually connect peer 2 to vectorproduct service */
- peer2.vh = GNUNET_VECTORPRODUCT_connect (cfg);
+ case PEER2_SCALARPRODUCT_CONNECT:
+ /* Actually connect peer 2 to scalarproduct service */
+ peer2.vh = GNUNET_SCALARPRODUCT_connect (cfg);
if (peer1.vh != NULL && peer2.vh != NULL)
@@ -848,12 +848,12 @@ peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op_,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", GNUNET_i2s_full
(&peer2.our_id));
- /* Connect peer 1 to vectorproduct service */
- /* The connect adapter vectorproduct_ca will be called to perform the actual connection */
- peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "vectorproduct",
- NULL, NULL, vectorproduct_ca,
- vectorproduct_da, &peer1);
- setup_state = PEER1_VECTORPRODUCT_CONNECT;
+ /* Connect peer 1 to scalarproduct service */
+ /* The connect adapter scalarproduct_ca will be called to perform the actual connection */
+ peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "scalarproduct",
+ NULL, NULL, scalarproduct_ca,
+ scalarproduct_da, &peer1);
+ setup_state = PEER1_SCALARPRODUCT_CONNECT;
}
break;
default:
@@ -904,8 +904,8 @@ main (int argc, char **argv)
max_mids = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_MessageHeader))
/ sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1;
- (void) GNUNET_TESTBED_test_run ("test_vectorproduct_api_regression2",
- "test_vectorproduct_api_data.conf",
+ (void) GNUNET_TESTBED_test_run ("test_scalarproduct_api_regression2",
+ "test_scalarproduct_api_data.conf",
NUM_PEERS, event_mask, &controller_event_cb,
NULL,
&test_master, NULL);
diff --git a/src/scalarproduct/vectorproduct_testing.h b/src/scalarproduct/vectorproduct_testing.h
@@ -1,18 +1,18 @@
/*
- * File: vectorproduct_testing.h
+ * File: scalarproduct_testing.h
* Author: gnunet
*
* Created on June 29, 2013, 7:39 PM
*/
-#ifndef VECTORPRODUCT_TESTING_H
-#define VECTORPRODUCT_TESTING_H
+#ifndef SCALARPRODUCT_TESTING_H
+#define SCALARPRODUCT_TESTING_H
#ifdef __cplusplus
extern "C" {
#endif
-struct GNUNET_VECTORPRODUCT_TESTING_handle
+struct GNUNET_SCALARPRODUCT_TESTING_handle
{
/**
* Testing library system handle
@@ -60,7 +60,7 @@ struct PeerContext
/**
* Pointer to Vector Product Handle
*/
- struct GNUNET_VECTORPRODUCT_Handle *vh;
+ struct GNUNET_SCALARPRODUCT_Handle *vh;
/**
* Closure for the callbacks
@@ -80,7 +80,7 @@ struct PeerContext
/**
* Pointer to the master testing handle
*/
- struct GNUNET_VECTORPRODUCT_TESTING_handle * vth;
+ struct GNUNET_SCALARPRODUCT_TESTING_handle * vth;
/**
* Callback when two peers are connected and both have called the connect callback
@@ -91,31 +91,31 @@ struct PeerContext
// /**
// * Pointer to function where the test occurs
// */
-// GNUNET_VECTORPRODUCT_TESTING_start_cb start_cb;
+// GNUNET_SCALARPRODUCT_TESTING_start_cb start_cb;
};
/**
* Callback when two peers are connected and both have called the connect callback
* to notify clients about a new peer
*/
-typedef void (*GNUNET_VECTORPRODUCT_TESTING_start_cb) (struct PeerContext * p,
+typedef void (*GNUNET_SCALARPRODUCT_TESTING_start_cb) (struct PeerContext * p,
void *cls);
-struct GNUNET_VECTORPRODUCT_TESTING_handle *
-GNUNET_VECTORPRODUCT_TESTING_init();
+struct GNUNET_SCALARPRODUCT_TESTING_handle *
+GNUNET_SCALARPRODUCT_TESTING_init();
static void
-GNUNET_VECTORPRODUCT_TESTING_done(struct GNUNET_VECTORPRODUCT_TESTING_handle * vth);
+GNUNET_SCALARPRODUCT_TESTING_done(struct GNUNET_SCALARPRODUCT_TESTING_handle * vth);
struct PeerContext *
-GNUNET_VECTORPRODUCT_TESTING_start_peer (struct GNUNET_VECTORPRODUCT_TESTING_handle * vth,
+GNUNET_SCALARPRODUCT_TESTING_start_peer (struct GNUNET_SCALARPRODUCT_TESTING_handle * vth,
const char *cfgname, int peer_id,
- GNUNET_VECTORPRODUCT_TESTING_start_cb start_cb,
+ GNUNET_SCALARPRODUCT_TESTING_start_cb start_cb,
void *cb_cls);
static void
-GNUNET_VECTORPRODUCT_TESTING_stop_peer
- (struct GNUNET_VECTORPRODUCT_TESTING_handle * vth,
+GNUNET_SCALARPRODUCT_TESTING_stop_peer
+ (struct GNUNET_SCALARPRODUCT_TESTING_handle * vth,
struct PeerContext *p);
@@ -125,5 +125,5 @@ GNUNET_VECTORPRODUCT_TESTING_stop_peer
}
#endif
-#endif /* VECTORPRODUCT_TESTING_H */
+#endif /* SCALARPRODUCT_TESTING_H */
