GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
static void
start_job (struct GNUNET_FS_QueueEntry *qe)
{
- qe->client = GNUNET_CLIENT_connect (qe->h->sched, "fs", qe->h->cfg);
+ qe->client = GNUNET_CLIENT_connect ("fs", qe->h->cfg);
if (qe->client == NULL)
{
GNUNET_break (0);
run_time);
rst = GNUNET_TIME_absolute_get_remaining (end_time);
restart_at = GNUNET_TIME_relative_min (rst, restart_at);
- if (rst.value > 0)
+ if (rst.rel_value > 0)
continue;
stop_job (qe);
}
- h->queue_job = GNUNET_SCHEDULER_add_delayed (h->sched,
- restart_at,
+ h->queue_job = GNUNET_SCHEDULER_add_delayed (restart_at,
&process_job_queue,
h);
}
h->pending_tail,
qe);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
h->queue_job
- = GNUNET_SCHEDULER_add_now (h->sched,
- &process_job_queue,
+ = GNUNET_SCHEDULER_add_now (&process_job_queue,
h);
return qe;
}
qh);
GNUNET_free (qh);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
h->queue_job
- = GNUNET_SCHEDULER_add_now (h->sched,
- &process_job_queue,
+ = GNUNET_SCHEDULER_add_now (&process_job_queue,
h);
}
&basename))
return NULL;
GNUNET_asprintf (&ret,
- "%s%s%s%s%s%s%s%s%s",
+ "%s%s%s%s%s%s%s.dir%s%s",
basename,
DIR_SEPARATOR_STR,
h->client_name,
return;
}
filename = get_serialization_file_name (h, ext, ent);
- if (0 != UNLINK (filename))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- filename);
- GNUNET_free (filename);
+ if (filename != NULL)
+ {
+ if (0 != UNLINK (filename))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ filename);
+ GNUNET_free (filename);
+ }
}
return;
}
filename = get_serialization_file_name_in_dir (h, ext, uni, ent);
- if (0 != UNLINK (filename))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- filename);
- GNUNET_free (filename);
+ if (filename != NULL)
+ {
+ if (0 != UNLINK (filename))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ filename);
+ GNUNET_free (filename);
+ }
}
struct GNUNET_TIME_Relative dur;
dur = GNUNET_TIME_absolute_get_duration (timestamp);
- return GNUNET_BIO_write_int64 (wh, dur.value);
+ return GNUNET_BIO_write_int64 (wh, dur.rel_value);
}
{
struct GNUNET_TIME_Relative dur;
if (GNUNET_OK !=
- GNUNET_BIO_read_int64 (rh, &dur.value))
+ GNUNET_BIO_read_int64 (rh, &dur.rel_value))
return GNUNET_SYSERR;
*timestamp = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
dur);
(GNUNET_YES !=
GNUNET_FS_uri_test_chk (ret->chk_uri)) ) ) ||
(GNUNET_OK !=
- GNUNET_BIO_read_int64 (rh, &ret->expirationTime.value)) ||
+ GNUNET_BIO_read_int64 (rh, &ret->expirationTime.abs_value)) ||
(GNUNET_OK !=
read_start_time (rh, &ret->start_time)) ||
(GNUNET_OK !=
ret->data.file.reader_cls = GNUNET_FS_make_file_reader_context_ (ret->filename);
break;
case 4: /* directory */
+ ret->is_directory = GNUNET_YES;
if ( (GNUNET_OK !=
GNUNET_BIO_read_int32 (rh, &dsize)) ||
(NULL == (ret->data.dir.dir_data = GNUNET_malloc_large (dsize))) ||
goto cleanup;
}
ret->data.dir.dir_size = (uint32_t) dsize;
- ret->is_directory = GNUNET_YES;
if (filename != NULL)
{
ret->data.dir.entries = deserialize_file_information (h, filename);
emsg);
GNUNET_free (emsg);
}
+ if (ret == NULL)
+ {
+ if (0 != UNLINK (filename))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ filename);
+ }
return ret;
}
if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
return NULL; /* persistence not requested */
dn = get_serialization_file_name (h, ext, "");
+ if (dn == NULL)
+ return NULL;
if (GNUNET_OK !=
GNUNET_DISK_directory_create_for_file (dn))
{
if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
return NULL; /* persistence not requested */
dn = get_serialization_file_name_in_dir (h, ext, uni, "");
+ if (dn == NULL)
+ return NULL;
if (GNUNET_OK !=
GNUNET_DISK_directory_create_for_file (dn))
{
char buf[32 * 1024];
uint64_t off;
size_t ret;
+ size_t left;
char *emsg;
emsg = NULL;
off = 0;
while (off < fi->data.file.file_size)
{
+ left = GNUNET_MIN (sizeof(buf), fi->data.file.file_size - off);
ret = fi->data.file.reader (fi->data.file.reader_cls,
- off, sizeof (buf),
+ off, left,
buf,
&emsg);
if (ret == 0)
(GNUNET_OK !=
GNUNET_BIO_write_string (wh, chks)) ||
(GNUNET_OK !=
- GNUNET_BIO_write_int64 (wh, fi->expirationTime.value)) ||
+ GNUNET_BIO_write_int64 (wh, fi->expirationTime.abs_value)) ||
(GNUNET_OK !=
write_start_time (wh, fi->start_time)) ||
(GNUNET_OK !=
(GNUNET_OK !=
GNUNET_BIO_write (wh, fi->data.dir.dir_data, (uint32_t) fi->data.dir.dir_size)) ||
(GNUNET_OK !=
- GNUNET_BIO_write_string (wh, fi->data.dir.entries->serialization)) )
+ GNUNET_BIO_write_string (wh,
+ (fi->data.dir.entries == NULL)
+ ? NULL
+ : fi->data.dir.entries->serialization)) )
{
GNUNET_break (0);
goto cleanup;
if (GNUNET_OK !=
GNUNET_BIO_write_close (wh))
{
+ wh = NULL;
GNUNET_break (0);
goto cleanup;
}
return; /* done! */
cleanup:
- (void) GNUNET_BIO_write_close (wh);
+ if (wh != NULL)
+ (void) GNUNET_BIO_write_close (wh);
GNUNET_free_non_null (chks);
GNUNET_free_non_null (ksks);
fn = get_serialization_file_name (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO, fi->serialization);
- if (0 != UNLINK (fn))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
- GNUNET_free (fn);
+ if (NULL != fn)
+ {
+ if (0 != UNLINK (fn))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+ GNUNET_free (fn);
+ }
GNUNET_free (fi->serialization);
fi->serialization = NULL;
}
* @param uri pointer to the keywords that will be used for this entry (can be modified)
* @param anonymity pointer to selected anonymity level (can be modified)
* @param priority pointer to selected priority (can be modified)
+ * @param do_index should we index?
* @param expirationTime pointer to selected expiration time (can be modified)
* @param client_info pointer to client context set upon creation (can be modified)
* @return GNUNET_OK to continue (always)
struct GNUNET_FS_Uri **uri,
uint32_t *anonymity,
uint32_t *priority,
+ int *do_index,
struct GNUNET_TIME_Absolute *expirationTime,
void **client_info)
{
if ( (0 == (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) &&
(GNUNET_YES != pc->all_done) )
{
- pc->dsh = GNUNET_DATASTORE_connect (h->cfg,
- h->sched);
+ pc->dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == pc->dsh)
goto cleanup;
}
pc->fi_pos = pc->fi;
}
}
+ GNUNET_free (fi_root);
+ fi_root = NULL;
/* generate RESUME event(s) */
GNUNET_FS_file_information_inspect (pc->fi,
&fip_signal_resume,
/* re-start publishing (if needed)... */
if (pc->all_done != GNUNET_YES)
pc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
pc);
if (GNUNET_OK !=
GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
if (0 != UNLINK (filename))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
- GNUNET_free_non_null (pc->serialization);
+ GNUNET_free (pc->serialization);
GNUNET_free (pc);
return GNUNET_OK;
}
{
struct GNUNET_BIO_WriteHandle *wh;
- if (UNINDEX_STATE_ABORTED == uc->state)
- return;
if (NULL == uc->serialization)
uc->serialization = make_serialization_file_name (uc->h,
GNUNET_FS_SYNC_PATH_MASTER_UNINDEX);
}
fn = GNUNET_DISK_mktemp (dir);
GNUNET_free (dir);
+ if (fn == NULL)
+ return;
dc->serialization = get_serialization_short_name (fn);
}
else
{
fn = get_download_sync_filename (dc, dc->serialization, "");
+ if (fn == NULL)
+ {
+ GNUNET_free (dc->serialization);
+ dc->serialization = NULL;
+ GNUNET_free (fn);
+ return;
+ }
}
wh = GNUNET_BIO_write_open (fn);
if (wh == NULL)
goto cleanup;
}
GNUNET_free_non_null (uris);
+ uris = NULL;
if (GNUNET_OK !=
GNUNET_BIO_write_close (wh))
{
category);
if (NULL == sc->serialization)
return;
+ uris = NULL;
wh = get_write_handle (sc->h, category, sc->serialization);
if (wh == NULL)
{
goto cleanup;
}
break;
- case UNINDEX_STATE_ABORTED:
- GNUNET_break (0);
- goto cleanup;
default:
GNUNET_break (0);
goto cleanup;
switch (uc->state)
{
case UNINDEX_STATE_HASHING:
- GNUNET_CRYPTO_hash_file (uc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
- uc->filename,
- HASHING_BLOCKSIZE,
- &GNUNET_FS_unindex_process_hash_,
- uc);
+ 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;
emsg = NULL;
uris = NULL;
download = NULL;
+ update_srch = NULL;
sr = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchResult));
sr->serialization = ser;
if ( (GNUNET_OK !=
drh = get_read_handle (sc->h,
GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
download);
- deserialize_download (sc->h,
- drh,
- NULL,
- sr,
- download);
- if (GNUNET_OK !=
- GNUNET_BIO_read_close (drh, &emsg))
+ if (drh != NULL)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to resume sub-download `%s': %s\n"),
- download,
- emsg);
- GNUNET_free (emsg);
+ 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);
}
drh = get_read_handle (sc->h,
GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
update_srch);
- deserialize_search (sc->h,
- drh,
- sr,
- update_srch);
- if (GNUNET_OK !=
- GNUNET_BIO_read_close (drh, &emsg))
+ if (drh != NULL)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to resume sub-search `%s': %s\n"),
- update_srch,
- emsg);
- GNUNET_free (emsg);
+ 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_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;
}
return GNUNET_OK;
}
sc = deserialize_search (h, rh, NULL, ser);
- sc->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, sc);
+ if (sc != NULL)
+ sc->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, sc);
GNUNET_free (ser);
if (GNUNET_OK !=
GNUNET_BIO_read_close (rh, &emsg))
rh = GNUNET_BIO_read_open (filename);
if (rh == NULL)
{
- if (filename != NULL)
- {
- if (0 != UNLINK (filename))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- filename);
- GNUNET_free (ser);
- }
+ if (0 != UNLINK (filename))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ filename);
+ GNUNET_free (ser);
return GNUNET_OK;
}
deserialize_download (h, rh, NULL, NULL, ser);
/**
* Setup a connection to the file-sharing service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param client_name unique identifier for this client
* @param upcb function to call to notify about FS actions
* @return NULL on error
*/
struct GNUNET_FS_Handle *
-GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *client_name,
GNUNET_FS_ProgressCallback upcb,
void *upcb_cls,
va_list ap;
ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Handle));
- ret->sched = sched;
ret->cfg = cfg;
ret->client_name = GNUNET_strdup (client_name);
ret->upcb = upcb;
while (h->top_head != NULL)
h->top_head->ssf (h->top_head->ssf_cls);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
GNUNET_free (h->client_name);
GNUNET_free (h);
}