+ * @param sr the struct to sync
+ */
+void
+GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
+{
+ struct GNUNET_BIO_WriteHandle *wh;
+ char *uris;
+
+ uris = NULL;
+ if (NULL == sr->serialization)
+ sr->serialization =
+ make_serialization_file_name_in_dir (sr->sc->h,
+ (sr->sc->psearch_result ==
+ NULL) ?
+ GNUNET_FS_SYNC_PATH_MASTER_SEARCH :
+ GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+ sr->sc->serialization);
+ if (NULL == sr->serialization)
+ return;
+ wh = get_write_handle_in_dir (sr->sc->h,
+ (sr->sc->psearch_result ==
+ NULL) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH :
+ GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+ sr->sc->serialization, sr->serialization);
+ if (wh == NULL)
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ uris = GNUNET_FS_uri_to_string (sr->uri);
+ if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+ (GNUNET_OK !=
+ GNUNET_BIO_write_string (wh,
+ sr->download !=
+ NULL ? sr->download->serialization : NULL)) ||
+ (GNUNET_OK !=
+ GNUNET_BIO_write_string (wh,
+ sr->update_search !=
+ NULL ? sr->update_search->serialization : NULL))
+ || (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, sr->meta)) ||
+ (GNUNET_OK != GNUNET_BIO_write (wh, &sr->key, sizeof (GNUNET_HashCode)))
+ || (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->mandatory_missing)) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->optional_support)) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->availability_success)) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->availability_trials)))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+ {
+ wh = NULL;
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ GNUNET_free_non_null (uris);
+ return;
+cleanup:
+ GNUNET_free_non_null (uris);
+ if (wh != NULL)
+ (void) GNUNET_BIO_write_close (wh);
+ remove_sync_file_in_dir (sr->sc->h,
+ (sr->sc->psearch_result ==
+ NULL) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH :
+ GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+ sr->sc->serialization, sr->serialization);
+ GNUNET_free (sr->serialization);
+ sr->serialization = NULL;
+}
+
+
+/**
+ * Synchronize this search struct with its mirror
+ * on disk. Note that all internal FS-operations that change
+ * publishing structs should already call "sync" internally,
+ * so this function is likely not useful for clients.
+ *
+ * @param sc the struct to sync
+ */
+void
+GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc)
+{
+ struct GNUNET_BIO_WriteHandle *wh;
+ char *uris;
+ char in_pause;
+ const char *category;
+
+ category =
+ (sc->psearch_result ==
+ NULL) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH :
+ GNUNET_FS_SYNC_PATH_CHILD_SEARCH;
+ if (NULL == sc->serialization)
+ sc->serialization = make_serialization_file_name (sc->h, category);
+ if (NULL == sc->serialization)
+ return;
+ uris = NULL;
+ wh = get_write_handle (sc->h, category, sc->serialization);
+ if (wh == NULL)
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ GNUNET_assert ((GNUNET_YES == GNUNET_FS_uri_test_ksk (sc->uri)) ||
+ (GNUNET_YES == GNUNET_FS_uri_test_sks (sc->uri)));
+ uris = GNUNET_FS_uri_to_string (sc->uri);
+ in_pause = (sc->task != GNUNET_SCHEDULER_NO_TASK) ? 'r' : '\0';
+ if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+ (GNUNET_OK != write_start_time (wh, sc->start_time)) ||
+ (GNUNET_OK != GNUNET_BIO_write_string (wh, sc->emsg)) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) sc->options)) ||
+ (GNUNET_OK != GNUNET_BIO_write (wh, &in_pause, sizeof (in_pause))) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sc->anonymity)))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ GNUNET_free (uris);
+ uris = NULL;
+ if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+ {
+ wh = NULL;
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ return;
+cleanup:
+ if (wh != NULL)
+ (void) GNUNET_BIO_write_close (wh);
+ GNUNET_free_non_null (uris);
+ GNUNET_FS_remove_sync_file_ (sc->h, category, sc->serialization);
+ GNUNET_free (sc->serialization);
+ sc->serialization = NULL;
+}
+
+
+/**
+ * Function called with a filename of serialized unindexing operation
+ * to deserialize.
+ *
+ * @param cls the 'struct GNUNET_FS_Handle*'
+ * @param filename complete filename (absolute path)
+ * @return GNUNET_OK (continue to iterate)
+ */
+static int
+deserialize_unindex_file (void *cls, const char *filename)
+{
+ struct GNUNET_FS_Handle *h = cls;
+ struct GNUNET_BIO_ReadHandle *rh;
+ struct GNUNET_FS_UnindexContext *uc;
+ struct GNUNET_FS_ProgressInfo pi;
+ char *emsg;
+ uint32_t state;
+
+ uc = GNUNET_malloc (sizeof (struct GNUNET_FS_UnindexContext));
+ uc->h = h;
+ uc->serialization = get_serialization_short_name (filename);
+ rh = GNUNET_BIO_read_open (filename);
+ if (rh == NULL)
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ if ((GNUNET_OK !=
+ GNUNET_BIO_read_string (rh, "unindex-fn", &uc->filename, 10 * 1024)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &uc->file_size)) ||
+ (GNUNET_OK != read_start_time (rh, &uc->start_time)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &state)))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ uc->state = (enum UnindexState) state;
+ switch (state)
+ {
+ case UNINDEX_STATE_HASHING:
+ break;
+ case UNINDEX_STATE_FS_NOTIFY:
+ if (GNUNET_OK !=
+ GNUNET_BIO_read (rh, "unindex-hash", &uc->file_id,
+ sizeof (GNUNET_HashCode)))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ break;
+ case UNINDEX_STATE_DS_REMOVE:
+ break;
+ case UNINDEX_STATE_COMPLETE:
+ break;
+ case UNINDEX_STATE_ERROR:
+ if (GNUNET_OK !=
+ GNUNET_BIO_read_string (rh, "unindex-emsg", &uc->emsg, 10 * 1024))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ break;
+ default:
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ uc->top = GNUNET_FS_make_top (h, &GNUNET_FS_unindex_signal_suspend_, uc);
+ pi.status = GNUNET_FS_STATUS_UNINDEX_RESUME;
+ pi.value.unindex.specifics.resume.message = uc->emsg;
+ GNUNET_FS_unindex_make_status_ (&pi, uc,
+ (uc->state ==
+ UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
+ switch (uc->state)
+ {
+ case UNINDEX_STATE_HASHING:
+ uc->fhc =
+ GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE, uc->filename,
+ HASHING_BLOCKSIZE,
+ &GNUNET_FS_unindex_process_hash_, uc);
+ break;
+ case UNINDEX_STATE_FS_NOTIFY:
+ uc->state = UNINDEX_STATE_HASHING;
+ GNUNET_FS_unindex_process_hash_ (uc, &uc->file_id);
+ break;
+ case UNINDEX_STATE_DS_REMOVE:
+ GNUNET_FS_unindex_do_remove_ (uc);
+ break;
+ case UNINDEX_STATE_COMPLETE:
+ case UNINDEX_STATE_ERROR:
+ /* no need to resume any operation, we were done */
+ break;
+ default:
+ break;
+ }
+ if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failure while resuming unindexing operation `%s': %s\n"),
+ filename, emsg);
+ GNUNET_free (emsg);
+ }
+ return GNUNET_OK;
+cleanup:
+ GNUNET_free_non_null (uc->filename);
+ if ((rh != NULL) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failed to resume unindexing operation `%s': %s\n"), filename,
+ emsg);
+ GNUNET_free (emsg);
+ }
+ if (uc->serialization != NULL)
+ GNUNET_FS_remove_sync_file_ (h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+ uc->serialization);
+ GNUNET_free_non_null (uc->serialization);
+ GNUNET_free (uc);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Deserialize a download.
+ *
+ * @param h overall context
+ * @param rh file to deserialize from
+ * @param parent parent download
+ * @param search associated search
+ * @param serialization name under which the search was serialized
+ */
+static void
+deserialize_download (struct GNUNET_FS_Handle *h,
+ struct GNUNET_BIO_ReadHandle *rh,
+ struct GNUNET_FS_DownloadContext *parent,
+ struct GNUNET_FS_SearchResult *search,
+ const char *serialization);
+
+
+/**
+ * Deserialize a search.
+ *
+ * @param h overall context
+ * @param rh file to deserialize from
+ * @param psearch_result parent search result
+ * @param serialization name under which the search was serialized
+ */
+static struct GNUNET_FS_SearchContext *
+deserialize_search (struct GNUNET_FS_Handle *h,
+ struct GNUNET_BIO_ReadHandle *rh,
+ struct GNUNET_FS_SearchResult *psearch_result,
+ const char *serialization);
+
+
+/**
+ * Function called with a filename of serialized search result
+ * to deserialize.
+ *
+ * @param cls the 'struct GNUNET_FS_SearchContext*'
+ * @param filename complete filename (absolute path)
+ * @return GNUNET_OK (continue to iterate)
+ */
+static int
+deserialize_search_result (void *cls, const char *filename)
+{
+ struct GNUNET_FS_SearchContext *sc = cls;
+ char *ser;
+ char *uris;
+ char *emsg;
+ char *download;
+ char *update_srch;
+ struct GNUNET_BIO_ReadHandle *rh;
+ struct GNUNET_BIO_ReadHandle *drh;
+ struct GNUNET_FS_SearchResult *sr;
+
+ ser = get_serialization_short_name (filename);
+ rh = GNUNET_BIO_read_open (filename);
+ if (rh == NULL)
+ {
+ if (ser != NULL)
+ {
+ remove_sync_file_in_dir (sc->h,
+ (sc->psearch_result ==
+ NULL) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH :
+ GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+ sc->serialization, ser);
+ GNUNET_free (ser);
+ }
+ return GNUNET_OK;
+ }
+ emsg = NULL;
+ uris = NULL;
+ download = NULL;
+ update_srch = NULL;
+ sr = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchResult));
+ sr->serialization = ser;
+ if ((GNUNET_OK != GNUNET_BIO_read_string (rh, "result-uri", &uris, 10 * 1024))
+ || (NULL == (sr->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
+ (GNUNET_OK != GNUNET_BIO_read_string (rh, "download-lnk", &download, 16))
+ || (GNUNET_OK !=
+ GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
+ (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "result-meta", &sr->meta)) ||
+ (GNUNET_OK !=
+ GNUNET_BIO_read (rh, "result-key", &sr->key, sizeof (GNUNET_HashCode)))
+ || (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->mandatory_missing)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->optional_support)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->availability_success)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->availability_trials)))
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ GNUNET_free (uris);
+ if (download != NULL)
+ {
+ drh = get_read_handle (sc->h, GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, download);
+ if (drh != NULL)
+ {
+ deserialize_download (sc->h, drh, NULL, sr, download);
+ if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failed to resume sub-download `%s': %s\n"), download,
+ emsg);
+ GNUNET_free (emsg);
+ }
+ }
+ GNUNET_free (download);
+ }
+ if (update_srch != NULL)
+ {
+ drh =
+ get_read_handle (sc->h, GNUNET_FS_SYNC_PATH_CHILD_SEARCH, update_srch);
+ if (drh != NULL)
+ {
+ deserialize_search (sc->h, drh, sr, update_srch);
+ if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failed to resume sub-search `%s': %s\n"), update_srch,
+ emsg);
+ GNUNET_free (emsg);
+ }
+ }
+ GNUNET_free (update_srch);
+ }
+ GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &sr->key, sr,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+ if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failure while resuming search operation `%s': %s\n"),
+ filename, emsg);
+ GNUNET_free (emsg);
+ }
+ return GNUNET_OK;
+cleanup:
+ GNUNET_free_non_null (download);
+ GNUNET_free_non_null (emsg);
+ GNUNET_free_non_null (uris);
+ GNUNET_free_non_null (update_srch);
+ if (sr->uri != NULL)
+ GNUNET_FS_uri_destroy (sr->uri);
+ if (sr->meta != NULL)
+ GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+ GNUNET_free (sr->serialization);
+ GNUNET_free (sr);
+ if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failure while resuming search operation `%s': %s\n"),
+ filename, emsg);
+ GNUNET_free (emsg);
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ * Send the 'resume' signal to the callback; also actually
+ * resume the download (put it in the queue). Does this
+ * recursively for the top-level download and all child
+ * downloads.
+ *
+ * @param dc download to resume
+ */
+static void
+signal_download_resume (struct GNUNET_FS_DownloadContext *dc)
+{
+ struct GNUNET_FS_DownloadContext *dcc;
+ struct GNUNET_FS_ProgressInfo pi;
+
+ pi.status = GNUNET_FS_STATUS_DOWNLOAD_RESUME;
+ pi.value.download.specifics.resume.meta = dc->meta;
+ pi.value.download.specifics.resume.message = dc->emsg;
+ GNUNET_FS_download_make_status_ (&pi, dc);
+ dcc = dc->child_head;
+ while (NULL != dcc)
+ {
+ signal_download_resume (dcc);
+ dcc = dcc->next;
+ }
+ if (dc->pending_head != NULL)
+ GNUNET_FS_download_start_downloading_ (dc);
+}
+
+
+/**
+ * Signal resuming of a search to our clients (for the
+ * top level search and all sub-searches).
+ *
+ * @param sc search being resumed
+ */
+static void
+signal_search_resume (struct GNUNET_FS_SearchContext *sc);
+
+
+/**
+ * Iterator over search results signaling resume to the client for
+ * each result.
+ *
+ * @param cls closure, the 'struct GNUNET_FS_SearchContext'
+ * @param key current key code
+ * @param value value in the hash map, the 'struct GNUNET_FS_SearchResult'
+ * @return GNUNET_YES (we should continue to iterate)
+ */
+static int
+signal_result_resume (void *cls, const GNUNET_HashCode * key, void *value)
+{
+ struct GNUNET_FS_SearchContext *sc = cls;
+ struct GNUNET_FS_ProgressInfo pi;
+ struct GNUNET_FS_SearchResult *sr = value;
+
+ if (0 == sr->mandatory_missing)
+ {
+ pi.status = GNUNET_FS_STATUS_SEARCH_RESUME_RESULT;
+ pi.value.search.specifics.resume_result.meta = sr->meta;
+ pi.value.search.specifics.resume_result.uri = sr->uri;
+ pi.value.search.specifics.resume_result.result = sr;
+ pi.value.search.specifics.resume_result.availability_rank =
+ 2 * sr->availability_success - sr->availability_trials;
+ pi.value.search.specifics.resume_result.availability_certainty =
+ sr->availability_trials;
+ pi.value.search.specifics.resume_result.applicability_rank =
+ sr->optional_support;
+ sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
+ }
+ if (sr->download != NULL)
+ {
+ signal_download_resume (sr->download);
+ }
+ else
+ {
+ GNUNET_FS_search_start_probe_ (sr);
+ }
+ if (sr->update_search != NULL)
+ signal_search_resume (sr->update_search);
+ return GNUNET_YES;
+}
+
+
+/**
+ * Free memory allocated by the search context and its children
+ *
+ * @param sc search context to free
+ */
+static void
+free_search_context (struct GNUNET_FS_SearchContext *sc);
+
+
+/**
+ * Iterator over search results freeing each.
+ *
+ * @param cls closure, the 'struct GNUNET_FS_SearchContext'
+ * @param key current key code
+ * @param value value in the hash map, the 'struct GNUNET_FS_SearchResult'
+ * @return GNUNET_YES (we should continue to iterate)
+ */
+static int
+free_result (void *cls, const GNUNET_HashCode * key, void *value)
+{
+ struct GNUNET_FS_SearchResult *sr = value;
+
+ if (sr->update_search != NULL)
+ {
+ free_search_context (sr->update_search);
+ GNUNET_assert (NULL == sr->update_search);
+ }
+ GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+ GNUNET_FS_uri_destroy (sr->uri);
+ GNUNET_free (sr);
+ return GNUNET_YES;
+}
+
+
+/**
+ * Free memory allocated by the search context and its children
+ *
+ * @param sc search context to free