library routines for testing FS publishing and downloading; this code is limited to flat files and no keywords (those functions can be tested with single-peer setups; this is for testing routing). More...

#include "platform.h"
#include "fs_api.h"
#include "fs_test_lib.h"

Include dependency graph for fs_test_lib.c:

Data Structures
struct	TestPublishOperation
	Handle for a publishing operation started for testing FS. More...

struct	TestDownloadOperation
	Handle for a download operation started for testing FS. More...

Macros
#define	CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS

Functions
static void	report_uri (void *cls)
	Task scheduled to report on the completion of our publish operation. More...

static void	publish_timeout (void *cls)
	Task scheduled to run when publish operation times out. More...

static void *	publish_progress_cb (void cls, const struct GNUNET_FS_ProgressInfo info)
	Progress callback for file-sharing events while publishing. More...

static size_t	file_generator (void cls, uint64_t offset, size_t max, void buf, char **emsg)
	Generate test data for publishing test. More...

static void *	publish_connect_adapter (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	Connect adapter for publishing operation. More...

static void	fs_disconnect_adapter (void cls, void op_result)
	Adapter function called to destroy connection to file-sharing service. More...

static void	publish_fs_connect_complete_cb (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	Callback to be called when testbed has connected to the fs service. More...

void	GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer peer, struct GNUNET_TIME_Relative timeout, uint32_t anonymity, int do_index, uint64_t size, uint32_t seed, unsigned int verbose, GNUNET_FS_TEST_UriContinuation cont, void cont_cls)
	Publish a file at the given daemon. More...

static void	download_timeout (void *cls)
	Task scheduled to run when download operation times out. More...

static void	report_success (void *cls)
	Task scheduled to report on the completion of our download operation. More...

static void *	download_progress_cb (void cls, const struct GNUNET_FS_ProgressInfo info)
	Progress callback for file-sharing events while downloading. More...

static void *	download_connect_adapter (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	Connect adapter for download operation. More...

static void	download_fs_connect_complete_cb (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	Callback to be called when testbed has connected to the fs service. More...

void	GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer peer, struct GNUNET_TIME_Relative timeout, uint32_t anonymity, uint32_t seed, const struct GNUNET_FS_Uri uri, unsigned int verbose, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
	Perform test download. More...

Detailed Description

library routines for testing FS publishing and downloading; this code is limited to flat files and no keywords (those functions can be tested with single-peer setups; this is for testing routing).

Author: Christian Grothoff

Definition in file fs_test_lib.c.

Macro Definition Documentation

◆ CONTENT_LIFETIME

#define CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS

Definition at line 34 of file fs_test_lib.c.

Function Documentation

◆ report_uri()

static void report_uri ( void * cls )

static

Task scheduled to report on the completion of our publish operation.

Parameters

cls	the publish operation context

Definition at line 182 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
  
   GNUNET_FS_publish_stop (po->publish_context);
   GNUNET_TESTBED_operation_done (po->fs_op);
   po->publish_cont (po->publish_cont_cls,
                     po->publish_uri,
                     (GNUNET_YES == po->do_index)
                     ? po->publish_tmp_file
                     : NULL);
   GNUNET_FS_uri_destroy (po->publish_uri);
   if ((GNUNET_YES != po->do_index) &&
       (NULL != po->publish_tmp_file))
     (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
   GNUNET_free (po->publish_tmp_file);
   GNUNET_free (po);
 }

References TestPublishOperation::do_index, TestPublishOperation::fs_op, GNUNET_DISK_directory_remove(), GNUNET_free, GNUNET_FS_publish_stop(), GNUNET_FS_uri_destroy(), GNUNET_TESTBED_operation_done(), GNUNET_YES, TestPublishOperation::publish_cont, TestPublishOperation::publish_cont_cls, TestPublishOperation::publish_context, TestPublishOperation::publish_tmp_file, and TestPublishOperation::publish_uri.

Referenced by publish_progress_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ publish_timeout()

static void publish_timeout ( void * cls )

static

Task scheduled to run when publish operation times out.

Parameters

cls	the publish operation context

Definition at line 208 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
  
   po->publish_timeout_task = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Timeout while trying to publish data\n");
   GNUNET_TESTBED_operation_done (po->fs_op);
   GNUNET_FS_publish_stop (po->publish_context);
   po->publish_cont (po->publish_cont_cls, NULL, NULL);
   (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
   GNUNET_free (po->publish_tmp_file);
   GNUNET_free (po);
 }

References TestPublishOperation::fs_op, GNUNET_DISK_directory_remove(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_publish_stop(), GNUNET_log, GNUNET_TESTBED_operation_done(), TestPublishOperation::publish_cont, TestPublishOperation::publish_cont_cls, TestPublishOperation::publish_context, TestPublishOperation::publish_timeout_task, and TestPublishOperation::publish_tmp_file.

Referenced by GNUNET_FS_TEST_publish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ publish_progress_cb()

static void* publish_progress_cb	(	void *	cls,
		const struct GNUNET_FS_ProgressInfo *	info
	)

static

Progress callback for file-sharing events while publishing.

Parameters

cls	the publish operation context
info	information about the event

Definition at line 231 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
  
   switch (info->status)
   {
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     GNUNET_SCHEDULER_cancel (po->publish_timeout_task);
     po->publish_timeout_task = NULL;
     po->publish_uri =
       GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
     GNUNET_SCHEDULER_add_now (&report_uri,
                               po);
     break;
  
   case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
     if (po->verbose)
       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
                   (unsigned long long) info->value.publish.completed,
                   (unsigned long long) info->value.publish.size);
     break;
  
   case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
     break;
  
   case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
     if (po->verbose)
       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
                   (unsigned long long) info->value.download.completed,
                   (unsigned long long) info->value.download.size);
     break;
  
   default:
     break;
   }
   return NULL;
 }

References GNUNET_ERROR_TYPE_INFO, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS, GNUNET_FS_STATUS_PUBLISH_COMPLETED, GNUNET_FS_STATUS_PUBLISH_PROGRESS, GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY, GNUNET_FS_uri_dup(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), info, TestPublishOperation::publish_timeout_task, TestPublishOperation::publish_uri, report_uri(), and TestPublishOperation::verbose.

Referenced by publish_connect_adapter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_generator()

static size_t file_generator	(	void *	cls,
		uint64_t	offset,
		size_t	max,
		void *	buf,
		char **	emsg
	)

static

Generate test data for publishing test.

Parameters

cls	pointer to uint32_t with publishing seed
offset	offset to generate data for
max	maximum number of bytes to generate
buf	where to write generated data
emsg	where to store error message (unused)

Returns: number of bytes written to buf

Definition at line 281 of file fs_test_lib.c.

 {
   uint32_t *publish_seed = cls;
   uint64_t pos;
   uint8_t *cbuf = buf;
   int mod;
  
   if (emsg != NULL)
     *emsg = NULL;
   if (buf == NULL)
     return 0;
   for (pos = 0; pos < 8; pos++)
     cbuf[pos] = (uint8_t) (offset >> pos * 8);
   for (pos = 8; pos < max; pos++)
   {
     mod = (255 - (offset / 1024 / 32));
     if (mod == 0)
       mod = 1;
     cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod);
   }
   return max;
 }

