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
 291 /**
 292  * Using the given serialization filename, try to deserialize
 293  * the file-information tree associated with it.
 294  *
 295  * @param h master context
 296  * @param fn name of the file (without directory) with
 297  *        the infromation
 298  * @param rh handle for reading
 299  * @return NULL on error
 300  */
 301 static struct GNUNET_FS_FileInformation *
 302 deserialize_fi_node (struct GNUNET_FS_Handle *h,
 303                      const char *fn,
 304                      struct GNUNET_BIO_ReadHandle *rh)
 305 {
 306   struct GNUNET_FS_FileInformation *ret;
 307   struct GNUNET_FS_FileInformation *nxt;
 308   char b;
 309   char *ksks;
 310   char *chks;
 311   char *filename;
 312   uint32_t dsize;
 313
 314   if (GNUNET_OK !=
 315       GNUNET_BIO_read (rh, "termination flag", &b, sizeof(b)))
 316     {
 317       GNUNET_break (0);
 318       return NULL;
 319     }
 320   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_FileInformation));
 321   ksks = NULL;
 322   chks = NULL;
 323   filename = NULL;
 324   if ( (GNUNET_OK !=
 325         GNUNET_BIO_read_meta_data (rh, "metadata", &ret->meta)) ||
 326        (GNUNET_OK !=
 327         GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32*1024)) ||
 328        (NULL ==
 329         (ret->keywords = GNUNET_FS_uri_parse (ksks, NULL))) ||
 330        (GNUNET_YES !=
 331         GNUNET_FS_uri_test_ksk (ret->keywords)) ||
 332        (GNUNET_OK !=
 333         GNUNET_BIO_read_string (rh, "chk-uri", &chks, 1024)) ||
 334        ( (chks != NULL) &&
 335          ( (NULL ==
 336             (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
 337            (GNUNET_YES !=
 338             GNUNET_FS_uri_test_chk (ret->chk_uri)) ) ) ||
 339        (GNUNET_OK !=
 340         GNUNET_BIO_read_int64 (rh, &ret->expirationTime.value)) ||
 341        (GNUNET_OK !=
 342         GNUNET_BIO_read_int64 (rh, &ret->start_time.value)) ||
 343        (GNUNET_OK !=
 344         GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16*1024)) ||
 345        (GNUNET_OK !=
 346         GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16*1024)) ||
 347        (GNUNET_OK !=
 348         GNUNET_BIO_read_int32 (rh, &ret->anonymity)) ||
 349        (GNUNET_OK !=
 350         GNUNET_BIO_read_int32 (rh, &ret->priority)) )
 351     goto cleanup;
 352   switch (b)
 353     {
 354     case 0: /* file-insert */
 355       if (GNUNET_OK !=
 356           GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size))
 357         goto cleanup;
 358       ret->is_directory = GNUNET_NO;
 359       ret->data.file.do_index = GNUNET_NO;
 360       ret->data.file.have_hash = GNUNET_NO;
 361       ret->data.file.index_start_confirmed = GNUNET_NO;
 362       break;
 363     case 1: /* file-index, no hash */
 364       if (GNUNET_OK !=
 365           GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size))
 366         goto cleanup;
 367       ret->is_directory = GNUNET_NO;
 368       ret->data.file.do_index = GNUNET_YES;
 369       ret->data.file.have_hash = GNUNET_NO;
 370       ret->data.file.index_start_confirmed = GNUNET_NO;
 371       break;
 372     case 2: /* file-index-with-hash */
 373       if ( (GNUNET_OK !=
 374             GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
 375            (GNUNET_OK !=
 376             GNUNET_BIO_read (rh, "fileid", &ret->data.file.file_id, sizeof (GNUNET_HashCode))) )
 377         goto cleanup;
 378       ret->is_directory = GNUNET_NO;
 379       ret->data.file.do_index = GNUNET_YES;
 380       ret->data.file.have_hash = GNUNET_YES;
 381       ret->data.file.index_start_confirmed = GNUNET_NO;
 382       break;
 383     case 3: /* file-index-with-hash-confirmed */
 384       if ( (GNUNET_OK !=
 385             GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
 386            (GNUNET_OK !=
 387             GNUNET_BIO_read (rh, "fileid", &ret->data.file.file_id, sizeof (GNUNET_HashCode))) )
 388         goto cleanup;
 389       ret->is_directory = GNUNET_NO;
 390       ret->data.file.do_index = GNUNET_YES;
 391       ret->data.file.have_hash = GNUNET_YES;
 392       ret->data.file.index_start_confirmed = GNUNET_YES;
 393       break;
 394     case 4: /* directory */
 395       if ( (GNUNET_OK !=
 396             GNUNET_BIO_read_int32 (rh, &dsize)) ||
 397            (NULL == (ret->data.dir.dir_data = GNUNET_malloc_large (dsize))) ||
 398            (GNUNET_OK !=
 399             GNUNET_BIO_read (rh, "dir-data", ret->data.dir.dir_data, dsize)) ||
 400            (GNUNET_OK !=
 401             GNUNET_BIO_read_string (rh, "ent-filename", &filename, 16*1024)) )
 402         goto cleanup;
 403       ret->data.dir.dir_size = (uint32_t) dsize;
 404       ret->is_directory = GNUNET_YES;
 405       if (filename != NULL)
 406         {
 407           ret->data.dir.entries = deserialize_file_information (h, filename);
 408           GNUNET_free (filename);
 409           filename = NULL;
 410           nxt = ret->data.dir.entries;
 411           while (nxt != NULL)
 412             {
 413               nxt->dir = ret;
 414               nxt = nxt->next;
 415             }
 416         }
 417       break;
 418     default:
 419       GNUNET_break (0);
 420       goto cleanup;
 421     }
 422   /* FIXME: adjust ret->start_time! */
 423   ret->serialization = GNUNET_strdup (fn);
 424   if (GNUNET_OK !=
 425       GNUNET_BIO_read_string (rh, "nxt-filename", &filename, 16*1024))
 426     goto cleanup;
 427   if (filename != NULL)
 428     {
 429       ret->next = deserialize_file_information (h, filename);
 430       GNUNET_free (filename);
 431       filename = NULL;
 432     }
 433   return ret;
 434  cleanup:
 435   GNUNET_free_non_null (ksks);
 436   GNUNET_free_non_null (chks);
 437   GNUNET_free_non_null (filename);
 438   GNUNET_FS_file_information_destroy (ret, NULL, NULL);
 439   return NULL;
 440
 441 }
 442
 443
 444 /**
 445  * Using the given serialization filename, try to deserialize
 446  * the file-information tree associated with it.
 447  *
 448  * @param h master context
 449  * @param filename name of the file (without directory) with
 450  *        the infromation
 451  * @return NULL on error
 452  */
 453 static struct GNUNET_FS_FileInformation *
 454 deserialize_file_information (struct GNUNET_FS_Handle *h,
 455                               const char *filename)
 456 {
 457   struct GNUNET_FS_FileInformation *ret;
 458   struct GNUNET_BIO_ReadHandle *rh;
 459   char *emsg;
 460
 461   rh = get_read_handle (h, "publish-fi", filename);
 462   if (rh == NULL)
 463     return NULL;
 464   ret = deserialize_fi_node (h, filename, rh);
 465   if (GNUNET_OK !=
 466       GNUNET_BIO_read_close (rh, &emsg))
 467     {
 468       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 469                   _("Failed to resume publishing information `%s': %s\n"),
 470                   filename,
 471                   emsg);
 472       GNUNET_free (emsg);
 473     }
 474   return ret;
 475 }
 476
 477
 478 /**
 479  * Find the entry in the file information struct where the
 480  * serialization filename matches the given name.
 481  *
 482  * @param pos file information to search
 483  * @param srch filename to search for
 484  * @return NULL if srch was not found in this subtree
 485  */
 486 static struct GNUNET_FS_FileInformation *
 487 find_file_position (struct GNUNET_FS_FileInformation *pos,
 488                     const char *srch)
 489 {
 490   struct GNUNET_FS_FileInformation *r;
 491
 492   while (pos != NULL)
 493     {
 494       if (0 == strcmp (srch,
 495                        pos->serialization))
 496         return pos;
 497       if (pos->is_directory)
 498         {
 499           r = find_file_position (pos->data.dir.entries,
 500                                   srch);
 501           if (r != NULL)
 502             return r;
 503         }
 504       pos = pos->next;
 505     }
 506   return NULL;
 507 }
 508
 509
 510 /**
 511  * Signal the FS's progress function that we are resuming
 512  * an upload.
 513  *
 514  * @param cls closure (of type "struct GNUNET_FS_PublishContext*")
 515  * @param fi the entry in the publish-structure
 516  * @param length length of the file or directory
 517  * @param meta metadata for the file or directory (can be modified)
 518  * @param uri pointer to the keywords that will be used for this entry (can be modified)
 519  * @param anonymity pointer to selected anonymity level (can be modified)
 520  * @param priority pointer to selected priority (can be modified)
 521  * @param expirationTime pointer to selected expiration time (can be modified)
 522  * @param client_info pointer to client context set upon creation (can be modified)
 523  * @return GNUNET_OK to continue (always)
 524  */
 525 static int
 526 fip_signal_resume(void *cls,
 527                   struct GNUNET_FS_FileInformation *fi,
 528                   uint64_t length,
 529                   struct GNUNET_CONTAINER_MetaData *meta,
 530                   struct GNUNET_FS_Uri **uri,
 531                   uint32_t *anonymity,
 532                   uint32_t *priority,
 533                   struct GNUNET_TIME_Absolute *expirationTime,
 534                   void **client_info)
 535 {
 536   struct GNUNET_FS_PublishContext *sc = cls;
 537   struct GNUNET_FS_ProgressInfo pi;
 538
 539   pi.status = GNUNET_FS_STATUS_PUBLISH_RESUME;
 540   pi.value.publish.specifics.resume.message = sc->fi->emsg;
 541   pi.value.publish.specifics.resume.chk_uri = sc->fi->chk_uri;
 542   *client_info = GNUNET_FS_publish_make_status_ (&pi, sc, fi, 0);
 543   return GNUNET_OK;
 544 }
 545
 546
 547 /**
 548  * Function called with a filename of serialized publishing operation
 549  * to deserialize.
 550  *
 551  * @param cls the 'struct GNUNET_FS_Handle*'
 552  * @param filename complete filename (absolute path)
 553  * @return GNUNET_OK (continue to iterate)
 554  */
 555 static int
 556 deserialize_publish_file (void *cls,
 557                           const char *filename)
 558 {
 559   struct GNUNET_FS_Handle *h = cls;
 560   struct GNUNET_BIO_ReadHandle *rh;
 561   struct GNUNET_FS_PublishContext *pc;
 562   int32_t options;
 563   int32_t all_done;
 564   char *fi_root;
 565   char *ns;
 566   char *fi_pos;
 567   char *emsg;
 568
 569   rh = GNUNET_BIO_read_open (filename);
 570   if (rh == NULL)
 571     {
 572       if (0 != UNLINK (filename))
 573         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
 574                                   "unlink",
 575                                   filename);
 576       return GNUNET_OK;
 577     }
 578   while (1)
 579     {
 580       fi_root = NULL;
 581       fi_pos = NULL;
 582       ns = NULL;
 583       pc = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishContext));
 584       pc->h = h;
 585       if ( (GNUNET_OK !=
 586             GNUNET_BIO_read_string (rh, "publish-nid", &pc->nid, 1024)) ||
 587            (GNUNET_OK !=
 588             GNUNET_BIO_read_string (rh, "publish-nuid", &pc->nuid, 1024)) ||
 589            (GNUNET_OK !=
 590             GNUNET_BIO_read_int32 (rh, &options)) ||
 591            (GNUNET_OK !=
 592             GNUNET_BIO_read_int32 (rh, &all_done)) ||
 593            (GNUNET_OK !=
 594             GNUNET_BIO_read_string (rh, "publish-firoot", &fi_root, 128)) ||
 595            (GNUNET_OK !=
 596             GNUNET_BIO_read_string (rh, "publish-fipos", &fi_pos, 128)) ||
 597            (GNUNET_OK !=
 598             GNUNET_BIO_read_string (rh, "publish-ns", &ns, 1024)) )
 599         {
 600           GNUNET_free_non_null (pc->nid);
 601           GNUNET_free_non_null (pc->nuid);
 602           GNUNET_free_non_null (fi_root);
 603           GNUNET_free_non_null (ns);
 604           GNUNET_free (pc);
 605           break;
 606         }
 607        pc->options = options;
 608        pc->all_done = all_done;
 609        pc->fi = deserialize_file_information (h, fi_root);
 610        if (pc->fi == NULL)
 611          {
 612            GNUNET_free_non_null (pc->nid);
 613            GNUNET_free_non_null (pc->nuid);
 614            GNUNET_free_non_null (fi_root);
 615            GNUNET_free_non_null (ns);
 616            GNUNET_free (pc);
 617            continue;
 618          }
 619        if (ns != NULL)
 620          {
 621            pc->namespace = GNUNET_FS_namespace_create (h, ns);
 622            if (pc->namespace == NULL)
 623              {
 624                GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 625                            _("Failed to recover namespace `%s', cannot resume publishing operation.\n"),
 626                            ns);
 627                GNUNET_free_non_null (pc->nid);
 628                GNUNET_free_non_null (pc->nuid);
 629                GNUNET_free_non_null (fi_root);
 630                GNUNET_free_non_null (ns);
 631                GNUNET_free (pc);
 632                continue;
 633              }
 634          }
 635        if (fi_pos != NULL)
 636          {
 637            pc->fi_pos = find_file_position (pc->fi,
 638                                             fi_pos);
 639            GNUNET_free (fi_pos);
 640            if (pc->fi_pos == NULL)
 641              {
 642                /* failed to find position for resuming, outch! Will start from root! */
 643                GNUNET_break (0);
 644                if (pc->all_done != GNUNET_YES)
 645                  pc->fi_pos = pc->fi;
 646              }
 647          }
 648        pc->serialization = GNUNET_strdup (filename);
 649        /* generate RESUME event(s) */
 650        GNUNET_FS_file_information_inspect (pc->fi,
 651                                            &fip_signal_resume,
 652                                            pc);
 653
 654        /* re-start publishing (if needed)... */
 655        if (pc->all_done != GNUNET_YES)
 656          pc->upload_task
 657            = GNUNET_SCHEDULER_add_with_priority (h->sched,
 658                                                  GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
 659                                                  &GNUNET_FS_publish_main_,
 660                                                  pc);
 661     }
 662   if (GNUNET_OK !=
 663       GNUNET_BIO_read_close (rh, &emsg))
 664     {
 665       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 666                   _("Failed to resume publishing operation `%s': %s\n"),
 667                   filename,
 668                   emsg);
 669       GNUNET_free (emsg);
 670     }
 671   return GNUNET_OK;
 672 }
 673
 674
 675 /**
 676  * Deserialize information about pending publish operations.
 677  *
 678  * @param h master context
 679  */
 680 static void
 681 deserialize_publish (struct GNUNET_FS_Handle *h)
 682 {
 683   char *dn;
 684
 685   dn = get_serialization_file_name (h, "publish", "");
 686   if (dn == NULL)
 687     return;
 688   GNUNET_DISK_directory_scan (dn, &deserialize_publish_file, h);
 689   GNUNET_free (dn);
 690 }
 691
 692
 693 /**
 694  * Setup a connection to the file-sharing service.
 695  *
 696  * @param sched scheduler to use
 697  * @param cfg configuration to use
 698  * @param client_name unique identifier for this client
 699  * @param upcb function to call to notify about FS actions
 700  * @param upcb_cls closure for upcb
 701  * @param flags specific attributes for fs-operations
 702  * @param ... list of optional options, terminated with GNUNET_FS_OPTIONS_END
 703  * @return NULL on error
 704  */
 705 struct GNUNET_FS_Handle *
 706 GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
 707                  const struct GNUNET_CONFIGURATION_Handle *cfg,
 708                  const char *client_name,
 709                  GNUNET_FS_ProgressCallback upcb,
 710                  void *upcb_cls,
 711                  enum GNUNET_FS_Flags flags,
 712                  ...)
 713 {
 714   struct GNUNET_FS_Handle *ret;
 715   struct GNUNET_CLIENT_Connection *client;
 716   enum GNUNET_FS_OPTIONS opt;
 717   va_list ap;
 718
 719   client = GNUNET_CLIENT_connect (sched,
 720                                   "fs",
 721                                   cfg);
 722   if (NULL == client)
 723     return NULL;
 724   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Handle));
 725   ret->sched = sched;
 726   ret->cfg = cfg;
 727   ret->client_name = GNUNET_strdup (client_name);
 728   ret->upcb = upcb;
 729   ret->upcb_cls = upcb_cls;
 730   ret->client = client;
 731   ret->flags = flags;
 732   ret->max_parallel_downloads = 1;
 733   ret->max_parallel_requests = 1;
 734   ret->avg_block_latency = GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
 735   va_start (ap, flags);
 736   while (GNUNET_FS_OPTIONS_END != (opt = va_arg (ap, enum GNUNET_FS_OPTIONS)))
 737     {
 738       switch (opt)
 739         {
 740         case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
 741           ret->max_parallel_downloads = va_arg (ap, unsigned int);
 742           break;
 743         case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
 744           ret->max_parallel_requests = va_arg (ap, unsigned int);
 745           break;
 746         default:
 747           GNUNET_break (0);
 748           GNUNET_free (ret->client_name);
 749           GNUNET_free (ret);
 750           va_end (ap);
 751           return NULL;
 752         }
 753     }
 754   va_end (ap);
 755   // FIXME: setup receive-loop with client (do we need one?)
 756
 757   if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
 758     {
 759       deserialize_publish (ret);
 760       /* FIXME: not implemented! */
 761       // Deserialize Search:
 762       // * read search queries
 763       // * for each query, read file with search results
 764       // * for each search result with active download, deserialize download
 765       // * for each directory search result, check for active downloads of contents
 766       // Deserialize Download:
 767       // * always part of search???
 768       // Deserialize Unindex:
 769       // * read FNs for unindex with progress offset
 770     }
 771   return ret;
 772 }
 773
 774
 775 /**
 776  * Close our connection with the file-sharing service.
 777  * The callback given to GNUNET_FS_start will no longer be
 778  * called after this function returns.
 779  *
 780  * @param h handle that was returned from GNUNET_FS_start
 781  */
 782 void
 783 GNUNET_FS_stop (struct GNUNET_FS_Handle *h)
 784 {
 785   if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & h->flags))
 786     {
 787       // FIXME: generate SUSPEND events and clean up state!
 788     }
 789   // FIXME: terminate receive-loop with client  (do we need one?)
 790   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
 791     GNUNET_SCHEDULER_cancel (h->sched,
 792                              h->queue_job);
 793   GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
 794   GNUNET_free (h->client_name);
 795   GNUNET_free (h);
 796 }
 797
 798
 799 /* end of fs.c */