set_api.c File Reference

api for the set service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_set_service.h"
#include "set.h"

Include dependency graph for set_api.c:

Go to the source code of this file.

Data Structures
struct	SetCopyRequest
struct	GNUNET_SET_Handle
	Opaque handle to a set. More...
struct	GNUNET_SET_Request
	Handle for a set operation request from another peer. More...
struct	GNUNET_SET_OperationHandle
	Handle to an operation. More...
struct	GNUNET_SET_ListenHandle
	Opaque handle to a listen operation. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "set-api", __VA_ARGS__)

Functions
static struct GNUNET_SET_Handle *	create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op, const uint32_t *cookie)
	FIXME. More...
static void	handle_copy_lazy (void *cls, const struct GNUNET_SET_CopyLazyResponseMessage *msg)
	Handle element for iteration over the set. More...
static int	check_iter_element (void *cls, const struct GNUNET_SET_IterResponseMessage *msg)
	Check that the given msg is well-formed. More...
static void	handle_iter_element (void *cls, const struct GNUNET_SET_IterResponseMessage *msg)
	Handle element for iteration over the set. More...
static void	handle_iter_done (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle message signalling conclusion of iteration over the set. More...
static int	check_result (void *cls, const struct GNUNET_SET_ResultMessage *msg)
	Check that the given msg is well-formed. More...
static void	handle_result (void *cls, const struct GNUNET_SET_ResultMessage *msg)
	Handle result message for a set operation. More...
static void	set_operation_destroy (struct GNUNET_SET_OperationHandle *oh)
	Destroy the given set operation. More...
void	GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
	Cancel the given set operation. More...
static void	handle_client_set_error (void *cls, enum GNUNET_MQ_Error error)
	We encountered an error communicating with the set service while performing a set operation. More...
struct GNUNET_SET_Handle *	GNUNET_SET_create (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op)
	Create an empty set, supporting the specified operation. More...
int	GNUNET_SET_add_element (struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
	Add an element to the given set. More...
int	GNUNET_SET_remove_element (struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
	Remove an element to the given set. More...
void	GNUNET_SET_destroy (struct GNUNET_SET_Handle *set)
	Destroy the set handle if no operations are left, mark the set for destruction otherwise. More...
struct GNUNET_SET_OperationHandle *	GNUNET_SET_prepare (const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
	Prepare a set operation to be evaluated with another peer. More...
static void	listen_connect (void *cls)
	Connect to the set service in order to listen for requests. More...
static int	check_request (void *cls, const struct GNUNET_SET_RequestMessage *msg)
	Check validity of request message for a listen operation. More...
static void	handle_request (void *cls, const struct GNUNET_SET_RequestMessage *msg)
	Handle request message for a listen operation. More...
static void	handle_client_listener_error (void *cls, enum GNUNET_MQ_Error error)
	Our connection with the set service encountered an error, re-initialize with exponential back-off. More...
struct GNUNET_SET_ListenHandle *	GNUNET_SET_listen (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType operation, const struct GNUNET_HashCode *app_id, GNUNET_SET_ListenCallback listen_cb, void *listen_cls)
	Wait for set operation requests for the given application id. More...
void	GNUNET_SET_listen_cancel (struct GNUNET_SET_ListenHandle *lh)
	Cancel the given listen operation. More...
struct GNUNET_SET_OperationHandle *	GNUNET_SET_accept (struct GNUNET_SET_Request *request, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
	Accept a request we got via GNUNET_SET_listen(). More...
int	GNUNET_SET_commit (struct GNUNET_SET_OperationHandle *oh, struct GNUNET_SET_Handle *set)
	Commit a set to be used with a set operation. More...
int	GNUNET_SET_iterate (struct GNUNET_SET_Handle *set, GNUNET_SET_ElementIterator iter, void *iter_cls)
	Iterate over all elements in the given set. More...
void	GNUNET_SET_copy_lazy (struct GNUNET_SET_Handle *set, GNUNET_SET_CopyReadyCallback cb, void *cls)
struct GNUNET_SET_Element *	GNUNET_SET_element_dup (const struct GNUNET_SET_Element *element)
	Create a copy of an element. More...
void	GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element, struct GNUNET_HashCode *ret_hash)
	Hash a set element. More...

Detailed Description

api for the set service

Author

Florian Dold

Christian Grothoff

Definition in file set_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "set-api", __VA_ARGS__)

Definition at line 33 of file set_api.c.

Function Documentation

create_internal()

static struct GNUNET_SET_Handle * create_internal ( const struct GNUNET_CONFIGURATION_Handle *  cfg, enum GNUNET_SET_OperationType  op, const uint32_t *  cookie  )

static

FIXME.

Definition at line 582 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle);
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_var_size (result,
                           GNUNET_MESSAGE_TYPE_SET_RESULT,
                           struct GNUNET_SET_ResultMessage,
                           set),
    GNUNET_MQ_hd_var_size (iter_element,
                           GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT,
                           struct GNUNET_SET_IterResponseMessage,
                           set),
    GNUNET_MQ_hd_fixed_size (iter_done,
                             GNUNET_MESSAGE_TYPE_SET_ITER_DONE,
                             struct GNUNET_MessageHeader,
                             set),
    GNUNET_MQ_hd_fixed_size (copy_lazy,
                             GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE,
                             struct GNUNET_SET_CopyLazyResponseMessage,
                             set),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_CreateMessage *create_msg;
  struct GNUNET_SET_CopyLazyConnectMessage *copy_msg;
 
  set->cfg = cfg;
  set->mq = GNUNET_CLIENT_connect (cfg,
                                   "set",
                                   mq_handlers,
                                   &handle_client_set_error,
                                   set);
  if (NULL == set->mq)
  {
    GNUNET_free (set);
    return NULL;
  }
  if (NULL == cookie)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating new set (operation %u)\n",
         op);
    mqm = GNUNET_MQ_msg (create_msg,
                         GNUNET_MESSAGE_TYPE_SET_CREATE);
    create_msg->operation = htonl (op);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating new set (lazy copy)\n");
    mqm = GNUNET_MQ_msg (copy_msg,
                         GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT);
    copy_msg->cookie = *cookie;
  }
  GNUNET_MQ_send (set->mq,
                  mqm);
  return set;
}

