diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/namestore/test_namestore_api_zone_iteration_stop.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/namestore/test_namestore_api_zone_iteration_stop.c')
-rw-r--r-- | src/namestore/test_namestore_api_zone_iteration_stop.c | 587 |
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 | ||
35 | static struct GNUNET_NAMESTORE_Handle * nsh; | 35 | static struct GNUNET_NAMESTORE_Handle *nsh; |
36 | 36 | ||
37 | static struct GNUNET_CRYPTO_EcdsaPrivateKey * privkey; | 37 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; |
38 | 38 | ||
39 | static struct GNUNET_CRYPTO_EcdsaPrivateKey * privkey2; | 39 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey2; |
40 | 40 | ||
41 | static struct GNUNET_NAMESTORE_ZoneIterator *zi; | 41 | static struct GNUNET_NAMESTORE_ZoneIterator *zi; |
42 | 42 | ||
@@ -44,15 +44,15 @@ static int res; | |||
44 | 44 | ||
45 | static int returned_records; | 45 | static int returned_records; |
46 | 46 | ||
47 | static char * s_name_1; | 47 | static char *s_name_1; |
48 | 48 | ||
49 | static struct GNUNET_GNSRECORD_Data *s_rd_1; | 49 | static struct GNUNET_GNSRECORD_Data *s_rd_1; |
50 | 50 | ||
51 | static char * s_name_2; | 51 | static char *s_name_2; |
52 | 52 | ||
53 | static struct GNUNET_GNSRECORD_Data *s_rd_2; | 53 | static struct GNUNET_GNSRECORD_Data *s_rd_2; |
54 | 54 | ||
55 | static char * s_name_3; | 55 | static char *s_name_3; |
56 | 56 | ||
57 | static struct GNUNET_GNSRECORD_Data *s_rd_3; | 57 | static 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 | */ |
65 | static void | 65 | static void |
66 | end(void *cls) | 66 | end (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 | ||
109 | static void | 109 | static void |
110 | delayed_end(void *cls) | 110 | delayed_end (void *cls) |
111 | { | 111 | { |
112 | GNUNET_SCHEDULER_shutdown(); | 112 | GNUNET_SCHEDULER_shutdown (); |
113 | } | 113 | } |
114 | 114 | ||
115 | 115 | ||
116 | static void | 116 | static void |
117 | fail_cb(void *cls) | 117 | fail_cb (void *cls) |
118 | { | 118 | { |
119 | GNUNET_assert(0); | 119 | GNUNET_assert (0); |
120 | } | 120 | } |
121 | 121 | ||
122 | 122 | ||
123 | static void | 123 | static void |
124 | zone_proc(void *cls, | 124 | zone_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 | ||
240 | static void | 242 | static void |
241 | zone_proc_end(void *cls) | 243 | zone_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 | ||
256 | static void | 258 | static void |
257 | put_cont(void *cls, int32_t success, const char *emsg) | 259 | put_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 | ||
301 | static struct GNUNET_GNSRECORD_Data * | 303 | static struct GNUNET_GNSRECORD_Data * |
302 | create_record(unsigned int count) | 304 | create_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 | */ |
326 | static void | 329 | static void |
327 | empty_zone_proc(void *cls, | 330 | empty_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 | ||
354 | static void | 357 | static void |
355 | empty_zone_proc_end(void *cls) | 358 | empty_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 | ||
419 | static void | 422 | static void |
420 | run(void *cls, | 423 | run (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 | ||
450 | int | 453 | int |
451 | main(int argc, char *argv[]) | 454 | main (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 | } |