static void *
progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
{
const char *keywords[] = {
"down_foo"
};
struct GNUNET_FS_Uri *kuri;
switch (event->status)
{
case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Publish is progressing (%llu/%llu at level %u off %llu)...\n",
(unsigned long long) event->value.publish.completed,
(unsigned long long) event->value.publish.size,
event->value.publish.specifics.progress.depth,
(unsigned long long) event->value.publish.specifics.
progress.offset);
break;
case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
kuri = GNUNET_FS_uri_ksk_create_from_args (1, keywords);
start = GNUNET_TIME_absolute_get ();
GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
"search");
GNUNET_FS_uri_destroy (kuri);
GNUNET_assert (search != NULL);
break;
case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
if (event->value.publish.pc == publish)
publish = NULL;
break;
case GNUNET_FS_STATUS_PUBLISH_RESUME:
if (NULL == publish)
publish = event->value.publish.pc;
break;
case GNUNET_FS_STATUS_SEARCH_RESULT:
/* FIXME: consider_restart (event->status); cannot be tested with
* search result since we exit here after the first one... */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Search complete.\n");
GNUNET_SCHEDULER_add_continuation (&abort_search_task, NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
case GNUNET_FS_STATUS_PUBLISH_ERROR:
FPRINTF (stderr, "Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
case GNUNET_FS_STATUS_SEARCH_ERROR:
FPRINTF (stderr, "Error searching file: %s\n",
event->value.search.specifics.error.message);
GNUNET_SCHEDULER_add_continuation (&abort_search_task, NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
case GNUNET_FS_STATUS_SEARCH_SUSPEND:
if (event->value.search.sc == search)
search = NULL;
break;
case GNUNET_FS_STATUS_SEARCH_RESUME:
if (NULL == search)
{
search = event->value.search.sc;
return "search";
}
break;
case GNUNET_FS_STATUS_PUBLISH_START:
GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
GNUNET_assert (NULL == event->value.publish.pctx);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (0 == event->value.publish.completed);
GNUNET_assert (1 == event->value.publish.anonymity);
break;
case GNUNET_FS_STATUS_PUBLISH_STOPPED:
GNUNET_assert (publish == event->value.publish.pc);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (1 == event->value.publish.anonymity);
GNUNET_FS_stop (fs);
fs = NULL;
break;
case GNUNET_FS_STATUS_SEARCH_START:
consider_restart (event->status);
GNUNET_assert (search == NULL);
search = event->value.search.sc;
GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
GNUNET_assert (1 == event->value.search.anonymity);
break;
case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
break;
case GNUNET_FS_STATUS_SEARCH_STOPPED:
GNUNET_assert (search == event->value.search.sc);
GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
search = NULL;
break;
default:
FPRINTF (stderr, "Unexpected event: %d\n", event->status);
break;
}
return NULL;
}
static void *
progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
{
void *ret;
ret = NULL;
switch (event->status)
{
case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
consider_restart (event->status);
ret = event->value.publish.cctx;
printf ("Publish complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000LL /
(1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value) / 1024));
if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
break;
case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
consider_restart (event->status);
ret = event->value.publish.cctx;
GNUNET_assert (publish == event->value.publish.pc);
#if VERBOSE
printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
(unsigned long long) event->value.publish.completed,
(unsigned long long) event->value.publish.size,
event->value.publish.specifics.progress.depth,
(unsigned long long) event->value.publish.specifics.
progress.offset);
#endif
break;
case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
if (event->value.publish.pc == publish)
publish = NULL;
break;
case GNUNET_FS_STATUS_PUBLISH_RESUME:
if (NULL == publish)
{
GNUNET_assert (GNUNET_YES ==
GNUNET_FS_file_information_is_directory (event->
value.publish.
fi));
publish = event->value.publish.pc;
return "publish-context-dir";
}
break;
case GNUNET_FS_STATUS_PUBLISH_ERROR:
ret = event->value.publish.cctx;
FPRINTF (stderr, "Error publishing file: %s\n",
event->value.publish.specifics.error.message);
err = 1;
GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
break;
case GNUNET_FS_STATUS_PUBLISH_START:
consider_restart (event->status);
publish = event->value.publish.pc;
ret = event->value.publish.cctx;
if (0 == strcmp ("publish-context1", event->value.publish.cctx))
{
GNUNET_assert (0 ==
strcmp ("publish-context-dir", event->value.publish.pctx));
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (0 == event->value.publish.completed);
GNUNET_assert (1 == event->value.publish.anonymity);
}
else if (0 == strcmp ("publish-context2", event->value.publish.cctx))
{
GNUNET_assert (0 ==
strcmp ("publish-context-dir", event->value.publish.pctx));
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (0 == event->value.publish.completed);
GNUNET_assert (2 == event->value.publish.anonymity);
}
else if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
{
GNUNET_assert (0 == event->value.publish.completed);
GNUNET_assert (3 == event->value.publish.anonymity);
}
else
GNUNET_assert (0);
break;
case GNUNET_FS_STATUS_PUBLISH_STOPPED:
consider_restart (event->status);
if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
GNUNET_assert (publish == event->value.publish.pc);
break;
default:
printf ("Unexpected event: %d\n", event->status);
break;
}
return ret;
}
static void *
progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
{
switch (event->status)
{
case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Publish is progressing (%llu/%llu at level %u off %llu)...\n",
(unsigned long long) event->value.publish.completed,
(unsigned long long) event->value.publish.size,
event->value.publish.specifics.progress.depth,
(unsigned long long) event->value.publish.specifics.
progress.offset);
break;
case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
break;
case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
printf ("Publishing complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000000LL /
(1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us) / 1024));
start = GNUNET_TIME_absolute_get ();
unindex = GNUNET_FS_unindex_start (fs, fn, "unindex");
GNUNET_assert (unindex != NULL);
break;
case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
printf ("Unindex complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000000LL /
(1 +
GNUNET_TIME_absolute_get_duration
(start).rel_value_us) / 1024));
GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
break;
case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
consider_restart (event->status);
GNUNET_assert (unindex == event->value.unindex.uc);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Unindex is progressing (%llu/%llu at level %u off %llu)...\n",
(unsigned long long) event->value.unindex.completed,
(unsigned long long) event->value.unindex.size,
event->value.unindex.specifics.progress.depth,
(unsigned long long) event->value.unindex.specifics.
progress.offset);
break;
case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
if (event->value.publish.pc == publish)
publish = NULL;
break;
case GNUNET_FS_STATUS_PUBLISH_RESUME:
if (NULL == publish)
{
publish = event->value.publish.pc;
return "publish-context";
}
break;
case GNUNET_FS_STATUS_UNINDEX_SUSPEND:
GNUNET_assert (event->value.unindex.uc == unindex);
unindex = NULL;
break;
case GNUNET_FS_STATUS_UNINDEX_RESUME:
GNUNET_assert (NULL == unindex);
unindex = event->value.unindex.uc;
return "unindex";
case GNUNET_FS_STATUS_PUBLISH_ERROR:
FPRINTF (stderr, "Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
break;
case GNUNET_FS_STATUS_UNINDEX_ERROR:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Error unindexing file: %s\n",
event->value.unindex.specifics.error.message);
GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
break;
case GNUNET_FS_STATUS_PUBLISH_START:
GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
GNUNET_assert (NULL == event->value.publish.pctx);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (0 == event->value.publish.completed);
GNUNET_assert (1 == event->value.publish.anonymity);
break;
case GNUNET_FS_STATUS_PUBLISH_STOPPED:
GNUNET_assert (publish == event->value.publish.pc);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (1 == event->value.publish.anonymity);
GNUNET_FS_stop (fs);
fs = NULL;
break;
case GNUNET_FS_STATUS_UNINDEX_START:
consider_restart (event->status);
GNUNET_assert (unindex == NULL);
GNUNET_assert (0 == strcmp ("unindex", event->value.unindex.cctx));
GNUNET_assert (0 == strcmp (fn, event->value.unindex.filename));
GNUNET_assert (FILESIZE == event->value.unindex.size);
GNUNET_assert (0 == event->value.unindex.completed);
break;
case GNUNET_FS_STATUS_UNINDEX_STOPPED:
GNUNET_assert (unindex == event->value.unindex.uc);
GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
break;
default:
printf ("Unexpected event: %d\n", event->status);
break;
}
return NULL;
}