References buf, max, and TestPublishOperation::publish_seed.

Referenced by publish_fs_connect_complete_cb().

Here is the caller graph for this function:

◆ publish_connect_adapter()

static void* publish_connect_adapter	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Connect adapter for publishing operation.

Parameters

cls	the 'struct TestPublishOperation'
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns: service handle to return in 'op_result', NULL on error

Definition at line 319 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
  
   return GNUNET_FS_start (cfg,
                           "fs-test-publish",
                           &publish_progress_cb, po,
                           GNUNET_FS_FLAGS_NONE,
                           GNUNET_FS_OPTIONS_END);
 }

References cfg, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END, GNUNET_FS_start(), and publish_progress_cb().

Referenced by GNUNET_FS_TEST_publish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fs_disconnect_adapter()

static void fs_disconnect_adapter	(	void *	cls,
		void *	op_result
	)

static

Adapter function called to destroy connection to file-sharing service.

Parameters

cls	the 'struct GNUNET_FS_Handle'
op_result	unused (different for publish/download!)

Definition at line 339 of file fs_test_lib.c.

 {
   struct GNUNET_FS_Handle *fs = op_result;
  
   GNUNET_FS_stop (fs);
 }

References fs, GNUNET_FS_stop(), and op_result().

Referenced by GNUNET_FS_TEST_download(), and GNUNET_FS_TEST_publish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ publish_fs_connect_complete_cb()

