diff options
Diffstat (limited to 'src/fs/test_fs_download_persistence.c')
-rw-r--r-- | src/fs/test_fs_download_persistence.c | 375 |
1 files changed, 196 insertions, 179 deletions
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c index 97c2a338c..78dbe821e 100644 --- a/src/fs/test_fs_download_persistence.c +++ b/src/fs/test_fs_download_persistence.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file fs/test_fs_download_persistence.c | 22 | * @file 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; |
@@ -62,66 +62,66 @@ 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, GNUNET_NO)); |
105 | GNUNET_assert (size == FILESIZE); | 105 | GNUNET_assert(size == FILESIZE); |
106 | GNUNET_DISK_directory_remove (fn); | 106 | GNUNET_DISK_directory_remove(fn); |
107 | GNUNET_free (fn); | 107 | GNUNET_free(fn); |
108 | fn = NULL; | 108 | fn = NULL; |
109 | GNUNET_SCHEDULER_cancel (timeout_kill); | 109 | GNUNET_SCHEDULER_cancel(timeout_kill); |
110 | timeout_kill = NULL; | 110 | timeout_kill = NULL; |
111 | } | 111 | } |
112 | 112 | ||
113 | 113 | ||
114 | static void * | 114 | static void * |
115 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event); | 115 | progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event); |
116 | 116 | ||
117 | 117 | ||
118 | static void | 118 | static void |
119 | restart_fs_task (void *cls) | 119 | restart_fs_task(void *cls) |
120 | { | 120 | { |
121 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n"); | 121 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n"); |
122 | GNUNET_FS_stop (fs); | 122 | GNUNET_FS_stop(fs); |
123 | fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL, | 123 | fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, |
124 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); | 124 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); |
125 | } | 125 | } |
126 | 126 | ||
127 | 127 | ||
@@ -133,7 +133,7 @@ restart_fs_task (void *cls) | |||
133 | * @param ev type of the event to consider | 133 | * @param ev type of the event to consider |
134 | */ | 134 | */ |
135 | static void | 135 | static void |
136 | consider_restart (int ev) | 136 | consider_restart(int ev) |
137 | { | 137 | { |
138 | static int prev[32]; | 138 | static int prev[32]; |
139 | static int off; | 139 | static int off; |
@@ -143,141 +143,158 @@ consider_restart (int ev) | |||
143 | if (prev[i] == ev) | 143 | if (prev[i] == ev) |
144 | return; | 144 | return; |
145 | prev[off++] = ev; | 145 | prev[off++] = ev; |
146 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT, | 146 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT, |
147 | &restart_fs_task, NULL); | 147 | &restart_fs_task, NULL); |
148 | } | 148 | } |
149 | 149 | ||
150 | 150 | ||
151 | static void * | 151 | static void * |
152 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) | 152 | progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) |
153 | { | 153 | { |
154 | switch (event->status) | 154 | switch (event->status) |
155 | { | 155 | { |
156 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: | 156 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: |
157 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 157 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
158 | "Publish is progressing (%llu/%llu at level %u off %llu)...\n", | 158 | "Publish is progressing (%llu/%llu at level %u off %llu)...\n", |
159 | (unsigned long long) event->value.publish.completed, | 159 | (unsigned long long)event->value.publish.completed, |
160 | (unsigned long long) event->value.publish.size, | 160 | (unsigned long long)event->value.publish.size, |
161 | event->value.publish.specifics.progress.depth, | 161 | event->value.publish.specifics.progress.depth, |
162 | (unsigned long long) event->value.publish.specifics. | 162 | (unsigned long long)event->value.publish.specifics. |
163 | progress.offset); | 163 | progress.offset); |
164 | break; | 164 | break; |
165 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: | 165 | |
166 | break; | 166 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: |
167 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: | 167 | break; |
168 | printf ("Publishing complete, %llu kbps.\n", | 168 | |
169 | (unsigned long long) (FILESIZE * 1000000LL / | 169 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: |
170 | printf("Publishing complete, %llu kbps.\n", | ||
171 | (unsigned long long)(FILESIZE * 1000000LL / | ||
170 | (1 + | 172 | (1 + |
171 | GNUNET_TIME_absolute_get_duration | 173 | GNUNET_TIME_absolute_get_duration |
172 | (start).rel_value_us) / 1024LL)); | 174 | (start).rel_value_us) / 1024LL)); |
173 | fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst"); | 175 | fn = GNUNET_DISK_mktemp("gnunet-download-test-dst"); |
174 | start = GNUNET_TIME_absolute_get (); | 176 | start = GNUNET_TIME_absolute_get(); |
175 | GNUNET_assert (download == NULL); | 177 | GNUNET_assert(download == NULL); |
176 | GNUNET_FS_download_start (fs, | 178 | GNUNET_FS_download_start(fs, |
177 | event->value.publish.specifics.completed.chk_uri, | 179 | event->value.publish.specifics.completed.chk_uri, |
178 | NULL, fn, NULL, 0, FILESIZE, 1, | 180 | NULL, fn, NULL, 0, FILESIZE, 1, |
179 | GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL); | 181 | GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL); |
180 | break; | 182 | break; |
181 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | 183 | |
182 | printf ("Download complete, %llu kbps.\n", | 184 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: |
183 | (unsigned long long) (FILESIZE * 1000000LL / | 185 | printf("Download complete, %llu kbps.\n", |
186 | (unsigned long long)(FILESIZE * 1000000LL / | ||
184 | (1 + | 187 | (1 + |
185 | GNUNET_TIME_absolute_get_duration | 188 | GNUNET_TIME_absolute_get_duration |
186 | (start).rel_value_us) / 1024LL)); | 189 | (start).rel_value_us) / 1024LL)); |
187 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); | 190 | GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); |
188 | break; | 191 | break; |
189 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: | 192 | |
190 | consider_restart (event->status); | 193 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: |
191 | GNUNET_assert (download == event->value.download.dc); | 194 | consider_restart(event->status); |
192 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 195 | GNUNET_assert(download == event->value.download.dc); |
193 | "Download is progressing (%llu/%llu at level %u off %llu)...\n", | 196 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
194 | (unsigned long long) event->value.download.completed, | 197 | "Download is progressing (%llu/%llu at level %u off %llu)...\n", |
195 | (unsigned long long) event->value.download.size, | 198 | (unsigned long long)event->value.download.completed, |
196 | event->value.download.specifics.progress.depth, | 199 | (unsigned long long)event->value.download.size, |
197 | (unsigned long long) event->value.download.specifics. | 200 | event->value.download.specifics.progress.depth, |
198 | progress.offset); | 201 | (unsigned long long)event->value.download.specifics. |
199 | break; | 202 | progress.offset); |
200 | case GNUNET_FS_STATUS_PUBLISH_ERROR: | 203 | break; |
201 | fprintf (stderr, "Error publishing file: %s\n", | 204 | |
202 | event->value.publish.specifics.error.message); | 205 | case GNUNET_FS_STATUS_PUBLISH_ERROR: |
203 | GNUNET_break (0); | 206 | fprintf(stderr, "Error publishing file: %s\n", |
204 | GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL); | 207 | event->value.publish.specifics.error.message); |
205 | break; | 208 | GNUNET_break(0); |
206 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: | 209 | GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); |
207 | fprintf (stderr, "Error downloading file: %s\n", | 210 | break; |
208 | event->value.download.specifics.error.message); | 211 | |
209 | GNUNET_SCHEDULER_add_now (&abort_download_task, NULL); | 212 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: |
210 | break; | 213 | fprintf(stderr, "Error downloading file: %s\n", |
211 | case GNUNET_FS_STATUS_PUBLISH_SUSPEND: | 214 | event->value.download.specifics.error.message); |
212 | GNUNET_assert (event->value.publish.pc == publish); | 215 | GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); |
213 | publish = NULL; | 216 | break; |
214 | break; | 217 | |
215 | case GNUNET_FS_STATUS_PUBLISH_RESUME: | 218 | case GNUNET_FS_STATUS_PUBLISH_SUSPEND: |
216 | GNUNET_assert (NULL == publish); | 219 | GNUNET_assert(event->value.publish.pc == publish); |
217 | publish = event->value.publish.pc; | 220 | publish = NULL; |
218 | break; | 221 | break; |
219 | case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: | 222 | |
220 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n"); | 223 | case GNUNET_FS_STATUS_PUBLISH_RESUME: |
221 | GNUNET_assert (event->value.download.dc == download); | 224 | GNUNET_assert(NULL == publish); |
222 | download = NULL; | 225 | publish = event->value.publish.pc; |
223 | break; | 226 | break; |
224 | case GNUNET_FS_STATUS_DOWNLOAD_RESUME: | 227 | |
225 | GNUNET_assert (NULL == download); | 228 | case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: |
226 | download = event->value.download.dc; | 229 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n"); |
227 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n"); | 230 | GNUNET_assert(event->value.download.dc == download); |
228 | break; | 231 | download = NULL; |
229 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | 232 | break; |
230 | consider_restart (event->status); | 233 | |
231 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download active.\n"); | 234 | case GNUNET_FS_STATUS_DOWNLOAD_RESUME: |
232 | break; | 235 | GNUNET_assert(NULL == download); |
233 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | 236 | download = event->value.download.dc; |
234 | consider_restart (event->status); | 237 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n"); |
235 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n"); | 238 | break; |
236 | break; | 239 | |
237 | case GNUNET_FS_STATUS_PUBLISH_START: | 240 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: |
238 | GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx)); | 241 | consider_restart(event->status); |
239 | GNUNET_assert (NULL == event->value.publish.pctx); | 242 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download active.\n"); |
240 | GNUNET_assert (FILESIZE == event->value.publish.size); | 243 | break; |
241 | GNUNET_assert (0 == event->value.publish.completed); | 244 | |
242 | GNUNET_assert (1 == event->value.publish.anonymity); | 245 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: |
243 | break; | 246 | consider_restart(event->status); |
244 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: | 247 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n"); |
245 | GNUNET_assert (publish == event->value.publish.pc); | 248 | break; |
246 | GNUNET_assert (FILESIZE == event->value.publish.size); | 249 | |
247 | GNUNET_assert (1 == event->value.publish.anonymity); | 250 | case GNUNET_FS_STATUS_PUBLISH_START: |
248 | GNUNET_FS_stop (fs); | 251 | GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx)); |
249 | fs = NULL; | 252 | GNUNET_assert(NULL == event->value.publish.pctx); |
250 | break; | 253 | GNUNET_assert(FILESIZE == event->value.publish.size); |
251 | case GNUNET_FS_STATUS_DOWNLOAD_START: | 254 | GNUNET_assert(0 == event->value.publish.completed); |
252 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download started.\n"); | 255 | GNUNET_assert(1 == event->value.publish.anonymity); |
253 | consider_restart (event->status); | 256 | break; |
254 | GNUNET_assert (download == NULL); | 257 | |
255 | download = event->value.download.dc; | 258 | case GNUNET_FS_STATUS_PUBLISH_STOPPED: |
256 | GNUNET_assert (0 == strcmp ("download", event->value.download.cctx)); | 259 | GNUNET_assert(publish == event->value.publish.pc); |
257 | GNUNET_assert (NULL == event->value.download.pctx); | 260 | GNUNET_assert(FILESIZE == event->value.publish.size); |
258 | GNUNET_assert (NULL != event->value.download.uri); | 261 | GNUNET_assert(1 == event->value.publish.anonymity); |
259 | GNUNET_assert (0 == strcmp (fn, event->value.download.filename)); | 262 | GNUNET_FS_stop(fs); |
260 | GNUNET_assert (FILESIZE == event->value.download.size); | 263 | fs = NULL; |
261 | GNUNET_assert (0 == event->value.download.completed); | 264 | break; |
262 | GNUNET_assert (1 == event->value.download.anonymity); | 265 | |
263 | break; | 266 | case GNUNET_FS_STATUS_DOWNLOAD_START: |
264 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | 267 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download started.\n"); |
265 | GNUNET_assert (download == event->value.download.dc); | 268 | consider_restart(event->status); |
266 | GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL); | 269 | GNUNET_assert(download == NULL); |
267 | download = NULL; | 270 | download = event->value.download.dc; |
268 | break; | 271 | GNUNET_assert(0 == strcmp("download", event->value.download.cctx)); |
269 | default: | 272 | GNUNET_assert(NULL == event->value.download.pctx); |
270 | printf ("Unexpected event: %d\n", event->status); | 273 | GNUNET_assert(NULL != event->value.download.uri); |
271 | break; | 274 | GNUNET_assert(0 == strcmp(fn, event->value.download.filename)); |
272 | } | 275 | GNUNET_assert(FILESIZE == event->value.download.size); |
276 | GNUNET_assert(0 == event->value.download.completed); | ||
277 | GNUNET_assert(1 == event->value.download.anonymity); | ||
278 | break; | ||
279 | |||
280 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | ||
281 | GNUNET_assert(download == event->value.download.dc); | ||
282 | GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); | ||
283 | download = NULL; | ||
284 | break; | ||
285 | |||
286 | default: | ||
287 | printf("Unexpected event: %d\n", event->status); | ||
288 | break; | ||
289 | } | ||
273 | return NULL; | 290 | return NULL; |
274 | } | 291 | } |
275 | 292 | ||
276 | 293 | ||
277 | static void | 294 | static void |
278 | run (void *cls, | 295 | run(void *cls, |
279 | const struct GNUNET_CONFIGURATION_Handle *c, | 296 | const struct GNUNET_CONFIGURATION_Handle *c, |
280 | struct GNUNET_TESTING_Peer *peer) | 297 | struct GNUNET_TESTING_Peer *peer) |
281 | { | 298 | { |
282 | const char *keywords[] = { | 299 | const char *keywords[] = { |
283 | "down_foo", | 300 | "down_foo", |
@@ -291,40 +308,40 @@ run (void *cls, | |||
291 | struct GNUNET_FS_BlockOptions bo; | 308 | struct GNUNET_FS_BlockOptions bo; |
292 | 309 | ||
293 | cfg = c; | 310 | cfg = c; |
294 | fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL, | 311 | fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, |
295 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); | 312 | GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); |
296 | GNUNET_assert (NULL != fs); | 313 | GNUNET_assert(NULL != fs); |
297 | buf = GNUNET_malloc (FILESIZE); | 314 | buf = GNUNET_malloc(FILESIZE); |
298 | for (i = 0; i < FILESIZE; i++) | 315 | for (i = 0; i < FILESIZE; i++) |
299 | buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256); | 316 | buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256); |
300 | meta = GNUNET_CONTAINER_meta_data_create (); | 317 | meta = GNUNET_CONTAINER_meta_data_create(); |
301 | kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords); | 318 | kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords); |
302 | bo.content_priority = 42; | 319 | bo.content_priority = 42; |
303 | bo.anonymity_level = 1; | 320 | bo.anonymity_level = 1; |
304 | bo.replication_level = 0; | 321 | bo.replication_level = 0; |
305 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME); | 322 | bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME); |
306 | fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context", | 323 | fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context", |
307 | FILESIZE, buf, kuri, meta, | 324 | FILESIZE, buf, kuri, meta, |
308 | GNUNET_NO, &bo); | 325 | GNUNET_NO, &bo); |
309 | GNUNET_FS_uri_destroy (kuri); | 326 | GNUNET_FS_uri_destroy(kuri); |
310 | GNUNET_CONTAINER_meta_data_destroy (meta); | 327 | GNUNET_CONTAINER_meta_data_destroy(meta); |
311 | GNUNET_assert (NULL != fi); | 328 | GNUNET_assert(NULL != fi); |
312 | timeout_kill = | 329 | timeout_kill = |
313 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL); | 330 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_kill_task, NULL); |
314 | start = GNUNET_TIME_absolute_get (); | 331 | start = GNUNET_TIME_absolute_get(); |
315 | publish = | 332 | publish = |
316 | GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL, | 333 | GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL, |
317 | GNUNET_FS_PUBLISH_OPTION_NONE); | 334 | GNUNET_FS_PUBLISH_OPTION_NONE); |
318 | GNUNET_assert (publish != NULL); | 335 | GNUNET_assert(publish != NULL); |
319 | } | 336 | } |
320 | 337 | ||
321 | 338 | ||
322 | int | 339 | int |
323 | main (int argc, char *argv[]) | 340 | main(int argc, char *argv[]) |
324 | { | 341 | { |
325 | if (0 != GNUNET_TESTING_peer_run ("test-fs-download-persistence", | 342 | if (0 != GNUNET_TESTING_peer_run("test-fs-download-persistence", |
326 | "test_fs_download_data.conf", | 343 | "test_fs_download_data.conf", |
327 | &run, NULL)) | 344 | &run, NULL)) |
328 | return 1; | 345 | return 1; |
329 | return err; | 346 | return err; |
330 | } | 347 | } |