References cfg, GNUNET_SET_Handle::cfg, GNUNET_SET_CopyLazyConnectMessage::cookie, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, GNUNET_MESSAGE_TYPE_SET_CREATE, GNUNET_MESSAGE_TYPE_SET_ITER_DONE, GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, handle_client_set_error(), LOG, GNUNET_SET_Handle::mq, op, GNUNET_SET_CreateMessage::operation, and result.

Referenced by GNUNET_SET_create(), and handle_copy_lazy().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_copy_lazy()

static void handle_copy_lazy ( void *  cls, const struct GNUNET_SET_CopyLazyResponseMessage *  msg  )

static

Handle element for iteration over the set.

Notifies the iterator and sends an acknowledgement to the service.

Parameters

cls	the struct GNUNET_SET_Handle *
msg	the message

Definition at line 248 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = cls;
  struct SetCopyRequest *req;
  struct GNUNET_SET_Handle *new_set;
 
  req = set->copy_req_head;
  if (NULL == req)
  {
    /* Service sent us unsolicited lazy copy response */
    GNUNET_break (0);
    return;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Handling response to lazy copy\n");
  GNUNET_CONTAINER_DLL_remove (set->copy_req_head,
                               set->copy_req_tail,
                               req);
  // We pass none as operation here, since it doesn't matter when
  // cloning.
  new_set = create_internal (set->cfg,
                             GNUNET_SET_OPERATION_NONE,
                             &msg->cookie);
  req->cb (req->cls, new_set);
  GNUNET_free (req);
}

