diff options
Diffstat (limited to 'src/fs/test_fs_download_persistence.c')
-rw-r--r-- | src/fs/test_fs_download_persistence.c | 399 |
1 files changed, 200 insertions, 199 deletions
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c index 78dbe821e..7b7a886eb 100644 --- a/src/fs/test_fs_download_persistence.c +++ b/src/fs/test_fs_download_persistence.c | |||
@@ -36,12 +36,12 @@ | |||
36 | /** | 36 | /** |
37 | * How long until we give up on transmitting the message? | 37 | * How long until we give up on transmitting the message? |
38 | */ | 38 | */ |
39 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60) | 39 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) |
40 | 40 | ||
41 | /** | 41 | /** |
42 | * How long should our test-content live? | 42 | * How long should our test-content live? |
43 | */ | 43 | */ |
44 | #define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15) | 44 | #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15) |
45 | 45 | ||
46 | 46 | ||
47 | static struct GNUNET_TIME_Absolute start; | 47 | static struct GNUNET_TIME_Absolute start; |
@@ -54,7 +54,7 @@ static struct GNUNET_FS_DownloadContext *download; | |||
54 | 54 | ||
55 | static struct GNUNET_FS_PublishContext *publish; | 55 | static struct GNUNET_FS_PublishContext *publish; |
56 | 56 | ||
57 | static struct GNUNET_SCHEDULER_Task * timeout_kill; | 57 | static struct GNUNET_SCHEDULER_Task *timeout_kill; |
58 | 58 | ||
59 | static char *fn; | 59 | static char *fn; |
60 | 60 | ||
@@ -62,66 +62,67 @@ static int err; | |||
62 | 62 | ||
63 | 63 | ||
64 | static void | 64 | static void |
65 | timeout_kill_task(void *cls) | 65 | timeout_kill_task (void *cls) |
66 | { | 66 | { |
67 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n"); | 67 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n"); |
68 | if (download != NULL) | 68 | if (download != NULL) |
69 | { | 69 | { |
70 | GNUNET_FS_download_stop(download, GNUNET_YES); | 70 | GNUNET_FS_download_stop (download, GNUNET_YES); |
71 | download = NULL; | 71 | download = NULL; |
72 | } | 72 | } |
73 | else if (publish != NULL) | 73 | else if (publish != NULL) |
74 | { | 74 | { |
75 | GNUNET_FS_publish_stop(publish); | 75 | GNUNET_FS_publish_stop (publish); |
76 | publish = NULL; | 76 | publish = NULL; |
77 | } | 77 | } |
78 | timeout_kill = NULL; | 78 | timeout_kill = NULL; |
79 | err = 1; | 79 | err = 1; |
80 | } | 80 | } |
81 | 81 | ||
82 | 82 | ||
83 | static void | 83 | static void |
84 | abort_publish_task(void *cls) | 84 | abort_publish_task (void *cls) |
85 | { | 85 | { |
86 | if (publish != NULL) | 86 | if (publish != NULL) |
87 | { | 87 | { |
88 | GNUNET_FS_publish_stop(publish); | 88 | GNUNET_FS_publish_stop (publish); |
89 | publish = NULL; | 89 | publish = NULL; |
90 | } | 90 | } |
91 | } | 91 | } |
92 | 92 | ||
93 | 93 | ||
94 | static void | 94 | static void |
95 | abort_download_task(void *cls) | 95 | abort_download_task (void *cls) |
96 | { | 96 | { |
97 | uint64_t size; | 97 | uint64_t size; |
98 | 98 | ||
99 | if (download != NULL) | 99 | if (download != NULL) |
100 | { | 100 | { |
101 | GNUNET_FS_download_stop(download, GNUNET_YES); | 101 | GNUNET_FS_download_stop (download, GNUNET_YES); |
102 | download = NULL; | 102 | download = NULL; |
103 | } | 103 | } |
104 | GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_size(fn, &size, GNUNET_YES, GNUNET_NO)); | 104 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES, |
105 | GNUNET_assert(size == FILESIZE); | 105 | GNUNET_NO)); |
106 | GNUNET_DISK_directory_remove(fn); | 106 | GNUNET_assert (size == FILESIZE); |
107 | GNUNET_free(fn); | 107 | GNUNET_DISK_directory_remove (fn); |
108 | GNUNET_free (fn); | ||
108 | fn = NULL; | 109 | fn = NULL; |
109 | GNUNET_SCHEDULER_cancel(timeout_kill); | 110 | GNUNET_SCHEDULER_cancel (timeout_kill); |
110 | timeout_kill = NULL; | 111 | timeout_kill = NULL; |
111 | } | 112 | } |
112 | 113 | ||
113 | 114 | ||
114 | static void * | 115 | static void * |
115 | progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event); | 116 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event); |
116 | 117 | ||
117 | 118 | ||
118 | static void | 119 | static void |
119 | restart_fs_task(void *cls) | 120 | restart_fs_task (void *cls) |
120 | { | 121 | { |
121 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n"); | 122 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n"); |
122 | GNUNET_FS_stop(fs); | 123 | GNUNET_FS_stop (fs); |
123 | fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, | 124 | fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL, |
124 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); | 125 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); |
125 | } | 126 | } |
126 | 127 | ||
127 | 128 | ||
@@ -133,7 +134,7 @@ restart_fs_task(void *cls) | |||
133 | * @param ev type of the event to consider | 134 | * @param ev type of the event to consider |
134 | */ | 135 | */ |
135 | static void | 136 | static void |
136 | consider_restart(int ev) | 137 | consider_restart (int ev) |
137 | { | 138 | { |
138 | static int prev[32]; | 139 | static int prev[32]; |
139 | static int off; | 140 | static int off; |
@@ -143,158 +144,158 @@ consider_restart(int ev) | |||
143 | if (prev[i] == ev) | 144 | if (prev[i] == ev) |
144 | return; | 145 | return; |
145 | prev[off++] = ev; | 146 | prev[off++] = ev; |
146 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT, | 147 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT, |
147 | &restart_fs_task, NULL); | 148 | &restart_fs_task, NULL); |
148 | } | 149 | } |
149 | 150 | ||
150 | 151 | ||
151 | static void * | 152 | static void * |
152 | progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) | 153 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) |
153 | { | 154 | { |
154 | switch (event->status) | 155 | switch (event->status) |
155 | { | 156 | { |
156 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: | 157 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: |
157 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 158 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
158 | "Publish is progressing (%llu/%llu at level %u off %llu)...\n", | 159 | "Publish is progressing (%llu/%llu at level %u off %llu)...\n", |
159 | (unsigned long long)event->value.publish.completed, | 160 | (unsigned long long) event->value.publish.completed, |
160 | (unsigned long long)event->value.publish.size, | 161 | (unsigned long long) event->value.publish.size, |
161 | event->value.publish.specifics.progress.depth, | 162 | event->value.publish.specifics.progress.depth, |
162 | (unsigned long long)event->value.publish.specifics. | 163 | (unsigned long long) event->value.publish.specifics. |
163 | progress.offset); | 164 | progress.offset); |
164 | break; | 165 | break; |
165 | 166 | ||
166 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: | 167 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: |
167 | break; | 168 | break; |
168 | 169 | ||
169 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: | 170 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: |
170 | printf("Publishing complete, %llu kbps.\n", | 171 | printf ("Publishing complete, %llu kbps.\n", |
171 | (unsigned long long)(FILESIZE * 1000000LL / | 172 | (unsigned long long) (FILESIZE * 1000000LL |
172 | (1 + | 173 | / (1 |
173 | GNUNET_TIME_absolute_get_duration | 174 | + GNUNET_TIME_absolute_get_duration |
174 | (start).rel_value_us) / 1024LL)); | 175 | (start).rel_value_us) / 1024LL)); |
175 | fn = GNUNET_DISK_mktemp("gnunet-download-test-dst"); | 176 | fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst"); |
176 | start = GNUNET_TIME_absolute_get(); | 177 | start = GNUNET_TIME_absolute_get (); |
177 | GNUNET_assert(download == NULL); | 178 | GNUNET_assert (download == NULL); |
178 | GNUNET_FS_download_start(fs, | 179 | GNUNET_FS_download_start (fs, |
179 | event->value.publish.specifics.completed.chk_uri, | 180 | event->value.publish.specifics.completed.chk_uri, |
180 | NULL, fn, NULL, 0, FILESIZE, 1, | 181 | NULL, fn, NULL, 0, FILESIZE, 1, |
181 | GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL); | 182 | GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL); |
182 | break; | 183 | break; |
183 | 184 | ||
184 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | 185 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: |
185 | printf("Download complete, %llu kbps.\n", | 186 | printf ("Download complete, %llu kbps.\n", |
186 | (unsigned long long)(FILESIZE * 1000000LL / | 187 | (unsigned long long) (FILESIZE * 1000000LL |
187 | (1 + | 188 | / (1 |
188 | GNUNET_TIME_absolute_get_duration | 189 | + GNUNET_TIME_absolute_get_duration |
189 | (start).rel_value_us) / 1024LL)); | 190 | (start).rel_value_us) / 1024LL)); |
190 | GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); | 191 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); |
191 | break; | 192 | break; |
192 | 193 | ||
193 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: | 194 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: |
194 | consider_restart(event->status); | 195 | consider_restart (event->status); |
195 | GNUNET_assert(download == event->value.download.dc); | 196 | GNUNET_assert (download == event->value.download.dc); |
196 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 197 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
197 | "Download is progressing (%llu/%llu at level %u off %llu)...\n", | 198 | "Download is progressing (%llu/%llu at level %u off %llu)...\n", |
198 | (unsigned long long)event->value.download.completed, | 199 | (unsigned long long) event->value.download.completed, |
199 | (unsigned long long)event->value.download.size, | 200 | (unsigned long long) event->value.download.size, |
200 | event->value.download.specifics.progress.depth, | 201 | event->value.download.specifics.progress.depth, |
201 | (unsigned long long)event->value.download.specifics. | 202 | (unsigned long long) event->value.download.specifics. |
202 | progress.offset); | 203 | progress.offset); |
203 | break; | 204 | break; |
204 | 205 | ||
205 | case GNUNET_FS_STATUS_PUBLISH_ERROR: | 206 | case GNUNET_FS_STATUS_PUBLISH_ERROR: |
206 | fprintf(stderr, "Error publishing file: %s\n", | 207 | fprintf (stderr, "Error publishing file: %s\n", |
207 | event->value.publish.specifics.error.message); | 208 | event->value.publish.specifics.error.message); |
208 | GNUNET_break(0); | 209 | GNUNET_break (0); |
209 | GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); | 210 | GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL); |
210 | break; | 211 | break; |
211 | 212 | ||
212 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: | 213 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: |
213 | fprintf(stderr, "Error downloading file: %s\n", | 214 | fprintf (stderr, "Error downloading file: %s\n", |
214 | event->value.download.specifics.error.message); | 215 | event->value.download.specifics.error.message); |
215 | GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); | 216 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); |
216 | break; | 217 | break; |
217 | 218 | ||
218 | case GNUNET_FS_STATUS_PUBLISH_SUSPEND: | 219 | case GNUNET_FS_STATUS_PUBLISH_SUSPEND: |
219 | GNUNET_assert(event->value.publish.pc == publish); | 220 | GNUNET_assert (event->value.publish.pc == publish); |
220 | publish = NULL; | 221 | publish = NULL; |
221 | break; | 222 | break; |
222 | 223 | ||
223 | case GNUNET_FS_STATUS_PUBLISH_RESUME: | 224 | case GNUNET_FS_STATUS_PUBLISH_RESUME: |
224 | GNUNET_assert(NULL == publish); | 225 | GNUNET_assert (NULL == publish); |
225 | publish = event->value.publish.pc; | 226 | publish = event->value.publish.pc; |
226 | break; | 227 | break; |
227 | 228 | ||
228 | case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: | 229 | case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: |
229 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n"); | 230 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n"); |
230 | GNUNET_assert(event->value.download.dc == download); | 231 | GNUNET_assert (event->value.download.dc == download); |
231 | download = NULL; | 232 | download = NULL; |
232 | break; | 233 | break; |
233 | 234 | ||
234 | case GNUNET_FS_STATUS_DOWNLOAD_RESUME: | 235 | case GNUNET_FS_STATUS_DOWNLOAD_RESUME: |
235 | GNUNET_assert(NULL == download); | 236 | GNUNET_assert (NULL == download); |
236 | download = event->value.download.dc; | 237 | download = event->value.download.dc; |
237 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n"); | 238 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n"); |
238 | break; | 239 | break; |
239 | 240 | ||
240 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | 241 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: |
241 | consider_restart(event->status); | 242 | consider_restart (event->status); |
242 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download active.\n"); | 243 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download active.\n"); |
243 | break; | 244 | break; |
244 | 245 | ||
245 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | 246 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: |
246 | consider_restart(event->status); | 247 | consider_restart (event->status); |
247 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n"); | 248 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n"); |
248 | break; | 249 | break; |
249 | 250 | ||
250 | case GNUNET_FS_STATUS_PUBLISH_START: | 251 | case GNUNET_FS_STATUS_PUBLISH_START: |
251 | GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx)); | 252 | GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx)); |
252 | GNUNET_assert(NULL == event->value.publish.pctx); | 253 | GNUNET_assert (NULL == event->value.publish.pctx); |
253 | GNUNET_assert(FILESIZE == event->value.publish.size); | 254 | GNUNET_assert (FILESIZE == event->value.publish.size); |
254 | GNUNET_assert(0 == event->value.publish.completed); | 255 | GNUNET_assert (0 == event->value.publish.completed); |
255 | GNUNET_assert(1 == event->value.publish.anonymity); | 256 | GNUNET_assert (1 == event->value.publish.anonymity); |
256 | break; | 257 | break; |
257 | 258 | ||
258 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: | 259 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: |
259 | GNUNET_assert(publish == event->value.publish.pc); | 260 | GNUNET_assert (publish == event->value.publish.pc); |
260 | GNUNET_assert(FILESIZE == event->value.publish.size); | 261 | GNUNET_assert (FILESIZE == event->value.publish.size); |
261 | GNUNET_assert(1 == event->value.publish.anonymity); | 262 | GNUNET_assert (1 == event->value.publish.anonymity); |
262 | GNUNET_FS_stop(fs); | 263 | GNUNET_FS_stop (fs); |
263 | fs = NULL; | 264 | fs = NULL; |
264 | break; | 265 | break; |
265 | 266 | ||
266 | case GNUNET_FS_STATUS_DOWNLOAD_START: | 267 | case GNUNET_FS_STATUS_DOWNLOAD_START: |
267 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download started.\n"); | 268 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download started.\n"); |
268 | consider_restart(event->status); | 269 | consider_restart (event->status); |
269 | GNUNET_assert(download == NULL); | 270 | GNUNET_assert (download == NULL); |
270 | download = event->value.download.dc; | 271 | download = event->value.download.dc; |
271 | GNUNET_assert(0 == strcmp("download", event->value.download.cctx)); | 272 | GNUNET_assert (0 == strcmp ("download", event->value.download.cctx)); |
272 | GNUNET_assert(NULL == event->value.download.pctx); | 273 | GNUNET_assert (NULL == event->value.download.pctx); |
273 | GNUNET_assert(NULL != event->value.download.uri); | 274 | GNUNET_assert (NULL != event->value.download.uri); |
274 | GNUNET_assert(0 == strcmp(fn, event->value.download.filename)); | 275 | GNUNET_assert (0 == strcmp (fn, event->value.download.filename)); |
275 | GNUNET_assert(FILESIZE == event->value.download.size); | 276 | GNUNET_assert (FILESIZE == event->value.download.size); |
276 | GNUNET_assert(0 == event->value.download.completed); | 277 | GNUNET_assert (0 == event->value.download.completed); |
277 | GNUNET_assert(1 == event->value.download.anonymity); | 278 | GNUNET_assert (1 == event->value.download.anonymity); |
278 | break; | 279 | break; |
279 | 280 | ||
280 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | 281 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: |
281 | GNUNET_assert(download == event->value.download.dc); | 282 | GNUNET_assert (download == event->value.download.dc); |
282 | GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); | 283 | GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL); |
283 | download = NULL; | 284 | download = NULL; |
284 | break; | 285 | break; |
285 | 286 | ||
286 | default: | 287 | default: |
287 | printf("Unexpected event: %d\n", event->status); | 288 | printf ("Unexpected event: %d\n", event->status); |
288 | break; | 289 | break; |
289 | } | 290 | } |
290 | return NULL; | 291 | return NULL; |
291 | } | 292 | } |
292 | 293 | ||
293 | 294 | ||
294 | static void | 295 | static void |
295 | run(void *cls, | 296 | run (void *cls, |
296 | const struct GNUNET_CONFIGURATION_Handle *c, | 297 | const struct GNUNET_CONFIGURATION_Handle *c, |
297 | struct GNUNET_TESTING_Peer *peer) | 298 | struct GNUNET_TESTING_Peer *peer) |
298 | { | 299 | { |
299 | const char *keywords[] = { | 300 | const char *keywords[] = { |
300 | "down_foo", | 301 | "down_foo", |
@@ -308,40 +309,40 @@ run(void *cls, | |||
308 | struct GNUNET_FS_BlockOptions bo; | 309 | struct GNUNET_FS_BlockOptions bo; |
309 | 310 | ||
310 | cfg = c; | 311 | cfg = c; |
311 | fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, | 312 | fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL, |
312 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); | 313 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); |
313 | GNUNET_assert(NULL != fs); | 314 | GNUNET_assert (NULL != fs); |
314 | buf = GNUNET_malloc(FILESIZE); | 315 | buf = GNUNET_malloc (FILESIZE); |
315 | for (i = 0; i < FILESIZE; i++) | 316 | for (i = 0; i < FILESIZE; i++) |
316 | buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256); | 317 | buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256); |
317 | meta = GNUNET_CONTAINER_meta_data_create(); | 318 | meta = GNUNET_CONTAINER_meta_data_create (); |
318 | kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords); | 319 | kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords); |
319 | bo.content_priority = 42; | 320 | bo.content_priority = 42; |
320 | bo.anonymity_level = 1; | 321 | bo.anonymity_level = 1; |
321 | bo.replication_level = 0; | 322 | bo.replication_level = 0; |
322 | bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME); | 323 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME); |
323 | fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context", | 324 | fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context", |
324 | FILESIZE, buf, kuri, meta, | 325 | FILESIZE, buf, kuri, meta, |
325 | GNUNET_NO, &bo); | 326 | GNUNET_NO, &bo); |
326 | GNUNET_FS_uri_destroy(kuri); | 327 | GNUNET_FS_uri_destroy (kuri); |
327 | GNUNET_CONTAINER_meta_data_destroy(meta); | 328 | GNUNET_CONTAINER_meta_data_destroy (meta); |
328 | GNUNET_assert(NULL != fi); | 329 | GNUNET_assert (NULL != fi); |
329 | timeout_kill = | 330 | timeout_kill = |
330 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_kill_task, NULL); | 331 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL); |
331 | start = GNUNET_TIME_absolute_get(); | 332 | start = GNUNET_TIME_absolute_get (); |
332 | publish = | 333 | publish = |
333 | GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL, | 334 | GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL, |
334 | GNUNET_FS_PUBLISH_OPTION_NONE); | 335 | GNUNET_FS_PUBLISH_OPTION_NONE); |
335 | GNUNET_assert(publish != NULL); | 336 | GNUNET_assert (publish != NULL); |
336 | } | 337 | } |
337 | 338 | ||
338 | 339 | ||
339 | int | 340 | int |
340 | main(int argc, char *argv[]) | 341 | main (int argc, char *argv[]) |
341 | { | 342 | { |
342 | if (0 != GNUNET_TESTING_peer_run("test-fs-download-persistence", | 343 | if (0 != GNUNET_TESTING_peer_run ("test-fs-download-persistence", |
343 | "test_fs_download_data.conf", | 344 | "test_fs_download_data.conf", |
344 | &run, NULL)) | 345 | &run, NULL)) |
345 | return 1; | 346 | return 1; |
346 | return err; | 347 | return err; |
347 | } | 348 | } |