src/rps/rps_api.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C)
   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 3, 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 rps/rps_api.c
  23  * @brief API for rps
  24  * @author Julius Bünger
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "rps.h"
  29 #include "gnunet_rps_service.h"
  30
  31 #include <inttypes.h>
  32
  33 #define LOG(kind,...) GNUNET_log_from (kind, "rps-api",__VA_ARGS__)
  34
  35 /**
  36  * Handler to handle requests from a client.
  37  */
  38 struct GNUNET_RPS_Handle
  39 {
  40   /**
  41    * The handle to the client configuration.
  42    */
  43   const struct GNUNET_CONFIGURATION_Handle *cfg;
  44
  45   /**
  46    * The connection to the client.
  47    */
  48   struct GNUNET_CLIENT_Connection *conn;
  49
  50   /**
  51    * The message queue to the client.
  52    */
  53   struct GNUNET_MQ_Handle *mq;
  54 };
  55
  56
  57 /**
  58  * Handler to single requests from the client.
  59  */
  60 struct GNUNET_RPS_Request_Handle
  61 {
  62   /**
  63    * The client issuing the request.
  64    */
  65   struct GNUNET_RPS_Handle *rps_handle;
  66
  67   /**
  68    * The id of the request.
  69    */
  70   uint32_t id;
  71
  72   /**
  73    * The callback to be called when we receive an answer.
  74    */
  75   GNUNET_RPS_NotifyReadyCB ready_cb;
  76
  77   /**
  78    * The closure for the callback.
  79    */
  80   void *ready_cb_cls;
  81 };
  82
  83
  84 /**
  85  * Array of Request_Handles.
  86  */
  87 struct GNUNET_RPS_Request_Handle *req_handlers = NULL;
  88
  89 /**
  90  * Current length of req_handlers.
  91  */
  92 unsigned int req_handlers_size = 0;
  93
  94
  95 /**
  96  * Struct used to pack the callback, its closure (provided by the caller)
  97  * and the connection handler to the service to pass it to a callback function.
  98  */
  99 struct cb_cls_pack
 100 {
 101   /**
 102    * Callback provided by the client
 103    */
 104   GNUNET_RPS_NotifyReadyCB cb;
 105
 106   /**
 107    * Closure provided by the client
 108    */
 109   void *cls;
 110
 111   /**
 112    * Handle to the service connection
 113    */
 114  struct GNUNET_CLIENT_Connection *service_conn;
 115 };
 116
 117
 118 /**
 119  * This function is called, when the service replies to our request.
 120  * It calls the callback the caller gave us with the provided closure
 121  * and disconnects afterwards.
 122  *
 123  * @param cls the closure
 124  * @param message the message
 125  */
 126   static void
 127 handle_reply (void *cls,
 128               const struct GNUNET_MessageHeader *message)
 129 {
 130   struct GNUNET_RPS_CS_ReplyMessage *msg;
 131   struct GNUNET_PeerIdentity *peers;
 132   struct GNUNET_RPS_Request_Handle *rh;
 133
 134   /* Give the peers back */
 135   msg = (struct GNUNET_RPS_CS_ReplyMessage *) message;
 136
 137   LOG (GNUNET_ERROR_TYPE_DEBUG,
 138        "Service replied with %" PRIu32 " peers for id %" PRIu32 "\n",
 139        ntohl (msg->num_peers),
 140        ntohl (msg->id));
 141
 142   peers = (struct GNUNET_PeerIdentity *) &msg[1];
 143   rh = &req_handlers[ntohl (msg->id)];
 144   rh->ready_cb((rh)->ready_cb_cls, ntohl (msg->num_peers), peers);
 145 }
 146
 147
 148 /**
 149  * Error handler for mq.
 150  *
 151  * This function is called whan mq encounters an error.
 152  * Until now mq doesn't provide useful error messages.
 153  *
 154  * @param cls the closure
 155  * @param error error code without specyfied meaning
 156  */
 157   static void
 158 mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 159 {
 160   //TODO LOG
 161   LOG (GNUNET_ERROR_TYPE_WARNING, "Some problem with the message queue. error: %i\n\
 162        1: READ,\n\
 163        2: WRITE,\n\
 164        4: TIMEOUT\n",
 165        error);
 166
 167 }
 168
 169 /**
 170  * Connect to the rps service
 171  *
 172  * @param cfg configuration to use
 173  * @return a handle to the service
 174  */
 175   struct GNUNET_RPS_Handle *
 176 GNUNET_RPS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 177 {
 178   struct GNUNET_RPS_Handle *h;
 179   //struct GNUNET_RPS_Request_Handle *rh;
 180   static const struct GNUNET_MQ_MessageHandler mq_handlers[] = {
 181     {&handle_reply, GNUNET_MESSAGE_TYPE_RPS_CS_REPLY, 0},
 182     GNUNET_MQ_HANDLERS_END
 183   };
 184
 185   h = GNUNET_new(struct GNUNET_RPS_Handle);
 186   //h->cfg = GNUNET_new(struct GNUNET_CONFIGURATION_Handle);
 187   //*h->cfg = *cfg;
 188   h->cfg = cfg; // FIXME |^
 189   h->conn = GNUNET_CLIENT_connect("rps", cfg);
 190   h->mq = GNUNET_MQ_queue_for_connection_client(h->conn,
 191                                                 mq_handlers,
 192                                                 mq_error_handler, // TODO implement
 193                                                 h);
 194
 195   return h;
 196 }
 197
 198
 199 /**
 200  * Request n random peers.
 201  *
 202  * @param rps_handle handle to the rps service
 203  * @param num_req_peers number of peers we want to receive
 204  * @param ready_cb the callback called when the peers are available
 205  * @param cls closure given to the callback
 206  * @return a handle to cancel this request
 207  */
 208   struct GNUNET_RPS_Request_Handle *
 209 GNUNET_RPS_request_peers (struct GNUNET_RPS_Handle *rps_handle,
 210                           uint32_t num_req_peers,
 211                           GNUNET_RPS_NotifyReadyCB ready_cb,
 212                           void *cls)
 213 {
 214   struct GNUNET_RPS_Request_Handle *rh;
 215   struct GNUNET_MQ_Envelope *ev;
 216   struct GNUNET_RPS_CS_RequestMessage *msg;
 217
 218   // assert func != NULL
 219   rh = GNUNET_new (struct GNUNET_RPS_Request_Handle);
 220   rh->rps_handle = rps_handle;
 221   rh->id = req_handlers_size; // TODO ntoh
 222   rh->ready_cb = ready_cb;
 223   rh->ready_cb_cls = cls;
 224
 225   LOG (GNUNET_ERROR_TYPE_DEBUG,
 226        "Requesting %" PRIu32 " peers with id %" PRIu32 "\n",
 227        num_req_peers,
 228        rh->id);
 229
 230   GNUNET_array_append (req_handlers, req_handlers_size, *rh);
 231   //memcpy(&req_handlers[req_handlers_size-1], rh, sizeof(struct GNUNET_RPS_Request_Handle));
 232
 233   ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST);
 234   msg->num_peers = htonl (num_req_peers);
 235   msg->id = htonl (rh->id);
 236   GNUNET_MQ_send (rps_handle->mq, ev);
 237   return rh;
 238 }
 239
 240
 241 /**
 242  * Seed rps service with peerIDs.
 243  *
 244  * @param h handle to the rps service
 245  * @param n number of peers to seed
 246  * @param ids the ids of the peers seeded
 247  */
 248   void
 249 GNUNET_RPS_seed_ids (struct GNUNET_RPS_Handle *h,
 250                      uint32_t n,
 251                      const struct GNUNET_PeerIdentity *ids)
 252 {
 253   size_t size_needed;
 254   uint32_t num_peers_max;
 255   const struct GNUNET_PeerIdentity *tmp_peer_pointer;
 256   struct GNUNET_MQ_Envelope *ev;
 257   struct GNUNET_RPS_CS_SeedMessage *msg;
 258
 259   unsigned int i;
 260
 261   LOG (GNUNET_ERROR_TYPE_DEBUG,
 262        "Client wants to seed %" PRIu32 " peers:\n",
 263        n);
 264   for (i = 0 ; i < n ; i++)
 265     LOG (GNUNET_ERROR_TYPE_DEBUG,
 266          "%u. peer: %s\n",
 267          i,
 268          GNUNET_i2s (&ids[i]));
 269
 270   /* The actual size the message occupies */
 271   size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
 272     n * sizeof (struct GNUNET_PeerIdentity);
 273   /* The number of peers that fits in one message together with
 274    * the respective header */
 275   num_peers_max = (GNUNET_SERVER_MAX_MESSAGE_SIZE -
 276       sizeof (struct GNUNET_RPS_CS_SeedMessage)) /
 277     sizeof (struct GNUNET_PeerIdentity);
 278   tmp_peer_pointer = ids;
 279
 280   while (GNUNET_SERVER_MAX_MESSAGE_SIZE < size_needed)
 281   {
 282     ev = GNUNET_MQ_msg_extra (msg, num_peers_max * sizeof (struct GNUNET_PeerIdentity),
 283         GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
 284     msg->num_peers = htonl (num_peers_max);
 285     memcpy (&msg[1], tmp_peer_pointer, num_peers_max * sizeof (struct GNUNET_PeerIdentity));
 286     GNUNET_MQ_send (h->mq, ev);
 287
 288     n -= num_peers_max;
 289     size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
 290                   n * sizeof (struct GNUNET_PeerIdentity);
 291     /* Set pointer to beginning of next block of num_peers_max peers */
 292     tmp_peer_pointer = &ids[num_peers_max];
 293   }
 294
 295   ev = GNUNET_MQ_msg_extra (msg, n * sizeof (struct GNUNET_PeerIdentity),
 296                             GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
 297   msg->num_peers = htonl (n);
 298   memcpy (&msg[1], tmp_peer_pointer, n * sizeof (struct GNUNET_PeerIdentity));
 299
 300   GNUNET_MQ_send (h->mq, ev);
 301 }
 302
 303
 304 #ifdef ENABLE_MALICIOUS
 305 /**
 306  * Turn RPS service to act malicious.
 307  *
 308  * @param h handle to the rps service
 309  * @param type which type of malicious peer to turn to.
 310  *             0 Don't act malicious at all
 311  *             1 Try to maximise representation
 312  *             2 Try to partition the network
 313  *               (isolate one peer from the rest)
 314  * @param n number of @a ids
 315  * @param ids the ids of the malicious peers
 316  *            if @type is 2 the last id is the id of the
 317  *            peer to be isolated from the rest
 318  */
 319   void
 320 GNUNET_RPS_act_malicious (struct GNUNET_RPS_Handle *h,
 321                           uint32_t type,
 322                           uint32_t num_peers,
 323                           const struct GNUNET_PeerIdentity *peer_ids)
 324 {
 325   size_t size_needed;
 326   uint32_t num_peers_max;
 327   const struct GNUNET_PeerIdentity *tmp_peer_pointer;
 328   struct GNUNET_MQ_Envelope *ev;
 329   struct GNUNET_RPS_CS_ActMaliciousMessage *msg;
 330
 331   unsigned int i;
 332
 333   LOG (GNUNET_ERROR_TYPE_DEBUG,
 334        "Client turns malicious (type %" PRIu32 ") with %" PRIu32 " other peers:\n",
 335        type,
 336        num_peers);
 337   for (i = 0 ; i < num_peers ; i++)
 338     LOG (GNUNET_ERROR_TYPE_DEBUG,
 339          "%u. peer: %s\n",
 340          i,
 341          GNUNET_i2s (&peer_ids[i]));
 342
 343   /* The actual size the message would occupy */
 344   size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
 345     num_peers * sizeof (struct GNUNET_PeerIdentity);
 346   /* The number of peers that fit in one message together with
 347    * the respective header */
 348   num_peers_max = (GNUNET_SERVER_MAX_MESSAGE_SIZE -
 349       sizeof (struct GNUNET_RPS_CS_SeedMessage)) /
 350     sizeof (struct GNUNET_PeerIdentity);
 351   tmp_peer_pointer = peer_ids;
 352
 353   while (GNUNET_SERVER_MAX_MESSAGE_SIZE < size_needed)
 354   {
 355     LOG (GNUNET_ERROR_TYPE_DEBUG,
 356          "Too many peers to send at once, sending %" PRIu32 " (all we can so far)\n",
 357          num_peers_max);
 358     ev = GNUNET_MQ_msg_extra (msg,
 359                               num_peers_max * sizeof (struct GNUNET_PeerIdentity),
 360                               GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
 361     msg->type = htonl (type);
 362     msg->num_peers = htonl (num_peers_max);
 363     if (2 == type
 364         || 3 == type)
 365       msg->attacked_peer = peer_ids[num_peers];
 366     memcpy (&msg[1],
 367             tmp_peer_pointer,
 368             num_peers_max * sizeof (struct GNUNET_PeerIdentity));
 369
 370     GNUNET_MQ_send (h->mq, ev);
 371
 372     num_peers -= num_peers_max;
 373     size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
 374                   num_peers * sizeof (struct GNUNET_PeerIdentity);
 375     /* Set pointer to beginning of next block of num_peers_max peers */
 376     tmp_peer_pointer = &peer_ids[num_peers_max];
 377   }
 378
 379   ev = GNUNET_MQ_msg_extra (msg,
 380                             num_peers * sizeof (struct GNUNET_PeerIdentity),
 381                             GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS);
 382   msg->type = htonl (type);
 383   msg->num_peers = htonl (num_peers);
 384   if (2 == type
 385       || 3 == type)
 386     msg->attacked_peer = peer_ids[num_peers];
 387   memcpy (&msg[1], tmp_peer_pointer, num_peers * sizeof (struct GNUNET_PeerIdentity));
 388
 389   GNUNET_MQ_send (h->mq, ev);
 390 }
 391 #endif /* ENABLE_MALICIOUS */
 392
 393
 394 /**
 395  * Cancle an issued request.
 396  *
 397  * @param rh request handle of request to cancle
 398  */
 399   void
 400 GNUNET_RPS_request_cancel (struct GNUNET_RPS_Request_Handle *rh)
 401 {
 402   // TODO
 403 }
 404
 405
 406 /**
 407  * Disconnect from the rps service
 408  *
 409  * @param h the handle to the rps service
 410  */
 411   void
 412 GNUNET_RPS_disconnect (struct GNUNET_RPS_Handle *h)
 413 {
 414   if (NULL != h->conn)
 415     GNUNET_CLIENT_disconnect (h->conn);
 416 }
 417
 418
 419 /* end of rps_api.c */