References SetCopyRequest::cb, GNUNET_SET_Handle::cfg, SetCopyRequest::cls, GNUNET_SET_Handle::copy_req_head, GNUNET_SET_Handle::copy_req_tail, create_internal(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SET_OPERATION_NONE, LOG, and msg.

Here is the call graph for this function:

check_iter_element()

static int check_iter_element ( void *  cls, const struct GNUNET_SET_IterResponseMessage *  msg  )

static

Check that the given msg is well-formed.

Parameters

cls	closure
msg	message to check

Returns

GNUNET_OK if message is well-formed

Definition at line 286 of file set_api.c.

{
  /* minimum size was already checked, everything else is OK! */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_iter_element()

static void handle_iter_element ( void *  cls, const struct GNUNET_SET_IterResponseMessage *  msg  )

static

Handle element for iteration over the set.

Notifies the iterator and sends an acknowledgement to the service.

Parameters

cls	the struct GNUNET_SET_Handle *
msg	the message

Definition at line 302 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = cls;
  GNUNET_SET_ElementIterator iter = set->iterator;
  struct GNUNET_SET_Element element;
  struct GNUNET_SET_IterAckMessage *ack_msg;
  struct GNUNET_MQ_Envelope *ev;
  uint16_t msize;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received element in set iteration\n");
  msize = ntohs (msg->header.size);
  if (set->iteration_id != ntohs (msg->iteration_id))
  {
    /* element from a previous iteration, skip! */
    iter = NULL;
  }
  if (NULL != iter)
  {
    element.size = msize - sizeof(struct GNUNET_SET_IterResponseMessage);
    element.element_type = ntohs (msg->element_type);
    element.data = &msg[1];
    iter (set->iterator_cls,
          &element);
  }
  ev = GNUNET_MQ_msg (ack_msg,
                      GNUNET_MESSAGE_TYPE_SET_ITER_ACK);
  ack_msg->send_more = htonl ((NULL != iter));
  GNUNET_MQ_send (set->mq, ev);
}

References GNUNET_SET_Element::data, GNUNET_SET_Element::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_ITER_ACK, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SET_Handle::iteration_id, GNUNET_SET_Handle::iterator, GNUNET_SET_Handle::iterator_cls, LOG, GNUNET_SET_Handle::mq, msg, GNUNET_SET_IterAckMessage::send_more, GNUNET_MessageHeader::size, and GNUNET_SET_Element::size.

Here is the call graph for this function:

handle_iter_done()

static void handle_iter_done ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle message signalling conclusion of iteration over the set.

Notifies the iterator that we are done.

Parameters

cls	the set
mh	the message

Definition at line 343 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = cls;
  GNUNET_SET_ElementIterator iter = set->iterator;
 
  if (NULL == iter)
  {
    /* FIXME: if this is true, could cancel+start a fresh one
       cause elements to go to the wrong iteration? */
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Service completed set iteration that was already cancelled\n");
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Set iteration completed\n");
  set->destroy_requested = GNUNET_SYSERR;
  set->iterator = NULL;
  set->iteration_id++;
  iter (set->iterator_cls,
        NULL);
  if (GNUNET_SYSERR == set->destroy_requested)
    set->destroy_requested = GNUNET_NO;
  if (GNUNET_YES == set->destroy_requested)
    GNUNET_SET_destroy (set);
}

References GNUNET_SET_Handle::destroy_requested, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_NO, GNUNET_SET_destroy(), GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::iteration_id, GNUNET_SET_Handle::iterator, GNUNET_SET_Handle::iterator_cls, and LOG.

Here is the call graph for this function:

check_result()

static int check_result ( void *  cls, const struct GNUNET_SET_ResultMessage *  msg  )

static

Check that the given msg is well-formed.

Parameters

cls	closure
msg	message to check

Returns

GNUNET_OK if message is well-formed

Definition at line 379 of file set_api.c.

{
  /* minimum size was already checked, everything else is OK! */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_result()

static void handle_result ( void *  cls, const struct GNUNET_SET_ResultMessage *  msg  )

static

Handle result message for a set operation.

Parameters

cls	the set
mh	the message

Definition at line 394 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = cls;
  struct GNUNET_SET_OperationHandle *oh;
  struct GNUNET_SET_Element e;
  enum GNUNET_SET_Status result_status;
  int destroy_set;
 
  GNUNET_assert (NULL != set->mq);
  result_status = ntohs (msg->result_status);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got result message with status %d\n",
       result_status);
 
  oh = GNUNET_MQ_assoc_get (set->mq,
                            ntohl (msg->request_id));
  if (NULL == oh)
  {
    /* 'oh' can be NULL if we canceled the operation, but the service
       did not get the cancel message yet. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Ignoring result from canceled operation\n");
    return;
  }
 
  switch (result_status)
  {
  case GNUNET_SET_STATUS_OK:
  case GNUNET_SET_STATUS_ADD_LOCAL:
  case GNUNET_SET_STATUS_ADD_REMOTE:
    goto do_element;
 
  case GNUNET_SET_STATUS_FAILURE:
  case GNUNET_SET_STATUS_DONE:
    goto do_final;
 
  case GNUNET_SET_STATUS_HALF_DONE:
    /* not used anymore */
    GNUNET_assert (0);
  }
 
do_final:
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Treating result as final status\n");
  GNUNET_MQ_assoc_remove (set->mq,
                          ntohl (msg->request_id));
  GNUNET_CONTAINER_DLL_remove (set->ops_head,
                               set->ops_tail,
                               oh);
  /* Need to do this calculation _before_ the result callback,
     as IF the application still has a valid set handle, it
     may trigger destruction of the set during the callback. */
  destroy_set = (GNUNET_YES == set->destroy_requested) &&
                (NULL == set->ops_head);
  if (NULL != oh->result_cb)
  {
    oh->result_cb (oh->result_cls,
                   NULL,
                   GNUNET_ntohll (msg->current_size),
                   result_status);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "No callback for final status\n");
  }
  if (destroy_set)
    GNUNET_SET_destroy (set);
  GNUNET_free (oh);
  return;
 