static void publish_fs_connect_complete_cb	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

Callback to be called when testbed has connected to the fs service.

Parameters

cls	the 'struct TestPublishOperation'
op	the operation that has been finished
ca_result	the 'struct GNUNET_FS_Handle ' (NULL on error)
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 358 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_DISK_FileHandle *fh;
   char *em;
   uint64_t off;
   char buf[DBLOCK_SIZE];
   size_t bsize;
   struct GNUNET_FS_BlockOptions bo;
  
   if (NULL == ca_result)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Failed to connect to FS for publishing: %s\n", emsg);
     po->publish_cont (po->publish_cont_cls,
                       NULL, NULL);
     GNUNET_TESTBED_operation_done (po->fs_op);
     GNUNET_free (po);
     return;
   }
   po->fs = ca_result;
  
   bo.expiration_time = GNUNET_TIME_relative_to_absolute (CONTENT_LIFETIME);
   bo.anonymity_level = po->anonymity;
   bo.content_priority = 42;
   bo.replication_level = 1;
   if (GNUNET_YES == po->do_index)
   {
     po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
     GNUNET_assert (po->publish_tmp_file != NULL);
     fh = GNUNET_DISK_file_open (po->publish_tmp_file,
                                 GNUNET_DISK_OPEN_WRITE
                                 | GNUNET_DISK_OPEN_CREATE,
                                 GNUNET_DISK_PERM_USER_READ
                                 | GNUNET_DISK_PERM_USER_WRITE);
     GNUNET_assert (NULL != fh);
     off = 0;
     while (off < po->size)
     {
       bsize = GNUNET_MIN (sizeof(buf), po->size - off);
       emsg = NULL;
       GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize,
                                               buf, &em));
       GNUNET_assert (em == NULL);
       GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize));
       off += bsize;
     }
     GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
     fi = GNUNET_FS_file_information_create_from_file (po->fs, po,
                                                       po->publish_tmp_file,
                                                       NULL, NULL, po->do_index,
                                                       &bo);
     GNUNET_assert (NULL != fi);
   }
   else
   {
     fi = GNUNET_FS_file_information_create_from_reader (po->fs, po,
                                                         po->size,
                                                         &file_generator,
                                                         &po->publish_seed,
                                                         NULL, NULL,
                                                         po->do_index, &bo);
     GNUNET_assert (NULL != fi);
   }
   po->publish_context =
     GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL,
                              GNUNET_FS_PUBLISH_OPTION_NONE);
 }

