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