gnunet-service-messenger_operation.c File Reference

#include "gnunet-service-messenger_operation.h"
#include "gnunet-service-messenger_message_kind.h"
#include "gnunet-service-messenger_operation_store.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet_common.h"

Include dependency graph for gnunet-service-messenger_operation.c:

Go to the source code of this file.

Functions
struct GNUNET_MESSENGER_Operation *	create_operation (const struct GNUNET_HashCode *hash)
	Creates and allocates a new operation under a given hash. More...
void	destroy_operation (struct GNUNET_MESSENGER_Operation *op)
	Destroys an operation and frees its memory fully. More...
static void	callback_operation (void *cls)
struct GNUNET_MESSENGER_Operation *	load_operation (struct GNUNET_MESSENGER_OperationStore *store, const char *path)
	Loads data from a configuration file at a selected path into a new allocated and created operation for a specific operation store if the required information could be read successfully. More...
void	save_operation (const struct GNUNET_MESSENGER_Operation *op, const char *path)
	Saves data from an operation into a configuration file at a selected path which can be load to restore the operation completely and continue its process. More...
void	callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
void	callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
enum GNUNET_GenericReturnValue	start_operation (struct GNUNET_MESSENGER_Operation *op, enum GNUNET_MESSENGER_OperationType type, struct GNUNET_MESSENGER_OperationStore *store, struct GNUNET_TIME_Relative delay)
	Starts an inactive operation with a given delay in a specific operation store. More...
enum GNUNET_GenericReturnValue	stop_operation (struct GNUNET_MESSENGER_Operation *op)
	Stops an active operation and resets its type to be GNUNET_MESSENGER_OP_UNKNOWN. More...

Function Documentation

create_operation()

struct GNUNET_MESSENGER_Operation * create_operation

(

const struct GNUNET_HashCode *

hash

)

Creates and allocates a new operation under a given hash.

Parameters

[in]

hash

Hash of message

Definition at line 34 of file gnunet-service-messenger_operation.c.

{
  struct GNUNET_MESSENGER_Operation *op;
 
  GNUNET_assert (hash);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new operation: %s\n",
              GNUNET_h2s (hash));
 
  op = GNUNET_new (struct GNUNET_MESSENGER_Operation);
 
  op->type = GNUNET_MESSENGER_OP_UNKNOWN;
  GNUNET_memcpy (&(op->hash), hash, sizeof(*hash));
  op->timestamp = GNUNET_TIME_absolute_get_zero_ ();
  op->store = NULL;
  op->task = NULL;
 
  return op;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_OP_UNKNOWN, GNUNET_new, GNUNET_TIME_absolute_get_zero_(), GNUNET_MESSENGER_Operation::hash, and op.

Referenced by load_operation(), and use_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_operation()

void destroy_operation

(

struct GNUNET_MESSENGER_Operation *

op

)

Destroys an operation and frees its memory fully.

Parameters

[in,out]

op

Operation

Definition at line 56 of file gnunet-service-messenger_operation.c.

{
  GNUNET_assert (op);
 
  if (op->task)
    GNUNET_SCHEDULER_cancel (op->task);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free operation: %s\n",
              GNUNET_h2s (&(op->hash)));
 
  GNUNET_free (op);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), and op.

Referenced by callback_scan_for_operations(), cancel_store_operation(), iterate_destroy_operations(), load_operation(), and use_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_operation()

static void callback_operation ( void *  cls )

static

Definition at line 212 of file gnunet-service-messenger_operation.c.

