summaryrefslogtreecommitdiff
path: root/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/namestore/test_namestore_api_zone_iteration_specific_zone.c')
-rw-r--r--src/namestore/test_namestore_api_zone_iteration_specific_zone.c546
1 files changed, 273 insertions, 273 deletions
diff --git a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
index e3c6d698a..924e1eb1e 100644
--- a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
+++ b/src/namestore/test_namestore_api_zone_iteration_specific_zone.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 * @file namestore/test_namestore_api_zone_iteration_specific_zone.c 21 * @file namestore/test_namestore_api_zone_iteration_specific_zone.c
22 * @brief testcase for zone iteration functionality: iterate over a specific zone 22 * @brief testcase for zone iteration functionality: iterate over a specific zone
@@ -31,7 +31,7 @@
31#define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT 31#define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
32 32
33 33
34#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100) 34#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
35 35
36 36
37static struct GNUNET_NAMESTORE_Handle * nsh; 37static struct GNUNET_NAMESTORE_Handle * nsh;
@@ -67,246 +67,246 @@ static struct GNUNET_GNSRECORD_Data *s_rd_3;
67 * @param cls handle to use to re-connect. 67 * @param cls handle to use to re-connect.
68 */ 68 */
69static void 69static void
70endbadly (void *cls) 70endbadly(void *cls)
71{ 71{
72 endbadly_task = NULL; 72 endbadly_task = NULL;
73 GNUNET_SCHEDULER_shutdown (); 73 GNUNET_SCHEDULER_shutdown();
74 res = 1; 74 res = 1;
75} 75}
76 76
77 77
78static void 78static void
79end (void *cls) 79end(void *cls)
80{ 80{
81 if (NULL != zi) 81 if (NULL != zi)
82 { 82 {
83 GNUNET_NAMESTORE_zone_iteration_stop (zi); 83 GNUNET_NAMESTORE_zone_iteration_stop(zi);
84 zi = NULL; 84 zi = NULL;
85 } 85 }
86 if (NULL != endbadly_task) 86 if (NULL != endbadly_task)
87 { 87 {
88 GNUNET_SCHEDULER_cancel (endbadly_task); 88 GNUNET_SCHEDULER_cancel(endbadly_task);
89 endbadly_task = NULL; 89 endbadly_task = NULL;
90 } 90 }
91 if (NULL != privkey) 91 if (NULL != privkey)
92 { 92 {
93 GNUNET_free (privkey); 93 GNUNET_free(privkey);
94 privkey = NULL; 94 privkey = NULL;
95 } 95 }
96 if (NULL != privkey2) 96 if (NULL != privkey2)
97 { 97 {
98 GNUNET_free (privkey2); 98 GNUNET_free(privkey2);
99 privkey2 = NULL; 99 privkey2 = NULL;
100 } 100 }
101 GNUNET_free_non_null (s_name_1); 101 GNUNET_free_non_null(s_name_1);
102 GNUNET_free_non_null (s_name_2); 102 GNUNET_free_non_null(s_name_2);
103 GNUNET_free_non_null (s_name_3); 103 GNUNET_free_non_null(s_name_3);
104 if (s_rd_1 != NULL) 104 if (s_rd_1 != NULL)
105 { 105 {
106 GNUNET_free ((void *)s_rd_1->data); 106 GNUNET_free((void *)s_rd_1->data);
107 GNUNET_free (s_rd_1); 107 GNUNET_free(s_rd_1);
108 } 108 }
109 if (s_rd_2 != NULL) 109 if (s_rd_2 != NULL)
110 { 110 {
111 GNUNET_free ((void *)s_rd_2->data); 111 GNUNET_free((void *)s_rd_2->data);
112 GNUNET_free (s_rd_2); 112 GNUNET_free(s_rd_2);
113 } 113 }
114 if (s_rd_3 != NULL) 114 if (s_rd_3 != NULL)
115 { 115 {
116 GNUNET_free ((void *)s_rd_3->data); 116 GNUNET_free((void *)s_rd_3->data);
117 GNUNET_free (s_rd_3); 117 GNUNET_free(s_rd_3);
118 } 118 }
119 if (nsh != NULL) 119 if (nsh != NULL)
120 { 120 {
121 GNUNET_NAMESTORE_disconnect (nsh); 121 GNUNET_NAMESTORE_disconnect(nsh);
122 nsh = NULL; 122 nsh = NULL;
123 } 123 }
124} 124}
125 125
126 126
127static void 127static void
128fail_cb (void *cls) 128fail_cb(void *cls)
129{ 129{
130 GNUNET_assert (0); 130 GNUNET_assert(0);
131 zi = NULL; 131 zi = NULL;
132} 132}
133 133
134 134
135static void 135static void
136zone_proc (void *cls, 136zone_proc(void *cls,
137 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, 137 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
138 const char *label, 138 const char *label,
139 unsigned int rd_count, 139 unsigned int rd_count,
140 const struct GNUNET_GNSRECORD_Data *rd) 140 const struct GNUNET_GNSRECORD_Data *rd)
141{ 141{
142 int failed = GNUNET_NO; 142 int failed = GNUNET_NO;
143 143
144 GNUNET_assert (NULL != zone); 144 GNUNET_assert(NULL != zone);
145 if (0 == GNUNET_memcmp (zone, 145 if (0 == GNUNET_memcmp(zone,
146 privkey)) 146 privkey))
147 {
148 if (0 == strcmp (label, s_name_1))
149 { 147 {
150 if (rd_count == 1) 148 if (0 == strcmp(label, s_name_1))
151 {
152 if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp (rd, s_rd_1))
153 { 149 {
154 failed = GNUNET_YES; 150 if (rd_count == 1)
155 GNUNET_break (0); 151 {
152 if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
153 {
154 failed = GNUNET_YES;
155 GNUNET_break(0);
156 }
157 }
158 else
159 {
160 failed = GNUNET_YES;
161 GNUNET_break(0);
162 }
163 }
164 else if (0 == strcmp(label, s_name_2))
165 {
166 if (rd_count == 1)
167 {
168 if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
169 {
170 failed = GNUNET_YES;
171 GNUNET_break(0);
172 }
173 }
174 else
175 {
176 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
177 "Received invalid record count\n");
178 failed = GNUNET_YES;
179 GNUNET_break(0);
180 }
156 } 181 }
157 }
158 else 182 else
159 {
160 failed = GNUNET_YES;
161 GNUNET_break (0);
162 }
163 }
164 else if (0 == strcmp (label, s_name_2))
165 {
166 if (rd_count == 1)
167 {
168 if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
169 { 183 {
184 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
185 "Comparing result failed: got name `%s' for first zone\n",
186 label);
170 failed = GNUNET_YES; 187 failed = GNUNET_YES;
171 GNUNET_break (0); 188 GNUNET_break(0);
172 } 189 }
173 }
174 else
175 {
176 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
177 "Received invalid record count\n");
178 failed = GNUNET_YES;
179 GNUNET_break (0);
180 }
181 } 190 }
182 else 191 else if (0 == GNUNET_memcmp(zone, privkey2))
183 { 192 {
184 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 193 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
185 "Comparing result failed: got name `%s' for first zone\n", 194 "Received data for not requested zone\n");
186 label);
187 failed = GNUNET_YES; 195 failed = GNUNET_YES;
188 GNUNET_break (0); 196 GNUNET_break(0);
189 } 197 }
190 }
191 else if (0 == GNUNET_memcmp (zone, privkey2))
192 {
193 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
194 "Received data for not requested zone\n");
195 failed = GNUNET_YES;
196 GNUNET_break (0);
197 }
198 else 198 else
199 { 199 {
200 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 200 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
201 "Received invalid zone\n"); 201 "Received invalid zone\n");
202 failed = GNUNET_YES; 202 failed = GNUNET_YES;
203 GNUNET_break (0); 203 GNUNET_break(0);
204 } 204 }
205 if (failed == GNUNET_NO) 205 if (failed == GNUNET_NO)
206 { 206 {
207 returned_records ++; 207 returned_records++;
208 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 208 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
209 "Telling namestore to send the next result\n"); 209 "Telling namestore to send the next result\n");
210 GNUNET_NAMESTORE_zone_iterator_next (zi, 210 GNUNET_NAMESTORE_zone_iterator_next(zi,
211 1); 211 1);
212 } 212 }
213 else 213 else
214 { 214 {
215 GNUNET_break (0); 215 GNUNET_break(0);
216 res = 2; 216 res = 2;
217 GNUNET_SCHEDULER_shutdown (); 217 GNUNET_SCHEDULER_shutdown();
218 } 218 }
219} 219}
220 220
221 221
222static void 222static void
223zone_proc_end (void *cls) 223zone_proc_end(void *cls)
224{ 224{
225 zi = NULL; 225 zi = NULL;
226 GNUNET_break (2 == returned_records); 226 GNUNET_break(2 == returned_records);
227 if (2 == returned_records) 227 if (2 == returned_records)
228 { 228 {
229 res = 0; /* Last iteraterator callback, we are done */ 229 res = 0; /* Last iteraterator callback, we are done */
230 } 230 }
231 else 231 else
232 { 232 {
233 res = 1; 233 res = 1;
234 } 234 }
235 235
236 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 236 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
237 "Received last result, iteration done after receing %u results\n", 237 "Received last result, iteration done after receing %u results\n",
238 returned_records); 238 returned_records);
239 GNUNET_SCHEDULER_shutdown (); 239 GNUNET_SCHEDULER_shutdown();
240} 240}
241 241
242 242
243static void 243static void
244put_cont (void *cls, 244put_cont(void *cls,
245 int32_t success, 245 int32_t success,
246 const char *emsg) 246 const char *emsg)
247{ 247{
248 static int c = 0; 248 static int c = 0;
249 249
250 if (success == GNUNET_OK) 250 if (success == GNUNET_OK)
251 { 251 {
252 c++; 252 c++;
253 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 253 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
254 "Created record %u \n", c); 254 "Created record %u \n", c);
255 } 255 }
256 else 256 else
257 {
258 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
259 "Failed to created records: `%s'\n",
260 emsg);
261 GNUNET_break (0);
262 res = 2;
263 GNUNET_SCHEDULER_shutdown ();
264 return;
265 }
266
267 if (c == 3)
268 {
269 res = 1;
270 returned_records = 0;
271 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
272 "All records created, starting iteration over all zones \n");
273 zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
274 privkey,
275 &fail_cb,
276 NULL,
277 &zone_proc,
278 NULL,
279 &zone_proc_end,
280 NULL);
281 if (zi == NULL)
282 { 257 {
283 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 258 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
284 "Failed to create zone iterator\n"); 259 "Failed to created records: `%s'\n",
285 GNUNET_break (0); 260 emsg);
261 GNUNET_break(0);
286 res = 2; 262 res = 2;
287 GNUNET_SCHEDULER_shutdown (); 263 GNUNET_SCHEDULER_shutdown();
288 return; 264 return;
289 } 265 }
290 } 266
267 if (c == 3)
268 {
269 res = 1;
270 returned_records = 0;
271 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
272 "All records created, starting iteration over all zones \n");
273 zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
274 privkey,
275 &fail_cb,
276 NULL,
277 &zone_proc,
278 NULL,
279 &zone_proc_end,
280 NULL);
281 if (zi == NULL)
282 {
283 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
284 "Failed to create zone iterator\n");
285 GNUNET_break(0);
286 res = 2;
287 GNUNET_SCHEDULER_shutdown();
288 return;
289 }
290 }
291} 291}
292 292
293 293
294static struct GNUNET_GNSRECORD_Data * 294static struct GNUNET_GNSRECORD_Data *
295create_record (unsigned int count) 295create_record(unsigned int count)
296{ 296{
297 struct GNUNET_GNSRECORD_Data *rd; 297 struct GNUNET_GNSRECORD_Data *rd;
298 298
299 rd = GNUNET_new_array (count, 299 rd = GNUNET_new_array(count,
300 struct GNUNET_GNSRECORD_Data); 300 struct GNUNET_GNSRECORD_Data);
301 for (unsigned int c = 0; c < count; c++) 301 for (unsigned int c = 0; c < count; c++)
302 { 302 {
303 rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value_us; 303 rd[c].expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS).abs_value_us;
304 rd[c].record_type = TEST_RECORD_TYPE; 304 rd[c].record_type = TEST_RECORD_TYPE;
305 rd[c].data_size = 50; 305 rd[c].data_size = 50;
306 rd[c].data = GNUNET_malloc(50); 306 rd[c].data = GNUNET_malloc(50);
307 rd[c].flags = 0; 307 rd[c].flags = 0;
308 memset ((char *) rd[c].data, 'a', 50); 308 memset((char *)rd[c].data, 'a', 50);
309 } 309 }
310 return rd; 310 return rd;
311} 311}
312 312
@@ -317,114 +317,114 @@ create_record (unsigned int count)
317 * start the actual tests by filling the zone. 317 * start the actual tests by filling the zone.
318 */ 318 */
319static void 319static void
320empty_zone_proc (void *cls, 320empty_zone_proc(void *cls,
321 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, 321 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
322 const char *label, 322 const char *label,
323 unsigned int rd_count, 323 unsigned int rd_count,
324 const struct GNUNET_GNSRECORD_Data *rd) 324 const struct GNUNET_GNSRECORD_Data *rd)
325{ 325{
326 GNUNET_assert (nsh == cls); 326 GNUNET_assert(nsh == cls);
327 if (NULL != zone) 327 if (NULL != zone)
328 { 328 {
329 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 329 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
330 _("Expected empty zone but received zone private key\n")); 330 _("Expected empty zone but received zone private key\n"));
331 GNUNET_break (0); 331 GNUNET_break(0);
332 res = 2; 332 res = 2;
333 GNUNET_SCHEDULER_shutdown (); 333 GNUNET_SCHEDULER_shutdown();
334 return; 334 return;
335 } 335 }
336 if ((NULL != label) || (NULL != rd) || (0 != rd_count)) 336 if ((NULL != label) || (NULL != rd) || (0 != rd_count))
337 { 337 {
338 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 338 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
339 _("Expected no zone content but received data\n")); 339 _("Expected no zone content but received data\n"));
340 GNUNET_break (0); 340 GNUNET_break(0);
341 res = 2; 341 res = 2;
342 GNUNET_SCHEDULER_shutdown (); 342 GNUNET_SCHEDULER_shutdown();
343 return; 343 return;
344 } 344 }
345 GNUNET_assert (0); 345 GNUNET_assert(0);
346} 346}
347 347
348 348
349static void 349static void
350empty_zone_proc_end (void *cls) 350empty_zone_proc_end(void *cls)
351{ 351{
352 zi = NULL; 352 zi = NULL;
353 privkey = GNUNET_CRYPTO_ecdsa_key_create (); 353 privkey = GNUNET_CRYPTO_ecdsa_key_create();
354 GNUNET_assert (privkey != NULL); 354 GNUNET_assert(privkey != NULL);
355 privkey2 = GNUNET_CRYPTO_ecdsa_key_create (); 355 privkey2 = GNUNET_CRYPTO_ecdsa_key_create();
356 GNUNET_assert (privkey2 != NULL); 356 GNUNET_assert(privkey2 != NULL);
357 357
358 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 358 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
359 "Created record 1\n"); 359 "Created record 1\n");
360 GNUNET_asprintf (&s_name_1, 360 GNUNET_asprintf(&s_name_1,
361 "dummy1"); 361 "dummy1");
362 s_rd_1 = create_record (1); 362 s_rd_1 = create_record(1);
363 GNUNET_NAMESTORE_records_store (nsh, 363 GNUNET_NAMESTORE_records_store(nsh,
364 privkey, 364 privkey,
365 s_name_1, 365 s_name_1,
366 1, 366 1,
367 s_rd_1, 367 s_rd_1,
368 &put_cont, 368 &put_cont,
369 NULL); 369 NULL);
370 370
371 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 371 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
372 "Created record 2 \n"); 372 "Created record 2 \n");
373 GNUNET_asprintf (&s_name_2, 373 GNUNET_asprintf(&s_name_2,
374 "dummy2"); 374 "dummy2");
375 s_rd_2 = create_record (1); 375 s_rd_2 = create_record(1);
376 GNUNET_NAMESTORE_records_store (nsh, 376 GNUNET_NAMESTORE_records_store(nsh,
377 privkey, 377 privkey,
378 s_name_2, 378 s_name_2,
379 1, 379 1,
380 s_rd_2, 380 s_rd_2,
381 &put_cont, 381 &put_cont,
382 NULL); 382 NULL);
383 383
384 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 384 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
385 "Created record 3\n"); 385 "Created record 3\n");
386 386
387 /* name in different zone */ 387 /* name in different zone */
388 GNUNET_asprintf (&s_name_3, 388 GNUNET_asprintf(&s_name_3,
389 "dummy3"); 389 "dummy3");
390 s_rd_3 = create_record (1); 390 s_rd_3 = create_record(1);
391 GNUNET_NAMESTORE_records_store (nsh, 391 GNUNET_NAMESTORE_records_store(nsh,
392 privkey2, 392 privkey2,
393 s_name_3, 393 s_name_3,
394 1, s_rd_3, 394 1, s_rd_3,
395 &put_cont, 395 &put_cont,
396 NULL); 396 NULL);
397} 397}
398 398
399 399
400static void 400static void
401run (void *cls, 401run(void *cls,
402 const struct GNUNET_CONFIGURATION_Handle *cfg, 402 const struct GNUNET_CONFIGURATION_Handle *cfg,
403 struct GNUNET_TESTING_Peer *peer) 403 struct GNUNET_TESTING_Peer *peer)
404{ 404{
405 GNUNET_SCHEDULER_add_shutdown (&end, 405 GNUNET_SCHEDULER_add_shutdown(&end,
406 NULL); 406 NULL);
407 endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 407 endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
408 &endbadly, 408 &endbadly,
409 NULL); 409 NULL);
410 nsh = GNUNET_NAMESTORE_connect (cfg); 410 nsh = GNUNET_NAMESTORE_connect(cfg);
411 GNUNET_break (NULL != nsh); 411 GNUNET_break(NULL != nsh);
412 /* first, iterate over empty namestore */ 412 /* first, iterate over empty namestore */
413 zi = GNUNET_NAMESTORE_zone_iteration_start (nsh, 413 zi = GNUNET_NAMESTORE_zone_iteration_start(nsh,
414 NULL, 414 NULL,
415 &fail_cb, 415 &fail_cb,
416 NULL, 416 NULL,
417 &empty_zone_proc, 417 &empty_zone_proc,
418 nsh, 418 nsh,
419 &empty_zone_proc_end, 419 &empty_zone_proc_end,
420 nsh); 420 nsh);
421 if (NULL == zi) 421 if (NULL == zi)
422 { 422 {
423 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 423 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
424 "Failed to create zone iterator\n"); 424 "Failed to create zone iterator\n");
425 GNUNET_break (0); 425 GNUNET_break(0);
426 GNUNET_SCHEDULER_shutdown (); 426 GNUNET_SCHEDULER_shutdown();
427 } 427 }
428} 428}
429 429
430 430
@@ -432,24 +432,24 @@ run (void *cls,
432 432
433 433
434int 434int
435main (int argc, char *argv[]) 435main(int argc, char *argv[])
436{ 436{
437 const char *plugin_name; 437 const char *plugin_name;
438 char *cfg_name; 438 char *cfg_name;
439 439
440 SETUP_CFG (plugin_name, cfg_name); 440 SETUP_CFG(plugin_name, cfg_name);
441 res = 1; 441 res = 1;
442 if (0 != 442 if (0 !=
443 GNUNET_TESTING_peer_run ("test-namestore-api-zone-iteration-specific-zone", 443 GNUNET_TESTING_peer_run("test-namestore-api-zone-iteration-specific-zone",
444 cfg_name, 444 cfg_name,
445 &run, 445 &run,
446 NULL)) 446 NULL))
447 { 447 {
448 res = 1; 448 res = 1;
449 } 449 }
450 GNUNET_DISK_purge_cfg_dir (cfg_name, 450 GNUNET_DISK_purge_cfg_dir(cfg_name,
451 "GNUNET_TEST_HOME"); 451 "GNUNET_TEST_HOME");
452 GNUNET_free (cfg_name); 452 GNUNET_free(cfg_name);
453 return res; 453 return res;
454} 454}
455 455