diff options
Diffstat (limited to 'src/fs/test_fs_download_indexed.c')
-rw-r--r-- | src/fs/test_fs_download_indexed.c | 355 |
1 files changed, 174 insertions, 181 deletions
diff --git a/src/fs/test_fs_download_indexed.c b/src/fs/test_fs_download_indexed.c index c99dd04de..86933352a 100644 --- a/src/fs/test_fs_download_indexed.c +++ b/src/fs/test_fs_download_indexed.c | |||
@@ -46,7 +46,7 @@ | |||
46 | 46 | ||
47 | /** | 47 | /** |
48 | * How long should our test-content live? | 48 | * How long should our test-content live? |
49 | */ | 49 | */ |
50 | #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15) | 50 | #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15) |
51 | 51 | ||
52 | struct PeerContext | 52 | struct PeerContext |
@@ -76,55 +76,51 @@ static char *fn1; | |||
76 | static int err; | 76 | static int err; |
77 | 77 | ||
78 | static void | 78 | static void |
79 | timeout_kill_task (void *cls, | 79 | timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
80 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
81 | { | 80 | { |
82 | if (download != NULL) | 81 | if (download != NULL) |
83 | { | 82 | { |
84 | GNUNET_FS_download_stop (download, GNUNET_YES); | 83 | GNUNET_FS_download_stop (download, GNUNET_YES); |
85 | download = NULL; | 84 | download = NULL; |
86 | } | 85 | } |
87 | else if (publish != NULL) | 86 | else if (publish != NULL) |
88 | { | 87 | { |
89 | GNUNET_FS_publish_stop (publish); | 88 | GNUNET_FS_publish_stop (publish); |
90 | publish = NULL; | 89 | publish = NULL; |
91 | } | 90 | } |
92 | timeout_kill = GNUNET_SCHEDULER_NO_TASK; | 91 | timeout_kill = GNUNET_SCHEDULER_NO_TASK; |
93 | err = 1; | 92 | err = 1; |
94 | } | 93 | } |
95 | 94 | ||
96 | static void | 95 | static void |
97 | abort_publish_task (void *cls, | 96 | abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
98 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
99 | { | 97 | { |
100 | if (publish != NULL) | 98 | if (publish != NULL) |
101 | { | 99 | { |
102 | GNUNET_FS_publish_stop (publish); | 100 | GNUNET_FS_publish_stop (publish); |
103 | publish = NULL; | 101 | publish = NULL; |
104 | } | 102 | } |
105 | } | 103 | } |
106 | 104 | ||
107 | static void | 105 | static void |
108 | stop_fs_task (void *cls, | 106 | stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
109 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
110 | { | 107 | { |
111 | GNUNET_FS_stop (fs); | 108 | GNUNET_FS_stop (fs); |
112 | fs = NULL; | 109 | fs = NULL; |
113 | } | 110 | } |
114 | 111 | ||
115 | static void | 112 | static void |
116 | abort_download_task (void *cls, | 113 | abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
117 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
118 | { | 114 | { |
119 | uint64_t size; | 115 | uint64_t size; |
120 | 116 | ||
121 | if (download != NULL) | 117 | if (download != NULL) |
122 | { | 118 | { |
123 | GNUNET_FS_download_stop (download, GNUNET_YES); | 119 | GNUNET_FS_download_stop (download, GNUNET_YES); |
124 | download = NULL; | 120 | download = NULL; |
125 | } | 121 | } |
126 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES)); | 122 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES)); |
127 | GNUNET_assert (size == FILESIZE); | 123 | GNUNET_assert (size == FILESIZE); |
128 | GNUNET_DISK_directory_remove (fn); | 124 | GNUNET_DISK_directory_remove (fn); |
129 | GNUNET_free (fn); | 125 | GNUNET_free (fn); |
130 | fn = NULL; | 126 | fn = NULL; |
@@ -134,115 +130,116 @@ abort_download_task (void *cls, | |||
134 | 130 | ||
135 | 131 | ||
136 | static void * | 132 | static void * |
137 | progress_cb (void *cls, | 133 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) |
138 | const struct GNUNET_FS_ProgressInfo *event) | ||
139 | { | 134 | { |
140 | 135 | ||
141 | switch (event->status) | 136 | switch (event->status) |
142 | { | 137 | { |
143 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: | 138 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: |
144 | #if VERBOSE | 139 | #if VERBOSE |
145 | printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n", | 140 | printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n", |
146 | (unsigned long long) event->value.publish.completed, | 141 | (unsigned long long) event->value.publish.completed, |
147 | (unsigned long long) event->value.publish.size, | 142 | (unsigned long long) event->value.publish.size, |
148 | event->value.publish.specifics.progress.depth, | 143 | event->value.publish.specifics.progress.depth, |
149 | (unsigned long long) event->value.publish.specifics.progress.offset); | 144 | (unsigned long long) event->value.publish.specifics. |
150 | #endif | 145 | progress.offset); |
151 | break; | 146 | #endif |
152 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: | 147 | break; |
153 | printf ("Publishing complete, %llu kbps.\n", | 148 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: |
154 | (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL)); | 149 | printf ("Publishing complete, %llu kbps.\n", |
155 | GAUGER ("FS", | 150 | (unsigned long long) (FILESIZE * 1000LL / |
156 | "Publishing speed (indexing)", | 151 | (1 + |
157 | (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL), | 152 | GNUNET_TIME_absolute_get_duration |
158 | "kb/s"); | 153 | (start).rel_value) / 1024LL)); |
159 | fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst"); | 154 | GAUGER ("FS", "Publishing speed (indexing)", |
160 | start = GNUNET_TIME_absolute_get (); | 155 | (unsigned long long) (FILESIZE * 1000LL / |
161 | download = GNUNET_FS_download_start (fs, | 156 | (1 + |
162 | event->value.publish.specifics.completed.chk_uri, | 157 | GNUNET_TIME_absolute_get_duration |
163 | NULL, | 158 | (start).rel_value) / 1024LL), "kb/s"); |
164 | fn, NULL, | 159 | fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst"); |
165 | 0, | 160 | start = GNUNET_TIME_absolute_get (); |
166 | FILESIZE, | 161 | download = GNUNET_FS_download_start (fs, |
167 | 1, | 162 | event->value.publish. |
168 | GNUNET_FS_DOWNLOAD_OPTION_NONE, | 163 | specifics.completed.chk_uri, NULL, fn, |
169 | "download", | 164 | NULL, 0, FILESIZE, 1, |
170 | NULL); | 165 | GNUNET_FS_DOWNLOAD_OPTION_NONE, |
171 | GNUNET_assert (download != NULL); | 166 | "download", NULL); |
172 | break; | 167 | GNUNET_assert (download != NULL); |
173 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | 168 | break; |
174 | printf ("Download complete, %llu kbps.\n", | 169 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: |
175 | (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL)); | 170 | printf ("Download complete, %llu kbps.\n", |
176 | GAUGER ("FS", | 171 | (unsigned long long) (FILESIZE * 1000LL / |
177 | "Local download speed (indexed)", | 172 | (1 + |
178 | (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL), | 173 | GNUNET_TIME_absolute_get_duration |
179 | "kb/s"); | 174 | (start).rel_value) / 1024LL)); |
180 | GNUNET_SCHEDULER_add_now (&abort_download_task, | 175 | GAUGER ("FS", "Local download speed (indexed)", |
181 | NULL); | 176 | (unsigned long long) (FILESIZE * 1000LL / |
182 | break; | 177 | (1 + |
183 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: | 178 | GNUNET_TIME_absolute_get_duration |
184 | GNUNET_assert (download == event->value.download.dc); | 179 | (start).rel_value) / 1024LL), "kb/s"); |
180 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); | ||
181 | break; | ||
182 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: | ||
183 | GNUNET_assert (download == event->value.download.dc); | ||
185 | #if VERBOSE | 184 | #if VERBOSE |
186 | printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n", | 185 | printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n", |
187 | (unsigned long long) event->value.download.completed, | 186 | (unsigned long long) event->value.download.completed, |
188 | (unsigned long long) event->value.download.size, | 187 | (unsigned long long) event->value.download.size, |
189 | event->value.download.specifics.progress.depth, | 188 | event->value.download.specifics.progress.depth, |
190 | (unsigned long long) event->value.download.specifics.progress.offset); | 189 | (unsigned long long) event->value.download.specifics. |
190 | progress.offset); | ||
191 | #endif | 191 | #endif |
192 | break; | 192 | break; |
193 | case GNUNET_FS_STATUS_PUBLISH_ERROR: | 193 | case GNUNET_FS_STATUS_PUBLISH_ERROR: |
194 | fprintf (stderr, | 194 | fprintf (stderr, |
195 | "Error publishing file: %s\n", | 195 | "Error publishing file: %s\n", |
196 | event->value.publish.specifics.error.message); | 196 | event->value.publish.specifics.error.message); |
197 | GNUNET_break (0); | 197 | GNUNET_break (0); |
198 | GNUNET_SCHEDULER_add_continuation (&abort_publish_task, | 198 | GNUNET_SCHEDULER_add_continuation (&abort_publish_task, |
199 | NULL, | 199 | NULL, |
200 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 200 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
201 | break; | 201 | break; |
202 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: | 202 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: |
203 | fprintf (stderr, | 203 | fprintf (stderr, |
204 | "Error downloading file: %s\n", | 204 | "Error downloading file: %s\n", |
205 | event->value.download.specifics.error.message); | 205 | event->value.download.specifics.error.message); |
206 | GNUNET_SCHEDULER_add_now (&abort_download_task, | 206 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); |
207 | NULL); | 207 | break; |
208 | break; | 208 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: |
209 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | 209 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: |
210 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | 210 | break; |
211 | break; | 211 | case GNUNET_FS_STATUS_PUBLISH_START: |
212 | case GNUNET_FS_STATUS_PUBLISH_START: | 212 | GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx)); |
213 | GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx)); | 213 | GNUNET_assert (NULL == event->value.publish.pctx); |
214 | GNUNET_assert (NULL == event->value.publish.pctx); | 214 | GNUNET_assert (FILESIZE == event->value.publish.size); |
215 | GNUNET_assert (FILESIZE == event->value.publish.size); | 215 | GNUNET_assert (0 == event->value.publish.completed); |
216 | GNUNET_assert (0 == event->value.publish.completed); | 216 | GNUNET_assert (1 == event->value.publish.anonymity); |
217 | GNUNET_assert (1 == event->value.publish.anonymity); | 217 | break; |
218 | break; | 218 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: |
219 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: | 219 | GNUNET_assert (publish == event->value.publish.pc); |
220 | GNUNET_assert (publish == event->value.publish.pc); | 220 | GNUNET_assert (FILESIZE == event->value.publish.size); |
221 | GNUNET_assert (FILESIZE == event->value.publish.size); | 221 | GNUNET_assert (1 == event->value.publish.anonymity); |
222 | GNUNET_assert (1 == event->value.publish.anonymity); | 222 | GNUNET_SCHEDULER_add_now (&stop_fs_task, NULL); |
223 | GNUNET_SCHEDULER_add_now (&stop_fs_task, | 223 | break; |
224 | NULL); | 224 | case GNUNET_FS_STATUS_DOWNLOAD_START: |
225 | break; | 225 | GNUNET_assert (0 == strcmp ("download", event->value.download.cctx)); |
226 | case GNUNET_FS_STATUS_DOWNLOAD_START: | 226 | GNUNET_assert (NULL == event->value.download.pctx); |
227 | GNUNET_assert (0 == strcmp ("download", event->value.download.cctx)); | 227 | GNUNET_assert (NULL != event->value.download.uri); |
228 | GNUNET_assert (NULL == event->value.download.pctx); | 228 | GNUNET_assert (0 == strcmp (fn, event->value.download.filename)); |
229 | GNUNET_assert (NULL != event->value.download.uri); | 229 | GNUNET_assert (FILESIZE == event->value.download.size); |
230 | GNUNET_assert (0 == strcmp (fn, event->value.download.filename)); | 230 | GNUNET_assert (0 == event->value.download.completed); |
231 | GNUNET_assert (FILESIZE == event->value.download.size); | 231 | GNUNET_assert (1 == event->value.download.anonymity); |
232 | GNUNET_assert (0 == event->value.download.completed); | 232 | break; |
233 | GNUNET_assert (1 == event->value.download.anonymity); | 233 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: |
234 | break; | 234 | GNUNET_assert (download == event->value.download.dc); |
235 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | 235 | GNUNET_SCHEDULER_add_continuation (&abort_publish_task, |
236 | GNUNET_assert (download == event->value.download.dc); | 236 | NULL, |
237 | GNUNET_SCHEDULER_add_continuation (&abort_publish_task, | 237 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
238 | NULL, | 238 | break; |
239 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 239 | default: |
240 | break; | 240 | printf ("Unexpected event: %d\n", event->status); |
241 | default: | 241 | break; |
242 | printf ("Unexpected event: %d\n", | 242 | } |
243 | event->status); | ||
244 | break; | ||
245 | } | ||
246 | return NULL; | 243 | return NULL; |
247 | } | 244 | } |
248 | 245 | ||
@@ -253,11 +250,11 @@ setup_peer (struct PeerContext *p, const char *cfgname) | |||
253 | p->cfg = GNUNET_CONFIGURATION_create (); | 250 | p->cfg = GNUNET_CONFIGURATION_create (); |
254 | #if START_ARM | 251 | #if START_ARM |
255 | p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", | 252 | p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", |
256 | "gnunet-service-arm", | 253 | "gnunet-service-arm", |
257 | #if VERBOSE | 254 | #if VERBOSE |
258 | "-L", "DEBUG", | 255 | "-L", "DEBUG", |
259 | #endif | 256 | #endif |
260 | "-c", cfgname, NULL); | 257 | "-c", cfgname, NULL); |
261 | #endif | 258 | #endif |
262 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | 259 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
263 | } | 260 | } |
@@ -268,16 +265,17 @@ stop_arm (struct PeerContext *p) | |||
268 | { | 265 | { |
269 | #if START_ARM | 266 | #if START_ARM |
270 | if (NULL != p->arm_proc) | 267 | if (NULL != p->arm_proc) |
271 | { | 268 | { |
272 | if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) | 269 | if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) |
273 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 270 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
274 | if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK) | 271 | if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK) |
275 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); | 272 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); |
276 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 273 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
277 | "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc)); | 274 | "ARM process %u stopped\n", |
278 | GNUNET_OS_process_close (p->arm_proc); | 275 | GNUNET_OS_process_get_pid (p->arm_proc)); |
279 | p->arm_proc = NULL; | 276 | GNUNET_OS_process_close (p->arm_proc); |
280 | } | 277 | p->arm_proc = NULL; |
278 | } | ||
281 | #endif | 279 | #endif |
282 | GNUNET_CONFIGURATION_destroy (p->cfg); | 280 | GNUNET_CONFIGURATION_destroy (p->cfg); |
283 | } | 281 | } |
@@ -286,8 +284,7 @@ stop_arm (struct PeerContext *p) | |||
286 | static void | 284 | static void |
287 | run (void *cls, | 285 | run (void *cls, |
288 | char *const *args, | 286 | char *const *args, |
289 | const char *cfgfile, | 287 | const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) |
290 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
291 | { | 288 | { |
292 | const char *keywords[] = { | 289 | const char *keywords[] = { |
293 | "down_foo", | 290 | "down_foo", |
@@ -302,47 +299,43 @@ run (void *cls, | |||
302 | 299 | ||
303 | setup_peer (&p1, "test_fs_download_data.conf"); | 300 | setup_peer (&p1, "test_fs_download_data.conf"); |
304 | fs = GNUNET_FS_start (cfg, | 301 | fs = GNUNET_FS_start (cfg, |
305 | "test-fs-download-indexed", | 302 | "test-fs-download-indexed", |
306 | &progress_cb, | 303 | &progress_cb, |
307 | NULL, | 304 | NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
308 | GNUNET_FS_FLAGS_NONE, | 305 | GNUNET_assert (NULL != fs); |
309 | GNUNET_FS_OPTIONS_END); | ||
310 | GNUNET_assert (NULL != fs); | ||
311 | 306 | ||
312 | fn1 = GNUNET_DISK_mktemp ("gnunet-download-indexed-test"); | 307 | fn1 = GNUNET_DISK_mktemp ("gnunet-download-indexed-test"); |
313 | buf = GNUNET_malloc (FILESIZE); | 308 | buf = GNUNET_malloc (FILESIZE); |
314 | for (i = 0; i < FILESIZE; i++) | 309 | for (i = 0; i < FILESIZE; i++) |
315 | buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256); | 310 | buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256); |
316 | GNUNET_assert (FILESIZE == | 311 | GNUNET_assert (FILESIZE == |
317 | GNUNET_DISK_fn_write (fn1, | 312 | GNUNET_DISK_fn_write (fn1, |
318 | buf, | 313 | buf, |
319 | FILESIZE, | 314 | FILESIZE, |
320 | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE)); | 315 | GNUNET_DISK_PERM_USER_READ | |
316 | GNUNET_DISK_PERM_USER_WRITE)); | ||
321 | GNUNET_free (buf); | 317 | GNUNET_free (buf); |
322 | meta = GNUNET_CONTAINER_meta_data_create (); | 318 | meta = GNUNET_CONTAINER_meta_data_create (); |
323 | kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords); | 319 | kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords); |
324 | bo.content_priority = 42; | 320 | bo.content_priority = 42; |
325 | bo.anonymity_level = 1; | 321 | bo.anonymity_level = 1; |
326 | bo.replication_level = 0; | 322 | bo.replication_level = 0; |
327 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME); | 323 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME); |
328 | fi = GNUNET_FS_file_information_create_from_file (fs, | 324 | fi = GNUNET_FS_file_information_create_from_file (fs, |
329 | "publish-context", | 325 | "publish-context", |
330 | fn1, | 326 | fn1, |
331 | kuri, | 327 | kuri, |
332 | meta, | 328 | meta, GNUNET_YES, &bo); |
333 | GNUNET_YES, | ||
334 | &bo); | ||
335 | GNUNET_FS_uri_destroy (kuri); | 329 | GNUNET_FS_uri_destroy (kuri); |
336 | GNUNET_CONTAINER_meta_data_destroy (meta); | 330 | GNUNET_CONTAINER_meta_data_destroy (meta); |
337 | GNUNET_assert (NULL != fi); | 331 | GNUNET_assert (NULL != fi); |
338 | timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT, | 332 | timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
339 | &timeout_kill_task, | 333 | &timeout_kill_task, NULL); |
340 | NULL); | ||
341 | start = GNUNET_TIME_absolute_get (); | 334 | start = GNUNET_TIME_absolute_get (); |
342 | publish = GNUNET_FS_publish_start (fs, | 335 | publish = GNUNET_FS_publish_start (fs, |
343 | fi, | 336 | fi, |
344 | NULL, NULL, NULL, | 337 | NULL, NULL, NULL, |
345 | GNUNET_FS_PUBLISH_OPTION_NONE); | 338 | GNUNET_FS_PUBLISH_OPTION_NONE); |
346 | GNUNET_assert (publish != NULL); | 339 | GNUNET_assert (publish != NULL); |
347 | } | 340 | } |
348 | 341 | ||
@@ -350,7 +343,7 @@ run (void *cls, | |||
350 | int | 343 | int |
351 | main (int argc, char *argv[]) | 344 | main (int argc, char *argv[]) |
352 | { | 345 | { |
353 | char *const argvx[] = { | 346 | char *const argvx[] = { |
354 | "test-fs-download-indexed", | 347 | "test-fs-download-indexed", |
355 | "-c", | 348 | "-c", |
356 | "test_fs_download_data.conf", | 349 | "test_fs_download_data.conf", |
@@ -363,27 +356,27 @@ main (int argc, char *argv[]) | |||
363 | GNUNET_GETOPT_OPTION_END | 356 | GNUNET_GETOPT_OPTION_END |
364 | }; | 357 | }; |
365 | 358 | ||
366 | GNUNET_log_setup ("test_fs_download_indexed", | 359 | GNUNET_log_setup ("test_fs_download_indexed", |
367 | #if VERBOSE | 360 | #if VERBOSE |
368 | "DEBUG", | 361 | "DEBUG", |
369 | #else | 362 | #else |
370 | "WARNING", | 363 | "WARNING", |
371 | #endif | 364 | #endif |
372 | NULL); | 365 | NULL); |
373 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, | 366 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, |
374 | argvx, "test-fs-download-indexed", | 367 | argvx, "test-fs-download-indexed", |
375 | "nohelp", options, &run, NULL); | 368 | "nohelp", options, &run, NULL); |
376 | stop_arm (&p1); | 369 | stop_arm (&p1); |
377 | if (fn1 != NULL) | 370 | if (fn1 != NULL) |
378 | { | 371 | { |
379 | GNUNET_DISK_directory_remove (fn1); | 372 | GNUNET_DISK_directory_remove (fn1); |
380 | GNUNET_free (fn1); | 373 | GNUNET_free (fn1); |
381 | } | 374 | } |
382 | if (fn != NULL) | 375 | if (fn != NULL) |
383 | { | 376 | { |
384 | GNUNET_DISK_directory_remove (fn); | 377 | GNUNET_DISK_directory_remove (fn); |
385 | GNUNET_free (fn); | 378 | GNUNET_free (fn); |
386 | } | 379 | } |
387 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/"); | 380 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/"); |
388 | return err; | 381 | return err; |
389 | } | 382 | } |