diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/testing | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/testing')
-rw-r--r-- | src/testing/gnunet-testing.c | 426 | ||||
-rw-r--r-- | src/testing/list-keys.c | 110 | ||||
-rw-r--r-- | src/testing/test_testing_peerstartup.c | 67 | ||||
-rw-r--r-- | src/testing/test_testing_peerstartup2.c | 138 | ||||
-rw-r--r-- | src/testing/test_testing_portreservation.c | 62 | ||||
-rw-r--r-- | src/testing/test_testing_servicestartup.c | 27 | ||||
-rw-r--r-- | src/testing/test_testing_sharedservices.c | 89 | ||||
-rw-r--r-- | src/testing/testing.c | 1462 |
8 files changed, 1195 insertions, 1186 deletions
diff --git a/src/testing/gnunet-testing.c b/src/testing/gnunet-testing.c index 834cf6cea..a13a32f77 100644 --- a/src/testing/gnunet-testing.c +++ b/src/testing/gnunet-testing.c | |||
@@ -28,7 +28,7 @@ | |||
28 | #include "gnunet_testing_lib.h" | 28 | #include "gnunet_testing_lib.h" |
29 | 29 | ||
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from(kind, "gnunet-testing", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from (kind, "gnunet-testing", __VA_ARGS__) |
32 | 32 | ||
33 | 33 | ||
34 | /** | 34 | /** |
@@ -84,7 +84,7 @@ static struct GNUNET_TESTING_Peer *my_peer; | |||
84 | 84 | ||
85 | 85 | ||
86 | static int | 86 | static int |
87 | create_unique_cfgs(const char *template, const unsigned int no) | 87 | create_unique_cfgs (const char *template, const unsigned int no) |
88 | { | 88 | { |
89 | struct GNUNET_TESTING_System *system; | 89 | struct GNUNET_TESTING_System *system; |
90 | int fail; | 90 | int fail; |
@@ -93,76 +93,76 @@ create_unique_cfgs(const char *template, const unsigned int no) | |||
93 | struct GNUNET_CONFIGURATION_Handle *cfg_new; | 93 | struct GNUNET_CONFIGURATION_Handle *cfg_new; |
94 | struct GNUNET_CONFIGURATION_Handle *cfg_tmpl; | 94 | struct GNUNET_CONFIGURATION_Handle *cfg_tmpl; |
95 | 95 | ||
96 | if (GNUNET_NO == GNUNET_DISK_file_test(template)) | 96 | if (GNUNET_NO == GNUNET_DISK_file_test (template)) |
97 | { | 97 | { |
98 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 98 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
99 | "Configuration template `%s': file not found\n", | 99 | "Configuration template `%s': file not found\n", |
100 | create_cfg_template); | 100 | create_cfg_template); |
101 | return 1; | 101 | return 1; |
102 | } | 102 | } |
103 | cfg_tmpl = GNUNET_CONFIGURATION_create(); | 103 | cfg_tmpl = GNUNET_CONFIGURATION_create (); |
104 | 104 | ||
105 | /* load template */ | 105 | /* load template */ |
106 | if ((create_cfg_template != NULL) && | 106 | if ((create_cfg_template != NULL) && |
107 | (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg_tmpl, create_cfg_template))) | 107 | (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg_tmpl, create_cfg_template))) |
108 | { | 108 | { |
109 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 109 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
110 | "Could not load template `%s'\n", | 110 | "Could not load template `%s'\n", |
111 | create_cfg_template); | 111 | create_cfg_template); |
112 | GNUNET_CONFIGURATION_destroy(cfg_tmpl); | 112 | GNUNET_CONFIGURATION_destroy (cfg_tmpl); |
113 | 113 | ||
114 | return 1; | 114 | return 1; |
115 | } | 115 | } |
116 | /* load defaults */ | 116 | /* load defaults */ |
117 | if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg_tmpl, NULL)) | 117 | if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg_tmpl, NULL)) |
118 | { | 118 | { |
119 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 119 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
120 | "Could not load template `%s'\n", | 120 | "Could not load template `%s'\n", |
121 | create_cfg_template); | 121 | create_cfg_template); |
122 | GNUNET_CONFIGURATION_destroy(cfg_tmpl); | 122 | GNUNET_CONFIGURATION_destroy (cfg_tmpl); |
123 | return 1; | 123 | return 1; |
124 | } | 124 | } |
125 | 125 | ||
126 | fail = GNUNET_NO; | 126 | fail = GNUNET_NO; |
127 | system = | 127 | system = |
128 | GNUNET_TESTING_system_create("testing", NULL /* controller */, NULL, NULL); | 128 | GNUNET_TESTING_system_create ("testing", NULL /* controller */, NULL, NULL); |
129 | for (cur = 0; cur < no; cur++) | 129 | for (cur = 0; cur < no; cur++) |
130 | { | ||
131 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
132 | "Creating configuration no. %u \n", | ||
133 | cur); | ||
134 | if (create_cfg_template != NULL) | ||
135 | GNUNET_asprintf (&cur_file, "%04u-%s", cur, create_cfg_template); | ||
136 | else | ||
137 | GNUNET_asprintf (&cur_file, "%04u%s", cur, ".conf"); | ||
138 | |||
139 | cfg_new = GNUNET_CONFIGURATION_dup (cfg_tmpl); | ||
140 | if (GNUNET_OK != GNUNET_TESTING_configuration_create (system, cfg_new)) | ||
130 | { | 141 | { |
131 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 142 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
132 | "Creating configuration no. %u \n", | 143 | "Could not create another configuration\n"); |
133 | cur); | 144 | GNUNET_CONFIGURATION_destroy (cfg_new); |
134 | if (create_cfg_template != NULL) | 145 | fail = GNUNET_YES; |
135 | GNUNET_asprintf(&cur_file, "%04u-%s", cur, create_cfg_template); | 146 | break; |
136 | else | ||
137 | GNUNET_asprintf(&cur_file, "%04u%s", cur, ".conf"); | ||
138 | |||
139 | cfg_new = GNUNET_CONFIGURATION_dup(cfg_tmpl); | ||
140 | if (GNUNET_OK != GNUNET_TESTING_configuration_create(system, cfg_new)) | ||
141 | { | ||
142 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
143 | "Could not create another configuration\n"); | ||
144 | GNUNET_CONFIGURATION_destroy(cfg_new); | ||
145 | fail = GNUNET_YES; | ||
146 | break; | ||
147 | } | ||
148 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
149 | "Writing configuration no. %u to file `%s' \n", | ||
150 | cur, | ||
151 | cur_file); | ||
152 | if (GNUNET_OK != GNUNET_CONFIGURATION_write(cfg_new, cur_file)) | ||
153 | { | ||
154 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
155 | "Failed to write configuration no. %u \n", | ||
156 | cur); | ||
157 | fail = GNUNET_YES; | ||
158 | } | ||
159 | GNUNET_CONFIGURATION_destroy(cfg_new); | ||
160 | GNUNET_free(cur_file); | ||
161 | if (GNUNET_YES == fail) | ||
162 | break; | ||
163 | } | 147 | } |
164 | GNUNET_CONFIGURATION_destroy(cfg_tmpl); | 148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
165 | GNUNET_TESTING_system_destroy(system, GNUNET_NO); | 149 | "Writing configuration no. %u to file `%s' \n", |
150 | cur, | ||
151 | cur_file); | ||
152 | if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg_new, cur_file)) | ||
153 | { | ||
154 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
155 | "Failed to write configuration no. %u \n", | ||
156 | cur); | ||
157 | fail = GNUNET_YES; | ||
158 | } | ||
159 | GNUNET_CONFIGURATION_destroy (cfg_new); | ||
160 | GNUNET_free (cur_file); | ||
161 | if (GNUNET_YES == fail) | ||
162 | break; | ||
163 | } | ||
164 | GNUNET_CONFIGURATION_destroy (cfg_tmpl); | ||
165 | GNUNET_TESTING_system_destroy (system, GNUNET_NO); | ||
166 | if (GNUNET_YES == fail) | 166 | if (GNUNET_YES == fail) |
167 | return 1; | 167 | return 1; |
168 | return 0; | 168 | return 0; |
@@ -170,40 +170,40 @@ create_unique_cfgs(const char *template, const unsigned int no) | |||
170 | 170 | ||
171 | 171 | ||
172 | static int | 172 | static int |
173 | create_hostkeys(const unsigned int no) | 173 | create_hostkeys (const unsigned int no) |
174 | { | 174 | { |
175 | struct GNUNET_TESTING_System *system; | 175 | struct GNUNET_TESTING_System *system; |
176 | struct GNUNET_PeerIdentity id; | 176 | struct GNUNET_PeerIdentity id; |
177 | struct GNUNET_DISK_FileHandle *fd; | 177 | struct GNUNET_DISK_FileHandle *fd; |
178 | struct GNUNET_CRYPTO_EddsaPrivateKey *pk; | 178 | struct GNUNET_CRYPTO_EddsaPrivateKey *pk; |
179 | 179 | ||
180 | system = GNUNET_TESTING_system_create("testing", NULL, NULL, NULL); | 180 | system = GNUNET_TESTING_system_create ("testing", NULL, NULL, NULL); |
181 | pk = GNUNET_TESTING_hostkey_get(system, create_no, &id); | 181 | pk = GNUNET_TESTING_hostkey_get (system, create_no, &id); |
182 | if (NULL == pk) | 182 | if (NULL == pk) |
183 | { | 183 | { |
184 | fprintf(stderr, | 184 | fprintf (stderr, |
185 | _("Could not extract hostkey %u (offset too large?)\n"), | 185 | _ ("Could not extract hostkey %u (offset too large?)\n"), |
186 | create_no); | 186 | create_no); |
187 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 187 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
188 | return 1; | 188 | return 1; |
189 | } | 189 | } |
190 | (void)GNUNET_DISK_directory_create_for_file(create_hostkey); | 190 | (void) GNUNET_DISK_directory_create_for_file (create_hostkey); |
191 | fd = | 191 | fd = |
192 | GNUNET_DISK_file_open(create_hostkey, | 192 | GNUNET_DISK_file_open (create_hostkey, |
193 | GNUNET_DISK_OPEN_READWRITE | GNUNET_DISK_OPEN_CREATE, | 193 | GNUNET_DISK_OPEN_READWRITE | GNUNET_DISK_OPEN_CREATE, |
194 | GNUNET_DISK_PERM_USER_READ | | 194 | GNUNET_DISK_PERM_USER_READ |
195 | GNUNET_DISK_PERM_USER_WRITE); | 195 | | GNUNET_DISK_PERM_USER_WRITE); |
196 | GNUNET_assert(fd != NULL); | 196 | GNUNET_assert (fd != NULL); |
197 | ret = GNUNET_DISK_file_write(fd, | 197 | ret = GNUNET_DISK_file_write (fd, |
198 | pk, | 198 | pk, |
199 | sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)); | 199 | sizeof(struct GNUNET_CRYPTO_EddsaPrivateKey)); |
200 | GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd)); | 200 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd)); |
201 | GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, | 201 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, |
202 | "transport-testing", | 202 | "transport-testing", |
203 | "Wrote hostkey to file: `%s'\n", | 203 | "Wrote hostkey to file: `%s'\n", |
204 | create_hostkey); | 204 | create_hostkey); |
205 | GNUNET_free(pk); | 205 | GNUNET_free (pk); |
206 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 206 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
207 | return 0; | 207 | return 0; |
208 | } | 208 | } |
209 | 209 | ||
@@ -215,25 +215,25 @@ create_hostkeys(const unsigned int no) | |||
215 | * @param cls unused | 215 | * @param cls unused |
216 | */ | 216 | */ |
217 | static void | 217 | static void |
218 | cleanup(void *cls) | 218 | cleanup (void *cls) |
219 | { | 219 | { |
220 | if (NULL != tmpfilename) | 220 | if (NULL != tmpfilename) |
221 | { | 221 | { |
222 | if (0 != unlink(tmpfilename)) | 222 | if (0 != unlink (tmpfilename)) |
223 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, | 223 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, |
224 | "unlink", | 224 | "unlink", |
225 | tmpfilename); | 225 | tmpfilename); |
226 | } | 226 | } |
227 | if (NULL != tid) | 227 | if (NULL != tid) |
228 | { | 228 | { |
229 | GNUNET_SCHEDULER_cancel(tid); | 229 | GNUNET_SCHEDULER_cancel (tid); |
230 | tid = NULL; | 230 | tid = NULL; |
231 | } | 231 | } |
232 | if (NULL != fh) | 232 | if (NULL != fh) |
233 | { | 233 | { |
234 | GNUNET_DISK_file_close(fh); | 234 | GNUNET_DISK_file_close (fh); |
235 | fh = NULL; | 235 | fh = NULL; |
236 | } | 236 | } |
237 | } | 237 | } |
238 | 238 | ||
239 | 239 | ||
@@ -243,42 +243,42 @@ cleanup(void *cls) | |||
243 | * @param cls unused | 243 | * @param cls unused |
244 | */ | 244 | */ |
245 | static void | 245 | static void |
246 | stdin_cb(void *cls) | 246 | stdin_cb (void *cls) |
247 | { | 247 | { |
248 | int c; | 248 | int c; |
249 | 249 | ||
250 | tid = NULL; | 250 | tid = NULL; |
251 | c = getchar(); | 251 | c = getchar (); |
252 | switch (c) | 252 | switch (c) |
253 | { | 253 | { |
254 | case EOF: | 254 | case EOF: |
255 | case 'q': | 255 | case 'q': |
256 | GNUNET_SCHEDULER_shutdown(); | 256 | GNUNET_SCHEDULER_shutdown (); |
257 | return; | 257 | return; |
258 | 258 | ||
259 | case 'r': | 259 | case 'r': |
260 | if (GNUNET_OK != GNUNET_TESTING_peer_stop(my_peer)) | 260 | if (GNUNET_OK != GNUNET_TESTING_peer_stop (my_peer)) |
261 | LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to stop the peer\n"); | 261 | LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to stop the peer\n"); |
262 | if (GNUNET_OK != GNUNET_TESTING_peer_start(my_peer)) | 262 | if (GNUNET_OK != GNUNET_TESTING_peer_start (my_peer)) |
263 | LOG(GNUNET_ERROR_TYPE_ERROR, "Failed to start the peer\n"); | 263 | LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to start the peer\n"); |
264 | printf("restarted\n"); | 264 | printf ("restarted\n"); |
265 | fflush(stdout); | 265 | fflush (stdout); |
266 | break; | 266 | break; |
267 | 267 | ||
268 | case '\n': | 268 | case '\n': |
269 | case '\r': | 269 | case '\r': |
270 | /* ignore whitespace */ | 270 | /* ignore whitespace */ |
271 | break; | 271 | break; |
272 | 272 | ||
273 | default: | 273 | default: |
274 | fprintf(stderr, | 274 | fprintf (stderr, |
275 | _("Unknown command, use 'q' to quit or 'r' to restart peer\n")); | 275 | _ ("Unknown command, use 'q' to quit or 'r' to restart peer\n")); |
276 | break; | 276 | break; |
277 | } | 277 | } |
278 | tid = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 278 | tid = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
279 | fh, | 279 | fh, |
280 | &stdin_cb, | 280 | &stdin_cb, |
281 | NULL); | 281 | NULL); |
282 | } | 282 | } |
283 | 283 | ||
284 | 284 | ||
@@ -291,32 +291,32 @@ stdin_cb(void *cls) | |||
291 | * @param peer handle to the peer | 291 | * @param peer handle to the peer |
292 | */ | 292 | */ |
293 | static void | 293 | static void |
294 | testing_main(void *cls, | 294 | testing_main (void *cls, |
295 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 295 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
296 | struct GNUNET_TESTING_Peer *peer) | 296 | struct GNUNET_TESTING_Peer *peer) |
297 | { | 297 | { |
298 | my_peer = peer; | 298 | my_peer = peer; |
299 | if (NULL == (tmpfilename = GNUNET_DISK_mktemp("gnunet-testing"))) | 299 | if (NULL == (tmpfilename = GNUNET_DISK_mktemp ("gnunet-testing"))) |
300 | { | 300 | { |
301 | GNUNET_break(0); | 301 | GNUNET_break (0); |
302 | GNUNET_SCHEDULER_shutdown(); | 302 | GNUNET_SCHEDULER_shutdown (); |
303 | return; | 303 | return; |
304 | } | 304 | } |
305 | if (GNUNET_SYSERR == | 305 | if (GNUNET_SYSERR == |
306 | GNUNET_CONFIGURATION_write((struct GNUNET_CONFIGURATION_Handle *)cfg, | 306 | GNUNET_CONFIGURATION_write ((struct GNUNET_CONFIGURATION_Handle *) cfg, |
307 | tmpfilename)) | 307 | tmpfilename)) |
308 | { | 308 | { |
309 | GNUNET_break(0); | 309 | GNUNET_break (0); |
310 | return; | 310 | return; |
311 | } | 311 | } |
312 | printf("ok\n%s\n", tmpfilename); | 312 | printf ("ok\n%s\n", tmpfilename); |
313 | fflush(stdout); | 313 | fflush (stdout); |
314 | GNUNET_SCHEDULER_add_shutdown(&cleanup, NULL); | 314 | GNUNET_SCHEDULER_add_shutdown (&cleanup, NULL); |
315 | fh = GNUNET_DISK_get_handle_from_native(stdin); | 315 | fh = GNUNET_DISK_get_handle_from_native (stdin); |
316 | tid = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 316 | tid = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
317 | fh, | 317 | fh, |
318 | &stdin_cb, | 318 | &stdin_cb, |
319 | NULL); | 319 | NULL); |
320 | } | 320 | } |
321 | 321 | ||
322 | 322 | ||
@@ -329,43 +329,43 @@ testing_main(void *cls, | |||
329 | * @param cfg configuration | 329 | * @param cfg configuration |
330 | */ | 330 | */ |
331 | static void | 331 | static void |
332 | run_no_scheduler(void *cls, | 332 | run_no_scheduler (void *cls, |
333 | char *const *args, | 333 | char *const *args, |
334 | const char *cfgfile, | 334 | const char *cfgfile, |
335 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 335 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
336 | { | 336 | { |
337 | if (NULL != run_service_name) | 337 | if (NULL != run_service_name) |
338 | { | 338 | { |
339 | ret = GNUNET_TESTING_service_run("gnunet_service_test", | 339 | ret = GNUNET_TESTING_service_run ("gnunet_service_test", |
340 | run_service_name, | 340 | run_service_name, |
341 | cfgfile, | 341 | cfgfile, |
342 | &testing_main, | 342 | &testing_main, |
343 | NULL); | 343 | NULL); |
344 | return; | 344 | return; |
345 | } | 345 | } |
346 | 346 | ||
347 | if (GNUNET_YES == create_cfg) | 347 | if (GNUNET_YES == create_cfg) |
348 | { | ||
349 | if (create_no > 0) | ||
348 | { | 350 | { |
349 | if (create_no > 0) | 351 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
350 | { | 352 | "Creating %u configuration files based on template `%s'\n", |
351 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 353 | create_no, |
352 | "Creating %u configuration files based on template `%s'\n", | 354 | create_cfg_template); |
353 | create_no, | 355 | ret = create_unique_cfgs (create_cfg_template, create_no); |
354 | create_cfg_template); | ||
355 | ret = create_unique_cfgs(create_cfg_template, create_no); | ||
356 | } | ||
357 | else | ||
358 | { | ||
359 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Missing arguments! \n"); | ||
360 | ret = 1; | ||
361 | } | ||
362 | } | 356 | } |
363 | if (NULL != create_hostkey) | 357 | else |
364 | { | 358 | { |
365 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Extracting hostkey %u\n", create_no); | 359 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Missing arguments! \n"); |
366 | ret = create_hostkeys(create_no); | 360 | ret = 1; |
367 | } | 361 | } |
368 | GNUNET_free_non_null(create_cfg_template); | 362 | } |
363 | if (NULL != create_hostkey) | ||
364 | { | ||
365 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Extracting hostkey %u\n", create_no); | ||
366 | ret = create_hostkeys (create_no); | ||
367 | } | ||
368 | GNUNET_free_non_null (create_cfg_template); | ||
369 | } | 369 | } |
370 | 370 | ||
371 | 371 | ||
@@ -377,46 +377,46 @@ run_no_scheduler(void *cls, | |||
377 | * @return 0 ok, 1 on error | 377 | * @return 0 ok, 1 on error |
378 | */ | 378 | */ |
379 | int | 379 | int |
380 | main(int argc, char *const *argv) | 380 | main (int argc, char *const *argv) |
381 | { | 381 | { |
382 | struct GNUNET_GETOPT_CommandLineOption options[] = | 382 | struct GNUNET_GETOPT_CommandLineOption options[] = |
383 | { GNUNET_GETOPT_option_flag('C', | 383 | { GNUNET_GETOPT_option_flag ('C', |
384 | "cfg", | 384 | "cfg", |
385 | gettext_noop( | 385 | gettext_noop ( |
386 | "create unique configuration files"), | 386 | "create unique configuration files"), |
387 | &create_cfg), | 387 | &create_cfg), |
388 | GNUNET_GETOPT_option_string( | 388 | GNUNET_GETOPT_option_string ( |
389 | 'k', | 389 | 'k', |
390 | "key", | 390 | "key", |
391 | "FILENAME", | 391 | "FILENAME", |
392 | gettext_noop("extract hostkey file from pre-computed hostkey list"), | 392 | gettext_noop ("extract hostkey file from pre-computed hostkey list"), |
393 | &create_hostkey), | 393 | &create_hostkey), |
394 | 394 | ||
395 | GNUNET_GETOPT_option_uint( | 395 | GNUNET_GETOPT_option_uint ( |
396 | 'n', | 396 | 'n', |
397 | "number", | 397 | "number", |
398 | "NUMBER", | 398 | "NUMBER", |
399 | gettext_noop( | 399 | gettext_noop ( |
400 | "number of unique configuration files to create, or number of the hostkey to extract"), | 400 | "number of unique configuration files to create, or number of the hostkey to extract"), |
401 | &create_no), | 401 | &create_no), |
402 | 402 | ||
403 | 403 | ||
404 | GNUNET_GETOPT_option_string('t', | 404 | GNUNET_GETOPT_option_string ('t', |
405 | "template", | 405 | "template", |
406 | "FILENAME", | 406 | "FILENAME", |
407 | gettext_noop("configuration template"), | 407 | gettext_noop ("configuration template"), |
408 | &create_cfg_template), | 408 | &create_cfg_template), |
409 | 409 | ||
410 | GNUNET_GETOPT_option_string( | 410 | GNUNET_GETOPT_option_string ( |
411 | 'r', | 411 | 'r', |
412 | "run", | 412 | "run", |
413 | "SERVICE", | 413 | "SERVICE", |
414 | gettext_noop( | 414 | gettext_noop ( |
415 | "run the given service, wait on stdin for 'r' (restart) or 'q' (quit)"), | 415 | "run the given service, wait on stdin for 'r' (restart) or 'q' (quit)"), |
416 | &run_service_name), | 416 | &run_service_name), |
417 | GNUNET_GETOPT_OPTION_END }; | 417 | GNUNET_GETOPT_OPTION_END }; |
418 | 418 | ||
419 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) | 419 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
420 | return 2; | 420 | return 2; |
421 | 421 | ||
422 | /* Run without scheduler, because we may want to call | 422 | /* Run without scheduler, because we may want to call |
@@ -425,18 +425,18 @@ main(int argc, char *const *argv) | |||
425 | * but beware when extending gnunet-testing. */ | 425 | * but beware when extending gnunet-testing. */ |
426 | ret = | 426 | ret = |
427 | (GNUNET_OK == | 427 | (GNUNET_OK == |
428 | GNUNET_PROGRAM_run2(argc, | 428 | GNUNET_PROGRAM_run2 (argc, |
429 | argv, | 429 | argv, |
430 | "gnunet-testing", | 430 | "gnunet-testing", |
431 | gettext_noop( | 431 | gettext_noop ( |
432 | "Command line tool to access the testing library"), | 432 | "Command line tool to access the testing library"), |
433 | options, | 433 | options, |
434 | &run_no_scheduler, | 434 | &run_no_scheduler, |
435 | NULL, | 435 | NULL, |
436 | GNUNET_YES)) | 436 | GNUNET_YES)) |
437 | ? ret | 437 | ? ret |
438 | : 1; | 438 | : 1; |
439 | GNUNET_free((void *)argv); | 439 | GNUNET_free ((void *) argv); |
440 | return ret; | 440 | return ret; |
441 | } | 441 | } |
442 | 442 | ||
diff --git a/src/testing/list-keys.c b/src/testing/list-keys.c index 37b880b49..f65b45a77 100644 --- a/src/testing/list-keys.c +++ b/src/testing/list-keys.c | |||
@@ -15,10 +15,10 @@ static int result; | |||
15 | * @param cfg the configuration file handle | 15 | * @param cfg the configuration file handle |
16 | */ | 16 | */ |
17 | static void | 17 | static void |
18 | run(void *cls, | 18 | run (void *cls, |
19 | char *const *args, | 19 | char *const *args, |
20 | const char *cfgfile, | 20 | const char *cfgfile, |
21 | const struct GNUNET_CONFIGURATION_Handle *config) | 21 | const struct GNUNET_CONFIGURATION_Handle *config) |
22 | { | 22 | { |
23 | char *idfile; | 23 | char *idfile; |
24 | struct GNUNET_DISK_FileHandle *f; | 24 | struct GNUNET_DISK_FileHandle *f; |
@@ -31,79 +31,79 @@ run(void *cls, | |||
31 | unsigned int nmax; | 31 | unsigned int nmax; |
32 | 32 | ||
33 | if ((NULL == args) || (NULL == args[0])) | 33 | if ((NULL == args) || (NULL == args[0])) |
34 | { | 34 | { |
35 | fprintf(stderr, "Need the hostkey file\n"); | 35 | fprintf (stderr, "Need the hostkey file\n"); |
36 | return; | 36 | return; |
37 | } | 37 | } |
38 | idfile = args[0]; | 38 | idfile = args[0]; |
39 | if (GNUNET_OK != | 39 | if (GNUNET_OK != |
40 | GNUNET_DISK_file_size(idfile, &fsize, GNUNET_YES, GNUNET_YES)) | 40 | GNUNET_DISK_file_size (idfile, &fsize, GNUNET_YES, GNUNET_YES)) |
41 | { | 41 | { |
42 | GNUNET_break(0); | 42 | GNUNET_break (0); |
43 | return; | 43 | return; |
44 | } | 44 | } |
45 | if (0 != (fsize % GNUNET_TESTING_HOSTKEYFILESIZE)) | 45 | if (0 != (fsize % GNUNET_TESTING_HOSTKEYFILESIZE)) |
46 | { | 46 | { |
47 | fprintf(stderr, _("Incorrect hostkey file format: %s\n"), idfile); | 47 | fprintf (stderr, _ ("Incorrect hostkey file format: %s\n"), idfile); |
48 | return; | 48 | return; |
49 | } | 49 | } |
50 | f = GNUNET_DISK_file_open(idfile, | 50 | f = GNUNET_DISK_file_open (idfile, |
51 | GNUNET_DISK_OPEN_READ, | 51 | GNUNET_DISK_OPEN_READ, |
52 | GNUNET_DISK_PERM_NONE); | 52 | GNUNET_DISK_PERM_NONE); |
53 | if (NULL == f) | 53 | if (NULL == f) |
54 | { | 54 | { |
55 | GNUNET_break(0); | 55 | GNUNET_break (0); |
56 | return; | 56 | return; |
57 | } | 57 | } |
58 | data = GNUNET_DISK_file_map(f, &map, GNUNET_DISK_MAP_TYPE_READ, fsize); | 58 | data = GNUNET_DISK_file_map (f, &map, GNUNET_DISK_MAP_TYPE_READ, fsize); |
59 | if (NULL == data) | 59 | if (NULL == data) |
60 | { | 60 | { |
61 | GNUNET_break(0); | 61 | GNUNET_break (0); |
62 | GNUNET_DISK_file_close(f); | 62 | GNUNET_DISK_file_close (f); |
63 | return; | 63 | return; |
64 | } | 64 | } |
65 | nmax = fsize / GNUNET_TESTING_HOSTKEYFILESIZE; | 65 | nmax = fsize / GNUNET_TESTING_HOSTKEYFILESIZE; |
66 | for (cnt = nskip; cnt < (nskip + nkeys); cnt++) | 66 | for (cnt = nskip; cnt < (nskip + nkeys); cnt++) |
67 | { | ||
68 | if (nskip + cnt >= nmax) | ||
67 | { | 69 | { |
68 | if (nskip + cnt >= nmax) | 70 | printf ("Max keys %u reached\n", nmax); |
69 | { | 71 | break; |
70 | printf("Max keys %u reached\n", nmax); | ||
71 | break; | ||
72 | } | ||
73 | GNUNET_memcpy(&pkey, | ||
74 | data + (cnt * GNUNET_TESTING_HOSTKEYFILESIZE), | ||
75 | GNUNET_TESTING_HOSTKEYFILESIZE); | ||
76 | GNUNET_CRYPTO_eddsa_key_get_public(&pkey, &id.public_key); | ||
77 | printf("Key %u: %s\n", cnt, GNUNET_i2s_full(&id)); | ||
78 | } | 72 | } |
73 | GNUNET_memcpy (&pkey, | ||
74 | data + (cnt * GNUNET_TESTING_HOSTKEYFILESIZE), | ||
75 | GNUNET_TESTING_HOSTKEYFILESIZE); | ||
76 | GNUNET_CRYPTO_eddsa_key_get_public (&pkey, &id.public_key); | ||
77 | printf ("Key %u: %s\n", cnt, GNUNET_i2s_full (&id)); | ||
78 | } | ||
79 | result = GNUNET_OK; | 79 | result = GNUNET_OK; |
80 | GNUNET_DISK_file_unmap(map); | 80 | GNUNET_DISK_file_unmap (map); |
81 | GNUNET_DISK_file_close(f); | 81 | GNUNET_DISK_file_close (f); |
82 | } | 82 | } |
83 | 83 | ||
84 | 84 | ||
85 | int | 85 | int |
86 | main(int argc, char *argv[]) | 86 | main (int argc, char *argv[]) |
87 | { | 87 | { |
88 | struct GNUNET_GETOPT_CommandLineOption option[] = | 88 | struct GNUNET_GETOPT_CommandLineOption option[] = |
89 | { GNUNET_GETOPT_option_uint('n', | 89 | { GNUNET_GETOPT_option_uint ('n', |
90 | "num-keys", | 90 | "num-keys", |
91 | "COUNT", | 91 | "COUNT", |
92 | gettext_noop("list COUNT number of keys"), | 92 | gettext_noop ("list COUNT number of keys"), |
93 | &nkeys), | 93 | &nkeys), |
94 | GNUNET_GETOPT_OPTION_END }; | 94 | GNUNET_GETOPT_OPTION_END }; |
95 | int ret; | 95 | int ret; |
96 | 96 | ||
97 | result = GNUNET_SYSERR; | 97 | result = GNUNET_SYSERR; |
98 | nkeys = 10; | 98 | nkeys = 10; |
99 | ret = | 99 | ret = |
100 | GNUNET_PROGRAM_run(argc, | 100 | GNUNET_PROGRAM_run (argc, |
101 | argv, | 101 | argv, |
102 | "list-keys", | 102 | "list-keys", |
103 | "Lists the peer IDs corresponding to the given keys file\n", | 103 | "Lists the peer IDs corresponding to the given keys file\n", |
104 | option, | 104 | option, |
105 | &run, | 105 | &run, |
106 | NULL); | 106 | NULL); |
107 | if (GNUNET_OK != ret) | 107 | if (GNUNET_OK != ret) |
108 | return 1; | 108 | return 1; |
109 | if (GNUNET_SYSERR == result) | 109 | if (GNUNET_SYSERR == result) |
diff --git a/src/testing/test_testing_peerstartup.c b/src/testing/test_testing_peerstartup.c index a03e6b596..cfc79e618 100644 --- a/src/testing/test_testing_peerstartup.c +++ b/src/testing/test_testing_peerstartup.c | |||
@@ -30,7 +30,7 @@ | |||
30 | #include "gnunet_testing_lib.h" | 30 | #include "gnunet_testing_lib.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) \ | 32 | #define LOG(kind, ...) \ |
33 | GNUNET_log(kind, __VA_ARGS__) | 33 | GNUNET_log (kind, __VA_ARGS__) |
34 | 34 | ||
35 | /** | 35 | /** |
36 | * The status of the test | 36 | * The status of the test |
@@ -40,7 +40,8 @@ int status; | |||
40 | /** | 40 | /** |
41 | * The testing context | 41 | * The testing context |
42 | */ | 42 | */ |
43 | struct TestingContext { | 43 | struct TestingContext |
44 | { | ||
44 | /** | 45 | /** |
45 | * The testing system | 46 | * The testing system |
46 | */ | 47 | */ |
@@ -64,21 +65,21 @@ struct TestingContext { | |||
64 | * @param cls the testing context | 65 | * @param cls the testing context |
65 | */ | 66 | */ |
66 | static void | 67 | static void |
67 | do_shutdown(void *cls) | 68 | do_shutdown (void *cls) |
68 | { | 69 | { |
69 | struct TestingContext *test_ctx = cls; | 70 | struct TestingContext *test_ctx = cls; |
70 | 71 | ||
71 | GNUNET_assert(NULL != test_ctx); | 72 | GNUNET_assert (NULL != test_ctx); |
72 | if (NULL != test_ctx->peer) | 73 | if (NULL != test_ctx->peer) |
73 | { | 74 | { |
74 | (void)GNUNET_TESTING_peer_stop(test_ctx->peer); | 75 | (void) GNUNET_TESTING_peer_stop (test_ctx->peer); |
75 | GNUNET_TESTING_peer_destroy(test_ctx->peer); | 76 | GNUNET_TESTING_peer_destroy (test_ctx->peer); |
76 | } | 77 | } |
77 | if (NULL != test_ctx->cfg) | 78 | if (NULL != test_ctx->cfg) |
78 | GNUNET_CONFIGURATION_destroy(test_ctx->cfg); | 79 | GNUNET_CONFIGURATION_destroy (test_ctx->cfg); |
79 | if (NULL != test_ctx->system) | 80 | if (NULL != test_ctx->system) |
80 | GNUNET_TESTING_system_destroy(test_ctx->system, GNUNET_YES); | 81 | GNUNET_TESTING_system_destroy (test_ctx->system, GNUNET_YES); |
81 | GNUNET_free(test_ctx); | 82 | GNUNET_free (test_ctx); |
82 | } | 83 | } |
83 | 84 | ||
84 | 85 | ||
@@ -86,42 +87,42 @@ do_shutdown(void *cls) | |||
86 | * Main point of test execution | 87 | * Main point of test execution |
87 | */ | 88 | */ |
88 | static void | 89 | static void |
89 | run(void *cls, char *const *args, const char *cfgfile, | 90 | run (void *cls, char *const *args, const char *cfgfile, |
90 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 91 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
91 | { | 92 | { |
92 | struct TestingContext *test_ctx; | 93 | struct TestingContext *test_ctx; |
93 | char *emsg; | 94 | char *emsg; |
94 | struct GNUNET_PeerIdentity id; | 95 | struct GNUNET_PeerIdentity id; |
95 | 96 | ||
96 | test_ctx = GNUNET_new(struct TestingContext); | 97 | test_ctx = GNUNET_new (struct TestingContext); |
97 | test_ctx->system = | 98 | test_ctx->system = |
98 | GNUNET_TESTING_system_create("test-gnunet-testing", | 99 | GNUNET_TESTING_system_create ("test-gnunet-testing", |
99 | "127.0.0.1", NULL, NULL); | 100 | "127.0.0.1", NULL, NULL); |
100 | emsg = NULL; | 101 | emsg = NULL; |
101 | if (NULL == test_ctx->system) | 102 | if (NULL == test_ctx->system) |
102 | goto end; | 103 | goto end; |
103 | test_ctx->cfg = GNUNET_CONFIGURATION_dup(cfg); | 104 | test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg); |
104 | test_ctx->peer = | 105 | test_ctx->peer = |
105 | GNUNET_TESTING_peer_configure(test_ctx->system, | 106 | GNUNET_TESTING_peer_configure (test_ctx->system, |
106 | test_ctx->cfg, | 107 | test_ctx->cfg, |
107 | 0, &id, &emsg); | 108 | 0, &id, &emsg); |
108 | if (NULL == test_ctx->peer) | 109 | if (NULL == test_ctx->peer) |
109 | { | 110 | { |
110 | if (NULL != emsg) | 111 | if (NULL != emsg) |
111 | printf("Test failed upon error: %s", emsg); | 112 | printf ("Test failed upon error: %s", emsg); |
112 | goto end; | 113 | goto end; |
113 | } | 114 | } |
114 | if (GNUNET_OK != GNUNET_TESTING_peer_start(test_ctx->peer)) | 115 | if (GNUNET_OK != GNUNET_TESTING_peer_start (test_ctx->peer)) |
115 | goto end; | 116 | goto end; |
116 | status = GNUNET_OK; | 117 | status = GNUNET_OK; |
117 | 118 | ||
118 | end: | 119 | end: |
119 | GNUNET_SCHEDULER_add_now(&do_shutdown, test_ctx); | 120 | GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx); |
120 | GNUNET_free_non_null(emsg); | 121 | GNUNET_free_non_null (emsg); |
121 | } | 122 | } |
122 | 123 | ||
123 | 124 | ||
124 | int main(int argc, char *argv[]) | 125 | int main (int argc, char *argv[]) |
125 | { | 126 | { |
126 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 127 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
127 | GNUNET_GETOPT_OPTION_END | 128 | GNUNET_GETOPT_OPTION_END |
@@ -129,10 +130,10 @@ int main(int argc, char *argv[]) | |||
129 | 130 | ||
130 | status = GNUNET_SYSERR; | 131 | status = GNUNET_SYSERR; |
131 | if (GNUNET_OK != | 132 | if (GNUNET_OK != |
132 | GNUNET_PROGRAM_run(argc, argv, | 133 | GNUNET_PROGRAM_run (argc, argv, |
133 | "test_testing_peerstartup", | 134 | "test_testing_peerstartup", |
134 | "test case for peerstartup using new testing library", | 135 | "test case for peerstartup using new testing library", |
135 | options, &run, NULL)) | 136 | options, &run, NULL)) |
136 | return 1; | 137 | return 1; |
137 | return (GNUNET_OK == status) ? 0 : 1; | 138 | return (GNUNET_OK == status) ? 0 : 1; |
138 | } | 139 | } |
diff --git a/src/testing/test_testing_peerstartup2.c b/src/testing/test_testing_peerstartup2.c index 80a3b719a..316a55951 100644 --- a/src/testing/test_testing_peerstartup2.c +++ b/src/testing/test_testing_peerstartup2.c | |||
@@ -30,18 +30,18 @@ | |||
30 | #include "gnunet_testing_lib.h" | 30 | #include "gnunet_testing_lib.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) \ | 32 | #define LOG(kind, ...) \ |
33 | GNUNET_log(kind, __VA_ARGS__) | 33 | GNUNET_log (kind, __VA_ARGS__) |
34 | 34 | ||
35 | 35 | ||
36 | #define FAIL_TEST(cond) \ | 36 | #define FAIL_TEST(cond) \ |
37 | do { \ | 37 | do { \ |
38 | if (!(cond)) { \ | 38 | if (! (cond)) { \ |
39 | GNUNET_break(0); \ | 39 | GNUNET_break (0); \ |
40 | if (GNUNET_OK == status) { \ | 40 | if (GNUNET_OK == status) { \ |
41 | status = GNUNET_SYSERR; \ | 41 | status = GNUNET_SYSERR; \ |
42 | } \ | 42 | } \ |
43 | } \ | 43 | } \ |
44 | } while (0) \ | 44 | } while (0) \ |
45 | 45 | ||
46 | 46 | ||
47 | /** | 47 | /** |
@@ -52,7 +52,8 @@ int status; | |||
52 | /** | 52 | /** |
53 | * The testing context | 53 | * The testing context |
54 | */ | 54 | */ |
55 | struct TestingContext { | 55 | struct TestingContext |
56 | { | ||
56 | /** | 57 | /** |
57 | * The testing system | 58 | * The testing system |
58 | */ | 59 | */ |
@@ -71,7 +72,8 @@ struct TestingContext { | |||
71 | /** | 72 | /** |
72 | * State | 73 | * State |
73 | */ | 74 | */ |
74 | enum { | 75 | enum |
76 | { | ||
75 | PEER_INIT, | 77 | PEER_INIT, |
76 | 78 | ||
77 | PEER_STARTED, | 79 | PEER_STARTED, |
@@ -82,17 +84,17 @@ struct TestingContext { | |||
82 | 84 | ||
83 | 85 | ||
84 | static void | 86 | static void |
85 | do_shutdown2(void *cls) | 87 | do_shutdown2 (void *cls) |
86 | { | 88 | { |
87 | struct TestingContext *test_ctx = cls; | 89 | struct TestingContext *test_ctx = cls; |
88 | 90 | ||
89 | if (NULL != test_ctx->peer) | 91 | if (NULL != test_ctx->peer) |
90 | GNUNET_TESTING_peer_destroy(test_ctx->peer); | 92 | GNUNET_TESTING_peer_destroy (test_ctx->peer); |
91 | if (NULL != test_ctx->cfg) | 93 | if (NULL != test_ctx->cfg) |
92 | GNUNET_CONFIGURATION_destroy(test_ctx->cfg); | 94 | GNUNET_CONFIGURATION_destroy (test_ctx->cfg); |
93 | if (NULL != test_ctx->system) | 95 | if (NULL != test_ctx->system) |
94 | GNUNET_TESTING_system_destroy(test_ctx->system, GNUNET_YES); | 96 | GNUNET_TESTING_system_destroy (test_ctx->system, GNUNET_YES); |
95 | GNUNET_free(test_ctx); | 97 | GNUNET_free (test_ctx); |
96 | } | 98 | } |
97 | 99 | ||
98 | 100 | ||
@@ -102,29 +104,29 @@ do_shutdown2(void *cls) | |||
102 | * @param cls the testing context | 104 | * @param cls the testing context |
103 | */ | 105 | */ |
104 | static void | 106 | static void |
105 | do_shutdown(void *cls); | 107 | do_shutdown (void *cls); |
106 | 108 | ||
107 | 109 | ||
108 | static void | 110 | static void |
109 | peer_status_cb(void *cls, struct GNUNET_TESTING_Peer *peer, int success) | 111 | peer_status_cb (void *cls, struct GNUNET_TESTING_Peer *peer, int success) |
110 | { | 112 | { |
111 | struct TestingContext *test_ctx = cls; | 113 | struct TestingContext *test_ctx = cls; |
112 | 114 | ||
113 | switch (test_ctx->state) | 115 | switch (test_ctx->state) |
114 | { | 116 | { |
115 | case PEER_INIT: | 117 | case PEER_INIT: |
116 | FAIL_TEST(0); | 118 | FAIL_TEST (0); |
117 | break; | 119 | break; |
118 | 120 | ||
119 | case PEER_STARTED: | 121 | case PEER_STARTED: |
120 | FAIL_TEST(GNUNET_YES == success); | 122 | FAIL_TEST (GNUNET_YES == success); |
121 | test_ctx->state = PEER_STOPPED; | 123 | test_ctx->state = PEER_STOPPED; |
122 | GNUNET_SCHEDULER_add_now(&do_shutdown2, cls); | 124 | GNUNET_SCHEDULER_add_now (&do_shutdown2, cls); |
123 | break; | 125 | break; |
124 | 126 | ||
125 | case PEER_STOPPED: | 127 | case PEER_STOPPED: |
126 | FAIL_TEST(0); | 128 | FAIL_TEST (0); |
127 | } | 129 | } |
128 | } | 130 | } |
129 | 131 | ||
130 | 132 | ||
@@ -134,20 +136,20 @@ peer_status_cb(void *cls, struct GNUNET_TESTING_Peer *peer, int success) | |||
134 | * @param cls the testing context | 136 | * @param cls the testing context |
135 | */ | 137 | */ |
136 | static void | 138 | static void |
137 | do_shutdown(void *cls) | 139 | do_shutdown (void *cls) |
138 | { | 140 | { |
139 | struct TestingContext *test_ctx = cls; | 141 | struct TestingContext *test_ctx = cls; |
140 | 142 | ||
141 | GNUNET_assert(NULL != test_ctx); | 143 | GNUNET_assert (NULL != test_ctx); |
142 | if (NULL != test_ctx->peer) | 144 | if (NULL != test_ctx->peer) |
143 | { | 145 | { |
144 | FAIL_TEST(GNUNET_OK == | 146 | FAIL_TEST (GNUNET_OK == |
145 | GNUNET_TESTING_peer_stop_async(test_ctx->peer, | 147 | GNUNET_TESTING_peer_stop_async (test_ctx->peer, |
146 | &peer_status_cb, | 148 | &peer_status_cb, |
147 | test_ctx)); | 149 | test_ctx)); |
148 | } | 150 | } |
149 | else | 151 | else |
150 | do_shutdown2(test_ctx); | 152 | do_shutdown2 (test_ctx); |
151 | } | 153 | } |
152 | 154 | ||
153 | 155 | ||
@@ -155,51 +157,51 @@ do_shutdown(void *cls) | |||
155 | * Main point of test execution | 157 | * Main point of test execution |
156 | */ | 158 | */ |
157 | static void | 159 | static void |
158 | run(void *cls, char *const *args, const char *cfgfile, | 160 | run (void *cls, char *const *args, const char *cfgfile, |
159 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 161 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
160 | { | 162 | { |
161 | struct TestingContext *test_ctx; | 163 | struct TestingContext *test_ctx; |
162 | char *emsg; | 164 | char *emsg; |
163 | struct GNUNET_PeerIdentity id; | 165 | struct GNUNET_PeerIdentity id; |
164 | 166 | ||
165 | test_ctx = GNUNET_new(struct TestingContext); | 167 | test_ctx = GNUNET_new (struct TestingContext); |
166 | test_ctx->system = | 168 | test_ctx->system = |
167 | GNUNET_TESTING_system_create("test-gnunet-testing", | 169 | GNUNET_TESTING_system_create ("test-gnunet-testing", |
168 | "127.0.0.1", NULL, NULL); | 170 | "127.0.0.1", NULL, NULL); |
169 | emsg = NULL; | 171 | emsg = NULL; |
170 | if (NULL == test_ctx->system) | 172 | if (NULL == test_ctx->system) |
171 | goto end; | 173 | goto end; |
172 | test_ctx->cfg = GNUNET_CONFIGURATION_dup(cfg); | 174 | test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg); |
173 | test_ctx->peer = | 175 | test_ctx->peer = |
174 | GNUNET_TESTING_peer_configure(test_ctx->system, | 176 | GNUNET_TESTING_peer_configure (test_ctx->system, |
175 | test_ctx->cfg, | 177 | test_ctx->cfg, |
176 | 0, &id, &emsg); | 178 | 0, &id, &emsg); |
177 | if (NULL == test_ctx->peer) | 179 | if (NULL == test_ctx->peer) |
178 | { | 180 | { |
179 | if (NULL != emsg) | 181 | if (NULL != emsg) |
180 | printf("Test failed upon error: %s", emsg); | 182 | printf ("Test failed upon error: %s", emsg); |
181 | goto end; | 183 | goto end; |
182 | } | 184 | } |
183 | if (GNUNET_OK != GNUNET_TESTING_peer_start(test_ctx->peer)) | 185 | if (GNUNET_OK != GNUNET_TESTING_peer_start (test_ctx->peer)) |
184 | goto end; | 186 | goto end; |
185 | test_ctx->state = PEER_STARTED; | 187 | test_ctx->state = PEER_STARTED; |
186 | FAIL_TEST(GNUNET_OK == | 188 | FAIL_TEST (GNUNET_OK == |
187 | GNUNET_TESTING_peer_stop_async(test_ctx->peer, | 189 | GNUNET_TESTING_peer_stop_async (test_ctx->peer, |
188 | &peer_status_cb, | 190 | &peer_status_cb, |
189 | test_ctx)); | 191 | test_ctx)); |
190 | GNUNET_TESTING_peer_stop_async_cancel(test_ctx->peer); | 192 | GNUNET_TESTING_peer_stop_async_cancel (test_ctx->peer); |
191 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | 193 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
192 | &do_shutdown, test_ctx); | 194 | &do_shutdown, test_ctx); |
193 | return; | 195 | return; |
194 | 196 | ||
195 | end: | 197 | end: |
196 | FAIL_TEST(0); | 198 | FAIL_TEST (0); |
197 | GNUNET_SCHEDULER_add_now(&do_shutdown, test_ctx); | 199 | GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx); |
198 | GNUNET_free_non_null(emsg); | 200 | GNUNET_free_non_null (emsg); |
199 | } | 201 | } |
200 | 202 | ||
201 | 203 | ||
202 | int main(int argc, char *argv[]) | 204 | int main (int argc, char *argv[]) |
203 | { | 205 | { |
204 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 206 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
205 | GNUNET_GETOPT_OPTION_END | 207 | GNUNET_GETOPT_OPTION_END |
@@ -207,10 +209,10 @@ int main(int argc, char *argv[]) | |||
207 | 209 | ||
208 | status = GNUNET_OK; | 210 | status = GNUNET_OK; |
209 | if (GNUNET_OK != | 211 | if (GNUNET_OK != |
210 | GNUNET_PROGRAM_run(argc, argv, | 212 | GNUNET_PROGRAM_run (argc, argv, |
211 | "test_testing_new_peerstartup", | 213 | "test_testing_new_peerstartup", |
212 | "test case for peerstartup using new testing library", | 214 | "test case for peerstartup using new testing library", |
213 | options, &run, NULL)) | 215 | options, &run, NULL)) |
214 | return 1; | 216 | return 1; |
215 | return (GNUNET_OK == status) ? 0 : 1; | 217 | return (GNUNET_OK == status) ? 0 : 1; |
216 | } | 218 | } |
diff --git a/src/testing/test_testing_portreservation.c b/src/testing/test_testing_portreservation.c index 308d462b7..d810ad8cf 100644 --- a/src/testing/test_testing_portreservation.c +++ b/src/testing/test_testing_portreservation.c | |||
@@ -30,7 +30,7 @@ | |||
30 | #include "gnunet_testing_lib.h" | 30 | #include "gnunet_testing_lib.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) \ | 32 | #define LOG(kind, ...) \ |
33 | GNUNET_log(kind, __VA_ARGS__) | 33 | GNUNET_log (kind, __VA_ARGS__) |
34 | 34 | ||
35 | /** | 35 | /** |
36 | * The status of the test | 36 | * The status of the test |
@@ -41,46 +41,46 @@ int status; | |||
41 | * Main point of test execution | 41 | * Main point of test execution |
42 | */ | 42 | */ |
43 | static void | 43 | static void |
44 | run(void *cls, char *const *args, const char *cfgfile, | 44 | run (void *cls, char *const *args, const char *cfgfile, |
45 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 45 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
46 | { | 46 | { |
47 | struct GNUNET_TESTING_System *system; | 47 | struct GNUNET_TESTING_System *system; |
48 | uint16_t new_port1; | 48 | uint16_t new_port1; |
49 | uint16_t new_port2; | 49 | uint16_t new_port2; |
50 | uint16_t old_port1; | 50 | uint16_t old_port1; |
51 | 51 | ||
52 | system = GNUNET_TESTING_system_create("/tmp/gnunet-testing-new", | 52 | system = GNUNET_TESTING_system_create ("/tmp/gnunet-testing-new", |
53 | "localhost", NULL, NULL); | 53 | "localhost", NULL, NULL); |
54 | GNUNET_assert(NULL != system); | 54 | GNUNET_assert (NULL != system); |
55 | new_port1 = GNUNET_TESTING_reserve_port(system); | 55 | new_port1 = GNUNET_TESTING_reserve_port (system); |
56 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 56 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
57 | "Reserved TCP port %u\n", new_port1); | 57 | "Reserved TCP port %u\n", new_port1); |
58 | if (0 == new_port1) | 58 | if (0 == new_port1) |
59 | goto end; | 59 | goto end; |
60 | new_port2 = GNUNET_TESTING_reserve_port(system); | 60 | new_port2 = GNUNET_TESTING_reserve_port (system); |
61 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 61 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
62 | "Reserved TCP port %u\n", new_port2); | 62 | "Reserved TCP port %u\n", new_port2); |
63 | if (0 == new_port2) | 63 | if (0 == new_port2) |
64 | goto end; | 64 | goto end; |
65 | GNUNET_assert(new_port1 != new_port2); | 65 | GNUNET_assert (new_port1 != new_port2); |
66 | GNUNET_TESTING_release_port(system, new_port1); | 66 | GNUNET_TESTING_release_port (system, new_port1); |
67 | old_port1 = new_port1; | 67 | old_port1 = new_port1; |
68 | new_port1 = 0; | 68 | new_port1 = 0; |
69 | new_port1 = GNUNET_TESTING_reserve_port(system); | 69 | new_port1 = GNUNET_TESTING_reserve_port (system); |
70 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 70 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
71 | "Reserved TCP port %u\n", new_port1); | 71 | "Reserved TCP port %u\n", new_port1); |
72 | GNUNET_assert(0 != new_port1); | 72 | GNUNET_assert (0 != new_port1); |
73 | GNUNET_assert(old_port1 == new_port1); | 73 | GNUNET_assert (old_port1 == new_port1); |
74 | GNUNET_TESTING_release_port(system, new_port1); | 74 | GNUNET_TESTING_release_port (system, new_port1); |
75 | GNUNET_TESTING_release_port(system, new_port2); | 75 | GNUNET_TESTING_release_port (system, new_port2); |
76 | status = GNUNET_OK; | 76 | status = GNUNET_OK; |
77 | 77 | ||
78 | end: | 78 | end: |
79 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 79 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
80 | } | 80 | } |
81 | 81 | ||
82 | 82 | ||
83 | int main(int argc, char *argv[]) | 83 | int main (int argc, char *argv[]) |
84 | { | 84 | { |
85 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 85 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
86 | GNUNET_GETOPT_OPTION_END | 86 | GNUNET_GETOPT_OPTION_END |
@@ -88,14 +88,14 @@ int main(int argc, char *argv[]) | |||
88 | 88 | ||
89 | status = GNUNET_SYSERR; | 89 | status = GNUNET_SYSERR; |
90 | if (GNUNET_OK != | 90 | if (GNUNET_OK != |
91 | GNUNET_PROGRAM_run(argc, | 91 | GNUNET_PROGRAM_run (argc, |
92 | argv, | 92 | argv, |
93 | "test_testing_new_portreservation", | 93 | "test_testing_new_portreservation", |
94 | "test case for testing port reservation routines" | 94 | "test case for testing port reservation routines" |
95 | " from the new testing library API", | 95 | " from the new testing library API", |
96 | options, | 96 | options, |
97 | &run, | 97 | &run, |
98 | NULL)) | 98 | NULL)) |
99 | return 1; | 99 | return 1; |
100 | return (GNUNET_OK == status) ? 0 : 1; | 100 | return (GNUNET_OK == status) ? 0 : 1; |
101 | } | 101 | } |
diff --git a/src/testing/test_testing_servicestartup.c b/src/testing/test_testing_servicestartup.c index 18786ea86..d25c16167 100644 --- a/src/testing/test_testing_servicestartup.c +++ b/src/testing/test_testing_servicestartup.c | |||
@@ -29,7 +29,7 @@ | |||
29 | 29 | ||
30 | 30 | ||
31 | #define LOG(kind, ...) \ | 31 | #define LOG(kind, ...) \ |
32 | GNUNET_log(kind, __VA_ARGS__) | 32 | GNUNET_log (kind, __VA_ARGS__) |
33 | 33 | ||
34 | 34 | ||
35 | /** | 35 | /** |
@@ -45,30 +45,29 @@ static int test_success; | |||
45 | * @param cfg the configuration with which the current testing service is run | 45 | * @param cfg the configuration with which the current testing service is run |
46 | */ | 46 | */ |
47 | static void | 47 | static void |
48 | test_run(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, | 48 | test_run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, |
49 | struct GNUNET_TESTING_Peer *peer) | 49 | struct GNUNET_TESTING_Peer *peer) |
50 | { | 50 | { |
51 | GNUNET_assert(NULL == cls); | 51 | GNUNET_assert (NULL == cls); |
52 | GNUNET_assert(NULL != cfg); | 52 | GNUNET_assert (NULL != cfg); |
53 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Service arm started successfully\n"); | 53 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Service arm started successfully\n"); |
54 | test_success = GNUNET_YES; | 54 | test_success = GNUNET_YES; |
55 | GNUNET_SCHEDULER_shutdown(); | 55 | GNUNET_SCHEDULER_shutdown (); |
56 | } | 56 | } |
57 | 57 | ||
58 | 58 | ||
59 | /** | 59 | /** |
60 | * The main point of execution | 60 | * The main point of execution |
61 | */ | 61 | */ |
62 | int main(int argc, char *argv[]) | 62 | int main (int argc, char *argv[]) |
63 | { | 63 | { |
64 | test_success = GNUNET_NO; | 64 | test_success = GNUNET_NO; |
65 | GNUNET_assert(0 == GNUNET_TESTING_service_run("test-testing-servicestartup", | 65 | GNUNET_assert (0 == GNUNET_TESTING_service_run ("test-testing-servicestartup", |
66 | "arm", | 66 | "arm", |
67 | "test_testing_defaults.conf", | 67 | "test_testing_defaults.conf", |
68 | &test_run, | 68 | &test_run, |
69 | NULL)); | 69 | NULL)); |
70 | return (GNUNET_YES == test_success) ? 0 : 1; | 70 | return (GNUNET_YES == test_success) ? 0 : 1; |
71 | } | 71 | } |
72 | 72 | ||
73 | /* end of test_testing_servicestartup.c */ | 73 | /* end of test_testing_servicestartup.c */ |
74 | |||
diff --git a/src/testing/test_testing_sharedservices.c b/src/testing/test_testing_sharedservices.c index 86e9f017c..13219bf5d 100644 --- a/src/testing/test_testing_sharedservices.c +++ b/src/testing/test_testing_sharedservices.c | |||
@@ -29,7 +29,7 @@ | |||
29 | #include "gnunet_testing_lib.h" | 29 | #include "gnunet_testing_lib.h" |
30 | 30 | ||
31 | #define LOG(kind, ...) \ | 31 | #define LOG(kind, ...) \ |
32 | GNUNET_log(kind, __VA_ARGS__) | 32 | GNUNET_log (kind, __VA_ARGS__) |
33 | 33 | ||
34 | #define NUM_PEERS 4 | 34 | #define NUM_PEERS 4 |
35 | 35 | ||
@@ -41,7 +41,8 @@ int status; | |||
41 | /** | 41 | /** |
42 | * The testing context | 42 | * The testing context |
43 | */ | 43 | */ |
44 | struct TestingContext { | 44 | struct TestingContext |
45 | { | ||
45 | /** | 46 | /** |
46 | * The testing system | 47 | * The testing system |
47 | */ | 48 | */ |
@@ -65,26 +66,26 @@ struct TestingContext { | |||
65 | * @param cls the testing context | 66 | * @param cls the testing context |
66 | */ | 67 | */ |
67 | static void | 68 | static void |
68 | do_shutdown(void *cls) | 69 | do_shutdown (void *cls) |
69 | { | 70 | { |
70 | struct TestingContext *test_ctx = cls; | 71 | struct TestingContext *test_ctx = cls; |
71 | struct GNUNET_TESTING_Peer *peer; | 72 | struct GNUNET_TESTING_Peer *peer; |
72 | unsigned int cnt; | 73 | unsigned int cnt; |
73 | 74 | ||
74 | GNUNET_assert(NULL != test_ctx); | 75 | GNUNET_assert (NULL != test_ctx); |
75 | for (cnt = 0; cnt < NUM_PEERS; cnt++) | 76 | for (cnt = 0; cnt < NUM_PEERS; cnt++) |
76 | { | 77 | { |
77 | peer = test_ctx->peers[cnt]; | 78 | peer = test_ctx->peers[cnt]; |
78 | if (NULL == peer) | 79 | if (NULL == peer) |
79 | continue; | 80 | continue; |
80 | (void)GNUNET_TESTING_peer_stop(peer); | 81 | (void) GNUNET_TESTING_peer_stop (peer); |
81 | GNUNET_TESTING_peer_destroy(peer); | 82 | GNUNET_TESTING_peer_destroy (peer); |
82 | } | 83 | } |
83 | if (NULL != test_ctx->cfg) | 84 | if (NULL != test_ctx->cfg) |
84 | GNUNET_CONFIGURATION_destroy(test_ctx->cfg); | 85 | GNUNET_CONFIGURATION_destroy (test_ctx->cfg); |
85 | if (NULL != test_ctx->system) | 86 | if (NULL != test_ctx->system) |
86 | GNUNET_TESTING_system_destroy(test_ctx->system, GNUNET_YES); | 87 | GNUNET_TESTING_system_destroy (test_ctx->system, GNUNET_YES); |
87 | GNUNET_free(test_ctx); | 88 | GNUNET_free (test_ctx); |
88 | } | 89 | } |
89 | 90 | ||
90 | 91 | ||
@@ -92,8 +93,8 @@ do_shutdown(void *cls) | |||
92 | * Main point of test execution | 93 | * Main point of test execution |
93 | */ | 94 | */ |
94 | static void | 95 | static void |
95 | run(void *cls, char *const *args, const char *cfgfile, | 96 | run (void *cls, char *const *args, const char *cfgfile, |
96 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 97 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
97 | { | 98 | { |
98 | struct TestingContext *test_ctx; | 99 | struct TestingContext *test_ctx; |
99 | char *emsg; | 100 | char *emsg; |
@@ -105,44 +106,44 @@ run(void *cls, char *const *args, const char *cfgfile, | |||
105 | struct GNUNET_TESTING_Peer *peer; | 106 | struct GNUNET_TESTING_Peer *peer; |
106 | unsigned int cnt; | 107 | unsigned int cnt; |
107 | 108 | ||
108 | test_ctx = GNUNET_new(struct TestingContext); | 109 | test_ctx = GNUNET_new (struct TestingContext); |
109 | test_ctx->system = | 110 | test_ctx->system = |
110 | GNUNET_TESTING_system_create("test-gnunet-testing", | 111 | GNUNET_TESTING_system_create ("test-gnunet-testing", |
111 | "127.0.0.1", NULL, ss); | 112 | "127.0.0.1", NULL, ss); |
112 | emsg = NULL; | 113 | emsg = NULL; |
113 | if (NULL == test_ctx->system) | 114 | if (NULL == test_ctx->system) |
114 | goto end; | 115 | goto end; |
115 | test_ctx->cfg = GNUNET_CONFIGURATION_dup(cfg); | 116 | test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg); |
116 | for (cnt = 0; cnt < NUM_PEERS; cnt++) | 117 | for (cnt = 0; cnt < NUM_PEERS; cnt++) |
118 | { | ||
119 | peer = GNUNET_TESTING_peer_configure (test_ctx->system, | ||
120 | test_ctx->cfg, | ||
121 | 0, &id, &emsg); | ||
122 | if (NULL == peer) | ||
123 | { | ||
124 | if (NULL != emsg) | ||
125 | printf ("Test failed upon error: %s", emsg); | ||
126 | goto end; | ||
127 | } | ||
128 | if (GNUNET_OK != GNUNET_TESTING_peer_start (peer)) | ||
117 | { | 129 | { |
118 | peer = GNUNET_TESTING_peer_configure(test_ctx->system, | 130 | GNUNET_TESTING_peer_destroy (peer); |
119 | test_ctx->cfg, | 131 | goto end; |
120 | 0, &id, &emsg); | ||
121 | if (NULL == peer) | ||
122 | { | ||
123 | if (NULL != emsg) | ||
124 | printf("Test failed upon error: %s", emsg); | ||
125 | goto end; | ||
126 | } | ||
127 | if (GNUNET_OK != GNUNET_TESTING_peer_start(peer)) | ||
128 | { | ||
129 | GNUNET_TESTING_peer_destroy(peer); | ||
130 | goto end; | ||
131 | } | ||
132 | test_ctx->peers[cnt] = peer; | ||
133 | } | 132 | } |
133 | test_ctx->peers[cnt] = peer; | ||
134 | } | ||
134 | status = GNUNET_OK; | 135 | status = GNUNET_OK; |
135 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | 136 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
136 | &do_shutdown, test_ctx); | 137 | &do_shutdown, test_ctx); |
137 | return; | 138 | return; |
138 | 139 | ||
139 | end: | 140 | end: |
140 | GNUNET_SCHEDULER_add_now(&do_shutdown, test_ctx); | 141 | GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx); |
141 | GNUNET_free_non_null(emsg); | 142 | GNUNET_free_non_null (emsg); |
142 | } | 143 | } |
143 | 144 | ||
144 | 145 | ||
145 | int main(int argc, char *argv[]) | 146 | int main (int argc, char *argv[]) |
146 | { | 147 | { |
147 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 148 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
148 | GNUNET_GETOPT_OPTION_END | 149 | GNUNET_GETOPT_OPTION_END |
@@ -153,10 +154,10 @@ int main(int argc, char *argv[]) | |||
153 | 154 | ||
154 | status = GNUNET_SYSERR; | 155 | status = GNUNET_SYSERR; |
155 | if (GNUNET_OK != | 156 | if (GNUNET_OK != |
156 | GNUNET_PROGRAM_run((sizeof(argv2) / sizeof(char *)) - 1, argv2, | 157 | GNUNET_PROGRAM_run ((sizeof(argv2) / sizeof(char *)) - 1, argv2, |
157 | "test_testing_sharedservices", | 158 | "test_testing_sharedservices", |
158 | "test case for testing service sharing among peers started by testing", | 159 | "test case for testing service sharing among peers started by testing", |
159 | options, &run, NULL)) | 160 | options, &run, NULL)) |
160 | return 1; | 161 | return 1; |
161 | return (GNUNET_OK == status) ? 0 : 3; | 162 | return (GNUNET_OK == status) ? 0 : 3; |
162 | } | 163 | } |
diff --git a/src/testing/testing.c b/src/testing/testing.c index 26e866225..362a24af5 100644 --- a/src/testing/testing.c +++ b/src/testing/testing.c | |||
@@ -34,7 +34,7 @@ | |||
34 | #include "gnunet_arm_service.h" | 34 | #include "gnunet_arm_service.h" |
35 | #include "gnunet_testing_lib.h" | 35 | #include "gnunet_testing_lib.h" |
36 | 36 | ||
37 | #define LOG(kind, ...) GNUNET_log_from(kind, "testing-api", __VA_ARGS__) | 37 | #define LOG(kind, ...) GNUNET_log_from (kind, "testing-api", __VA_ARGS__) |
38 | 38 | ||
39 | 39 | ||
40 | /** | 40 | /** |
@@ -59,7 +59,8 @@ | |||
59 | #define HIGH_PORT 56000 | 59 | #define HIGH_PORT 56000 |
60 | 60 | ||
61 | 61 | ||
62 | struct SharedServiceInstance { | 62 | struct SharedServiceInstance |
63 | { | ||
63 | struct SharedService *ss; | 64 | struct SharedService *ss; |
64 | 65 | ||
65 | char *cfg_fn; | 66 | char *cfg_fn; |
@@ -73,7 +74,8 @@ struct SharedServiceInstance { | |||
73 | unsigned int n_refs; | 74 | unsigned int n_refs; |
74 | }; | 75 | }; |
75 | 76 | ||
76 | struct SharedService { | 77 | struct SharedService |
78 | { | ||
77 | char *sname; | 79 | char *sname; |
78 | 80 | ||
79 | struct SharedServiceInstance **instances; | 81 | struct SharedServiceInstance **instances; |
@@ -92,7 +94,8 @@ struct SharedService { | |||
92 | * Handle for a system on which GNUnet peers are executed; | 94 | * Handle for a system on which GNUnet peers are executed; |
93 | * a system is used for reserving unique paths and ports. | 95 | * a system is used for reserving unique paths and ports. |
94 | */ | 96 | */ |
95 | struct GNUNET_TESTING_System { | 97 | struct GNUNET_TESTING_System |
98 | { | ||
96 | /** | 99 | /** |
97 | * Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each | 100 | * Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each |
98 | * GNUNET_HOME. | 101 | * GNUNET_HOME. |
@@ -164,7 +167,8 @@ struct GNUNET_TESTING_System { | |||
164 | /** | 167 | /** |
165 | * Handle for a GNUnet peer controlled by testing. | 168 | * Handle for a GNUnet peer controlled by testing. |
166 | */ | 169 | */ |
167 | struct GNUNET_TESTING_Peer { | 170 | struct GNUNET_TESTING_Peer |
171 | { | ||
168 | /** | 172 | /** |
169 | * The TESTING system associated with this peer | 173 | * The TESTING system associated with this peer |
170 | */ | 174 | */ |
@@ -245,56 +249,56 @@ struct GNUNET_TESTING_Peer { | |||
245 | * @return #GNUNET_OK on success; #GNUNET_SYSERR on error | 249 | * @return #GNUNET_OK on success; #GNUNET_SYSERR on error |
246 | */ | 250 | */ |
247 | static int | 251 | static int |
248 | hostkeys_load(struct GNUNET_TESTING_System *system) | 252 | hostkeys_load (struct GNUNET_TESTING_System *system) |
249 | { | 253 | { |
250 | uint64_t fs; | 254 | uint64_t fs; |
251 | char *data_dir; | 255 | char *data_dir; |
252 | char *filename; | 256 | char *filename; |
253 | struct GNUNET_DISK_FileHandle *fd; | 257 | struct GNUNET_DISK_FileHandle *fd; |
254 | 258 | ||
255 | GNUNET_assert(NULL == system->hostkeys_data); | 259 | GNUNET_assert (NULL == system->hostkeys_data); |
256 | data_dir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR); | 260 | data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR); |
257 | GNUNET_asprintf(&filename, "%s/testing_hostkeys.ecc", data_dir); | 261 | GNUNET_asprintf (&filename, "%s/testing_hostkeys.ecc", data_dir); |
258 | GNUNET_free(data_dir); | 262 | GNUNET_free (data_dir); |
259 | 263 | ||
260 | if (GNUNET_YES != GNUNET_DISK_file_test(filename)) | 264 | if (GNUNET_YES != GNUNET_DISK_file_test (filename)) |
261 | { | 265 | { |
262 | LOG(GNUNET_ERROR_TYPE_ERROR, | 266 | LOG (GNUNET_ERROR_TYPE_ERROR, |
263 | _("Hostkeys file not found: %s\n"), | 267 | _ ("Hostkeys file not found: %s\n"), |
264 | filename); | 268 | filename); |
265 | GNUNET_free(filename); | 269 | GNUNET_free (filename); |
266 | return GNUNET_SYSERR; | 270 | return GNUNET_SYSERR; |
267 | } | 271 | } |
268 | /* Check hostkey file size, read entire thing into memory */ | 272 | /* Check hostkey file size, read entire thing into memory */ |
269 | if (GNUNET_OK != | 273 | if (GNUNET_OK != |
270 | GNUNET_DISK_file_size(filename, &fs, GNUNET_YES, GNUNET_YES)) | 274 | GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES)) |
271 | fs = 0; | 275 | fs = 0; |
272 | if (0 == fs) | 276 | if (0 == fs) |
273 | { | 277 | { |
274 | GNUNET_free(filename); | 278 | GNUNET_free (filename); |
275 | return GNUNET_SYSERR; /* File is empty */ | 279 | return GNUNET_SYSERR; /* File is empty */ |
276 | } | 280 | } |
277 | if (0 != (fs % GNUNET_TESTING_HOSTKEYFILESIZE)) | 281 | if (0 != (fs % GNUNET_TESTING_HOSTKEYFILESIZE)) |
278 | { | 282 | { |
279 | LOG(GNUNET_ERROR_TYPE_ERROR, | 283 | LOG (GNUNET_ERROR_TYPE_ERROR, |
280 | _("Incorrect hostkey file format: %s\n"), | 284 | _ ("Incorrect hostkey file format: %s\n"), |
281 | filename); | 285 | filename); |
282 | GNUNET_free(filename); | 286 | GNUNET_free (filename); |
283 | return GNUNET_SYSERR; | 287 | return GNUNET_SYSERR; |
284 | } | 288 | } |
285 | fd = GNUNET_DISK_file_open(filename, | 289 | fd = GNUNET_DISK_file_open (filename, |
286 | GNUNET_DISK_OPEN_READ, | 290 | GNUNET_DISK_OPEN_READ, |
287 | GNUNET_DISK_PERM_NONE); | 291 | GNUNET_DISK_PERM_NONE); |
288 | if (NULL == fd) | 292 | if (NULL == fd) |
289 | { | 293 | { |
290 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", filename); | 294 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename); |
291 | GNUNET_free(filename); | 295 | GNUNET_free (filename); |
292 | return GNUNET_SYSERR; | 296 | return GNUNET_SYSERR; |
293 | } | 297 | } |
294 | GNUNET_free(filename); | 298 | GNUNET_free (filename); |
295 | system->hostkeys_data = | 299 | system->hostkeys_data = |
296 | GNUNET_DISK_file_map(fd, &system->map, GNUNET_DISK_MAP_TYPE_READ, fs); | 300 | GNUNET_DISK_file_map (fd, &system->map, GNUNET_DISK_MAP_TYPE_READ, fs); |
297 | GNUNET_DISK_file_close(fd); | 301 | GNUNET_DISK_file_close (fd); |
298 | if (NULL == system->hostkeys_data) | 302 | if (NULL == system->hostkeys_data) |
299 | return GNUNET_SYSERR; | 303 | return GNUNET_SYSERR; |
300 | system->total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE; | 304 | system->total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE; |
@@ -308,11 +312,11 @@ hostkeys_load(struct GNUNET_TESTING_System *system) | |||
308 | * @param system the testing system handle | 312 | * @param system the testing system handle |
309 | */ | 313 | */ |
310 | static void | 314 | static void |
311 | hostkeys_unload(struct GNUNET_TESTING_System *system) | 315 | hostkeys_unload (struct GNUNET_TESTING_System *system) |
312 | { | 316 | { |
313 | GNUNET_break(NULL != system->hostkeys_data); | 317 | GNUNET_break (NULL != system->hostkeys_data); |
314 | system->hostkeys_data = NULL; | 318 | system->hostkeys_data = NULL; |
315 | GNUNET_DISK_file_unmap(system->map); | 319 | GNUNET_DISK_file_unmap (system->map); |
316 | system->map = NULL; | 320 | system->map = NULL; |
317 | system->hostkeys_data = NULL; | 321 | system->hostkeys_data = NULL; |
318 | system->total_hostkeys = 0; | 322 | system->total_hostkeys = 0; |
@@ -328,14 +332,14 @@ hostkeys_unload(struct GNUNET_TESTING_System *system) | |||
328 | * @param value value of the option | 332 | * @param value value of the option |
329 | */ | 333 | */ |
330 | static void | 334 | static void |
331 | cfg_copy_iterator(void *cls, | 335 | cfg_copy_iterator (void *cls, |
332 | const char *section, | 336 | const char *section, |
333 | const char *option, | 337 | const char *option, |
334 | const char *value) | 338 | const char *value) |
335 | { | 339 | { |
336 | struct GNUNET_CONFIGURATION_Handle *cfg2 = cls; | 340 | struct GNUNET_CONFIGURATION_Handle *cfg2 = cls; |
337 | 341 | ||
338 | GNUNET_CONFIGURATION_set_value_string(cfg2, section, option, value); | 342 | GNUNET_CONFIGURATION_set_value_string (cfg2, section, option, value); |
339 | } | 343 | } |
340 | 344 | ||
341 | 345 | ||
@@ -361,7 +365,7 @@ cfg_copy_iterator(void *cls, | |||
361 | * @return handle to this system, NULL on error | 365 | * @return handle to this system, NULL on error |
362 | */ | 366 | */ |
363 | struct GNUNET_TESTING_System * | 367 | struct GNUNET_TESTING_System * |
364 | GNUNET_TESTING_system_create_with_portrange( | 368 | GNUNET_TESTING_system_create_with_portrange ( |
365 | const char *testdir, | 369 | const char *testdir, |
366 | const char *trusted_ip, | 370 | const char *trusted_ip, |
367 | const char *hostname, | 371 | const char *hostname, |
@@ -374,53 +378,53 @@ GNUNET_TESTING_system_create_with_portrange( | |||
374 | struct SharedService *ss; | 378 | struct SharedService *ss; |
375 | unsigned int cnt; | 379 | unsigned int cnt; |
376 | 380 | ||
377 | GNUNET_assert(NULL != testdir); | 381 | GNUNET_assert (NULL != testdir); |
378 | system = GNUNET_new(struct GNUNET_TESTING_System); | 382 | system = GNUNET_new (struct GNUNET_TESTING_System); |
379 | if (NULL == (system->tmppath = getenv(GNUNET_TESTING_PREFIX))) | 383 | if (NULL == (system->tmppath = getenv (GNUNET_TESTING_PREFIX))) |
380 | system->tmppath = GNUNET_DISK_mkdtemp(testdir); | 384 | system->tmppath = GNUNET_DISK_mkdtemp (testdir); |
381 | else | 385 | else |
382 | system->tmppath = GNUNET_strdup(system->tmppath); | 386 | system->tmppath = GNUNET_strdup (system->tmppath); |
383 | system->lowport = lowport; | 387 | system->lowport = lowport; |
384 | system->highport = highport; | 388 | system->highport = highport; |
385 | if (NULL == system->tmppath) | 389 | if (NULL == system->tmppath) |
386 | { | 390 | { |
387 | GNUNET_free(system); | 391 | GNUNET_free (system); |
388 | return NULL; | 392 | return NULL; |
389 | } | 393 | } |
390 | if (NULL != trusted_ip) | 394 | if (NULL != trusted_ip) |
391 | system->trusted_ip = GNUNET_strdup(trusted_ip); | 395 | system->trusted_ip = GNUNET_strdup (trusted_ip); |
392 | if (NULL != hostname) | 396 | if (NULL != hostname) |
393 | system->hostname = GNUNET_strdup(hostname); | 397 | system->hostname = GNUNET_strdup (hostname); |
394 | if (GNUNET_OK != hostkeys_load(system)) | 398 | if (GNUNET_OK != hostkeys_load (system)) |
395 | { | 399 | { |
396 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 400 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
397 | return NULL; | 401 | return NULL; |
398 | } | 402 | } |
399 | if (NULL == shared_services) | 403 | if (NULL == shared_services) |
400 | return system; | 404 | return system; |
401 | for (cnt = 0; NULL != shared_services[cnt].service; cnt++) | 405 | for (cnt = 0; NULL != shared_services[cnt].service; cnt++) |
402 | { | 406 | { |
403 | tss = shared_services[cnt]; | 407 | tss = shared_services[cnt]; |
404 | ss = GNUNET_new(struct SharedService); | 408 | ss = GNUNET_new (struct SharedService); |
405 | ss->sname = GNUNET_strdup(tss.service); | 409 | ss->sname = GNUNET_strdup (tss.service); |
406 | ss->cfg = GNUNET_CONFIGURATION_create(); | 410 | ss->cfg = GNUNET_CONFIGURATION_create (); |
407 | GNUNET_CONFIGURATION_iterate_section_values(tss.cfg, | 411 | GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, |
408 | ss->sname, | 412 | ss->sname, |
409 | &cfg_copy_iterator, | 413 | &cfg_copy_iterator, |
410 | ss->cfg); | 414 | ss->cfg); |
411 | GNUNET_CONFIGURATION_iterate_section_values(tss.cfg, | 415 | GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, |
412 | "TESTING", | 416 | "TESTING", |
413 | &cfg_copy_iterator, | 417 | &cfg_copy_iterator, |
414 | ss->cfg); | 418 | ss->cfg); |
415 | GNUNET_CONFIGURATION_iterate_section_values(tss.cfg, | 419 | GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, |
416 | "PATHS", | 420 | "PATHS", |
417 | &cfg_copy_iterator, | 421 | &cfg_copy_iterator, |
418 | ss->cfg); | 422 | ss->cfg); |
419 | ss->share = tss.share; | 423 | ss->share = tss.share; |
420 | GNUNET_array_append(system->shared_services, | 424 | GNUNET_array_append (system->shared_services, |
421 | system->n_shared_services, | 425 | system->n_shared_services, |
422 | ss); | 426 | ss); |
423 | } | 427 | } |
424 | return system; | 428 | return system; |
425 | } | 429 | } |
426 | 430 | ||
@@ -446,59 +450,59 @@ GNUNET_TESTING_system_create_with_portrange( | |||
446 | * @return handle to this system, NULL on error | 450 | * @return handle to this system, NULL on error |
447 | */ | 451 | */ |
448 | struct GNUNET_TESTING_System * | 452 | struct GNUNET_TESTING_System * |
449 | GNUNET_TESTING_system_create( | 453 | GNUNET_TESTING_system_create ( |
450 | const char *testdir, | 454 | const char *testdir, |
451 | const char *trusted_ip, | 455 | const char *trusted_ip, |
452 | const char *hostname, | 456 | const char *hostname, |
453 | const struct GNUNET_TESTING_SharedService *shared_services) | 457 | const struct GNUNET_TESTING_SharedService *shared_services) |
454 | { | 458 | { |
455 | return GNUNET_TESTING_system_create_with_portrange(testdir, | 459 | return GNUNET_TESTING_system_create_with_portrange (testdir, |
456 | trusted_ip, | 460 | trusted_ip, |
457 | hostname, | 461 | hostname, |
458 | shared_services, | 462 | shared_services, |
459 | LOW_PORT, | 463 | LOW_PORT, |
460 | HIGH_PORT); | 464 | HIGH_PORT); |
461 | } | 465 | } |
462 | 466 | ||
463 | 467 | ||
464 | static void | 468 | static void |
465 | cleanup_shared_service_instance(struct SharedServiceInstance *i) | 469 | cleanup_shared_service_instance (struct SharedServiceInstance *i) |
466 | { | 470 | { |
467 | if (NULL != i->cfg_fn) | 471 | if (NULL != i->cfg_fn) |
468 | { | 472 | { |
469 | (void)unlink(i->cfg_fn); | 473 | (void) unlink (i->cfg_fn); |
470 | GNUNET_free(i->cfg_fn); | 474 | GNUNET_free (i->cfg_fn); |
471 | } | 475 | } |
472 | GNUNET_free_non_null(i->unix_sock); | 476 | GNUNET_free_non_null (i->unix_sock); |
473 | GNUNET_free_non_null(i->port_str); | 477 | GNUNET_free_non_null (i->port_str); |
474 | GNUNET_break(NULL == i->proc); | 478 | GNUNET_break (NULL == i->proc); |
475 | GNUNET_break(0 == i->n_refs); | 479 | GNUNET_break (0 == i->n_refs); |
476 | GNUNET_free(i); | 480 | GNUNET_free (i); |
477 | } | 481 | } |
478 | 482 | ||
479 | 483 | ||
480 | static int | 484 | static int |
481 | start_shared_service_instance(struct SharedServiceInstance *i) | 485 | start_shared_service_instance (struct SharedServiceInstance *i) |
482 | { | 486 | { |
483 | char *binary; | 487 | char *binary; |
484 | char *libexec_binary; | 488 | char *libexec_binary; |
485 | 489 | ||
486 | GNUNET_assert(NULL == i->proc); | 490 | GNUNET_assert (NULL == i->proc); |
487 | GNUNET_assert(NULL != i->cfg_fn); | 491 | GNUNET_assert (NULL != i->cfg_fn); |
488 | (void)GNUNET_asprintf(&binary, "gnunet-service-%s", i->ss->sname); | 492 | (void) GNUNET_asprintf (&binary, "gnunet-service-%s", i->ss->sname); |
489 | libexec_binary = GNUNET_OS_get_libexec_binary_path(binary); | 493 | libexec_binary = GNUNET_OS_get_libexec_binary_path (binary); |
490 | GNUNET_free(binary); | 494 | GNUNET_free (binary); |
491 | i->proc = GNUNET_OS_start_process(PIPE_CONTROL, | 495 | i->proc = GNUNET_OS_start_process (PIPE_CONTROL, |
492 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 496 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
493 | NULL, | 497 | NULL, |
494 | NULL, | 498 | NULL, |
495 | NULL, | 499 | NULL, |
496 | libexec_binary, | 500 | libexec_binary, |
497 | libexec_binary, | 501 | libexec_binary, |
498 | "-c", | 502 | "-c", |
499 | i->cfg_fn, | 503 | i->cfg_fn, |
500 | NULL); | 504 | NULL); |
501 | GNUNET_free(libexec_binary); | 505 | GNUNET_free (libexec_binary); |
502 | if (NULL == i->proc) | 506 | if (NULL == i->proc) |
503 | return GNUNET_SYSERR; | 507 | return GNUNET_SYSERR; |
504 | return GNUNET_OK; | 508 | return GNUNET_OK; |
@@ -506,15 +510,15 @@ start_shared_service_instance(struct SharedServiceInstance *i) | |||
506 | 510 | ||
507 | 511 | ||
508 | static void | 512 | static void |
509 | stop_shared_service_instance(struct SharedServiceInstance *i) | 513 | stop_shared_service_instance (struct SharedServiceInstance *i) |
510 | { | 514 | { |
511 | GNUNET_break(0 == i->n_refs); | 515 | GNUNET_break (0 == i->n_refs); |
512 | if (0 != GNUNET_OS_process_kill(i->proc, GNUNET_TERM_SIG)) | 516 | if (0 != GNUNET_OS_process_kill (i->proc, GNUNET_TERM_SIG)) |
513 | LOG(GNUNET_ERROR_TYPE_WARNING, | 517 | LOG (GNUNET_ERROR_TYPE_WARNING, |
514 | "Killing shared service instance (%s) failed\n", | 518 | "Killing shared service instance (%s) failed\n", |
515 | i->ss->sname); | 519 | i->ss->sname); |
516 | (void)GNUNET_OS_process_wait(i->proc); | 520 | (void) GNUNET_OS_process_wait (i->proc); |
517 | GNUNET_OS_process_destroy(i->proc); | 521 | GNUNET_OS_process_destroy (i->proc); |
518 | i->proc = NULL; | 522 | i->proc = NULL; |
519 | } | 523 | } |
520 | 524 | ||
@@ -527,8 +531,8 @@ stop_shared_service_instance(struct SharedServiceInstance *i) | |||
527 | * be removed (clean up on shutdown)? | 531 | * be removed (clean up on shutdown)? |
528 | */ | 532 | */ |
529 | void | 533 | void |
530 | GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, | 534 | GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system, |
531 | int remove_paths) | 535 | int remove_paths) |
532 | { | 536 | { |
533 | struct SharedService *ss; | 537 | struct SharedService *ss; |
534 | struct SharedServiceInstance *i; | 538 | struct SharedServiceInstance *i; |
@@ -536,29 +540,29 @@ GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, | |||
536 | unsigned int i_cnt; | 540 | unsigned int i_cnt; |
537 | 541 | ||
538 | if (NULL != system->hostkeys_data) | 542 | if (NULL != system->hostkeys_data) |
539 | hostkeys_unload(system); | 543 | hostkeys_unload (system); |
540 | for (ss_cnt = 0; ss_cnt < system->n_shared_services; ss_cnt++) | 544 | for (ss_cnt = 0; ss_cnt < system->n_shared_services; ss_cnt++) |
545 | { | ||
546 | ss = system->shared_services[ss_cnt]; | ||
547 | for (i_cnt = 0; i_cnt < ss->n_instances; i_cnt++) | ||
541 | { | 548 | { |
542 | ss = system->shared_services[ss_cnt]; | 549 | i = ss->instances[i_cnt]; |
543 | for (i_cnt = 0; i_cnt < ss->n_instances; i_cnt++) | 550 | if (NULL != i->proc) |
544 | { | 551 | stop_shared_service_instance (i); |
545 | i = ss->instances[i_cnt]; | 552 | cleanup_shared_service_instance (i); |
546 | if (NULL != i->proc) | ||
547 | stop_shared_service_instance(i); | ||
548 | cleanup_shared_service_instance(i); | ||
549 | } | ||
550 | GNUNET_free_non_null(ss->instances); | ||
551 | GNUNET_CONFIGURATION_destroy(ss->cfg); | ||
552 | GNUNET_free(ss->sname); | ||
553 | GNUNET_free(ss); | ||
554 | } | 553 | } |
555 | GNUNET_free_non_null(system->shared_services); | 554 | GNUNET_free_non_null (ss->instances); |
555 | GNUNET_CONFIGURATION_destroy (ss->cfg); | ||
556 | GNUNET_free (ss->sname); | ||
557 | GNUNET_free (ss); | ||
558 | } | ||
559 | GNUNET_free_non_null (system->shared_services); | ||
556 | if (GNUNET_YES == remove_paths) | 560 | if (GNUNET_YES == remove_paths) |
557 | GNUNET_DISK_directory_remove(system->tmppath); | 561 | GNUNET_DISK_directory_remove (system->tmppath); |
558 | GNUNET_free(system->tmppath); | 562 | GNUNET_free (system->tmppath); |
559 | GNUNET_free_non_null(system->trusted_ip); | 563 | GNUNET_free_non_null (system->trusted_ip); |
560 | GNUNET_free_non_null(system->hostname); | 564 | GNUNET_free_non_null (system->hostname); |
561 | GNUNET_free(system); | 565 | GNUNET_free (system); |
562 | } | 566 | } |
563 | 567 | ||
564 | 568 | ||
@@ -569,7 +573,7 @@ GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, | |||
569 | * @return 0 if no free port was available | 573 | * @return 0 if no free port was available |
570 | */ | 574 | */ |
571 | uint16_t | 575 | uint16_t |
572 | GNUNET_TESTING_reserve_port(struct GNUNET_TESTING_System *system) | 576 | GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system) |
573 | { | 577 | { |
574 | struct GNUNET_NETWORK_Handle *socket; | 578 | struct GNUNET_NETWORK_Handle *socket; |
575 | struct addrinfo hint; | 579 | struct addrinfo hint; |
@@ -603,57 +607,57 @@ GNUNET_TESTING_reserve_port(struct GNUNET_TESTING_System *system) | |||
603 | port_buckets = system->reserved_ports; | 607 | port_buckets = system->reserved_ports; |
604 | for (index = (system->lowport / 32) + 1; index < (system->highport / 32); | 608 | for (index = (system->lowport / 32) + 1; index < (system->highport / 32); |
605 | index++) | 609 | index++) |
610 | { | ||
611 | xor_image = (UINT32_MAX ^ port_buckets[index]); | ||
612 | if (0 == xor_image) /* Ports in the bucket are full */ | ||
613 | continue; | ||
614 | pos = system->lowport % 32; | ||
615 | while (pos < 32) | ||
606 | { | 616 | { |
607 | xor_image = (UINT32_MAX ^ port_buckets[index]); | 617 | if (0 == ((xor_image >> pos) & 1U)) |
608 | if (0 == xor_image) /* Ports in the bucket are full */ | 618 | { |
619 | pos++; | ||
609 | continue; | 620 | continue; |
610 | pos = system->lowport % 32; | 621 | } |
611 | while (pos < 32) | 622 | open_port = (index * 32) + pos; |
612 | { | 623 | if (open_port >= system->highport) |
613 | if (0 == ((xor_image >> pos) & 1U)) | 624 | return 0; |
614 | { | 625 | GNUNET_asprintf (&open_port_str, "%u", (unsigned int) open_port); |
615 | pos++; | 626 | ret = NULL; |
616 | continue; | 627 | GNUNET_assert (0 == getaddrinfo (NULL, open_port_str, &hint, &ret)); |
617 | } | 628 | GNUNET_free (open_port_str); |
618 | open_port = (index * 32) + pos; | 629 | bind_status = GNUNET_NO; |
619 | if (open_port >= system->highport) | 630 | for (ai = ret; NULL != ai; ai = ai->ai_next) |
620 | return 0; | 631 | { |
621 | GNUNET_asprintf(&open_port_str, "%u", (unsigned int)open_port); | 632 | socket = GNUNET_NETWORK_socket_create (ai->ai_family, SOCK_STREAM, 0); |
622 | ret = NULL; | 633 | if (NULL == socket) |
623 | GNUNET_assert(0 == getaddrinfo(NULL, open_port_str, &hint, &ret)); | 634 | continue; |
624 | GNUNET_free(open_port_str); | 635 | bind_status = |
625 | bind_status = GNUNET_NO; | 636 | GNUNET_NETWORK_socket_bind (socket, ai->ai_addr, ai->ai_addrlen); |
626 | for (ai = ret; NULL != ai; ai = ai->ai_next) | 637 | GNUNET_NETWORK_socket_close (socket); |
627 | { | 638 | if (GNUNET_OK != bind_status) |
628 | socket = GNUNET_NETWORK_socket_create(ai->ai_family, SOCK_STREAM, 0); | 639 | break; |
629 | if (NULL == socket) | 640 | socket = GNUNET_NETWORK_socket_create (ai->ai_family, SOCK_DGRAM, 0); |
630 | continue; | 641 | if (NULL == socket) |
631 | bind_status = | 642 | continue; |
632 | GNUNET_NETWORK_socket_bind(socket, ai->ai_addr, ai->ai_addrlen); | 643 | bind_status = |
633 | GNUNET_NETWORK_socket_close(socket); | 644 | GNUNET_NETWORK_socket_bind (socket, ai->ai_addr, ai->ai_addrlen); |
634 | if (GNUNET_OK != bind_status) | 645 | GNUNET_NETWORK_socket_close (socket); |
635 | break; | 646 | if (GNUNET_OK != bind_status) |
636 | socket = GNUNET_NETWORK_socket_create(ai->ai_family, SOCK_DGRAM, 0); | 647 | break; |
637 | if (NULL == socket) | 648 | } |
638 | continue; | 649 | port_buckets[index] |= (1U << pos); /* Set the port bit */ |
639 | bind_status = | 650 | freeaddrinfo (ret); |
640 | GNUNET_NETWORK_socket_bind(socket, ai->ai_addr, ai->ai_addrlen); | 651 | if (GNUNET_OK == bind_status) |
641 | GNUNET_NETWORK_socket_close(socket); | 652 | { |
642 | if (GNUNET_OK != bind_status) | 653 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
643 | break; | 654 | "Found a free port %u\n", |
644 | } | 655 | (unsigned int) open_port); |
645 | port_buckets[index] |= (1U << pos); /* Set the port bit */ | 656 | return open_port; |
646 | freeaddrinfo(ret); | 657 | } |
647 | if (GNUNET_OK == bind_status) | 658 | pos++; |
648 | { | ||
649 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
650 | "Found a free port %u\n", | ||
651 | (unsigned int)open_port); | ||
652 | return open_port; | ||
653 | } | ||
654 | pos++; | ||
655 | } | ||
656 | } | 659 | } |
660 | } | ||
657 | return 0; | 661 | return 0; |
658 | } | 662 | } |
659 | 663 | ||
@@ -666,8 +670,8 @@ GNUNET_TESTING_reserve_port(struct GNUNET_TESTING_System *system) | |||
666 | * @param port reserved port to release | 670 | * @param port reserved port to release |
667 | */ | 671 | */ |
668 | void | 672 | void |
669 | GNUNET_TESTING_release_port(struct GNUNET_TESTING_System *system, | 673 | GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system, |
670 | uint16_t port) | 674 | uint16_t port) |
671 | { | 675 | { |
672 | uint32_t *port_buckets; | 676 | uint32_t *port_buckets; |
673 | uint16_t bucket; | 677 | uint16_t bucket; |
@@ -676,12 +680,12 @@ GNUNET_TESTING_release_port(struct GNUNET_TESTING_System *system, | |||
676 | port_buckets = system->reserved_ports; | 680 | port_buckets = system->reserved_ports; |
677 | bucket = port / 32; | 681 | bucket = port / 32; |
678 | pos = port % 32; | 682 | pos = port % 32; |
679 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Releasing port %u\n", port); | 683 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Releasing port %u\n", port); |
680 | if (0 == (port_buckets[bucket] & (1U << pos))) | 684 | if (0 == (port_buckets[bucket] & (1U << pos))) |
681 | { | 685 | { |
682 | GNUNET_break(0); /* Port was not reserved by us using reserve_port() */ | 686 | GNUNET_break (0); /* Port was not reserved by us using reserve_port() */ |
683 | return; | 687 | return; |
684 | } | 688 | } |
685 | port_buckets[bucket] &= ~(1U << pos); | 689 | port_buckets[bucket] &= ~(1U << pos); |
686 | } | 690 | } |
687 | 691 | ||
@@ -704,27 +708,27 @@ GNUNET_TESTING_release_port(struct GNUNET_TESTING_System *system, | |||
704 | * @return NULL on error (not enough keys) | 708 | * @return NULL on error (not enough keys) |
705 | */ | 709 | */ |
706 | struct GNUNET_CRYPTO_EddsaPrivateKey * | 710 | struct GNUNET_CRYPTO_EddsaPrivateKey * |
707 | GNUNET_TESTING_hostkey_get(const struct GNUNET_TESTING_System *system, | 711 | GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system, |
708 | uint32_t key_number, | 712 | uint32_t key_number, |
709 | struct GNUNET_PeerIdentity *id) | 713 | struct GNUNET_PeerIdentity *id) |
710 | { | 714 | { |
711 | struct GNUNET_CRYPTO_EddsaPrivateKey *private_key; | 715 | struct GNUNET_CRYPTO_EddsaPrivateKey *private_key; |
712 | 716 | ||
713 | if ((NULL == id) || (NULL == system->hostkeys_data)) | 717 | if ((NULL == id) || (NULL == system->hostkeys_data)) |
714 | return NULL; | 718 | return NULL; |
715 | if (key_number >= system->total_hostkeys) | 719 | if (key_number >= system->total_hostkeys) |
716 | { | 720 | { |
717 | LOG(GNUNET_ERROR_TYPE_ERROR, | 721 | LOG (GNUNET_ERROR_TYPE_ERROR, |
718 | _("Key number %u does not exist\n"), | 722 | _ ("Key number %u does not exist\n"), |
719 | key_number); | 723 | key_number); |
720 | return NULL; | 724 | return NULL; |
721 | } | 725 | } |
722 | private_key = GNUNET_new(struct GNUNET_CRYPTO_EddsaPrivateKey); | 726 | private_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey); |
723 | GNUNET_memcpy(private_key, | 727 | GNUNET_memcpy (private_key, |
724 | system->hostkeys_data + | 728 | system->hostkeys_data |
725 | (key_number * GNUNET_TESTING_HOSTKEYFILESIZE), | 729 | + (key_number * GNUNET_TESTING_HOSTKEYFILESIZE), |
726 | GNUNET_TESTING_HOSTKEYFILESIZE); | 730 | GNUNET_TESTING_HOSTKEYFILESIZE); |
727 | GNUNET_CRYPTO_eddsa_key_get_public(private_key, &id->public_key); | 731 | GNUNET_CRYPTO_eddsa_key_get_public (private_key, &id->public_key); |
728 | return private_key; | 732 | return private_key; |
729 | } | 733 | } |
730 | 734 | ||
@@ -733,7 +737,8 @@ GNUNET_TESTING_hostkey_get(const struct GNUNET_TESTING_System *system, | |||
733 | * Structure for holding data to build new configurations from a configuration | 737 | * Structure for holding data to build new configurations from a configuration |
734 | * template | 738 | * template |
735 | */ | 739 | */ |
736 | struct UpdateContext { | 740 | struct UpdateContext |
741 | { | ||
737 | /** | 742 | /** |
738 | * The system for which we are building configurations | 743 | * The system for which we are building configurations |
739 | */ | 744 | */ |
@@ -779,10 +784,10 @@ struct UpdateContext { | |||
779 | * @param value value of the option | 784 | * @param value value of the option |
780 | */ | 785 | */ |
781 | static void | 786 | static void |
782 | update_config(void *cls, | 787 | update_config (void *cls, |
783 | const char *section, | 788 | const char *section, |
784 | const char *option, | 789 | const char *option, |
785 | const char *value) | 790 | const char *value) |
786 | { | 791 | { |
787 | struct UpdateContext *uc = cls; | 792 | struct UpdateContext *uc = cls; |
788 | unsigned int ival; | 793 | unsigned int ival; |
@@ -795,76 +800,76 @@ update_config(void *cls, | |||
795 | 800 | ||
796 | if (GNUNET_OK != uc->status) | 801 | if (GNUNET_OK != uc->status) |
797 | return; | 802 | return; |
798 | if (!((0 == strcmp(option, "PORT")) || (0 == strcmp(option, "UNIXPATH")) || | 803 | if (! ((0 == strcmp (option, "PORT")) || (0 == strcmp (option, "UNIXPATH")) || |
799 | (0 == strcmp(option, "HOSTNAME")))) | 804 | (0 == strcmp (option, "HOSTNAME")))) |
800 | return; | 805 | return; |
801 | GNUNET_asprintf(&single_variable, "single_%s_per_host", section); | 806 | GNUNET_asprintf (&single_variable, "single_%s_per_host", section); |
802 | GNUNET_asprintf(&per_host_variable, "num_%s_per_host", section); | 807 | GNUNET_asprintf (&per_host_variable, "num_%s_per_host", section); |
803 | if ((0 == strcmp(option, "PORT")) && (1 == sscanf(value, "%u", &ival))) | 808 | if ((0 == strcmp (option, "PORT")) && (1 == sscanf (value, "%u", &ival))) |
809 | { | ||
810 | if ((ival != 0) && | ||
811 | (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, | ||
812 | "testing", | ||
813 | single_variable))) | ||
804 | { | 814 | { |
805 | if ((ival != 0) && | 815 | new_port = GNUNET_TESTING_reserve_port (uc->system); |
806 | (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno(uc->cfg, | 816 | if (0 == new_port) |
807 | "testing", | 817 | { |
808 | single_variable))) | 818 | uc->status = GNUNET_SYSERR; |
809 | { | 819 | GNUNET_free (single_variable); |
810 | new_port = GNUNET_TESTING_reserve_port(uc->system); | 820 | GNUNET_free (per_host_variable); |
811 | if (0 == new_port) | 821 | return; |
812 | { | 822 | } |
813 | uc->status = GNUNET_SYSERR; | 823 | GNUNET_snprintf (cval, sizeof(cval), "%u", new_port); |
814 | GNUNET_free(single_variable); | 824 | value = cval; |
815 | GNUNET_free(per_host_variable); | 825 | GNUNET_array_append (uc->ports, uc->nports, new_port); |
816 | return; | ||
817 | } | ||
818 | GNUNET_snprintf(cval, sizeof(cval), "%u", new_port); | ||
819 | value = cval; | ||
820 | GNUNET_array_append(uc->ports, uc->nports, new_port); | ||
821 | } | ||
822 | else if ((ival != 0) && | ||
823 | (GNUNET_YES == | ||
824 | GNUNET_CONFIGURATION_get_value_yesno(uc->cfg, | ||
825 | "testing", | ||
826 | single_variable)) && | ||
827 | GNUNET_CONFIGURATION_get_value_number(uc->cfg, | ||
828 | "testing", | ||
829 | per_host_variable, | ||
830 | &num_per_host)) | ||
831 | { | ||
832 | /* GNUNET_snprintf (cval, sizeof (cval), "%u", */ | ||
833 | /* ival + ctx->fdnum % num_per_host); */ | ||
834 | /* value = cval; */ | ||
835 | GNUNET_break(0); /* FIXME */ | ||
836 | } | ||
837 | } | 826 | } |
838 | if (0 == strcmp(option, "UNIXPATH")) | 827 | else if ((ival != 0) && |
828 | (GNUNET_YES == | ||
829 | GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, | ||
830 | "testing", | ||
831 | single_variable)) && | ||
832 | GNUNET_CONFIGURATION_get_value_number (uc->cfg, | ||
833 | "testing", | ||
834 | per_host_variable, | ||
835 | &num_per_host)) | ||
839 | { | 836 | { |
840 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno(uc->cfg, | 837 | /* GNUNET_snprintf (cval, sizeof (cval), "%u", */ |
841 | "testing", | 838 | /* ival + ctx->fdnum % num_per_host); */ |
842 | single_variable)) | 839 | /* value = cval; */ |
843 | { | 840 | GNUNET_break (0); /* FIXME */ |
844 | GNUNET_snprintf(uval, | 841 | } |
845 | sizeof(uval), | 842 | } |
846 | "%s/%s.sock", | 843 | if (0 == strcmp (option, "UNIXPATH")) |
847 | uc->gnunet_home, | 844 | { |
848 | section); | 845 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, |
849 | value = uval; | 846 | "testing", |
850 | } | 847 | single_variable)) |
851 | else if ((GNUNET_YES == | 848 | { |
852 | GNUNET_CONFIGURATION_get_value_number(uc->cfg, | 849 | GNUNET_snprintf (uval, |
853 | "testing", | 850 | sizeof(uval), |
854 | per_host_variable, | 851 | "%s/%s.sock", |
855 | &num_per_host)) && | 852 | uc->gnunet_home, |
856 | (num_per_host > 0)) | 853 | section); |
857 | { | 854 | value = uval; |
858 | GNUNET_break(0); /* FIXME */ | ||
859 | } | ||
860 | } | 855 | } |
861 | if (0 == strcmp(option, "HOSTNAME")) | 856 | else if ((GNUNET_YES == |
857 | GNUNET_CONFIGURATION_get_value_number (uc->cfg, | ||
858 | "testing", | ||
859 | per_host_variable, | ||
860 | &num_per_host)) && | ||
861 | (num_per_host > 0)) | ||
862 | { | 862 | { |
863 | value = (NULL == uc->system->hostname) ? "localhost" : uc->system->hostname; | 863 | GNUNET_break (0); /* FIXME */ |
864 | } | 864 | } |
865 | GNUNET_free(single_variable); | 865 | } |
866 | GNUNET_free(per_host_variable); | 866 | if (0 == strcmp (option, "HOSTNAME")) |
867 | GNUNET_CONFIGURATION_set_value_string(uc->cfg, section, option, value); | 867 | { |
868 | value = (NULL == uc->system->hostname) ? "localhost" : uc->system->hostname; | ||
869 | } | ||
870 | GNUNET_free (single_variable); | ||
871 | GNUNET_free (per_host_variable); | ||
872 | GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, option, value); | ||
868 | } | 873 | } |
869 | 874 | ||
870 | 875 | ||
@@ -876,7 +881,7 @@ update_config(void *cls, | |||
876 | * @param section name of the section | 881 | * @param section name of the section |
877 | */ | 882 | */ |
878 | static void | 883 | static void |
879 | update_config_sections(void *cls, const char *section) | 884 | update_config_sections (void *cls, const char *section) |
880 | { | 885 | { |
881 | struct UpdateContext *uc = cls; | 886 | struct UpdateContext *uc = cls; |
882 | char **ikeys; | 887 | char **ikeys; |
@@ -893,98 +898,98 @@ update_config_sections(void *cls, const char *section) | |||
893 | /* Ignore certain options from sections. See | 898 | /* Ignore certain options from sections. See |
894 | https://gnunet.org/bugs/view.php?id=2476 */ | 899 | https://gnunet.org/bugs/view.php?id=2476 */ |
895 | if (GNUNET_YES == | 900 | if (GNUNET_YES == |
896 | GNUNET_CONFIGURATION_have_value(uc->cfg, section, "TESTING_IGNORE_KEYS")) | 901 | GNUNET_CONFIGURATION_have_value (uc->cfg, section, "TESTING_IGNORE_KEYS")) |
897 | { | 902 | { |
898 | GNUNET_assert(GNUNET_YES == | 903 | GNUNET_assert (GNUNET_YES == |
899 | GNUNET_CONFIGURATION_get_value_string(uc->cfg, | 904 | GNUNET_CONFIGURATION_get_value_string (uc->cfg, |
900 | section, | 905 | section, |
901 | "TESTING_IGNORE_KEYS", | 906 | "TESTING_IGNORE_KEYS", |
902 | &val)); | 907 | &val)); |
908 | ptr = val; | ||
909 | for (ikeys_cnt = 0; NULL != (ptr = strstr (ptr, ";")); ikeys_cnt++) | ||
910 | ptr++; | ||
911 | if (0 == ikeys_cnt) | ||
912 | GNUNET_break (0); | ||
913 | else | ||
914 | { | ||
915 | ikeys = GNUNET_malloc ((sizeof(char *)) * ikeys_cnt); | ||
903 | ptr = val; | 916 | ptr = val; |
904 | for (ikeys_cnt = 0; NULL != (ptr = strstr(ptr, ";")); ikeys_cnt++) | 917 | for (key = 0; key < ikeys_cnt; key++) |
918 | { | ||
919 | ikeys[key] = ptr; | ||
920 | ptr = strstr (ptr, ";"); | ||
921 | GNUNET_assert (NULL != ptr); /* worked just before... */ | ||
922 | *ptr = '\0'; | ||
905 | ptr++; | 923 | ptr++; |
906 | if (0 == ikeys_cnt) | 924 | } |
907 | GNUNET_break(0); | ||
908 | else | ||
909 | { | ||
910 | ikeys = GNUNET_malloc((sizeof(char *)) * ikeys_cnt); | ||
911 | ptr = val; | ||
912 | for (key = 0; key < ikeys_cnt; key++) | ||
913 | { | ||
914 | ikeys[key] = ptr; | ||
915 | ptr = strstr(ptr, ";"); | ||
916 | GNUNET_assert(NULL != ptr); /* worked just before... */ | ||
917 | *ptr = '\0'; | ||
918 | ptr++; | ||
919 | } | ||
920 | } | ||
921 | } | 925 | } |
926 | } | ||
922 | if (0 != ikeys_cnt) | 927 | if (0 != ikeys_cnt) |
928 | { | ||
929 | for (key = 0; key < ikeys_cnt; key++) | ||
923 | { | 930 | { |
924 | for (key = 0; key < ikeys_cnt; key++) | 931 | if (NULL != strstr (ikeys[key], "ADVERTISED_PORT")) |
925 | { | 932 | break; |
926 | if (NULL != strstr(ikeys[key], "ADVERTISED_PORT")) | ||
927 | break; | ||
928 | } | ||
929 | if ((key == ikeys_cnt) && | ||
930 | (GNUNET_YES == | ||
931 | GNUNET_CONFIGURATION_have_value(uc->cfg, section, "ADVERTISED_PORT"))) | ||
932 | { | ||
933 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(uc->cfg, | ||
934 | section, | ||
935 | "PORT", | ||
936 | &ptr)) | ||
937 | { | ||
938 | GNUNET_CONFIGURATION_set_value_string(uc->cfg, | ||
939 | section, | ||
940 | "ADVERTISED_PORT", | ||
941 | ptr); | ||
942 | GNUNET_free(ptr); | ||
943 | } | ||
944 | } | ||
945 | for (key = 0; key < ikeys_cnt; key++) | ||
946 | { | ||
947 | if (NULL != strstr(ikeys[key], "ACCEPT_FROM")) | ||
948 | { | ||
949 | GNUNET_free(ikeys); | ||
950 | GNUNET_free(val); | ||
951 | return; | ||
952 | } | ||
953 | } | ||
954 | GNUNET_free(ikeys); | ||
955 | } | 933 | } |
956 | GNUNET_free_non_null(val); | 934 | if ((key == ikeys_cnt) && |
935 | (GNUNET_YES == | ||
936 | GNUNET_CONFIGURATION_have_value (uc->cfg, section, "ADVERTISED_PORT"))) | ||
937 | { | ||
938 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (uc->cfg, | ||
939 | section, | ||
940 | "PORT", | ||
941 | &ptr)) | ||
942 | { | ||
943 | GNUNET_CONFIGURATION_set_value_string (uc->cfg, | ||
944 | section, | ||
945 | "ADVERTISED_PORT", | ||
946 | ptr); | ||
947 | GNUNET_free (ptr); | ||
948 | } | ||
949 | } | ||
950 | for (key = 0; key < ikeys_cnt; key++) | ||
951 | { | ||
952 | if (NULL != strstr (ikeys[key], "ACCEPT_FROM")) | ||
953 | { | ||
954 | GNUNET_free (ikeys); | ||
955 | GNUNET_free (val); | ||
956 | return; | ||
957 | } | ||
958 | } | ||
959 | GNUNET_free (ikeys); | ||
960 | } | ||
961 | GNUNET_free_non_null (val); | ||
957 | ACCEPT_FROM_key = "ACCEPT_FROM"; | 962 | ACCEPT_FROM_key = "ACCEPT_FROM"; |
958 | if ((NULL != uc->system->trusted_ip) && | 963 | if ((NULL != uc->system->trusted_ip) && |
959 | (NULL != strstr(uc->system->trusted_ip, ":"))) /* IPv6 in use */ | 964 | (NULL != strstr (uc->system->trusted_ip, ":"))) /* IPv6 in use */ |
960 | ACCEPT_FROM_key = "ACCEPT_FROM6"; | 965 | ACCEPT_FROM_key = "ACCEPT_FROM6"; |
961 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(uc->cfg, | 966 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (uc->cfg, |
962 | section, | 967 | section, |
963 | ACCEPT_FROM_key, | 968 | ACCEPT_FROM_key, |
964 | &orig_allowed_hosts)) | 969 | &orig_allowed_hosts)) |
965 | { | 970 | { |
966 | orig_allowed_hosts = GNUNET_strdup("127.0.0.1;"); | 971 | orig_allowed_hosts = GNUNET_strdup ("127.0.0.1;"); |
967 | } | 972 | } |
968 | if (NULL == uc->system->trusted_ip) | 973 | if (NULL == uc->system->trusted_ip) |
969 | allowed_hosts = GNUNET_strdup(orig_allowed_hosts); | 974 | allowed_hosts = GNUNET_strdup (orig_allowed_hosts); |
970 | else | 975 | else |
971 | GNUNET_asprintf(&allowed_hosts, | 976 | GNUNET_asprintf (&allowed_hosts, |
972 | "%s%s;", | 977 | "%s%s;", |
973 | orig_allowed_hosts, | 978 | orig_allowed_hosts, |
974 | uc->system->trusted_ip); | 979 | uc->system->trusted_ip); |
975 | GNUNET_free(orig_allowed_hosts); | 980 | GNUNET_free (orig_allowed_hosts); |
976 | GNUNET_CONFIGURATION_set_value_string(uc->cfg, | 981 | GNUNET_CONFIGURATION_set_value_string (uc->cfg, |
977 | section, | 982 | section, |
978 | ACCEPT_FROM_key, | 983 | ACCEPT_FROM_key, |
979 | allowed_hosts); | 984 | allowed_hosts); |
980 | GNUNET_free(allowed_hosts); | 985 | GNUNET_free (allowed_hosts); |
981 | } | 986 | } |
982 | 987 | ||
983 | 988 | ||
984 | static struct SharedServiceInstance * | 989 | static struct SharedServiceInstance * |
985 | associate_shared_service(struct GNUNET_TESTING_System *system, | 990 | associate_shared_service (struct GNUNET_TESTING_System *system, |
986 | struct SharedService *ss, | 991 | struct SharedService *ss, |
987 | struct GNUNET_CONFIGURATION_Handle *cfg) | 992 | struct GNUNET_CONFIGURATION_Handle *cfg) |
988 | { | 993 | { |
989 | struct SharedServiceInstance *i; | 994 | struct SharedServiceInstance *i; |
990 | struct GNUNET_CONFIGURATION_Handle *temp; | 995 | struct GNUNET_CONFIGURATION_Handle *temp; |
@@ -995,62 +1000,62 @@ associate_shared_service(struct GNUNET_TESTING_System *system, | |||
995 | if (((0 == ss->share) && (NULL == ss->instances)) || | 1000 | if (((0 == ss->share) && (NULL == ss->instances)) || |
996 | ((0 != ss->share) && | 1001 | ((0 != ss->share) && |
997 | (ss->n_instances < ((ss->n_peers + ss->share - 1) / ss->share)))) | 1002 | (ss->n_instances < ((ss->n_peers + ss->share - 1) / ss->share)))) |
998 | { | 1003 | { |
999 | i = GNUNET_new(struct SharedServiceInstance); | 1004 | i = GNUNET_new (struct SharedServiceInstance); |
1000 | i->ss = ss; | 1005 | i->ss = ss; |
1001 | (void)GNUNET_asprintf(&gnunet_home, | 1006 | (void) GNUNET_asprintf (&gnunet_home, |
1002 | "%s/shared/%s/%u", | 1007 | "%s/shared/%s/%u", |
1003 | system->tmppath, | 1008 | system->tmppath, |
1004 | ss->sname, | 1009 | ss->sname, |
1005 | ss->n_instances); | 1010 | ss->n_instances); |
1006 | (void)GNUNET_asprintf(&i->unix_sock, "%s/sock", gnunet_home); | 1011 | (void) GNUNET_asprintf (&i->unix_sock, "%s/sock", gnunet_home); |
1007 | port = GNUNET_TESTING_reserve_port(system); | 1012 | port = GNUNET_TESTING_reserve_port (system); |
1008 | if (0 == port) | 1013 | if (0 == port) |
1009 | { | 1014 | { |
1010 | GNUNET_free(gnunet_home); | 1015 | GNUNET_free (gnunet_home); |
1011 | cleanup_shared_service_instance(i); | 1016 | cleanup_shared_service_instance (i); |
1012 | return NULL; | 1017 | return NULL; |
1013 | } | ||
1014 | GNUNET_array_append(ss->instances, ss->n_instances, i); | ||
1015 | temp = GNUNET_CONFIGURATION_dup(ss->cfg); | ||
1016 | (void)GNUNET_asprintf(&i->port_str, "%u", port); | ||
1017 | (void)GNUNET_asprintf(&i->cfg_fn, "%s/config", gnunet_home); | ||
1018 | GNUNET_CONFIGURATION_set_value_string(temp, | ||
1019 | "PATHS", | ||
1020 | "GNUNET_HOME", | ||
1021 | gnunet_home); | ||
1022 | GNUNET_free(gnunet_home); | ||
1023 | GNUNET_CONFIGURATION_set_value_string(temp, | ||
1024 | ss->sname, | ||
1025 | "UNIXPATH", | ||
1026 | i->unix_sock); | ||
1027 | GNUNET_CONFIGURATION_set_value_string(temp, | ||
1028 | ss->sname, | ||
1029 | "PORT", | ||
1030 | i->port_str); | ||
1031 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_write(temp, i->cfg_fn)) | ||
1032 | { | ||
1033 | GNUNET_CONFIGURATION_destroy(temp); | ||
1034 | cleanup_shared_service_instance(i); | ||
1035 | return NULL; | ||
1036 | } | ||
1037 | GNUNET_CONFIGURATION_destroy(temp); | ||
1038 | } | 1018 | } |
1039 | else | 1019 | GNUNET_array_append (ss->instances, ss->n_instances, i); |
1020 | temp = GNUNET_CONFIGURATION_dup (ss->cfg); | ||
1021 | (void) GNUNET_asprintf (&i->port_str, "%u", port); | ||
1022 | (void) GNUNET_asprintf (&i->cfg_fn, "%s/config", gnunet_home); | ||
1023 | GNUNET_CONFIGURATION_set_value_string (temp, | ||
1024 | "PATHS", | ||
1025 | "GNUNET_HOME", | ||
1026 | gnunet_home); | ||
1027 | GNUNET_free (gnunet_home); | ||
1028 | GNUNET_CONFIGURATION_set_value_string (temp, | ||
1029 | ss->sname, | ||
1030 | "UNIXPATH", | ||
1031 | i->unix_sock); | ||
1032 | GNUNET_CONFIGURATION_set_value_string (temp, | ||
1033 | ss->sname, | ||
1034 | "PORT", | ||
1035 | i->port_str); | ||
1036 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_write (temp, i->cfg_fn)) | ||
1040 | { | 1037 | { |
1041 | GNUNET_assert(NULL != ss->instances); | 1038 | GNUNET_CONFIGURATION_destroy (temp); |
1042 | GNUNET_assert(0 < ss->n_instances); | 1039 | cleanup_shared_service_instance (i); |
1043 | i = ss->instances[ss->n_instances - 1]; | 1040 | return NULL; |
1044 | } | 1041 | } |
1045 | GNUNET_CONFIGURATION_iterate_section_values(ss->cfg, | 1042 | GNUNET_CONFIGURATION_destroy (temp); |
1046 | ss->sname, | 1043 | } |
1047 | &cfg_copy_iterator, | 1044 | else |
1048 | cfg); | 1045 | { |
1049 | GNUNET_CONFIGURATION_set_value_string(cfg, | 1046 | GNUNET_assert (NULL != ss->instances); |
1050 | ss->sname, | 1047 | GNUNET_assert (0 < ss->n_instances); |
1051 | "UNIXPATH", | 1048 | i = ss->instances[ss->n_instances - 1]; |
1052 | i->unix_sock); | 1049 | } |
1053 | GNUNET_CONFIGURATION_set_value_string(cfg, ss->sname, "PORT", i->port_str); | 1050 | GNUNET_CONFIGURATION_iterate_section_values (ss->cfg, |
1051 | ss->sname, | ||
1052 | &cfg_copy_iterator, | ||
1053 | cfg); | ||
1054 | GNUNET_CONFIGURATION_set_value_string (cfg, | ||
1055 | ss->sname, | ||
1056 | "UNIXPATH", | ||
1057 | i->unix_sock); | ||
1058 | GNUNET_CONFIGURATION_set_value_string (cfg, ss->sname, "PORT", i->port_str); | ||
1054 | return i; | 1059 | return i; |
1055 | } | 1060 | } |
1056 | 1061 | ||
@@ -1075,10 +1080,10 @@ associate_shared_service(struct GNUNET_TESTING_System *system, | |||
1075 | * be incomplete and should not be used there upon | 1080 | * be incomplete and should not be used there upon |
1076 | */ | 1081 | */ |
1077 | static int | 1082 | static int |
1078 | GNUNET_TESTING_configuration_create_(struct GNUNET_TESTING_System *system, | 1083 | GNUNET_TESTING_configuration_create_ (struct GNUNET_TESTING_System *system, |
1079 | struct GNUNET_CONFIGURATION_Handle *cfg, | 1084 | struct GNUNET_CONFIGURATION_Handle *cfg, |
1080 | uint16_t **ports, | 1085 | uint16_t **ports, |
1081 | unsigned int *nports) | 1086 | unsigned int *nports) |
1082 | { | 1087 | { |
1083 | struct UpdateContext uc; | 1088 | struct UpdateContext uc; |
1084 | char *default_config; | 1089 | char *default_config; |
@@ -1088,35 +1093,35 @@ GNUNET_TESTING_configuration_create_(struct GNUNET_TESTING_System *system, | |||
1088 | uc.status = GNUNET_OK; | 1093 | uc.status = GNUNET_OK; |
1089 | uc.ports = NULL; | 1094 | uc.ports = NULL; |
1090 | uc.nports = 0; | 1095 | uc.nports = 0; |
1091 | GNUNET_asprintf(&uc.gnunet_home, | 1096 | GNUNET_asprintf (&uc.gnunet_home, |
1092 | "%s/%u", | 1097 | "%s/%u", |
1093 | system->tmppath, | 1098 | system->tmppath, |
1094 | system->path_counter++); | 1099 | system->path_counter++); |
1095 | GNUNET_asprintf(&default_config, "%s/config", uc.gnunet_home); | 1100 | GNUNET_asprintf (&default_config, "%s/config", uc.gnunet_home); |
1096 | GNUNET_CONFIGURATION_set_value_string(cfg, | 1101 | GNUNET_CONFIGURATION_set_value_string (cfg, |
1097 | "PATHS", | 1102 | "PATHS", |
1098 | "DEFAULTCONFIG", | 1103 | "DEFAULTCONFIG", |
1099 | default_config); | 1104 | default_config); |
1100 | GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", default_config); | 1105 | GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", default_config); |
1101 | GNUNET_free(default_config); | 1106 | GNUNET_free (default_config); |
1102 | GNUNET_CONFIGURATION_set_value_string(cfg, | 1107 | GNUNET_CONFIGURATION_set_value_string (cfg, |
1103 | "PATHS", | 1108 | "PATHS", |
1104 | "GNUNET_HOME", | 1109 | "GNUNET_HOME", |
1105 | uc.gnunet_home); | 1110 | uc.gnunet_home); |
1106 | /* make PORTs and UNIXPATHs unique */ | 1111 | /* make PORTs and UNIXPATHs unique */ |
1107 | GNUNET_CONFIGURATION_iterate(cfg, &update_config, &uc); | 1112 | GNUNET_CONFIGURATION_iterate (cfg, &update_config, &uc); |
1108 | /* allow connections to services from system trusted_ip host */ | 1113 | /* allow connections to services from system trusted_ip host */ |
1109 | GNUNET_CONFIGURATION_iterate_sections(cfg, &update_config_sections, &uc); | 1114 | GNUNET_CONFIGURATION_iterate_sections (cfg, &update_config_sections, &uc); |
1110 | /* enable loopback-based connections between peers */ | 1115 | /* enable loopback-based connections between peers */ |
1111 | GNUNET_CONFIGURATION_set_value_string(cfg, "nat", "USE_LOCALADDR", "YES"); | 1116 | GNUNET_CONFIGURATION_set_value_string (cfg, "nat", "USE_LOCALADDR", "YES"); |
1112 | GNUNET_free(uc.gnunet_home); | 1117 | GNUNET_free (uc.gnunet_home); |
1113 | if ((NULL != ports) && (NULL != nports)) | 1118 | if ((NULL != ports) && (NULL != nports)) |
1114 | { | 1119 | { |
1115 | *ports = uc.ports; | 1120 | *ports = uc.ports; |
1116 | *nports = uc.nports; | 1121 | *nports = uc.nports; |
1117 | } | 1122 | } |
1118 | else | 1123 | else |
1119 | GNUNET_free_non_null(uc.ports); | 1124 | GNUNET_free_non_null (uc.ports); |
1120 | return uc.status; | 1125 | return uc.status; |
1121 | } | 1126 | } |
1122 | 1127 | ||
@@ -1138,10 +1143,10 @@ GNUNET_TESTING_configuration_create_(struct GNUNET_TESTING_System *system, | |||
1138 | * be incomplete and should not be used there upon | 1143 | * be incomplete and should not be used there upon |
1139 | */ | 1144 | */ |
1140 | int | 1145 | int |
1141 | GNUNET_TESTING_configuration_create(struct GNUNET_TESTING_System *system, | 1146 | GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system, |
1142 | struct GNUNET_CONFIGURATION_Handle *cfg) | 1147 | struct GNUNET_CONFIGURATION_Handle *cfg) |
1143 | { | 1148 | { |
1144 | return GNUNET_TESTING_configuration_create_(system, cfg, NULL, NULL); | 1149 | return GNUNET_TESTING_configuration_create_ (system, cfg, NULL, NULL); |
1145 | } | 1150 | } |
1146 | 1151 | ||
1147 | 1152 | ||
@@ -1159,11 +1164,11 @@ GNUNET_TESTING_configuration_create(struct GNUNET_TESTING_System *system, | |||
1159 | * @return handle to the peer, NULL on error | 1164 | * @return handle to the peer, NULL on error |
1160 | */ | 1165 | */ |
1161 | struct GNUNET_TESTING_Peer * | 1166 | struct GNUNET_TESTING_Peer * |
1162 | GNUNET_TESTING_peer_configure(struct GNUNET_TESTING_System *system, | 1167 | GNUNET_TESTING_peer_configure (struct GNUNET_TESTING_System *system, |
1163 | struct GNUNET_CONFIGURATION_Handle *cfg, | 1168 | struct GNUNET_CONFIGURATION_Handle *cfg, |
1164 | uint32_t key_number, | 1169 | uint32_t key_number, |
1165 | struct GNUNET_PeerIdentity *id, | 1170 | struct GNUNET_PeerIdentity *id, |
1166 | char **emsg) | 1171 | char **emsg) |
1167 | { | 1172 | { |
1168 | struct GNUNET_TESTING_Peer *peer; | 1173 | struct GNUNET_TESTING_Peer *peer; |
1169 | struct GNUNET_DISK_FileHandle *fd; | 1174 | struct GNUNET_DISK_FileHandle *fd; |
@@ -1184,141 +1189,141 @@ GNUNET_TESTING_peer_configure(struct GNUNET_TESTING_System *system, | |||
1184 | if (NULL != emsg) | 1189 | if (NULL != emsg) |
1185 | *emsg = NULL; | 1190 | *emsg = NULL; |
1186 | if (key_number >= system->total_hostkeys) | 1191 | if (key_number >= system->total_hostkeys) |
1187 | { | 1192 | { |
1188 | GNUNET_asprintf( | 1193 | GNUNET_asprintf ( |
1189 | &emsg_, | 1194 | &emsg_, |
1190 | _( | 1195 | _ ( |
1191 | "You attempted to create a testbed with more than %u hosts. Please precompute more hostkeys first.\n"), | 1196 | "You attempted to create a testbed with more than %u hosts. Please precompute more hostkeys first.\n"), |
1192 | (unsigned int)system->total_hostkeys); | 1197 | (unsigned int) system->total_hostkeys); |
1193 | goto err_ret; | 1198 | goto err_ret; |
1194 | } | 1199 | } |
1195 | pk = NULL; | 1200 | pk = NULL; |
1196 | if ((NULL != id) && | 1201 | if ((NULL != id) && |
1197 | (NULL == (pk = GNUNET_TESTING_hostkey_get(system, key_number, id)))) | 1202 | (NULL == (pk = GNUNET_TESTING_hostkey_get (system, key_number, id)))) |
1198 | { | 1203 | { |
1199 | GNUNET_asprintf(&emsg_, | 1204 | GNUNET_asprintf (&emsg_, |
1200 | _("Failed to initialize hostkey for peer %u\n"), | 1205 | _ ("Failed to initialize hostkey for peer %u\n"), |
1201 | (unsigned int)key_number); | 1206 | (unsigned int) key_number); |
1202 | goto err_ret; | 1207 | goto err_ret; |
1203 | } | 1208 | } |
1204 | if (NULL != pk) | 1209 | if (NULL != pk) |
1205 | GNUNET_free(pk); | 1210 | GNUNET_free (pk); |
1206 | if (GNUNET_NO == GNUNET_CONFIGURATION_have_value(cfg, "PEER", "PRIVATE_KEY")) | 1211 | if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (cfg, "PEER", "PRIVATE_KEY")) |
1207 | { | 1212 | { |
1208 | GNUNET_asprintf( | 1213 | GNUNET_asprintf ( |
1209 | &emsg_, | 1214 | &emsg_, |
1210 | _("PRIVATE_KEY option in PEER section missing in configuration\n")); | 1215 | _ ("PRIVATE_KEY option in PEER section missing in configuration\n")); |
1211 | goto err_ret; | 1216 | goto err_ret; |
1212 | } | 1217 | } |
1213 | /* Remove sections for shared services */ | 1218 | /* Remove sections for shared services */ |
1214 | for (cnt = 0; cnt < system->n_shared_services; cnt++) | 1219 | for (cnt = 0; cnt < system->n_shared_services; cnt++) |
1215 | { | 1220 | { |
1216 | ss = system->shared_services[cnt]; | 1221 | ss = system->shared_services[cnt]; |
1217 | GNUNET_CONFIGURATION_remove_section(cfg, ss->sname); | 1222 | GNUNET_CONFIGURATION_remove_section (cfg, ss->sname); |
1218 | } | 1223 | } |
1219 | if (GNUNET_OK != | 1224 | if (GNUNET_OK != |
1220 | GNUNET_TESTING_configuration_create_(system, cfg, &ports, &nports)) | 1225 | GNUNET_TESTING_configuration_create_ (system, cfg, &ports, &nports)) |
1221 | { | 1226 | { |
1222 | GNUNET_asprintf(&emsg_, | 1227 | GNUNET_asprintf (&emsg_, |
1223 | _("Failed to create configuration for peer " | 1228 | _ ("Failed to create configuration for peer " |
1224 | "(not enough free ports?)\n")); | 1229 | "(not enough free ports?)\n")); |
1225 | goto err_ret; | 1230 | goto err_ret; |
1226 | } | 1231 | } |
1227 | GNUNET_assert(GNUNET_OK == | 1232 | GNUNET_assert (GNUNET_OK == |
1228 | GNUNET_CONFIGURATION_get_value_filename(cfg, | 1233 | GNUNET_CONFIGURATION_get_value_filename (cfg, |
1229 | "PEER", | 1234 | "PEER", |
1230 | "PRIVATE_KEY", | 1235 | "PRIVATE_KEY", |
1231 | &hostkey_filename)); | 1236 | &hostkey_filename)); |
1232 | fd = GNUNET_DISK_file_open(hostkey_filename, | 1237 | fd = GNUNET_DISK_file_open (hostkey_filename, |
1233 | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, | 1238 | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE, |
1234 | GNUNET_DISK_PERM_USER_READ | | 1239 | GNUNET_DISK_PERM_USER_READ |
1235 | GNUNET_DISK_PERM_USER_WRITE); | 1240 | | GNUNET_DISK_PERM_USER_WRITE); |
1236 | if (NULL == fd) | 1241 | if (NULL == fd) |
1237 | { | 1242 | { |
1238 | GNUNET_asprintf(&emsg_, | 1243 | GNUNET_asprintf (&emsg_, |
1239 | _("Cannot open hostkey file `%s': %s\n"), | 1244 | _ ("Cannot open hostkey file `%s': %s\n"), |
1240 | hostkey_filename, | 1245 | hostkey_filename, |
1241 | strerror(errno)); | 1246 | strerror (errno)); |
1242 | GNUNET_free(hostkey_filename); | 1247 | GNUNET_free (hostkey_filename); |
1243 | goto err_ret; | 1248 | goto err_ret; |
1244 | } | 1249 | } |
1245 | GNUNET_free(hostkey_filename); | 1250 | GNUNET_free (hostkey_filename); |
1246 | if (GNUNET_TESTING_HOSTKEYFILESIZE != | 1251 | if (GNUNET_TESTING_HOSTKEYFILESIZE != |
1247 | GNUNET_DISK_file_write(fd, | 1252 | GNUNET_DISK_file_write (fd, |
1248 | system->hostkeys_data + | 1253 | system->hostkeys_data |
1249 | (key_number * GNUNET_TESTING_HOSTKEYFILESIZE), | 1254 | + (key_number * GNUNET_TESTING_HOSTKEYFILESIZE), |
1250 | GNUNET_TESTING_HOSTKEYFILESIZE)) | 1255 | GNUNET_TESTING_HOSTKEYFILESIZE)) |
1251 | { | 1256 | { |
1252 | GNUNET_asprintf(&emsg_, | 1257 | GNUNET_asprintf (&emsg_, |
1253 | _("Failed to write hostkey file for peer %u: %s\n"), | 1258 | _ ("Failed to write hostkey file for peer %u: %s\n"), |
1254 | (unsigned int)key_number, | 1259 | (unsigned int) key_number, |
1255 | strerror(errno)); | 1260 | strerror (errno)); |
1256 | GNUNET_DISK_file_close(fd); | 1261 | GNUNET_DISK_file_close (fd); |
1257 | goto err_ret; | 1262 | goto err_ret; |
1258 | } | 1263 | } |
1259 | GNUNET_DISK_file_close(fd); | 1264 | GNUNET_DISK_file_close (fd); |
1260 | ss_instances = GNUNET_malloc(sizeof(struct SharedServiceInstance *) * | 1265 | ss_instances = GNUNET_malloc (sizeof(struct SharedServiceInstance *) |
1261 | system->n_shared_services); | 1266 | * system->n_shared_services); |
1262 | for (cnt = 0; cnt < system->n_shared_services; cnt++) | 1267 | for (cnt = 0; cnt < system->n_shared_services; cnt++) |
1268 | { | ||
1269 | ss = system->shared_services[cnt]; | ||
1270 | ss_instances[cnt] = associate_shared_service (system, ss, cfg); | ||
1271 | if (NULL == ss_instances[cnt]) | ||
1263 | { | 1272 | { |
1264 | ss = system->shared_services[cnt]; | 1273 | emsg_ = GNUNET_strdup ("FIXME"); |
1265 | ss_instances[cnt] = associate_shared_service(system, ss, cfg); | ||
1266 | if (NULL == ss_instances[cnt]) | ||
1267 | { | ||
1268 | emsg_ = GNUNET_strdup("FIXME"); | ||
1269 | goto err_ret; | ||
1270 | } | ||
1271 | } | ||
1272 | GNUNET_assert(GNUNET_OK == | ||
1273 | GNUNET_CONFIGURATION_get_value_filename(cfg, | ||
1274 | "PATHS", | ||
1275 | "DEFAULTCONFIG", | ||
1276 | &config_filename)); | ||
1277 | if (GNUNET_OK != GNUNET_CONFIGURATION_write(cfg, config_filename)) | ||
1278 | { | ||
1279 | GNUNET_asprintf(&emsg_, | ||
1280 | _( | ||
1281 | "Failed to write configuration file `%s' for peer %u: %s\n"), | ||
1282 | config_filename, | ||
1283 | (unsigned int)key_number, | ||
1284 | strerror(errno)); | ||
1285 | GNUNET_free(config_filename); | ||
1286 | goto err_ret; | 1274 | goto err_ret; |
1287 | } | 1275 | } |
1288 | peer = GNUNET_new(struct GNUNET_TESTING_Peer); | 1276 | } |
1277 | GNUNET_assert (GNUNET_OK == | ||
1278 | GNUNET_CONFIGURATION_get_value_filename (cfg, | ||
1279 | "PATHS", | ||
1280 | "DEFAULTCONFIG", | ||
1281 | &config_filename)); | ||
1282 | if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, config_filename)) | ||
1283 | { | ||
1284 | GNUNET_asprintf (&emsg_, | ||
1285 | _ ( | ||
1286 | "Failed to write configuration file `%s' for peer %u: %s\n"), | ||
1287 | config_filename, | ||
1288 | (unsigned int) key_number, | ||
1289 | strerror (errno)); | ||
1290 | GNUNET_free (config_filename); | ||
1291 | goto err_ret; | ||
1292 | } | ||
1293 | peer = GNUNET_new (struct GNUNET_TESTING_Peer); | ||
1289 | peer->ss_instances = ss_instances; | 1294 | peer->ss_instances = ss_instances; |
1290 | peer->cfgfile = config_filename; /* Free in peer_destroy */ | 1295 | peer->cfgfile = config_filename; /* Free in peer_destroy */ |
1291 | peer->cfg = GNUNET_CONFIGURATION_dup(cfg); | 1296 | peer->cfg = GNUNET_CONFIGURATION_dup (cfg); |
1292 | libexec_binary = GNUNET_OS_get_libexec_binary_path("gnunet-service-arm"); | 1297 | libexec_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm"); |
1293 | if (GNUNET_SYSERR == | 1298 | if (GNUNET_SYSERR == |
1294 | GNUNET_CONFIGURATION_get_value_string(cfg, | 1299 | GNUNET_CONFIGURATION_get_value_string (cfg, |
1295 | "arm", | 1300 | "arm", |
1296 | "PREFIX", | 1301 | "PREFIX", |
1297 | &peer->main_binary)) | 1302 | &peer->main_binary)) |
1298 | { | 1303 | { |
1299 | /* No prefix */ | 1304 | /* No prefix */ |
1300 | GNUNET_asprintf(&peer->main_binary, "%s", libexec_binary); | 1305 | GNUNET_asprintf (&peer->main_binary, "%s", libexec_binary); |
1301 | peer->args = GNUNET_strdup(""); | 1306 | peer->args = GNUNET_strdup (""); |
1302 | } | 1307 | } |
1303 | else | 1308 | else |
1304 | { | 1309 | { |
1305 | peer->args = GNUNET_strdup(libexec_binary); | 1310 | peer->args = GNUNET_strdup (libexec_binary); |
1306 | } | 1311 | } |
1307 | peer->system = system; | 1312 | peer->system = system; |
1308 | peer->key_number = key_number; | 1313 | peer->key_number = key_number; |
1309 | GNUNET_free(libexec_binary); | 1314 | GNUNET_free (libexec_binary); |
1310 | peer->ports = ports; /* Free in peer_destroy */ | 1315 | peer->ports = ports; /* Free in peer_destroy */ |
1311 | peer->nports = nports; | 1316 | peer->nports = nports; |
1312 | return peer; | 1317 | return peer; |
1313 | 1318 | ||
1314 | err_ret: | 1319 | err_ret: |
1315 | GNUNET_free_non_null(ss_instances); | 1320 | GNUNET_free_non_null (ss_instances); |
1316 | GNUNET_free_non_null(ports); | 1321 | GNUNET_free_non_null (ports); |
1317 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "%s", emsg_); | 1322 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_); |
1318 | if (NULL != emsg) | 1323 | if (NULL != emsg) |
1319 | *emsg = emsg_; | 1324 | *emsg = emsg_; |
1320 | else | 1325 | else |
1321 | GNUNET_free(emsg_); | 1326 | GNUNET_free (emsg_); |
1322 | return NULL; | 1327 | return NULL; |
1323 | } | 1328 | } |
1324 | 1329 | ||
@@ -1330,18 +1335,18 @@ err_ret: | |||
1330 | * @param id identifier for the daemon, will be set | 1335 | * @param id identifier for the daemon, will be set |
1331 | */ | 1336 | */ |
1332 | void | 1337 | void |
1333 | GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, | 1338 | GNUNET_TESTING_peer_get_identity (struct GNUNET_TESTING_Peer *peer, |
1334 | struct GNUNET_PeerIdentity *id) | 1339 | struct GNUNET_PeerIdentity *id) |
1335 | { | 1340 | { |
1336 | if (NULL != peer->id) | 1341 | if (NULL != peer->id) |
1337 | { | 1342 | { |
1338 | GNUNET_memcpy(id, peer->id, sizeof(struct GNUNET_PeerIdentity)); | 1343 | GNUNET_memcpy (id, peer->id, sizeof(struct GNUNET_PeerIdentity)); |
1339 | return; | 1344 | return; |
1340 | } | 1345 | } |
1341 | peer->id = GNUNET_new(struct GNUNET_PeerIdentity); | 1346 | peer->id = GNUNET_new (struct GNUNET_PeerIdentity); |
1342 | GNUNET_free( | 1347 | GNUNET_free ( |
1343 | GNUNET_TESTING_hostkey_get(peer->system, peer->key_number, peer->id)); | 1348 | GNUNET_TESTING_hostkey_get (peer->system, peer->key_number, peer->id)); |
1344 | GNUNET_memcpy(id, peer->id, sizeof(struct GNUNET_PeerIdentity)); | 1349 | GNUNET_memcpy (id, peer->id, sizeof(struct GNUNET_PeerIdentity)); |
1345 | } | 1350 | } |
1346 | 1351 | ||
1347 | 1352 | ||
@@ -1352,44 +1357,44 @@ GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, | |||
1352 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (i.e. peer already running) | 1357 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (i.e. peer already running) |
1353 | */ | 1358 | */ |
1354 | int | 1359 | int |
1355 | GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer) | 1360 | GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer) |
1356 | { | 1361 | { |
1357 | struct SharedServiceInstance *i; | 1362 | struct SharedServiceInstance *i; |
1358 | unsigned int cnt; | 1363 | unsigned int cnt; |
1359 | 1364 | ||
1360 | if (NULL != peer->main_process) | 1365 | if (NULL != peer->main_process) |
1361 | { | 1366 | { |
1362 | GNUNET_break(0); | 1367 | GNUNET_break (0); |
1363 | return GNUNET_SYSERR; | 1368 | return GNUNET_SYSERR; |
1364 | } | 1369 | } |
1365 | GNUNET_assert(NULL != peer->cfgfile); | 1370 | GNUNET_assert (NULL != peer->cfgfile); |
1366 | for (cnt = 0; cnt < peer->system->n_shared_services; cnt++) | 1371 | for (cnt = 0; cnt < peer->system->n_shared_services; cnt++) |
1367 | { | 1372 | { |
1368 | i = peer->ss_instances[cnt]; | 1373 | i = peer->ss_instances[cnt]; |
1369 | if ((0 == i->n_refs) && | 1374 | if ((0 == i->n_refs) && |
1370 | (GNUNET_SYSERR == start_shared_service_instance(i))) | 1375 | (GNUNET_SYSERR == start_shared_service_instance (i))) |
1371 | return GNUNET_SYSERR; | 1376 | return GNUNET_SYSERR; |
1372 | i->n_refs++; | 1377 | i->n_refs++; |
1373 | } | 1378 | } |
1374 | peer->main_binary = | 1379 | peer->main_binary = |
1375 | GNUNET_CONFIGURATION_expand_dollar(peer->cfg, peer->main_binary); | 1380 | GNUNET_CONFIGURATION_expand_dollar (peer->cfg, peer->main_binary); |
1376 | peer->main_process = | 1381 | peer->main_process = |
1377 | GNUNET_OS_start_process_s(PIPE_CONTROL, | 1382 | GNUNET_OS_start_process_s (PIPE_CONTROL, |
1378 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 1383 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
1379 | NULL, | 1384 | NULL, |
1380 | peer->main_binary, | 1385 | peer->main_binary, |
1381 | peer->args, | 1386 | peer->args, |
1382 | "-c", | 1387 | "-c", |
1383 | peer->cfgfile, | 1388 | peer->cfgfile, |
1384 | NULL); | 1389 | NULL); |
1385 | if (NULL == peer->main_process) | 1390 | if (NULL == peer->main_process) |
1386 | { | 1391 | { |
1387 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1392 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1388 | _("Failed to start `%s': %s\n"), | 1393 | _ ("Failed to start `%s': %s\n"), |
1389 | peer->main_binary, | 1394 | peer->main_binary, |
1390 | strerror(errno)); | 1395 | strerror (errno)); |
1391 | return GNUNET_SYSERR; | 1396 | return GNUNET_SYSERR; |
1392 | } | 1397 | } |
1393 | return GNUNET_OK; | 1398 | return GNUNET_OK; |
1394 | } | 1399 | } |
1395 | 1400 | ||
@@ -1402,26 +1407,26 @@ GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer) | |||
1402 | * or upon any error while sending SIGTERM | 1407 | * or upon any error while sending SIGTERM |
1403 | */ | 1408 | */ |
1404 | int | 1409 | int |
1405 | GNUNET_TESTING_peer_kill(struct GNUNET_TESTING_Peer *peer) | 1410 | GNUNET_TESTING_peer_kill (struct GNUNET_TESTING_Peer *peer) |
1406 | { | 1411 | { |
1407 | struct SharedServiceInstance *i; | 1412 | struct SharedServiceInstance *i; |
1408 | unsigned int cnt; | 1413 | unsigned int cnt; |
1409 | 1414 | ||
1410 | if (NULL == peer->main_process) | 1415 | if (NULL == peer->main_process) |
1411 | { | 1416 | { |
1412 | GNUNET_break(0); | 1417 | GNUNET_break (0); |
1413 | return GNUNET_SYSERR; | 1418 | return GNUNET_SYSERR; |
1414 | } | 1419 | } |
1415 | if (0 != GNUNET_OS_process_kill(peer->main_process, GNUNET_TERM_SIG)) | 1420 | if (0 != GNUNET_OS_process_kill (peer->main_process, GNUNET_TERM_SIG)) |
1416 | return GNUNET_SYSERR; | 1421 | return GNUNET_SYSERR; |
1417 | for (cnt = 0; cnt < peer->system->n_shared_services; cnt++) | 1422 | for (cnt = 0; cnt < peer->system->n_shared_services; cnt++) |
1418 | { | 1423 | { |
1419 | i = peer->ss_instances[cnt]; | 1424 | i = peer->ss_instances[cnt]; |
1420 | GNUNET_assert(0 != i->n_refs); | 1425 | GNUNET_assert (0 != i->n_refs); |
1421 | i->n_refs--; | 1426 | i->n_refs--; |
1422 | if (0 == i->n_refs) | 1427 | if (0 == i->n_refs) |
1423 | stop_shared_service_instance(i); | 1428 | stop_shared_service_instance (i); |
1424 | } | 1429 | } |
1425 | return GNUNET_OK; | 1430 | return GNUNET_OK; |
1426 | } | 1431 | } |
1427 | 1432 | ||
@@ -1434,17 +1439,17 @@ GNUNET_TESTING_peer_kill(struct GNUNET_TESTING_Peer *peer) | |||
1434 | * or upon any error while waiting | 1439 | * or upon any error while waiting |
1435 | */ | 1440 | */ |
1436 | int | 1441 | int |
1437 | GNUNET_TESTING_peer_wait(struct GNUNET_TESTING_Peer *peer) | 1442 | GNUNET_TESTING_peer_wait (struct GNUNET_TESTING_Peer *peer) |
1438 | { | 1443 | { |
1439 | int ret; | 1444 | int ret; |
1440 | 1445 | ||
1441 | if (NULL == peer->main_process) | 1446 | if (NULL == peer->main_process) |
1442 | { | 1447 | { |
1443 | GNUNET_break(0); | 1448 | GNUNET_break (0); |
1444 | return GNUNET_SYSERR; | 1449 | return GNUNET_SYSERR; |
1445 | } | 1450 | } |
1446 | ret = GNUNET_OS_process_wait(peer->main_process); | 1451 | ret = GNUNET_OS_process_wait (peer->main_process); |
1447 | GNUNET_OS_process_destroy(peer->main_process); | 1452 | GNUNET_OS_process_destroy (peer->main_process); |
1448 | peer->main_process = NULL; | 1453 | peer->main_process = NULL; |
1449 | return ret; | 1454 | return ret; |
1450 | } | 1455 | } |
@@ -1457,11 +1462,11 @@ GNUNET_TESTING_peer_wait(struct GNUNET_TESTING_Peer *peer) | |||
1457 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1462 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1458 | */ | 1463 | */ |
1459 | int | 1464 | int |
1460 | GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer) | 1465 | GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer) |
1461 | { | 1466 | { |
1462 | if (GNUNET_SYSERR == GNUNET_TESTING_peer_kill(peer)) | 1467 | if (GNUNET_SYSERR == GNUNET_TESTING_peer_kill (peer)) |
1463 | return GNUNET_SYSERR; | 1468 | return GNUNET_SYSERR; |
1464 | if (GNUNET_SYSERR == GNUNET_TESTING_peer_wait(peer)) | 1469 | if (GNUNET_SYSERR == GNUNET_TESTING_peer_wait (peer)) |
1465 | return GNUNET_SYSERR; | 1470 | return GNUNET_SYSERR; |
1466 | return GNUNET_OK; | 1471 | return GNUNET_OK; |
1467 | } | 1472 | } |
@@ -1475,24 +1480,24 @@ GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer) | |||
1475 | * #GNUNET_SYSERR on error. | 1480 | * #GNUNET_SYSERR on error. |
1476 | */ | 1481 | */ |
1477 | static void | 1482 | static void |
1478 | disconn_status(void *cls, int connected) | 1483 | disconn_status (void *cls, int connected) |
1479 | { | 1484 | { |
1480 | struct GNUNET_TESTING_Peer *peer = cls; | 1485 | struct GNUNET_TESTING_Peer *peer = cls; |
1481 | 1486 | ||
1482 | if (GNUNET_SYSERR == connected) | 1487 | if (GNUNET_SYSERR == connected) |
1483 | { | 1488 | { |
1484 | peer->cb(peer->cb_cls, peer, connected); | 1489 | peer->cb (peer->cb_cls, peer, connected); |
1485 | return; | 1490 | return; |
1486 | } | 1491 | } |
1487 | if (GNUNET_YES == connected) | 1492 | if (GNUNET_YES == connected) |
1488 | { | 1493 | { |
1489 | GNUNET_break(GNUNET_OK == GNUNET_TESTING_peer_kill(peer)); | 1494 | GNUNET_break (GNUNET_OK == GNUNET_TESTING_peer_kill (peer)); |
1490 | return; | 1495 | return; |
1491 | } | 1496 | } |
1492 | GNUNET_break(GNUNET_OK == GNUNET_TESTING_peer_wait(peer)); | 1497 | GNUNET_break (GNUNET_OK == GNUNET_TESTING_peer_wait (peer)); |
1493 | GNUNET_ARM_disconnect(peer->ah); | 1498 | GNUNET_ARM_disconnect (peer->ah); |
1494 | peer->ah = NULL; | 1499 | peer->ah = NULL; |
1495 | peer->cb(peer->cb_cls, peer, GNUNET_YES); | 1500 | peer->cb (peer->cb_cls, peer, GNUNET_YES); |
1496 | } | 1501 | } |
1497 | 1502 | ||
1498 | 1503 | ||
@@ -1508,13 +1513,13 @@ disconn_status(void *cls, int connected) | |||
1508 | * upon any error. | 1513 | * upon any error. |
1509 | */ | 1514 | */ |
1510 | int | 1515 | int |
1511 | GNUNET_TESTING_peer_stop_async(struct GNUNET_TESTING_Peer *peer, | 1516 | GNUNET_TESTING_peer_stop_async (struct GNUNET_TESTING_Peer *peer, |
1512 | GNUNET_TESTING_PeerStopCallback cb, | 1517 | GNUNET_TESTING_PeerStopCallback cb, |
1513 | void *cb_cls) | 1518 | void *cb_cls) |
1514 | { | 1519 | { |
1515 | if (NULL == peer->main_process) | 1520 | if (NULL == peer->main_process) |
1516 | return GNUNET_SYSERR; | 1521 | return GNUNET_SYSERR; |
1517 | peer->ah = GNUNET_ARM_connect(peer->cfg, &disconn_status, peer); | 1522 | peer->ah = GNUNET_ARM_connect (peer->cfg, &disconn_status, peer); |
1518 | if (NULL == peer->ah) | 1523 | if (NULL == peer->ah) |
1519 | return GNUNET_SYSERR; | 1524 | return GNUNET_SYSERR; |
1520 | peer->cb = cb; | 1525 | peer->cb = cb; |
@@ -1533,10 +1538,10 @@ GNUNET_TESTING_peer_stop_async(struct GNUNET_TESTING_Peer *peer, | |||
1533 | * before. | 1538 | * before. |
1534 | */ | 1539 | */ |
1535 | void | 1540 | void |
1536 | GNUNET_TESTING_peer_stop_async_cancel(struct GNUNET_TESTING_Peer *peer) | 1541 | GNUNET_TESTING_peer_stop_async_cancel (struct GNUNET_TESTING_Peer *peer) |
1537 | { | 1542 | { |
1538 | GNUNET_assert(NULL != peer->ah); | 1543 | GNUNET_assert (NULL != peer->ah); |
1539 | GNUNET_ARM_disconnect(peer->ah); | 1544 | GNUNET_ARM_disconnect (peer->ah); |
1540 | peer->ah = NULL; | 1545 | peer->ah = NULL; |
1541 | } | 1546 | } |
1542 | 1547 | ||
@@ -1549,28 +1554,28 @@ GNUNET_TESTING_peer_stop_async_cancel(struct GNUNET_TESTING_Peer *peer) | |||
1549 | * @param peer peer to destroy | 1554 | * @param peer peer to destroy |
1550 | */ | 1555 | */ |
1551 | void | 1556 | void |
1552 | GNUNET_TESTING_peer_destroy(struct GNUNET_TESTING_Peer *peer) | 1557 | GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer) |
1553 | { | 1558 | { |
1554 | unsigned int cnt; | 1559 | unsigned int cnt; |
1555 | 1560 | ||
1556 | if (NULL != peer->main_process) | 1561 | if (NULL != peer->main_process) |
1557 | GNUNET_TESTING_peer_stop(peer); | 1562 | GNUNET_TESTING_peer_stop (peer); |
1558 | if (NULL != peer->ah) | 1563 | if (NULL != peer->ah) |
1559 | GNUNET_ARM_disconnect(peer->ah); | 1564 | GNUNET_ARM_disconnect (peer->ah); |
1560 | GNUNET_free(peer->cfgfile); | 1565 | GNUNET_free (peer->cfgfile); |
1561 | if (NULL != peer->cfg) | 1566 | if (NULL != peer->cfg) |
1562 | GNUNET_CONFIGURATION_destroy(peer->cfg); | 1567 | GNUNET_CONFIGURATION_destroy (peer->cfg); |
1563 | GNUNET_free(peer->main_binary); | 1568 | GNUNET_free (peer->main_binary); |
1564 | GNUNET_free(peer->args); | 1569 | GNUNET_free (peer->args); |
1565 | GNUNET_free_non_null(peer->id); | 1570 | GNUNET_free_non_null (peer->id); |
1566 | GNUNET_free_non_null(peer->ss_instances); | 1571 | GNUNET_free_non_null (peer->ss_instances); |
1567 | if (NULL != peer->ports) | 1572 | if (NULL != peer->ports) |
1568 | { | 1573 | { |
1569 | for (cnt = 0; cnt < peer->nports; cnt++) | 1574 | for (cnt = 0; cnt < peer->nports; cnt++) |
1570 | GNUNET_TESTING_release_port(peer->system, peer->ports[cnt]); | 1575 | GNUNET_TESTING_release_port (peer->system, peer->ports[cnt]); |
1571 | GNUNET_free(peer->ports); | 1576 | GNUNET_free (peer->ports); |
1572 | } | 1577 | } |
1573 | GNUNET_free(peer); | 1578 | GNUNET_free (peer); |
1574 | } | 1579 | } |
1575 | 1580 | ||
1576 | 1581 | ||
@@ -1591,19 +1596,20 @@ GNUNET_TESTING_peer_destroy(struct GNUNET_TESTING_Peer *peer) | |||
1591 | * @return 0 on success, 1 on error | 1596 | * @return 0 on success, 1 on error |
1592 | */ | 1597 | */ |
1593 | int | 1598 | int |
1594 | GNUNET_TESTING_peer_run(const char *testdir, | 1599 | GNUNET_TESTING_peer_run (const char *testdir, |
1595 | const char *cfgfilename, | 1600 | const char *cfgfilename, |
1596 | GNUNET_TESTING_TestMain tm, | 1601 | GNUNET_TESTING_TestMain tm, |
1597 | void *tm_cls) | 1602 | void *tm_cls) |
1598 | { | 1603 | { |
1599 | return GNUNET_TESTING_service_run(testdir, "arm", cfgfilename, tm, tm_cls); | 1604 | return GNUNET_TESTING_service_run (testdir, "arm", cfgfilename, tm, tm_cls); |
1600 | } | 1605 | } |
1601 | 1606 | ||
1602 | 1607 | ||
1603 | /** | 1608 | /** |
1604 | * Structure for holding service data | 1609 | * Structure for holding service data |
1605 | */ | 1610 | */ |
1606 | struct ServiceContext { | 1611 | struct ServiceContext |
1612 | { | ||
1607 | /** | 1613 | /** |
1608 | * The configuration of the peer in which the service is run | 1614 | * The configuration of the peer in which the service is run |
1609 | */ | 1615 | */ |
@@ -1632,11 +1638,11 @@ struct ServiceContext { | |||
1632 | * @param cls the ServiceContext | 1638 | * @param cls the ServiceContext |
1633 | */ | 1639 | */ |
1634 | static void | 1640 | static void |
1635 | service_run_main(void *cls) | 1641 | service_run_main (void *cls) |
1636 | { | 1642 | { |
1637 | struct ServiceContext *sc = cls; | 1643 | struct ServiceContext *sc = cls; |
1638 | 1644 | ||
1639 | sc->tm(sc->tm_cls, sc->cfg, sc->peer); | 1645 | sc->tm (sc->tm_cls, sc->cfg, sc->peer); |
1640 | } | 1646 | } |
1641 | 1647 | ||
1642 | 1648 | ||
@@ -1662,11 +1668,11 @@ service_run_main(void *cls) | |||
1662 | * @return 0 on success, 1 on error | 1668 | * @return 0 on success, 1 on error |
1663 | */ | 1669 | */ |
1664 | int | 1670 | int |
1665 | GNUNET_TESTING_service_run(const char *testdir, | 1671 | GNUNET_TESTING_service_run (const char *testdir, |
1666 | const char *service_name, | 1672 | const char *service_name, |
1667 | const char *cfgfilename, | 1673 | const char *cfgfilename, |
1668 | GNUNET_TESTING_TestMain tm, | 1674 | GNUNET_TESTING_TestMain tm, |
1669 | void *tm_cls) | 1675 | void *tm_cls) |
1670 | { | 1676 | { |
1671 | struct ServiceContext sc; | 1677 | struct ServiceContext sc; |
1672 | struct GNUNET_TESTING_System *system; | 1678 | struct GNUNET_TESTING_System *system; |
@@ -1675,70 +1681,70 @@ GNUNET_TESTING_service_run(const char *testdir, | |||
1675 | char *binary; | 1681 | char *binary; |
1676 | char *libexec_binary; | 1682 | char *libexec_binary; |
1677 | 1683 | ||
1678 | GNUNET_log_setup(testdir, "WARNING", NULL); | 1684 | GNUNET_log_setup (testdir, "WARNING", NULL); |
1679 | system = GNUNET_TESTING_system_create(testdir, "127.0.0.1", NULL, NULL); | 1685 | system = GNUNET_TESTING_system_create (testdir, "127.0.0.1", NULL, NULL); |
1680 | if (NULL == system) | 1686 | if (NULL == system) |
1681 | return 1; | 1687 | return 1; |
1682 | cfg = GNUNET_CONFIGURATION_create(); | 1688 | cfg = GNUNET_CONFIGURATION_create (); |
1683 | if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg, cfgfilename)) | 1689 | if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename)) |
1684 | { | 1690 | { |
1685 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1691 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1686 | _("Failed to load configuration from %s\n"), | 1692 | _ ("Failed to load configuration from %s\n"), |
1687 | cfgfilename); | 1693 | cfgfilename); |
1688 | GNUNET_CONFIGURATION_destroy(cfg); | 1694 | GNUNET_CONFIGURATION_destroy (cfg); |
1689 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 1695 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
1690 | return 1; | 1696 | return 1; |
1691 | } | 1697 | } |
1692 | peer = GNUNET_TESTING_peer_configure(system, cfg, 0, NULL, NULL); | 1698 | peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL); |
1693 | if (NULL == peer) | 1699 | if (NULL == peer) |
1694 | { | 1700 | { |
1695 | GNUNET_CONFIGURATION_destroy(cfg); | 1701 | GNUNET_CONFIGURATION_destroy (cfg); |
1696 | hostkeys_unload(system); | 1702 | hostkeys_unload (system); |
1697 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 1703 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
1698 | return 1; | 1704 | return 1; |
1699 | } | 1705 | } |
1700 | GNUNET_free(peer->main_binary); | 1706 | GNUNET_free (peer->main_binary); |
1701 | GNUNET_free(peer->args); | 1707 | GNUNET_free (peer->args); |
1702 | GNUNET_asprintf(&binary, "gnunet-service-%s", service_name); | 1708 | GNUNET_asprintf (&binary, "gnunet-service-%s", service_name); |
1703 | libexec_binary = GNUNET_OS_get_libexec_binary_path(binary); | 1709 | libexec_binary = GNUNET_OS_get_libexec_binary_path (binary); |
1704 | if (GNUNET_SYSERR == | 1710 | if (GNUNET_SYSERR == |
1705 | GNUNET_CONFIGURATION_get_value_string(cfg, | 1711 | GNUNET_CONFIGURATION_get_value_string (cfg, |
1706 | service_name, | 1712 | service_name, |
1707 | "PREFIX", | 1713 | "PREFIX", |
1708 | &peer->main_binary)) | 1714 | &peer->main_binary)) |
1709 | { | 1715 | { |
1710 | /* No prefix */ | 1716 | /* No prefix */ |
1711 | GNUNET_asprintf(&peer->main_binary, "%s", libexec_binary); | 1717 | GNUNET_asprintf (&peer->main_binary, "%s", libexec_binary); |
1712 | peer->args = GNUNET_strdup(""); | 1718 | peer->args = GNUNET_strdup (""); |
1713 | } | 1719 | } |
1714 | else | 1720 | else |
1715 | peer->args = GNUNET_strdup(libexec_binary); | 1721 | peer->args = GNUNET_strdup (libexec_binary); |
1716 | 1722 | ||
1717 | GNUNET_free(libexec_binary); | 1723 | GNUNET_free (libexec_binary); |
1718 | GNUNET_free(binary); | 1724 | GNUNET_free (binary); |
1719 | if (GNUNET_OK != GNUNET_TESTING_peer_start(peer)) | 1725 | if (GNUNET_OK != GNUNET_TESTING_peer_start (peer)) |
1720 | { | 1726 | { |
1721 | GNUNET_TESTING_peer_destroy(peer); | 1727 | GNUNET_TESTING_peer_destroy (peer); |
1722 | GNUNET_CONFIGURATION_destroy(cfg); | 1728 | GNUNET_CONFIGURATION_destroy (cfg); |
1723 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 1729 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
1724 | return 1; | 1730 | return 1; |
1725 | } | 1731 | } |
1726 | sc.cfg = cfg; | 1732 | sc.cfg = cfg; |
1727 | sc.tm = tm; | 1733 | sc.tm = tm; |
1728 | sc.tm_cls = tm_cls; | 1734 | sc.tm_cls = tm_cls; |
1729 | sc.peer = peer; | 1735 | sc.peer = peer; |
1730 | GNUNET_SCHEDULER_run(&service_run_main, &sc); /* Scheduler loop */ | 1736 | GNUNET_SCHEDULER_run (&service_run_main, &sc); /* Scheduler loop */ |
1731 | if ((NULL != peer->main_process) && | 1737 | if ((NULL != peer->main_process) && |
1732 | (GNUNET_OK != GNUNET_TESTING_peer_stop(peer))) | 1738 | (GNUNET_OK != GNUNET_TESTING_peer_stop (peer))) |
1733 | { | 1739 | { |
1734 | GNUNET_TESTING_peer_destroy(peer); | 1740 | GNUNET_TESTING_peer_destroy (peer); |
1735 | GNUNET_CONFIGURATION_destroy(cfg); | 1741 | GNUNET_CONFIGURATION_destroy (cfg); |
1736 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 1742 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
1737 | return 1; | 1743 | return 1; |
1738 | } | 1744 | } |
1739 | GNUNET_TESTING_peer_destroy(peer); | 1745 | GNUNET_TESTING_peer_destroy (peer); |
1740 | GNUNET_CONFIGURATION_destroy(cfg); | 1746 | GNUNET_CONFIGURATION_destroy (cfg); |
1741 | GNUNET_TESTING_system_destroy(system, GNUNET_YES); | 1747 | GNUNET_TESTING_system_destroy (system, GNUNET_YES); |
1742 | return 0; | 1748 | return 0; |
1743 | } | 1749 | } |
1744 | 1750 | ||
@@ -1757,22 +1763,22 @@ GNUNET_TESTING_service_run(const char *testdir, | |||
1757 | * NULL if argv0 has no '_' | 1763 | * NULL if argv0 has no '_' |
1758 | */ | 1764 | */ |
1759 | char * | 1765 | char * |
1760 | GNUNET_TESTING_get_testname_from_underscore(const char *argv0) | 1766 | GNUNET_TESTING_get_testname_from_underscore (const char *argv0) |
1761 | { | 1767 | { |
1762 | size_t slen = strlen(argv0) + 1; | 1768 | size_t slen = strlen (argv0) + 1; |
1763 | char sbuf[slen]; | 1769 | char sbuf[slen]; |
1764 | char *ret; | 1770 | char *ret; |
1765 | char *dot; | 1771 | char *dot; |
1766 | 1772 | ||
1767 | GNUNET_memcpy(sbuf, argv0, slen); | 1773 | GNUNET_memcpy (sbuf, argv0, slen); |
1768 | ret = strrchr(sbuf, '_'); | 1774 | ret = strrchr (sbuf, '_'); |
1769 | if (NULL == ret) | 1775 | if (NULL == ret) |
1770 | return NULL; | 1776 | return NULL; |
1771 | ret++; /* skip underscore */ | 1777 | ret++; /* skip underscore */ |
1772 | dot = strchr(ret, '.'); | 1778 | dot = strchr (ret, '.'); |
1773 | if (NULL != dot) | 1779 | if (NULL != dot) |
1774 | *dot = '\0'; | 1780 | *dot = '\0'; |
1775 | return GNUNET_strdup(ret); | 1781 | return GNUNET_strdup (ret); |
1776 | } | 1782 | } |
1777 | 1783 | ||
1778 | 1784 | ||