gnunet-service-regex.c File Reference

service to advertise capabilities described as regex and to lookup capabilities by regex More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "regex_internal_lib.h"
#include "regex_ipc.h"

Include dependency graph for gnunet-service-regex.c:

Go to the source code of this file.

Data Structures
struct	ClientEntry
	Information about one of our clients. More...

Functions
static void	cleanup_task (void *cls)
	Task run during shutdown. More...
static void	reannounce (void *cls)
	Periodic task to refresh our announcement of the regex. More...
static int	check_announce (void *cls, const struct AnnounceMessage *am)
	Check ANNOUNCE message. More...
static void	handle_announce (void *cls, const struct AnnounceMessage *am)
	Handle ANNOUNCE message. More...
static void	handle_search_result (void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length)
	Handle result, pass it back to the client. More...
static int	check_search (void *cls, const struct RegexSearchMessage *sm)
	Check SEARCH message. More...
static void	handle_search (void *cls, const struct RegexSearchMessage *sm)
	Handle SEARCH message. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process regex requests. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service. More...
	GNUNET_SERVICE_MAIN ("regex", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(announce, GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE, struct AnnounceMessage, NULL), GNUNET_MQ_hd_var_size(search, GNUNET_MESSAGE_TYPE_REGEX_SEARCH, struct RegexSearchMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_DHT_Handle *	dht
	Connection to the DHT. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle for doing statistics. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey *	my_private_key
	Private key for this peer. More...

Detailed Description

service to advertise capabilities described as regex and to lookup capabilities by regex

Author

Christian Grothoff

Definition in file gnunet-service-regex.c.

Function Documentation

cleanup_task()

static void cleanup_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 91 of file gnunet-service-regex.c.

References GNUNET_DHT_disconnect(), GNUNET_free, GNUNET_NO, and GNUNET_STATISTICS_destroy().

Referenced by run().

{
  GNUNET_DHT_disconnect(dht);
  dht = NULL;
  GNUNET_STATISTICS_destroy(stats,
                            GNUNET_NO);
  stats = NULL;
  GNUNET_free(my_private_key);
  my_private_key = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

reannounce()

static void reannounce ( void *  cls )

static

Periodic task to refresh our announcement of the regex.

Parameters

cls	the struct ClientEntry * of the client that triggered the announcement

Definition at line 110 of file gnunet-service-regex.c.

References ClientEntry::ah, ClientEntry::frequency, GNUNET_SCHEDULER_add_delayed(), ClientEntry::refresh_task, and REGEX_INTERNAL_reannounce().

Referenced by handle_announce().

{
  struct ClientEntry *ce = cls;

  REGEX_INTERNAL_reannounce(ce->ah);
  ce->refresh_task = GNUNET_SCHEDULER_add_delayed(ce->frequency,
                                                  &reannounce,
                                                  ce);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_announce()

static int check_announce ( void *  cls, const struct AnnounceMessage *  am  )

static

Check ANNOUNCE message.

Parameters

cls	identification of the client
am	the actual message

Returns

GNUNET_OK if is well-formed

Definition at line 129 of file gnunet-service-regex.c.

References ClientEntry::ah, GNUNET_break, GNUNET_MQ_check_zero_termination, GNUNET_OK, and GNUNET_SYSERR.

{
  struct ClientEntry *ce = cls;

  GNUNET_MQ_check_zero_termination(am);
  if (NULL != ce->ah)
    {
      /* only one announcement per client allowed */
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_announce()

static void handle_announce ( void *  cls, const struct AnnounceMessage *  am  )

static

Handle ANNOUNCE message.

Parameters

cls	identification of the client
am	the actual message

Definition at line 152 of file gnunet-service-regex.c.

References ClientEntry::ah, ClientEntry::client, AnnounceMessage::compression, ClientEntry::frequency, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_ntoh(), reannounce(), AnnounceMessage::refresh_delay, ClientEntry::refresh_task, and REGEX_INTERNAL_announce().

{
  struct ClientEntry *ce = cls;
  const char *regex;

  regex = (const char *)&am[1];
  ce->frequency = GNUNET_TIME_relative_ntoh(am->refresh_delay);
  ce->refresh_task = GNUNET_SCHEDULER_add_delayed(ce->frequency,
                                                  &reannounce,
                                                  ce);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Starting to announce regex `%s' every %s\n",
             regex,
             GNUNET_STRINGS_relative_time_to_string(ce->frequency,
                                                    GNUNET_NO));
  ce->ah = REGEX_INTERNAL_announce(dht,
                                   my_private_key,
                                   regex,
                                   ntohs(am->compression),
                                   stats);
  if (NULL == ce->ah)
    {
      GNUNET_break(0);
      GNUNET_SCHEDULER_cancel(ce->refresh_task);
      ce->refresh_task = NULL;
      GNUNET_SERVICE_client_drop(ce->client);
      return;
    }
  GNUNET_SERVICE_client_continue(ce->client);
}

Here is the call graph for this function:

handle_search_result()

static void handle_search_result ( void *  cls, const struct GNUNET_PeerIdentity *  id, const struct GNUNET_PeerIdentity *  get_path, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  put_path, unsigned int  put_path_length  )

static

Handle result, pass it back to the client.

Parameters

cls	the struct ClientEntry of the client searching
id	Peer providing a regex that matches the string.
get_path	Path of the get request.
get_path_length	Lenght of get_path.
put_path	Path of the put request.
put_path_length	Length of the put_path.

Definition at line 196 of file gnunet-service-regex.c.

References env, ResultMessage::get_path_length, GNUNET_break, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_REGEX_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), ResultMessage::id, id, ClientEntry::mq, ResultMessage::put_path_length, result, and size.

Referenced by handle_search().

{
  struct ClientEntry *ce = cls;
  struct GNUNET_MQ_Envelope *env;
  struct ResultMessage *result;
  struct GNUNET_PeerIdentity *gp;
  uint16_t size;

  if ((get_path_length >= 65536) ||
      (put_path_length >= 65536) ||
      ((get_path_length + put_path_length) * sizeof(struct GNUNET_PeerIdentity))
      + sizeof(struct ResultMessage) >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  size = (get_path_length + put_path_length) * sizeof(struct GNUNET_PeerIdentity);
  env = GNUNET_MQ_msg_extra(result,
                            size,
                            GNUNET_MESSAGE_TYPE_REGEX_RESULT);
  result->get_path_length = htons((uint16_t)get_path_length);
  result->put_path_length = htons((uint16_t)put_path_length);
  result->id = *id;
  gp = &result->id;
  GNUNET_memcpy(&gp[1],
                get_path,
                get_path_length * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_memcpy(&gp[1 + get_path_length],
                put_path,
                put_path_length * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_MQ_send(ce->mq,
                 env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_search()

static int check_search ( void *  cls, const struct RegexSearchMessage *  sm  )

static

Check SEARCH message.

Parameters

cls	identification of the client
message	the actual message

Definition at line 243 of file gnunet-service-regex.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, RegexSearchMessage::header, ClientEntry::sh, size, and GNUNET_MessageHeader::size.

{
  struct ClientEntry *ce = cls;
  const char *string;
  uint16_t size;

  size = ntohs(sm->header.size) - sizeof(*sm);
  string = (const char *)&sm[1];
  if ('\0' != string[size - 1])
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  if (NULL != ce->sh)
    {
      /* only one search allowed per client */
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

handle_search()

static void handle_search ( void *  cls, const struct RegexSearchMessage *  sm  )

static

Handle SEARCH message.

Parameters

cls	identification of the client
message	the actual message

Definition at line 274 of file gnunet-service-regex.c.

References ClientEntry::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), handle_search_result(), REGEX_INTERNAL_search(), and ClientEntry::sh.

{
  struct ClientEntry *ce = cls;
  const char *string;

  string = (const char *)&sm[1];
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Starting to search for `%s'\n",
             string);
  ce->sh = REGEX_INTERNAL_search(dht,
                                 string,
                                 &handle_search_result,
                                 ce,
                                 stats);
  if (NULL == ce->sh)
    {
      GNUNET_break(0);
      GNUNET_SERVICE_client_drop(ce->client);
      return;
    }
  GNUNET_SERVICE_client_continue(ce->client);
}

Here is the call graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  service  )

static

Process regex requests.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 307 of file gnunet-service-regex.c.

References cleanup_task(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_DHT_connect(), GNUNET_free, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), and GNUNET_STATISTICS_create().

Referenced by client_disconnect_cb().

{
  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
  if (NULL == my_private_key)
    {
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  dht = GNUNET_DHT_connect(cfg, 1024);
  if (NULL == dht)
    {
      GNUNET_free(my_private_key);
      my_private_key = NULL;
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  GNUNET_SCHEDULER_add_shutdown(&cleanup_task,
                                NULL);
  stats = GNUNET_STATISTICS_create("regex", cfg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_cb()

static void* client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, struct GNUNET_MQ_Handle *  mq  )

static

Callback called when a client connects to the service.

Parameters

cls	closure for the service
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

c

Definition at line 340 of file gnunet-service-regex.c.

References ClientEntry::client, GNUNET_new, and ClientEntry::mq.

Referenced by client_disconnect_cb().

{
  struct ClientEntry *ce;

  ce = GNUNET_new(struct ClientEntry);
  ce->client = c;
  ce->mq = mq;
  return ce;
}

Here is the caller graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, void *  internal_cls  )

static

Callback called when a client disconnected from the service.

Parameters

cls	closure for the service
c	the client that disconnected
internal_cls	should be equal to c

Definition at line 361 of file gnunet-service-regex.c.

References ClientEntry::ah, client_connect_cb(), GNUNET_free, GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE, GNUNET_MESSAGE_TYPE_REGEX_SEARCH, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, ClientEntry::refresh_task, REGEX_INTERNAL_announce_cancel(), REGEX_INTERNAL_search_cancel(), run(), and ClientEntry::sh.

{
  struct ClientEntry *ce = internal_cls;

  if (NULL != ce->refresh_task)
    {
      GNUNET_SCHEDULER_cancel(ce->refresh_task);
      ce->refresh_task = NULL;
    }
  if (NULL != ce->ah)
    {
      REGEX_INTERNAL_announce_cancel(ce->ah);
      ce->ah = NULL;
    }
  if (NULL != ce->sh)
    {
      REGEX_INTERNAL_search_cancel(ce->sh);
      ce->sh = NULL;
    }
  GNUNET_free(ce);
}

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"regex"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(announce, GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE, struct AnnounceMessage, NULL)	,
		GNUNET_MQ_hd_var_size(search, GNUNET_MESSAGE_TYPE_REGEX_SEARCH, struct RegexSearchMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Referenced by client_disconnect_cb().

Here is the caller graph for this function:

Variable Documentation

dht

struct GNUNET_DHT_Handle* dht

static

Connection to the DHT.

Definition at line 72 of file gnunet-service-regex.c.

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle for doing statistics.

Definition at line 77 of file gnunet-service-regex.c.

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key

static

Private key for this peer.

Definition at line 82 of file gnunet-service-regex.c.