diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/namestore/test_namestore_api_zone_iteration_specific_zone.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
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.c | 546 |
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 | ||
37 | static struct GNUNET_NAMESTORE_Handle * nsh; | 37 | static 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 | */ |
69 | static void | 69 | static void |
70 | endbadly (void *cls) | 70 | endbadly(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 | ||
78 | static void | 78 | static void |
79 | end (void *cls) | 79 | end(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 | ||
127 | static void | 127 | static void |
128 | fail_cb (void *cls) | 128 | fail_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 | ||
135 | static void | 135 | static void |
136 | zone_proc (void *cls, | 136 | zone_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 | ||
222 | static void | 222 | static void |
223 | zone_proc_end (void *cls) | 223 | zone_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 | ||
243 | static void | 243 | static void |
244 | put_cont (void *cls, | 244 | put_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 | ||
294 | static struct GNUNET_GNSRECORD_Data * | 294 | static struct GNUNET_GNSRECORD_Data * |
295 | create_record (unsigned int count) | 295 | create_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 | */ |
319 | static void | 319 | static void |
320 | empty_zone_proc (void *cls, | 320 | empty_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 | ||
349 | static void | 349 | static void |
350 | empty_zone_proc_end (void *cls) | 350 | empty_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 | ||
400 | static void | 400 | static void |
401 | run (void *cls, | 401 | run(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 | ||
434 | int | 434 | int |
435 | main (int argc, char *argv[]) | 435 | main(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 | ||