do_element:
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Treating result as element\n");
  e.data = &msg[1];
  e.size = ntohs (msg->header.size) - sizeof(struct GNUNET_SET_ResultMessage);
  e.element_type = ntohs (msg->element_type);
  if (NULL != oh->result_cb)
    oh->result_cb (oh->result_cls,
                   &e,
                   GNUNET_ntohll (msg->current_size),
                   result_status);
}

References GNUNET_SET_Element::data, GNUNET_SET_Handle::destroy_requested, GNUNET_SET_Element::element_type, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MQ_assoc_get(), GNUNET_MQ_assoc_remove(), GNUNET_ntohll(), GNUNET_SET_destroy(), GNUNET_SET_STATUS_ADD_LOCAL, GNUNET_SET_STATUS_ADD_REMOTE, GNUNET_SET_STATUS_DONE, GNUNET_SET_STATUS_FAILURE, GNUNET_SET_STATUS_HALF_DONE, GNUNET_SET_STATUS_OK, GNUNET_YES, LOG, GNUNET_SET_Handle::mq, msg, GNUNET_SET_Handle::ops_head, GNUNET_SET_Handle::ops_tail, GNUNET_SET_OperationHandle::result_cb, GNUNET_SET_OperationHandle::result_cls, GNUNET_SET_ResultMessage::result_status, GNUNET_MessageHeader::size, and GNUNET_SET_Element::size.

Here is the call graph for this function:

set_operation_destroy()

static void set_operation_destroy ( struct GNUNET_SET_OperationHandle *  oh )

static

Destroy the given set operation.

Parameters

oh	set operation to destroy

Definition at line 486 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = oh->set;
  struct GNUNET_SET_OperationHandle *h_assoc;
 
  if (NULL != oh->conclude_mqm)
    GNUNET_MQ_discard (oh->conclude_mqm);
  /* is the operation already committed? */
  if (NULL != set)
  {
    GNUNET_CONTAINER_DLL_remove (set->ops_head,
                                 set->ops_tail,
                                 oh);
    h_assoc = GNUNET_MQ_assoc_remove (set->mq,
                                      oh->request_id);
    GNUNET_assert ((NULL == h_assoc) ||
                   (h_assoc == oh));
  }
  GNUNET_free (oh);
}

References GNUNET_SET_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_assoc_remove(), GNUNET_MQ_discard(), GNUNET_SET_Handle::mq, GNUNET_SET_Handle::ops_head, GNUNET_SET_Handle::ops_tail, GNUNET_SET_OperationHandle::request_id, and GNUNET_SET_OperationHandle::set.

Referenced by GNUNET_SET_operation_cancel(), and handle_client_set_error().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_set_error()

static void handle_client_set_error ( void *  cls, enum GNUNET_MQ_Error  error  )

static

We encountered an error communicating with the set service while performing a set operation.

Report to the application.

Parameters

cls	the struct GNUNET_SET_Handle
error	error code

Definition at line 550 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = cls;
  GNUNET_SET_ElementIterator iter = set->iterator;
 
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "Handling client set error %d\n",
       error);
  while (NULL != set->ops_head)
  {
    if ((NULL != set->ops_head->result_cb) &&
        (GNUNET_NO == set->destroy_requested))
      set->ops_head->result_cb (set->ops_head->result_cls,
                                NULL,
                                0,
                                GNUNET_SET_STATUS_FAILURE);
    set_operation_destroy (set->ops_head);
  }
  set->iterator = NULL;
  set->iteration_id++;
  set->invalid = GNUNET_YES;
  if (NULL != iter)
    iter (set->iterator_cls,
          NULL);
}

References GNUNET_SET_Handle::destroy_requested, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_SET_STATUS_FAILURE, GNUNET_YES, GNUNET_SET_Handle::invalid, GNUNET_SET_Handle::iteration_id, GNUNET_SET_Handle::iterator, GNUNET_SET_Handle::iterator_cls, LOG, GNUNET_SET_Handle::ops_head, GNUNET_SET_OperationHandle::result_cb, GNUNET_SET_OperationHandle::result_cls, and set_operation_destroy().

Referenced by create_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

listen_connect()

static void listen_connect ( void *  cls )

static

Connect to the set service in order to listen for requests.

Parameters

cls	the struct GNUNET_SET_ListenHandle * to connect

Definition at line 933 of file set_api.c.

