messenger_api_message_control.c File Reference

#include "messenger_api_message_control.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_scheduler_lib.h"
#include "messenger_api_contact.h"
#include "messenger_api_contact_store.h"
#include "messenger_api_handle.h"
#include "messenger_api_message.h"
#include "messenger_api_room.h"

Include dependency graph for messenger_api_message_control.c:

Go to the source code of this file.

Functions
struct GNUNET_MESSENGER_MessageControl *	create_message_control (struct GNUNET_MESSENGER_Room *room)
	Creates and allocates a new message control for a room of the client API.
void	destroy_message_control (struct GNUNET_MESSENGER_MessageControl *control)
	Destroys a message control and frees its memory fully from the client API.
static void	enqueue_message_control (struct GNUNET_MESSENGER_MessageControl *control, const struct GNUNET_HashCode *sender, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *epoch, const struct GNUNET_MESSENGER_Message *message, enum GNUNET_MESSENGER_MessageFlags flags)
static void	handle_message_control (struct GNUNET_MESSENGER_MessageControl *control, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *epoch, const struct GNUNET_MESSENGER_Message *message, enum GNUNET_MESSENGER_MessageFlags flags)
static void	task_message_control (void *cls)
static enum GNUNET_GenericReturnValue	iterate_message_control (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
void	process_message_control (struct GNUNET_MESSENGER_MessageControl *control, const struct GNUNET_HashCode *sender, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *epoch, const struct GNUNET_MESSENGER_Message *message, enum GNUNET_MESSENGER_MessageFlags flags)
	Processes a new message with its hash and regarding information about sender, context and message flags using a selected message control.

Function Documentation

create_message_control()

struct GNUNET_MESSENGER_MessageControl * create_message_control

(

struct GNUNET_MESSENGER_Room *

room

)

Creates and allocates a new message control for a room of the client API.

Parameters

[in,out]

room

Room

Returns

New message control

Definition at line 38 of file messenger_api_message_control.c.

{
  struct GNUNET_MESSENGER_MessageControl *control;
 
  GNUNET_assert (room);
 
  control = GNUNET_new (struct GNUNET_MESSENGER_MessageControl);
  control->room = room;
 
  control->peer_messages = GNUNET_CONTAINER_multishortmap_create (8, GNUNET_NO);
  control->member_messages = GNUNET_CONTAINER_multishortmap_create (8,
                                                                    GNUNET_NO);
 
  control->head = NULL;
  control->tail = NULL;
 
  return control;
}

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_create(), GNUNET_new, GNUNET_NO, GNUNET_MESSENGER_MessageControl::head, GNUNET_MESSENGER_MessageControl::member_messages, GNUNET_MESSENGER_MessageControl::peer_messages, GNUNET_MESSENGER_MessageControl::room, and GNUNET_MESSENGER_MessageControl::tail.

Referenced by create_room().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_message_control()

void destroy_message_control

(

struct GNUNET_MESSENGER_MessageControl *

control

)

Destroys a message control and frees its memory fully from the client API.

Parameters

[in,out]

control

Message control

Definition at line 59 of file messenger_api_message_control.c.

{
  GNUNET_assert (control);
 
  while (control->head)
  {
    struct GNUNET_MESSENGER_MessageControlQueue *queue;
    queue = control->head;
 
    if (queue->task)
      GNUNET_SCHEDULER_cancel (queue->task);
 
    destroy_message (queue->message);
 
    GNUNET_CONTAINER_DLL_remove (control->head, control->tail, queue);
    GNUNET_free (queue);
  }
 
  GNUNET_CONTAINER_multishortmap_destroy (control->peer_messages);
  GNUNET_CONTAINER_multishortmap_destroy (control->member_messages);
 
  GNUNET_free (control);
}

References GNUNET_MESSENGER_MessageControlQueue::control, destroy_message(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_MESSENGER_MessageControl::head, GNUNET_MESSENGER_MessageControl::member_messages, GNUNET_MESSENGER_MessageControl::peer_messages, queue(), and GNUNET_MESSENGER_MessageControl::tail.

Referenced by destroy_room().

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue_message_control()

static void enqueue_message_control ( struct GNUNET_MESSENGER_MessageControl *  control, const struct GNUNET_HashCode *  sender, const struct GNUNET_HashCode *  context, const struct GNUNET_HashCode *  hash, const struct GNUNET_HashCode *  epoch, const struct GNUNET_MESSENGER_Message *  message, enum GNUNET_MESSENGER_MessageFlags  flags  )

static

Definition at line 85 of file messenger_api_message_control.c.

{
  struct GNUNET_CONTAINER_MultiShortmap *map;
  struct GNUNET_MESSENGER_MessageControlQueue *queue;
 
  GNUNET_assert ((control) && (sender) && (context) && (hash) && (message));
 
  if (GNUNET_YES == is_peer_message (message))
    map = control->peer_messages;
  else
    map = control->member_messages;
 
  queue = GNUNET_new (struct GNUNET_MESSENGER_MessageControlQueue);
  queue->control = control;
 
  GNUNET_memcpy (&(queue->sender), sender, sizeof (queue->sender));
  GNUNET_memcpy (&(queue->context), context, sizeof (queue->context));
  GNUNET_memcpy (&(queue->hash), hash, sizeof (queue->hash));
  GNUNET_memcpy (&(queue->epoch), epoch, sizeof (queue->epoch));
 
  queue->message = copy_message (message);
  queue->flags = flags;
  queue->task = NULL;
 
  GNUNET_CONTAINER_DLL_insert (control->head, control->tail, queue);
 
  GNUNET_CONTAINER_multishortmap_put (map,
                                      &(message->header.sender_id),
                                      queue,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
}

References context, GNUNET_MESSENGER_MessageControlQueue::control, copy_message(), GNUNET_MESSENGER_MessageControlQueue::epoch, GNUNET_MESSENGER_MessageControlQueue::flags, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_memcpy, GNUNET_new, GNUNET_YES, GNUNET_MESSENGER_MessageControlQueue::hash, GNUNET_MESSENGER_MessageControl::head, GNUNET_MESSENGER_Message::header, is_peer_message(), map, GNUNET_MESSENGER_MessageControl::member_messages, GNUNET_MESSENGER_MessageControlQueue::message, GNUNET_MESSENGER_MessageControl::peer_messages, queue(), GNUNET_MESSENGER_MessageControlQueue::sender, GNUNET_MESSENGER_MessageHeader::sender_id, and GNUNET_MESSENGER_MessageControl::tail.

Referenced by process_message_control().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_message_control()

static void handle_message_control ( struct GNUNET_MESSENGER_MessageControl *  control, struct GNUNET_MESSENGER_Contact *  contact, const struct GNUNET_HashCode *  hash, const struct GNUNET_HashCode *  epoch, const struct GNUNET_MESSENGER_Message *  message, enum GNUNET_MESSENGER_MessageFlags  flags  )

static

Definition at line 125 of file messenger_api_message_control.c.

{
  GNUNET_assert ((control) && (hash) && (message));
 
  handle_room_message (control->room, contact, message, hash, epoch, flags);
 
  if ((flags & GNUNET_MESSENGER_FLAG_RECENT) &&
      (! get_message_discourse (message)))
    update_room_last_message (control->room, hash, epoch);
 
  callback_room_message (control->room, hash);
}

References callback_room_message(), GNUNET_MESSENGER_MessageControlQueue::control, GNUNET_MESSENGER_MessageControlQueue::epoch, GNUNET_MESSENGER_MessageControlQueue::flags, get_message_discourse(), GNUNET_assert, GNUNET_MESSENGER_FLAG_RECENT, handle_room_message(), GNUNET_MESSENGER_MessageControlQueue::hash, GNUNET_MESSENGER_MessageControlQueue::message, GNUNET_MESSENGER_MessageControl::room, and update_room_last_message().

Referenced by process_message_control(), and task_message_control().

Here is the call graph for this function:

Here is the caller graph for this function:

task_message_control()

static void task_message_control ( void *  cls )

static

Definition at line 145 of file messenger_api_message_control.c.

{
  struct GNUNET_MESSENGER_MessageControlQueue *queue;
  struct GNUNET_MESSENGER_MessageControl *control;
  struct GNUNET_MESSENGER_Contact *contact;
  struct GNUNET_CONTAINER_MultiShortmap *map;
 
  GNUNET_assert (cls);
 
  queue = cls;
  control = queue->control;
 
  queue->task = NULL;
 
  {
    struct GNUNET_MESSENGER_Handle *handle;
    struct GNUNET_MESSENGER_ContactStore *store;
 
    handle = get_room_handle (control->room);
    store = get_handle_contact_store (handle);
 
    contact = get_store_contact_raw (
      store, &(queue->context), &(queue->sender));
  }
 
  if (GNUNET_YES == is_peer_message (queue->message))
    map = control->peer_messages;
  else
    map = control->member_messages;
 
  GNUNET_CONTAINER_multishortmap_remove (map,
                                         &(queue->message->header.sender_id),
                                         queue);
 
  GNUNET_CONTAINER_DLL_remove (control->head, control->tail, queue);
 
  handle_message_control (control,
                          contact,
                          &(queue->hash),
                          &(queue->epoch),
                          queue->message,
                          queue->flags);
 
  destroy_message (queue->message);
 
  GNUNET_free (queue);
}

References destroy_message(), get_handle_contact_store(), get_room_handle(), get_store_contact_raw(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_free, GNUNET_YES, handle, handle_message_control(), GNUNET_MESSENGER_MessageControl::head, is_peer_message(), map, GNUNET_MESSENGER_MessageControl::member_messages, GNUNET_MESSENGER_MessageControl::peer_messages, queue(), GNUNET_MESSENGER_MessageControl::room, and GNUNET_MESSENGER_MessageControl::tail.

Referenced by iterate_message_control().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_message_control()

static enum GNUNET_GenericReturnValue iterate_message_control ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 195 of file messenger_api_message_control.c.

{
  struct GNUNET_MESSENGER_MessageControlQueue *queue;
 
  GNUNET_assert ((key) && (value));
 
  queue = value;
 
  if (queue->task)
    return GNUNET_YES;
 
  queue->task = GNUNET_SCHEDULER_add_with_priority (
    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
    task_message_control,
    queue);
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_YES, key, queue(), task_message_control(), and value.

Referenced by process_message_control().

Here is the call graph for this function:

Here is the caller graph for this function:

process_message_control()

void process_message_control	(	struct GNUNET_MESSENGER_MessageControl *	control,
		const struct GNUNET_HashCode *	sender,
		const struct GNUNET_HashCode *	context,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_HashCode *	epoch,
		const struct GNUNET_MESSENGER_Message *	message,
		enum GNUNET_MESSENGER_MessageFlags	flags
	)

Processes a new message with its hash and regarding information about sender, context and message flags using a selected message control.

The message control will ensure order of messages so that senders of messages can be identified via previously processed messages.

Parameters

[in,out]	control	Message control
[in]	sender	Sender hash
[in]	context	Context hash
[in]	hash	Message hash
[in]	epoch	Epoch hash
[in]	message	Message
[in]	flags	Message flags

Definition at line 218 of file messenger_api_message_control.c.

{
  struct GNUNET_MESSENGER_Contact *contact;
  struct GNUNET_CONTAINER_MultiShortmap *map;
  const struct GNUNET_ShortHashCode *id;
 
  GNUNET_assert ((control) && (sender) && (context) && (hash) && (message));
 
  {
    struct GNUNET_MESSENGER_Handle *handle;
    struct GNUNET_MESSENGER_ContactStore *store;
 
    handle = get_room_handle (control->room);
    store = get_handle_contact_store (handle);
 
    contact = get_store_contact_raw (store, context, sender);
  }
 
  if ((! contact) &&
      (GNUNET_MESSENGER_KIND_JOIN != message->header.kind) &&
      (GNUNET_MESSENGER_KIND_PEER != message->header.kind))
    enqueue_message_control (control, sender, context, hash, epoch, message,
                             flags);
  else
  {
    if ((! contact) && (GNUNET_MESSENGER_KIND_JOIN == message->header.kind))
      flags |= GNUNET_MESSENGER_FLAG_MEMBER;
 
    handle_message_control (control, contact, hash, epoch, message, flags);
  }
 
  map = NULL;
  id = &(message->header.sender_id);
 
  if (GNUNET_YES == is_peer_message (message))
    map = control->peer_messages;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    map = control->member_messages;
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    map = control->peer_messages;
    break;
  case GNUNET_MESSENGER_KIND_ID:
    map = control->member_messages;
    id = &(message->body.id.id);
    break;
  default:
    break;
  }
 
  if (! map)
    return;
 
  GNUNET_CONTAINER_multishortmap_get_multiple (map,
                                               id,
                                               iterate_message_control,
                                               NULL);
}

References GNUNET_MESSENGER_Message::body, context, enqueue_message_control(), get_handle_contact_store(), get_room_handle(), get_store_contact_raw(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_MESSENGER_FLAG_MEMBER, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_PEER, GNUNET_YES, handle, handle_message_control(), GNUNET_MESSENGER_Message::header, id, GNUNET_MESSENGER_MessageId::id, GNUNET_MESSENGER_MessageBody::id, is_peer_message(), iterate_message_control(), GNUNET_MESSENGER_MessageHeader::kind, map, GNUNET_MESSENGER_MessageControl::member_messages, GNUNET_MESSENGER_MessageControl::peer_messages, GNUNET_MESSENGER_MessageControl::room, and GNUNET_MESSENGER_MessageHeader::sender_id.

Referenced by handle_recv_message().

Here is the call graph for this function:

Here is the caller graph for this function: