/*
This file is part of GNUnet
- (C) 2012, 2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2012, 2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
Boston, MA 02111-1307, USA.
*/
/**
- * @file include/gnunet_regex_service.h
+ * @file regex/regex_api.c
* @brief access regex service to advertise capabilities via regex and discover
* respective peers using matching strings
* @author Maximilian Szengel
*/
struct GNUNET_CLIENT_Connection *client;
- /**
+ /**
* Our configuration.
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
-
+
/**
* Message we're sending to the service.
*/
/**
* We got a response (!?) or disconnect after asking regex
* to do the announcement. Retry.
- *
+ *
* @param cls the 'struct GNUNET_REGEX_Announcement' to retry
* @param msg NULL on disconnect
*/
/**
- * Try sending the announcement request to regex. On
+ * Try sending the announcement request to regex. On
* errors (i.e. regex died), try again.
*
* @param a the announcement to retry
/**
* We got a response (!?) or disconnect after asking regex
* to do the announcement. Retry.
- *
+ *
* @param cls the 'struct GNUNET_REGEX_Announcement' to retry
* @param msg NULL on disconnect
*/
/**
* Announce the given peer under the given regular expression. Does
- * not free resources, must call GNUNET_REGEX_announce_cancel for
+ * not free resources, must call #GNUNET_REGEX_announce_cancel for
* that.
- *
+ *
* @param cfg configuration to use
- * @param id ID to announce as provider of regex. Own ID in most cases.
* @param regex Regular expression to announce.
* @param refresh_delay after what delay should the announcement be repeated?
* @param compression How many characters per edge can we squeeze?
* @return Handle to reuse o free cached resources.
- * Must be freed by calling GNUNET_REGEX_announce_cancel.
+ * Must be freed by calling #GNUNET_REGEX_announce_cancel.
*/
struct GNUNET_REGEX_Announcement *
GNUNET_REGEX_announce (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *id,
const char *regex,
struct GNUNET_TIME_Relative refresh_delay,
uint16_t compression)
slen = strlen (regex) + 1;
if (slen + sizeof (struct AnnounceMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Regex `%s' is too long!\n"),
+ regex);
GNUNET_break (0);
return NULL;
}
a->cfg = cfg;
a->client = GNUNET_CLIENT_connect ("regex", cfg);
if (NULL == a->client)
+ {
+ GNUNET_free (a);
return NULL;
+ }
a->msg.header.type = htons (GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE);
a->msg.header.size = htons (slen + sizeof (struct AnnounceMessage));
a->msg.compression = htons (compression);
a->msg.reserved = htons (0);
a->msg.refresh_delay = GNUNET_TIME_relative_hton (refresh_delay);
- a->msg.pid = *id;
memcpy (&a[1], regex, slen);
retry_announcement (a);
return a;
/**
* Stop announcing the regex specified by the given handle.
- *
+ *
* @param a handle returned by a previous GNUNET_REGEX_announce call.
*/
void
*/
struct GNUNET_CLIENT_Connection *client;
- /**
+ /**
* Our configuration.
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
-
+
/**
* Function to call with results.
*/
GNUNET_REGEX_Found callback;
/**
- * Closure for 'callback'.
+ * Closure for @e callback.
*/
void *callback_cls;
-
+
/**
* Search message to transmit to the service.
*/
- struct SearchMessage msg;
+ struct RegexSearchMessage *msg;
};
/**
* We got a response or disconnect after asking regex
* to do the search. Handle it.
- *
- * @param cls the 'struct GNUNET_REGEX_Search' to retry
+ *
+ * @param cls the `struct GNUNET_REGEX_Search` to retry
* @param msg NULL on disconnect
*/
static void
/**
- * Try sending the search request to regex. On
+ * Try sending the search request to regex. On
* errors (i.e. regex died), try again.
*
* @param s the search to retry
GNUNET_assert (NULL != s->client);
GNUNET_assert (GNUNET_OK ==
GNUNET_CLIENT_transmit_and_get_response (s->client,
- &s->msg.header,
+ &s->msg->header,
GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_YES,
&handle_search_response,
/**
* We got a response or disconnect after asking regex
* to do the search. Handle it.
- *
+ *
* @param cls the 'struct GNUNET_REGEX_Search' to retry
* @param msg NULL on disconnect, otherwise presumably a response
*/
result = (const struct ResultMessage *) msg;
gpl = ntohs (result->get_path_length);
ppl = ntohs (result->put_path_length);
- if (size == (sizeof (struct ResultMessage) +
+ if (size == (sizeof (struct ResultMessage) +
(gpl + ppl) * sizeof (struct GNUNET_PeerIdentity)))
{
const struct GNUNET_PeerIdentity *pid;
s->callback (s->callback_cls,
pid,
&pid[1], gpl,
- &pid[1 + gpl], ppl);
+ &pid[1 + gpl], ppl);
return;
}
}
size_t slen;
slen = strlen (string) + 1;
- s = GNUNET_malloc (sizeof (struct GNUNET_REGEX_Announcement) + slen);
+ s = GNUNET_new (struct GNUNET_REGEX_Search);
s->cfg = cfg;
s->client = GNUNET_CLIENT_connect ("regex", cfg);
if (NULL == s->client)
+ {
+ GNUNET_free (s);
return NULL;
+ }
s->callback = callback;
s->callback_cls = callback_cls;
- s->msg.header.type = htons (GNUNET_MESSAGE_TYPE_REGEX_SEARCH);
- s->msg.header.size = htons (sizeof (struct SearchMessage) + slen);
- memcpy (&s[1], string, slen);
+ s->msg = GNUNET_malloc (sizeof (struct RegexSearchMessage) + slen);
+ s->msg->header.type = htons (GNUNET_MESSAGE_TYPE_REGEX_SEARCH);
+ s->msg->header.size = htons (sizeof (struct RegexSearchMessage) + slen);
+ memcpy (&s->msg[1], string, slen);
retry_search (s);
return s;
}
/**
* Stop search and free all data used by a GNUNET_REGEX_search call.
- *
+ *
* @param s Handle returned by a previous GNUNET_REGEX_search call.
*/
void
GNUNET_REGEX_search_cancel (struct GNUNET_REGEX_Search *s)
{
GNUNET_CLIENT_disconnect (s->client);
+ GNUNET_free (s->msg);
GNUNET_free (s);
}
projects / oweals / gnunet.git / blobdiff