{
  struct GNUNET_SET_ListenHandle *lh = cls;
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_var_size (request,
                           GNUNET_MESSAGE_TYPE_SET_REQUEST,
                           struct GNUNET_SET_RequestMessage,
                           lh),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_ListenMessage *msg;
 
  lh->reconnect_task = NULL;
  GNUNET_assert (NULL == lh->mq);
  lh->mq = GNUNET_CLIENT_connect (lh->cfg,
                                  "set",
                                  mq_handlers,
                                  &handle_client_listener_error,
                                  lh);
  if (NULL == lh->mq)
    return;
  mqm = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_LISTEN);
  msg->operation = htonl (lh->operation);
  msg->app_id = lh->app_id;
  GNUNET_MQ_send (lh->mq,
                  mqm);
}

References GNUNET_SET_ListenHandle::app_id, GNUNET_SET_ListenHandle::cfg, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_SET_LISTEN, GNUNET_MESSAGE_TYPE_SET_REQUEST, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), handle_client_listener_error(), GNUNET_SET_ListenHandle::mq, msg, GNUNET_SET_ListenHandle::operation, GNUNET_SET_ListenHandle::reconnect_task, and request.

Referenced by GNUNET_SET_listen(), and handle_client_listener_error().

Here is the call graph for this function:

Here is the caller graph for this function:

check_request()

static int check_request ( void *  cls, const struct GNUNET_SET_RequestMessage *  msg  )

static

Check validity of request message for a listen operation.

Parameters

cls	the listen handle
msg	the message

Returns

GNUNET_OK if the message is well-formed

Definition at line 843 of file set_api.c.

{
  const struct GNUNET_MessageHeader *context_msg;
 
  if (ntohs (msg->header.size) == sizeof(*msg))
    return GNUNET_OK; /* no context message is OK */
  context_msg = GNUNET_MQ_extract_nested_mh (msg);
  if (NULL == context_msg)
  {
    /* malformed context message is NOT ok */
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_MQ_extract_nested_mh, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

handle_request()

static void handle_request ( void *  cls, const struct GNUNET_SET_RequestMessage *  msg  )

static

Handle request message for a listen operation.

Parameters

cls	the listen handle
msg	the message

Definition at line 868 of file set_api.c.

{
  struct GNUNET_SET_ListenHandle *lh = cls;
  struct GNUNET_SET_Request req;
  const struct GNUNET_MessageHeader *context_msg;
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_RejectMessage *rmsg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Processing incoming operation request with id %u\n",
       ntohl (msg->accept_id));
  /* we got another valid request => reset the backoff */
  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  req.accept_id = ntohl (msg->accept_id);
  req.accepted = GNUNET_NO;
  context_msg = GNUNET_MQ_extract_nested_mh (msg);
  /* calling #GNUNET_SET_accept() in the listen cb will set req->accepted */
  lh->listen_cb (lh->listen_cls,
                 &msg->peer_id,
                 context_msg,
                 &req);
  if (GNUNET_YES == req.accepted)
    return; /* the accept-case is handled in #GNUNET_SET_accept() */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Rejected request %u\n",
       ntohl (msg->accept_id));
  mqm = GNUNET_MQ_msg (rmsg,
                       GNUNET_MESSAGE_TYPE_SET_REJECT);
  rmsg->accept_reject_id = msg->accept_id;
  GNUNET_MQ_send (lh->mq, mqm);
}

References GNUNET_SET_Request::accept_id, GNUNET_SET_RejectMessage::accept_reject_id, GNUNET_SET_Request::accepted, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_REJECT, GNUNET_MQ_extract_nested_mh, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, GNUNET_SET_ListenHandle::listen_cb, GNUNET_SET_ListenHandle::listen_cls, LOG, GNUNET_SET_ListenHandle::mq, msg, and GNUNET_SET_ListenHandle::reconnect_backoff.

Here is the call graph for this function:

handle_client_listener_error()

static void handle_client_listener_error ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Our connection with the set service encountered an error, re-initialize with exponential back-off.

Parameters

cls	the struct GNUNET_SET_ListenHandle *
error	reason for the disconnect

Definition at line 910 of file set_api.c.

{
  struct GNUNET_SET_ListenHandle *lh = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Listener broke down (%d), re-connecting\n",
       (int) error);
  GNUNET_MQ_destroy (lh->mq);
  lh->mq = NULL;
  lh->reconnect_task = GNUNET_SCHEDULER_add_delayed (lh->reconnect_backoff,
                                                     &listen_connect,
                                                     lh);
  lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (lh->reconnect_backoff);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, listen_connect(), LOG, GNUNET_SET_ListenHandle::mq, GNUNET_SET_ListenHandle::reconnect_backoff, and GNUNET_SET_ListenHandle::reconnect_task.

Referenced by listen_connect().

Here is the call graph for this function:

Here is the caller graph for this function: