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