aboutsummaryrefslogtreecommitdiff
path: root/src/namestore/test_namestore_api_lookup_shadow_filter.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/namestore/test_namestore_api_lookup_shadow_filter.c')
-rw-r--r--src/namestore/test_namestore_api_lookup_shadow_filter.c375
1 files changed, 188 insertions, 187 deletions
diff --git a/src/namestore/test_namestore_api_lookup_shadow_filter.c b/src/namestore/test_namestore_api_lookup_shadow_filter.c
index 3d1dbfacf..d8d6b8a29 100644
--- a/src/namestore/test_namestore_api_lookup_shadow_filter.c
+++ b/src/namestore/test_namestore_api_lookup_shadow_filter.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_lookup_shadow_filter.c 21 * @file namestore/test_namestore_api_lookup_shadow_filter.c
22 * @brief testcase for namestore_api.c: store a record with short expiration 22 * @brief testcase for namestore_api.c: store a record with short expiration
@@ -37,8 +37,8 @@
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
43static struct GNUNET_NAMESTORE_Handle *nsh; 43static struct GNUNET_NAMESTORE_Handle *nsh;
44 44
@@ -70,24 +70,24 @@ static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
70 70
71 71
72static void 72static void
73cleanup () 73cleanup()
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,239 +97,240 @@ cleanup ()
97 * @param cls handle to use to re-connect. 97 * @param cls handle to use to re-connect.
98 */ 98 */
99static void 99static void
100endbadly (void *cls) 100endbadly(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
122static void 122static void
123end (void *cls) 123end(void *cls)
124{ 124{
125 cleanup (); 125 cleanup();
126 res = 0; 126 res = 0;
127} 127}
128 128
129 129
130static void 130static void
131rd_decrypt_cb (void *cls, 131rd_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)
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 { 139 {
162 GNUNET_SCHEDULER_add_now (&endbadly, NULL); 140 GNUNET_SCHEDULER_add_now(&endbadly, NULL);
163 GNUNET_break (0); 141 GNUNET_break(0);
164 return; 142 return;
165 } 143 }
166 if (0 != memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)) 144 if (NULL == rd)
167 { 145 {
168 GNUNET_SCHEDULER_add_now (&endbadly, NULL); 146 GNUNET_SCHEDULER_add_now(&endbadly, NULL);
169 GNUNET_break (0); 147 GNUNET_break(0);
170 return; 148 return;
171 } 149 }
172 if (0 != (GNUNET_GNSRECORD_RF_SHADOW_RECORD & rd[0].flags)) 150 if (expected_rd == &records[0])
173 { 151 {
174 GNUNET_SCHEDULER_add_now (&endbadly, NULL); 152 /* Expecting active record */
175 GNUNET_break (0); 153 memset(rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
176 return; 154 if (TEST_RECORD_TYPE != rd[0].record_type)
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");
177 } 180 }
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 { 182 {
187 GNUNET_SCHEDULER_add_now (&endbadly, NULL); 183 /* Expecting shadow record but without shadow flag*/
188 GNUNET_break (0); 184 memset(rd_cmp_data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
189 return; 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))
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);
190 } 212 }
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 }
213} 213}
214 214
215 215
216static void 216static void
217name_lookup_active_proc (void *cls, 217name_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 GNUNET_assert (NULL != expected_rd); 221
222 GNUNET_assert(NULL != expected_rd);
222 223
223 ncqe = NULL; 224 ncqe = NULL;
224 ncqe_shadow = NULL; 225 ncqe_shadow = NULL;
225 if (endbadly_task != NULL) 226 if (endbadly_task != NULL)
226 { 227 {
227 GNUNET_SCHEDULER_cancel (endbadly_task); 228 GNUNET_SCHEDULER_cancel(endbadly_task);
228 endbadly_task = NULL; 229 endbadly_task = NULL;
229 } 230 }
230 231
231 if (NULL == block) 232 if (NULL == block)
232 { 233 {
233 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 234 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
234 _("Namestore returned no block\n")); 235 _("Namestore returned no block\n"));
235 if (endbadly_task != NULL) 236 if (endbadly_task != NULL)
236 GNUNET_SCHEDULER_cancel (endbadly_task); 237 GNUNET_SCHEDULER_cancel(endbadly_task);
237 endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL); 238 endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
238 return; 239 return;
239 } 240 }
240 241
241 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 242 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
242 "Namestore returned block, decrypting \n"); 243 "Namestore returned block, decrypting \n");
243 GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block, 244 GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
244 &pubkey, TEST_NAME, &rd_decrypt_cb, expected_rd)); 245 &pubkey, TEST_NAME, &rd_decrypt_cb, expected_rd));
245} 246}
246 247
247 248
248static void 249static void
249name_lookup_shadow (void *cls) 250name_lookup_shadow(void *cls)
250{ 251{
251 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 252 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
252 "Performing lookup for shadow record \n"); 253 "Performing lookup for shadow record \n");
253 delayed_lookup_task = NULL; 254 delayed_lookup_task = NULL;
254 ncqe_shadow = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, 255 ncqe_shadow = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
255 &name_lookup_active_proc, &records[1]); 256 &name_lookup_active_proc, &records[1]);
256} 257}
257 258
258 259
259static void 260static void
260put_cont (void *cls, int32_t success, const char *emsg) 261put_cont(void *cls, int32_t success, const char *emsg)
261{ 262{
262 nsqe = NULL; 263 nsqe = NULL;
263 264
264 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 265 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
265 "Name store added record for `%s': %s\n", 266 "Name store added record for `%s': %s\n",
266 TEST_NAME, 267 TEST_NAME,
267 (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); 268 (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
268 269
269 /* Create derived hash */ 270 /* Create derived hash */
270 GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); 271 GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
271 GNUNET_GNSRECORD_query_from_public_key (&pubkey, TEST_NAME, &derived_hash); 272 GNUNET_GNSRECORD_query_from_public_key(&pubkey, TEST_NAME, &derived_hash);
272 273
273 if (0 == GNUNET_TIME_absolute_get_remaining(record_expiration).rel_value_us ) 274 if (0 == GNUNET_TIME_absolute_get_remaining(record_expiration).rel_value_us)
274 { 275 {
275 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 276 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
276 "Test to too long to store records, cannot run test!\n"); 277 "Test to too long to store records, cannot run test!\n");
277 GNUNET_SCHEDULER_add_now (&end, NULL ); 278 GNUNET_SCHEDULER_add_now(&end, NULL);
278 return; 279 return;
279 } 280 }
280 /* Lookup active record now */ 281 /* Lookup active record now */
281 GNUNET_log (GNUNET_ERROR_TYPE_INFO, 282 GNUNET_log(GNUNET_ERROR_TYPE_INFO,
282 "Performing lookup for active record \n"); 283 "Performing lookup for active record \n");
283 ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, 284 ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
284 &name_lookup_active_proc, &records[0]); 285 &name_lookup_active_proc, &records[0]);
285 286
286 delayed_lookup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (EXPIRATION, 2), &name_lookup_shadow, NULL); 287 delayed_lookup_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(EXPIRATION, 2), &name_lookup_shadow, NULL);
287} 288}
288 289
289 290
290static void 291static void
291run (void *cls, 292run(void *cls,
292 const struct GNUNET_CONFIGURATION_Handle *cfg, 293 const struct GNUNET_CONFIGURATION_Handle *cfg,
293 struct GNUNET_TESTING_Peer *peer) 294 struct GNUNET_TESTING_Peer *peer)
294{ 295{
295 endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 296 endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
296 &endbadly, 297 &endbadly,
297 NULL); 298 NULL);
298 privkey = GNUNET_CRYPTO_ecdsa_key_create (); 299 privkey = GNUNET_CRYPTO_ecdsa_key_create();
299 GNUNET_assert (privkey != NULL); 300 GNUNET_assert(privkey != NULL);
300 GNUNET_CRYPTO_ecdsa_key_get_public (privkey, 301 GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
301 &pubkey); 302 &pubkey);
302 303
303 record_expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(), 304 record_expiration = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
304 EXPIRATION); 305 EXPIRATION);
305 records[0].expiration_time = record_expiration.abs_value_us; 306 records[0].expiration_time = record_expiration.abs_value_us;
306 records[0].record_type = TEST_RECORD_TYPE; 307 records[0].record_type = TEST_RECORD_TYPE;
307 records[0].data_size = TEST_RECORD_DATALEN; 308 records[0].data_size = TEST_RECORD_DATALEN;
308 records[0].data = GNUNET_malloc (TEST_RECORD_DATALEN); 309 records[0].data = GNUNET_malloc(TEST_RECORD_DATALEN);
309 records[0].flags = GNUNET_GNSRECORD_RF_NONE; 310 records[0].flags = GNUNET_GNSRECORD_RF_NONE;
310 memset ((char *) records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN); 311 memset((char *)records[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
311 312
312 records[1].expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000; 313 records[1].expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
313 records[1].record_type = TEST_RECORD_TYPE; 314 records[1].record_type = TEST_RECORD_TYPE;
314 records[1].data_size = TEST_RECORD_DATALEN; 315 records[1].data_size = TEST_RECORD_DATALEN;
315 records[1].data = GNUNET_malloc (TEST_RECORD_DATALEN); 316 records[1].data = GNUNET_malloc(TEST_RECORD_DATALEN);
316 records[1].flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD; 317 records[1].flags = GNUNET_GNSRECORD_RF_SHADOW_RECORD;
317 memset ((char *) records[1].data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN); 318 memset((char *)records[1].data, TEST_SHADOW_RECORD_DATA, TEST_RECORD_DATALEN);
318 319
319 nsh = GNUNET_NAMESTORE_connect (cfg); 320 nsh = GNUNET_NAMESTORE_connect(cfg);
320 nch = GNUNET_NAMECACHE_connect (cfg); 321 nch = GNUNET_NAMECACHE_connect(cfg);
321 GNUNET_break (NULL != nsh); 322 GNUNET_break(NULL != nsh);
322 GNUNET_break (NULL != nch); 323 GNUNET_break(NULL != nch);
323 nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, TEST_NAME, 324 nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, TEST_NAME,
324 2, records, &put_cont, NULL); 325 2, records, &put_cont, NULL);
325 if (NULL == nsqe) 326 if (NULL == nsqe)
326 { 327 {
327 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 328 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
328 _("Namestore cannot store no block\n")); 329 _("Namestore cannot store no block\n"));
329 } 330 }
330 331
331 GNUNET_free ((void *) records[0].data); 332 GNUNET_free((void *)records[0].data);
332 GNUNET_free ((void *) records[1].data); 333 GNUNET_free((void *)records[1].data);
333} 334}
334 335
335 336
@@ -337,24 +338,24 @@ run (void *cls,
337 338
338 339
339int 340int
340main (int argc, char *argv[]) 341main(int argc, char *argv[])
341{ 342{
342 const char *plugin_name; 343 const char *plugin_name;
343 char *cfg_name; 344 char *cfg_name;
344 345
345 SETUP_CFG (plugin_name, cfg_name); 346 SETUP_CFG(plugin_name, cfg_name);
346 res = 1; 347 res = 1;
347 if (0 != 348 if (0 !=
348 GNUNET_TESTING_peer_run ("test-namestore-api-lookup-shadow-filter", 349 GNUNET_TESTING_peer_run("test-namestore-api-lookup-shadow-filter",
349 cfg_name, 350 cfg_name,
350 &run, 351 &run,
351 NULL)) 352 NULL))
352 { 353 {
353 res = 1; 354 res = 1;
354 } 355 }
355 GNUNET_DISK_purge_cfg_dir (cfg_name, 356 GNUNET_DISK_purge_cfg_dir(cfg_name,
356 "GNUNET_TEST_HOME"); 357 "GNUNET_TEST_HOME");
357 GNUNET_free (cfg_name); 358 GNUNET_free(cfg_name);
358 return res; 359 return res;
359} 360}
360 361