aboutsummaryrefslogtreecommitdiff
path: root/src/fs/test_fs_namespace.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r--src/fs/test_fs_namespace.c330
1 files changed, 165 insertions, 165 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 3abbd5063..cdcb4d8fd 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -41,7 +41,7 @@ static struct GNUNET_FS_SearchContext *sks_search;
41 41
42static struct GNUNET_FS_SearchContext *ksk_search; 42static struct GNUNET_FS_SearchContext *ksk_search;
43 43
44static struct GNUNET_SCHEDULER_Task * kill_task; 44static struct GNUNET_SCHEDULER_Task *kill_task;
45 45
46static int update_started; 46static int update_started;
47 47
@@ -49,123 +49,123 @@ static int err;
49 49
50 50
51static void 51static void
52abort_ksk_search_task(void *cls) 52abort_ksk_search_task (void *cls)
53{ 53{
54 if (ksk_search != NULL) 54 if (ksk_search != NULL)
55 {
56 GNUNET_FS_search_stop (ksk_search);
57 ksk_search = NULL;
58 if (sks_search == NULL)
55 { 59 {
56 GNUNET_FS_search_stop(ksk_search); 60 GNUNET_FS_stop (fs);
57 ksk_search = NULL; 61 if (NULL != kill_task)
58 if (sks_search == NULL) 62 GNUNET_SCHEDULER_cancel (kill_task);
59 {
60 GNUNET_FS_stop(fs);
61 if (NULL != kill_task)
62 GNUNET_SCHEDULER_cancel(kill_task);
63 }
64 } 63 }
64 }
65} 65}
66 66
67 67
68static void 68static void
69abort_sks_search_task(void *cls) 69abort_sks_search_task (void *cls)
70{ 70{
71 if (sks_search == NULL) 71 if (sks_search == NULL)
72 return; 72 return;
73 GNUNET_FS_search_stop(sks_search); 73 GNUNET_FS_search_stop (sks_search);
74 sks_search = NULL; 74 sks_search = NULL;
75 if (ksk_search == NULL) 75 if (ksk_search == NULL)
76 { 76 {
77 GNUNET_FS_stop(fs); 77 GNUNET_FS_stop (fs);
78 if (NULL != kill_task) 78 if (NULL != kill_task)
79 GNUNET_SCHEDULER_cancel(kill_task); 79 GNUNET_SCHEDULER_cancel (kill_task);
80 } 80 }
81} 81}
82 82
83 83
84static void 84static void
85do_timeout(void *cls) 85do_timeout (void *cls)
86{ 86{
87 err = 1; 87 err = 1;
88 fprintf(stderr, "%s", "Operation timed out\n"); 88 fprintf (stderr, "%s", "Operation timed out\n");
89 kill_task = NULL; 89 kill_task = NULL;
90 abort_sks_search_task(NULL); 90 abort_sks_search_task (NULL);
91 abort_ksk_search_task(NULL); 91 abort_ksk_search_task (NULL);
92} 92}
93 93
94 94
95static void * 95static void *
96progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) 96progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
97{ 97{
98 switch (event->status) 98 switch (event->status)
99 {
100 case GNUNET_FS_STATUS_SEARCH_RESULT:
101 if (sks_search == event->value.search.sc)
99 { 102 {
100 case GNUNET_FS_STATUS_SEARCH_RESULT: 103 if (! GNUNET_FS_uri_test_equal
101 if (sks_search == event->value.search.sc) 104 (sks_expect_uri, event->value.search.specifics.result.uri))
102 { 105 {
103 if (!GNUNET_FS_uri_test_equal 106 fprintf (stderr, "%s", "Wrong result for sks search!\n");
104 (sks_expect_uri, event->value.search.specifics.result.uri)) 107 err = 1;
105 { 108 }
106 fprintf(stderr, "%s", "Wrong result for sks search!\n"); 109 /* give system 1ms to initiate update search! */
107 err = 1; 110 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
108 } 111 &abort_sks_search_task, NULL);
109 /* give system 1ms to initiate update search! */
110 GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS,
111 &abort_sks_search_task, NULL);
112 }
113 else if (ksk_search == event->value.search.sc)
114 {
115 if (!GNUNET_FS_uri_test_equal
116 (ksk_expect_uri, event->value.search.specifics.result.uri))
117 {
118 fprintf(stderr, "%s", "Wrong result for ksk search!\n");
119 err = 1;
120 }
121 GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL);
122 }
123 else
124 {
125 fprintf(stderr, "%s", "Unexpected search result received!\n");
126 GNUNET_break(0);
127 }
128 break;
129
130 case GNUNET_FS_STATUS_SEARCH_ERROR:
131 fprintf(stderr, "Error searching file: %s\n",
132 event->value.search.specifics.error.message);
133 if (sks_search == event->value.search.sc)
134 GNUNET_SCHEDULER_add_now(&abort_sks_search_task, NULL);
135 else if (ksk_search == event->value.search.sc)
136 GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL);
137 else
138 GNUNET_break(0);
139 break;
140
141 case GNUNET_FS_STATUS_SEARCH_START:
142 GNUNET_assert((NULL == event->value.search.cctx) ||
143 (0 == strcmp("sks_search", event->value.search.cctx)) ||
144 (0 == strcmp("ksk_search", event->value.search.cctx)));
145 if (NULL == event->value.search.cctx)
146 {
147 GNUNET_assert(0 == strcmp("sks_search", event->value.search.pctx));
148 update_started = GNUNET_YES;
149 }
150 GNUNET_assert(1 == event->value.search.anonymity);
151 break;
152
153 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
154 return NULL;
155
156 case GNUNET_FS_STATUS_SEARCH_STOPPED:
157 return NULL;
158
159 default:
160 fprintf(stderr, "Unexpected event: %d\n", event->status);
161 break;
162 } 112 }
113 else if (ksk_search == event->value.search.sc)
114 {
115 if (! GNUNET_FS_uri_test_equal
116 (ksk_expect_uri, event->value.search.specifics.result.uri))
117 {
118 fprintf (stderr, "%s", "Wrong result for ksk search!\n");
119 err = 1;
120 }
121 GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
122 }
123 else
124 {
125 fprintf (stderr, "%s", "Unexpected search result received!\n");
126 GNUNET_break (0);
127 }
128 break;
129
130 case GNUNET_FS_STATUS_SEARCH_ERROR:
131 fprintf (stderr, "Error searching file: %s\n",
132 event->value.search.specifics.error.message);
133 if (sks_search == event->value.search.sc)
134 GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL);
135 else if (ksk_search == event->value.search.sc)
136 GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
137 else
138 GNUNET_break (0);
139 break;
140
141 case GNUNET_FS_STATUS_SEARCH_START:
142 GNUNET_assert ((NULL == event->value.search.cctx) ||
143 (0 == strcmp ("sks_search", event->value.search.cctx)) ||
144 (0 == strcmp ("ksk_search", event->value.search.cctx)));
145 if (NULL == event->value.search.cctx)
146 {
147 GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
148 update_started = GNUNET_YES;
149 }
150 GNUNET_assert (1 == event->value.search.anonymity);
151 break;
152
153 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
154 return NULL;
155
156 case GNUNET_FS_STATUS_SEARCH_STOPPED:
157 return NULL;
158
159 default:
160 fprintf (stderr, "Unexpected event: %d\n", event->status);
161 break;
162 }
163 return event->value.search.cctx; 163 return event->value.search.cctx;
164} 164}
165 165
166 166
167static void 167static void
168publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) 168publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
169{ 169{
170 char *msg; 170 char *msg;
171 struct GNUNET_FS_Uri *sks_uri; 171 struct GNUNET_FS_Uri *sks_uri;
@@ -174,37 +174,37 @@ publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
174 char *ret; 174 char *ret;
175 175
176 if (NULL != emsg) 176 if (NULL != emsg)
177 { 177 {
178 fprintf(stderr, "Error publishing: %s\n", emsg); 178 fprintf (stderr, "Error publishing: %s\n", emsg);
179 err = 1; 179 err = 1;
180 GNUNET_FS_stop(fs); 180 GNUNET_FS_stop (fs);
181 return; 181 return;
182 } 182 }
183 ret = GNUNET_STRINGS_data_to_string(&nsid, sizeof(nsid), buf, sizeof(buf)); 183 ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof(nsid), buf, sizeof(buf));
184 GNUNET_assert(NULL != ret); 184 GNUNET_assert (NULL != ret);
185 ret[0] = '\0'; 185 ret[0] = '\0';
186 GNUNET_snprintf(sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf); 186 GNUNET_snprintf (sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf);
187 sks_uri = GNUNET_FS_uri_parse(sbuf, &msg); 187 sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
188 if (NULL == sks_uri) 188 if (NULL == sks_uri)
189 { 189 {
190 fprintf(stderr, "failed to parse URI `%s': %s\n", sbuf, msg); 190 fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
191 err = 1; 191 err = 1;
192 GNUNET_FS_stop(fs); 192 GNUNET_FS_stop (fs);
193 GNUNET_free_non_null(msg); 193 GNUNET_free_non_null (msg);
194 return; 194 return;
195 } 195 }
196 ksk_search = 196 ksk_search =
197 GNUNET_FS_search_start(fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, 197 GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
198 "ksk_search"); 198 "ksk_search");
199 sks_search = 199 sks_search =
200 GNUNET_FS_search_start(fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, 200 GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
201 "sks_search"); 201 "sks_search");
202 GNUNET_FS_uri_destroy(sks_uri); 202 GNUNET_FS_uri_destroy (sks_uri);
203} 203}
204 204
205 205
206static void 206static void
207sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) 207sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
208{ 208{
209 struct GNUNET_CONTAINER_MetaData *meta; 209 struct GNUNET_CONTAINER_MetaData *meta;
210 struct GNUNET_FS_Uri *ksk_uri; 210 struct GNUNET_FS_Uri *ksk_uri;
@@ -212,61 +212,61 @@ sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
212 struct GNUNET_FS_BlockOptions bo; 212 struct GNUNET_FS_BlockOptions bo;
213 213
214 if (NULL == uri) 214 if (NULL == uri)
215 { 215 {
216 fprintf(stderr, "Error publishing: %s\n", emsg); 216 fprintf (stderr, "Error publishing: %s\n", emsg);
217 err = 1; 217 err = 1;
218 GNUNET_FS_stop(fs); 218 GNUNET_FS_stop (fs);
219 return; 219 return;
220 } 220 }
221 meta = GNUNET_CONTAINER_meta_data_create(); 221 meta = GNUNET_CONTAINER_meta_data_create ();
222 msg = NULL; 222 msg = NULL;
223 ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/ns-search", &msg); 223 ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
224 GNUNET_assert(NULL == msg); 224 GNUNET_assert (NULL == msg);
225 ksk_expect_uri = GNUNET_FS_uri_dup(uri); 225 ksk_expect_uri = GNUNET_FS_uri_dup (uri);
226 bo.content_priority = 1; 226 bo.content_priority = 1;
227 bo.anonymity_level = 1; 227 bo.anonymity_level = 1;
228 bo.replication_level = 0; 228 bo.replication_level = 0;
229 bo.expiration_time = 229 bo.expiration_time =
230 GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); 230 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
231 GNUNET_FS_publish_ksk(fs, ksk_uri, meta, uri, &bo, 231 GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
232 GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); 232 GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
233 GNUNET_FS_uri_destroy(ksk_uri); 233 GNUNET_FS_uri_destroy (ksk_uri);
234 GNUNET_CONTAINER_meta_data_destroy(meta); 234 GNUNET_CONTAINER_meta_data_destroy (meta);
235} 235}
236 236
237 237
238static void 238static void
239adv_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) 239adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
240{ 240{
241 struct GNUNET_CONTAINER_MetaData *meta; 241 struct GNUNET_CONTAINER_MetaData *meta;
242 struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; 242 struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
243 struct GNUNET_FS_BlockOptions bo; 243 struct GNUNET_FS_BlockOptions bo;
244 244
245 if (NULL != emsg) 245 if (NULL != emsg)
246 { 246 {
247 fprintf(stderr, "Error publishing: %s\n", emsg); 247 fprintf (stderr, "Error publishing: %s\n", emsg);
248 err = 1; 248 err = 1;
249 GNUNET_FS_stop(fs); 249 GNUNET_FS_stop (fs);
250 return; 250 return;
251 } 251 }
252 ns = GNUNET_CRYPTO_ecdsa_key_create(); 252 ns = GNUNET_CRYPTO_ecdsa_key_create ();
253 meta = GNUNET_CONTAINER_meta_data_create(); 253 meta = GNUNET_CONTAINER_meta_data_create ();
254 sks_expect_uri = GNUNET_FS_uri_dup(uri); 254 sks_expect_uri = GNUNET_FS_uri_dup (uri);
255 bo.content_priority = 1; 255 bo.content_priority = 1;
256 bo.anonymity_level = 1; 256 bo.anonymity_level = 1;
257 bo.replication_level = 0; 257 bo.replication_level = 0;
258 bo.expiration_time = 258 bo.expiration_time =
259 GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); 259 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
260 GNUNET_CRYPTO_ecdsa_key_get_public(ns, &nsid); 260 GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid);
261 GNUNET_FS_publish_sks(fs, ns, "this", "next", meta, uri, 261 GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,
262 &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); 262 &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
263 GNUNET_CONTAINER_meta_data_destroy(meta); 263 GNUNET_CONTAINER_meta_data_destroy (meta);
264 GNUNET_free(ns); 264 GNUNET_free (ns);
265} 265}
266 266
267 267
268static void 268static void
269testNamespace() 269testNamespace ()
270{ 270{
271 struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; 271 struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
272 struct GNUNET_FS_BlockOptions bo; 272 struct GNUNET_FS_BlockOptions bo;
@@ -274,46 +274,46 @@ testNamespace()
274 struct GNUNET_FS_Uri *ksk_uri; 274 struct GNUNET_FS_Uri *ksk_uri;
275 struct GNUNET_FS_Uri *sks_uri; 275 struct GNUNET_FS_Uri *sks_uri;
276 276
277 ns = GNUNET_CRYPTO_ecdsa_key_create(); 277 ns = GNUNET_CRYPTO_ecdsa_key_create ();
278 meta = GNUNET_CONTAINER_meta_data_create(); 278 meta = GNUNET_CONTAINER_meta_data_create ();
279 ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/testnsa", NULL); 279 ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
280 bo.content_priority = 1; 280 bo.content_priority = 1;
281 bo.anonymity_level = 1; 281 bo.anonymity_level = 1;
282 bo.replication_level = 0; 282 bo.replication_level = 0;
283 bo.expiration_time = 283 bo.expiration_time =
284 GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); 284 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
285 sks_uri = GNUNET_FS_uri_sks_create(&nsid, "root"); 285 sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");
286 GNUNET_FS_publish_ksk(fs, 286 GNUNET_FS_publish_ksk (fs,
287 ksk_uri, meta, sks_uri, 287 ksk_uri, meta, sks_uri,
288 &bo, GNUNET_FS_PUBLISH_OPTION_NONE, 288 &bo, GNUNET_FS_PUBLISH_OPTION_NONE,
289 &adv_cont, NULL); 289 &adv_cont, NULL);
290 GNUNET_FS_uri_destroy(sks_uri); 290 GNUNET_FS_uri_destroy (sks_uri);
291 kill_task = 291 kill_task =
292 GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &do_timeout, 292 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
293 NULL); 293 NULL);
294 GNUNET_FS_uri_destroy(ksk_uri); 294 GNUNET_FS_uri_destroy (ksk_uri);
295 GNUNET_CONTAINER_meta_data_destroy(meta); 295 GNUNET_CONTAINER_meta_data_destroy (meta);
296 GNUNET_free(ns); 296 GNUNET_free (ns);
297} 297}
298 298
299 299
300static void 300static void
301run(void *cls, 301run (void *cls,
302 const struct GNUNET_CONFIGURATION_Handle *cfg, 302 const struct GNUNET_CONFIGURATION_Handle *cfg,
303 struct GNUNET_TESTING_Peer *peer) 303 struct GNUNET_TESTING_Peer *peer)
304{ 304{
305 fs = GNUNET_FS_start(cfg, "test-fs-namespace", &progress_cb, NULL, 305 fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
306 GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); 306 GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
307 testNamespace(); 307 testNamespace ();
308} 308}
309 309
310 310
311int 311int
312main(int argc, char *argv[]) 312main (int argc, char *argv[])
313{ 313{
314 if (0 != GNUNET_TESTING_peer_run("test-fs-namespace", 314 if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace",
315 "test_fs_namespace_data.conf", 315 "test_fs_namespace_data.conf",
316 &run, NULL)) 316 &run, NULL))
317 return 1; 317 return 1;
318 return err; 318 return err;
319} 319}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-23 14:15:34 +0000