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 | 375 |
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 | ||
43 | static struct GNUNET_NAMESTORE_Handle *nsh; | 43 | static struct GNUNET_NAMESTORE_Handle *nsh; |
44 | 44 | ||
@@ -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,239 +97,240 @@ 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) | ||
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 | ||
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 | 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 | ||
248 | static void | 249 | static void |
249 | name_lookup_shadow (void *cls) | 250 | name_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 | ||
259 | static void | 260 | static void |
260 | put_cont (void *cls, int32_t success, const char *emsg) | 261 | put_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 | ||
290 | static void | 291 | static void |
291 | run (void *cls, | 292 | run(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 | ||
339 | int | 340 | int |
340 | main (int argc, char *argv[]) | 341 | main(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 | ||