References TestPublishOperation::anonymity, GNUNET_FS_BlockOptions::anonymity_level, bo, bsize, buf, CONTENT_LIFETIME, GNUNET_FS_BlockOptions::content_priority, DBLOCK_SIZE, TestPublishOperation::do_index, GNUNET_FS_BlockOptions::expiration_time, fh, file_generator(), TestPublishOperation::fs, TestPublishOperation::fs_op, GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_mktemp(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_file_information_create_from_file(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_publish_start(), GNUNET_log, GNUNET_MIN, GNUNET_OK, GNUNET_TESTBED_operation_done(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, TestPublishOperation::publish_cont, TestPublishOperation::publish_cont_cls, TestPublishOperation::publish_context, TestPublishOperation::publish_seed, TestPublishOperation::publish_tmp_file, GNUNET_FS_BlockOptions::replication_level, TestPublishOperation::size, and size.

Referenced by GNUNET_FS_TEST_publish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_FS_TEST_publish()

void GNUNET_FS_TEST_publish	(	struct GNUNET_TESTBED_Peer *	peer,
		struct GNUNET_TIME_Relative	timeout,
		uint32_t	anonymity,
		int	do_index,
		uint64_t	size,
		uint32_t	seed,
		unsigned int	verbose,
		GNUNET_FS_TEST_UriContinuation	cont,
		void *	cont_cls
	)

Publish a file at the given daemon.

Parameters

peer	where to publish
timeout	if this operation cannot be completed within the given period, call the continuation with an error code
anonymity	option for publication
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
size	size of the file to publish
seed	seed to use for file generation
verbose	how verbose to be in reporting
cont	function to call when done
cont_cls	closure for cont

Definition at line 433 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po;
  
   po = GNUNET_new (struct TestPublishOperation);
   po->publish_cont = cont;
   po->publish_cont_cls = cont_cls;
   po->publish_seed = seed;
   po->anonymity = anonymity;
   po->size = size;
   po->verbose = verbose;
   po->do_index = do_index;
   po->fs_op = GNUNET_TESTBED_service_connect (po,
                                               peer,
                                               "fs",
                                               &publish_fs_connect_complete_cb,
                                               po,
                                               &publish_connect_adapter,
                                               &fs_disconnect_adapter,
                                               po);
   po->publish_timeout_task =
     GNUNET_SCHEDULER_add_delayed (timeout, &publish_timeout, po);
 }

References TestPublishOperation::anonymity, anonymity, TestPublishOperation::do_index, fs_disconnect_adapter(), TestPublishOperation::fs_op, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_service_connect(), peer, publish_connect_adapter(), TestPublishOperation::publish_cont, TestPublishOperation::publish_cont_cls, publish_fs_connect_complete_cb(), TestPublishOperation::publish_seed, publish_timeout(), TestPublishOperation::publish_timeout_task, TestPublishOperation::size, size, timeout, verbose, and TestPublishOperation::verbose.

Here is the call graph for this function:

◆ download_timeout()

static void download_timeout ( void * cls )

static

Task scheduled to run when download operation times out.

Parameters

cls	the download operation context

Definition at line 471 of file fs_test_lib.c.

 {
   struct TestDownloadOperation *dop = cls;
  
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Timeout while trying to download file\n");
   dop->download_timeout_task = NULL;
   GNUNET_FS_download_stop (dop->download_context,
                            GNUNET_YES);
   GNUNET_SCHEDULER_add_now (dop->download_cont,
                             dop->download_cont_cls);
   GNUNET_TESTBED_operation_done (dop->fs_op);
   GNUNET_FS_uri_destroy (dop->uri);
   GNUNET_free (dop);
 }

References TestDownloadOperation::download_cont, TestDownloadOperation::download_cont_cls, TestDownloadOperation::download_context, TestDownloadOperation::download_timeout_task, TestDownloadOperation::fs_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_download_stop(), GNUNET_FS_uri_destroy(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_operation_done(), GNUNET_YES, and TestDownloadOperation::uri.

Referenced by GNUNET_FS_TEST_download().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ report_success()

static void report_success ( void * cls )

static

Task scheduled to report on the completion of our download operation.

Parameters

cls	the download operation context

Definition at line 494 of file fs_test_lib.c.

 {
   struct TestDownloadOperation *dop = cls;
  
   GNUNET_FS_download_stop (dop->download_context,
                            GNUNET_YES);
   GNUNET_SCHEDULER_add_now (dop->download_cont,
                             dop->download_cont_cls);
   GNUNET_TESTBED_operation_done (dop->fs_op);
   GNUNET_FS_uri_destroy (dop->uri);
   GNUNET_free (dop);
 }

References TestDownloadOperation::download_cont, TestDownloadOperation::download_cont_cls, TestDownloadOperation::download_context, TestDownloadOperation::fs_op, GNUNET_free, GNUNET_FS_download_stop(), GNUNET_FS_uri_destroy(), GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_operation_done(), GNUNET_YES, and TestDownloadOperation::uri.

Referenced by download_progress_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ download_progress_cb()

static void* download_progress_cb	(	void *	cls,
		const struct GNUNET_FS_ProgressInfo *	info
	)

static

Progress callback for file-sharing events while downloading.

Parameters

cls	the download operation context
info	information about the event

Definition at line 515 of file fs_test_lib.c.

 {
   struct TestDownloadOperation *dop = cls;
  
   switch (info->status)
   {
   case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
     if (dop->verbose)
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Download at %llu/%llu bytes\n",
                   (unsigned long long) info->value.download.completed,
                   (unsigned long long) info->value.download.size);
     break;
  
   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
     GNUNET_SCHEDULER_cancel (dop->download_timeout_task);
     dop->download_timeout_task = NULL;
     GNUNET_SCHEDULER_add_now (&report_success, dop);
     break;
  
   case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
   case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
     break;
  
   /* FIXME: monitor data correctness during download progress */
   /* FIXME: do performance reports given sufficient verbosity */
   /* FIXME: advance timeout task to "immediate" on error */
   default:
     break;
   }
   return NULL;
 }

References TestDownloadOperation::download_timeout_task, GNUNET_ERROR_TYPE_INFO, GNUNET_FS_STATUS_DOWNLOAD_ACTIVE, GNUNET_FS_STATUS_DOWNLOAD_COMPLETED, GNUNET_FS_STATUS_DOWNLOAD_INACTIVE, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), info, report_success(), and TestDownloadOperation::verbose.

Referenced by download_connect_adapter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ download_connect_adapter()

static void* download_connect_adapter	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Connect adapter for download operation.

Parameters

cls	the 'struct TestDownloadOperation'
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns: service handle to return in 'op_result', NULL on error

Definition at line 560 of file fs_test_lib.c.

 {
   struct TestPublishOperation *po = cls;
  
   return GNUNET_FS_start (cfg,
                           "fs-test-download",
                           &download_progress_cb, po,
                           GNUNET_FS_FLAGS_NONE,
                           GNUNET_FS_OPTIONS_END);
 }

References cfg, download_progress_cb(), GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END, and GNUNET_FS_start().

Referenced by GNUNET_FS_TEST_download().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ download_fs_connect_complete_cb()

static void download_fs_connect_complete_cb	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

Callback to be called when testbed has connected to the fs service.

Parameters

cls	the 'struct TestPublishOperation'
op	the operation that has been finished
ca_result	the 'struct GNUNET_FS_Handle ' (NULL on error)
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 583 of file fs_test_lib.c.

 {
   struct TestDownloadOperation *dop = cls;
  
   dop->fs = ca_result;
   GNUNET_assert (NULL != dop->fs);
   dop->download_context =
     GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
                               dop->anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE,
                               NULL, NULL);
 }

References TestDownloadOperation::anonymity, TestDownloadOperation::download_context, TestDownloadOperation::fs, GNUNET_assert, GNUNET_FS_DOWNLOAD_OPTION_NONE, GNUNET_FS_download_start(), TestDownloadOperation::size, and TestDownloadOperation::uri.

Referenced by GNUNET_FS_TEST_download().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_FS_TEST_download()

void GNUNET_FS_TEST_download	(	struct GNUNET_TESTBED_Peer *	peer,
		struct GNUNET_TIME_Relative	timeout,
		uint32_t	anonymity,
		uint32_t	seed,
		const struct GNUNET_FS_Uri *	uri,
		unsigned int	verbose,
		GNUNET_SCHEDULER_TaskCallback	cont,
		void *	cont_cls
	)

Perform test download.

Parameters

peer	which peer to download from
timeout	if this operation cannot be completed within the given period, call the continuation with an error code
anonymity	option for download
seed	used for file validation
uri	URI of file to download (CHK/LOC only)
verbose	how verbose to be in reporting
cont	function to call when done
cont_cls	closure for cont

Definition at line 600 of file fs_test_lib.c.

 {
   struct TestDownloadOperation *dop;
  
   dop = GNUNET_new (struct TestDownloadOperation);
   dop->uri = GNUNET_FS_uri_dup (uri);
   dop->size = GNUNET_FS_uri_chk_get_file_size (uri);
   dop->verbose = verbose;
   dop->anonymity = anonymity;
   dop->download_cont = cont;
   dop->download_cont_cls = cont_cls;
   dop->download_seed = seed;
  
   dop->fs_op = GNUNET_TESTBED_service_connect (dop,
                                                peer,
                                                "fs",
                                                &download_fs_connect_complete_cb,
                                                dop,
                                                &download_connect_adapter,
                                                &fs_disconnect_adapter,
                                                dop);
   dop->download_timeout_task =
     GNUNET_SCHEDULER_add_delayed (timeout, &download_timeout, dop);
 }

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ CONTENT_LIFETIME

Function Documentation

◆ report_uri()

◆ publish_timeout()

◆ publish_progress_cb()

◆ file_generator()

◆ publish_connect_adapter()

◆ fs_disconnect_adapter()

◆ publish_fs_connect_complete_cb()

◆ GNUNET_FS_TEST_publish()

◆ download_timeout()

◆ report_success()

◆ download_progress_cb()

◆ download_connect_adapter()

◆ download_fs_connect_complete_cb()

◆ GNUNET_FS_TEST_download()