src/namestore/gnunet-namestore-fcfsd.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012-2014 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file gnunet-namestore-fcfsd.c
  22  * @brief HTTP daemon that offers first-come-first-serve GNS domain registration
  23  * @author Christian Grothoff
  24  *
  25  * TODO:
  26  * - need to track active zone info requests so we can cancel them
  27  *   during shutdown, right?
  28  * - the code currently contains a 'race' between checking that the
  29  *   domain name is available and allocating it to the new public key
  30  *   (should this race be solved by namestore or by fcfsd?)
  31  * - nicer error reporting to browser
  32  */
  33 #include "platform.h"
  34 #include <microhttpd.h>
  35 #include "gnunet_util_lib.h"
  36 #include "gnunet_identity_service.h"
  37 #include "gnunet_gnsrecord_lib.h"
  38 #include "gnunet_namestore_service.h"
  39
  40 /**
  41  * Invalid method page.
  42  */
  43 #define METHOD_ERROR "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>Illegal request</title></head><body>Go away.</body></html>"
  44
  45 /**
  46  * Front page. (/)
  47  */
  48 #define MAIN_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>GNUnet FCFS Authority Name Registration Service</title></head><body><form action=\"S\" method=\"post\">What is your desired domain name? (at most 63 lowercase characters, no dots allowed.) <input type=\"text\" name=\"domain\" /> <p> What is your public key? (Copy from gnunet-setup.) <input type=\"text\" name=\"pkey\" /> <input type=\"submit\" value=\"Next\" /><br/><a href=./Zoneinfo> List of all registered names </a></body></html>"
  49
  50 /**
  51  * Second page (/S)
  52  */
  53 #define SUBMIT_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>%s</title></head><body>%s</body></html>"
  54
  55 /**
  56  * Fcfs zoneinfo page (/Zoneinfo)
  57  */
  58 #define ZONEINFO_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>FCFS Zoneinfo</title></head><body><h1> FCFS Zoneinfo </h1><table border=\"1\"><th>name</th><th>PKEY</th>%s</table></body></html>"
  59
  60 #define FCFS_ZONEINFO_URL "/Zoneinfo"
  61
  62 /**
  63  * Mime type for HTML pages.
  64  */
  65 #define MIME_HTML "text/html"
  66
  67 /**
  68  * Name of our cookie.
  69  */
  70 #define COOKIE_NAME "namestore-fcfsd"
  71
  72 #define DEFAULT_ZONEINFO_BUFSIZE 2048
  73
  74 /**
  75  * Phases a request goes through.
  76  */
  77 enum Phase
  78   {
  79     /**
  80      * Start phase (parsing POST, checking).
  81      */
  82     RP_START = 0,
  83
  84     /**
  85      * Lookup to see if the domain name is taken.
  86      */
  87     RP_LOOKUP,
  88
  89     /**
  90      * Storing of the record.
  91      */
  92     RP_PUT,
  93
  94     /**
  95      * We're done with success.
  96      */
  97     RP_SUCCESS,
  98
  99     /**
 100      * Send failure message.
 101      */
 102     RP_FAIL
 103   };
 104
 105
 106 /**
 107  * Data kept per request.
 108  */
 109 struct Request
 110 {
 111
 112   /**
 113    * Associated session.
 114    */
 115   // FIXME: struct Session *session;
 116
 117   /**
 118    * Post processor handling form data (IF this is
 119    * a POST request).
 120    */
 121   struct MHD_PostProcessor *pp;
 122
 123   /**
 124    * URL to serve in response to this POST (if this request
 125    * was a 'POST')
 126    */
 127   const char *post_url;
 128
 129   /**
 130    * Active request with the namestore.
 131    */
 132   struct GNUNET_NAMESTORE_QueueEntry *qe;
 133
 134   /**
 135    * Active iteration with the namestore.
 136    */
 137   struct GNUNET_NAMESTORE_ZoneIterator *zi;
 138
 139   /**
 140    * Current processing phase.
 141    */
 142   enum Phase phase;
 143
 144   /**
 145    * Domain name submitted via form.
 146    */
 147   char domain_name[64];
 148
 149   /**
 150    * Public key submitted via form.
 151    */
 152   char public_key[128];
 153
 154   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 155
 156 };
 157
 158 /**
 159  * Zoneinfo request
 160  */
 161 struct ZoneinfoRequest
 162 {
 163   /**
 164    * Connection
 165    */
 166   struct MHD_Connection *connection;
 167
 168   /**
 169    * List iterator
 170    */
 171   struct GNUNET_NAMESTORE_ZoneIterator *list_it;
 172
 173   /**
 174    * Buffer
 175    */
 176   char* zoneinfo;
 177
 178   /**
 179    * Buffer length
 180    */
 181   size_t buf_len;
 182
 183   /**
 184    * Buffer write offset
 185    */
 186   size_t write_offset;
 187 };
 188
 189 /**
 190  * MHD deamon reference.
 191  */
 192 static struct MHD_Daemon *httpd;
 193
 194 /**
 195  * Main HTTP task.
 196  */
 197 static struct GNUNET_SCHEDULER_Task * httpd_task;
 198
 199 /**
 200  * Handle to the namestore.
 201  */
 202 static struct GNUNET_NAMESTORE_Handle *ns;
 203
 204 /**
 205  * Private key for the fcfsd zone.
 206  */
 207 static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey;
 208
 209 /**
 210  * Connection to identity service.
 211  */
 212 static struct GNUNET_IDENTITY_Handle *identity;
 213
 214 /**
 215  * Request for our ego.
 216  */
 217 static struct GNUNET_IDENTITY_Operation *id_op;
 218
 219 /**
 220  * Port we use for the HTTP server.
 221  */
 222 static unsigned long long port;
 223
 224
 225 /**
 226  * Task run whenever HTTP server operations are pending.
 227  *
 228  * @param cls unused
 229  */
 230 static void
 231 do_httpd (void *cls);
 232
 233
 234 /**
 235  * Schedule task to run MHD server now.
 236  */
 237 static void
 238 run_httpd_now ()
 239 {
 240   if (NULL != httpd_task)
 241   {
 242     GNUNET_SCHEDULER_cancel (httpd_task);
 243     httpd_task = NULL;
 244   }
 245   httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
 246 }
 247
 248
 249 /**
 250  * Process a record that was stored in the namestore, adding
 251  * the information to the HTML.
 252  *
 253  * @param cls closure with the `struct ZoneinfoRequest *`
 254  * @param zone_key private key of the zone; NULL on disconnect
 255  * @param name label of the records; NULL on disconnect
 256  * @param rd_len number of entries in @a rd array, 0 if label was deleted
 257  * @param rd array of records with data to store
 258  */
 259 static void
 260 iterate_cb (void *cls,
 261             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 262             const char *name,
 263             unsigned int rd_len,
 264             const struct GNUNET_GNSRECORD_Data *rd)
 265 {
 266   struct ZoneinfoRequest *zr = cls;
 267   struct MHD_Response *response;
 268   char* full_page;
 269   size_t bytes_free;
 270   char* pkey;
 271   char* new_buf;
 272
 273
 274   if (NULL == name)
 275   {
 276     zr->list_it = NULL;
 277
 278     /* return static form */
 279     GNUNET_asprintf (&full_page,
 280                      ZONEINFO_PAGE,
 281                      zr->zoneinfo,
 282                      zr->zoneinfo);
 283     response = MHD_create_response_from_buffer (strlen (full_page),
 284                                               (void *) full_page,
 285                                               MHD_RESPMEM_MUST_FREE);
 286     MHD_add_response_header (response,
 287                            MHD_HTTP_HEADER_CONTENT_TYPE,
 288                            MIME_HTML);
 289     MHD_queue_response (zr->connection,
 290                             MHD_HTTP_OK,
 291                             response);
 292     MHD_destroy_response (response);
 293     GNUNET_free (zr->zoneinfo);
 294     GNUNET_free (zr);
 295     run_httpd_now ();
 296     return;
 297   }
 298
 299   if (1 != rd_len)
 300   {
 301     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it);
 302     return;
 303   }
 304
 305   if (GNUNET_GNSRECORD_TYPE_PKEY != rd->record_type)
 306   {
 307     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it);
 308     return;
 309   }
 310
 311   bytes_free = zr->buf_len - zr->write_offset;
 312   pkey = GNUNET_GNSRECORD_value_to_string (rd->record_type,
 313                                            rd->data,
 314                                            rd->data_size);
 315   if (NULL == pkey)
 316   {
 317     GNUNET_break (0);
 318     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it);
 319     return;
 320   }
 321   if (bytes_free < (strlen (name) + strlen (pkey) + 40))
 322   {
 323     new_buf = GNUNET_malloc (zr->buf_len * 2);
 324     memcpy (new_buf, zr->zoneinfo, zr->write_offset);
 325     GNUNET_free (zr->zoneinfo);
 326     zr->zoneinfo = new_buf;
 327     zr->buf_len *= 2;
 328   }
 329   sprintf (zr->zoneinfo + zr->write_offset,
 330            "<tr><td>%s</td><td>%s</td></tr>",
 331            name,
 332            pkey);
 333   zr->write_offset = strlen (zr->zoneinfo);
 334   GNUNET_NAMESTORE_zone_iterator_next (zr->list_it);
 335   GNUNET_free (pkey);
 336 }
 337
 338
 339 /**
 340  * Handler that returns FCFS zoneinfo page.
 341  *
 342  * @param connection connection to use
 343  * @return MHD_YES on success
 344  */
 345 static int
 346 serve_zoneinfo_page (struct MHD_Connection *connection)
 347 {
 348   struct ZoneinfoRequest *zr;
 349
 350   zr = GNUNET_new (struct ZoneinfoRequest);
 351   zr->zoneinfo = GNUNET_malloc (DEFAULT_ZONEINFO_BUFSIZE);
 352   zr->buf_len = DEFAULT_ZONEINFO_BUFSIZE;
 353   zr->connection = connection;
 354   zr->write_offset = 0;
 355   zr->list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
 356                                                        &fcfs_zone_pkey,
 357                                                        &iterate_cb,
 358                                                        zr);
 359   return MHD_YES;
 360 }
 361
 362
 363 /**
 364  * Handler that returns a simple static HTTP page.
 365  *
 366  * @param connection connection to use
 367  * @return MHD_YES on success
 368  */
 369 static int
 370 serve_main_page (struct MHD_Connection *connection)
 371 {
 372   int ret;
 373   struct MHD_Response *response;
 374
 375   /* return static form */
 376   response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
 377                                               (void *) MAIN_PAGE,
 378                                               MHD_RESPMEM_PERSISTENT);
 379   MHD_add_response_header (response,
 380                            MHD_HTTP_HEADER_CONTENT_TYPE,
 381                            MIME_HTML);
 382   ret = MHD_queue_response (connection,
 383                             MHD_HTTP_OK,
 384                             response);
 385   MHD_destroy_response (response);
 386   return ret;
 387 }
 388
 389
 390 /**
 391  * Send the 'SUBMIT_PAGE'.
 392  *
 393  * @param info information string to send to the user
 394  * @param request request information
 395  * @param connection connection to use
 396  */
 397 static int
 398 fill_s_reply (const char *info,
 399               struct Request *request,
 400               struct MHD_Connection *connection)
 401 {
 402   int ret;
 403   char *reply;
 404   struct MHD_Response *response;
 405
 406   GNUNET_asprintf (&reply,
 407                    SUBMIT_PAGE,
 408                    info,
 409                    info);
 410   /* return static form */
 411   response = MHD_create_response_from_buffer (strlen (reply),
 412                                               (void *) reply,
 413                                               MHD_RESPMEM_MUST_FREE);
 414   MHD_add_response_header (response,
 415                            MHD_HTTP_HEADER_CONTENT_TYPE,
 416                            MIME_HTML);
 417   ret = MHD_queue_response (connection,
 418                             MHD_HTTP_OK,
 419                             response);
 420   MHD_destroy_response (response);
 421   return ret;
 422 }
 423
 424
 425 /**
 426  * Iterator over key-value pairs where the value
 427  * maybe made available in increments and/or may
 428  * not be zero-terminated.  Used for processing
 429  * POST data.
 430  *
 431  * @param cls user-specified closure
 432  * @param kind type of the value
 433  * @param key 0-terminated key for the value
 434  * @param filename name of the uploaded file, NULL if not known
 435  * @param content_type mime-type of the data, NULL if not known
 436  * @param transfer_encoding encoding of the data, NULL if not known
 437  * @param data pointer to size bytes of data at the
 438  *              specified offset
 439  * @param off offset of data in the overall value
 440  * @param size number of bytes in data available
 441  * @return MHD_YES to continue iterating,
 442  *         MHD_NO to abort the iteration
 443  */
 444 static int
 445 post_iterator (void *cls,
 446                enum MHD_ValueKind kind,
 447                const char *key,
 448                const char *filename,
 449                const char *content_type,
 450                const char *transfer_encoding,
 451                const char *data, uint64_t off, size_t size)
 452 {
 453   struct Request *request = cls;
 454
 455   if (0 == strcmp ("domain", key))
 456     {
 457       if (size + off >= sizeof(request->domain_name))
 458         size = sizeof (request->domain_name) - off - 1;
 459       memcpy (&request->domain_name[off],
 460               data,
 461               size);
 462       request->domain_name[size+off] = '\0';
 463       return MHD_YES;
 464     }
 465   if (0 == strcmp ("pkey", key))
 466     {
 467       if (size + off >= sizeof(request->public_key))
 468         size = sizeof (request->public_key) - off - 1;
 469       memcpy (&request->public_key[off],
 470               data,
 471               size);
 472       request->public_key[size+off] = '\0';
 473       return MHD_YES;
 474     }
 475   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 476               _("Unsupported form value `%s'\n"),
 477               key);
 478   return MHD_YES;
 479 }
 480
 481
 482 /**
 483  * Continuation called to notify client about result of the
 484  * operation.
 485  *
 486  * @param cls closure
 487  * @param success #GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate)
 488  *                #GNUNET_NO if content was already there
 489  *                #GNUNET_YES (or other positive value) on success
 490  * @param emsg NULL on success, otherwise an error message
 491  */
 492 static void
 493 put_continuation (void *cls,
 494                   int32_t success,
 495                   const char *emsg)
 496 {
 497   struct Request *request = cls;
 498
 499   request->qe = NULL;
 500   if (0 >= success)
 501   {
 502     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 503                 _("Failed to create record for domain `%s': %s\n"),
 504                 request->domain_name,
 505                 emsg);
 506     request->phase = RP_FAIL;
 507   }
 508   else
 509     request->phase = RP_SUCCESS;
 510   run_httpd_now ();
 511 }
 512
 513
 514 /**
 515  * Test if a name mapping was found, if so, refuse.  If not, initiate storing of the record.
 516  *
 517  * @param cls closure
 518  * @param zone_key public key of the zone
 519  * @param name name that is being mapped (at most 255 characters long)
 520  * @param rd_count number of entries in @a rd array
 521  * @param rd array of records with data to store
 522  */
 523 static void
 524 zone_to_name_cb (void *cls,
 525                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 526                  const char *name,
 527                  unsigned int rd_count,
 528                  const struct GNUNET_GNSRECORD_Data *rd)
 529 {
 530   struct Request *request = cls;
 531   struct GNUNET_GNSRECORD_Data r;
 532   request->qe = NULL;
 533
 534   if (0 != rd_count)
 535   {
 536     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 537                 _("Found existing name `%s' for the given key\n"),
 538                 name);
 539     request->phase = RP_FAIL;
 540     run_httpd_now ();
 541     return;
 542   }
 543   if (NULL == zone_key)
 544   {
 545     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 546                 _("Error when mapping zone to name\n"));
 547     request->phase = RP_FAIL;
 548     run_httpd_now ();
 549     return;
 550   }
 551
 552   r.data = &request->pub;
 553   r.data_size = sizeof (request->pub);
 554   r.expiration_time = UINT64_MAX;
 555   r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
 556   r.flags = GNUNET_GNSRECORD_RF_NONE;
 557   request->qe = GNUNET_NAMESTORE_records_store (ns,
 558                                                 &fcfs_zone_pkey,
 559                                                 request->domain_name,
 560                                                 1, &r,
 561                                                 &put_continuation,
 562                                                 request);
 563 }
 564
 565
 566 /**
 567  * We got a block back from the namestore.  Decrypt it
 568  * and continue to process the result.
 569  *
 570  * @param cls the 'struct Request' we are processing
 571  * @param zone private key of the zone; NULL on disconnect
 572  * @param label label of the records; NULL on disconnect
 573  * @param rd_count number of entries in @a rd array, 0 if label was deleted
 574  * @param rd array of records with data to store
 575  */
 576 static void
 577 lookup_block_processor (void *cls,
 578                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 579                         const char *label,
 580                         unsigned int rd_count,
 581                         const struct GNUNET_GNSRECORD_Data *rd)
 582 {
 583   struct Request *request = cls;
 584
 585   request->qe = NULL;
 586   if (0 == rd_count)
 587   {
 588
 589     if (GNUNET_OK !=
 590         GNUNET_CRYPTO_ecdsa_public_key_from_string (request->public_key,
 591                                                     strlen (request->public_key),
 592                                                     &request->pub))
 593     {
 594       GNUNET_break (0);
 595       request->phase = RP_FAIL;
 596       run_httpd_now ();
 597       return;
 598     }
 599     request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
 600                                                  &fcfs_zone_pkey,
 601                                                  &request->pub,
 602                                                  &zone_to_name_cb,
 603                                                  request);
 604     return;
 605   }
 606   GNUNET_break (0 != rd_count);
 607   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 608               _("Found %u existing records for domain `%s'\n"),
 609               rd_count,
 610               request->domain_name);
 611   request->phase = RP_FAIL;
 612   run_httpd_now ();
 613   return;
 614 }
 615
 616
 617 /**
 618  * Main MHD callback for handling requests.
 619  *
 620  * @param cls unused
 621  * @param connection MHD connection handle
 622  * @param url the requested url
 623  * @param method the HTTP method used ("GET", "PUT", etc.)
 624  * @param version the HTTP version string (i.e. "HTTP/1.1")
 625  * @param upload_data the data being uploaded (excluding HEADERS,
 626  *        for a POST that fits into memory and that is encoded
 627  *        with a supported encoding, the POST data will NOT be
 628  *        given in upload_data and is instead available as
 629  *        part of MHD_get_connection_values; very large POST
 630  *        data *will* be made available incrementally in
 631  *        upload_data)
 632  * @param upload_data_size set initially to the size of the
 633  *        @a upload_data provided; the method must update this
 634  *        value to the number of bytes NOT processed;
 635  * @param ptr pointer to location where we store the 'struct Request'
 636  * @return MHD_YES if the connection was handled successfully,
 637  *         MHD_NO if the socket must be closed due to a serious
 638  *         error while handling the request
 639  */
 640 static int
 641 create_response (void *cls,
 642                  struct MHD_Connection *connection,
 643                  const char *url,
 644                  const char *method,
 645                  const char *version,
 646                  const char *upload_data,
 647                  size_t *upload_data_size,
 648                  void **ptr)
 649 {
 650   struct MHD_Response *response;
 651   struct Request *request;
 652   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 653   int ret;
 654
 655   if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
 656        (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
 657     {
 658       if (0 == strcmp (url, FCFS_ZONEINFO_URL))
 659         ret = serve_zoneinfo_page (connection);
 660       else
 661         ret = serve_main_page (connection);
 662       if (ret != MHD_YES)
 663         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 664                     _("Failed to create page for `%s'\n"),
 665                     url);
 666       return ret;
 667     }
 668   if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
 669     {
 670       request = *ptr;
 671       if (NULL == request)
 672       {
 673         request = GNUNET_new (struct Request);
 674         *ptr = request;
 675         request->pp = MHD_create_post_processor (connection, 1024,
 676                                                  &post_iterator, request);
 677         if (NULL == request->pp)
 678           {
 679             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 680                         _("Failed to setup post processor for `%s'\n"),
 681                         url);
 682             return MHD_NO; /* internal error */
 683           }
 684         return MHD_YES;
 685       }
 686       if (NULL != request->pp)
 687       {
 688         /* evaluate POST data */
 689         MHD_post_process (request->pp,
 690                           upload_data,
 691                           *upload_data_size);
 692         if (0 != *upload_data_size)
 693           {
 694             *upload_data_size = 0;
 695             return MHD_YES;
 696           }
 697         /* done with POST data, serve response */
 698         MHD_destroy_post_processor (request->pp);
 699         request->pp = NULL;
 700       }
 701       if (GNUNET_OK !=
 702           GNUNET_CRYPTO_ecdsa_public_key_from_string (request->public_key,
 703                                                       strlen (request->public_key),
 704                                                       &pub))
 705       {
 706         /* parse error */
 707         return fill_s_reply ("Failed to parse given public key",
 708                              request, connection);
 709       }
 710       switch (request->phase)
 711         {
 712         case RP_START:
 713           if (NULL != strchr (request->domain_name, (int) '.'))
 714           {
 715             GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 716                         _("Domain name must not contain `.'\n"));
 717             request->phase = RP_FAIL;
 718             return fill_s_reply ("Domain name must not contain `.', sorry.",
 719                                  request, connection);
 720           }
 721           if (NULL != strchr (request->domain_name, (int) '+'))
 722           {
 723             GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 724                         _("Domain name must not contain `+'\n"));
 725             request->phase = RP_FAIL;
 726             return fill_s_reply ("Domain name must not contain `+', sorry.",
 727                                  request, connection);
 728           }
 729           request->phase = RP_LOOKUP;
 730           request->qe = GNUNET_NAMESTORE_records_lookup (ns,
 731                                                        &fcfs_zone_pkey,
 732                                                        request->domain_name,
 733                                                        &lookup_block_processor,
 734                                                        request);
 735           break;
 736         case RP_LOOKUP:
 737           break;
 738         case RP_PUT:
 739           break;
 740         case RP_FAIL:
 741           return fill_s_reply ("Request failed, sorry.",
 742                                request, connection);
 743         case RP_SUCCESS:
 744           return fill_s_reply ("Success.",
 745                                request, connection);
 746         default:
 747           GNUNET_break (0);
 748           return MHD_NO;
 749         }
 750         return MHD_YES; /* will have a reply later... */
 751     }
 752   /* unsupported HTTP method */
 753   response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
 754                                               (void *) METHOD_ERROR,
 755                                               MHD_RESPMEM_PERSISTENT);
 756   ret = MHD_queue_response (connection,
 757                             MHD_HTTP_NOT_ACCEPTABLE,
 758                             response);
 759   MHD_destroy_response (response);
 760   return ret;
 761 }
 762
 763
 764 /**
 765  * Callback called upon completion of a request.
 766  * Decrements session reference counter.
 767  *
 768  * @param cls not used
 769  * @param connection connection that completed
 770  * @param con_cls session handle
 771  * @param toe status code
 772  */
 773 static void
 774 request_completed_callback (void *cls,
 775                             struct MHD_Connection *connection,
 776                             void **con_cls,
 777                             enum MHD_RequestTerminationCode toe)
 778 {
 779   struct Request *request = *con_cls;
 780
 781   if (NULL == request)
 782     return;
 783   if (NULL != request->pp)
 784     MHD_destroy_post_processor (request->pp);
 785   if (NULL != request->qe)
 786     GNUNET_NAMESTORE_cancel (request->qe);
 787   GNUNET_free (request);
 788 }
 789
 790
 791 #define UNSIGNED_MHD_LONG_LONG unsigned MHD_LONG_LONG
 792
 793
 794 /**
 795  * Schedule tasks to run MHD server.
 796  */
 797 static void
 798 run_httpd ()
 799 {
 800   fd_set rs;
 801   fd_set ws;
 802   fd_set es;
 803   struct GNUNET_NETWORK_FDSet *wrs;
 804   struct GNUNET_NETWORK_FDSet *wws;
 805   struct GNUNET_NETWORK_FDSet *wes;
 806   int max;
 807   int haveto;
 808   UNSIGNED_MHD_LONG_LONG timeout;
 809   struct GNUNET_TIME_Relative tv;
 810
 811   FD_ZERO (&rs);
 812   FD_ZERO (&ws);
 813   FD_ZERO (&es);
 814   wrs = GNUNET_NETWORK_fdset_create ();
 815   wes = GNUNET_NETWORK_fdset_create ();
 816   wws = GNUNET_NETWORK_fdset_create ();
 817   max = -1;
 818   GNUNET_assert (MHD_YES == MHD_get_fdset (httpd, &rs, &ws, &es, &max));
 819   haveto = MHD_get_timeout (httpd, &timeout);
 820   if (haveto == MHD_YES)
 821     tv.rel_value_us = (uint64_t) timeout * 1000LL;
 822   else
 823     tv = GNUNET_TIME_UNIT_FOREVER_REL;
 824   GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
 825   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
 826   GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1);
 827   httpd_task =
 828       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
 829                                    tv, wrs, wws,
 830                                    &do_httpd, NULL);
 831   GNUNET_NETWORK_fdset_destroy (wrs);
 832   GNUNET_NETWORK_fdset_destroy (wws);
 833   GNUNET_NETWORK_fdset_destroy (wes);
 834 }
 835
 836
 837 /**
 838  * Task run whenever HTTP server operations are pending.
 839  *
 840  * @param cls unused
 841  */
 842 static void
 843 do_httpd (void *cls)
 844 {
 845   httpd_task = NULL;
 846   MHD_run (httpd);
 847   run_httpd ();
 848 }
 849
 850
 851 /**
 852  * Task run on shutdown.  Cleans up everything.
 853  *
 854  * @param cls unused
 855  */
 856 static void
 857 do_shutdown (void *cls)
 858 {
 859   if (NULL != httpd_task)
 860   {
 861     GNUNET_SCHEDULER_cancel (httpd_task);
 862     httpd_task = NULL;
 863   }
 864   if (NULL != ns)
 865   {
 866     GNUNET_NAMESTORE_disconnect (ns);
 867     ns = NULL;
 868   }
 869   if (NULL != httpd)
 870   {
 871     MHD_stop_daemon (httpd);
 872     httpd = NULL;
 873   }
 874   if (NULL != id_op)
 875   {
 876     GNUNET_IDENTITY_cancel (id_op);
 877     id_op = NULL;
 878   }
 879   if (NULL != identity)
 880   {
 881     GNUNET_IDENTITY_disconnect (identity);
 882     identity = NULL;
 883   }
 884 }
 885
 886
 887 /**
 888  * Method called to inform about the egos of this peer.
 889  *
 890  * When used with #GNUNET_IDENTITY_create or #GNUNET_IDENTITY_get,
 891  * this function is only called ONCE, and 'NULL' being passed in
 892  * @a ego does indicate an error (i.e. name is taken or no default
 893  * value is known).  If @a ego is non-NULL and if '*ctx'
 894  * is set in those callbacks, the value WILL be passed to a subsequent
 895  * call to the identity callback of #GNUNET_IDENTITY_connect (if
 896  * that one was not NULL).
 897  *
 898  * @param cls closure, NULL
 899  * @param ego ego handle
 900  * @param ctx context for application to store data for this ego
 901  *                 (during the lifetime of this process, initially NULL)
 902  * @param name name assigned by the user for this ego,
 903  *                   NULL if the user just deleted the ego and it
 904  *                   must thus no longer be used
 905  */
 906 static void
 907 identity_cb (void *cls,
 908              struct GNUNET_IDENTITY_Ego *ego,
 909              void **ctx,
 910              const char *name)
 911 {
 912   int options;
 913
 914   id_op = NULL;
 915   if (NULL == ego)
 916   {
 917     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 918                 _("No ego configured for `fcfsd` subsystem\n"));
 919     return;
 920   }
 921   fcfs_zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
 922
 923   options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG;
 924   do
 925     {
 926       httpd = MHD_start_daemon (options,
 927                                 (uint16_t) port,
 928                                 NULL, NULL,
 929                                 &create_response, NULL,
 930                                 MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
 931                                 MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
 932                                 MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
 933                                 MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4 * 1024),
 934                                 MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
 935                                 MHD_OPTION_END);
 936       if (MHD_USE_DEBUG == options)
 937         break;
 938       options = MHD_USE_DEBUG;
 939     }
 940   while (NULL == httpd);
 941   if (NULL == httpd)
 942   {
 943     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 944                 _("Failed to start HTTP server\n"));
 945     GNUNET_SCHEDULER_shutdown ();
 946     return;
 947   }
 948   run_httpd ();
 949 }
 950
 951
 952 /**
 953  * Main function that will be run.
 954  *
 955  * @param cls closure
 956  * @param args remaining command-line arguments
 957  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 958  * @param cfg configuration
 959  */
 960 static void
 961 run (void *cls, char *const *args, const char *cfgfile,
 962      const struct GNUNET_CONFIGURATION_Handle *cfg)
 963 {
 964   if (GNUNET_OK !=
 965       GNUNET_CONFIGURATION_get_value_number (cfg,
 966                                              "fcfsd",
 967                                              "HTTPPORT",
 968                                              &port))
 969   {
 970     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
 971                                "fcfsd", "HTTPPORT");
 972     return;
 973   }
 974   ns = GNUNET_NAMESTORE_connect (cfg);
 975   if (NULL == ns)
 976     {
 977       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 978                   _("Failed to connect to namestore\n"));
 979       return;
 980     }
 981   identity = GNUNET_IDENTITY_connect (cfg,
 982                                       NULL, NULL);
 983   if (NULL == identity)
 984   {
 985     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 986                 _("Failed to connect to identity\n"));
 987     return;
 988   }
 989   id_op = GNUNET_IDENTITY_get (identity, "fcfsd",
 990                                &identity_cb, NULL);
 991   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 992 }
 993
 994
 995 /**
 996  * The main function for the fcfs daemon.
 997  *
 998  * @param argc number of arguments from the command line
 999  * @param argv command line arguments
1000  * @return 0 ok, 1 on error
1001  */
1002 int
1003 main (int argc, char *const *argv)
1004 {
1005   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
1006     GNUNET_GETOPT_OPTION_END
1007   };
1008
1009   int ret;
1010
1011   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1012     return 2;
1013
1014   GNUNET_log_setup ("fcfsd", "WARNING", NULL);
1015   ret =
1016       (GNUNET_OK ==
1017        GNUNET_PROGRAM_run (argc, argv, "fcfsd",
1018                            _("GNU Name System First Come First Serve name registration service"),
1019                            options,
1020                            &run, NULL)) ? 0 : 1;
1021   GNUNET_free ((void*) argv);
1022   GNUNET_CRYPTO_ecdsa_key_clear (&fcfs_zone_pkey);
1023   return ret;
1024 }
1025
1026 /* end of gnunet-namestore-fcfsd.c */