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_protocols.h"
  30 #include "gnunet_service_lib.h"
  31 #include "gnunet_server_lib.h"
  32
  33 #include "lockmanager.h"
  34
  35 #define LOG(kind,...) \
  36   GNUNET_log_from (kind, "gnunet-service-lockmanager",__VA_ARGS__)
  37
  38 #define TIME_REL_MINS(min) \
  39   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, min)
  40
  41 #define TIMEOUT TIME_REL_MINS(3)
  42
  43 /**
  44  * Transmit notify for sending message to client
  45  *
  46  * @param cls the message to send
  47  * @param size number of bytes available in buf
  48  * @param buf where the callee should write the message
  49  * @return number of bytes written to buf
  50  */
  51 static size_t
  52 transmit_notify (void *cls, size_t size, void *buf)
  53 {
  54   struct GNUNET_LOCKMANAGER_Message *msg = cls;
  55   uint16_t msg_size;
  56
  57   if ((0 == size) || (NULL == buf))
  58     {
  59       /* FIXME: Timed out -- requeue? */
  60       return 0;
  61     }
  62   msg_size = ntohs (msg->header.size);
  63   GNUNET_assert (size >= msg_size);
  64   memcpy (buf, msg, msg_size);
  65   GNUNET_free (msg);
  66   LOG (GNUNET_ERROR_TYPE_DEBUG,
  67        "Message of size %u sent\n", msg_size);
  68   return msg_size;
  69 }
  70
  71
  72 /**
  73  * Handler for GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE
  74  *
  75  * @param cls NULL
  76  * @param client the client sending this message
  77  * @param message GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE message
  78  */
  79 static void
  80 handle_acquire (void *cls,
  81                 struct GNUNET_SERVER_Client *client,
  82                 const struct GNUNET_MessageHeader *message)
  83 {
  84   const struct GNUNET_LOCKMANAGER_Message *request;
  85   struct GNUNET_LOCKMANAGER_Message *reply;
  86   int16_t request_size;
  87
  88
  89   LOG (GNUNET_ERROR_TYPE_DEBUG,
  90        "Received an ACQUIRE message\n");
  91
  92   request = (struct GNUNET_LOCKMANAGER_Message *) message;
  93
  94   /* FIXME: Dummy implementation; just echos success for every lock */
  95   request_size = ntohs (message->size);
  96   reply = GNUNET_malloc (request_size);
  97   memcpy (reply, request, request_size);
  98   reply->header.type = htons (GNUNET_MESSAGE_TYPE_LOCKMANAGER_SUCCESS);
  99   GNUNET_SERVER_notify_transmit_ready (client,
 100                                        request_size,
 101                                        TIMEOUT,
 102                                        &transmit_notify,
 103                                        reply);
 104
 105   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 106 }
 107
 108
 109 /**
 110  * Handle for GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE
 111  *
 112  * @param
 113  * @return
 114  */
 115 static void
 116 handle_release (void *cls,
 117                 struct GNUNET_SERVER_Client *client,
 118                 const struct GNUNET_MessageHeader *message)
 119 {
 120   LOG (GNUNET_ERROR_TYPE_DEBUG,
 121        "Received a RELEASE message\n");
 122
 123   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 124 }
 125
 126
 127 /**
 128  * Lock manager setup
 129  *
 130  * @param cls closure
 131  * @param server the initialized server
 132  * @param cfg configuration to use
 133  */
 134 static void
 135 lockmanager_run (void *cls,
 136                  struct GNUNET_SERVER_Handle * server,
 137                  const struct GNUNET_CONFIGURATION_Handle *cfg)
 138 {
 139   static const struct GNUNET_SERVER_MessageHandler message_handlers[] =
 140     {
 141       {&handle_acquire, NULL, GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE, 0},
 142       {&handle_release, NULL, GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE, 0},
 143       {NULL}
 144     };
 145
 146   LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting lockmanager\n");
 147   GNUNET_SERVER_add_handlers (server,
 148                               message_handlers);
 149
 150 }
 151
 152 /**
 153  * The starting point of execution
 154  */
 155 int main (int argc, char *const *argv)
 156 {
 157   int ret;
 158
 159   LOG (GNUNET_ERROR_TYPE_DEBUG, "main()\n");
 160   ret =
 161     (GNUNET_OK ==
 162      GNUNET_SERVICE_run (argc,
 163                          argv,
 164                          "lockmanager",
 165                          GNUNET_SERVICE_OPTION_NONE,
 166                          &lockmanager_run,
 167                          NULL)) ? 0 : 1;
 168   LOG (GNUNET_ERROR_TYPE_DEBUG, "main() END\n");
 169   return ret;
 170 }