/**
* Transmit the next pending message, called by notify_transmit_ready
*
* @param cls the DHT handle
* @param size number of bytes available in @a buf for transmission
* @param buf where to copy messages for the service
* @return number of bytes written to @a buf
*/
static size_t
transmit_pending (void *cls,
size_t size,
void *buf)
{
struct GNUNET_DHT_Handle *handle = cls;
struct PendingMessage *head;
size_t tsize;
handle->th = NULL;
if (NULL == buf)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmission to DHT service failed! Reconnecting!\n");
do_disconnect (handle);
return 0;
}
if (NULL == (head = handle->pending_head))
return 0;
tsize = ntohs (head->msg->size);
if (size < tsize)
{
process_pending_messages (handle);
return 0;
}
memcpy (buf, head->msg, tsize);
GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
head);
head->in_pending_queue = GNUNET_NO;
if (NULL != head->cont)
{
head->cont (head->cont_cls, NULL);
head->cont = NULL;
head->cont_cls = NULL;
}
if (GNUNET_YES == head->free_on_send)
GNUNET_free (head);
process_pending_messages (handle);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Forwarded request of %u bytes to DHT service\n", (unsigned int) tsize);
if (GNUNET_NO == handle->in_receive)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting to process replies from DHT\n");
handle->in_receive = GNUNET_YES;
GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle,
GNUNET_TIME_UNIT_FOREVER_REL);
}
return tsize;
}
/**
* Callback called as a result of issuing a GNUNET_SERVER_notify_transmit_ready
* request. A ClientList is passed as closure, take the head of the list
* and copy it into buf, which has the result of sending the message to the
* client.
*
* @param cls closure to this call
* @param size maximum number of bytes available to send
* @param buf where to copy the actual message to
*
* @return the number of bytes actually copied, 0 indicates failure
*/
static size_t
send_reply_to_client (void *cls, size_t size, void *buf)
{
struct ClientList *client = cls;
char *cbuf = buf;
struct PendingMessage *reply;
size_t off;
size_t msize;
client->transmit_handle = NULL;
if (buf == NULL)
{
/* client disconnected */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client %p disconnected, pending messages will be discarded\n",
client->client_handle);
return 0;
}
off = 0;
while ((NULL != (reply = client->pending_head)) &&
(size >= off + (msize = ntohs (reply->msg->size))))
{
GNUNET_CONTAINER_DLL_remove (client->pending_head, client->pending_tail,
reply);
memcpy (&cbuf[off], reply->msg, msize);
GNUNET_free (reply);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting %u bytes to client %p\n",
msize, client->client_handle);
off += msize;
}
process_pending_messages (client);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitted %u/%u bytes to client %p\n",
(unsigned int) off, (unsigned int) size, client->client_handle);
return off;
}
/**
* Stop monitoring.
*
* @param handle The handle to the monitor request returned by monitor_start.
*
* On return get_handle will no longer be valid, caller must not use again!!!
*/
void
GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *handle)
{
struct GNUNET_DHT_MonitorStartStopMessage *m;
struct PendingMessage *pending;
GNUNET_CONTAINER_DLL_remove (handle->dht_handle->monitor_head,
handle->dht_handle->monitor_tail,
handle);
pending = GNUNET_malloc (sizeof (struct GNUNET_DHT_MonitorStartStopMessage) +
sizeof (struct PendingMessage));
m = (struct GNUNET_DHT_MonitorStartStopMessage *) &pending[1];
pending->msg = &m->header;
pending->handle = handle->dht_handle;
pending->free_on_send = GNUNET_YES;
m->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP);
m->header.size = htons (sizeof (struct GNUNET_DHT_MonitorStartStopMessage));
m->type = htonl(handle->type);
m->get = htons(NULL != handle->get_cb);
m->get_resp = htons(NULL != handle->get_resp_cb);
m->put = htons(NULL != handle->put_cb);
if (NULL != handle->key) {
m->filter_key = htons(1);
memcpy (&m->key, handle->key, sizeof(GNUNET_HashCode));
}
GNUNET_CONTAINER_DLL_insert (handle->dht_handle->pending_head,
handle->dht_handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
process_pending_messages (handle->dht_handle);
GNUNET_free_non_null (handle->key);
GNUNET_free (handle);
}
/**
* Add a PendingMessage to the clients list of messages to be sent
*
* @param client the active client to send the message to
* @param pending_message the actual message to send
*/
static void
add_pending_message (struct ClientList *client,
struct PendingMessage *pending_message)
{
GNUNET_CONTAINER_DLL_insert_tail (client->pending_head, client->pending_tail,
pending_message);
process_pending_messages (client);
}
/**
* Perform a PUT operation storing data in the DHT. FIXME: we should
* change the protocol to get a confirmation for the PUT from the DHT
* and call 'cont' only after getting the confirmation; otherwise, the
* client has no good way of telling if the 'PUT' message actually got
* to the DHT service!
*
* @param handle handle to DHT service
* @param key the key to store under
* @param desired_replication_level estimate of how many
* nearest peers this request should reach
* @param options routing options for this message
* @param type type of the value
* @param size number of bytes in data; must be less than 64k
* @param data the data to store
* @param exp desired expiration time for the value
* @param timeout how long to wait for transmission of this request
* @param cont continuation to call when done (transmitting request to service)
* You must not call #GNUNET_DHT_disconnect in this continuation
* @param cont_cls closure for @a cont
*/
struct GNUNET_DHT_PutHandle *
GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
const struct GNUNET_HashCode * key,
uint32_t desired_replication_level,
enum GNUNET_DHT_RouteOption options,
enum GNUNET_BLOCK_Type type, size_t size,
const void *data,
struct GNUNET_TIME_Absolute exp,
struct GNUNET_TIME_Relative timeout,
GNUNET_DHT_PutContinuation cont,
void *cont_cls)
{
struct GNUNET_DHT_ClientPutMessage *put_msg;
size_t msize;
struct PendingMessage *pending;
struct GNUNET_DHT_PutHandle *ph;
msize = sizeof (struct GNUNET_DHT_ClientPutMessage) + size;
if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
(size >= GNUNET_SERVER_MAX_MESSAGE_SIZE))
{
GNUNET_break (0);
return NULL;
}
ph = GNUNET_new (struct GNUNET_DHT_PutHandle);
ph->dht_handle = handle;
ph->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout, &timeout_put_request, ph);
ph->cont = cont;
ph->cont_cls = cont_cls;
ph->unique_id = ++handle->uid_gen;
pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);
ph->pending = pending;
put_msg = (struct GNUNET_DHT_ClientPutMessage *) &pending[1];
pending->msg = &put_msg->header;
pending->handle = handle;
pending->cont = &mark_put_message_gone;
pending->cont_cls = ph;
pending->free_on_send = GNUNET_YES;
put_msg->header.size = htons (msize);
put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);
put_msg->type = htonl (type);
put_msg->options = htonl ((uint32_t) options);
put_msg->desired_replication_level = htonl (desired_replication_level);
put_msg->unique_id = ph->unique_id;
put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
put_msg->key = *key;
memcpy (&put_msg[1], data, size);
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
GNUNET_CONTAINER_DLL_insert_tail (handle->put_head,
handle->put_tail,
ph);
process_pending_messages (handle);
return ph;
}
/**
* Reconnect to GNS service.
*
* @param handle the handle to the GNS service
*/
static void
reconnect (struct GNUNET_GNS_Handle *handle)
{
GNUNET_assert (NULL == handle->client);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Trying to connect to GNS\n");
handle->client = GNUNET_CLIENT_connect ("gns", handle->cfg);
GNUNET_assert (NULL != handle->client);
process_pending_messages (handle);
}
/**
* Perform an asynchronous GET operation on the DHT identified. See
* also #GNUNET_BLOCK_evaluate.
*
* @param handle handle to the DHT service
* @param type expected type of the response object
* @param key the key to look up
* @param desired_replication_level estimate of how many
nearest peers this request should reach
* @param options routing options for this message
* @param xquery extended query data (can be NULL, depending on type)
* @param xquery_size number of bytes in @a xquery
* @param iter function to call on each result
* @param iter_cls closure for iter
* @return handle to stop the async get
*/
struct GNUNET_DHT_GetHandle *
GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode * key,
uint32_t desired_replication_level,
enum GNUNET_DHT_RouteOption options, const void *xquery,
size_t xquery_size, GNUNET_DHT_GetIterator iter,
void *iter_cls)
{
struct GNUNET_DHT_ClientGetMessage *get_msg;
struct GNUNET_DHT_GetHandle *get_handle;
size_t msize;
struct PendingMessage *pending;
msize = sizeof (struct GNUNET_DHT_ClientGetMessage) + xquery_size;
if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
(xquery_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE))
{
GNUNET_break (0);
return NULL;
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending query for %s to DHT %p\n",
GNUNET_h2s (key), handle);
pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);
get_msg = (struct GNUNET_DHT_ClientGetMessage *) &pending[1];
pending->msg = &get_msg->header;
pending->handle = handle;
pending->free_on_send = GNUNET_NO;
get_msg->header.size = htons (msize);
get_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);
get_msg->options = htonl ((uint32_t) options);
get_msg->desired_replication_level = htonl (desired_replication_level);
get_msg->type = htonl (type);
get_msg->key = *key;
get_msg->unique_id = ++handle->uid_gen;
memcpy (&get_msg[1], xquery, xquery_size);
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
get_handle = GNUNET_new (struct GNUNET_DHT_GetHandle);
get_handle->key = *key;
get_handle->dht_handle = handle;
get_handle->iter = iter;
get_handle->iter_cls = iter_cls;
get_handle->message = pending;
get_handle->unique_id = get_msg->unique_id;
GNUNET_CONTAINER_multihashmap_put (handle->active_requests,
&get_handle->key,
get_handle,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
process_pending_messages (handle);
return get_handle;
}
/**
* Start monitoring the local DHT service.
*
* @param handle Handle to the DHT service.
* @param type Type of blocks that are of interest.
* @param key Key of data of interest, NULL for all.
* @param get_cb Callback to process monitored get messages.
* @param get_resp_cb Callback to process monitored get response messages.
* @param put_cb Callback to process monitored put messages.
* @param cb_cls Closure for cb.
*
* @return Handle to stop monitoring.
*/
struct GNUNET_DHT_MonitorHandle *
GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle,
enum GNUNET_BLOCK_Type type,
const GNUNET_HashCode *key,
GNUNET_DHT_MonitorGetCB get_cb,
GNUNET_DHT_MonitorGetRespCB get_resp_cb,
GNUNET_DHT_MonitorPutCB put_cb,
void *cb_cls)
{
struct GNUNET_DHT_MonitorHandle *h;
struct GNUNET_DHT_MonitorStartStopMessage *m;
struct PendingMessage *pending;
h = GNUNET_malloc (sizeof (struct GNUNET_DHT_MonitorHandle));
GNUNET_CONTAINER_DLL_insert(handle->monitor_head, handle->monitor_tail, h);
h->get_cb = get_cb;
h->get_resp_cb = get_resp_cb;
h->put_cb = put_cb;
h->cb_cls = cb_cls;
h->type = type;
h->dht_handle = handle;
if (NULL != key)
{
h->key = GNUNET_malloc (sizeof(GNUNET_HashCode));
memcpy (h->key, key, sizeof(GNUNET_HashCode));
}
pending = GNUNET_malloc (sizeof (struct GNUNET_DHT_MonitorStartStopMessage) +
sizeof (struct PendingMessage));
m = (struct GNUNET_DHT_MonitorStartStopMessage *) &pending[1];
pending->msg = &m->header;
pending->handle = handle;
pending->free_on_send = GNUNET_YES;
m->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_MONITOR_START);
m->header.size = htons (sizeof (struct GNUNET_DHT_MonitorStartStopMessage));
m->type = htonl(type);
m->get = htons(NULL != get_cb);
m->get_resp = htons(NULL != get_resp_cb);
m->put = htons(NULL != put_cb);
if (NULL != key) {
m->filter_key = htons(1);
memcpy (&m->key, key, sizeof(GNUNET_HashCode));
}
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
process_pending_messages (handle);
return h;
}
/**
* Stop async DHT-get.
*
* @param get_handle handle to the GET operation to stop
*/
void
GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
{
struct GNUNET_DHT_Handle *handle;
const struct GNUNET_DHT_ClientGetMessage *get_msg;
struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
struct PendingMessage *pending;
handle = get_handle->message->handle;
get_msg =
(const struct GNUNET_DHT_ClientGetMessage *) get_handle->message->msg;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Sending STOP for %s to DHT via %p\n",
GNUNET_h2s (&get_msg->key), handle);
/* generate STOP */
pending =
GNUNET_malloc (sizeof (struct PendingMessage) +
sizeof (struct GNUNET_DHT_ClientGetStopMessage));
stop_msg = (struct GNUNET_DHT_ClientGetStopMessage *) &pending[1];
pending->msg = &stop_msg->header;
pending->handle = handle;
pending->free_on_send = GNUNET_YES;
stop_msg->header.size =
htons (sizeof (struct GNUNET_DHT_ClientGetStopMessage));
stop_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
stop_msg->reserved = htonl (0);
stop_msg->unique_id = get_msg->unique_id;
stop_msg->key = get_msg->key;
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
/* remove 'GET' from active status */
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,
&get_handle->key,
get_handle));
if (GNUNET_YES == get_handle->message->in_pending_queue)
{
GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
get_handle->message);
get_handle->message->in_pending_queue = GNUNET_NO;
}
GNUNET_free (get_handle->message);
GNUNET_array_grow (get_handle->seen_results,
get_handle->seen_results_end,
0);
GNUNET_free (get_handle);
process_pending_messages (handle);
}
/**
* Perform an authority lookup for a given name.
*
* @param handle handle to the GNS service
* @param name the name to look up authority for
* @param proc function to call on result
* @param proc_cls closure for processor
* @return handle to the operation
*/
struct GNUNET_GNS_GetAuthRequest*
GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle,
const char *name,
GNUNET_GNS_GetAuthResultProcessor proc,
void *proc_cls)
{
struct GNUNET_GNS_ClientGetAuthMessage *get_auth_msg;
struct GNUNET_GNS_GetAuthRequest *gar;
size_t msize;
struct PendingMessage *pending;
if (NULL == name)
{
GNUNET_break (0);
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Trying to look up authority for %s in GNS\n", name);
msize = sizeof (struct GNUNET_GNS_ClientGetAuthMessage) + strlen (name) + 1;
if (msize > UINT16_MAX)
{
GNUNET_break (0);
return NULL;
}
gar = GNUNET_malloc (sizeof (struct GNUNET_GNS_GetAuthRequest) +
sizeof (struct PendingMessage) + msize);
gar->gns_handle = handle;
gar->auth_proc = proc;
gar->proc_cls = proc_cls;
gar->r_id = handle->r_id_gen++;
GNUNET_CONTAINER_DLL_insert_tail (handle->get_auth_head,
handle->get_auth_tail, gar);
pending = (struct PendingMessage *) &gar[1];
pending->size = msize;
pending->r_id = gar->r_id;
get_auth_msg = (struct GNUNET_GNS_ClientGetAuthMessage *) &pending[1];
get_auth_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_GET_AUTH);
get_auth_msg->header.size = htons (msize);
get_auth_msg->id = htonl (gar->r_id);
memcpy (&get_auth_msg[1], name, strlen (name) + 1);
GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head,
handle->pending_tail,
pending);
process_pending_messages (handle);
return gar;
}
/**
* Try reconnecting to the dht service.
*
* @param cls a `struct GNUNET_DHT_Handle`
* @param tc scheduler context
*/
static void
try_reconnect (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_DHT_Handle *handle = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
handle->retry_time = GNUNET_TIME_STD_BACKOFF (handle->retry_time);
handle->reconnect_task = NULL;
if (GNUNET_YES != try_connect (handle))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
return;
}
GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests,
&add_request_to_pending, handle);
process_pending_messages (handle);
}
/**
* Tell the DHT not to return any of the following known results
* to this client.
*
* @param get_handle get operation for which results should be filtered
* @param num_results number of results to be blocked that are
* provided in this call (size of the @a results array)
* @param results array of hash codes over the 'data' of the results
* to be blocked
*/
void
GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle,
unsigned int num_results,
const struct GNUNET_HashCode *results)
{
unsigned int needed;
needed = get_handle->seen_results_end + num_results;
if (needed > get_handle->seen_results_size)
GNUNET_array_grow (get_handle->seen_results,
get_handle->seen_results_size,
needed);
memcpy (&get_handle->seen_results[get_handle->seen_results_end],
results,
num_results * sizeof (struct GNUNET_HashCode));
get_handle->seen_results_end += num_results;
queue_filter_messages (get_handle);
process_pending_messages (get_handle->dht_handle);
}
/**
* Transmit the next pending message, called by notify_transmit_ready
*
* @param cls the closure
* @param size size of pending data
* @param buf buffer with pending data
* @return size data transmitted
*/
static size_t
transmit_pending (void *cls, size_t size, void *buf)
{
struct GNUNET_GNS_Handle *handle = cls;
char *cbuf = buf;
struct PendingMessage *p;
size_t tsize;
handle->th = NULL;
if ((0 == size) || (NULL == buf))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmission to GNS service failed!\n");
force_reconnect (handle);
return 0;
}
if (NULL == (p = handle->pending_head))
return 0;
tsize = 0;
while ((NULL != (p = handle->pending_head)) && (p->size <= size))
{
memcpy (&cbuf[tsize], &p[1], p->size);
tsize += p->size;
size -= p->size;
p->transmitted = GNUNET_YES;
GNUNET_CONTAINER_DLL_remove (handle->pending_head,
handle->pending_tail,
p);
if (GNUNET_YES != handle->in_receive)
{
GNUNET_CLIENT_receive (handle->client, &process_message, handle,
GNUNET_TIME_UNIT_FOREVER_REL);
handle->in_receive = GNUNET_YES;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending %u bytes\n",
(unsigned int) tsize);
process_pending_messages (handle);
return tsize;
}
/**
* Try reconnecting to the dht service.
*
* @param cls GNUNET_DHT_Handle
* @param tc scheduler context
*/
static void
try_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_DHT_Handle *handle = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (handle->retry_time.rel_value < GNUNET_CONSTANTS_SERVICE_RETRY.rel_value)
handle->retry_time = GNUNET_CONSTANTS_SERVICE_RETRY;
else
handle->retry_time = GNUNET_TIME_relative_multiply (handle->retry_time, 2);
if (handle->retry_time.rel_value > GNUNET_CONSTANTS_SERVICE_TIMEOUT.rel_value)
handle->retry_time = GNUNET_CONSTANTS_SERVICE_TIMEOUT;
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_YES != try_connect (handle))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
return;
}
GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests,
&add_request_to_pending, handle);
process_pending_messages (handle);
}
/**
* Perform a name shortening operation on the GNS.
*
* @param handle handle to the GNS service
* @param name the name to look up
* @param private_zone the public zone of the private zone
* @param shorten_zone the public zone of the shorten zone
* @param zone the zone to start the resolution in
* @param proc function to call on result
* @param proc_cls closure for processor
* @return handle to the operation
*/
struct GNUNET_GNS_ShortenRequest*
GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle,
const char *name,
struct GNUNET_CRYPTO_ShortHashCode *private_zone,
struct GNUNET_CRYPTO_ShortHashCode *shorten_zone,
struct GNUNET_CRYPTO_ShortHashCode *zone,
GNUNET_GNS_ShortenResultProcessor proc,
void *proc_cls)
{
/* IPC to shorten gns names, return shorten_handle */
struct GNUNET_GNS_ClientShortenMessage *shorten_msg;
struct GNUNET_GNS_ShortenRequest *sr;
size_t msize;
struct PendingMessage *pending;
if (NULL == name)
{
GNUNET_break (0);
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to shorten `%s' in GNS\n", name);
msize = sizeof (struct GNUNET_GNS_ClientShortenMessage) + strlen (name) + 1;
if (msize > UINT16_MAX)
{
GNUNET_break (0);
return NULL;
}
sr = GNUNET_malloc (sizeof (struct GNUNET_GNS_ShortenRequest) +
sizeof (struct PendingMessage) + msize);
sr->gns_handle = handle;
sr->shorten_proc = proc;
sr->proc_cls = proc_cls;
sr->r_id = handle->r_id_gen++;
GNUNET_CONTAINER_DLL_insert_tail (handle->shorten_head,
handle->shorten_tail, sr);
pending = (struct PendingMessage *)&sr[1];
pending->size = msize;
pending->r_id = sr->r_id;
shorten_msg = (struct GNUNET_GNS_ClientShortenMessage *) &pending[1];
shorten_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_SHORTEN);
shorten_msg->header.size = htons ((uint16_t) msize);
shorten_msg->id = htonl (sr->r_id);
shorten_msg->private_zone = *private_zone;
shorten_msg->shorten_zone = *shorten_zone;
if (NULL != zone)
{
shorten_msg->use_default_zone = htonl (GNUNET_NO);
memcpy (&shorten_msg->zone, zone,
sizeof (struct GNUNET_CRYPTO_ShortHashCode));
}
else
{
shorten_msg->use_default_zone = htonl (GNUNET_YES);
memset (&shorten_msg->zone, 0, sizeof (struct GNUNET_CRYPTO_ShortHashCode));
}
memcpy (&shorten_msg[1], name, strlen (name) + 1);
GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head, handle->pending_tail,
pending);
process_pending_messages (handle);
return sr;
}
/**
* Perform an asynchronous Lookup operation on the GNS.
*
* @param handle handle to the GNS service
* @param name the name to look up
* @param zone the zone to start the resolution in
* @param type the record type to look up
* @param only_cached GNUNET_YES to only check locally not DHT for performance
* @param shorten_key the private key of the shorten zone (can be NULL)
* @param proc processor to call on result
* @param proc_cls closure for processor
* @return handle to the get request
*/
struct GNUNET_GNS_LookupRequest*
GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle,
const char *name,
struct GNUNET_CRYPTO_ShortHashCode *zone,
enum GNUNET_GNS_RecordType type,
int only_cached,
struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key,
GNUNET_GNS_LookupResultProcessor proc,
void *proc_cls)
{
/* IPC to shorten gns names, return shorten_handle */
struct GNUNET_GNS_ClientLookupMessage *lookup_msg;
struct GNUNET_GNS_LookupRequest *lr;
size_t msize;
struct PendingMessage *pending;
struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey_enc;
size_t key_len;
char* pkey_tmp;
if (NULL == name)
{
GNUNET_break (0);
return NULL;
}
if (NULL != shorten_key)
{
pkey_enc = GNUNET_CRYPTO_rsa_encode_key (shorten_key);
GNUNET_assert (pkey_enc != NULL);
key_len = ntohs (pkey_enc->len);
}
else
{
pkey_enc = NULL;
key_len = 0;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Trying to lookup `%s' in GNS\n",
name);
msize = sizeof (struct GNUNET_GNS_ClientLookupMessage)
+ key_len + strlen (name) + 1;
if (msize > UINT16_MAX)
{
GNUNET_break (0);
GNUNET_free (pkey_enc);
return NULL;
}
lr = GNUNET_malloc (sizeof (struct GNUNET_GNS_LookupRequest) +
sizeof (struct PendingMessage) + msize);
lr->gns_handle = handle;
lr->lookup_proc = proc;
lr->proc_cls = proc_cls;
lr->r_id = handle->r_id_gen++;
pending = (struct PendingMessage *)&lr[1];
pending->size = msize;
pending->r_id = lr->r_id;
GNUNET_CONTAINER_DLL_insert_tail (handle->lookup_head,
handle->lookup_tail, lr);
lookup_msg = (struct GNUNET_GNS_ClientLookupMessage *) &pending[1];
lookup_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_LOOKUP);
lookup_msg->header.size = htons (msize);
lookup_msg->id = htonl (lr->r_id);
lookup_msg->only_cached = htonl (only_cached);
if (NULL != zone)
{
lookup_msg->use_default_zone = htonl (GNUNET_NO);
memcpy (&lookup_msg->zone, zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode));
}
else
{
lookup_msg->use_default_zone = htonl (GNUNET_YES);
memset (&lookup_msg->zone, 0, sizeof(struct GNUNET_CRYPTO_ShortHashCode));
}
lookup_msg->type = htonl (type);
pkey_tmp = (char *) &lookup_msg[1];
if (pkey_enc != NULL)
{
lookup_msg->have_key = htonl (GNUNET_YES);
memcpy (pkey_tmp, pkey_enc, key_len);
}
else
lookup_msg->have_key = htonl (GNUNET_NO);
GNUNET_free_non_null (pkey_enc);
memcpy (&pkey_tmp[key_len], name, strlen (name) + 1);
GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head,
handle->pending_tail,
pending);
process_pending_messages (handle);
return lr;
}
