src/namestore/gnunet-namestore-fcfsd.c

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