{
  struct GNUNET_MESSENGER_Operation *op;
  struct GNUNET_MESSENGER_OperationStore *store;
  struct GNUNET_MESSENGER_SrvRoom *room;
  enum GNUNET_MESSENGER_OperationType type;
  struct GNUNET_HashCode hash;
 
  GNUNET_assert (cls);
 
  op = cls;
  op->task = NULL;
 
  GNUNET_assert ((op->store) && (op->store->room));
 
  store = op->store;
  room = store->room;
  type = op->type;
 
  GNUNET_memcpy (&hash, &(op->hash), sizeof(hash));
 
  cancel_store_operation (store, &hash);
 
  if (GNUNET_is_zero (&hash))
    return;
 
  switch (type)
  {
  case GNUNET_MESSENGER_OP_REQUEST:
    break;
  case GNUNET_MESSENGER_OP_DELETE:
    {
      if (GNUNET_OK != delete_store_message (get_srv_room_message_store (room),
                                             &hash))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Deletion of message failed! (%s)\n",
                    GNUNET_h2s (&hash));
        break;
      }
 
      break;
    }
  case GNUNET_MESSENGER_OP_MERGE:
    {
      struct GNUNET_MESSENGER_Message *message;
 
      if (! room->host)
        break;
 
      message = create_message_merge (&hash);
 
      if (! message)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Merging operation failed: %s\n",
                    GNUNET_h2s (&(room->key)));
        break;
      }
 
      send_srv_room_message (room, room->host, message);
      break;
    }
  default:
    break;
  }
}

References cancel_store_operation(), create_message_merge(), delete_store_message(), get_srv_room_message_store(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_is_zero, GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_OP_DELETE, GNUNET_MESSENGER_OP_MERGE, GNUNET_MESSENGER_OP_REQUEST, GNUNET_OK, GNUNET_MESSENGER_SrvRoom::host, GNUNET_MESSENGER_SrvRoom::key, op, GNUNET_MESSENGER_OperationStore::room, send_srv_room_message(), and type.

Referenced by load_operation(), and start_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

load_operation()

struct GNUNET_MESSENGER_Operation * load_operation	(	struct GNUNET_MESSENGER_OperationStore *	store,
		const char *	path
	)

Loads data from a configuration file at a selected path into a new allocated and created operation for a specific operation store if the required information could be read successfully.

The method will return the new operation and it will be started automatically to match its timestamp of execution.

If the method fails to restore any valid operation from the file, NULL gets returned instead.

Parameters

[in,out]	store	Operation store
[in]	path	Path of a configuration file

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

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  struct GNUNET_MESSENGER_Operation *op;
 
  GNUNET_assert ((store) && (path));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load operation configuration: %s\n",
              path);
 
  cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
 
  if (! cfg)
    return NULL;
 
  op = NULL;
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, path))
    goto destroy_config;
 
  {
    struct GNUNET_HashCode hash;
 
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation", "hash",
                                                    &hash, sizeof(hash)))
      goto destroy_config;
 
    op = create_operation (&hash);
  }
 
  {
    unsigned long long type_number;
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "operation",
                                                            "type", &type_number
                                                            ))
      switch (type_number)
      {
      case GNUNET_MESSENGER_OP_REQUEST:
        op->type = GNUNET_MESSENGER_OP_REQUEST;
        break;
      case GNUNET_MESSENGER_OP_DELETE:
        op->type = GNUNET_MESSENGER_OP_DELETE;
        break;
      case GNUNET_MESSENGER_OP_MERGE:
        op->type = GNUNET_MESSENGER_OP_MERGE;
        break;
      default:
        break;
      }
  }
 
  if ((GNUNET_MESSENGER_OP_UNKNOWN == op->type) ||
      (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "operation",
                                                   "timestamp",
                                                   &(op->timestamp),
                                                   sizeof(op->timestamp))))
  {
    destroy_operation (op);
    op = NULL;
    goto destroy_config;
  }
 
  {
    struct GNUNET_TIME_Relative delay;
    delay = GNUNET_TIME_absolute_get_remaining (op->timestamp);
 
    op->task = GNUNET_SCHEDULER_add_delayed_with_priority (
      delay,
      GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
      callback_operation,
      op);
  }
 
  op->store = store;
 
destroy_config:
  GNUNET_CONFIGURATION_destroy (cfg);
 
  return op;
}

