src/fs/fs.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file fs/fs.c
  23  * @brief main FS functions
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_fs_service.h"
  30 #include "fs.h"
  31
  32
  33 /**
  34  * Start the given job (send signal, remove from pending queue, update
  35  * counters and state).
  36  *
  37  * @param qe job to start
  38  */
  39 static void
  40 start_job (struct GNUNET_FS_QueueEntry *qe)
  41 {
  42   qe->client = GNUNET_CLIENT_connect (qe->h->sched, "fs", qe->h->cfg);
  43   if (qe->client == NULL)
  44     {
  45       GNUNET_break (0);
  46       return;
  47     }
  48   qe->start (qe->cls, qe->client);
  49   qe->start_times++;
  50   qe->h->active_blocks += qe->blocks;
  51   qe->start_time = GNUNET_TIME_absolute_get ();
  52   GNUNET_CONTAINER_DLL_remove (qe->h->pending_head,
  53                                qe->h->pending_tail,
  54                                qe);
  55   GNUNET_CONTAINER_DLL_insert_after (qe->h->running_head,
  56                                      qe->h->running_tail,
  57                                      qe->h->running_tail,
  58                                      qe);
  59 }
  60
  61
  62 /**
  63  * Stop the given job (send signal, remove from active queue, update
  64  * counters and state).
  65  *
  66  * @param qe job to stop
  67  */
  68 static void
  69 stop_job (struct GNUNET_FS_QueueEntry *qe)
  70 {
  71   qe->client = NULL;
  72   qe->stop (qe->cls);
  73   qe->h->active_downloads--;
  74   qe->h->active_blocks -= qe->blocks;
  75   qe->run_time = GNUNET_TIME_relative_add (qe->run_time,
  76                                            GNUNET_TIME_absolute_get_duration (qe->start_time));
  77   GNUNET_CONTAINER_DLL_remove (qe->h->running_head,
  78                                qe->h->running_tail,
  79                                qe);
  80   GNUNET_CONTAINER_DLL_insert_after (qe->h->pending_head,
  81                                      qe->h->pending_tail,
  82                                      qe->h->pending_tail,
  83                                      qe);
  84 }
  85
  86
  87 /**
  88  * Process the jobs in the job queue, possibly starting some
  89  * and stopping others.
  90  *
  91  * @param cls the 'struct GNUNET_FS_Handle'
  92  * @param tc scheduler context
  93  */
  94 static void
  95 process_job_queue (void *cls,
  96                    const struct GNUNET_SCHEDULER_TaskContext *tc)
  97 {
  98   struct GNUNET_FS_Handle *h = cls;
  99   struct GNUNET_FS_QueueEntry *qe;
 100   struct GNUNET_FS_QueueEntry *next;
 101   struct GNUNET_TIME_Relative run_time;
 102   struct GNUNET_TIME_Relative restart_at;
 103   struct GNUNET_TIME_Relative rst;
 104   struct GNUNET_TIME_Absolute end_time;
 105
 106   h->queue_job = GNUNET_SCHEDULER_NO_TASK;
 107   next = h->pending_head;
 108   while (NULL != (qe = next))
 109     {
 110       next = qe->next;
 111       if (h->running_head == NULL)
 112         {
 113           start_job (qe);
 114           continue;
 115         }
 116       if ( (qe->blocks + h->active_blocks <= h->max_parallel_requests) &&
 117            (h->active_downloads + 1 <= h->max_parallel_downloads) )
 118         {
 119           start_job (qe);
 120           continue;
 121         }
 122     }
 123   if (h->pending_head == NULL)
 124     return; /* no need to stop anything */
 125   restart_at = GNUNET_TIME_UNIT_FOREVER_REL;
 126   next = h->running_head;
 127   while (NULL != (qe = next))
 128     {
 129       next = qe->next;
 130       /* FIXME: might be faster/simpler to do this calculation only once
 131          when we start a job (OTOH, this would allow us to dynamically
 132          and easily adjust qe->blocks over time, given the right API...) */
 133       run_time = GNUNET_TIME_relative_multiply (h->avg_block_latency,
 134                                                 qe->blocks * qe->start_times);
 135       end_time = GNUNET_TIME_absolute_add (qe->start_time,
 136                                            run_time);
 137       rst = GNUNET_TIME_absolute_get_remaining (end_time);
 138       restart_at = GNUNET_TIME_relative_min (rst, restart_at);
 139       if (rst.value > 0)
 140         continue;
 141       stop_job (qe);
 142     }
 143   h->queue_job = GNUNET_SCHEDULER_add_delayed (h->sched,
 144                                                restart_at,
 145                                                &process_job_queue,
 146                                                h);
 147 }
 148
 149
 150 /**
 151  * Add a job to the queue.
 152  *
 153  * @param h handle to the overall FS state
 154  * @param start function to call to begin the job
 155  * @param stop function to call to pause the job, or on dequeue (if the job was running)
 156  * @param cls closure for start and stop
 157  * @param blocks number of blocks this jobs uses
 158  * @return queue handle
 159  */
 160 struct GNUNET_FS_QueueEntry *
 161 GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
 162                   GNUNET_FS_QueueStart start,
 163                   GNUNET_FS_QueueStop stop,
 164                   void *cls,
 165                   unsigned int blocks)
 166 {
 167   struct GNUNET_FS_QueueEntry *qe;
 168
 169   qe = GNUNET_malloc (sizeof (struct GNUNET_FS_QueueEntry));
 170   qe->h = h;
 171   qe->start = start;
 172   qe->stop = stop;
 173   qe->cls = cls;
 174   qe->queue_time = GNUNET_TIME_absolute_get ();
 175   qe->blocks = blocks;
 176   GNUNET_CONTAINER_DLL_insert_after (h->pending_head,
 177                                      h->pending_tail,
 178                                      h->pending_tail,
 179                                      qe);
 180   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
 181     GNUNET_SCHEDULER_cancel (h->sched,
 182                              h->queue_job);
 183   h->queue_job
 184     = GNUNET_SCHEDULER_add_now (h->sched,
 185                                 &process_job_queue,
 186                                 h);
 187   return qe;
 188 }
 189
 190
 191 /**
 192  * Dequeue a job from the queue.
 193  * @param qh handle for the job
 194  */
 195 void
 196 GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh)
 197 {
 198   struct GNUNET_FS_Handle *h;
 199
 200   h = qh->h;
 201   if (qh->client != NULL)
 202     stop_job (qh);
 203   GNUNET_CONTAINER_DLL_remove (h->pending_head,
 204                                h->pending_tail,
 205                                qh);
 206   GNUNET_free (qh);
 207   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
 208     GNUNET_SCHEDULER_cancel (h->sched,
 209                              h->queue_job);
 210   h->queue_job
 211     = GNUNET_SCHEDULER_add_now (h->sched,
 212                                 &process_job_queue,
 213                                 h);
 214 }
 215
 216
 217 /**
 218  * Return the full filename where we would store state information
 219  * (for serialization/deserialization).
 220  *
 221  * @param h master context
 222  * @param ext component of the path
 223  * @param ent entity identifier (or emtpy string for the directory)
 224  * @return NULL on error
 225  */
 226 static char *
 227 get_serialization_file_name (struct GNUNET_FS_Handle *h,
 228                              const char *ext,
 229                              const char *ent)
 230 {
 231   char *basename;
 232   char *ret;
 233   if (GNUNET_OK !=
 234       GNUNET_CONFIGURATION_get_value_filename (h->cfg,
 235                                                "fs",
 236                                                "STATE_DIR",
 237                                                &basename))
 238     return NULL;
 239   GNUNET_asprintf (&ret,
 240                    "%s%s%s-%s%s%s",
 241                    basename,
 242                    DIR_SEPARATOR_STR,
 243                    h->client_name,
 244                    ext,
 245                    DIR_SEPARATOR_STR,
 246                    ent);
 247   GNUNET_free (basename);
 248   return ret;
 249 }
 250
 251
 252 /**
 253  * Return a read handle for deserialization.
 254  *
 255  * @param h master context
 256  * @param ext component of the path
 257  * @param ent entity identifier (or emtpy string for the directory)
 258  * @return NULL on error
 259  */
 260 static struct GNUNET_BIO_ReadHandle *
 261 get_read_handle (struct GNUNET_FS_Handle *h,
 262                  const char *ext,
 263                  const char *ent)
 264 {
 265   char *fn;
 266   struct GNUNET_BIO_ReadHandle *ret;
 267
 268   fn = get_serialization_file_name (h, ext, ent);
 269   if (fn == NULL)
 270     return NULL;
 271   ret = GNUNET_BIO_read_open (fn);
 272   GNUNET_free (fn);
 273   return ret;
 274 }
 275
 276
 277 /**
 278  * Using the given serialization filename, try to deserialize
 279  * the file-information tree associated with it.
 280  *
 281  * @param h master context
 282  * @param filename name of the file (without directory) with
 283  *        the infromation
 284  * @return NULL on error
 285  */
 286 static struct GNUNET_FS_FileInformation *
 287 deserialize_file_information (struct GNUNET_FS_Handle *h,
 288                               const char *filename)
 289 {
 290   struct GNUNET_FS_FileInformation *ret;
 291   struct GNUNET_BIO_ReadHandle *rh;
 292   char *emsg;
 293
 294   rh = get_read_handle (h, "publish-fi", filename);
 295   if (rh == NULL)
 296     return NULL;
 297
 298   ret = NULL;
 299
 300
 301   if (GNUNET_OK !=
 302       GNUNET_BIO_read_close (rh, &emsg))
 303     {
 304       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 305                   _("Failed to resume publishing information `%s': %s\n"),
 306                   filename,
 307                   emsg);
 308       GNUNET_free (emsg);
 309     }
 310   return ret;
 311 }
 312
 313
 314 /**
 315  * Find the entry in the file information struct where the
 316  * serialization filename matches the given name.
 317  *
 318  * @param pos file information to search
 319  * @param srch filename to search for
 320  * @return NULL if srch was not found in this subtree
 321  */
 322 static struct GNUNET_FS_FileInformation *
 323 find_file_position (struct GNUNET_FS_FileInformation *pos,
 324                     const char *srch)
 325 {
 326   struct GNUNET_FS_FileInformation *r;
 327
 328   while (pos != NULL)
 329     {
 330       if (0 == strcmp (srch,
 331                        pos->serialization_name))
 332         return pos;
 333       if (pos->is_directory)
 334         {
 335           r = find_file_position (pos->data.dir.entries,
 336                                   srch);
 337           if (r != NULL)
 338             return r;
 339         }
 340       pos = pos->next;
 341     }
 342   return NULL;
 343 }
 344
 345
 346 /**
 347  * Signal the FS's progress function that we are resuming
 348  * an upload.
 349  *
 350  * @param cls closure (of type "struct GNUNET_FS_PublishContext*")
 351  * @param fi the entry in the publish-structure
 352  * @param length length of the file or directory
 353  * @param meta metadata for the file or directory (can be modified)
 354  * @param uri pointer to the keywords that will be used for this entry (can be modified)
 355  * @param anonymity pointer to selected anonymity level (can be modified)
 356  * @param priority pointer to selected priority (can be modified)
 357  * @param expirationTime pointer to selected expiration time (can be modified)
 358  * @param client_info pointer to client context set upon creation (can be modified)
 359  * @return GNUNET_OK to continue (always)
 360  */
 361 static int
 362 fip_signal_resume(void *cls,
 363                   struct GNUNET_FS_FileInformation *fi,
 364                   uint64_t length,
 365                   struct GNUNET_CONTAINER_MetaData *meta,
 366                   struct GNUNET_FS_Uri **uri,
 367                   uint32_t *anonymity,
 368                   uint32_t *priority,
 369                   struct GNUNET_TIME_Absolute *expirationTime,
 370                   void **client_info)
 371 {
 372   struct GNUNET_FS_PublishContext *sc = cls;
 373   struct GNUNET_FS_ProgressInfo pi;
 374
 375   pi.status = GNUNET_FS_STATUS_PUBLISH_RESUME;
 376   pi.value.publish.specifics.resume.message = sc->fi->emsg;
 377   pi.value.publish.specifics.resume.chk_uri = sc->fi->chk_uri;
 378   *client_info = GNUNET_FS_publish_make_status_ (&pi, sc, fi, 0);
 379   return GNUNET_OK;
 380 }
 381
 382
 383 /**
 384  * Function called with a filename of serialized publishing operation
 385  * to deserialize.
 386  *
 387  * @param cls the 'struct GNUNET_FS_Handle*'
 388  * @param filename complete filename (absolute path)
 389  * @return GNUNET_OK (continue to iterate)
 390  */
 391 static int
 392 deserialize_publish_file (void *cls,
 393                           const char *filename)
 394 {
 395   struct GNUNET_FS_Handle *h = cls;
 396   struct GNUNET_BIO_ReadHandle *rh;
 397   struct GNUNET_FS_PublishContext *pc;
 398   int32_t options;
 399   int32_t all_done;
 400   char *fi_root;
 401   char *ns;
 402   char *fi_pos;
 403   char *emsg;
 404
 405   rh = GNUNET_BIO_read_open (filename);
 406   if (rh == NULL)
 407     {
 408       if (0 != UNLINK (filename))
 409         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
 410                                   "unlink",
 411                                   filename);
 412       return GNUNET_OK;
 413     }
 414   while (1)
 415     {
 416       fi_root = NULL;
 417       fi_pos = NULL;
 418       ns = NULL;
 419       pc = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishContext));
 420       pc->h = h;
 421       if ( (GNUNET_OK !=
 422             GNUNET_BIO_read_string (rh, "publish-nid", &pc->nid, 1024)) ||
 423            (GNUNET_OK !=
 424             GNUNET_BIO_read_string (rh, "publish-nuid", &pc->nuid, 1024)) ||
 425            (GNUNET_OK !=
 426             GNUNET_BIO_read_int32 (rh, &options)) ||
 427            (GNUNET_OK !=
 428             GNUNET_BIO_read_int32 (rh, &all_done)) ||
 429            (GNUNET_OK !=
 430             GNUNET_BIO_read_string (rh, "publish-firoot", &fi_root, 128)) ||
 431            (GNUNET_OK !=
 432             GNUNET_BIO_read_string (rh, "publish-fipos", &fi_pos, 128)) ||
 433            (GNUNET_OK !=
 434             GNUNET_BIO_read_string (rh, "publish-ns", &ns, 1024)) )
 435         {
 436           GNUNET_free_non_null (pc->nid);
 437           GNUNET_free_non_null (pc->nuid);
 438           GNUNET_free_non_null (fi_root);
 439           GNUNET_free_non_null (ns);
 440           GNUNET_free (pc);
 441           break;
 442         }
 443        pc->options = options;
 444        pc->all_done = all_done;
 445        pc->fi = deserialize_file_information (h, fi_root);
 446        if (pc->fi == NULL)
 447          {
 448            GNUNET_free_non_null (pc->nid);
 449            GNUNET_free_non_null (pc->nuid);
 450            GNUNET_free_non_null (fi_root);
 451            GNUNET_free_non_null (ns);
 452            GNUNET_free (pc);
 453            continue;
 454          }
 455        if (ns != NULL)
 456          {
 457            pc->namespace = GNUNET_FS_namespace_create (h, ns);
 458            if (pc->namespace == NULL)
 459              {
 460                GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 461                            _("Failed to recover namespace `%s', cannot resume publishing operation.\n"),
 462                            ns);
 463                GNUNET_free_non_null (pc->nid);
 464                GNUNET_free_non_null (pc->nuid);
 465                GNUNET_free_non_null (fi_root);
 466                GNUNET_free_non_null (ns);
 467                GNUNET_free (pc);
 468                continue;
 469              }
 470          }
 471        if (fi_pos != NULL)
 472          {
 473            pc->fi_pos = find_file_position (pc->fi,
 474                                             fi_pos);
 475            GNUNET_free (fi_pos);
 476            if (pc->fi_pos == NULL)
 477              {
 478                /* failed to find position for resuming, outch! Will start from root! */
 479                GNUNET_break (0);
 480                if (pc->all_done != GNUNET_YES)
 481                  pc->fi_pos = pc->fi;
 482              }
 483          }
 484        pc->serialization = GNUNET_strdup (filename);
 485        /* generate RESUME event(s) */
 486        GNUNET_FS_file_information_inspect (pc->fi,
 487                                            &fip_signal_resume,
 488                                            pc);
 489
 490        /* re-start publishing (if needed)... */
 491        if (pc->all_done != GNUNET_YES)
 492          pc->upload_task
 493            = GNUNET_SCHEDULER_add_with_priority (h->sched,
 494                                                  GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
 495                                                  &GNUNET_FS_publish_main_,
 496                                                  pc);
 497     }
 498   if (GNUNET_OK !=
 499       GNUNET_BIO_read_close (rh, &emsg))
 500     {
 501       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 502                   _("Failed to resume publishing operation `%s': %s\n"),
 503                   filename,
 504                   emsg);
 505       GNUNET_free (emsg);
 506     }
 507   return GNUNET_OK;
 508 }
 509
 510
 511 /**
 512  * Deserialize information about pending publish operations.
 513  *
 514  * @param h master context
 515  */
 516 static void
 517 deserialize_publish (struct GNUNET_FS_Handle *h)
 518 {
 519   char *dn;
 520
 521   dn = get_serialization_file_name (h, "publish", "");
 522   if (dn == NULL)
 523     return;
 524   GNUNET_DISK_directory_scan (dn, &deserialize_publish_file, h);
 525   GNUNET_free (dn);
 526 }
 527
 528
 529 /**
 530  * Setup a connection to the file-sharing service.
 531  *
 532  * @param sched scheduler to use
 533  * @param cfg configuration to use
 534  * @param client_name unique identifier for this client
 535  * @param upcb function to call to notify about FS actions
 536  * @param upcb_cls closure for upcb
 537  * @param flags specific attributes for fs-operations
 538  * @param ... list of optional options, terminated with GNUNET_FS_OPTIONS_END
 539  * @return NULL on error
 540  */
 541 struct GNUNET_FS_Handle *
 542 GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
 543                  const struct GNUNET_CONFIGURATION_Handle *cfg,
 544                  const char *client_name,
 545                  GNUNET_FS_ProgressCallback upcb,
 546                  void *upcb_cls,
 547                  enum GNUNET_FS_Flags flags,
 548                  ...)
 549 {
 550   struct GNUNET_FS_Handle *ret;
 551   struct GNUNET_CLIENT_Connection *client;
 552   enum GNUNET_FS_OPTIONS opt;
 553   va_list ap;
 554
 555   client = GNUNET_CLIENT_connect (sched,
 556                                   "fs",
 557                                   cfg);
 558   if (NULL == client)
 559     return NULL;
 560   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Handle));
 561   ret->sched = sched;
 562   ret->cfg = cfg;
 563   ret->client_name = GNUNET_strdup (client_name);
 564   ret->upcb = upcb;
 565   ret->upcb_cls = upcb_cls;
 566   ret->client = client;
 567   ret->flags = flags;
 568   ret->max_parallel_downloads = 1;
 569   ret->max_parallel_requests = 1;
 570   ret->avg_block_latency = GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
 571   va_start (ap, flags);
 572   while (GNUNET_FS_OPTIONS_END != (opt = va_arg (ap, enum GNUNET_FS_OPTIONS)))
 573     {
 574       switch (opt)
 575         {
 576         case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
 577           ret->max_parallel_downloads = va_arg (ap, unsigned int);
 578           break;
 579         case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
 580           ret->max_parallel_requests = va_arg (ap, unsigned int);
 581           break;
 582         default:
 583           GNUNET_break (0);
 584           GNUNET_free (ret->client_name);
 585           GNUNET_free (ret);
 586           va_end (ap);
 587           return NULL;
 588         }
 589     }
 590   va_end (ap);
 591   // FIXME: setup receive-loop with client (do we need one?)
 592
 593   if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
 594     {
 595       deserialize_publish (ret);
 596       // Deserialize Search:
 597       // * read search queries
 598       // * for each query, read file with search results
 599       // * for each search result with active download, deserialize download
 600       // * for each directory search result, check for active downloads of contents
 601       // Deserialize Download:
 602       // * always part of search???
 603       // Deserialize Unindex:
 604       // * read FNs for unindex with progress offset
 605     }
 606   return ret;
 607 }
 608
 609
 610 /**
 611  * Close our connection with the file-sharing service.
 612  * The callback given to GNUNET_FS_start will no longer be
 613  * called after this function returns.
 614  *
 615  * @param h handle that was returned from GNUNET_FS_start
 616  */
 617 void
 618 GNUNET_FS_stop (struct GNUNET_FS_Handle *h)
 619 {
 620   if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & h->flags))
 621     {
 622       // FIXME: generate SUSPEND events and clean up state!
 623     }
 624   // FIXME: terminate receive-loop with client  (do we need one?)
 625   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
 626     GNUNET_SCHEDULER_cancel (h->sched,
 627                              h->queue_job);
 628   GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
 629   GNUNET_free (h->client_name);
 630   GNUNET_free (h);
 631 }
 632
 633
 634 /* end of fs.c */