gnunet-service-regex.c File Reference

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

#include "gnunet_pils_service.h"
#include "regex_internal_lib.h"
#include "regex_ipc.h"
#include "gnunet_util_lib.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.
static void	reannounce (void *cls)
	Periodic task to refresh our announcement of the regex.
static int	check_announce (void *cls, const struct AnnounceMessage *am)
	Check ANNOUNCE message.
static void	handle_announce (void *cls, const struct AnnounceMessage *am)
	Handle ANNOUNCE message.
static void	handle_search_result (void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length)
	Handle result, pass it back to the client.
static int	check_search (void *cls, const struct RegexSearchMessage *sm)
	Check SEARCH message.
static void	handle_search (void *cls, const struct RegexSearchMessage *sm)
	Handle SEARCH message.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process regex requests.
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.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "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.

Variables
static struct GNUNET_DHT_Handle *	dht
	Connection to the DHT.
static struct GNUNET_STATISTICS_Handle *	stats
	Handle for doing statistics.
static struct GNUNET_PILS_Handle *	pils
	Handle for pils service.

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 93 of file gnunet-service-regex.c.

{
  if (NULL != dht)
  {
    GNUNET_DHT_disconnect (dht);
    dht = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats,
                               GNUNET_NO);
    stats = NULL;
  }
  if (NULL != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
}

References dht, GNUNET_DHT_disconnect(), GNUNET_NO, GNUNET_PILS_disconnect(), GNUNET_STATISTICS_destroy(), pils, and stats.

Here is the call 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 121 of file gnunet-service-regex.c.

{
  struct ClientEntry *ce = cls;
 
  REGEX_INTERNAL_reannounce (ce->ah);
  ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,
                                                   &reannounce,
                                                   ce);
}

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

Referenced by handle_announce(), and reannounce().

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 am is well-formed

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

{
  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;
}

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

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 163 of file gnunet-service-regex.c.

{
  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,
                                    pils,
                                    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);
}

References ClientEntry::ah, ClientEntry::client, AnnounceMessage::compression, dht, 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(), pils, reannounce(), AnnounceMessage::refresh_delay, ClientEntry::refresh_task, REGEX_INTERNAL_announce(), and stats.

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_DHT_PathElement *  get_path, unsigned int  get_path_length, const struct GNUNET_DHT_PathElement *  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	Length of get_path.
put_path	Path of the put request.
put_path_length	Length of the put_path.

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

{
  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;
  for (unsigned int i = 0; i<get_path_length; i++)
    gp[i + 1] = get_path[i].pred;
  for (unsigned int i = 0; i<put_path_length; i++)
    gp[i + get_path_length + 1] = put_path[i].pred;
  GNUNET_MQ_send (ce->mq,
                  env);
}

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

Referenced by handle_search().

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
sm	the actual message

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

{
  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;
}

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

handle_search()

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

static

Handle SEARCH message.

Parameters

cls	identification of the client
sm	the actual message

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

{
  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);
}

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

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 318 of file gnunet-service-regex.c.

{
  pils = GNUNET_PILS_connect (cfg, NULL, NULL);
  if (NULL == pils)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  dht = GNUNET_DHT_connect (cfg, 1024);
  if (NULL == dht)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
                                 NULL);
  stats = GNUNET_STATISTICS_create ("regex", cfg);
}

References cfg, cleanup_task, dht, GNUNET_DHT_connect(), GNUNET_PILS_connect(), GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), pils, and stats.

Here is the call 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 351 of file gnunet-service-regex.c.

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

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

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 372 of file gnunet-service-regex.c.

{
  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);
}

References ClientEntry::ah, GNUNET_free, GNUNET_SCHEDULER_cancel(), ClientEntry::refresh_task, REGEX_INTERNAL_announce_cancel(), REGEX_INTERNAL_search_cancel(), and ClientEntry::sh.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"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.

Variable Documentation

dht

struct GNUNET_DHT_Handle* dht

static

Connection to the DHT.

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

Referenced by cleanup_task(), handle_announce(), handle_search(), and run().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle for doing statistics.

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

Referenced by cleanup_task(), handle_announce(), handle_search(), and run().

pils

struct GNUNET_PILS_Handle* pils

static

Handle for pils service.

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

Referenced by cleanup_task(), handle_announce(), and run().