* @param cls closure (points to the file information)
* @param offset offset to read from; it is possible
* that the caller might need to go backwards
- * a bit at times
+ * a bit at times; set to UINT64_MAX to tell
+ * the reader that we won't be reading for a while
+ * (used to close the file descriptor but NOT fully
+ * clean up the reader's state); in this case,
+ * a value of '0' for max should be ignored
* @param max maximum number of bytes that should be
* copied to buf; readers are not allowed
* to provide less data unless there is an error;
struct FileInfo *fi = cls;
ssize_t ret;
- if (max == 0)
+ if (UINT64_MAX == offset)
+ {
+ if (NULL != fi->fd)
+ {
+ GNUNET_DISK_file_close (fi->fd);
+ fi->fd = NULL;
+ }
+ return 0;
+ }
+ if (0 == max)
{
- if (fi->fd != NULL)
+ if (NULL != fi->fd)
GNUNET_DISK_file_close (fi->fd);
GNUNET_free (fi->filename);
GNUNET_free (fi);
return 0;
}
- if (fi->fd == NULL)
+ if (NULL == fi->fd)
{
fi->fd =
GNUNET_DISK_file_open (fi->filename, GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
- if (fi->fd == NULL)
+ if (NULL == fi->fd)
{
GNUNET_asprintf (emsg, _("Could not open file `%s': %s"), fi->filename,
STRERROR (errno));
}
GNUNET_DISK_file_seek (fi->fd, offset, GNUNET_DISK_SEEK_SET);
ret = GNUNET_DISK_file_read (fi->fd, buf, max);
- if (ret == -1)
+ if (-1 == ret)
{
GNUNET_asprintf (emsg, _("Could not read file `%s': %s"), fi->filename,
STRERROR (errno));
* @param cls closure (points to the buffer)
* @param offset offset to read from; it is possible
* that the caller might need to go backwards
- * a bit at times
+ * a bit at times; set to UINT64_MAX to tell
+ * the reader that we won't be reading for a while
+ * (used to close the file descriptor but NOT fully
+ * clean up the reader's state); in this case,
+ * a value of '0' for max should be ignored
* @param max maximum number of bytes that should be
* copied to buf; readers are not allowed
* to provide less data unless there is an error;
{
char *data = cls;
+ if (UINT64_MAX == offset)
+ return 0;
if (max == 0)
{
GNUNET_free_non_null (data);
GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
{
struct GNUNET_BIO_WriteHandle *wh;
+ char *uris;
if (NULL == uc->serialization)
uc->serialization =
GNUNET_break (0);
goto cleanup;
}
+ if (NULL != uc->ksk_uri)
+ uris = GNUNET_FS_uri_to_string (uc->ksk_uri);
+ else
+ uris = NULL;
if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uc->filename)) ||
(GNUNET_OK != GNUNET_BIO_write_int64 (wh, uc->file_size)) ||
(GNUNET_OK != write_start_time (wh, uc->start_time)) ||
(GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->state)) ||
+ (GNUNET_OK !=
+ GNUNET_BIO_write (wh, &uc->chk, sizeof (struct ContentHashKey))) ||
+ (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+ (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->ksk_offset)) ||
((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
(GNUNET_OK !=
GNUNET_BIO_write (wh, &uc->file_id, sizeof (GNUNET_HashCode)))) ||
char *fn;
char *dir;
+ if (0 != (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
+ return; /* we don't sync probes */
if (NULL == dc->serialization)
{
dir = get_download_sync_filename (dc, "", "");
struct GNUNET_FS_UnindexContext *uc;
struct GNUNET_FS_ProgressInfo pi;
char *emsg;
+ char *uris;
uint32_t state;
uc = GNUNET_malloc (sizeof (struct GNUNET_FS_UnindexContext));
GNUNET_break (0);
goto cleanup;
}
+ uris = NULL;
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_OK != GNUNET_BIO_read_int32 (rh, &state)) ||
+ (GNUNET_OK != GNUNET_BIO_read (rh, "uri", &uc->chk, sizeof (struct ContentHashKey))) ||
+ (GNUNET_OK != GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
+ (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &uc->ksk_offset)) )
{
+ GNUNET_free_non_null (uris);
GNUNET_break (0);
goto cleanup;
}
+ if (NULL != uris)
+ {
+ uc->ksk_uri = GNUNET_FS_uri_parse (uris, &emsg);
+ GNUNET_free (uris);
+ if (NULL == uc->ksk_uri)
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
+ }
+ if ( (uc->ksk_offset > 0) &&
+ ( (NULL == uc->ksk_uri) ||
+ (uc->ksk_offset > uc->ksk_uri->data.ksk.keywordCount) ) )
+ {
+ GNUNET_break (0);
+ goto cleanup;
+ }
uc->state = (enum UnindexState) state;
switch (state)
{
}
break;
case UNINDEX_STATE_DS_REMOVE:
+ case UNINDEX_STATE_EXTRACT_KEYWORDS:
+ case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
break;
case UNINDEX_STATE_COMPLETE:
break;
case UNINDEX_STATE_DS_REMOVE:
GNUNET_FS_unindex_do_remove_ (uc);
break;
+ case UNINDEX_STATE_EXTRACT_KEYWORDS:
+ GNUNET_FS_unindex_do_extract_keywords_ (uc);
+ break;
+ case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
+ GNUNET_FS_unindex_do_remove_kblocks_ (uc);
+ break;
case UNINDEX_STATE_COMPLETE:
case UNINDEX_STATE_ERROR:
/* no need to resume any operation, we were done */