diff options
Diffstat (limited to 'src/namestore/test_namestore_api_lookup_shadow_filter.c')
-rw-r--r-- | src/namestore/test_namestore_api_lookup_shadow_filter.c | 383 |
1 files changed, 195 insertions, 188 deletions
diff --git a/src/namestore/test_namestore_api_lookup_shadow_filter.c b/src/namestore/test_namestore_api_lookup_shadow_filter.c index d8d6b8a29..694c189e1 100644 --- a/src/namestore/test_namestore_api_lookup_shadow_filter.c +++ b/src/namestore/test_namestore_api_lookup_shadow_filter.c | |||
@@ -37,16 +37,16 @@ | |||
37 | #define TEST_RECORD_DATA 'a' | 37 | #define TEST_RECORD_DATA 'a' |
38 | #define TEST_SHADOW_RECORD_DATA 'b' | 38 | #define TEST_SHADOW_RECORD_DATA 'b' |
39 | 39 | ||
40 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100) | 40 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100) |
41 | #define EXPIRATION GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 41 | #define EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
42 | 42 | ||
43 | static struct GNUNET_NAMESTORE_Handle *nsh; | 43 | static struct GNUNET_NAMESTORE_Handle *nsh; |
44 | 44 | ||
45 | static struct GNUNET_NAMECACHE_Handle *nch; | 45 | static struct GNUNET_NAMECACHE_Handle *nch; |
46 | 46 | ||
47 | static struct GNUNET_SCHEDULER_Task * endbadly_task; | 47 | static struct GNUNET_SCHEDULER_Task *endbadly_task; |
48 | 48 | ||
49 | static struct GNUNET_SCHEDULER_Task * delayed_lookup_task; | 49 | static struct GNUNET_SCHEDULER_Task *delayed_lookup_task; |
50 | 50 | ||
51 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; | 51 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; |
52 | 52 | ||
@@ -70,24 +70,24 @@ static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey; | |||
70 | 70 | ||
71 | 71 | ||
72 | static void | 72 | static void |
73 | cleanup() | 73 | cleanup () |
74 | { | 74 | { |
75 | if (NULL != nsh) | 75 | if (NULL != nsh) |
76 | { | 76 | { |
77 | GNUNET_NAMESTORE_disconnect(nsh); | 77 | GNUNET_NAMESTORE_disconnect (nsh); |
78 | nsh = NULL; | 78 | nsh = NULL; |
79 | } | 79 | } |
80 | if (NULL != nch) | 80 | if (NULL != nch) |
81 | { | 81 | { |
82 | GNUNET_NAMECACHE_disconnect(nch); | 82 | GNUNET_NAMECACHE_disconnect (nch); |
83 | nch = NULL; | 83 | nch = NULL; |
84 | } | 84 | } |
85 | if (NULL != privkey) | 85 | if (NULL != privkey) |
86 | { | 86 | { |
87 | GNUNET_free(privkey); | 87 | GNUNET_free (privkey); |
88 | privkey = NULL; | 88 | privkey = NULL; |
89 | } | 89 | } |
90 | GNUNET_SCHEDULER_shutdown(); | 90 | GNUNET_SCHEDULER_shutdown (); |
91 | } | 91 | } |
92 | 92 | ||
93 | 93 | ||
@@ -97,240 +97,247 @@ cleanup() | |||
97 | * @param cls handle to use to re-connect. | 97 | * @param cls handle to use to re-connect. |
98 | */ | 98 | */ |
99 | static void | 99 | static void |
100 | endbadly(void *cls) | 100 | endbadly (void *cls) |
101 | { | 101 | { |
102 | if (NULL != delayed_lookup_task) | 102 | if (NULL != delayed_lookup_task) |
103 | { | 103 | { |
104 | GNUNET_SCHEDULER_cancel(delayed_lookup_task); | 104 | GNUNET_SCHEDULER_cancel (delayed_lookup_task); |
105 | delayed_lookup_task = NULL; | 105 | delayed_lookup_task = NULL; |
106 | } | 106 | } |
107 | if (NULL != nsqe) | 107 | if (NULL != nsqe) |
108 | { | 108 | { |
109 | GNUNET_NAMESTORE_cancel(nsqe); | 109 | GNUNET_NAMESTORE_cancel (nsqe); |
110 | nsqe = NULL; | 110 | nsqe = NULL; |
111 | } | 111 | } |
112 | if (NULL != ncqe) | 112 | if (NULL != ncqe) |
113 | { | 113 | { |
114 | GNUNET_NAMECACHE_cancel(ncqe); | 114 | GNUNET_NAMECACHE_cancel (ncqe); |
115 | ncqe = NULL; | 115 | ncqe = NULL; |
116 | } | 116 | } |
117 | cleanup(); | 117 | cleanup (); |
118 | res = 1; | 118 | res = 1; |
119 | } | 119 | } |
120 | 120 | ||
121 | 121 | ||
122 | static void | 122 | static void |
123 | end(void *cls) | 123 | end (void *cls) |
124 | { | 124 | { |
125 | cleanup(); | 125 | cleanup (); |
126 | res = 0; | 126 | res = 0; |
127 | } | 127 | } |
128 | 128 | ||
129 | 129 | ||
130 | static void | 130 | static void |
131 | rd_decrypt_cb(void *cls, | 131 | rd_decrypt_cb (void *cls, |
132 | unsigned int rd_count, | 132 | unsigned int rd_count, |
133 | const struct GNUNET_GNSRECORD_Data *rd) | 133 | const struct GNUNET_GNSRECORD_Data *rd) |
134 | { | 134 | { |
135 | struct GNUNET_GNSRECORD_Data *expected_rd = cls; | 135 | struct GNUNET_GNSRECORD_Data *expected_rd = cls; |
136 | char rd_cmp_data[TEST_RECORD_DATALEN]; | 136 | char rd_cmp_data[TEST_RECORD_DATALEN]; |
137 | 137 | ||
138 | if (1 != rd_count) | 138 | if (1 != rd_count) |
139 | { | ||
140 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
141 | GNUNET_break (0); | ||
142 | return; | ||
143 | } | ||
144 | if (NULL == rd) | ||
145 | { | ||
146 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
147 | GNUNET_break (0); | ||
148 | return; | ||
149 | } | ||
150 | if (expected_rd == &records[0]) | ||
151 | { | ||
152 | /* Expecting active record */ | ||
153 | memset (rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN); | ||
154 | if (TEST_RECORD_TYPE != rd[0].record_type) | ||
139 | { | 155 | { |
140 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | 156 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
141 | GNUNET_break(0); | 157 | GNUNET_break (0); |
142 | return; | 158 | return; |
143 | } | 159 | } |
144 | if (NULL == rd) | 160 | if (TEST_RECORD_DATALEN != rd[0].data_size) |
145 | { | 161 | { |
146 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | 162 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
147 | GNUNET_break(0); | 163 | GNUNET_break (0); |
148 | return; | 164 | return; |
149 | } | 165 | } |
150 | if (expected_rd == &records[0]) | 166 | if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) |
151 | { | 167 | { |
152 | /* Expecting active record */ | 168 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
153 | memset(rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN); | 169 | GNUNET_break (0); |
154 | if (TEST_RECORD_TYPE != rd[0].record_type) | 170 | return; |
155 | { | ||
156 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
157 | GNUNET_break(0); | ||
158 | return; | ||
159 | } | ||
160 | if (TEST_RECORD_DATALEN != rd[0].data_size) | ||
161 | { | ||
162 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
163 | GNUNET_break(0); | ||
164 | return; | ||
165 | } | ||
166 | if (0 != memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) | ||
167 | { | ||
168 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
169 | GNUNET_break(0); | ||
170 | return; | ||
171 | } | ||
172 | if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) | ||
173 | { | ||
174 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
175 | GNUNET_break(0); | ||
176 | return; | ||
177 | } | ||
178 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
179 | "Block was decrypted successfully with active record\n"); | ||
180 | } | 171 | } |
172 | if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) | ||
173 | { | ||
174 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
175 | GNUNET_break (0); | ||
176 | return; | ||
177 | } | ||
178 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
179 | "Block was decrypted successfully with active record\n"); | ||
180 | } | ||
181 | if (expected_rd == &records[1]) | 181 | if (expected_rd == &records[1]) |
182 | { | ||
183 | /* Expecting shadow record but without shadow flag*/ | ||
184 | memset (rd_cmp_data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN); | ||
185 | if (TEST_RECORD_TYPE != rd[0].record_type) | ||
186 | { | ||
187 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
188 | GNUNET_break (0); | ||
189 | return; | ||
190 | } | ||
191 | if (TEST_RECORD_DATALEN != rd[0].data_size) | ||
192 | { | ||
193 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
194 | GNUNET_break (0); | ||
195 | return; | ||
196 | } | ||
197 | if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) | ||
182 | { | 198 | { |
183 | /* Expecting shadow record but without shadow flag*/ | 199 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
184 | memset(rd_cmp_data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN); | 200 | GNUNET_break (0); |
185 | if (TEST_RECORD_TYPE != rd[0].record_type) | 201 | return; |
186 | { | ||
187 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
188 | GNUNET_break(0); | ||
189 | return; | ||
190 | } | ||
191 | if (TEST_RECORD_DATALEN != rd[0].data_size) | ||
192 | { | ||
193 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
194 | GNUNET_break(0); | ||
195 | return; | ||
196 | } | ||
197 | if (0 != memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) | ||
198 | { | ||
199 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
200 | GNUNET_break(0); | ||
201 | return; | ||
202 | } | ||
203 | if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) | ||
204 | { | ||
205 | GNUNET_SCHEDULER_add_now(&endbadly, NULL); | ||
206 | GNUNET_break(0); | ||
207 | return; | ||
208 | } | ||
209 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
210 | "Block was decrypted successfully with former shadow record \n"); | ||
211 | GNUNET_SCHEDULER_add_now(&end, NULL); | ||
212 | } | 202 | } |
203 | if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) | ||
204 | { | ||
205 | GNUNET_SCHEDULER_add_now (&endbadly, NULL); | ||
206 | GNUNET_break (0); | ||
207 | return; | ||
208 | } | ||
209 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
210 | "Block was decrypted successfully with former shadow record \n"); | ||
211 | GNUNET_SCHEDULER_add_now (&end, NULL); | ||
212 | } | ||
213 | } | 213 | } |
214 | 214 | ||
215 | 215 | ||
216 | static void | 216 | static void |
217 | name_lookup_active_proc(void *cls, | 217 | name_lookup_active_proc (void *cls, |
218 | const struct GNUNET_GNSRECORD_Block *block) | 218 | const struct GNUNET_GNSRECORD_Block *block) |
219 | { | 219 | { |
220 | struct GNUNET_GNSRECORD_Data *expected_rd = cls; | 220 | struct GNUNET_GNSRECORD_Data *expected_rd = cls; |
221 | 221 | ||
222 | GNUNET_assert(NULL != expected_rd); | 222 | GNUNET_assert (NULL != expected_rd); |
223 | 223 | ||
224 | ncqe = NULL; | 224 | ncqe = NULL; |
225 | ncqe_shadow = NULL; | 225 | ncqe_shadow = NULL; |
226 | if (endbadly_task != NULL) | 226 | if (endbadly_task != NULL) |
227 | { | 227 | { |
228 | GNUNET_SCHEDULER_cancel(endbadly_task); | 228 | GNUNET_SCHEDULER_cancel (endbadly_task); |
229 | endbadly_task = NULL; | 229 | endbadly_task = NULL; |
230 | } | 230 | } |
231 | 231 | ||
232 | if (NULL == block) | 232 | if (NULL == block) |
233 | { | 233 | { |
234 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 234 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
235 | _("Namestore returned no block\n")); | 235 | _ ("Namestore returned no block\n")); |
236 | if (endbadly_task != NULL) | 236 | if (endbadly_task != NULL) |
237 | GNUNET_SCHEDULER_cancel(endbadly_task); | 237 | GNUNET_SCHEDULER_cancel (endbadly_task); |
238 | endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL); | 238 | endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
239 | return; | 239 | return; |
240 | } | 240 | } |
241 | 241 | ||
242 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 242 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
243 | "Namestore returned block, decrypting \n"); | 243 | "Namestore returned block, decrypting \n"); |
244 | GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block, | 244 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt (block, |
245 | &pubkey, TEST_NAME, &rd_decrypt_cb, expected_rd)); | 245 | &pubkey, |
246 | TEST_NAME, | ||
247 | &rd_decrypt_cb, | ||
248 | expected_rd)); | ||
246 | } | 249 | } |
247 | 250 | ||
248 | 251 | ||
249 | static void | 252 | static void |
250 | name_lookup_shadow(void *cls) | 253 | name_lookup_shadow (void *cls) |
251 | { | 254 | { |
252 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 255 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
253 | "Performing lookup for shadow record \n"); | 256 | "Performing lookup for shadow record \n"); |
254 | delayed_lookup_task = NULL; | 257 | delayed_lookup_task = NULL; |
255 | ncqe_shadow = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash, | 258 | ncqe_shadow = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, |
256 | &name_lookup_active_proc, &records[1]); | 259 | &name_lookup_active_proc, |
260 | &records[1]); | ||
257 | } | 261 | } |
258 | 262 | ||
259 | 263 | ||
260 | static void | 264 | static void |
261 | put_cont(void *cls, int32_t success, const char *emsg) | 265 | put_cont (void *cls, int32_t success, const char *emsg) |
262 | { | 266 | { |
263 | nsqe = NULL; | 267 | nsqe = NULL; |
264 | 268 | ||
265 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 269 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
266 | "Name store added record for `%s': %s\n", | 270 | "Name store added record for `%s': %s\n", |
267 | TEST_NAME, | 271 | TEST_NAME, |
268 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); | 272 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); |
269 | 273 | ||
270 | /* Create derived hash */ | 274 | /* Create derived hash */ |
271 | GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey); | 275 | GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); |
272 | GNUNET_GNSRECORD_query_from_public_key(&pubkey, TEST_NAME, &derived_hash); | 276 | GNUNET_GNSRECORD_query_from_public_key (&pubkey, TEST_NAME, &derived_hash); |
273 | 277 | ||
274 | if (0 == GNUNET_TIME_absolute_get_remaining(record_expiration).rel_value_us) | 278 | if (0 == GNUNET_TIME_absolute_get_remaining (record_expiration).rel_value_us) |
275 | { | 279 | { |
276 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 280 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
277 | "Test to too long to store records, cannot run test!\n"); | 281 | "Test to too long to store records, cannot run test!\n"); |
278 | GNUNET_SCHEDULER_add_now(&end, NULL); | 282 | GNUNET_SCHEDULER_add_now (&end, NULL); |
279 | return; | 283 | return; |
280 | } | 284 | } |
281 | /* Lookup active record now */ | 285 | /* Lookup active record now */ |
282 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 286 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
283 | "Performing lookup for active record \n"); | 287 | "Performing lookup for active record \n"); |
284 | ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash, | 288 | ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, |
285 | &name_lookup_active_proc, &records[0]); | 289 | &name_lookup_active_proc, &records[0]); |
286 | 290 | ||
287 | delayed_lookup_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(EXPIRATION, 2), &name_lookup_shadow, NULL); | 291 | delayed_lookup_task = GNUNET_SCHEDULER_add_delayed ( |
292 | GNUNET_TIME_relative_multiply (EXPIRATION, 2), &name_lookup_shadow, NULL); | ||
288 | } | 293 | } |
289 | 294 | ||
290 | 295 | ||
291 | static void | 296 | static void |
292 | run(void *cls, | 297 | run (void *cls, |
293 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 298 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
294 | struct GNUNET_TESTING_Peer *peer) | 299 | struct GNUNET_TESTING_Peer *peer) |
295 | { | 300 | { |
296 | endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, | 301 | endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
297 | &endbadly, | 302 | &endbadly, |
298 | NULL); | 303 | NULL); |
299 | privkey = GNUNET_CRYPTO_ecdsa_key_create(); | 304 | privkey = GNUNET_CRYPTO_ecdsa_key_create (); |
300 | GNUNET_assert(privkey != NULL); | 305 | GNUNET_assert (privkey != NULL); |
301 | GNUNET_CRYPTO_ecdsa_key_get_public(privkey, | 306 | GNUNET_CRYPTO_ecdsa_key_get_public (privkey, |
302 | &pubkey); | 307 | &pubkey); |
303 | 308 | ||
304 | record_expiration = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), | 309 | record_expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), |
305 | EXPIRATION); | 310 | EXPIRATION); |
306 | records[0].expiration_time = record_expiration.abs_value_us; | 311 | records[0].expiration_time = record_expiration.abs_value_us; |
307 | records[0].record_type = TEST_RECORD_TYPE; | 312 | records[0].record_type = TEST_RECORD_TYPE; |
308 | records[0].data_size = TEST_RECORD_DATALEN; | 313 | records[0].data_size = TEST_RECORD_DATALEN; |
309 | records[0].data = GNUNET_malloc(TEST_RECORD_DATALEN); | 314 | records[0].data = GNUNET_malloc (TEST_RECORD_DATALEN); |
310 | records[0].flags = GNUNET_GNSRECORD_RF_NONE; | 315 | records[0].flags = GNUNET_GNSRECORD_RF_NONE; |
311 | memset((char *)records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN); | 316 | memset ((char *) records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN); |
312 | 317 | ||
313 | records[1].expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000; | 318 | records[1].expiration_time = GNUNET_TIME_absolute_get ().abs_value_us |
319 | + 1000000000; | ||
314 | records[1].record_type = TEST_RECORD_TYPE; | 320 | records[1].record_type = TEST_RECORD_TYPE; |
315 | records[1].data_size = TEST_RECORD_DATALEN; | 321 | records[1].data_size = TEST_RECORD_DATALEN; |
316 | records[1].data = GNUNET_malloc(TEST_RECORD_DATALEN); | 322 | records[1].data = GNUNET_malloc (TEST_RECORD_DATALEN); |
317 | records[1].flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD; | 323 | records[1].flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD; |
318 | memset((char *)records[1].data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN); | 324 | memset ((char *) records[1].data, TEST_SHADOW_RECORD_DATA, |
319 | 325 | TEST_RECORD_DATALEN); | |
320 | nsh = GNUNET_NAMESTORE_connect(cfg); | 326 | |
321 | nch = GNUNET_NAMECACHE_connect(cfg); | 327 | nsh = GNUNET_NAMESTORE_connect (cfg); |
322 | GNUNET_break(NULL != nsh); | 328 | nch = GNUNET_NAMECACHE_connect (cfg); |
323 | GNUNET_break(NULL != nch); | 329 | GNUNET_break (NULL != nsh); |
324 | nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, TEST_NAME, | 330 | GNUNET_break (NULL != nch); |
325 | 2, records, &put_cont, NULL); | 331 | nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, TEST_NAME, |
332 | 2, records, &put_cont, NULL); | ||
326 | if (NULL == nsqe) | 333 | if (NULL == nsqe) |
327 | { | 334 | { |
328 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 335 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
329 | _("Namestore cannot store no block\n")); | 336 | _ ("Namestore cannot store no block\n")); |
330 | } | 337 | } |
331 | 338 | ||
332 | GNUNET_free((void *)records[0].data); | 339 | GNUNET_free ((void *) records[0].data); |
333 | GNUNET_free((void *)records[1].data); | 340 | GNUNET_free ((void *) records[1].data); |
334 | } | 341 | } |
335 | 342 | ||
336 | 343 | ||
@@ -338,24 +345,24 @@ run(void *cls, | |||
338 | 345 | ||
339 | 346 | ||
340 | int | 347 | int |
341 | main(int argc, char *argv[]) | 348 | main (int argc, char *argv[]) |
342 | { | 349 | { |
343 | const char *plugin_name; | 350 | const char *plugin_name; |
344 | char *cfg_name; | 351 | char *cfg_name; |
345 | 352 | ||
346 | SETUP_CFG(plugin_name, cfg_name); | 353 | SETUP_CFG (plugin_name, cfg_name); |
347 | res = 1; | 354 | res = 1; |
348 | if (0 != | 355 | if (0 != |
349 | GNUNET_TESTING_peer_run("test-namestore-api-lookup-shadow-filter", | 356 | GNUNET_TESTING_peer_run ("test-namestore-api-lookup-shadow-filter", |
350 | cfg_name, | 357 | cfg_name, |
351 | &run, | 358 | &run, |
352 | NULL)) | 359 | NULL)) |
353 | { | 360 | { |
354 | res = 1; | 361 | res = 1; |
355 | } | 362 | } |
356 | GNUNET_DISK_purge_cfg_dir(cfg_name, | 363 | GNUNET_DISK_purge_cfg_dir (cfg_name, |
357 | "GNUNET_TEST_HOME"); | 364 | "GNUNET_TEST_HOME"); |
358 | GNUNET_free(cfg_name); | 365 | GNUNET_free (cfg_name); |
359 | return res; | 366 | return res; |
360 | } | 367 | } |
361 | 368 | ||