path: root/src/lockmanager/gnunet-service-lockmanager.c

/*
  This file is part of GNUnet.
  (C) 2012 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
  by the Free Software Foundation; either version 2, or (at your
  option) any later version.

  GNUnet is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with GNUnet; see the file COPYING.  If not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.
*/

/**
 * @file lockmanager/gnunet-service-lockmanager.c
 * @brief implementation of the LOCKMANAGER service
 * @author Sree Harsha Totakura
 */

#include "platform.h"
#include "gnunet_common.h"
#include "gnunet_container_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_service_lib.h"
#include "gnunet_server_lib.h"

#include "lockmanager.h"


#define LOG(kind,...)                           \
  GNUNET_log (kind, __VA_ARGS__)

#define TIME_REL_MINS(min)                                      \
  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, min)

#define TIMEOUT TIME_REL_MINS(3)


/**
 * Doubly linked list of clients having connections to us
 */
struct ClientList;


/**
 * Doubly linked list of clients waiting for a lock
 */
struct WaitList
{
  /**
   * The next client structure
   */
  struct WaitList *next;

  /**
   * The prev client structure
   */
  struct WaitList *prev;

  /**
   * Pointer to the client
   */
  struct ClientList *cl_entry;
};


/**
 * Structure representing a Lock
 */
struct Lock
{
  /**
   * List head of clients waiting for this lock
   */
  struct WaitList *wl_head;

  /**
   * List tail of clients waiting for this lock
   */
  struct WaitList *wl_tail;

  /**
   * The client which is currently holding this lock
   */
  struct ClientList *cl_entry;

  /**
   * The name of the locking domain this lock belongs to
   */
  char *domain_name;

  /**
   * The number of this lock
   */
  uint32_t lock_num;
};


/**
 * A Lock element for a doubly linked list
 */
struct LockList
{
  /**
   * The next element pointer
   */
  struct LockList *next;

  /**
   * Pointer to the previous element
   */
  struct LockList *prev;

  /**
   * Pointer to the Lock
   */
  struct Lock *lock;
};


/**
 * Doubly linked list of clients having connections to us
 */
struct ClientList
{

  /**
   * The next client structure
   */
  struct ClientList *next;

  /**
   * The previous client structure
   */
  struct ClientList *prev;

  /**
   * Head of the doubly linked list of the currently held locks by this client
   */
  struct LockList *ll_head;

  /**
   * Tail of the doubly linked list of the currently held locks by this client
   */
  struct LockList *ll_tail;

  /**
   * Pointer to the client
   */
  struct GNUNET_SERVER_Client *client;
};


/**
 * Structure for matching a lock
 */
struct LockMatch
{
  /**
   * The matched LockingRequest entry; Should be NULL if no entry is found
   */
  struct Lock *matched_entry;

  /**
   * The locking domain name of the lock
   */
  const char *domain_name;

  /**
   * The lock number
   */
  uint32_t lock_num;
};


/**
 * Map of lock-keys to the 'struct LockList' entry for the key.
 */
static struct GNUNET_CONTAINER_MultiHashMap *lock_map;

/**
 * Head of the doubly linked list of clients currently connected
 */
static struct ClientList *cl_head;

/**
 * Tail of the doubly linked list of clients currently connected
 */
static struct ClientList *cl_tail;


/**
 * Get the key for the given lock in the 'lock_map'.
 *
 * @param domain_name
 * @param lock_number
 * @param key set to the key
 */
static void
get_key (const char *domain_name, uint32_t lock_number,
         struct GNUNET_HashCode *key)
{
  uint32_t *last_32;

  GNUNET_CRYPTO_hash (domain_name, strlen (domain_name), key);
  last_32 = (uint32_t *) key;
  *last_32 ^= lock_number;
}


/**
 * Hashmap iterator for matching a lock
 *
 * @param cls the LockMatch structure
 * @param key current key code
 * @param value value in the hash map (struct Lock)
 * @return GNUNET_YES if we should continue to
 *         iterate,
 *         GNUNET_NO if not.
 */
static int
match_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
{
  struct LockMatch *match = cls;
  struct Lock *lock = value;

  if ((match->lock_num == lock->lock_num) &&
      (0 == strcmp (match->domain_name, lock->domain_name)))
  {
    match->matched_entry = lock;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}


/**
 * Function to search for a lock in the global lock hashmap
 *
 * @param domain_name the name of the locking domain
 * @param lock_num the number of the lock
 * @return the lock if found; NULL if not
 */
static struct Lock *
find_lock (const char *domain_name, const uint32_t lock_num)
{
  struct LockMatch match;
  struct GNUNET_HashCode key;

  match.lock_num = lock_num;
  match.domain_name = domain_name;
  match.matched_entry = NULL;
  get_key (domain_name, lock_num, &key);
  GNUNET_CONTAINER_multihashmap_get_multiple (lock_map, &key, &match_iterator,
                                              &match);
  return match.matched_entry;
}


/**
 * Adds a lock to the global lock hashmap
 *
 * @param domain_name the name of the lock's locking domain
 * @param lock_num the lock number
 * @return pointer to the lock structure which is added to lock map
 */
static struct Lock *
add_lock (const char *domain_name, uint32_t lock_num)
{
  struct Lock *lock;
  struct GNUNET_HashCode key;
  size_t domain_name_len;

  lock = GNUNET_malloc (sizeof (struct Lock));
  domain_name_len = strlen (domain_name) + 1;
  lock->domain_name = GNUNET_malloc (domain_name_len);
  strncpy (lock->domain_name, domain_name, domain_name_len);
  lock->lock_num = lock_num;
  get_key (domain_name, lock_num, &key);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding a lock with num: %d and domain: %s to the lock map\n",
       lock->lock_num, lock->domain_name);
  GNUNET_CONTAINER_multihashmap_put (lock_map, &key, lock,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  return lock;
}


/**
 * Removes a lock from the lock map. The WaitList of the lock should be empty
 *
 * @param lock the lock to remove
 */
static void
remove_lock (struct Lock *lock)
{
  struct GNUNET_HashCode key;

  GNUNET_assert (NULL == lock->wl_head);
  get_key (lock->domain_name, lock->lock_num, &key);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing lock with num: %u, domain: %s from lock map\n", lock->lock_num,
       lock->domain_name);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (lock_map, &key, lock));
  GNUNET_free (lock->domain_name);
  GNUNET