src/lockmanager/gnunet-service-lockmanager.c

   1 /*
   2   This file is part of GNUnet.
   3   (C) 2012 Christian Grothoff (and other contributing authors)
   4
   5   GNUnet is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published
   7   by the Free Software Foundation; either version 2, or (at your
   8   option) any later version.
   9
  10   GNUnet is distributed in the hope that it will be useful, but
  11   WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13   General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with GNUnet; see the file COPYING.  If not, write to the
  17   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18   Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file lockmanager/gnunet-service-lockmanager.c
  23  * @brief implementation of the LOCKMANAGER service
  24  * @author Sree Harsha Totakura
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_container_lib.h"
  30 #include "gnunet_protocols.h"
  31 #include "gnunet_service_lib.h"
  32 #include "gnunet_server_lib.h"
  33
  34 #include "lockmanager.h"
  35
  36
  37 #define LOG(kind,...)                           \
  38   GNUNET_log (kind, __VA_ARGS__)
  39
  40 #define TIME_REL_MINS(min)                                      \
  41   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, min)
  42
  43 #define TIMEOUT TIME_REL_MINS(3)
  44
  45
  46 /**
  47  * Doubly linked list of clients having connections to us
  48  */
  49 struct ClientList;
  50
  51
  52 /**
  53  * Doubly linked list of clients waiting for a lock
  54  */
  55 struct WaitList
  56 {
  57   /**
  58    * The next client structure
  59    */
  60   struct WaitList *next;
  61
  62   /**
  63    * The prev client structure
  64    */
  65   struct WaitList *prev;
  66
  67   /**
  68    * Pointer to the client
  69    */
  70   struct ClientList *cl_entry;
  71 };
  72
  73
  74 /**
  75  * Structure representing a Lock
  76  */
  77 struct Lock
  78 {
  79   /**
  80    * List head of clients waiting for this lock
  81    */
  82   struct WaitList *wl_head;
  83
  84   /**
  85    * List tail of clients waiting for this lock
  86    */
  87   struct WaitList *wl_tail;
  88
  89   /**
  90    * The client which is currently holding this lock
  91    */
  92   struct ClientList *cl_entry;
  93
  94   /**
  95    * The name of the locking domain this lock belongs to
  96    */
  97   char *domain_name;
  98
  99   /**
 100    * The number of this lock
 101    */
 102   uint32_t lock_num;
 103 };
 104
 105
 106 /**
 107  * A Lock element for a doubly linked list
 108  */
 109 struct LockList
 110 {
 111   /**
 112    * The next element pointer
 113    */
 114   struct LockList *next;
 115
 116   /**
 117    * Pointer to the previous element
 118    */
 119   struct LockList *prev;
 120
 121   /**
 122    * Pointer to the Lock
 123    */
 124   struct Lock *lock;
 125 };
 126
 127
 128 /**
 129  * Doubly linked list of clients having connections to us
 130  */
 131 struct ClientList
 132 {
 133
 134   /**
 135    * The next client structure
 136    */
 137   struct ClientList *next;
 138
 139   /**
 140    * The previous client structure
 141    */
 142   struct ClientList *prev;
 143
 144   /**
 145    * Head of the doubly linked list of the currently held locks by this client
 146    */
 147   struct LockList *ll_head;
 148
 149   /**
 150    * Tail of the doubly linked list of the currently held locks by this client
 151    */
 152   struct LockList *ll_tail;
 153
 154   /**
 155    * Pointer to the client
 156    */
 157   struct GNUNET_SERVER_Client *client;
 158 };
 159
 160
 161 /**
 162  * Structure for matching a lock
 163  */
 164 struct LockMatch
 165 {
 166   /**
 167    * The matched LockingRequest entry; Should be NULL if no entry is found
 168    */
 169   struct Lock *matched_entry;
 170
 171   /**
 172    * The locking domain name of the lock
 173    */
 174   const char *domain_name;
 175
 176   /**
 177    * The lock number
 178    */
 179   uint32_t lock_num;
 180 };
 181
 182
 183 /**
 184  * Map of lock-keys to the 'struct LockList' entry for the key.
 185  */
 186 static struct GNUNET_CONTAINER_MultiHashMap *lock_map;
 187
 188 /**
 189  * Head of the doubly linked list of clients currently connected
 190  */
 191 static struct ClientList *cl_head;
 192
 193 /**
 194  * Tail of the doubly linked list of clients currently connected
 195  */
 196 static struct ClientList *cl_tail;
 197
 198
 199 /**
 200  * Get the key for the given lock in the 'lock_map'.
 201  *
 202  * @param domain_name
 203  * @param lock_number
 204  * @param key set to the key
 205  */
 206 static void
 207 get_key (const char *domain_name,
 208          uint32_t lock_number,
 209          struct GNUNET_HashCode *key)
 210 {
 211   uint32_t *last_32;
 212
 213   GNUNET_CRYPTO_hash (domain_name,
 214                       strlen (domain_name),
 215                       key);
 216   last_32 = (uint32_t *) key;
 217   *last_32 ^= lock_number;
 218 }
 219
 220
 221 /**
 222  * Hashmap iterator for matching a lock
 223  *
 224  * @param cls the LockMatch structure
 225  * @param key current key code
 226  * @param value value in the hash map (struct Lock)
 227  * @return GNUNET_YES if we should continue to
 228  *         iterate,
 229  *         GNUNET_NO if not.
 230  */
 231 static int
 232 match_iterator (void *cls, const GNUNET_HashCode *key, void *value)
 233 {
 234   struct LockMatch *match = cls;
 235   struct Lock *lock = value;
 236
 237   if ( (match->lock_num == lock->lock_num)
 238        && (0 == strcmp (match->domain_name, lock->domain_name)) )
 239   {
 240     match->matched_entry = lock;
 241     return GNUNET_NO;
 242   }
 243   return GNUNET_YES;
 244 }
 245
 246
 247 /**
 248  * Function to search for a lock in the global lock hashmap
 249  *
 250  * @param domain_name the name of the locking domain
 251  * @param lock_num the number of the lock
 252  * @return the lock if found; NULL if not
 253  */
 254 static struct Lock *
 255 find_lock (const char *domain_name,
 256            const uint32_t lock_num)
 257
 258 {
 259   struct LockMatch match;
 260   struct GNUNET_HashCode key;
 261
 262   match.lock_num = lock_num;
 263   match.domain_name = domain_name;
 264   match.matched_entry = NULL;
 265   get_key (domain_name, lock_num, &key);
 266   GNUNET_CONTAINER_multihashmap_get_multiple (lock_map,
 267                                               &key,
 268                                               &match_iterator,
 269                                               &match);
 270   return match.matched_entry;
 271 }
 272
 273
 274 /**
 275  * Adds a lock to the global lock hashmap
 276  *
 277  * @param domain_name the name of the lock's locking domain
 278  * @param lock_num the lock number
 279  * @return pointer to the lock structure which is added to lock map
 280  */
 281 static struct Lock *
 282 add_lock (const char *domain_name,
 283           uint32_t lock_num)
 284 {
 285   struct Lock *lock;
 286   struct GNUNET_HashCode key;
 287   size_t domain_name_len;
 288
 289   lock = GNUNET_malloc (sizeof (struct Lock));
 290   domain_name_len = strlen (domain_name) + 1;
 291   lock->domain_name = GNUNET_malloc (domain_name_len);
 292   strncpy (lock->domain_name, domain_name, domain_name_len);
 293   lock->lock_num = lock_num;
 294   get_key (domain_name, lock_num, &key);
 295   LOG (GNUNET_ERROR_TYPE_DEBUG,
 296        "Adding a lock with num: %d and domain: %s to the lock map\n",
 297        lock->lock_num, lock->domain_name);
 298   GNUNET_CONTAINER_multihashmap_put (lock_map,
 299                                      &key,
 300                                      lock,
 301                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 302   return lock;
 303 }
 304
 305
 306 /**
 307  * Removes a lock from the lock map. The WaitList of the lock should be empty
 308  *
 309  * @param lock the lock to remove
 310  */
 311 static void
 312 remove_lock (struct Lock *lock)
 313 {
 314   struct GNUNET_HashCode key;
 315
 316   GNUNET_assert (NULL == lock->wl_head);
 317   get_key (lock->domain_name,
 318            lock->lock_num,
 319            &key);
 320   LOG (GNUNET_ERROR_TYPE_DEBUG,
 321        "Removing lock with num: %u, domain: %s from lock map\n",
 322        lock->lock_num, lock->domain_name);
 323   GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove
 324                  (lock_map, &key, lock));
 325   GNUNET_free (lock->domain_name);
 326   GNUNET_free (lock);
 327 }
 328
 329
 330 /**
 331  * Find the LockList entry corresponding to the given Lock in a ClientList
 332  * entry
 333  *
 334  * @param cl_entry the ClientList entry whose lock list has to be searched
 335  * @param lock the lock which has to be matched
 336  * @return the matching LockList entry; NULL if no match is found
 337  */
 338 static struct LockList *
 339 cl_ll_find_lock (struct ClientList *cl_entry,
 340                  const struct Lock *lock)
 341 {
 342   struct LockList *ll_entry;
 343
 344   for (ll_entry = cl_entry->ll_head;
 345        NULL != ll_entry; ll_entry = ll_entry->next)
 346   {
 347     if (lock == ll_entry->lock)
 348       return ll_entry;
 349   }
 350   return NULL;
 351 }
 352
 353
 354 /**
 355  * Function to append a lock to the lock list of a ClientList entry
 356  *
 357  * @param cl_entry the client which currently owns this lock
 358  * @param lock the lock to be added to the cl_entry's lock list
 359  */
 360 static void
 361 cl_ll_add_lock (struct ClientList *cl_entry,
 362                 struct Lock *lock)
 363 {
 364   struct LockList *ll_entry;
 365
 366   ll_entry = GNUNET_malloc (sizeof (struct LockList));
 367   ll_entry->lock = lock;
 368   LOG (GNUNET_ERROR_TYPE_DEBUG,
 369        "Adding a lock with num: %u and domain: %s to lock list\n",
 370        lock->lock_num, lock->domain_name);
 371   GNUNET_CONTAINER_DLL_insert_tail (cl_entry->ll_head,
 372                                     cl_entry->ll_tail,
 373                                     ll_entry);
 374 }
 375
 376
 377 /**
 378  * Function to delete a lock from the lock list of the given ClientList entry
 379  *
 380  * @param cl_entry the ClientList entry
 381  * @param ll_entry the LockList entry to be deleted
 382  */
 383 static void
 384 cl_ll_remove_lock (struct ClientList *cl_entry,
 385                    struct LockList *ll_entry)
 386 {
 387   LOG (GNUNET_ERROR_TYPE_DEBUG,
 388        "Removing lock with num: %u, domain: %s from lock list of a client\n",
 389        ll_entry->lock->lock_num,
 390        ll_entry->lock->domain_name);
 391   GNUNET_assert (NULL != cl_entry->ll_head);
 392   GNUNET_CONTAINER_DLL_remove (cl_entry->ll_head,
 393                                cl_entry->ll_tail,
 394                                ll_entry);
 395   GNUNET_free (ll_entry);
 396 }
 397
 398
 399 /**
 400  * Find a WaitList entry in the waiting list of a lock
 401  *
 402  * @param lock the lock whose wait list has to be searched
 403  * @param cl_entry the ClientList entry to be searched
 404  * @return the WaitList entry matching the given cl_entry; NULL if not match
 405  *           was found
 406  */
 407 static struct WaitList *
 408 lock_wl_find (const struct Lock *lock,
 409               const struct ClientList *cl_entry)
 410 {
 411   struct WaitList *wl_entry;
 412
 413   for (wl_entry = lock->wl_head;
 414        NULL != wl_entry;
 415        wl_entry = wl_entry->next)
 416   {
 417     if (cl_entry == wl_entry->cl_entry)
 418       return wl_entry;
 419   }
 420   return NULL;
 421 }
 422
 423
 424 /**
 425  * Add a client to the wait list of given lock
 426  *
 427  * @param lock the lock list entry of a lock
 428  * @param cl_entry the client to queue for the lock's wait list
 429  */
 430 static void
 431 lock_wl_add_client (struct Lock *lock,
 432                     struct ClientList *cl_entry)
 433 {
 434   struct WaitList *wl_entry;
 435
 436   LOG (GNUNET_ERROR_TYPE_DEBUG,
 437        "Adding a client to lock's wait list (lock num: %u, domain: %s)\n",
 438        lock->lock_num,
 439        lock->domain_name);
 440   wl_entry = GNUNET_malloc (sizeof (struct WaitList));
 441   wl_entry->cl_entry = cl_entry;
 442   GNUNET_CONTAINER_DLL_insert_tail (lock->wl_head,
 443                                     lock->wl_tail,
 444                                     wl_entry);
 445 }
 446
 447
 448 /**
 449  * Remove an entry from the wait list of the given lock
 450  *
 451  * @param lock the lock
 452  * @param wl_entry the wait list entry to be removed
 453  */
 454 static void
 455 lock_wl_remove (struct Lock *lock,
 456                 struct WaitList *wl_entry)
 457 {
 458   LOG (GNUNET_ERROR_TYPE_DEBUG,
 459        "Removing client from wait list of lock with num: %u, domain: %s\n",
 460        lock->lock_num, lock->domain_name);
 461   GNUNET_CONTAINER_DLL_remove (lock->wl_head,
 462                                lock->wl_tail,
 463                                wl_entry);
 464   GNUNET_free (wl_entry);
 465 }
 466
 467
 468 /**
 469  * Search for a client in the client list
 470  *
 471  * @param client the client to be searched for
 472  * @return the ClientList entry; NULL if the client is not found
 473  */
 474 static struct ClientList *
 475 cl_find_client (const struct GNUNET_SERVER_Client *client)
 476 {
 477   struct ClientList *current;
 478
 479   for (current = cl_head; NULL != current; current = current->next)
 480     if (client == current->client)
 481       return current;
 482   return NULL;
 483 }
 484
 485
 486 /**
 487  * Append a client to the client list
 488  *
 489  * @param client the client to be appended to the list
 490  * @return the client list entry which is added to the client list
 491  */
 492 static struct ClientList *
 493 cl_add_client (struct GNUNET_SERVER_Client *client)
 494 {
 495   struct ClientList *new_client;
 496
 497   LOG (GNUNET_ERROR_TYPE_DEBUG,
 498        "Adding a client to the client list\n");
 499   new_client = GNUNET_malloc (sizeof (struct ClientList));
 500   GNUNET_SERVER_client_keep (client);
 501   new_client->client = client;
 502   GNUNET_CONTAINER_DLL_insert_tail (cl_head,
 503                                     cl_tail,
 504                                     new_client);
 505   return new_client;
 506 }
 507
 508
 509 /**
 510  * Delete the given client from the client list. The LockList should be empty
 511  *
 512  * @param cl_entry the client list entry to delete
 513  */
 514 static void
 515 cl_remove_client (struct ClientList *cl_entry)
 516 {
 517   GNUNET_assert (NULL == cl_entry->ll_head);
 518   LOG (GNUNET_ERROR_TYPE_DEBUG,
 519        "Removing a client from the client list\n");
 520   GNUNET_SERVER_client_drop (cl_entry->client);
 521   GNUNET_CONTAINER_DLL_remove (cl_head,
 522                                cl_tail,
 523                                cl_entry);
 524   GNUNET_free (cl_entry);
 525 }
 526
 527
 528 /**
 529  * Transmit notify for sending message to client
 530  *
 531  * @param cls the message to send
 532  * @param size number of bytes available in buf
 533  * @param buf where the callee should write the message
 534  * @return number of bytes written to buf
 535  */
 536 static size_t
 537 transmit_notify (void *cls, size_t size, void *buf)
 538 {
 539   struct GNUNET_LOCKMANAGER_Message *msg = cls;
 540   uint16_t msg_size;
 541
 542   if ((0 == size) || (NULL == buf))
 543   {
 544     /* FIXME: Timed out -- requeue? */
 545     return 0;
 546   }
 547   msg_size = ntohs (msg->header.size);
 548   GNUNET_assert (size >= msg_size);
 549   memcpy (buf, msg, msg_size);
 550   GNUNET_free (msg);
 551   LOG (GNUNET_ERROR_TYPE_DEBUG,
 552        "Message of size %u sent\n", msg_size);
 553   return msg_size;
 554 }
 555
 556
 557 /**
 558  * Send SUCCESS message to the client
 559  *
 560  * @param client the client to which the message has to be sent
 561  * @param domain_name the locking domain of the successfully acquried lock
 562  * @param lock_num the number of the successfully acquired lock
 563  */
 564 static void
 565 send_success_msg (struct GNUNET_SERVER_Client *client,
 566                   const char *domain_name,
 567                   int lock_num)
 568 {
 569   struct GNUNET_LOCKMANAGER_Message *reply;
 570   size_t domain_name_len;
 571   uint16_t reply_size;
 572
 573   domain_name_len = strlen (domain_name) + 1;
 574   reply_size = sizeof (struct GNUNET_LOCKMANAGER_Message) + domain_name_len;
 575   reply = GNUNET_malloc (reply_size);
 576   reply->header.size = htons (reply_size);
 577   reply->header.type = htons (GNUNET_MESSAGE_TYPE_LOCKMANAGER_SUCCESS);
 578   reply->lock = htonl (lock_num);
 579   strncpy ((char *) &reply[1], domain_name, domain_name_len);
 580   LOG (GNUNET_ERROR_TYPE_DEBUG,
 581        "Sending SUCCESS message for lock with num: %u, domain: %s\n",
 582        lock_num, domain_name);
 583   GNUNET_SERVER_notify_transmit_ready (client,
 584                                        reply_size,
 585                                        TIMEOUT,
 586                                        &transmit_notify,
 587                                        reply);
 588 }
 589
 590
 591 /**
 592  * Handler for GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE
 593  *
 594  * @param cls NULL
 595  * @param client the client sending this message
 596  * @param message GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE message
 597  */
 598 static void
 599 handle_acquire (void *cls,
 600                 struct GNUNET_SERVER_Client *client,
 601                 const struct GNUNET_MessageHeader *message)
 602 {
 603   const struct GNUNET_LOCKMANAGER_Message *request;
 604   const char *domain_name;
 605   struct Lock *lock;
 606   struct ClientList *cl_entry;
 607   uint32_t lock_num;
 608   uint16_t msize;
 609
 610   msize = htons (message->size);
 611   if (msize <= sizeof (struct GNUNET_LOCKMANAGER_Message))
 612   {
 613     GNUNET_break (0);
 614     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 615     return;
 616   }
 617   request = (struct GNUNET_LOCKMANAGER_Message *) message;
 618   domain_name = (const char *) &request[1];
 619   msize -= sizeof (struct GNUNET_LOCKMANAGER_Message);
 620   if ('\0' != domain_name[msize])
 621   {
 622     GNUNET_break (0);
 623     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 624     return;
 625   }
 626   lock_num = ntohl (request->lock);
 627   LOG (GNUNET_ERROR_TYPE_DEBUG,
 628        "Received an ACQUIRE message for lock num: %u domain: %s\n",
 629        lock_num, domain_name);
 630   if (NULL == (cl_entry = cl_find_client (client)))
 631     cl_entry = cl_add_client (client); /* Add client if not in client list */
 632   if (NULL != (lock = find_lock (domain_name,lock_num)))
 633   {
 634     if (lock->cl_entry == cl_entry)
 635     {                         /* Client is requesting a lock it already owns */
 636       GNUNET_break (0);
 637       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 638       return;
 639     }
 640     lock_wl_add_client (lock, cl_entry);
 641     cl_ll_add_lock (cl_entry, lock);
 642   }
 643   else                          /* Lock not present */
 644   {
 645     lock = add_lock (domain_name, lock_num);
 646     lock->cl_entry = cl_entry;
 647     cl_ll_add_lock (cl_entry, lock);
 648     send_success_msg (cl_entry->client, domain_name, lock_num);
 649   }
 650   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 651 }
 652
 653
 654 /**
 655  * This function gives the lock to the first client in the wait list of the
 656  * lock. If no clients are currently waiting for this lock, the lock is then
 657  * destroyed.
 658  *
 659  * @param lock the lock which has to be processed for release
 660  */
 661 static void
 662 process_lock_release (struct Lock *lock)
 663 {
 664   struct WaitList *wl_entry;
 665
 666   LOG (GNUNET_ERROR_TYPE_DEBUG,
 667        "Processing lock release for lock with num: %u, domain: %s\n",
 668        lock->lock_num, lock->domain_name);
 669   wl_entry = lock->wl_head;
 670   if (NULL == wl_entry)
 671   {
 672     remove_lock (lock);   /* No clients waiting for this lock - delete */
 673     return;
 674   }
 675   LOG (GNUNET_ERROR_TYPE_DEBUG,
 676        "Giving lock to a client from wait list\n");
 677   lock->cl_entry = wl_entry->cl_entry;
 678   lock_wl_remove(lock, wl_entry);
 679   send_success_msg (lock->cl_entry->client,
 680                     lock->domain_name,
 681                     lock->lock_num);
 682   return;
 683 }
 684
 685
 686 /**
 687  * Handle for GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE
 688  *
 689  * @param cls NULL
 690  * @param client the client sending this message
 691  * @param message the LOCKMANAGER_RELEASE message
 692  */
 693 static void
 694 handle_release (void *cls,
 695                 struct GNUNET_SERVER_Client *client,
 696                 const struct GNUNET_MessageHeader *message)
 697 {
 698   const struct GNUNET_LOCKMANAGER_Message *request;
 699   struct ClientList *cl_entry;
 700   struct WaitList *wl_entry;
 701   struct LockList *ll_entry;
 702   const char *domain_name;
 703   struct Lock *lock;
 704   uint32_t lock_num;
 705   uint16_t msize;
 706
 707   msize = ntohs (message->size);
 708   if (msize <= sizeof (struct GNUNET_LOCKMANAGER_Message))
 709   {
 710     GNUNET_break (0);
 711     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 712     return;
 713   }
 714   request = (const struct GNUNET_LOCKMANAGER_Message *) message;
 715   domain_name = (const char *) &request[1];
 716   msize -= sizeof (struct GNUNET_LOCKMANAGER_Message);
 717   if ('\0' != domain_name[msize-1])
 718   {
 719     GNUNET_break (0);
 720     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 721     return;
 722
 723
 724   }
 725   lock_num = ntohl (request->lock);
 726   LOG (GNUNET_ERROR_TYPE_DEBUG,
 727        "Received RELEASE message for lock with num: %d, domain: %s\n",
 728        lock_num, domain_name);
 729   if (NULL == (cl_entry = cl_find_client (client)))
 730   {
 731     GNUNET_break(0);
 732     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 733     return;
 734   }
 735   lock = find_lock (domain_name, lock_num);
 736   if(NULL == lock)
 737   {
 738     GNUNET_break (0);
 739     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 740     return;
 741   }
 742   if (NULL == (ll_entry = cl_ll_find_lock (cl_entry, lock)))
 743   {
 744     GNUNET_break (0);
 745     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 746     return;
 747   }
 748   cl_ll_remove_lock (cl_entry, ll_entry);
 749   if (cl_entry == lock->cl_entry)
 750   {
 751     process_lock_release (lock);
 752     GNUNET_SERVER_receive_done (client, GNUNET_OK);
 753     return;
 754   }
 755   /* remove 'client' from wait list (check that it is not there...) */
 756   if (NULL != (wl_entry = lock_wl_find (lock, cl_entry)))
 757   {
 758     lock_wl_remove (lock, wl_entry);
 759   }
 760   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 761 }
 762
 763
 764 /**
 765  * Callback for client disconnect
 766  *
 767  * @param cls NULL
 768  * @param client the client which has disconnected
 769  */
 770 static void
 771 client_disconnect_cb (void *cls, struct GNUNET_SERVER_Client *client)
 772 {
 773   struct ClientList *cl_entry;
 774   struct LockList *ll_entry;
 775
 776   if (NULL == client)
 777     return;
 778   LOG (GNUNET_ERROR_TYPE_DEBUG,
 779        "A client has been disconnected -- freeing its locks and resources\n");
 780   cl_entry = cl_find_client (client);
 781   if (NULL == cl_entry)
 782     return;
 783   while (NULL != (ll_entry = cl_entry->ll_head))
 784   {
 785     cl_ll_remove_lock (cl_entry, ll_entry);
 786     process_lock_release (ll_entry->lock);
 787   }
 788   cl_remove_client (cl_entry);
 789 }
 790
 791
 792 /**
 793  * Hashmap Iterator to delete lock entries in hash map
 794  *
 795  * @param cls NULL
 796  * @param key current key code
 797  * @param value value in the hash map
 798  * @return GNUNET_YES if we should continue to
 799  *         iterate,
 800  *         GNUNET_NO if not.
 801  */
 802 static int
 803 lock_delete_iterator (void *cls,
 804                       const GNUNET_HashCode * key,
 805                       void *value)
 806 {
 807   struct Lock *lock = value;
 808
 809   GNUNET_assert (NULL != lock);
 810   while (NULL != lock->wl_head)
 811   {
 812     lock_wl_remove (lock, lock->wl_head);
 813   }
 814   GNUNET_assert (GNUNET_YES ==
 815                  GNUNET_CONTAINER_multihashmap_remove(lock_map,
 816                                                       key,
 817                                                       lock));
 818   GNUNET_free (lock->domain_name);
 819   GNUNET_free (lock);
 820   return GNUNET_YES;
 821 }
 822
 823
 824 /**
 825  * Task to clean up and shutdown nicely
 826  *
 827  * @param cls NULL
 828  * @param tc the TaskContext from scheduler
 829  */
 830 static void
 831 shutdown_task (void *cls,
 832                const struct GNUNET_SCHEDULER_TaskContext *tc)
 833 {
 834   LOG (GNUNET_ERROR_TYPE_DEBUG,
 835        "Shutting down lock manager\n");
 836   /* Clean the global ClientList */
 837   while (NULL != cl_head)
 838   {
 839     while (NULL != cl_head->ll_head) /* Clear the LockList */
 840     {
 841       cl_ll_remove_lock (cl_head, cl_head->ll_head);
 842     }
 843     cl_remove_client (cl_head);
 844   }
 845   /* Clean the global hash table */
 846   GNUNET_CONTAINER_multihashmap_iterate (lock_map,
 847                                          &lock_delete_iterator,
 848                                          NULL);
 849   GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (lock_map));
 850   GNUNET_CONTAINER_multihashmap_destroy (lock_map);
 851 }
 852
 853
 854 /**
 855  * Lock manager setup
 856  *
 857  * @param cls closure
 858  * @param server the initialized server
 859  * @param cfg configuration to use
 860  */
 861 static void
 862 lockmanager_run (void *cls,
 863                  struct GNUNET_SERVER_Handle * server,
 864                  const struct GNUNET_CONFIGURATION_Handle *cfg)
 865 {
 866   static const struct GNUNET_SERVER_MessageHandler message_handlers[] =
 867     {
 868       {&handle_acquire, NULL, GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE, 0},
 869       {&handle_release, NULL, GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE, 0},
 870       {NULL}
 871     };
 872   GNUNET_SERVER_add_handlers (server,
 873                               message_handlers);
 874   GNUNET_SERVER_disconnect_notify (server,
 875                                    &client_disconnect_cb,
 876                                    NULL);
 877   lock_map = GNUNET_CONTAINER_multihashmap_create (30);
 878   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 879                                 &shutdown_task,
 880                                 NULL);
 881 }
 882
 883
 884 /**
 885  * The starting point of execution
 886  */
 887 int main (int argc, char *const *argv)
 888 {
 889   return
 890     (GNUNET_OK ==
 891      GNUNET_SERVICE_run (argc,
 892                          argv,
 893                          "lockmanager",
 894                          GNUNET_SERVICE_OPTION_NONE,
 895                          &lockmanager_run,
 896                          NULL)) ? 0 : 1;
 897 }