References callback_operation(), cfg, create_operation(), destroy_operation(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_parse(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_OP_DELETE, GNUNET_MESSENGER_OP_MERGE, GNUNET_MESSENGER_OP_REQUEST, GNUNET_MESSENGER_OP_UNKNOWN, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_BACKGROUND, GNUNET_TIME_absolute_get_remaining(), op, and GNUNET_MESSENGER_Operation::store.

Referenced by callback_scan_for_operations().

Here is the call graph for this function:

Here is the caller graph for this function:

save_operation()

void save_operation	(	const struct GNUNET_MESSENGER_Operation *	op,
		const char *	path
	)

Saves data from an operation into a configuration file at a selected path which can be load to restore the operation completely and continue its process.

Parameters

[in]	op	Operation
[in]	path	Path of a configuration file

Definition at line 158 of file gnunet-service-messenger_operation.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  char *hash_data;
  char *timestamp_data;
 
  GNUNET_assert ((path) && (op));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save operation configuration: %s\n",
              path);
 
  cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
 
  if (! cfg)
    return;
 
  hash_data = GNUNET_STRINGS_data_to_string_alloc (&(op->hash),
                                                   sizeof(op->hash));
 
  if (hash_data)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "hash", hash_data);
 
    GNUNET_free (hash_data);
  }
 
  GNUNET_CONFIGURATION_set_value_number (cfg, "operation", "type", op->type);
 
  timestamp_data = GNUNET_STRINGS_data_to_string_alloc (&(op->timestamp),
                                                        sizeof(op->timestamp));
 
  if (timestamp_data)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg, "operation", "timestamp",
                                           timestamp_data);
 
    GNUNET_free (timestamp_data);
  }
 
  GNUNET_CONFIGURATION_write (cfg, path);
  GNUNET_CONFIGURATION_destroy (cfg);
}

References cfg, GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OS_project_data_gnunet(), GNUNET_STRINGS_data_to_string_alloc(), and op.

Referenced by iterate_save_operations().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_room_deletion()

void callback_room_deletion	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_HashCode *	hash
	)

callback_room_merge()

void callback_room_merge	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_HashCode *	hash
	)

start_operation()

enum GNUNET_GenericReturnValue start_operation	(	struct GNUNET_MESSENGER_Operation *	op,
		enum GNUNET_MESSENGER_OperationType	type,
		struct GNUNET_MESSENGER_OperationStore *	store,
		struct GNUNET_TIME_Relative	delay
	)

Starts an inactive operation with a given delay in a specific operation store.

The method will replace the operations type to process it correctly. An operation can't be started twice, it has to be stopped or fully processed first.

Parameters

[in,out]	op	Operation
[in]	type	Type of operation
[in,out]	store	Operation store
[in]	delay	Delay

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 282 of file gnunet-service-messenger_operation.c.

{
  struct GNUNET_TIME_Absolute timestamp;
 
  GNUNET_assert ((op) && (store));
 
  if (op->task)
    return GNUNET_SYSERR;
 
  timestamp = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
 
  op->task = GNUNET_SCHEDULER_add_delayed_with_priority (
    delay,
    GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
    callback_operation,
    op);
 
  op->type = type;
  op->timestamp = timestamp;
  op->store = store;
 
  return GNUNET_OK;
}

References callback_operation(), GNUNET_assert, GNUNET_OK, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_BACKGROUND, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), op, timestamp(), and type.

Referenced by use_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_operation()

enum GNUNET_GenericReturnValue stop_operation

(

struct GNUNET_MESSENGER_Operation *

op

)

Stops an active operation and resets its type to be GNUNET_MESSENGER_OP_UNKNOWN.

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 311 of file gnunet-service-messenger_operation.c.

{
  GNUNET_assert (op);
 
  if (! op->task)
    return GNUNET_SYSERR;
 
  GNUNET_SCHEDULER_cancel (op->task);
  op->task = NULL;
 
  op->type = GNUNET_MESSENGER_OP_UNKNOWN;
  op->timestamp = GNUNET_TIME_absolute_get_zero_ ();
  op->store = NULL;
 
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_MESSENGER_OP_UNKNOWN, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_zero_(), and op.

Referenced by cancel_store_operation(), and use_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function: