diff options
Diffstat (limited to 'src/pt/test_gnunet_vpn.c')
-rw-r--r-- | src/pt/test_gnunet_vpn.c | 525 |
1 files changed, 266 insertions, 259 deletions
diff --git a/src/pt/test_gnunet_vpn.c b/src/pt/test_gnunet_vpn.c index c52c0c6c9..dcf3c5d93 100644 --- a/src/pt/test_gnunet_vpn.c +++ b/src/pt/test_gnunet_vpn.c | |||
@@ -32,7 +32,7 @@ | |||
32 | 32 | ||
33 | #define PORT 48080 | 33 | #define PORT 48080 |
34 | 34 | ||
35 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300) | 35 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300) |
36 | 36 | ||
37 | 37 | ||
38 | /** | 38 | /** |
@@ -74,7 +74,8 @@ static int dest_af; | |||
74 | static int src_af; | 74 | static int src_af; |
75 | 75 | ||
76 | 76 | ||
77 | struct CBC { | 77 | struct CBC |
78 | { | ||
78 | char buf[1024]; | 79 | char buf[1024]; |
79 | size_t pos; | 80 | size_t pos; |
80 | }; | 81 | }; |
@@ -83,87 +84,87 @@ static struct CBC cbc; | |||
83 | 84 | ||
84 | 85 | ||
85 | static size_t | 86 | static size_t |
86 | copy_buffer(void *ptr, size_t size, size_t nmemb, void *ctx) | 87 | copy_buffer (void *ptr, size_t size, size_t nmemb, void *ctx) |
87 | { | 88 | { |
88 | struct CBC *cbc = ctx; | 89 | struct CBC *cbc = ctx; |
89 | 90 | ||
90 | if (cbc->pos + size * nmemb > sizeof(cbc->buf)) | 91 | if (cbc->pos + size * nmemb > sizeof(cbc->buf)) |
91 | return 0; /* overflow */ | 92 | return 0; /* overflow */ |
92 | GNUNET_memcpy(&cbc->buf[cbc->pos], ptr, size * nmemb); | 93 | GNUNET_memcpy (&cbc->buf[cbc->pos], ptr, size * nmemb); |
93 | cbc->pos += size * nmemb; | 94 | cbc->pos += size * nmemb; |
94 | return size * nmemb; | 95 | return size * nmemb; |
95 | } | 96 | } |
96 | 97 | ||
97 | 98 | ||
98 | static int | 99 | static int |
99 | mhd_ahc(void *cls, | 100 | mhd_ahc (void *cls, |
100 | struct MHD_Connection *connection, | 101 | struct MHD_Connection *connection, |
101 | const char *url, | 102 | const char *url, |
102 | const char *method, | 103 | const char *method, |
103 | const char *version, | 104 | const char *version, |
104 | const char *upload_data, | 105 | const char *upload_data, |
105 | size_t * upload_data_size, | 106 | size_t *upload_data_size, |
106 | void **unused) | 107 | void **unused) |
107 | { | 108 | { |
108 | static int ptr; | 109 | static int ptr; |
109 | struct MHD_Response *response; | 110 | struct MHD_Response *response; |
110 | int ret; | 111 | int ret; |
111 | 112 | ||
112 | if (0 != strcmp("GET", method)) | 113 | if (0 != strcmp ("GET", method)) |
113 | return MHD_NO; /* unexpected method */ | 114 | return MHD_NO; /* unexpected method */ |
114 | if (&ptr != *unused) | 115 | if (&ptr != *unused) |
115 | { | 116 | { |
116 | *unused = &ptr; | 117 | *unused = &ptr; |
117 | return MHD_YES; | 118 | return MHD_YES; |
118 | } | 119 | } |
119 | *unused = NULL; | 120 | *unused = NULL; |
120 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 121 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
121 | "MHD sends respose for request to URL `%s'\n", url); | 122 | "MHD sends respose for request to URL `%s'\n", url); |
122 | response = | 123 | response = |
123 | MHD_create_response_from_buffer(strlen(url), (void *)url, | 124 | MHD_create_response_from_buffer (strlen (url), (void *) url, |
124 | MHD_RESPMEM_MUST_COPY); | 125 | MHD_RESPMEM_MUST_COPY); |
125 | ret = MHD_queue_response(connection, MHD_HTTP_OK, response); | 126 | ret = MHD_queue_response (connection, MHD_HTTP_OK, response); |
126 | MHD_destroy_response(response); | 127 | MHD_destroy_response (response); |
127 | if (ret == MHD_NO) | 128 | if (ret == MHD_NO) |
128 | abort(); | 129 | abort (); |
129 | return ret; | 130 | return ret; |
130 | } | 131 | } |
131 | 132 | ||
132 | 133 | ||
133 | static void | 134 | static void |
134 | do_shutdown(void *cls) | 135 | do_shutdown (void *cls) |
135 | { | 136 | { |
136 | if (NULL != mhd_task_id) | 137 | if (NULL != mhd_task_id) |
137 | { | 138 | { |
138 | GNUNET_SCHEDULER_cancel(mhd_task_id); | 139 | GNUNET_SCHEDULER_cancel (mhd_task_id); |
139 | mhd_task_id = NULL; | 140 | mhd_task_id = NULL; |
140 | } | 141 | } |
141 | if (NULL != curl_task_id) | 142 | if (NULL != curl_task_id) |
142 | { | 143 | { |
143 | GNUNET_SCHEDULER_cancel(curl_task_id); | 144 | GNUNET_SCHEDULER_cancel (curl_task_id); |
144 | curl_task_id = NULL; | 145 | curl_task_id = NULL; |
145 | } | 146 | } |
146 | if (NULL != timeout_task_id) | 147 | if (NULL != timeout_task_id) |
147 | { | 148 | { |
148 | GNUNET_SCHEDULER_cancel(timeout_task_id); | 149 | GNUNET_SCHEDULER_cancel (timeout_task_id); |
149 | timeout_task_id = NULL; | 150 | timeout_task_id = NULL; |
150 | } | 151 | } |
151 | if (NULL != mhd) | 152 | if (NULL != mhd) |
152 | { | 153 | { |
153 | MHD_stop_daemon(mhd); | 154 | MHD_stop_daemon (mhd); |
154 | mhd = NULL; | 155 | mhd = NULL; |
155 | } | 156 | } |
156 | if (NULL != rr) | 157 | if (NULL != rr) |
157 | { | 158 | { |
158 | GNUNET_VPN_cancel_request(rr); | 159 | GNUNET_VPN_cancel_request (rr); |
159 | rr = NULL; | 160 | rr = NULL; |
160 | } | 161 | } |
161 | if (NULL != vpn) | 162 | if (NULL != vpn) |
162 | { | 163 | { |
163 | GNUNET_VPN_disconnect(vpn); | 164 | GNUNET_VPN_disconnect (vpn); |
164 | vpn = NULL; | 165 | vpn = NULL; |
165 | } | 166 | } |
166 | GNUNET_free_non_null(url); | 167 | GNUNET_free_non_null (url); |
167 | url = NULL; | 168 | url = NULL; |
168 | } | 169 | } |
169 | 170 | ||
@@ -172,7 +173,7 @@ do_shutdown(void *cls) | |||
172 | * Function to run the HTTP client. | 173 | * Function to run the HTTP client. |
173 | */ | 174 | */ |
174 | static void | 175 | static void |
175 | curl_main(void *cls) | 176 | curl_main (void *cls) |
176 | { | 177 | { |
177 | fd_set rs; | 178 | fd_set rs; |
178 | fd_set ws; | 179 | fd_set ws; |
@@ -187,55 +188,55 @@ curl_main(void *cls) | |||
187 | 188 | ||
188 | curl_task_id = NULL; | 189 | curl_task_id = NULL; |
189 | max = 0; | 190 | max = 0; |
190 | FD_ZERO(&rs); | 191 | FD_ZERO (&rs); |
191 | FD_ZERO(&ws); | 192 | FD_ZERO (&ws); |
192 | FD_ZERO(&es); | 193 | FD_ZERO (&es); |
193 | curl_multi_perform(multi, &running); | 194 | curl_multi_perform (multi, &running); |
194 | if (running == 0) | 195 | if (running == 0) |
196 | { | ||
197 | GNUNET_assert (NULL != (msg = curl_multi_info_read (multi, &running))); | ||
198 | if (msg->msg == CURLMSG_DONE) | ||
199 | { | ||
200 | if (msg->data.result != CURLE_OK) | ||
201 | { | ||
202 | fprintf (stderr, "%s failed at %s:%d: `%s'\n", "curl_multi_perform", | ||
203 | __FILE__, __LINE__, curl_easy_strerror (msg->data.result)); | ||
204 | global_ret = 1; | ||
205 | } | ||
206 | } | ||
207 | curl_multi_remove_handle (multi, curl); | ||
208 | curl_multi_cleanup (multi); | ||
209 | curl_easy_cleanup (curl); | ||
210 | curl = NULL; | ||
211 | multi = NULL; | ||
212 | if (cbc.pos != strlen ("/hello_world")) | ||
213 | { | ||
214 | GNUNET_break (0); | ||
215 | global_ret = 2; | ||
216 | } | ||
217 | if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world"))) | ||
195 | { | 218 | { |
196 | GNUNET_assert(NULL != (msg = curl_multi_info_read(multi, &running))); | 219 | GNUNET_break (0); |
197 | if (msg->msg == CURLMSG_DONE) | 220 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
198 | { | 221 | "You might want to check if your host-based firewall is blocking the connections.\n"); |
199 | if (msg->data.result != CURLE_OK) | 222 | global_ret = 3; |
200 | { | ||
201 | fprintf(stderr, "%s failed at %s:%d: `%s'\n", "curl_multi_perform", | ||
202 | __FILE__, __LINE__, curl_easy_strerror(msg->data.result)); | ||
203 | global_ret = 1; | ||
204 | } | ||
205 | } | ||
206 | curl_multi_remove_handle(multi, curl); | ||
207 | curl_multi_cleanup(multi); | ||
208 | curl_easy_cleanup(curl); | ||
209 | curl = NULL; | ||
210 | multi = NULL; | ||
211 | if (cbc.pos != strlen("/hello_world")) | ||
212 | { | ||
213 | GNUNET_break(0); | ||
214 | global_ret = 2; | ||
215 | } | ||
216 | if (0 != strncmp("/hello_world", cbc.buf, strlen("/hello_world"))) | ||
217 | { | ||
218 | GNUNET_break(0); | ||
219 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | ||
220 | "You might want to check if your host-based firewall is blocking the connections.\n"); | ||
221 | global_ret = 3; | ||
222 | } | ||
223 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!\n"); | ||
224 | GNUNET_SCHEDULER_shutdown(); | ||
225 | return; | ||
226 | } | 223 | } |
227 | GNUNET_assert(CURLM_OK == curl_multi_fdset(multi, &rs, &ws, &es, &max)); | 224 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!\n"); |
228 | if ((CURLM_OK != curl_multi_timeout(multi, &timeout)) || (-1 == timeout)) | 225 | GNUNET_SCHEDULER_shutdown (); |
226 | return; | ||
227 | } | ||
228 | GNUNET_assert (CURLM_OK == curl_multi_fdset (multi, &rs, &ws, &es, &max)); | ||
229 | if ((CURLM_OK != curl_multi_timeout (multi, &timeout)) || (-1 == timeout)) | ||
229 | delay = GNUNET_TIME_UNIT_SECONDS; | 230 | delay = GNUNET_TIME_UNIT_SECONDS; |
230 | else | 231 | else |
231 | delay = | 232 | delay = |
232 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, | 233 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, |
233 | (unsigned int)timeout); | 234 | (unsigned int) timeout); |
234 | GNUNET_NETWORK_fdset_copy_native(&nrs, &rs, max + 1); | 235 | GNUNET_NETWORK_fdset_copy_native (&nrs, &rs, max + 1); |
235 | GNUNET_NETWORK_fdset_copy_native(&nws, &ws, max + 1); | 236 | GNUNET_NETWORK_fdset_copy_native (&nws, &ws, max + 1); |
236 | curl_task_id = | 237 | curl_task_id = |
237 | GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay, | 238 | GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay, |
238 | &nrs, &nws, &curl_main, NULL); | 239 | &nrs, &nws, &curl_main, NULL); |
239 | } | 240 | } |
240 | 241 | ||
241 | 242 | ||
@@ -253,53 +254,53 @@ curl_main(void *cls) | |||
253 | * specified target peer; NULL on error | 254 | * specified target peer; NULL on error |
254 | */ | 255 | */ |
255 | static void | 256 | static void |
256 | allocation_cb(void *cls, int af, const void *address) | 257 | allocation_cb (void *cls, int af, const void *address) |
257 | { | 258 | { |
258 | char ips[INET6_ADDRSTRLEN]; | 259 | char ips[INET6_ADDRSTRLEN]; |
259 | 260 | ||
260 | rr = NULL; | 261 | rr = NULL; |
261 | if (src_af != af) | 262 | if (src_af != af) |
262 | { | 263 | { |
263 | fprintf(stderr, | 264 | fprintf (stderr, |
264 | "VPN failed to allocate appropriate address\n"); | 265 | "VPN failed to allocate appropriate address\n"); |
265 | GNUNET_SCHEDULER_shutdown(); | 266 | GNUNET_SCHEDULER_shutdown (); |
266 | return; | 267 | return; |
267 | } | 268 | } |
268 | if (AF_INET6 == af) | 269 | if (AF_INET6 == af) |
269 | GNUNET_asprintf(&url, | 270 | GNUNET_asprintf (&url, |
270 | "http://[%s]:%u/hello_world", | 271 | "http://[%s]:%u/hello_world", |
271 | inet_ntop(af, | 272 | inet_ntop (af, |
272 | address, | 273 | address, |
273 | ips, | 274 | ips, |
274 | sizeof(ips)), | 275 | sizeof(ips)), |
275 | (unsigned int)PORT); | 276 | (unsigned int) PORT); |
276 | else | 277 | else |
277 | GNUNET_asprintf(&url, | 278 | GNUNET_asprintf (&url, |
278 | "http://%s:%u/hello_world", | 279 | "http://%s:%u/hello_world", |
279 | inet_ntop(af, | 280 | inet_ntop (af, |
280 | address, | 281 | address, |
281 | ips, | 282 | ips, |
282 | sizeof(ips)), | 283 | sizeof(ips)), |
283 | (unsigned int)PORT); | 284 | (unsigned int) PORT); |
284 | curl = curl_easy_init(); | 285 | curl = curl_easy_init (); |
285 | curl_easy_setopt(curl, CURLOPT_URL, url); | 286 | curl_easy_setopt (curl, CURLOPT_URL, url); |
286 | curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ©_buffer); | 287 | curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, ©_buffer); |
287 | curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbc); | 288 | curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbc); |
288 | curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1); | 289 | curl_easy_setopt (curl, CURLOPT_FAILONERROR, 1); |
289 | curl_easy_setopt(curl, CURLOPT_TIMEOUT, 150L); | 290 | curl_easy_setopt (curl, CURLOPT_TIMEOUT, 150L); |
290 | curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 15L); | 291 | curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, 15L); |
291 | curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); | 292 | curl_easy_setopt (curl, CURLOPT_NOSIGNAL, 1); |
292 | curl_easy_setopt(curl, CURLOPT_VERBOSE, 0); | 293 | curl_easy_setopt (curl, CURLOPT_VERBOSE, 0); |
293 | 294 | ||
294 | multi = curl_multi_init(); | 295 | multi = curl_multi_init (); |
295 | GNUNET_assert(multi != NULL); | 296 | GNUNET_assert (multi != NULL); |
296 | GNUNET_assert(CURLM_OK == curl_multi_add_handle(multi, curl)); | 297 | GNUNET_assert (CURLM_OK == curl_multi_add_handle (multi, curl)); |
297 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 298 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
298 | "Beginning HTTP download from `%s'\n", | 299 | "Beginning HTTP download from `%s'\n", |
299 | url); | 300 | url); |
300 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | 301 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
301 | &curl_main, | 302 | &curl_main, |
302 | NULL); | 303 | NULL); |
303 | } | 304 | } |
304 | 305 | ||
305 | 306 | ||
@@ -307,30 +308,30 @@ allocation_cb(void *cls, int af, const void *address) | |||
307 | * Function to keep the HTTP server running. | 308 | * Function to keep the HTTP server running. |
308 | */ | 309 | */ |
309 | static void | 310 | static void |
310 | mhd_main(void); | 311 | mhd_main (void); |
311 | 312 | ||
312 | 313 | ||
313 | static void | 314 | static void |
314 | mhd_task(void *cls) | 315 | mhd_task (void *cls) |
315 | { | 316 | { |
316 | mhd_task_id = NULL; | 317 | mhd_task_id = NULL; |
317 | MHD_run(mhd); | 318 | MHD_run (mhd); |
318 | mhd_main(); | 319 | mhd_main (); |
319 | } | 320 | } |
320 | 321 | ||
321 | 322 | ||
322 | static void | 323 | static void |
323 | do_timeout(void *cls) | 324 | do_timeout (void *cls) |
324 | { | 325 | { |
325 | timeout_task_id = NULL; | 326 | timeout_task_id = NULL; |
326 | GNUNET_SCHEDULER_shutdown(); | 327 | GNUNET_SCHEDULER_shutdown (); |
327 | GNUNET_break(0); | 328 | GNUNET_break (0); |
328 | global_ret = 1; | 329 | global_ret = 1; |
329 | } | 330 | } |
330 | 331 | ||
331 | 332 | ||
332 | static void | 333 | static void |
333 | mhd_main() | 334 | mhd_main () |
334 | { | 335 | { |
335 | struct GNUNET_NETWORK_FDSet nrs; | 336 | struct GNUNET_NETWORK_FDSet nrs; |
336 | struct GNUNET_NETWORK_FDSet nws; | 337 | struct GNUNET_NETWORK_FDSet nws; |
@@ -341,78 +342,78 @@ mhd_main() | |||
341 | unsigned MHD_LONG_LONG timeout; | 342 | unsigned MHD_LONG_LONG timeout; |
342 | struct GNUNET_TIME_Relative delay; | 343 | struct GNUNET_TIME_Relative delay; |
343 | 344 | ||
344 | GNUNET_assert(NULL == mhd_task_id); | 345 | GNUNET_assert (NULL == mhd_task_id); |
345 | FD_ZERO(&rs); | 346 | FD_ZERO (&rs); |
346 | FD_ZERO(&ws); | 347 | FD_ZERO (&ws); |
347 | FD_ZERO(&es); | 348 | FD_ZERO (&es); |
348 | max_fd = -1; | 349 | max_fd = -1; |
349 | GNUNET_assert(MHD_YES == MHD_get_fdset(mhd, &rs, &ws, &es, &max_fd)); | 350 | GNUNET_assert (MHD_YES == MHD_get_fdset (mhd, &rs, &ws, &es, &max_fd)); |
350 | if (MHD_YES == MHD_get_timeout(mhd, &timeout)) | 351 | if (MHD_YES == MHD_get_timeout (mhd, &timeout)) |
351 | delay = | 352 | delay = |
352 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, | 353 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, |
353 | (unsigned int)timeout); | 354 | (unsigned int) timeout); |
354 | else | 355 | else |
355 | delay = GNUNET_TIME_UNIT_FOREVER_REL; | 356 | delay = GNUNET_TIME_UNIT_FOREVER_REL; |
356 | GNUNET_NETWORK_fdset_copy_native(&nrs, &rs, max_fd + 1); | 357 | GNUNET_NETWORK_fdset_copy_native (&nrs, &rs, max_fd + 1); |
357 | GNUNET_NETWORK_fdset_copy_native(&nws, &ws, max_fd + 1); | 358 | GNUNET_NETWORK_fdset_copy_native (&nws, &ws, max_fd + 1); |
358 | mhd_task_id = | 359 | mhd_task_id = |
359 | GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay, | 360 | GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay, |
360 | &nrs, &nws, &mhd_task, NULL); | 361 | &nrs, &nws, &mhd_task, NULL); |
361 | } | 362 | } |
362 | 363 | ||
363 | 364 | ||
364 | static void | 365 | static void |
365 | run(void *cls, | 366 | run (void *cls, |
366 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 367 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
367 | struct GNUNET_TESTING_Peer *peer) | 368 | struct GNUNET_TESTING_Peer *peer) |
368 | { | 369 | { |
369 | struct in_addr v4; | 370 | struct in_addr v4; |
370 | struct in6_addr v6; | 371 | struct in6_addr v6; |
371 | void *addr; | 372 | void *addr; |
372 | enum MHD_FLAG flags; | 373 | enum MHD_FLAG flags; |
373 | 374 | ||
374 | vpn = GNUNET_VPN_connect(cfg); | 375 | vpn = GNUNET_VPN_connect (cfg); |
375 | GNUNET_assert(NULL != vpn); | 376 | GNUNET_assert (NULL != vpn); |
376 | flags = MHD_USE_DEBUG; | 377 | flags = MHD_USE_DEBUG; |
377 | if (AF_INET6 == dest_af) | 378 | if (AF_INET6 == dest_af) |
378 | flags |= MHD_USE_IPv6; | 379 | flags |= MHD_USE_IPv6; |
379 | mhd = | 380 | mhd = |
380 | MHD_start_daemon(flags, PORT, NULL, NULL, &mhd_ahc, NULL, | 381 | MHD_start_daemon (flags, PORT, NULL, NULL, &mhd_ahc, NULL, |
381 | MHD_OPTION_END); | 382 | MHD_OPTION_END); |
382 | 383 | ||
383 | 384 | ||
384 | GNUNET_assert(NULL != mhd); | 385 | GNUNET_assert (NULL != mhd); |
385 | mhd_main(); | 386 | mhd_main (); |
386 | addr = NULL; | 387 | addr = NULL; |
387 | switch (dest_af) | 388 | switch (dest_af) |
388 | { | 389 | { |
389 | case AF_INET: | 390 | case AF_INET: |
390 | GNUNET_assert(1 == inet_pton(dest_af, dest_ip, &v4)); | 391 | GNUNET_assert (1 == inet_pton (dest_af, dest_ip, &v4)); |
391 | addr = &v4; | 392 | addr = &v4; |
392 | break; | 393 | break; |
393 | 394 | ||
394 | case AF_INET6: | 395 | case AF_INET6: |
395 | GNUNET_assert(1 == inet_pton(dest_af, dest_ip, &v6)); | 396 | GNUNET_assert (1 == inet_pton (dest_af, dest_ip, &v6)); |
396 | addr = &v6; | 397 | addr = &v6; |
397 | break; | 398 | break; |
398 | 399 | ||
399 | default: | 400 | default: |
400 | GNUNET_assert(0); | 401 | GNUNET_assert (0); |
401 | } | 402 | } |
402 | rr = GNUNET_VPN_redirect_to_ip(vpn, src_af, dest_af, addr, | 403 | rr = GNUNET_VPN_redirect_to_ip (vpn, src_af, dest_af, addr, |
403 | GNUNET_TIME_UNIT_FOREVER_ABS, &allocation_cb, | 404 | GNUNET_TIME_UNIT_FOREVER_ABS, &allocation_cb, |
404 | NULL); | 405 | NULL); |
405 | timeout_task_id = | 406 | timeout_task_id = |
406 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, | 407 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
407 | &do_timeout, | 408 | &do_timeout, |
409 | NULL); | ||
410 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | ||
408 | NULL); | 411 | NULL); |
409 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, | ||
410 | NULL); | ||
411 | } | 412 | } |
412 | 413 | ||
413 | 414 | ||
414 | int | 415 | int |
415 | main(int argc, char *const *argv) | 416 | main (int argc, char *const *argv) |
416 | { | 417 | { |
417 | const char *type; | 418 | const char *type; |
418 | const char *bin; | 419 | const char *bin; |
@@ -420,90 +421,96 @@ main(int argc, char *const *argv) | |||
420 | char *exit_binary; | 421 | char *exit_binary; |
421 | int ret = 0; | 422 | int ret = 0; |
422 | 423 | ||
423 | if (0 != access("/dev/net/tun", R_OK)) | 424 | if (0 != access ("/dev/net/tun", R_OK)) |
424 | { | 425 | { |
425 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, | 426 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, |
426 | "access", | 427 | "access", |
427 | "/dev/net/tun"); | 428 | "/dev/net/tun"); |
428 | fprintf(stderr, | 429 | fprintf (stderr, |
429 | "WARNING: System unable to run test, skipping.\n"); | 430 | "WARNING: System unable to run test, skipping.\n"); |
430 | return 77; | 431 | return 77; |
431 | } | 432 | } |
432 | 433 | ||
433 | vpn_binary = GNUNET_OS_get_libexec_binary_path("gnunet-helper-vpn"); | 434 | vpn_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-vpn"); |
434 | exit_binary = GNUNET_OS_get_libexec_binary_path("gnunet-helper-exit"); | 435 | exit_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-exit"); |
435 | if ((GNUNET_YES != (ret = GNUNET_OS_check_helper_binary(vpn_binary, GNUNET_YES, "-d gnunet-vpn - - 169.1.3.3.7 255.255.255.0"))) || //ipv4 only please! | 436 | if ((GNUNET_YES != (ret = GNUNET_OS_check_helper_binary (vpn_binary, |
436 | (GNUNET_YES != (ret = GNUNET_OS_check_helper_binary(exit_binary, GNUNET_YES, "-d gnunet-vpn - - - 169.1.3.3.7 255.255.255.0")))) //no nat, ipv4 only | 437 | GNUNET_YES, |
437 | { | 438 | "-d gnunet-vpn - - 169.1.3.3.7 255.255.255.0"))) |
438 | GNUNET_free(vpn_binary); | 439 | || // ipv4 only please! |
439 | GNUNET_free(exit_binary); | 440 | (GNUNET_YES != (ret = GNUNET_OS_check_helper_binary (exit_binary, |
440 | fprintf(stderr, | 441 | GNUNET_YES, |
441 | "WARNING: gnunet-helper-{exit,vpn} binaries are not SUID, refusing to run test (as it would have to fail). %d\n", ret); | 442 | "-d gnunet-vpn - - - 169.1.3.3.7 255.255.255.0")))) // no nat, ipv4 only |
442 | return 77; | 443 | { |
443 | } | 444 | GNUNET_free (vpn_binary); |
444 | 445 | GNUNET_free (exit_binary); | |
445 | GNUNET_free(vpn_binary); | 446 | fprintf (stderr, |
446 | GNUNET_free(exit_binary); | 447 | "WARNING: gnunet-helper-{exit,vpn} binaries are not SUID, refusing to run test (as it would have to fail). %d\n", |
448 | ret); | ||
449 | return 77; | ||
450 | } | ||
451 | |||
452 | GNUNET_free (vpn_binary); | ||
453 | GNUNET_free (exit_binary); | ||
447 | bin = argv[0]; | 454 | bin = argv[0]; |
448 | if (NULL != strstr(bin, "lt-")) | 455 | if (NULL != strstr (bin, "lt-")) |
449 | bin = strstr(bin, "lt-") + 4; | 456 | bin = strstr (bin, "lt-") + 4; |
450 | type = strstr(bin, "-"); | 457 | type = strstr (bin, "-"); |
451 | if (NULL == type) | 458 | if (NULL == type) |
452 | { | 459 | { |
453 | fprintf(stderr, | 460 | fprintf (stderr, |
454 | "invalid binary name\n"); | 461 | "invalid binary name\n"); |
455 | return 1; | 462 | return 1; |
456 | } | 463 | } |
457 | type++; | 464 | type++; |
458 | /* on Windows, .exe is suffixed to these binaries, | 465 | /* on Windows, .exe is suffixed to these binaries, |
459 | * thus cease comparison after the 6th char. | 466 | * thus cease comparison after the 6th char. |
460 | */ | 467 | */ |
461 | if (0 == strncmp(type, "4_to_6", 6)) | 468 | if (0 == strncmp (type, "4_to_6", 6)) |
462 | { | 469 | { |
463 | dest_ip = "FC5A:04E1:C2BA::1"; | 470 | dest_ip = "FC5A:04E1:C2BA::1"; |
464 | dest_af = AF_INET6; | 471 | dest_af = AF_INET6; |
465 | src_af = AF_INET; | 472 | src_af = AF_INET; |
466 | } | 473 | } |
467 | else if (0 == strncmp(type, "6_to_4", 6)) | 474 | else if (0 == strncmp (type, "6_to_4", 6)) |
468 | { | 475 | { |
469 | dest_ip = "169.254.86.1"; | 476 | dest_ip = "169.254.86.1"; |
470 | dest_af = AF_INET; | 477 | dest_af = AF_INET; |
471 | src_af = AF_INET6; | 478 | src_af = AF_INET6; |
472 | } | 479 | } |
473 | else if (0 == strncmp(type, "4_over", 6)) | 480 | else if (0 == strncmp (type, "4_over", 6)) |
474 | { | 481 | { |
475 | dest_ip = "169.254.86.1"; | 482 | dest_ip = "169.254.86.1"; |
476 | dest_af = AF_INET; | 483 | dest_af = AF_INET; |
477 | src_af = AF_INET; | 484 | src_af = AF_INET; |
478 | } | 485 | } |
479 | else if (0 == strncmp(type, "6_over", 6)) | 486 | else if (0 == strncmp (type, "6_over", 6)) |
480 | { | 487 | { |
481 | dest_ip = "FC5A:04E1:C2BA::1"; | 488 | dest_ip = "FC5A:04E1:C2BA::1"; |
482 | dest_af = AF_INET6; | 489 | dest_af = AF_INET6; |
483 | src_af = AF_INET6; | 490 | src_af = AF_INET6; |
484 | } | 491 | } |
485 | else | 492 | else |
486 | { | 493 | { |
487 | fprintf(stderr, "invalid binary suffix `%s'\n", type); | 494 | fprintf (stderr, "invalid binary suffix `%s'\n", type); |
488 | return 1; | 495 | return 1; |
489 | } | 496 | } |
490 | if ((GNUNET_OK != GNUNET_NETWORK_test_pf(src_af)) || | 497 | if ((GNUNET_OK != GNUNET_NETWORK_test_pf (src_af)) || |
491 | (GNUNET_OK != GNUNET_NETWORK_test_pf(dest_af))) | 498 | (GNUNET_OK != GNUNET_NETWORK_test_pf (dest_af))) |
492 | { | 499 | { |
493 | fprintf(stderr, | 500 | fprintf (stderr, |
494 | "Required address families not supported by this system, skipping test.\n"); | 501 | "Required address families not supported by this system, skipping test.\n"); |
495 | return 0; | 502 | return 0; |
496 | } | 503 | } |
497 | if (0 != curl_global_init(CURL_GLOBAL_WIN32)) | 504 | if (0 != curl_global_init (CURL_GLOBAL_WIN32)) |
498 | { | 505 | { |
499 | fprintf(stderr, "failed to initialize curl\n"); | 506 | fprintf (stderr, "failed to initialize curl\n"); |
500 | return 2; | 507 | return 2; |
501 | } | 508 | } |
502 | if (0 != | 509 | if (0 != |
503 | GNUNET_TESTING_peer_run("test-gnunet-vpn", "test_gnunet_vpn.conf", &run, | 510 | GNUNET_TESTING_peer_run ("test-gnunet-vpn", "test_gnunet_vpn.conf", &run, |
504 | NULL)) | 511 | NULL)) |
505 | return 1; | 512 | return 1; |
506 | GNUNET_DISK_directory_remove("/tmp/gnunet-test-vpn"); | 513 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-vpn"); |
507 | return global_ret; | 514 | return global_ret; |
508 | } | 515 | } |
509 | 516 | ||