gnunet-scalarproduct.c File Reference

scalarproduct client More...

#include "platform.h"
#include <gcrypt.h>
#include <inttypes.h>
#include "gnunet_util_lib.h"
#include "gnunet_scalarproduct_service.h"
#include "gnunet_protocols.h"
#include "scalarproduct.h"

Include dependency graph for gnunet-scalarproduct.c:

Go to the source code of this file.

Macros
#define	GCRYPT_NO_DEPRECATED
#define	LOG(kind, ...)

Functions
static void	responder_callback (void *cls, enum GNUNET_SCALARPRODUCT_ResponseStatus status)
	Callback called if we are initiating a new computation session. More...
static void	requester_callback (void *cls, enum GNUNET_SCALARPRODUCT_ResponseStatus status, gcry_mpi_t result)
	Callback called if we are initiating a new computation session. More...
static void	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function to the scalarproduct client. More...

Variables
static struct GNUNET_HashCode	session_key
	the session key identifying this computation More...
static struct GNUNET_PeerIdentity	peer_id
	PeerID we want to compute a scalar product with. More...
static char *	input_peer_id
	Option -p: destination peer identity for checking message-ids with. More...
static char *	input_session_key
	Option -p: destination peer identity for checking message-ids with. More...
static char *	input_elements
	Option -e: vector to calculate a scalarproduct with. More...
static int	ret = -1
	Global return value. More...
static struct GNUNET_SCALARPRODUCT_ComputationHandle *	computation
	our Scalarproduct Computation handle More...

Detailed Description

scalarproduct client

Author

Christian M. Fuchs

Definition in file gnunet-scalarproduct.c.

Macro Definition Documentation

GCRYPT_NO_DEPRECATED

#define GCRYPT_NO_DEPRECATED

Definition at line 26 of file gnunet-scalarproduct.c.

LOG

#define LOG	(		kind,
			...
	)

Value:

                                        GNUNET_log_from (kind, "gnunet-scalarproduct", \
                                        __VA_ARGS__)

Definition at line 36 of file gnunet-scalarproduct.c.

Function Documentation

responder_callback()

static void responder_callback ( void *  cls, enum GNUNET_SCALARPRODUCT_ResponseStatus  status  )

static

Callback called if we are initiating a new computation session.

Parameters

cls	unused
status	if our job was successfully processed

Definition at line 83 of file gnunet-scalarproduct.c.

{
  switch (status)
  {
  case GNUNET_SCALARPRODUCT_STATUS_SUCCESS:
    ret = 0;
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Session %s concluded.\n",
         GNUNET_h2s (&session_key));
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s failed: invalid response\n",
         GNUNET_h2s (&session_key));
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_FAILURE:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s failed: service failure\n",
         GNUNET_h2s (&session_key));
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s failed: service disconnect!\n",
         GNUNET_h2s (&session_key));
    break;
 
  default:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s failed: return code %d\n",
         GNUNET_h2s (&session_key),
         status);
  }
  computation = NULL;
  GNUNET_SCHEDULER_shutdown ();
}

References computation, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED, GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE, GNUNET_SCALARPRODUCT_STATUS_SUCCESS, GNUNET_SCHEDULER_shutdown(), LOG, ret, session_key, and status.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

requester_callback()

static void requester_callback ( void *  cls, enum GNUNET_SCALARPRODUCT_ResponseStatus  status, gcry_mpi_t  result  )

static

Callback called if we are initiating a new computation session.

Parameters

cls	unused
status	if our job was successfully processed
result	the result in gnu/gcry MPI format

Definition at line 132 of file gnunet-scalarproduct.c.

{
  unsigned char *buf;
  gcry_error_t rc;
 
  switch (status)
  {
  case GNUNET_SCALARPRODUCT_STATUS_SUCCESS:
    if (0 == (rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, result)))
    {
      ret = 0;
      fprintf (stdout,
               "%s\n",
               buf);
      fflush (stdout);
    }
    else
      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
                "gcry_mpi_aprint",
                rc);
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s with peer %s failed: invalid response received\n",
         GNUNET_h2s (&session_key),
         GNUNET_i2s (&peer_id));
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_FAILURE:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s with peer %s failed: API failure\n",
         GNUNET_h2s (&session_key),
         GNUNET_i2s (&peer_id));
    break;
 
  case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s with peer %s was disconnected from service.\n",
         GNUNET_h2s (&session_key),
         GNUNET_i2s (&peer_id));
    break;
 
  default:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Session %s with peer %s failed: return code %d\n",
         GNUNET_h2s (&session_key),
         GNUNET_i2s (&peer_id),
         status);
  }
  computation = NULL;
  GNUNET_SCHEDULER_shutdown ();
}

References computation, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_i2s(), GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED, GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE, GNUNET_SCALARPRODUCT_STATUS_SUCCESS, GNUNET_SCHEDULER_shutdown(), LOG, LOG_GCRY, peer_id, result, ret, session_key, and status.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 195 of file gnunet-scalarproduct.c.

{
  if (NULL != computation)
  {
    GNUNET_SCALARPRODUCT_cancel (computation);
    ret = 1;   /* aborted */
  }
}

References computation, GNUNET_SCALARPRODUCT_cancel(), and ret.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 214 of file gnunet-scalarproduct.c.

{
  char *begin = input_elements;
  char *end;
  unsigned int i;
  struct GNUNET_SCALARPRODUCT_Element *elements;
  uint32_t element_count = 0;
 
  if (NULL == input_elements)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("You must specify at least one message ID to check!\n"));
    return;
  }
  if ((NULL == input_session_key) ||
      (0 == strlen (input_session_key)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ (
           "This program needs a session identifier for comparing vectors.\n"));
    return;
  }
  GNUNET_CRYPTO_hash (input_session_key,
                      strlen (input_session_key),
                      &session_key);
  if ((NULL != input_peer_id) &&
      (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_public_key_from_string (input_peer_id,
                                                   strlen (input_peer_id),
                                                   &peer_id.public_key)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Tried to set initiator mode, as peer ID was given. "
            "However, `%s' is not a valid peer identifier.\n"),
         input_peer_id);
    return;
  }
  if (('\'' == *begin) &&
      ('\'' == begin[strlen (begin) - 1]))
  {
    begin[strlen (begin) - 1] = '\0';
    if (strlen (begin) > 0)
      begin++;
  }
  for (end = begin; 0 != *end; end++)
    if (*end == ';')
      element_count++;
  if (0 == element_count)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Need elements to compute the scalarproduct, got none.\n"));
    return;
  }
 
  elements = GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element)
                            * element_count);
 
  for (i = 0; i < element_count; i++)
  {
    struct GNUNET_SCALARPRODUCT_Element element;
    char*separator = NULL;
 
    /* get the length of the current key,value; tuple */
    for (end = begin; *end != ';'; end++)
      if (*end == ',')
        separator = end;
 
    /* final element */
    if ((NULL == separator) ||
        (begin == separator) ||
        (separator == end - 1))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Malformed input, could not parse `%s'\n"),
           begin);
      GNUNET_free (elements);
      return;
    }
    *separator = 0;
    /* read the element's key */
    GNUNET_CRYPTO_hash (begin,
                        strlen (begin),
                        &element.key);
 
    /* read the element's value */
    if (1 !=
        sscanf (separator + 1,
                "%" SCNd64 ";",
                &element.value))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Could not convert `%s' to int64_t.\n"),
           begin);
      GNUNET_free (elements);
      return;
    }
    element.value = GNUNET_htonll (element.value);
    elements[i] = element;
    begin = end + 1;
  }
 
  if (((NULL != input_peer_id) &&
       (NULL == (computation
                   = GNUNET_SCALARPRODUCT_start_computation (cfg,
                                                             &session_key,
                                                             &peer_id,
                                                             elements,
                                                             element_count,
                                                             &requester_callback
                                                             ,
                                                             NULL)))) ||
      ((NULL == input_peer_id) &&
       (NULL == (computation
                   = GNUNET_SCALARPRODUCT_accept_computation (cfg,
                                                              &session_key,
                                                              elements,
                                                              element_count,
                                                              &
                                                              responder_callback,
                                                              NULL)))))
  {
    fprintf (stderr,
             _ ("Failed to initiate computation, were all keys unique?\n"));
    GNUNET_free (elements);
    return;
  }
  GNUNET_free (elements);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  ret = 0;
}

References _, cfg, computation, end, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_htonll(), GNUNET_malloc, GNUNET_OK, GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SCHEDULER_add_shutdown(), input_elements, input_peer_id, input_session_key, GNUNET_SCALARPRODUCT_Element::key, LOG, peer_id, GNUNET_PeerIdentity::public_key, requester_callback(), responder_callback(), ret, session_key, shutdown_task(), and GNUNET_SCALARPRODUCT_Element::value.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function to the scalarproduct client.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 358 of file gnunet-scalarproduct.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('e',
                                 "elements",
                                 "\"key1,val1;key2,val2;...,keyn,valn;\"",
                                 gettext_noop (
                                   "A comma separated list of elements to compare as vector with our remote peer."),
                                 &input_elements),
 
    GNUNET_GETOPT_option_string ('e',
                                 "elements",
                                 "\"key1,val1;key2,val2;...,keyn,valn;\"",
                                 gettext_noop (
                                   "A comma separated list of elements to compare as vector with our remote peer."),
                                 &input_elements),
 
    GNUNET_GETOPT_option_string ('p',
                                 "peer",
                                 "PEERID",
                                 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."),
                                 &input_peer_id),
 
    GNUNET_GETOPT_option_string ('k',
                                 "key",
                                 "TRANSACTION_ID",
                                 gettext_noop (
                                   "Transaction ID shared with peer."),
                                 &input_session_key),
 
    GNUNET_GETOPT_OPTION_END
  };
 
  return (GNUNET_OK ==
          GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                              argc,
                              argv,
                              "gnunet-scalarproduct",
                              gettext_noop (
                                "Calculate the Vectorproduct with a GNUnet peer."),
                              options, &run, NULL)) ? ret : 1;
}

References gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), input_elements, input_peer_id, input_session_key, options, ret, and run().

Here is the call graph for this function:

Variable Documentation

session_key

struct GNUNET_HashCode session_key

static

the session key identifying this computation

Definition at line 43 of file gnunet-scalarproduct.c.

Referenced by GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), requester_callback(), responder_callback(), and run().

peer_id

struct GNUNET_PeerIdentity peer_id

static

PeerID we want to compute a scalar product with.

Definition at line 48 of file gnunet-scalarproduct.c.

Referenced by requester_callback(), and run().

input_peer_id

char* input_peer_id

static

Option -p: destination peer identity for checking message-ids with.

Definition at line 53 of file gnunet-scalarproduct.c.

Referenced by main(), and run().

input_session_key

char* input_session_key

static

Option -p: destination peer identity for checking message-ids with.

Definition at line 58 of file gnunet-scalarproduct.c.

Referenced by main(), and run().

input_elements

char* input_elements

static

Option -e: vector to calculate a scalarproduct with.

Definition at line 63 of file gnunet-scalarproduct.c.

Referenced by main(), and run().

ret

int ret = -1

static

Global return value.

Definition at line 68 of file gnunet-scalarproduct.c.

Referenced by main(), requester_callback(), responder_callback(), run(), and shutdown_task().

computation

struct GNUNET_SCALARPRODUCT_ComputationHandle* computation

static

our Scalarproduct Computation handle

Definition at line 73 of file gnunet-scalarproduct.c.

Referenced by requester_callback(), responder_callback(), run(), and shutdown_task().