diff options
Diffstat (limited to 'src/nat-auto')
-rw-r--r-- | src/nat-auto/gnunet-nat-auto.c | 288 | ||||
-rw-r--r-- | src/nat-auto/gnunet-nat-auto_legacy.c | 476 | ||||
-rw-r--r-- | src/nat-auto/gnunet-nat-server.c | 300 | ||||
-rw-r--r-- | src/nat-auto/gnunet-service-nat-auto.c | 327 | ||||
-rw-r--r-- | src/nat-auto/gnunet-service-nat-auto_legacy.c | 1008 | ||||
-rw-r--r-- | src/nat-auto/nat-auto.h | 17 | ||||
-rw-r--r-- | src/nat-auto/nat_auto_api.c | 264 | ||||
-rw-r--r-- | src/nat-auto/nat_auto_api_test.c | 490 |
8 files changed, 1586 insertions, 1584 deletions
diff --git a/src/nat-auto/gnunet-nat-auto.c b/src/nat-auto/gnunet-nat-auto.c index 106d60228..87850509d 100644 --- a/src/nat-auto/gnunet-nat-auto.c +++ b/src/nat-auto/gnunet-nat-auto.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/nat/gnunet-nat-auto.c | 22 | * @file src/nat/gnunet-nat-auto.c |
@@ -90,13 +90,13 @@ static uint8_t proto; | |||
90 | * terminate. | 90 | * terminate. |
91 | */ | 91 | */ |
92 | static void | 92 | static void |
93 | test_finished () | 93 | test_finished() |
94 | { | 94 | { |
95 | if (NULL != ah) | 95 | if (NULL != ah) |
96 | return; | 96 | return; |
97 | if (NULL != nt) | 97 | if (NULL != nt) |
98 | return; | 98 | return; |
99 | GNUNET_SCHEDULER_shutdown (); | 99 | GNUNET_SCHEDULER_shutdown(); |
100 | } | 100 | } |
101 | 101 | ||
102 | 102 | ||
@@ -109,16 +109,16 @@ test_finished () | |||
109 | * @param value value of the option | 109 | * @param value value of the option |
110 | */ | 110 | */ |
111 | static void | 111 | static void |
112 | auto_conf_iter (void *cls, | 112 | auto_conf_iter(void *cls, |
113 | const char *section, | 113 | const char *section, |
114 | const char *option, | 114 | const char *option, |
115 | const char *value) | 115 | const char *value) |
116 | { | 116 | { |
117 | struct GNUNET_CONFIGURATION_Handle *new_cfg = cls; | 117 | struct GNUNET_CONFIGURATION_Handle *new_cfg = cls; |
118 | 118 | ||
119 | printf ("%s: %s\n", option, value); | 119 | printf("%s: %s\n", option, value); |
120 | if (NULL != new_cfg) | 120 | if (NULL != new_cfg) |
121 | GNUNET_CONFIGURATION_set_value_string (new_cfg, section, option, value); | 121 | GNUNET_CONFIGURATION_set_value_string(new_cfg, section, option, value); |
122 | } | 122 | } |
123 | 123 | ||
124 | 124 | ||
@@ -132,10 +132,10 @@ auto_conf_iter (void *cls, | |||
132 | * @param type what the situation of the NAT | 132 | * @param type what the situation of the NAT |
133 | */ | 133 | */ |
134 | static void | 134 | static void |
135 | auto_config_cb (void *cls, | 135 | auto_config_cb(void *cls, |
136 | const struct GNUNET_CONFIGURATION_Handle *diff, | 136 | const struct GNUNET_CONFIGURATION_Handle *diff, |
137 | enum GNUNET_NAT_StatusCode result, | 137 | enum GNUNET_NAT_StatusCode result, |
138 | enum GNUNET_NAT_Type type) | 138 | enum GNUNET_NAT_Type type) |
139 | { | 139 | { |
140 | const char *nat_type; | 140 | const char *nat_type; |
141 | char unknown_type[64]; | 141 | char unknown_type[64]; |
@@ -143,80 +143,84 @@ auto_config_cb (void *cls, | |||
143 | 143 | ||
144 | ah = NULL; | 144 | ah = NULL; |
145 | switch (type) | 145 | switch (type) |
146 | { | 146 | { |
147 | case GNUNET_NAT_TYPE_NO_NAT: | 147 | case GNUNET_NAT_TYPE_NO_NAT: |
148 | nat_type = "NO NAT"; | 148 | nat_type = "NO NAT"; |
149 | break; | 149 | break; |
150 | case GNUNET_NAT_TYPE_UNREACHABLE_NAT: | 150 | |
151 | nat_type = "NAT but we can traverse"; | 151 | case GNUNET_NAT_TYPE_UNREACHABLE_NAT: |
152 | break; | 152 | nat_type = "NAT but we can traverse"; |
153 | case GNUNET_NAT_TYPE_STUN_PUNCHED_NAT: | 153 | break; |
154 | nat_type = "NAT but STUN is able to identify the correct information"; | 154 | |
155 | break; | 155 | case GNUNET_NAT_TYPE_STUN_PUNCHED_NAT: |
156 | case GNUNET_NAT_TYPE_UPNP_NAT: | 156 | nat_type = "NAT but STUN is able to identify the correct information"; |
157 | nat_type = "NAT but UPNP opened the ports"; | 157 | break; |
158 | break; | 158 | |
159 | default: | 159 | case GNUNET_NAT_TYPE_UPNP_NAT: |
160 | sprintf (unknown_type, "NAT unknown, type %u", type); | 160 | nat_type = "NAT but UPNP opened the ports"; |
161 | nat_type = unknown_type; | 161 | break; |
162 | break; | 162 | |
163 | } | 163 | default: |
164 | 164 | sprintf(unknown_type, "NAT unknown, type %u", type); | |
165 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | 165 | nat_type = unknown_type; |
166 | "NAT status: %s/%s\n", | 166 | break; |
167 | GNUNET_NAT_AUTO_status2string (result), | 167 | } |
168 | nat_type); | 168 | |
169 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
170 | "NAT status: %s/%s\n", | ||
171 | GNUNET_NAT_AUTO_status2string(result), | ||
172 | nat_type); | ||
169 | 173 | ||
170 | if (NULL == diff) | 174 | if (NULL == diff) |
171 | return; | 175 | return; |
172 | 176 | ||
173 | /* Shortcut: if there are no changes suggested, bail out early. */ | 177 | /* Shortcut: if there are no changes suggested, bail out early. */ |
174 | if (GNUNET_NO == GNUNET_CONFIGURATION_is_dirty (diff)) | 178 | if (GNUNET_NO == GNUNET_CONFIGURATION_is_dirty(diff)) |
175 | { | 179 | { |
176 | test_finished (); | 180 | test_finished(); |
177 | return; | 181 | return; |
178 | } | 182 | } |
179 | 183 | ||
180 | /* Apply diff to original configuration and show changes | 184 | /* Apply diff to original configuration and show changes |
181 | to the user */ | 185 | to the user */ |
182 | new_cfg = write_cfg ? GNUNET_CONFIGURATION_dup (cfg) : NULL; | 186 | new_cfg = write_cfg ? GNUNET_CONFIGURATION_dup(cfg) : NULL; |
183 | 187 | ||
184 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | 188 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, |
185 | _ ("Suggested configuration changes:\n")); | 189 | _("Suggested configuration changes:\n")); |
186 | GNUNET_CONFIGURATION_iterate_section_values (diff, | 190 | GNUNET_CONFIGURATION_iterate_section_values(diff, |
187 | "nat", | 191 | "nat", |
188 | &auto_conf_iter, | 192 | &auto_conf_iter, |
189 | new_cfg); | 193 | new_cfg); |
190 | 194 | ||
191 | /* If desired, write configuration to file; we write only the | 195 | /* If desired, write configuration to file; we write only the |
192 | changes to the defaults to keep things compact. */ | 196 | changes to the defaults to keep things compact. */ |
193 | if (write_cfg) | 197 | if (write_cfg) |
194 | { | ||
195 | struct GNUNET_CONFIGURATION_Handle *def_cfg; | ||
196 | |||
197 | GNUNET_CONFIGURATION_set_value_string (new_cfg, "ARM", "CONFIG", NULL); | ||
198 | def_cfg = GNUNET_CONFIGURATION_create (); | ||
199 | GNUNET_break (GNUNET_OK == GNUNET_CONFIGURATION_load (def_cfg, NULL)); | ||
200 | if (GNUNET_OK != | ||
201 | GNUNET_CONFIGURATION_write_diffs (def_cfg, new_cfg, cfg_file)) | ||
202 | { | 198 | { |
203 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | 199 | struct GNUNET_CONFIGURATION_Handle *def_cfg; |
204 | _ ("Failed to write configuration to `%s'\n"), | 200 | |
205 | cfg_file); | 201 | GNUNET_CONFIGURATION_set_value_string(new_cfg, "ARM", "CONFIG", NULL); |
206 | global_ret = 1; | 202 | def_cfg = GNUNET_CONFIGURATION_create(); |
203 | GNUNET_break(GNUNET_OK == GNUNET_CONFIGURATION_load(def_cfg, NULL)); | ||
204 | if (GNUNET_OK != | ||
205 | GNUNET_CONFIGURATION_write_diffs(def_cfg, new_cfg, cfg_file)) | ||
206 | { | ||
207 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
208 | _("Failed to write configuration to `%s'\n"), | ||
209 | cfg_file); | ||
210 | global_ret = 1; | ||
211 | } | ||
212 | else | ||
213 | { | ||
214 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
215 | _("Wrote updated configuration to `%s'\n"), | ||
216 | cfg_file); | ||
217 | } | ||
218 | GNUNET_CONFIGURATION_destroy(def_cfg); | ||
207 | } | 219 | } |
208 | else | ||
209 | { | ||
210 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | ||
211 | _ ("Wrote updated configuration to `%s'\n"), | ||
212 | cfg_file); | ||
213 | } | ||
214 | GNUNET_CONFIGURATION_destroy (def_cfg); | ||
215 | } | ||
216 | 220 | ||
217 | if (NULL != new_cfg) | 221 | if (NULL != new_cfg) |
218 | GNUNET_CONFIGURATION_destroy (new_cfg); | 222 | GNUNET_CONFIGURATION_destroy(new_cfg); |
219 | test_finished (); | 223 | test_finished(); |
220 | } | 224 | } |
221 | 225 | ||
222 | 226 | ||
@@ -228,11 +232,11 @@ auto_config_cb (void *cls, | |||
228 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code | 232 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code |
229 | */ | 233 | */ |
230 | static void | 234 | static void |
231 | test_report_cb (void *cls, enum GNUNET_NAT_StatusCode result) | 235 | test_report_cb(void *cls, enum GNUNET_NAT_StatusCode result) |
232 | { | 236 | { |
233 | nt = NULL; | 237 | nt = NULL; |
234 | printf ("NAT test result: %s\n", GNUNET_NAT_AUTO_status2string (result)); | 238 | printf("NAT test result: %s\n", GNUNET_NAT_AUTO_status2string(result)); |
235 | test_finished (); | 239 | test_finished(); |
236 | } | 240 | } |
237 | 241 | ||
238 | 242 | ||
@@ -242,18 +246,18 @@ test_report_cb (void *cls, enum GNUNET_NAT_StatusCode result) | |||
242 | * @param cls NULL | 246 | * @param cls NULL |
243 | */ | 247 | */ |
244 | static void | 248 | static void |
245 | do_shutdown (void *cls) | 249 | do_shutdown(void *cls) |
246 | { | 250 | { |
247 | if (NULL != ah) | 251 | if (NULL != ah) |
248 | { | 252 | { |
249 | GNUNET_NAT_AUTO_autoconfig_cancel (ah); | 253 | GNUNET_NAT_AUTO_autoconfig_cancel(ah); |
250 | ah = NULL; | 254 | ah = NULL; |
251 | } | 255 | } |
252 | if (NULL != nt) | 256 | if (NULL != nt) |
253 | { | 257 | { |
254 | GNUNET_NAT_AUTO_test_stop (nt); | 258 | GNUNET_NAT_AUTO_test_stop(nt); |
255 | nt = NULL; | 259 | nt = NULL; |
256 | } | 260 | } |
257 | } | 261 | } |
258 | 262 | ||
259 | 263 | ||
@@ -266,29 +270,29 @@ do_shutdown (void *cls) | |||
266 | * @param c configuration | 270 | * @param c configuration |
267 | */ | 271 | */ |
268 | static void | 272 | static void |
269 | run (void *cls, | 273 | run(void *cls, |
270 | char *const *args, | 274 | char *const *args, |
271 | const char *cfgfile, | 275 | const char *cfgfile, |
272 | const struct GNUNET_CONFIGURATION_Handle *c) | 276 | const struct GNUNET_CONFIGURATION_Handle *c) |
273 | { | 277 | { |
274 | cfg_file = cfgfile; | 278 | cfg_file = cfgfile; |
275 | cfg = c; | 279 | cfg = c; |
276 | 280 | ||
277 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); | 281 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); |
278 | 282 | ||
279 | if (do_auto) | 283 | if (do_auto) |
280 | { | 284 | { |
281 | ah = GNUNET_NAT_AUTO_autoconfig_start (c, &auto_config_cb, NULL); | 285 | ah = GNUNET_NAT_AUTO_autoconfig_start(c, &auto_config_cb, NULL); |
282 | } | 286 | } |
283 | 287 | ||
284 | if (use_tcp && use_udp) | 288 | if (use_tcp && use_udp) |
285 | { | 289 | { |
286 | if (do_auto) | 290 | if (do_auto) |
291 | return; | ||
292 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); | ||
293 | global_ret = 1; | ||
287 | return; | 294 | return; |
288 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); | 295 | } |
289 | global_ret = 1; | ||
290 | return; | ||
291 | } | ||
292 | proto = 0; | 296 | proto = 0; |
293 | if (use_tcp) | 297 | if (use_tcp) |
294 | proto = IPPROTO_TCP; | 298 | proto = IPPROTO_TCP; |
@@ -296,14 +300,14 @@ run (void *cls, | |||
296 | proto = IPPROTO_UDP; | 300 | proto = IPPROTO_UDP; |
297 | 301 | ||
298 | if (NULL != section_name) | 302 | if (NULL != section_name) |
299 | { | 303 | { |
300 | nt = GNUNET_NAT_AUTO_test_start (c, | 304 | nt = GNUNET_NAT_AUTO_test_start(c, |
301 | proto, | 305 | proto, |
302 | section_name, | 306 | section_name, |
303 | &test_report_cb, | 307 | &test_report_cb, |
304 | NULL); | 308 | NULL); |
305 | } | 309 | } |
306 | test_finished (); | 310 | test_finished(); |
307 | } | 311 | } |
308 | 312 | ||
309 | 313 | ||
@@ -315,47 +319,47 @@ run (void *cls, | |||
315 | * @return 0 on success, -1 on error | 319 | * @return 0 on success, -1 on error |
316 | */ | 320 | */ |
317 | int | 321 | int |
318 | main (int argc, char *const argv[]) | 322 | main(int argc, char *const argv[]) |
319 | { | 323 | { |
320 | struct GNUNET_GETOPT_CommandLineOption options[] = | 324 | struct GNUNET_GETOPT_CommandLineOption options[] = |
321 | {GNUNET_GETOPT_option_flag ('a', | 325 | { GNUNET_GETOPT_option_flag('a', |
322 | "auto", | 326 | "auto", |
323 | gettext_noop ("run autoconfiguration"), | 327 | gettext_noop("run autoconfiguration"), |
324 | &do_auto), | 328 | &do_auto), |
325 | 329 | ||
326 | GNUNET_GETOPT_option_string ( | 330 | GNUNET_GETOPT_option_string( |
327 | 'S', | 331 | 'S', |
328 | "section", | 332 | "section", |
329 | "NAME", | 333 | "NAME", |
330 | gettext_noop ( | 334 | gettext_noop( |
331 | "section name providing the configuration for the adapter"), | 335 | "section name providing the configuration for the adapter"), |
332 | §ion_name), | 336 | §ion_name), |
333 | 337 | ||
334 | GNUNET_GETOPT_option_flag ('t', "tcp", gettext_noop ("use TCP"), &use_tcp), | 338 | GNUNET_GETOPT_option_flag('t', "tcp", gettext_noop("use TCP"), &use_tcp), |
335 | 339 | ||
336 | GNUNET_GETOPT_option_flag ('u', "udp", gettext_noop ("use UDP"), &use_udp), | 340 | GNUNET_GETOPT_option_flag('u', "udp", gettext_noop("use UDP"), &use_udp), |
337 | 341 | ||
338 | GNUNET_GETOPT_option_flag ( | 342 | GNUNET_GETOPT_option_flag( |
339 | 'w', | 343 | 'w', |
340 | "write", | 344 | "write", |
341 | gettext_noop ("write configuration file (for autoconfiguration)"), | 345 | gettext_noop("write configuration file (for autoconfiguration)"), |
342 | &write_cfg), | 346 | &write_cfg), |
343 | GNUNET_GETOPT_OPTION_END}; | 347 | GNUNET_GETOPT_OPTION_END }; |
344 | 348 | ||
345 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 349 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
346 | return 2; | 350 | return 2; |
347 | if (GNUNET_OK != | 351 | if (GNUNET_OK != |
348 | GNUNET_PROGRAM_run (argc, | 352 | GNUNET_PROGRAM_run(argc, |
349 | argv, | 353 | argv, |
350 | "gnunet-nat-auto [options]", | 354 | "gnunet-nat-auto [options]", |
351 | _ ("GNUnet NAT traversal autoconfiguration"), | 355 | _("GNUnet NAT traversal autoconfiguration"), |
352 | options, | 356 | options, |
353 | &run, | 357 | &run, |
354 | NULL)) | 358 | NULL)) |
355 | { | 359 | { |
356 | global_ret = 1; | 360 | global_ret = 1; |
357 | } | 361 | } |
358 | GNUNET_free ((void *) argv); | 362 | GNUNET_free((void *)argv); |
359 | return global_ret; | 363 | return global_ret; |
360 | } | 364 | } |
361 | 365 | ||
diff --git a/src/nat-auto/gnunet-nat-auto_legacy.c b/src/nat-auto/gnunet-nat-auto_legacy.c index 93b544343..333e75529 100644 --- a/src/nat-auto/gnunet-nat-auto_legacy.c +++ b/src/nat-auto/gnunet-nat-auto_legacy.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file nat/nat_test.c | 22 | * @file nat/nat_test.c |
@@ -28,16 +28,15 @@ | |||
28 | #include "gnunet_nat_lib.h" | 28 | #include "gnunet_nat_lib.h" |
29 | #include "nat.h" | 29 | #include "nat.h" |
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from (kind, "nat", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat", __VA_ARGS__) |
32 | 32 | ||
33 | #define NAT_SERVER_TIMEOUT \ | 33 | #define NAT_SERVER_TIMEOUT \ |
34 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 34 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30) |
35 | 35 | ||
36 | /** | 36 | /** |
37 | * Entry we keep for each incoming connection. | 37 | * Entry we keep for each incoming connection. |
38 | */ | 38 | */ |
39 | struct NatActivity | 39 | struct NatActivity { |
40 | { | ||
41 | /** | 40 | /** |
42 | * This is a doubly-linked list. | 41 | * This is a doubly-linked list. |
43 | */ | 42 | */ |
@@ -68,8 +67,7 @@ struct NatActivity | |||
68 | /** | 67 | /** |
69 | * Entry we keep for each connection to the gnunet-nat-service. | 68 | * Entry we keep for each connection to the gnunet-nat-service. |
70 | */ | 69 | */ |
71 | struct ClientActivity | 70 | struct ClientActivity { |
72 | { | ||
73 | /** | 71 | /** |
74 | * This is a doubly-linked list. | 72 | * This is a doubly-linked list. |
75 | */ | 73 | */ |
@@ -95,9 +93,7 @@ struct ClientActivity | |||
95 | /** | 93 | /** |
96 | * Handle to a NAT test. | 94 | * Handle to a NAT test. |
97 | */ | 95 | */ |
98 | struct GNUNET_NAT_Test | 96 | struct GNUNET_NAT_Test { |
99 | { | ||
100 | |||
101 | /** | 97 | /** |
102 | * Configuration used | 98 | * Configuration used |
103 | */ | 99 | */ |
@@ -184,22 +180,22 @@ struct GNUNET_NAT_Test | |||
184 | * @param addrlen actual lenght of the @a addr | 180 | * @param addrlen actual lenght of the @a addr |
185 | */ | 181 | */ |
186 | static void | 182 | static void |
187 | reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) | 183 | reversal_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen) |
188 | { | 184 | { |
189 | struct GNUNET_NAT_Test *h = cls; | 185 | struct GNUNET_NAT_Test *h = cls; |
190 | const struct sockaddr_in *sa; | 186 | const struct sockaddr_in *sa; |
191 | 187 | ||
192 | if (sizeof (struct sockaddr_in) != addrlen) | 188 | if (sizeof(struct sockaddr_in) != addrlen) |
193 | return; | 189 | return; |
194 | sa = (const struct sockaddr_in *) addr; | 190 | sa = (const struct sockaddr_in *)addr; |
195 | if (h->data != sa->sin_port) | 191 | if (h->data != sa->sin_port) |
196 | { | 192 | { |
197 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 193 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
198 | "Received connection reversal request for wrong port\n"); | 194 | "Received connection reversal request for wrong port\n"); |
199 | return; /* wrong port */ | 195 | return; /* wrong port */ |
200 | } | 196 | } |
201 | /* report success */ | 197 | /* report success */ |
202 | h->report (h->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 198 | h->report(h->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
203 | } | 199 | } |
204 | 200 | ||
205 | 201 | ||
@@ -210,31 +206,31 @@ reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) | |||
210 | * @param cls the `struct GNUNET_NAT_Test` | 206 | * @param cls the `struct GNUNET_NAT_Test` |
211 | */ | 207 | */ |
212 | static void | 208 | static void |
213 | do_udp_read (void *cls) | 209 | do_udp_read(void *cls) |
214 | { | 210 | { |
215 | struct GNUNET_NAT_Test *tst = cls; | 211 | struct GNUNET_NAT_Test *tst = cls; |
216 | uint16_t data; | 212 | uint16_t data; |
217 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 213 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
218 | 214 | ||
219 | tc = GNUNET_SCHEDULER_get_task_context (); | 215 | tc = GNUNET_SCHEDULER_get_task_context(); |
220 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 216 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
221 | tst->lsock, | 217 | tst->lsock, |
222 | &do_udp_read, | 218 | &do_udp_read, |
223 | tst); | 219 | tst); |
224 | if ((NULL != tc->write_ready) && | 220 | if ((NULL != tc->write_ready) && |
225 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, tst->lsock)) && | 221 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, tst->lsock)) && |
226 | (sizeof (data) == | 222 | (sizeof(data) == |
227 | GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof (data)))) | 223 | GNUNET_NETWORK_socket_recv(tst->lsock, &data, sizeof(data)))) |
228 | { | 224 | { |
229 | if (data == tst->data) | 225 | if (data == tst->data) |
230 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 226 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
231 | else | 227 | else |
232 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 228 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
233 | "Received data mismatches expected value\n"); | 229 | "Received data mismatches expected value\n"); |
234 | } | 230 | } |
235 | else | 231 | else |
236 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 232 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
237 | "Failed to receive data from inbound connection\n"); | 233 | "Failed to receive data from inbound connection\n"); |
238 | } | 234 | } |
239 | 235 | ||
240 | 236 | ||
@@ -245,33 +241,33 @@ do_udp_read (void *cls) | |||
245 | * @param cls the `struct NatActivity` | 241 | * @param cls the `struct NatActivity` |
246 | */ | 242 | */ |
247 | static void | 243 | static void |
248 | do_read (void *cls) | 244 | do_read(void *cls) |
249 | { | 245 | { |
250 | struct NatActivity *na = cls; | 246 | struct NatActivity *na = cls; |
251 | struct GNUNET_NAT_Test *tst; | 247 | struct GNUNET_NAT_Test *tst; |
252 | uint16_t data; | 248 | uint16_t data; |
253 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 249 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
254 | 250 | ||
255 | tc = GNUNET_SCHEDULER_get_task_context (); | 251 | tc = GNUNET_SCHEDULER_get_task_context(); |
256 | na->rtask = NULL; | 252 | na->rtask = NULL; |
257 | tst = na->h; | 253 | tst = na->h; |
258 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na); | 254 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, na); |
259 | if ((NULL != tc->write_ready) && | 255 | if ((NULL != tc->write_ready) && |
260 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, na->sock)) && | 256 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, na->sock)) && |
261 | (sizeof (data) == | 257 | (sizeof(data) == |
262 | GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof (data)))) | 258 | GNUNET_NETWORK_socket_recv(na->sock, &data, sizeof(data)))) |
263 | { | 259 | { |
264 | if (data == tst->data) | 260 | if (data == tst->data) |
265 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 261 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
266 | else | 262 | else |
267 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 263 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
268 | "Received data does not match expected value\n"); | 264 | "Received data does not match expected value\n"); |
269 | } | 265 | } |
270 | else | 266 | else |
271 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 267 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
272 | "Failed to receive data from inbound connection\n"); | 268 | "Failed to receive data from inbound connection\n"); |
273 | GNUNET_NETWORK_socket_close (na->sock); | 269 | GNUNET_NETWORK_socket_close(na->sock); |
274 | GNUNET_free (na); | 270 | GNUNET_free(na); |
275 | } | 271 | } |
276 | 272 | ||
277 | 273 | ||
@@ -282,32 +278,32 @@ do_read (void *cls) | |||
282 | * @param cls the `struct GNUNET_NAT_Test` | 278 | * @param cls the `struct GNUNET_NAT_Test` |
283 | */ | 279 | */ |
284 | static void | 280 | static void |
285 | do_accept (void *cls) | 281 | do_accept(void *cls) |
286 | { | 282 | { |
287 | struct GNUNET_NAT_Test *tst = cls; | 283 | struct GNUNET_NAT_Test *tst = cls; |
288 | struct GNUNET_NETWORK_Handle *s; | 284 | struct GNUNET_NETWORK_Handle *s; |
289 | struct NatActivity *wl; | 285 | struct NatActivity *wl; |
290 | 286 | ||
291 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 287 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
292 | tst->lsock, | 288 | tst->lsock, |
293 | &do_accept, | 289 | &do_accept, |
294 | tst); | 290 | tst); |
295 | s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL); | 291 | s = GNUNET_NETWORK_socket_accept(tst->lsock, NULL, NULL); |
296 | if (NULL == s) | 292 | if (NULL == s) |
297 | { | 293 | { |
298 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept"); | 294 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, "accept"); |
299 | return; /* odd error */ | 295 | return; /* odd error */ |
300 | } | 296 | } |
301 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 297 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
302 | "Got an inbound connection, waiting for data\n"); | 298 | "Got an inbound connection, waiting for data\n"); |
303 | wl = GNUNET_new (struct NatActivity); | 299 | wl = GNUNET_new(struct NatActivity); |
304 | wl->sock = s; | 300 | wl->sock = s; |
305 | wl->h = tst; | 301 | wl->h = tst; |
306 | wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 302 | wl->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
307 | wl->sock, | 303 | wl->sock, |
308 | &do_read, | 304 | &do_read, |
309 | wl); | 305 | wl); |
310 | GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl); | 306 | GNUNET_CONTAINER_DLL_insert(tst->na_head, tst->na_tail, wl); |
311 | } | 307 | } |
312 | 308 | ||
313 | 309 | ||
@@ -319,14 +315,14 @@ do_accept (void *cls) | |||
319 | * @param error error code | 315 | * @param error error code |
320 | */ | 316 | */ |
321 | static void | 317 | static void |
322 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) | 318 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) |
323 | { | 319 | { |
324 | struct ClientActivity *ca = cls; | 320 | struct ClientActivity *ca = cls; |
325 | struct GNUNET_NAT_Test *tst = ca->h; | 321 | struct GNUNET_NAT_Test *tst = ca->h; |
326 | 322 | ||
327 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca); | 323 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, ca); |
328 | GNUNET_MQ_destroy (ca->mq); | 324 | GNUNET_MQ_destroy(ca->mq); |
329 | GNUNET_free (ca); | 325 | GNUNET_free(ca); |
330 | } | 326 | } |
331 | 327 | ||
332 | 328 | ||
@@ -340,10 +336,10 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error) | |||
340 | * @param addrlen actual length of the @a addr | 336 | * @param addrlen actual length of the @a addr |
341 | */ | 337 | */ |
342 | static void | 338 | static void |
343 | addr_cb (void *cls, | 339 | addr_cb(void *cls, |
344 | int add_remove, | 340 | int add_remove, |
345 | const struct sockaddr *addr, | 341 | const struct sockaddr *addr, |
346 | socklen_t addrlen) | 342 | socklen_t addrlen) |
347 | { | 343 | { |
348 | struct GNUNET_NAT_Test *h = cls; | 344 | struct GNUNET_NAT_Test *h = cls; |
349 | struct ClientActivity *ca; | 345 | struct ClientActivity *ca; |
@@ -353,39 +349,39 @@ addr_cb (void *cls, | |||
353 | 349 | ||
354 | if (GNUNET_YES != add_remove) | 350 | if (GNUNET_YES != add_remove) |
355 | return; | 351 | return; |
356 | if (addrlen != sizeof (struct sockaddr_in)) | 352 | if (addrlen != sizeof(struct sockaddr_in)) |
357 | { | 353 | { |
358 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 354 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
359 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", | 355 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", |
360 | GNUNET_a2s (addr, addrlen)); | 356 | GNUNET_a2s(addr, addrlen)); |
361 | return; /* ignore IPv6 here */ | 357 | return; /* ignore IPv6 here */ |
362 | } | 358 | } |
363 | LOG (GNUNET_ERROR_TYPE_INFO, | 359 | LOG(GNUNET_ERROR_TYPE_INFO, |
364 | "Asking gnunet-nat-server to connect to `%s'\n", | 360 | "Asking gnunet-nat-server to connect to `%s'\n", |
365 | GNUNET_a2s (addr, addrlen)); | 361 | GNUNET_a2s(addr, addrlen)); |
366 | 362 | ||
367 | ca = GNUNET_new (struct ClientActivity); | 363 | ca = GNUNET_new(struct ClientActivity); |
368 | ca->h = h; | 364 | ca->h = h; |
369 | ca->mq = GNUNET_CLIENT_connect (h->cfg, | 365 | ca->mq = GNUNET_CLIENT_connect(h->cfg, |
370 | "gnunet-nat-server", | 366 | "gnunet-nat-server", |
371 | NULL, | 367 | NULL, |
372 | &mq_error_handler, | 368 | &mq_error_handler, |
373 | ca); | 369 | ca); |
374 | if (NULL == ca->mq) | 370 | if (NULL == ca->mq) |
375 | { | 371 | { |
376 | GNUNET_free (ca); | 372 | GNUNET_free(ca); |
377 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 373 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
378 | _ ("Failed to connect to `gnunet-nat-server'\n")); | 374 | _("Failed to connect to `gnunet-nat-server'\n")); |
379 | return; | 375 | return; |
380 | } | 376 | } |
381 | GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca); | 377 | GNUNET_CONTAINER_DLL_insert(h->ca_head, h->ca_tail, ca); |
382 | sa = (const struct sockaddr_in *) addr; | 378 | sa = (const struct sockaddr_in *)addr; |
383 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST); | 379 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAT_TEST); |
384 | msg->dst_ipv4 = sa->sin_addr.s_addr; | 380 | msg->dst_ipv4 = sa->sin_addr.s_addr; |
385 | msg->dport = sa->sin_port; | 381 | msg->dport = sa->sin_port; |
386 | msg->data = h->data; | 382 | msg->data = h->data; |
387 | msg->is_tcp = htonl ((uint32_t) h->is_tcp); | 383 | msg->is_tcp = htonl((uint32_t)h->is_tcp); |
388 | GNUNET_MQ_send (ca->mq, env); | 384 | GNUNET_MQ_send(ca->mq, env); |
389 | } | 385 | } |
390 | 386 | ||
391 | 387 | ||
@@ -398,15 +394,15 @@ addr_cb (void *cls, | |||
398 | * @param cls handle to the timed out NAT test | 394 | * @param cls handle to the timed out NAT test |
399 | */ | 395 | */ |
400 | static void | 396 | static void |
401 | do_timeout (void *cls) | 397 | do_timeout(void *cls) |
402 | { | 398 | { |
403 | struct GNUNET_NAT_Test *nh = cls; | 399 | struct GNUNET_NAT_Test *nh = cls; |
404 | 400 | ||
405 | nh->ttask = NULL; | 401 | nh->ttask = NULL; |
406 | nh->report (nh->report_cls, | 402 | nh->report(nh->report_cls, |
407 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) | 403 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) |
408 | ? GNUNET_NAT_ERROR_TIMEOUT | 404 | ? GNUNET_NAT_ERROR_TIMEOUT |
409 | : nh->status); | 405 | : nh->status); |
410 | } | 406 | } |
411 | 407 | ||
412 | 408 | ||
@@ -426,27 +422,27 @@ do_timeout (void *cls) | |||
426 | * @return handle to cancel NAT test or NULL. The error is always indicated via the report callback | 422 | * @return handle to cancel NAT test or NULL. The error is always indicated via the report callback |
427 | */ | 423 | */ |
428 | struct GNUNET_NAT_Test * | 424 | struct GNUNET_NAT_Test * |
429 | GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | 425 | GNUNET_NAT_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
430 | int is_tcp, | 426 | int is_tcp, |
431 | uint16_t bnd_port, | 427 | uint16_t bnd_port, |
432 | uint16_t adv_port, | 428 | uint16_t adv_port, |
433 | struct GNUNET_TIME_Relative timeout, | 429 | struct GNUNET_TIME_Relative timeout, |
434 | GNUNET_NAT_TestCallback report, | 430 | GNUNET_NAT_TestCallback report, |
435 | void *report_cls) | 431 | void *report_cls) |
436 | { | 432 | { |
437 | struct GNUNET_NAT_Test *nh; | 433 | struct GNUNET_NAT_Test *nh; |
438 | struct sockaddr_in sa; | 434 | struct sockaddr_in sa; |
439 | const struct sockaddr *addrs[] = {(const struct sockaddr *) &sa}; | 435 | const struct sockaddr *addrs[] = { (const struct sockaddr *)&sa }; |
440 | const socklen_t addrlens[] = {sizeof (sa)}; | 436 | const socklen_t addrlens[] = { sizeof(sa) }; |
441 | 437 | ||
442 | memset (&sa, 0, sizeof (sa)); | 438 | memset(&sa, 0, sizeof(sa)); |
443 | sa.sin_family = AF_INET; | 439 | sa.sin_family = AF_INET; |
444 | sa.sin_port = htons (bnd_port); | 440 | sa.sin_port = htons(bnd_port); |
445 | #if HAVE_SOCKADDR_IN_SIN_LEN | 441 | #if HAVE_SOCKADDR_IN_SIN_LEN |
446 | sa.sin_len = sizeof (sa); | 442 | sa.sin_len = sizeof(sa); |
447 | #endif | 443 | #endif |
448 | 444 | ||
449 | nh = GNUNET_new (struct GNUNET_NAT_Test); | 445 | nh = GNUNET_new(struct GNUNET_NAT_Test); |
450 | nh->cfg = cfg; | 446 | nh->cfg = cfg; |
451 | nh->is_tcp = is_tcp; | 447 | nh->is_tcp = is_tcp; |
452 | nh->data = bnd_port; | 448 | nh->data = bnd_port; |
@@ -455,93 +451,93 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
455 | nh->report_cls = report_cls; | 451 | nh->report_cls = report_cls; |
456 | nh->status = GNUNET_NAT_ERROR_SUCCESS; | 452 | nh->status = GNUNET_NAT_ERROR_SUCCESS; |
457 | if (0 == bnd_port) | 453 | if (0 == bnd_port) |
458 | { | ||
459 | nh->nat = GNUNET_NAT_register (cfg, | ||
460 | is_tcp, | ||
461 | 0, | ||
462 | 0, | ||
463 | NULL, | ||
464 | NULL, | ||
465 | &addr_cb, | ||
466 | &reversal_cb, | ||
467 | nh, | ||
468 | NULL); | ||
469 | } | ||
470 | else | ||
471 | { | ||
472 | nh->lsock = | ||
473 | GNUNET_NETWORK_socket_create (AF_INET, | ||
474 | (is_tcp == GNUNET_YES) ? SOCK_STREAM | ||
475 | : SOCK_DGRAM, | ||
476 | 0); | ||
477 | if ((nh->lsock == NULL) || | ||
478 | (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock, | ||
479 | (const struct sockaddr *) &sa, | ||
480 | sizeof (sa)))) | ||
481 | { | ||
482 | GNUNET_log ( | ||
483 | GNUNET_ERROR_TYPE_ERROR, | ||
484 | _ ("Failed to create listen socket bound to `%s' for NAT test: %s\n"), | ||
485 | GNUNET_a2s ((const struct sockaddr *) &sa, sizeof (sa)), | ||
486 | strerror (errno)); | ||
487 | if (NULL != nh->lsock) | ||
488 | { | ||
489 | GNUNET_NETWORK_socket_close (nh->lsock); | ||
490 | nh->lsock = NULL; | ||
491 | } | ||
492 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
493 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); | ||
494 | return nh; | ||
495 | } | ||
496 | if (GNUNET_YES == is_tcp) | ||
497 | { | ||
498 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5)); | ||
499 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
500 | nh->lsock, | ||
501 | &do_accept, | ||
502 | nh); | ||
503 | } | ||
504 | else | ||
505 | { | 454 | { |
506 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 455 | nh->nat = GNUNET_NAT_register(cfg, |
507 | nh->lsock, | 456 | is_tcp, |
508 | &do_udp_read, | 457 | 0, |
509 | nh); | 458 | 0, |
459 | NULL, | ||
460 | NULL, | ||
461 | &addr_cb, | ||
462 | &reversal_cb, | ||
463 | nh, | ||
464 | NULL); | ||
510 | } | 465 | } |
511 | LOG (GNUNET_ERROR_TYPE_INFO, | 466 | else |
512 | "NAT test listens on port %u (%s)\n", | ||
513 | bnd_port, | ||
514 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); | ||
515 | nh->nat = GNUNET_NAT_register (cfg, | ||
516 | is_tcp, | ||
517 | adv_port, | ||
518 | 1, | ||
519 | addrs, | ||
520 | addrlens, | ||
521 | &addr_cb, | ||
522 | NULL, | ||
523 | nh, | ||
524 | NULL); | ||
525 | if (NULL == nh->nat) | ||
526 | { | 467 | { |
527 | LOG (GNUNET_ERROR_TYPE_INFO, | 468 | nh->lsock = |
528 | _ ("NAT test failed to start NAT library\n")); | 469 | GNUNET_NETWORK_socket_create(AF_INET, |
529 | if (NULL != nh->ltask) | 470 | (is_tcp == GNUNET_YES) ? SOCK_STREAM |
530 | { | 471 | : SOCK_DGRAM, |
531 | GNUNET_SCHEDULER_cancel (nh->ltask); | 472 | 0); |
532 | nh->ltask = NULL; | 473 | if ((nh->lsock == NULL) || |
533 | } | 474 | (GNUNET_OK != GNUNET_NETWORK_socket_bind(nh->lsock, |
534 | if (NULL != nh->lsock) | 475 | (const struct sockaddr *)&sa, |
535 | { | 476 | sizeof(sa)))) |
536 | GNUNET_NETWORK_socket_close (nh->lsock); | 477 | { |
537 | nh->lsock = NULL; | 478 | GNUNET_log( |
538 | } | 479 | GNUNET_ERROR_TYPE_ERROR, |
539 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | 480 | _("Failed to create listen socket bound to `%s' for NAT test: %s\n"), |
540 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); | 481 | GNUNET_a2s((const struct sockaddr *)&sa, sizeof(sa)), |
541 | return nh; | 482 | strerror(errno)); |
483 | if (NULL != nh->lsock) | ||
484 | { | ||
485 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
486 | nh->lsock = NULL; | ||
487 | } | ||
488 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
489 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_timeout, nh); | ||
490 | return nh; | ||
491 | } | ||
492 | if (GNUNET_YES == is_tcp) | ||
493 | { | ||
494 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_listen(nh->lsock, 5)); | ||
495 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
496 | nh->lsock, | ||
497 | &do_accept, | ||
498 | nh); | ||
499 | } | ||
500 | else | ||
501 | { | ||
502 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
503 | nh->lsock, | ||
504 | &do_udp_read, | ||
505 | nh); | ||
506 | } | ||
507 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
508 | "NAT test listens on port %u (%s)\n", | ||
509 | bnd_port, | ||
510 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); | ||
511 | nh->nat = GNUNET_NAT_register(cfg, | ||
512 | is_tcp, | ||
513 | adv_port, | ||
514 | 1, | ||
515 | addrs, | ||
516 | addrlens, | ||
517 | &addr_cb, | ||
518 | NULL, | ||
519 | nh, | ||
520 | NULL); | ||
521 | if (NULL == nh->nat) | ||
522 | { | ||
523 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
524 | _("NAT test failed to start NAT library\n")); | ||
525 | if (NULL != nh->ltask) | ||
526 | { | ||
527 | GNUNET_SCHEDULER_cancel(nh->ltask); | ||
528 | nh->ltask = NULL; | ||
529 | } | ||
530 | if (NULL != nh->lsock) | ||
531 | { | ||
532 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
533 | nh->lsock = NULL; | ||
534 | } | ||
535 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | ||
536 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_timeout, nh); | ||
537 | return nh; | ||
538 | } | ||
542 | } | 539 | } |
543 | } | 540 | nh->ttask = GNUNET_SCHEDULER_add_delayed(timeout, &do_timeout, nh); |
544 | nh->ttask = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, nh); | ||
545 | return nh; | 541 | return nh; |
546 | } | 542 | } |
547 | 543 | ||
@@ -552,46 +548,46 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
552 | * @param tst test to stop. | 548 | * @param tst test to stop. |
553 | */ | 549 | */ |
554 | void | 550 | void |
555 | GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst) | 551 | GNUNET_NAT_test_stop(struct GNUNET_NAT_Test *tst) |
556 | { | 552 | { |
557 | struct NatActivity *pos; | 553 | struct NatActivity *pos; |
558 | struct ClientActivity *cpos; | 554 | struct ClientActivity *cpos; |
559 | 555 | ||
560 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); | 556 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); |
561 | while (NULL != (cpos = tst->ca_head)) | 557 | while (NULL != (cpos = tst->ca_head)) |
562 | { | 558 | { |
563 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos); | 559 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, cpos); |
564 | GNUNET_MQ_destroy (cpos->mq); | 560 | GNUNET_MQ_destroy(cpos->mq); |
565 | GNUNET_free (cpos); | 561 | GNUNET_free(cpos); |
566 | } | 562 | } |
567 | while (NULL != (pos = tst->na_head)) | 563 | while (NULL != (pos = tst->na_head)) |
568 | { | 564 | { |
569 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos); | 565 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, pos); |
570 | GNUNET_SCHEDULER_cancel (pos->rtask); | 566 | GNUNET_SCHEDULER_cancel(pos->rtask); |
571 | GNUNET_NETWORK_socket_close (pos->sock); | 567 | GNUNET_NETWORK_socket_close(pos->sock); |
572 | GNUNET_free (pos); | 568 | GNUNET_free(pos); |
573 | } | 569 | } |
574 | if (NULL != tst->ttask) | 570 | if (NULL != tst->ttask) |
575 | { | 571 | { |
576 | GNUNET_SCHEDULER_cancel (tst->ttask); | 572 | GNUNET_SCHEDULER_cancel(tst->ttask); |
577 | tst->ttask = NULL; | 573 | tst->ttask = NULL; |
578 | } | 574 | } |
579 | if (NULL != tst->ltask) | 575 | if (NULL != tst->ltask) |
580 | { | 576 | { |
581 | GNUNET_SCHEDULER_cancel (tst->ltask); | 577 | GNUNET_SCHEDULER_cancel(tst->ltask); |
582 | tst->ltask = NULL; | 578 | tst->ltask = NULL; |
583 | } | 579 | } |
584 | if (NULL != tst->lsock) | 580 | if (NULL != tst->lsock) |
585 | { | 581 | { |
586 | GNUNET_NETWORK_socket_close (tst->lsock); | 582 | GNUNET_NETWORK_socket_close(tst->lsock); |
587 | tst->lsock = NULL; | 583 | tst->lsock = NULL; |
588 | } | 584 | } |
589 | if (NULL != tst->nat) | 585 | if (NULL != tst->nat) |
590 | { | 586 | { |
591 | GNUNET_NAT_unregister (tst->nat); | 587 | GNUNET_NAT_unregister(tst->nat); |
592 | tst->nat = NULL; | 588 | tst->nat = NULL; |
593 | } | 589 | } |
594 | GNUNET_free (tst); | 590 | GNUNET_free(tst); |
595 | } | 591 | } |
596 | 592 | ||
597 | /* end of nat_test.c */ | 593 | /* end of nat_test.c */ |
diff --git a/src/nat-auto/gnunet-nat-server.c b/src/nat-auto/gnunet-nat-server.c index c58768982..db44d7629 100644 --- a/src/nat-auto/gnunet-nat-server.c +++ b/src/nat-auto/gnunet-nat-server.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/nat/gnunet-nat-server.c | 22 | * @file src/nat/gnunet-nat-server.c |
@@ -33,8 +33,7 @@ | |||
33 | /** | 33 | /** |
34 | * Information we track per client. | 34 | * Information we track per client. |
35 | */ | 35 | */ |
36 | struct ClientData | 36 | struct ClientData { |
37 | { | ||
38 | /** | 37 | /** |
39 | * Timeout task. | 38 | * Timeout task. |
40 | */ | 39 | */ |
@@ -61,9 +60,9 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; | |||
61 | * @param is_tcp mark for TCP (#GNUNET_YES) or UDP (#GNUNET_NO) | 60 | * @param is_tcp mark for TCP (#GNUNET_YES) or UDP (#GNUNET_NO) |
62 | */ | 61 | */ |
63 | static void | 62 | static void |
64 | try_anat (uint32_t dst_ipv4, | 63 | try_anat(uint32_t dst_ipv4, |
65 | uint16_t dport, | 64 | uint16_t dport, |
66 | int is_tcp) | 65 | int is_tcp) |
67 | { | 66 | { |
68 | struct GNUNET_NAT_Handle *h; | 67 | struct GNUNET_NAT_Handle *h; |
69 | struct sockaddr_in lsa; | 68 | struct sockaddr_in lsa; |
@@ -71,45 +70,44 @@ try_anat (uint32_t dst_ipv4, | |||
71 | const struct sockaddr *sa; | 70 | const struct sockaddr *sa; |
72 | socklen_t sa_len; | 71 | socklen_t sa_len; |
73 | 72 | ||
74 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 73 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
75 | "Asking for connection reversal with %x and code %u\n", | 74 | "Asking for connection reversal with %x and code %u\n", |
76 | (unsigned int) dst_ipv4, | 75 | (unsigned int)dst_ipv4, |
77 | (unsigned int) dport); | 76 | (unsigned int)dport); |
78 | memset (&lsa, 0, sizeof (lsa)); | 77 | memset(&lsa, 0, sizeof(lsa)); |
79 | lsa.sin_family = AF_INET; | 78 | lsa.sin_family = AF_INET; |
80 | #if HAVE_SOCKADDR_IN_SIN_LEN | 79 | #if HAVE_SOCKADDR_IN_SIN_LEN |
81 | lsa.sin_len = sizeof (sa); | 80 | lsa.sin_len = sizeof(sa); |
82 | #endif | 81 | #endif |
83 | lsa.sin_addr.s_addr = 0; | 82 | lsa.sin_addr.s_addr = 0; |
84 | lsa.sin_port = htons (dport); | 83 | lsa.sin_port = htons(dport); |
85 | memset (&rsa, 0, sizeof (rsa)); | 84 | memset(&rsa, 0, sizeof(rsa)); |
86 | rsa.sin_family = AF_INET; | 85 | rsa.sin_family = AF_INET; |
87 | #if HAVE_SOCKADDR_IN_SIN_LEN | 86 | #if HAVE_SOCKADDR_IN_SIN_LEN |
88 | rsa.sin_len = sizeof (sa); | 87 | rsa.sin_len = sizeof(sa); |
89 | #endif | 88 | #endif |
90 | rsa.sin_addr.s_addr = dst_ipv4; | 89 | rsa.sin_addr.s_addr = dst_ipv4; |
91 | rsa.sin_port = htons (dport); | 90 | rsa.sin_port = htons(dport); |
92 | sa_len = sizeof (lsa); | 91 | sa_len = sizeof(lsa); |
93 | sa = (const struct sockaddr *) &lsa; | 92 | sa = (const struct sockaddr *)&lsa; |
94 | h = GNUNET_NAT_register (cfg, | 93 | h = GNUNET_NAT_register(cfg, |
95 | "none", | 94 | "none", |
96 | is_tcp ? IPPROTO_TCP : IPPROTO_UDP, | 95 | is_tcp ? IPPROTO_TCP : IPPROTO_UDP, |
97 | 1, | 96 | 1, |
98 | &sa, | 97 | &sa, |
99 | &sa_len, | 98 | &sa_len, |
100 | NULL, NULL, NULL); | 99 | NULL, NULL, NULL); |
101 | GNUNET_NAT_request_reversal (h, | 100 | GNUNET_NAT_request_reversal(h, |
102 | &lsa, | 101 | &lsa, |
103 | &rsa); | 102 | &rsa); |
104 | GNUNET_NAT_unregister (h); | 103 | GNUNET_NAT_unregister(h); |
105 | } | 104 | } |
106 | 105 | ||
107 | 106 | ||
108 | /** | 107 | /** |
109 | * Closure for #tcp_send. | 108 | * Closure for #tcp_send. |
110 | */ | 109 | */ |
111 | struct TcpContext | 110 | struct TcpContext { |
112 | { | ||
113 | /** | 111 | /** |
114 | * TCP socket. | 112 | * TCP socket. |
115 | */ | 113 | */ |
@@ -129,24 +127,24 @@ struct TcpContext | |||
129 | * @param cls the `struct TcpContext` | 127 | * @param cls the `struct TcpContext` |
130 | */ | 128 | */ |
131 | static void | 129 | static void |
132 | tcp_send (void *cls) | 130 | tcp_send(void *cls) |
133 | { | 131 | { |
134 | struct TcpContext *ctx = cls; | 132 | struct TcpContext *ctx = cls; |
135 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 133 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
136 | 134 | ||
137 | tc = GNUNET_SCHEDULER_get_task_context (); | 135 | tc = GNUNET_SCHEDULER_get_task_context(); |
138 | if ((NULL != tc->write_ready) && | 136 | if ((NULL != tc->write_ready) && |
139 | (GNUNET_NETWORK_fdset_isset (tc->write_ready, ctx->s))) | 137 | (GNUNET_NETWORK_fdset_isset(tc->write_ready, ctx->s))) |
140 | { | ||
141 | if (-1 == | ||
142 | GNUNET_NETWORK_socket_send (ctx->s, &ctx->data, sizeof (ctx->data))) | ||
143 | { | 138 | { |
144 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send"); | 139 | if (-1 == |
140 | GNUNET_NETWORK_socket_send(ctx->s, &ctx->data, sizeof(ctx->data))) | ||
141 | { | ||
142 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "send"); | ||
143 | } | ||
144 | GNUNET_NETWORK_socket_shutdown(ctx->s, SHUT_RDWR); | ||
145 | } | 145 | } |
146 | GNUNET_NETWORK_socket_shutdown (ctx->s, SHUT_RDWR); | 146 | GNUNET_NETWORK_socket_close(ctx->s); |
147 | } | 147 | GNUNET_free(ctx); |
148 | GNUNET_NETWORK_socket_close (ctx->s); | ||
149 | GNUNET_free (ctx); | ||
150 | } | 148 | } |
151 | 149 | ||
152 | 150 | ||
@@ -159,52 +157,52 @@ tcp_send (void *cls) | |||
159 | * @param data data to send | 157 | * @param data data to send |
160 | */ | 158 | */ |
161 | static void | 159 | static void |
162 | try_send_tcp (uint32_t dst_ipv4, | 160 | try_send_tcp(uint32_t dst_ipv4, |
163 | uint16_t dport, | 161 | uint16_t dport, |
164 | uint16_t data) | 162 | uint16_t data) |
165 | { | 163 | { |
166 | struct GNUNET_NETWORK_Handle *s; | 164 | struct GNUNET_NETWORK_Handle *s; |
167 | struct sockaddr_in sa; | 165 | struct sockaddr_in sa; |
168 | struct TcpContext *ctx; | 166 | struct TcpContext *ctx; |
169 | 167 | ||
170 | s = GNUNET_NETWORK_socket_create (AF_INET, | 168 | s = GNUNET_NETWORK_socket_create(AF_INET, |
171 | SOCK_STREAM, | 169 | SOCK_STREAM, |
172 | 0); | 170 | 0); |
173 | if (NULL == s) | 171 | if (NULL == s) |
174 | { | 172 | { |
175 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 173 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
176 | "socket"); | 174 | "socket"); |
177 | return; | 175 | return; |
178 | } | 176 | } |
179 | memset (&sa, 0, sizeof (sa)); | 177 | memset(&sa, 0, sizeof(sa)); |
180 | sa.sin_family = AF_INET; | 178 | sa.sin_family = AF_INET; |
181 | #if HAVE_SOCKADDR_IN_SIN_LEN | 179 | #if HAVE_SOCKADDR_IN_SIN_LEN |
182 | sa.sin_len = sizeof (sa); | 180 | sa.sin_len = sizeof(sa); |
183 | #endif | 181 | #endif |
184 | sa.sin_addr.s_addr = dst_ipv4; | 182 | sa.sin_addr.s_addr = dst_ipv4; |
185 | sa.sin_port = htons (dport); | 183 | sa.sin_port = htons(dport); |
186 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 184 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
187 | "Sending TCP message to `%s'\n", | 185 | "Sending TCP message to `%s'\n", |
188 | GNUNET_a2s ((struct sockaddr *) &sa, | 186 | GNUNET_a2s((struct sockaddr *)&sa, |
189 | sizeof (sa))); | 187 | sizeof(sa))); |
190 | if ( (GNUNET_OK != | 188 | if ((GNUNET_OK != |
191 | GNUNET_NETWORK_socket_connect (s, | 189 | GNUNET_NETWORK_socket_connect(s, |
192 | (const struct sockaddr *) &sa, | 190 | (const struct sockaddr *)&sa, |
193 | sizeof (sa))) && | 191 | sizeof(sa))) && |
194 | (errno != EINPROGRESS) ) | 192 | (errno != EINPROGRESS)) |
195 | { | 193 | { |
196 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 194 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
197 | "connect"); | 195 | "connect"); |
198 | GNUNET_NETWORK_socket_close (s); | 196 | GNUNET_NETWORK_socket_close(s); |
199 | return; | 197 | return; |
200 | } | 198 | } |
201 | ctx = GNUNET_new (struct TcpContext); | 199 | ctx = GNUNET_new(struct TcpContext); |
202 | ctx->s = s; | 200 | ctx->s = s; |
203 | ctx->data = data; | 201 | ctx->data = data; |
204 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_SECONDS, | 202 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_SECONDS, |
205 | s, | 203 | s, |
206 | &tcp_send, | 204 | &tcp_send, |
207 | ctx); | 205 | ctx); |
208 | } | 206 | } |
209 | 207 | ||
210 | 208 | ||
@@ -217,42 +215,42 @@ try_send_tcp (uint32_t dst_ipv4, | |||
217 | * @param data data to send | 215 | * @param data data to send |
218 | */ | 216 | */ |
219 | static void | 217 | static void |
220 | try_send_udp (uint32_t dst_ipv4, | 218 | try_send_udp(uint32_t dst_ipv4, |
221 | uint16_t dport, | 219 | uint16_t dport, |
222 | uint16_t data) | 220 | uint16_t data) |
223 | { | 221 | { |
224 | struct GNUNET_NETWORK_Handle *s; | 222 | struct GNUNET_NETWORK_Handle *s; |
225 | struct sockaddr_in sa; | 223 | struct sockaddr_in sa; |
226 | 224 | ||
227 | s = GNUNET_NETWORK_socket_create (AF_INET, | 225 | s = GNUNET_NETWORK_socket_create(AF_INET, |
228 | SOCK_DGRAM, | 226 | SOCK_DGRAM, |
229 | 0); | 227 | 0); |
230 | if (NULL == s) | 228 | if (NULL == s) |
231 | { | 229 | { |
232 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 230 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
233 | "socket"); | 231 | "socket"); |
234 | return; | 232 | return; |
235 | } | 233 | } |
236 | memset (&sa, 0, sizeof (sa)); | 234 | memset(&sa, 0, sizeof(sa)); |
237 | sa.sin_family = AF_INET; | 235 | sa.sin_family = AF_INET; |
238 | #if HAVE_SOCKADDR_IN_SIN_LEN | 236 | #if HAVE_SOCKADDR_IN_SIN_LEN |
239 | sa.sin_len = sizeof (sa); | 237 | sa.sin_len = sizeof(sa); |
240 | #endif | 238 | #endif |
241 | sa.sin_addr.s_addr = dst_ipv4; | 239 | sa.sin_addr.s_addr = dst_ipv4; |
242 | sa.sin_port = htons (dport); | 240 | sa.sin_port = htons(dport); |
243 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 241 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
244 | "Sending UDP packet to `%s'\n", | 242 | "Sending UDP packet to `%s'\n", |
245 | GNUNET_a2s ((struct sockaddr *) &sa, | 243 | GNUNET_a2s((struct sockaddr *)&sa, |
246 | sizeof (sa))); | 244 | sizeof(sa))); |
247 | if (-1 == | 245 | if (-1 == |
248 | GNUNET_NETWORK_socket_sendto (s, | 246 | GNUNET_NETWORK_socket_sendto(s, |
249 | &data, | 247 | &data, |
250 | sizeof (data), | 248 | sizeof(data), |
251 | (const struct sockaddr *) &sa, | 249 | (const struct sockaddr *)&sa, |
252 | sizeof (sa))) | 250 | sizeof(sa))) |
253 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 251 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
254 | "sendto"); | 252 | "sendto"); |
255 | GNUNET_NETWORK_socket_close (s); | 253 | GNUNET_NETWORK_socket_close(s); |
256 | } | 254 | } |
257 | 255 | ||
258 | 256 | ||
@@ -264,28 +262,28 @@ try_send_udp (uint32_t dst_ipv4, | |||
264 | * @param msg message with details about what to test | 262 | * @param msg message with details about what to test |
265 | */ | 263 | */ |
266 | static void | 264 | static void |
267 | handle_test (void *cls, | 265 | handle_test(void *cls, |
268 | const struct GNUNET_NAT_AUTO_TestMessage *tm) | 266 | const struct GNUNET_NAT_AUTO_TestMessage *tm) |
269 | { | 267 | { |
270 | struct ClientData *cd = cls; | 268 | struct ClientData *cd = cls; |
271 | uint16_t dport; | 269 | uint16_t dport; |
272 | 270 | ||
273 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 271 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
274 | "Received test request\n"); | 272 | "Received test request\n"); |
275 | dport = ntohs (tm->dport); | 273 | dport = ntohs(tm->dport); |
276 | if (0 == dport) | 274 | if (0 == dport) |
277 | try_anat (tm->dst_ipv4, | 275 | try_anat(tm->dst_ipv4, |
278 | ntohs (tm->data), | 276 | ntohs(tm->data), |
279 | (int) ntohl (tm->is_tcp)); | 277 | (int)ntohl(tm->is_tcp)); |
280 | else if (GNUNET_YES == ntohl (tm->is_tcp)) | 278 | else if (GNUNET_YES == ntohl(tm->is_tcp)) |
281 | try_send_tcp (tm->dst_ipv4, | 279 | try_send_tcp(tm->dst_ipv4, |
282 | dport, | 280 | dport, |
283 | tm->data); | 281 | tm->data); |
284 | else | 282 | else |
285 | try_send_udp (tm->dst_ipv4, | 283 | try_send_udp(tm->dst_ipv4, |
286 | dport, | 284 | dport, |
287 | tm->data); | 285 | tm->data); |
288 | GNUNET_SERVICE_client_drop (cd->client); | 286 | GNUNET_SERVICE_client_drop(cd->client); |
289 | } | 287 | } |
290 | 288 | ||
291 | 289 | ||
@@ -297,9 +295,9 @@ handle_test (void *cls, | |||
297 | * @param srv service handle | 295 | * @param srv service handle |
298 | */ | 296 | */ |
299 | static void | 297 | static void |
300 | run (void *cls, | 298 | run(void *cls, |
301 | const struct GNUNET_CONFIGURATION_Handle *c, | 299 | const struct GNUNET_CONFIGURATION_Handle *c, |
302 | struct GNUNET_SERVICE_Handle *srv) | 300 | struct GNUNET_SERVICE_Handle *srv) |
303 | { | 301 | { |
304 | cfg = c; | 302 | cfg = c; |
305 | } | 303 | } |
@@ -311,12 +309,12 @@ run (void *cls, | |||
311 | * @param cls our `struct ClientData` of a client to drop | 309 | * @param cls our `struct ClientData` of a client to drop |
312 | */ | 310 | */ |
313 | static void | 311 | static void |
314 | force_timeout (void *cls) | 312 | force_timeout(void *cls) |
315 | { | 313 | { |
316 | struct ClientData *cd = cls; | 314 | struct ClientData *cd = cls; |
317 | 315 | ||
318 | cd->tt = NULL; | 316 | cd->tt = NULL; |
319 | GNUNET_SERVICE_client_drop (cd->client); | 317 | GNUNET_SERVICE_client_drop(cd->client); |
320 | } | 318 | } |
321 | 319 | ||
322 | 320 | ||
@@ -330,17 +328,17 @@ force_timeout (void *cls) | |||
330 | * @return our `struct ClientData` | 328 | * @return our `struct ClientData` |
331 | */ | 329 | */ |
332 | static void * | 330 | static void * |
333 | client_connect_cb (void *cls, | 331 | client_connect_cb(void *cls, |
334 | struct GNUNET_SERVICE_Client *c, | 332 | struct GNUNET_SERVICE_Client *c, |
335 | struct GNUNET_MQ_Handle *mq) | 333 | struct GNUNET_MQ_Handle *mq) |
336 | { | 334 | { |
337 | struct ClientData *cd; | 335 | struct ClientData *cd; |
338 | 336 | ||
339 | cd = GNUNET_new (struct ClientData); | 337 | cd = GNUNET_new(struct ClientData); |
340 | cd->client = c; | 338 | cd->client = c; |
341 | cd->tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | 339 | cd->tt = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, |
342 | &force_timeout, | 340 | &force_timeout, |
343 | cd); | 341 | cd); |
344 | return cd; | 342 | return cd; |
345 | } | 343 | } |
346 | 344 | ||
@@ -353,15 +351,15 @@ client_connect_cb (void *cls, | |||
353 | * @param internal_cls our `struct ClientData` | 351 | * @param internal_cls our `struct ClientData` |
354 | */ | 352 | */ |
355 | static void | 353 | static void |
356 | client_disconnect_cb (void *cls, | 354 | client_disconnect_cb(void *cls, |
357 | struct GNUNET_SERVICE_Client *c, | 355 | struct GNUNET_SERVICE_Client *c, |
358 | void *internal_cls) | 356 | void *internal_cls) |
359 | { | 357 | { |
360 | struct ClientData *cd = internal_cls; | 358 | struct ClientData *cd = internal_cls; |
361 | 359 | ||
362 | if (NULL != cd->tt) | 360 | if (NULL != cd->tt) |
363 | GNUNET_SCHEDULER_cancel (cd->tt); | 361 | GNUNET_SCHEDULER_cancel(cd->tt); |
364 | GNUNET_free (cd); | 362 | GNUNET_free(cd); |
365 | } | 363 | } |
366 | 364 | ||
367 | 365 | ||
@@ -369,17 +367,17 @@ client_disconnect_cb (void *cls, | |||
369 | * Define "main" method using service macro. | 367 | * Define "main" method using service macro. |
370 | */ | 368 | */ |
371 | GNUNET_SERVICE_MAIN | 369 | GNUNET_SERVICE_MAIN |
372 | ("nat-server", | 370 | ("nat-server", |
373 | GNUNET_SERVICE_OPTION_NONE, | 371 | GNUNET_SERVICE_OPTION_NONE, |
374 | &run, | 372 | &run, |
375 | &client_connect_cb, | 373 | &client_connect_cb, |
376 | &client_disconnect_cb, | 374 | &client_disconnect_cb, |
377 | NULL, | 375 | NULL, |
378 | GNUNET_MQ_hd_fixed_size (test, | 376 | GNUNET_MQ_hd_fixed_size(test, |
379 | GNUNET_MESSAGE_TYPE_NAT_TEST, | 377 | GNUNET_MESSAGE_TYPE_NAT_TEST, |
380 | struct GNUNET_NAT_AUTO_TestMessage, | 378 | struct GNUNET_NAT_AUTO_TestMessage, |
381 | NULL), | 379 | NULL), |
382 | GNUNET_MQ_handler_end ()); | 380 | GNUNET_MQ_handler_end()); |
383 | 381 | ||
384 | 382 | ||
385 | #if defined(LINUX) && defined(__GLIBC__) | 383 | #if defined(LINUX) && defined(__GLIBC__) |
@@ -389,11 +387,11 @@ GNUNET_SERVICE_MAIN | |||
389 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 387 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
390 | */ | 388 | */ |
391 | void __attribute__ ((constructor)) | 389 | void __attribute__ ((constructor)) |
392 | GNUNET_ARM_memory_init () | 390 | GNUNET_ARM_memory_init() |
393 | { | 391 | { |
394 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 392 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); |
395 | mallopt (M_TOP_PAD, 1 * 1024); | 393 | mallopt(M_TOP_PAD, 1 * 1024); |
396 | malloc_trim (0); | 394 | malloc_trim(0); |
397 | } | 395 | } |
398 | #endif | 396 | #endif |
399 | 397 | ||
diff --git a/src/nat-auto/gnunet-service-nat-auto.c b/src/nat-auto/gnunet-service-nat-auto.c index 0b2995441..199a759ea 100644 --- a/src/nat-auto/gnunet-service-nat-auto.c +++ b/src/nat-auto/gnunet-service-nat-auto.c | |||
@@ -1,19 +1,19 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | Copyright (C) 2016, 2017 GNUnet e.V. | 3 | Copyright (C) 2016, 2017 GNUnet e.V. |
4 | 4 | ||
5 | GNUnet is free software: you can redistribute it and/or modify it | 5 | GNUnet is free software: you can redistribute it and/or modify it |
6 | under the terms of the GNU Affero General Public License as published | 6 | under the terms of the GNU Affero General Public License as published |
7 | by the Free Software Foundation, either version 3 of the License, | 7 | by the Free Software Foundation, either version 3 of the License, |
8 | or (at your option) any later version. | 8 | or (at your option) any later version. |
9 | 9 | ||
10 | GNUnet is distributed in the hope that it will be useful, but | 10 | GNUnet is distributed in the hope that it will be useful, but |
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
@@ -45,15 +45,13 @@ | |||
45 | /** | 45 | /** |
46 | * How long do we wait until we forcefully terminate autoconfiguration? | 46 | * How long do we wait until we forcefully terminate autoconfiguration? |
47 | */ | 47 | */ |
48 | #define AUTOCONFIG_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) | 48 | #define AUTOCONFIG_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) |
49 | 49 | ||
50 | 50 | ||
51 | /** | 51 | /** |
52 | * Internal data structure we track for each of our clients. | 52 | * Internal data structure we track for each of our clients. |
53 | */ | 53 | */ |
54 | struct ClientHandle | 54 | struct ClientHandle { |
55 | { | ||
56 | |||
57 | /** | 55 | /** |
58 | * Kept in a DLL. | 56 | * Kept in a DLL. |
59 | */ | 57 | */ |
@@ -79,8 +77,7 @@ struct ClientHandle | |||
79 | /** | 77 | /** |
80 | * Context for autoconfiguration operations. | 78 | * Context for autoconfiguration operations. |
81 | */ | 79 | */ |
82 | struct AutoconfigContext | 80 | struct AutoconfigContext { |
83 | { | ||
84 | /** | 81 | /** |
85 | * Kept in a DLL. | 82 | * Kept in a DLL. |
86 | */ | 83 | */ |
@@ -170,8 +167,8 @@ static struct GNUNET_STATISTICS_Handle *stats; | |||
170 | * @return #GNUNET_OK if message is well-formed | 167 | * @return #GNUNET_OK if message is well-formed |
171 | */ | 168 | */ |
172 | static int | 169 | static int |
173 | check_autoconfig_request (void *cls, | 170 | check_autoconfig_request(void *cls, |
174 | const struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *message) | 171 | const struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *message) |
175 | { | 172 | { |
176 | return GNUNET_OK; /* checked later */ | 173 | return GNUNET_OK; /* checked later */ |
177 | } | 174 | } |
@@ -183,13 +180,13 @@ check_autoconfig_request (void *cls, | |||
183 | * @param ac autoconfiguration to terminate activities for | 180 | * @param ac autoconfiguration to terminate activities for |
184 | */ | 181 | */ |
185 | static void | 182 | static void |
186 | terminate_ac_activities (struct AutoconfigContext *ac) | 183 | terminate_ac_activities(struct AutoconfigContext *ac) |
187 | { | 184 | { |
188 | if (NULL != ac->timeout_task) | 185 | if (NULL != ac->timeout_task) |
189 | { | 186 | { |
190 | GNUNET_SCHEDULER_cancel (ac->timeout_task); | 187 | GNUNET_SCHEDULER_cancel(ac->timeout_task); |
191 | ac->timeout_task = NULL; | 188 | ac->timeout_task = NULL; |
192 | } | 189 | } |
193 | } | 190 | } |
194 | 191 | ||
195 | 192 | ||
@@ -200,7 +197,7 @@ terminate_ac_activities (struct AutoconfigContext *ac) | |||
200 | * @param cls the `struct AutoconfigContext` to conclude | 197 | * @param cls the `struct AutoconfigContext` to conclude |
201 | */ | 198 | */ |
202 | static void | 199 | static void |
203 | conclude_autoconfig_request (void *cls) | 200 | conclude_autoconfig_request(void *cls) |
204 | { | 201 | { |
205 | struct AutoconfigContext *ac = cls; | 202 | struct AutoconfigContext *ac = cls; |
206 | struct ClientHandle *ch = ac->ch; | 203 | struct ClientHandle *ch = ac->ch; |
@@ -211,34 +208,34 @@ conclude_autoconfig_request (void *cls) | |||
211 | struct GNUNET_CONFIGURATION_Handle *diff; | 208 | struct GNUNET_CONFIGURATION_Handle *diff; |
212 | 209 | ||
213 | ac->timeout_task = NULL; | 210 | ac->timeout_task = NULL; |
214 | terminate_ac_activities (ac); | 211 | terminate_ac_activities(ac); |
215 | 212 | ||
216 | /* Send back response */ | 213 | /* Send back response */ |
217 | diff = GNUNET_CONFIGURATION_get_diff (ac->orig, | 214 | diff = GNUNET_CONFIGURATION_get_diff(ac->orig, |
218 | ac->c); | 215 | ac->c); |
219 | buf = GNUNET_CONFIGURATION_serialize (diff, | 216 | buf = GNUNET_CONFIGURATION_serialize(diff, |
220 | &c_size); | 217 | &c_size); |
221 | GNUNET_CONFIGURATION_destroy (diff); | 218 | GNUNET_CONFIGURATION_destroy(diff); |
222 | env = GNUNET_MQ_msg_extra (arm, | 219 | env = GNUNET_MQ_msg_extra(arm, |
223 | c_size, | 220 | c_size, |
224 | GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT); | 221 | GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT); |
225 | arm->status_code = htonl ((uint32_t) ac->status_code); | 222 | arm->status_code = htonl((uint32_t)ac->status_code); |
226 | arm->type = htonl ((uint32_t) ac->type); | 223 | arm->type = htonl((uint32_t)ac->type); |
227 | GNUNET_memcpy (&arm[1], | 224 | GNUNET_memcpy(&arm[1], |
228 | buf, | 225 | buf, |
229 | c_size); | 226 | c_size); |
230 | GNUNET_free (buf); | 227 | GNUNET_free(buf); |
231 | GNUNET_MQ_send (ch->mq, | 228 | GNUNET_MQ_send(ch->mq, |
232 | env); | 229 | env); |
233 | 230 | ||
234 | /* clean up */ | 231 | /* clean up */ |
235 | GNUNET_CONFIGURATION_destroy (ac->orig); | 232 | GNUNET_CONFIGURATION_destroy(ac->orig); |
236 | GNUNET_CONFIGURATION_destroy (ac->c); | 233 | GNUNET_CONFIGURATION_destroy(ac->c); |
237 | GNUNET_CONTAINER_DLL_remove (ac_head, | 234 | GNUNET_CONTAINER_DLL_remove(ac_head, |
238 | ac_tail, | 235 | ac_tail, |
239 | ac); | 236 | ac); |
240 | GNUNET_free (ac); | 237 | GNUNET_free(ac); |
241 | GNUNET_SERVICE_client_continue (ch->client); | 238 | GNUNET_SERVICE_client_continue(ch->client); |
242 | } | 239 | } |
243 | 240 | ||
244 | 241 | ||
@@ -249,12 +246,12 @@ conclude_autoconfig_request (void *cls) | |||
249 | * @param ac autoconfiguation context to check | 246 | * @param ac autoconfiguation context to check |
250 | */ | 247 | */ |
251 | static void | 248 | static void |
252 | check_autoconfig_finished (struct AutoconfigContext *ac) | 249 | check_autoconfig_finished(struct AutoconfigContext *ac) |
253 | { | 250 | { |
254 | GNUNET_SCHEDULER_cancel (ac->timeout_task); | 251 | GNUNET_SCHEDULER_cancel(ac->timeout_task); |
255 | ac->timeout_task | 252 | ac->timeout_task |
256 | = GNUNET_SCHEDULER_add_now (&conclude_autoconfig_request, | 253 | = GNUNET_SCHEDULER_add_now(&conclude_autoconfig_request, |
257 | ac); | 254 | ac); |
258 | } | 255 | } |
259 | 256 | ||
260 | 257 | ||
@@ -264,26 +261,28 @@ check_autoconfig_finished (struct AutoconfigContext *ac) | |||
264 | * @param ac autoconfiguration to update | 261 | * @param ac autoconfiguration to update |
265 | */ | 262 | */ |
266 | static void | 263 | static void |
267 | update_enable_upnpc_option (struct AutoconfigContext *ac) | 264 | update_enable_upnpc_option(struct AutoconfigContext *ac) |
268 | { | 265 | { |
269 | switch (ac->enable_upnpc) | 266 | switch (ac->enable_upnpc) |
270 | { | 267 | { |
271 | case GNUNET_YES: | 268 | case GNUNET_YES: |
272 | GNUNET_CONFIGURATION_set_value_string (ac->c, | 269 | GNUNET_CONFIGURATION_set_value_string(ac->c, |
273 | "NAT", | 270 | "NAT", |
274 | "ENABLE_UPNP", | 271 | "ENABLE_UPNP", |
275 | "YES"); | 272 | "YES"); |
276 | break; | 273 | break; |
277 | case GNUNET_NO: | 274 | |
278 | GNUNET_CONFIGURATION_set_value_string (ac->c, | 275 | case GNUNET_NO: |
279 | "NAT", | 276 | GNUNET_CONFIGURATION_set_value_string(ac->c, |
280 | "ENABLE_UPNP", | 277 | "NAT", |
281 | "NO"); | 278 | "ENABLE_UPNP", |
282 | break; | 279 | "NO"); |
283 | case GNUNET_SYSERR: | 280 | break; |
284 | /* We are unsure, do not change option */ | 281 | |
285 | break; | 282 | case GNUNET_SYSERR: |
286 | } | 283 | /* We are unsure, do not change option */ |
284 | break; | ||
285 | } | ||
287 | } | 286 | } |
288 | 287 | ||
289 | 288 | ||
@@ -295,62 +294,62 @@ update_enable_upnpc_option (struct AutoconfigContext *ac) | |||
295 | * @param message the message received | 294 | * @param message the message received |
296 | */ | 295 | */ |
297 | static void | 296 | static void |
298 | handle_autoconfig_request (void *cls, | 297 | handle_autoconfig_request(void *cls, |
299 | const struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *message) | 298 | const struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *message) |
300 | { | 299 | { |
301 | struct ClientHandle *ch = cls; | 300 | struct ClientHandle *ch = cls; |
302 | size_t left = ntohs (message->header.size) - sizeof (*message); | 301 | size_t left = ntohs(message->header.size) - sizeof(*message); |
303 | struct AutoconfigContext *ac; | 302 | struct AutoconfigContext *ac; |
304 | 303 | ||
305 | ac = GNUNET_new (struct AutoconfigContext); | 304 | ac = GNUNET_new(struct AutoconfigContext); |
306 | ac->status_code = GNUNET_NAT_ERROR_SUCCESS; | 305 | ac->status_code = GNUNET_NAT_ERROR_SUCCESS; |
307 | ac->ch = ch; | 306 | ac->ch = ch; |
308 | ac->c = GNUNET_CONFIGURATION_create (); | 307 | ac->c = GNUNET_CONFIGURATION_create(); |
309 | if (GNUNET_OK != | 308 | if (GNUNET_OK != |
310 | GNUNET_CONFIGURATION_deserialize (ac->c, | 309 | GNUNET_CONFIGURATION_deserialize(ac->c, |
311 | (const char *) &message[1], | 310 | (const char *)&message[1], |
312 | left, | 311 | left, |
313 | NULL)) | 312 | NULL)) |
314 | { | 313 | { |
315 | GNUNET_break (0); | 314 | GNUNET_break(0); |
316 | GNUNET_SERVICE_client_drop (ch->client); | 315 | GNUNET_SERVICE_client_drop(ch->client); |
317 | GNUNET_CONFIGURATION_destroy (ac->c); | 316 | GNUNET_CONFIGURATION_destroy(ac->c); |
318 | GNUNET_free (ac); | 317 | GNUNET_free(ac); |
319 | return; | 318 | return; |
320 | } | 319 | } |
321 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 320 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
322 | "Received REQUEST_AUTO_CONFIG message from client\n"); | 321 | "Received REQUEST_AUTO_CONFIG message from client\n"); |
323 | 322 | ||
324 | GNUNET_CONTAINER_DLL_insert (ac_head, | 323 | GNUNET_CONTAINER_DLL_insert(ac_head, |
325 | ac_tail, | 324 | ac_tail, |
326 | ac); | 325 | ac); |
327 | ac->orig | 326 | ac->orig |
328 | = GNUNET_CONFIGURATION_dup (ac->c); | 327 | = GNUNET_CONFIGURATION_dup(ac->c); |
329 | ac->timeout_task | 328 | ac->timeout_task |
330 | = GNUNET_SCHEDULER_add_delayed (AUTOCONFIG_TIMEOUT, | 329 | = GNUNET_SCHEDULER_add_delayed(AUTOCONFIG_TIMEOUT, |
331 | &conclude_autoconfig_request, | 330 | &conclude_autoconfig_request, |
332 | ac); | 331 | ac); |
333 | ac->enable_upnpc = GNUNET_SYSERR; /* undecided */ | 332 | ac->enable_upnpc = GNUNET_SYSERR; /* undecided */ |
334 | 333 | ||
335 | /* Probe for upnpc */ | 334 | /* Probe for upnpc */ |
336 | if (GNUNET_SYSERR == | 335 | if (GNUNET_SYSERR == |
337 | GNUNET_OS_check_helper_binary ("upnpc", | 336 | GNUNET_OS_check_helper_binary("upnpc", |
338 | GNUNET_NO, | 337 | GNUNET_NO, |
339 | NULL)) | 338 | NULL)) |
340 | { | 339 | { |
341 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 340 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
342 | _("UPnP client `upnpc` command not found, disabling UPnP\n")); | 341 | _("UPnP client `upnpc` command not found, disabling UPnP\n")); |
343 | ac->enable_upnpc = GNUNET_NO; | 342 | ac->enable_upnpc = GNUNET_NO; |
344 | } | 343 | } |
345 | else | 344 | else |
346 | { | 345 | { |
347 | /* We might at some point be behind NAT, try upnpc */ | 346 | /* We might at some point be behind NAT, try upnpc */ |
348 | ac->enable_upnpc = GNUNET_YES; | 347 | ac->enable_upnpc = GNUNET_YES; |
349 | } | 348 | } |
350 | update_enable_upnpc_option (ac); | 349 | update_enable_upnpc_option(ac); |
351 | 350 | ||
352 | /* Finally, check if we are already done */ | 351 | /* Finally, check if we are already done */ |
353 | check_autoconfig_finished (ac); | 352 | check_autoconfig_finished(ac); |
354 | } | 353 | } |
355 | 354 | ||
356 | 355 | ||
@@ -360,24 +359,24 @@ handle_autoconfig_request (void *cls, | |||
360 | * @param cls unused | 359 | * @param cls unused |
361 | */ | 360 | */ |
362 | static void | 361 | static void |
363 | shutdown_task (void *cls) | 362 | shutdown_task(void *cls) |
364 | { | 363 | { |
365 | struct AutoconfigContext *ac; | 364 | struct AutoconfigContext *ac; |
366 | 365 | ||
367 | while (NULL != (ac = ac_head)) | 366 | while (NULL != (ac = ac_head)) |
368 | { | 367 | { |
369 | GNUNET_CONTAINER_DLL_remove (ac_head, | 368 | GNUNET_CONTAINER_DLL_remove(ac_head, |
370 | ac_tail, | 369 | ac_tail, |
371 | ac); | 370 | ac); |
372 | terminate_ac_activities (ac); | 371 | terminate_ac_activities(ac); |
373 | GNUNET_free (ac); | 372 | GNUNET_free(ac); |
374 | } | 373 | } |
375 | if (NULL != stats) | 374 | if (NULL != stats) |
376 | { | 375 | { |
377 | GNUNET_STATISTICS_destroy (stats, | 376 | GNUNET_STATISTICS_destroy(stats, |
378 | GNUNET_NO); | 377 | GNUNET_NO); |
379 | stats = NULL; | 378 | stats = NULL; |
380 | } | 379 | } |
381 | } | 380 | } |
382 | 381 | ||
383 | 382 | ||
@@ -389,15 +388,15 @@ shutdown_task (void *cls) | |||
389 | * @param service the initialized service | 388 | * @param service the initialized service |
390 | */ | 389 | */ |
391 | static void | 390 | static void |
392 | run (void *cls, | 391 | run(void *cls, |
393 | const struct GNUNET_CONFIGURATION_Handle *c, | 392 | const struct GNUNET_CONFIGURATION_Handle *c, |
394 | struct GNUNET_SERVICE_Handle *service) | 393 | struct GNUNET_SERVICE_Handle *service) |
395 | { | 394 | { |
396 | cfg = c; | 395 | cfg = c; |
397 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, | 396 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, |
398 | NULL); | 397 | NULL); |
399 | stats = GNUNET_STATISTICS_create ("nat-auto", | 398 | stats = GNUNET_STATISTICS_create("nat-auto", |
400 | cfg); | 399 | cfg); |
401 | } | 400 | } |
402 | 401 | ||
403 | 402 | ||
@@ -410,18 +409,18 @@ run (void *cls, | |||
410 | * @return a `struct ClientHandle` | 409 | * @return a `struct ClientHandle` |
411 | */ | 410 | */ |
412 | static void * | 411 | static void * |
413 | client_connect_cb (void *cls, | 412 | client_connect_cb(void *cls, |
414 | struct GNUNET_SERVICE_Client *c, | 413 | struct GNUNET_SERVICE_Client *c, |
415 | struct GNUNET_MQ_Handle *mq) | 414 | struct GNUNET_MQ_Handle *mq) |
416 | { | 415 | { |
417 | struct ClientHandle *ch; | 416 | struct ClientHandle *ch; |
418 | 417 | ||
419 | ch = GNUNET_new (struct ClientHandle); | 418 | ch = GNUNET_new(struct ClientHandle); |
420 | ch->mq = mq; | 419 | ch->mq = mq; |
421 | ch->client = c; | 420 | ch->client = c; |
422 | GNUNET_CONTAINER_DLL_insert (ch_head, | 421 | GNUNET_CONTAINER_DLL_insert(ch_head, |
423 | ch_tail, | 422 | ch_tail, |
424 | ch); | 423 | ch); |
425 | return ch; | 424 | return ch; |
426 | } | 425 | } |
427 | 426 | ||
@@ -434,16 +433,16 @@ client_connect_cb (void *cls, | |||
434 | * @param internal_cls a `struct ClientHandle *` | 433 | * @param internal_cls a `struct ClientHandle *` |
435 | */ | 434 | */ |
436 | static void | 435 | static void |
437 | client_disconnect_cb (void *cls, | 436 | client_disconnect_cb(void *cls, |
438 | struct GNUNET_SERVICE_Client *c, | 437 | struct GNUNET_SERVICE_Client *c, |
439 | void *internal_cls) | 438 | void *internal_cls) |
440 | { | 439 | { |
441 | struct ClientHandle *ch = internal_cls; | 440 | struct ClientHandle *ch = internal_cls; |
442 | 441 | ||
443 | GNUNET_CONTAINER_DLL_remove (ch_head, | 442 | GNUNET_CONTAINER_DLL_remove(ch_head, |
444 | ch_tail, | 443 | ch_tail, |
445 | ch); | 444 | ch); |
446 | GNUNET_free (ch); | 445 | GNUNET_free(ch); |
447 | } | 446 | } |
448 | 447 | ||
449 | 448 | ||
@@ -451,17 +450,17 @@ client_disconnect_cb (void *cls, | |||
451 | * Define "main" method using service macro. | 450 | * Define "main" method using service macro. |
452 | */ | 451 | */ |
453 | GNUNET_SERVICE_MAIN | 452 | GNUNET_SERVICE_MAIN |
454 | ("nat-auto", | 453 | ("nat-auto", |
455 | GNUNET_SERVICE_OPTION_NONE, | 454 | GNUNET_SERVICE_OPTION_NONE, |
456 | &run, | 455 | &run, |
457 | &client_connect_cb, | 456 | &client_connect_cb, |
458 | &client_disconnect_cb, | 457 | &client_disconnect_cb, |
459 | NULL, | 458 | NULL, |
460 | GNUNET_MQ_hd_var_size (autoconfig_request, | 459 | GNUNET_MQ_hd_var_size(autoconfig_request, |
461 | GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG, | 460 | GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG, |
462 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage, | 461 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage, |
463 | NULL), | 462 | NULL), |
464 | GNUNET_MQ_handler_end ()); | 463 | GNUNET_MQ_handler_end()); |
465 | 464 | ||
466 | 465 | ||
467 | #if defined(LINUX) && defined(__GLIBC__) | 466 | #if defined(LINUX) && defined(__GLIBC__) |
@@ -471,11 +470,11 @@ GNUNET_SERVICE_MAIN | |||
471 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 470 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
472 | */ | 471 | */ |
473 | void __attribute__ ((constructor)) | 472 | void __attribute__ ((constructor)) |
474 | GNUNET_ARM_memory_init () | 473 | GNUNET_ARM_memory_init() |
475 | { | 474 | { |
476 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 475 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); |
477 | mallopt (M_TOP_PAD, 1 * 1024); | 476 | mallopt(M_TOP_PAD, 1 * 1024); |
478 | malloc_trim (0); | 477 | malloc_trim(0); |
479 | } | 478 | } |
480 | #endif | 479 | #endif |
481 | 480 | ||
diff --git a/src/nat-auto/gnunet-service-nat-auto_legacy.c b/src/nat-auto/gnunet-service-nat-auto_legacy.c index 00bdeb693..30f1f855d 100644 --- a/src/nat-auto/gnunet-service-nat-auto_legacy.c +++ b/src/nat-auto/gnunet-service-nat-auto_legacy.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file nat/nat_auto.c | 22 | * @file nat/nat_auto.c |
@@ -30,21 +30,20 @@ | |||
30 | #include "gnunet_nat_lib.h" | 30 | #include "gnunet_nat_lib.h" |
31 | #include "nat.h" | 31 | #include "nat.h" |
32 | 32 | ||
33 | #define LOG(kind,...) GNUNET_log_from (kind, "nat", __VA_ARGS__) | 33 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat", __VA_ARGS__) |
34 | 34 | ||
35 | 35 | ||
36 | /** | 36 | /** |
37 | * How long do we wait for the NAT test to report success? | 37 | * How long do we wait for the NAT test to report success? |
38 | */ | 38 | */ |
39 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) | 39 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) |
40 | 40 | ||
41 | #define NAT_SERVER_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10) | 41 | #define NAT_SERVER_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10) |
42 | 42 | ||
43 | /** | 43 | /** |
44 | * Phases of the auto configuration. | 44 | * Phases of the auto configuration. |
45 | */ | 45 | */ |
46 | enum AutoPhase | 46 | enum AutoPhase { |
47 | { | ||
48 | /** | 47 | /** |
49 | * Initial start value. | 48 | * Initial start value. |
50 | */ | 49 | */ |
@@ -58,7 +57,7 @@ enum AutoPhase | |||
58 | /** | 57 | /** |
59 | * Test our external IP. | 58 | * Test our external IP. |
60 | */ | 59 | */ |
61 | AUTO_STUN, | 60 | AUTO_STUN, |
62 | 61 | ||
63 | /** | 62 | /** |
64 | * Test our internal IP. | 63 | * Test our internal IP. |
@@ -89,16 +88,13 @@ enum AutoPhase | |||
89 | * Last phase, we're done. | 88 | * Last phase, we're done. |
90 | */ | 89 | */ |
91 | AUTO_DONE | 90 | AUTO_DONE |
92 | |||
93 | }; | 91 | }; |
94 | 92 | ||
95 | 93 | ||
96 | /** | 94 | /** |
97 | * Handle to auto-configuration in progress. | 95 | * Handle to auto-configuration in progress. |
98 | */ | 96 | */ |
99 | struct GNUNET_NAT_AutoHandle | 97 | struct GNUNET_NAT_AutoHandle { |
100 | { | ||
101 | |||
102 | /** | 98 | /** |
103 | * Handle to the active NAT test. | 99 | * Handle to the active NAT test. |
104 | */ | 100 | */ |
@@ -209,7 +205,7 @@ static unsigned int stun_port = 3478; | |||
209 | * @param ah auto test handle | 205 | * @param ah auto test handle |
210 | */ | 206 | */ |
211 | static void | 207 | static void |
212 | next_phase (struct GNUNET_NAT_AutoHandle *ah); | 208 | next_phase(struct GNUNET_NAT_AutoHandle *ah); |
213 | 209 | ||
214 | 210 | ||
215 | static void | 211 | static void |
@@ -217,12 +213,12 @@ process_stun_reply(struct sockaddr_in *answer, | |||
217 | struct GNUNET_NAT_AutoHandle *ah) | 213 | struct GNUNET_NAT_AutoHandle *ah) |
218 | { | 214 | { |
219 | ah->stun_ip = inet_ntoa(answer->sin_addr); | 215 | ah->stun_ip = inet_ntoa(answer->sin_addr); |
220 | ah->stun_port = ntohs (answer->sin_port); | 216 | ah->stun_port = ntohs(answer->sin_port); |
221 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 217 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
222 | "External IP is: %s , with port %u\n", | 218 | "External IP is: %s , with port %u\n", |
223 | ah->stun_ip, | 219 | ah->stun_ip, |
224 | ah->stun_port); | 220 | ah->stun_port); |
225 | next_phase (ah); | 221 | next_phase(ah); |
226 | } | 222 | } |
227 | 223 | ||
228 | 224 | ||
@@ -230,22 +226,22 @@ process_stun_reply(struct sockaddr_in *answer, | |||
230 | * Function that terminates the test. | 226 | * Function that terminates the test. |
231 | */ | 227 | */ |
232 | static void | 228 | static void |
233 | stop_stun () | 229 | stop_stun() |
234 | { | 230 | { |
235 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 231 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
236 | "Stopping STUN and quitting...\n"); | 232 | "Stopping STUN and quitting...\n"); |
237 | /* Clean task */ | 233 | /* Clean task */ |
238 | if (NULL != ltask4) | 234 | if (NULL != ltask4) |
239 | { | 235 | { |
240 | GNUNET_SCHEDULER_cancel (ltask4); | 236 | GNUNET_SCHEDULER_cancel(ltask4); |
241 | ltask4 = NULL; | 237 | ltask4 = NULL; |
242 | } | 238 | } |
243 | /* Clean socket */ | 239 | /* Clean socket */ |
244 | if (NULL != lsock4) | 240 | if (NULL != lsock4) |
245 | { | 241 | { |
246 | GNUNET_NETWORK_socket_close (lsock4); | 242 | GNUNET_NETWORK_socket_close(lsock4); |
247 | lsock4 = NULL; | 243 | lsock4 = NULL; |
248 | } | 244 | } |
249 | } | 245 | } |
250 | 246 | ||
251 | 247 | ||
@@ -256,7 +252,7 @@ stop_stun () | |||
256 | * @param cls | 252 | * @param cls |
257 | */ | 253 | */ |
258 | static void | 254 | static void |
259 | do_udp_read (void *cls) | 255 | do_udp_read(void *cls) |
260 | { | 256 | { |
261 | struct GNUNET_NAT_AutoHandle *ah = cls; | 257 | struct GNUNET_NAT_AutoHandle *ah = cls; |
262 | unsigned char reply_buf[1024]; | 258 | unsigned char reply_buf[1024]; |
@@ -264,51 +260,51 @@ do_udp_read (void *cls) | |||
264 | struct sockaddr_in answer; | 260 | struct sockaddr_in answer; |
265 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 261 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
266 | 262 | ||
267 | tc = GNUNET_SCHEDULER_get_task_context (); | 263 | tc = GNUNET_SCHEDULER_get_task_context(); |
268 | if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && | 264 | if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && |
269 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, | 265 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, |
270 | lsock4))) | 266 | lsock4))) |
271 | { | ||
272 | rlen = GNUNET_NETWORK_socket_recv (lsock4, | ||
273 | reply_buf, | ||
274 | sizeof (reply_buf)); | ||
275 | |||
276 | //Lets handle the packet | ||
277 | memset (&answer, 0, sizeof(struct sockaddr_in)); | ||
278 | if (ah->phase == AUTO_NAT_PUNCHED) | ||
279 | { | 267 | { |
280 | //Destroy the connection | 268 | rlen = GNUNET_NETWORK_socket_recv(lsock4, |
281 | GNUNET_NETWORK_socket_close (lsock4); | 269 | reply_buf, |
282 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 270 | sizeof(reply_buf)); |
283 | "The external server was able to connect back"); | 271 | |
284 | ah->connected_back = GNUNET_YES; | 272 | //Lets handle the packet |
285 | next_phase (ah); | 273 | memset(&answer, 0, sizeof(struct sockaddr_in)); |
286 | } | 274 | if (ah->phase == AUTO_NAT_PUNCHED) |
287 | else | 275 | { |
288 | { | 276 | //Destroy the connection |
289 | if (GNUNET_OK == | 277 | GNUNET_NETWORK_socket_close(lsock4); |
290 | GNUNET_NAT_stun_handle_packet (reply_buf, rlen, &answer)) | 278 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
291 | { | 279 | "The external server was able to connect back"); |
292 | //Process the answer | 280 | ah->connected_back = GNUNET_YES; |
293 | process_stun_reply (&answer, ah); | 281 | next_phase(ah); |
294 | } | 282 | } |
295 | else | 283 | else |
296 | { | 284 | { |
297 | next_phase (ah); | 285 | if (GNUNET_OK == |
298 | } | 286 | GNUNET_NAT_stun_handle_packet(reply_buf, rlen, &answer)) |
287 | { | ||
288 | //Process the answer | ||
289 | process_stun_reply(&answer, ah); | ||
290 | } | ||
291 | else | ||
292 | { | ||
293 | next_phase(ah); | ||
294 | } | ||
295 | } | ||
299 | } | 296 | } |
300 | } | ||
301 | else | 297 | else |
302 | { | ||
303 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
304 | "TIMEOUT while waiting for an answer\n"); | ||
305 | if (ah->phase == AUTO_NAT_PUNCHED) | ||
306 | { | 298 | { |
307 | stop_stun(); | 299 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
308 | } | 300 | "TIMEOUT while waiting for an answer\n"); |
301 | if (ah->phase == AUTO_NAT_PUNCHED) | ||
302 | { | ||
303 | stop_stun(); | ||
304 | } | ||
309 | 305 | ||
310 | next_phase (ah); | 306 | next_phase(ah); |
311 | } | 307 | } |
312 | } | 308 | } |
313 | 309 | ||
314 | 310 | ||
@@ -318,45 +314,45 @@ do_udp_read (void *cls) | |||
318 | * @return NULL on error | 314 | * @return NULL on error |
319 | */ | 315 | */ |
320 | static struct GNUNET_NETWORK_Handle * | 316 | static struct GNUNET_NETWORK_Handle * |
321 | bind_v4 () | 317 | bind_v4() |
322 | { | 318 | { |
323 | struct GNUNET_NETWORK_Handle *ls; | 319 | struct GNUNET_NETWORK_Handle *ls; |
324 | struct sockaddr_in sa4; | 320 | struct sockaddr_in sa4; |
325 | int eno; | 321 | int eno; |
326 | 322 | ||
327 | memset (&sa4, 0, sizeof (sa4)); | 323 | memset(&sa4, 0, sizeof(sa4)); |
328 | sa4.sin_family = AF_INET; | 324 | sa4.sin_family = AF_INET; |
329 | sa4.sin_port = htons (port); | 325 | sa4.sin_port = htons(port); |
330 | #if HAVE_SOCKADDR_IN_SIN_LEN | 326 | #if HAVE_SOCKADDR_IN_SIN_LEN |
331 | sa4.sin_len = sizeof (sa4); | 327 | sa4.sin_len = sizeof(sa4); |
332 | #endif | 328 | #endif |
333 | ls = GNUNET_NETWORK_socket_create (AF_INET, | 329 | ls = GNUNET_NETWORK_socket_create(AF_INET, |
334 | SOCK_DGRAM, | 330 | SOCK_DGRAM, |
335 | 0); | 331 | 0); |
336 | if (NULL == ls) | 332 | if (NULL == ls) |
337 | return NULL; | 333 | return NULL; |
338 | if (GNUNET_OK != | 334 | if (GNUNET_OK != |
339 | GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4, | 335 | GNUNET_NETWORK_socket_bind(ls, (const struct sockaddr *)&sa4, |
340 | sizeof (sa4))) | 336 | sizeof(sa4))) |
341 | { | 337 | { |
342 | eno = errno; | 338 | eno = errno; |
343 | GNUNET_NETWORK_socket_close (ls); | 339 | GNUNET_NETWORK_socket_close(ls); |
344 | errno = eno; | 340 | errno = eno; |
345 | return NULL; | 341 | return NULL; |
346 | } | 342 | } |
347 | return ls; | 343 | return ls; |
348 | } | 344 | } |
349 | 345 | ||
350 | 346 | ||
351 | static void | 347 | static void |
352 | request_callback (void *cls, | 348 | request_callback(void *cls, |
353 | enum GNUNET_NAT_StatusCode result) | 349 | enum GNUNET_NAT_StatusCode result) |
354 | { | 350 | { |
355 | // struct GNUNET_NAT_AutoHandle *ah = cls; | 351 | // struct GNUNET_NAT_AutoHandle *ah = cls; |
356 | 352 | ||
357 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 353 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
358 | "Request callback: stop and quit\n"); | 354 | "Request callback: stop and quit\n"); |
359 | stop_stun (); | 355 | stop_stun(); |
360 | 356 | ||
361 | // next_phase (ah); FIXME this always will be NULL, as called in test_stun() | 357 | // next_phase (ah); FIXME this always will be NULL, as called in test_stun() |
362 | } | 358 | } |
@@ -371,22 +367,22 @@ request_callback (void *cls, | |||
371 | * @param emsg NULL on success, otherwise an error message | 367 | * @param emsg NULL on success, otherwise an error message |
372 | */ | 368 | */ |
373 | static void | 369 | static void |
374 | result_callback (void *cls, | 370 | result_callback(void *cls, |
375 | enum GNUNET_NAT_StatusCode ret) | 371 | enum GNUNET_NAT_StatusCode ret) |
376 | { | 372 | { |
377 | struct GNUNET_NAT_AutoHandle *ah = cls; | 373 | struct GNUNET_NAT_AutoHandle *ah = cls; |
378 | 374 | ||
379 | if (GNUNET_NAT_ERROR_SUCCESS == ret) | 375 | if (GNUNET_NAT_ERROR_SUCCESS == ret) |
380 | GNUNET_NAT_test_stop (ah->tst); | 376 | GNUNET_NAT_test_stop(ah->tst); |
381 | ah->tst = NULL; | 377 | ah->tst = NULL; |
382 | ah->ret = ret; | 378 | ah->ret = ret; |
383 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 379 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
384 | GNUNET_NAT_ERROR_SUCCESS == ret | 380 | GNUNET_NAT_ERROR_SUCCESS == ret |
385 | ? _("NAT traversal with ICMP Server succeeded.\n") | 381 | ? _("NAT traversal with ICMP Server succeeded.\n") |
386 | : _("NAT traversal with ICMP Server failed.\n")); | 382 | : _("NAT traversal with ICMP Server failed.\n")); |
387 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER", | 383 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "ENABLE_ICMP_SERVER", |
388 | GNUNET_NAT_ERROR_SUCCESS == ret ? "NO" : "YES"); | 384 | GNUNET_NAT_ERROR_SUCCESS == ret ? "NO" : "YES"); |
389 | next_phase (ah); | 385 | next_phase(ah); |
390 | } | 386 | } |
391 | 387 | ||
392 | 388 | ||
@@ -396,16 +392,16 @@ result_callback (void *cls, | |||
396 | * @param cls the `struct GNUNET_NAT_AutoHandle` | 392 | * @param cls the `struct GNUNET_NAT_AutoHandle` |
397 | */ | 393 | */ |
398 | static void | 394 | static void |
399 | reversal_test (void *cls) | 395 | reversal_test(void *cls) |
400 | { | 396 | { |
401 | struct GNUNET_NAT_AutoHandle *ah = cls; | 397 | struct GNUNET_NAT_AutoHandle *ah = cls; |
402 | 398 | ||
403 | ah->task = NULL; | 399 | ah->task = NULL; |
404 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 400 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
405 | _("Testing connection reversal with ICMP server.\n")); | 401 | _("Testing connection reversal with ICMP server.\n")); |
406 | GNUNET_RESOLVER_connect (ah->cfg); | 402 | GNUNET_RESOLVER_connect(ah->cfg); |
407 | ah->tst = GNUNET_NAT_test_start (ah->cfg, GNUNET_YES, 0, 0, TIMEOUT, | 403 | ah->tst = GNUNET_NAT_test_start(ah->cfg, GNUNET_YES, 0, 0, TIMEOUT, |
408 | &result_callback, ah); | 404 | &result_callback, ah); |
409 | } | 405 | } |
410 | 406 | ||
411 | 407 | ||
@@ -418,9 +414,9 @@ reversal_test (void *cls) | |||
418 | * @param emsg NULL on success, otherwise an error message | 414 | * @param emsg NULL on success, otherwise an error message |
419 | */ | 415 | */ |
420 | static void | 416 | static void |
421 | set_external_ipv4 (void *cls, | 417 | set_external_ipv4(void *cls, |
422 | const struct in_addr *addr, | 418 | const struct in_addr *addr, |
423 | enum GNUNET_NAT_StatusCode ret) | 419 | enum GNUNET_NAT_StatusCode ret) |
424 | { | 420 | { |
425 | struct GNUNET_NAT_AutoHandle *ah = cls; | 421 | struct GNUNET_NAT_AutoHandle *ah = cls; |
426 | char buf[INET_ADDRSTRLEN]; | 422 | char buf[INET_ADDRSTRLEN]; |
@@ -428,35 +424,35 @@ set_external_ipv4 (void *cls, | |||
428 | ah->eh = NULL; | 424 | ah->eh = NULL; |
429 | ah->ret = ret; | 425 | ah->ret = ret; |
430 | if (GNUNET_NAT_ERROR_SUCCESS != ret) | 426 | if (GNUNET_NAT_ERROR_SUCCESS != ret) |
431 | { | 427 | { |
432 | next_phase (ah); | 428 | next_phase(ah); |
433 | return; | 429 | return; |
434 | } | 430 | } |
435 | /* enable 'behind nat' */ | 431 | /* enable 'behind nat' */ |
436 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 432 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
437 | _("Detected external IP `%s'\n"), | 433 | _("Detected external IP `%s'\n"), |
438 | inet_ntop (AF_INET, | 434 | inet_ntop(AF_INET, |
439 | addr, | 435 | addr, |
440 | buf, | 436 | buf, |
441 | sizeof (buf))); | 437 | sizeof(buf))); |
442 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES"); | 438 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "BEHIND_NAT", "YES"); |
443 | 439 | ||
444 | /* set external IP address */ | 440 | /* set external IP address */ |
445 | if (NULL == inet_ntop (AF_INET, addr, buf, sizeof (buf))) | 441 | if (NULL == inet_ntop(AF_INET, addr, buf, sizeof(buf))) |
446 | { | 442 | { |
447 | GNUNET_break (0); | 443 | GNUNET_break(0); |
448 | /* actually, this should never happen, as the caller already executed just | 444 | /* actually, this should never happen, as the caller already executed just |
449 | * this check, but for consistency (eg: future changes in the caller) | 445 | * this check, but for consistency (eg: future changes in the caller) |
450 | * we still need to report this error... | 446 | * we still need to report this error... |
451 | */ | 447 | */ |
452 | ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID; | 448 | ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID; |
453 | next_phase (ah); | 449 | next_phase(ah); |
454 | return; | 450 | return; |
455 | } | 451 | } |
456 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS", | 452 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "EXTERNAL_ADDRESS", |
457 | buf); | 453 | buf); |
458 | ah->upnp_set_external_address = GNUNET_YES; | 454 | ah->upnp_set_external_address = GNUNET_YES; |
459 | next_phase (ah); | 455 | next_phase(ah); |
460 | } | 456 | } |
461 | 457 | ||
462 | 458 | ||
@@ -466,15 +462,15 @@ set_external_ipv4 (void *cls, | |||
466 | * @param ah auto setup context | 462 | * @param ah auto setup context |
467 | */ | 463 | */ |
468 | static void | 464 | static void |
469 | test_external_ip (struct GNUNET_NAT_AutoHandle *ah) | 465 | test_external_ip(struct GNUNET_NAT_AutoHandle *ah) |
470 | { | 466 | { |
471 | if (GNUNET_NAT_ERROR_SUCCESS != ah->ret) | 467 | if (GNUNET_NAT_ERROR_SUCCESS != ah->ret) |
472 | next_phase (ah); | 468 | next_phase(ah); |
473 | 469 | ||
474 | // FIXME: CPS? | 470 | // FIXME: CPS? |
475 | /* try to detect external IP */ | 471 | /* try to detect external IP */ |
476 | ah->eh = GNUNET_NAT_mini_get_external_ipv4 (TIMEOUT, | 472 | ah->eh = GNUNET_NAT_mini_get_external_ipv4(TIMEOUT, |
477 | &set_external_ipv4, ah); | 473 | &set_external_ipv4, ah); |
478 | } | 474 | } |
479 | 475 | ||
480 | 476 | ||
@@ -484,54 +480,53 @@ test_external_ip (struct GNUNET_NAT_AutoHandle *ah) | |||
484 | * @param ah auto setup context | 480 | * @param ah auto setup context |
485 | */ | 481 | */ |
486 | static void | 482 | static void |
487 | test_stun (struct GNUNET_NAT_AutoHandle *ah) | 483 | test_stun(struct GNUNET_NAT_AutoHandle *ah) |
488 | { | 484 | { |
489 | 485 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Running STUN test\n"); | |
490 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running STUN test\n"); | ||
491 | 486 | ||
492 | /* Get port from the configuration */ | 487 | /* Get port from the configuration */ |
493 | if (GNUNET_OK != | 488 | if (GNUNET_OK != |
494 | GNUNET_CONFIGURATION_get_value_number (ah->cfg, | 489 | GNUNET_CONFIGURATION_get_value_number(ah->cfg, |
495 | "transport-udp", | 490 | "transport-udp", |
496 | "PORT", | 491 | "PORT", |
497 | &port)) | 492 | &port)) |
498 | { | 493 | { |
499 | port = 2086; | 494 | port = 2086; |
500 | } | 495 | } |
501 | 496 | ||
502 | //Lets create the socket | 497 | //Lets create the socket |
503 | lsock4 = bind_v4 (); | 498 | lsock4 = bind_v4(); |
504 | if (NULL == lsock4) | 499 | if (NULL == lsock4) |
505 | { | 500 | { |
506 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); | 501 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); |
507 | next_phase(ah); | 502 | next_phase(ah); |
508 | return; | 503 | return; |
509 | } | 504 | } |
510 | else | 505 | else |
511 | { | 506 | { |
512 | //Lets call our function now when it accepts | 507 | //Lets call our function now when it accepts |
513 | ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT, | 508 | ltask4 = GNUNET_SCHEDULER_add_read_net(NAT_SERVER_TIMEOUT, |
514 | lsock4, | 509 | lsock4, |
515 | &do_udp_read, | 510 | &do_udp_read, |
516 | ah); | 511 | ah); |
517 | } | 512 | } |
518 | 513 | ||
519 | 514 | ||
520 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 515 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
521 | "STUN service listens on port %u\n", | 516 | "STUN service listens on port %u\n", |
522 | (unsigned int) port); | 517 | (unsigned int)port); |
523 | if (GNUNET_NO == | 518 | if (GNUNET_NO == |
524 | GNUNET_NAT_stun_make_request (stun_server, | 519 | GNUNET_NAT_stun_make_request(stun_server, |
525 | stun_port, | 520 | stun_port, |
526 | lsock4, | 521 | lsock4, |
527 | &request_callback, | 522 | &request_callback, |
528 | NULL)) | 523 | NULL)) |
529 | { | 524 | { |
530 | /*An error happened*/ | 525 | /*An error happened*/ |
531 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STUN error, stopping\n"); | 526 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "STUN error, stopping\n"); |
532 | stop_stun (); | 527 | stop_stun(); |
533 | next_phase (ah); | 528 | next_phase(ah); |
534 | } | 529 | } |
535 | } | 530 | } |
536 | 531 | ||
537 | 532 | ||
@@ -549,57 +544,57 @@ test_stun (struct GNUNET_NAT_AutoHandle *ah) | |||
549 | * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort | 544 | * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort |
550 | */ | 545 | */ |
551 | static int | 546 | static int |
552 | process_if (void *cls, | 547 | process_if(void *cls, |
553 | const char *name, | 548 | const char *name, |
554 | int isDefault, | 549 | int isDefault, |
555 | const struct sockaddr *addr, | 550 | const struct sockaddr *addr, |
556 | const struct sockaddr *broadcast_addr, | 551 | const struct sockaddr *broadcast_addr, |
557 | const struct sockaddr *netmask, | 552 | const struct sockaddr *netmask, |
558 | socklen_t addrlen) | 553 | socklen_t addrlen) |
559 | { | 554 | { |
560 | struct GNUNET_NAT_AutoHandle *ah = cls; | 555 | struct GNUNET_NAT_AutoHandle *ah = cls; |
561 | const struct sockaddr_in *in; | 556 | const struct sockaddr_in *in; |
562 | char buf[INET_ADDRSTRLEN]; | 557 | char buf[INET_ADDRSTRLEN]; |
563 | 558 | ||
564 | 559 | ||
565 | if ( (sizeof (struct sockaddr_in6) == addrlen) && | 560 | if ((sizeof(struct sockaddr_in6) == addrlen) && |
566 | (0 != GNUNET_memcmp (&in6addr_loopback, &((const struct sockaddr_in6 *) addr)->sin6_addr)) && | 561 | (0 != GNUNET_memcmp(&in6addr_loopback, &((const struct sockaddr_in6 *)addr)->sin6_addr)) && |
567 | (! IN6_IS_ADDR_LINKLOCAL(&((const struct sockaddr_in6 *) addr)->sin6_addr)) ) | 562 | (!IN6_IS_ADDR_LINKLOCAL(&((const struct sockaddr_in6 *)addr)->sin6_addr))) |
568 | { | 563 | { |
569 | ah->have_v6 = GNUNET_YES; | 564 | ah->have_v6 = GNUNET_YES; |
570 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 565 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
571 | _("This system has a global IPv6 address, setting IPv6 to supported.\n")); | 566 | _("This system has a global IPv6 address, setting IPv6 to supported.\n")); |
572 | 567 | ||
568 | return GNUNET_OK; | ||
569 | } | ||
570 | if (addrlen != sizeof(struct sockaddr_in)) | ||
573 | return GNUNET_OK; | 571 | return GNUNET_OK; |
574 | } | 572 | in = (const struct sockaddr_in *)addr; |
575 | if (addrlen != sizeof (struct sockaddr_in)) | ||
576 | return GNUNET_OK; | ||
577 | in = (const struct sockaddr_in *) addr; | ||
578 | 573 | ||
579 | 574 | ||
580 | /* set internal IP address */ | 575 | /* set internal IP address */ |
581 | if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof (buf))) | 576 | if (NULL == inet_ntop(AF_INET, &in->sin_addr, buf, sizeof(buf))) |
582 | { | 577 | { |
583 | GNUNET_break (0); | 578 | GNUNET_break(0); |
584 | return GNUNET_OK; | 579 | return GNUNET_OK; |
585 | } | 580 | } |
586 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS", | 581 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "INTERNAL_ADDRESS", |
587 | buf); | 582 | buf); |
588 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 583 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
589 | _("Detected internal network address `%s'.\n"), | 584 | _("Detected internal network address `%s'.\n"), |
590 | buf); | 585 | buf); |
591 | 586 | ||
592 | 587 | ||
593 | ah->ret = GNUNET_NAT_ERROR_SUCCESS; | 588 | ah->ret = GNUNET_NAT_ERROR_SUCCESS; |
594 | 589 | ||
595 | /* Check if our internal IP is the same as the External detect by STUN*/ | 590 | /* Check if our internal IP is the same as the External detect by STUN*/ |
596 | if(ah->stun_ip && (strcmp(buf, ah->stun_ip) == 0) ) | 591 | if (ah->stun_ip && (strcmp(buf, ah->stun_ip) == 0)) |
597 | { | 592 | { |
598 | ah->internal_ip_is_public = GNUNET_YES; | 593 | ah->internal_ip_is_public = GNUNET_YES; |
599 | GNUNET_log (GNUNET_ERROR_TYPE_INFO,"A internal IP is the sameas the external"); | 594 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "A internal IP is the sameas the external"); |
600 | /* No need to continue*/ | 595 | /* No need to continue*/ |
601 | return GNUNET_SYSERR; | 596 | return GNUNET_SYSERR; |
602 | } | 597 | } |
603 | 598 | ||
604 | /* no need to continue iteration if we found the default */ | 599 | /* no need to continue iteration if we found the default */ |
605 | if (!isDefault) | 600 | if (!isDefault) |
@@ -615,15 +610,15 @@ process_if (void *cls, | |||
615 | * @param ah auto setup context | 610 | * @param ah auto setup context |
616 | */ | 611 | */ |
617 | static void | 612 | static void |
618 | test_local_ip (struct GNUNET_NAT_AutoHandle *ah) | 613 | test_local_ip(struct GNUNET_NAT_AutoHandle *ah) |
619 | { | 614 | { |
620 | ah->have_v6 = GNUNET_NO; | 615 | ah->have_v6 = GNUNET_NO; |
621 | ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP | 616 | ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP |
622 | GNUNET_OS_network_interfaces_list (&process_if, ah); | 617 | GNUNET_OS_network_interfaces_list(&process_if, ah); |
623 | 618 | ||
624 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6", | 619 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "DISABLEV6", |
625 | (GNUNET_YES == ah->have_v6) ? "NO" : "YES"); | 620 | (GNUNET_YES == ah->have_v6) ? "NO" : "YES"); |
626 | next_phase (ah); | 621 | next_phase(ah); |
627 | } | 622 | } |
628 | 623 | ||
629 | 624 | ||
@@ -635,15 +630,15 @@ test_local_ip (struct GNUNET_NAT_AutoHandle *ah) | |||
635 | * @param error error code | 630 | * @param error error code |
636 | */ | 631 | */ |
637 | static void | 632 | static void |
638 | mq_error_handler (void *cls, | 633 | mq_error_handler(void *cls, |
639 | enum GNUNET_MQ_Error error) | 634 | enum GNUNET_MQ_Error error) |
640 | { | 635 | { |
641 | struct GNUNET_NAT_AutoHandle *ah = cls; | 636 | struct GNUNET_NAT_AutoHandle *ah = cls; |
642 | 637 | ||
643 | GNUNET_MQ_destroy (ah->mq); | 638 | GNUNET_MQ_destroy(ah->mq); |
644 | ah->mq = NULL; | 639 | ah->mq = NULL; |
645 | /* wait a bit first? */ | 640 | /* wait a bit first? */ |
646 | next_phase (ah); | 641 | next_phase(ah); |
647 | } | 642 | } |
648 | 643 | ||
649 | 644 | ||
@@ -653,50 +648,50 @@ mq_error_handler (void *cls, | |||
653 | * @param ah auto setup context | 648 | * @param ah auto setup context |
654 | */ | 649 | */ |
655 | static void | 650 | static void |
656 | test_nat_punched (struct GNUNET_NAT_AutoHandle *ah) | 651 | test_nat_punched(struct GNUNET_NAT_AutoHandle *ah) |
657 | { | 652 | { |
658 | struct GNUNET_NAT_TestMessage *msg; | 653 | struct GNUNET_NAT_TestMessage *msg; |
659 | struct GNUNET_MQ_Envelope *env; | 654 | struct GNUNET_MQ_Envelope *env; |
660 | 655 | ||
661 | if (! ah->stun_ip) | 656 | if (!ah->stun_ip) |
662 | { | 657 | { |
663 | LOG (GNUNET_ERROR_TYPE_INFO, | 658 | LOG(GNUNET_ERROR_TYPE_INFO, |
664 | "We don't have a STUN IP"); | 659 | "We don't have a STUN IP"); |
665 | next_phase (ah); | 660 | next_phase(ah); |
666 | return; | 661 | return; |
667 | } | 662 | } |
668 | 663 | ||
669 | LOG (GNUNET_ERROR_TYPE_INFO, | 664 | LOG(GNUNET_ERROR_TYPE_INFO, |
670 | "Asking gnunet-nat-server to connect to `%s'\n", | 665 | "Asking gnunet-nat-server to connect to `%s'\n", |
671 | ah->stun_ip); | 666 | ah->stun_ip); |
672 | ah->mq = GNUNET_CLIENT_connect (ah->cfg, | 667 | ah->mq = GNUNET_CLIENT_connect(ah->cfg, |
673 | "gnunet-nat-server", | 668 | "gnunet-nat-server", |
674 | NULL, | 669 | NULL, |
675 | &mq_error_handler, | 670 | &mq_error_handler, |
676 | ah); | 671 | ah); |
677 | if (NULL == ah->mq) | 672 | if (NULL == ah->mq) |
678 | { | 673 | { |
679 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 674 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
680 | _("Failed to connect to `gnunet-nat-server'\n")); | 675 | _("Failed to connect to `gnunet-nat-server'\n")); |
681 | next_phase (ah); | 676 | next_phase(ah); |
682 | return; | 677 | return; |
683 | } | 678 | } |
684 | env = GNUNET_MQ_msg (msg, | 679 | env = GNUNET_MQ_msg(msg, |
685 | GNUNET_MESSAGE_TYPE_NAT_TEST); | 680 | GNUNET_MESSAGE_TYPE_NAT_TEST); |
686 | msg->dst_ipv4 = inet_addr (ah->stun_ip); | 681 | msg->dst_ipv4 = inet_addr(ah->stun_ip); |
687 | msg->dport = htons (ah->stun_port); | 682 | msg->dport = htons(ah->stun_port); |
688 | msg->data = port; | 683 | msg->data = port; |
689 | msg->is_tcp = htonl ((uint32_t) GNUNET_NO); | 684 | msg->is_tcp = htonl((uint32_t)GNUNET_NO); |
690 | GNUNET_MQ_send (ah->mq, | 685 | GNUNET_MQ_send(ah->mq, |
691 | env); | 686 | env); |
692 | if (NULL != ltask4) | 687 | if (NULL != ltask4) |
693 | { | 688 | { |
694 | GNUNET_SCHEDULER_cancel (ltask4); | 689 | GNUNET_SCHEDULER_cancel(ltask4); |
695 | ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT, | 690 | ltask4 = GNUNET_SCHEDULER_add_read_net(NAT_SERVER_TIMEOUT, |
696 | lsock4, | 691 | lsock4, |
697 | &do_udp_read, | 692 | &do_udp_read, |
698 | ah); | 693 | ah); |
699 | } | 694 | } |
700 | } | 695 | } |
701 | 696 | ||
702 | 697 | ||
@@ -706,26 +701,24 @@ test_nat_punched (struct GNUNET_NAT_AutoHandle *ah) | |||
706 | * @param ah auto setup context | 701 | * @param ah auto setup context |
707 | */ | 702 | */ |
708 | static void | 703 | static void |
709 | test_upnpc (struct GNUNET_NAT_AutoHandle *ah) | 704 | test_upnpc(struct GNUNET_NAT_AutoHandle *ah) |
710 | { | 705 | { |
711 | |||
712 | int have_upnpc; | 706 | int have_upnpc; |
713 | 707 | ||
714 | if (GNUNET_NAT_ERROR_SUCCESS != ah->ret) | 708 | if (GNUNET_NAT_ERROR_SUCCESS != ah->ret) |
715 | next_phase (ah); | 709 | next_phase(ah); |
716 | 710 | ||
717 | // test if upnpc is available | 711 | // test if upnpc is available |
718 | have_upnpc = (GNUNET_SYSERR != | 712 | have_upnpc = (GNUNET_SYSERR != |
719 | GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL)); | 713 | GNUNET_OS_check_helper_binary("upnpc", GNUNET_NO, NULL)); |
720 | //FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP | 714 | //FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP |
721 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 715 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
722 | (have_upnpc) | 716 | (have_upnpc) |
723 | ? _("upnpc found, enabling its use\n") | 717 | ? _("upnpc found, enabling its use\n") |
724 | : _("upnpc not found\n")); | 718 | : _("upnpc not found\n")); |
725 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP", | 719 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, "nat", "ENABLE_UPNP", |
726 | (GNUNET_YES == have_upnpc) ? "YES" : "NO"); | 720 | (GNUNET_YES == have_upnpc) ? "YES" : "NO"); |
727 | next_phase (ah); | 721 | next_phase(ah); |
728 | |||
729 | } | 722 | } |
730 | 723 | ||
731 | 724 | ||
@@ -735,66 +728,66 @@ test_upnpc (struct GNUNET_NAT_AutoHandle *ah) | |||
735 | * @param ah auto setup context | 728 | * @param ah auto setup context |
736 | */ | 729 | */ |
737 | static void | 730 | static void |
738 | test_icmp_server (struct GNUNET_NAT_AutoHandle *ah) | 731 | test_icmp_server(struct GNUNET_NAT_AutoHandle *ah) |
739 | { | 732 | { |
740 | |||
741 | int ext_ip; | 733 | int ext_ip; |
742 | int nated; | 734 | int nated; |
743 | int binary; | 735 | int binary; |
744 | char *tmp; | 736 | char *tmp; |
745 | char *helper; | 737 | char *helper; |
738 | |||
746 | ext_ip = GNUNET_NO; | 739 | ext_ip = GNUNET_NO; |
747 | nated = GNUNET_NO; | 740 | nated = GNUNET_NO; |
748 | binary = GNUNET_NO; | 741 | binary = GNUNET_NO; |
749 | 742 | ||
750 | tmp = NULL; | 743 | tmp = NULL; |
751 | helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server"); | 744 | helper = GNUNET_OS_get_libexec_binary_path("gnunet-helper-nat-server"); |
752 | if ( (GNUNET_OK == | 745 | if ((GNUNET_OK == |
753 | GNUNET_CONFIGURATION_get_value_string (ah->cfg, | 746 | GNUNET_CONFIGURATION_get_value_string(ah->cfg, |
754 | "nat", | 747 | "nat", |
755 | "EXTERNAL_ADDRESS", | 748 | "EXTERNAL_ADDRESS", |
756 | &tmp)) && | 749 | &tmp)) && |
757 | (0 < strlen (tmp)) ) | 750 | (0 < strlen(tmp))) |
758 | { | 751 | { |
759 | ext_ip = GNUNET_OK; | 752 | ext_ip = GNUNET_OK; |
760 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 753 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
761 | _("test_icmp_server not possible, as we have no public IPv4 address\n")); | 754 | _("test_icmp_server not possible, as we have no public IPv4 address\n")); |
762 | } | 755 | } |
763 | else | 756 | else |
764 | goto err; | 757 | goto err; |
765 | 758 | ||
766 | if (GNUNET_YES == | 759 | if (GNUNET_YES == |
767 | GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, | 760 | GNUNET_CONFIGURATION_get_value_yesno(ah->cfg, |
768 | "nat", | 761 | "nat", |
769 | "BEHIND_NAT")) | 762 | "BEHIND_NAT")) |
770 | { | 763 | { |
771 | nated = GNUNET_YES; | 764 | nated = GNUNET_YES; |
772 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 765 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
773 | _("test_icmp_server not possible, as we are not behind NAT\n")); | 766 | _("test_icmp_server not possible, as we are not behind NAT\n")); |
774 | } | 767 | } |
775 | else | 768 | else |
776 | goto err; | 769 | goto err; |
777 | 770 | ||
778 | if (GNUNET_YES == | 771 | if (GNUNET_YES == |
779 | GNUNET_OS_check_helper_binary (helper, | 772 | GNUNET_OS_check_helper_binary(helper, |
780 | GNUNET_YES, | 773 | GNUNET_YES, |
781 | "-d 127.0.0.1" )) | 774 | "-d 127.0.0.1")) |
782 | { | 775 | { |
783 | binary = GNUNET_OK; // use localhost as source for that one udp-port, ok for testing | 776 | binary = GNUNET_OK; // use localhost as source for that one udp-port, ok for testing |
784 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 777 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
785 | _("No working gnunet-helper-nat-server found\n")); | 778 | _("No working gnunet-helper-nat-server found\n")); |
786 | } | 779 | } |
787 | err: | 780 | err: |
788 | GNUNET_free_non_null (tmp); | 781 | GNUNET_free_non_null(tmp); |
789 | GNUNET_free (helper); | 782 | GNUNET_free(helper); |
790 | 783 | ||
791 | if ( (GNUNET_OK == ext_ip) && | 784 | if ((GNUNET_OK == ext_ip) && |
792 | (GNUNET_YES == nated) && | 785 | (GNUNET_YES == nated) && |
793 | (GNUNET_OK == binary) ) | 786 | (GNUNET_OK == binary)) |
794 | ah->task = GNUNET_SCHEDULER_add_now (&reversal_test, | 787 | ah->task = GNUNET_SCHEDULER_add_now(&reversal_test, |
795 | ah); | 788 | ah); |
796 | else | 789 | else |
797 | next_phase (ah); | 790 | next_phase(ah); |
798 | } | 791 | } |
799 | 792 | ||
800 | 793 | ||
@@ -804,51 +797,51 @@ err: | |||
804 | * @param ah auto setup context | 797 | * @param ah auto setup context |
805 | */ | 798 | */ |
806 | static void | 799 | static void |
807 | test_icmp_client (struct GNUNET_NAT_AutoHandle *ah) | 800 | test_icmp_client(struct GNUNET_NAT_AutoHandle *ah) |
808 | { | 801 | { |
809 | char *tmp; | 802 | char *tmp; |
810 | char *helper; | 803 | char *helper; |
811 | 804 | ||
812 | tmp = NULL; | 805 | tmp = NULL; |
813 | helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client"); | 806 | helper = GNUNET_OS_get_libexec_binary_path("gnunet-helper-nat-client"); |
814 | if ( (GNUNET_OK == | 807 | if ((GNUNET_OK == |
815 | GNUNET_CONFIGURATION_get_value_string (ah->cfg, | 808 | GNUNET_CONFIGURATION_get_value_string(ah->cfg, |
816 | "nat", | 809 | "nat", |
817 | "INTERNAL_ADDRESS", | 810 | "INTERNAL_ADDRESS", |
818 | &tmp)) && | 811 | &tmp)) && |
819 | (0 < strlen (tmp)) ) | 812 | (0 < strlen(tmp))) |
820 | { | 813 | { |
821 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 814 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
822 | _("test_icmp_client not possible, as we have no internal IPv4 address\n")); | 815 | _("test_icmp_client not possible, as we have no internal IPv4 address\n")); |
823 | } | 816 | } |
824 | else | 817 | else |
825 | goto err; | 818 | goto err; |
826 | 819 | ||
827 | if (GNUNET_YES != | 820 | if (GNUNET_YES != |
828 | GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, | 821 | GNUNET_CONFIGURATION_get_value_yesno(ah->cfg, |
829 | "nat", | 822 | "nat", |
830 | "BEHIND_NAT")) | 823 | "BEHIND_NAT")) |
831 | { | 824 | { |
832 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 825 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
833 | _("test_icmp_server not possible, as we are not behind NAT\n")); | 826 | _("test_icmp_server not possible, as we are not behind NAT\n")); |
834 | } | 827 | } |
835 | else | 828 | else |
836 | goto err; | 829 | goto err; |
837 | 830 | ||
838 | if (GNUNET_YES == | 831 | if (GNUNET_YES == |
839 | GNUNET_OS_check_helper_binary (helper, | 832 | GNUNET_OS_check_helper_binary(helper, |
840 | GNUNET_YES, | 833 | GNUNET_YES, |
841 | "-d 127.0.0.1 127.0.0.2 42")) | 834 | "-d 127.0.0.1 127.0.0.2 42")) |
842 | { | 835 | { |
843 | // none of these parameters are actually used in privilege testing mode | 836 | // none of these parameters are actually used in privilege testing mode |
844 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 837 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
845 | _("No working gnunet-helper-nat-server found\n")); | 838 | _("No working gnunet-helper-nat-server found\n")); |
846 | } | 839 | } |
847 | err: | 840 | err: |
848 | GNUNET_free_non_null (tmp); | 841 | GNUNET_free_non_null(tmp); |
849 | GNUNET_free (helper); | 842 | GNUNET_free(helper); |
850 | 843 | ||
851 | next_phase (ah); | 844 | next_phase(ah); |
852 | } | 845 | } |
853 | 846 | ||
854 | 847 | ||
@@ -856,156 +849,161 @@ err: | |||
856 | * Run the next phase of the auto test. | 849 | * Run the next phase of the auto test. |
857 | */ | 850 | */ |
858 | static void | 851 | static void |
859 | next_phase (struct GNUNET_NAT_AutoHandle *ah) | 852 | next_phase(struct GNUNET_NAT_AutoHandle *ah) |
860 | { | 853 | { |
861 | struct GNUNET_CONFIGURATION_Handle *diff; | 854 | struct GNUNET_CONFIGURATION_Handle *diff; |
862 | 855 | ||
863 | ah->phase++; | 856 | ah->phase++; |
864 | switch (ah->phase) | 857 | switch (ah->phase) |
865 | { | ||
866 | case AUTO_INIT: | ||
867 | GNUNET_assert (0); | ||
868 | break; | ||
869 | case AUTO_EXTERNAL_IP: | ||
870 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
871 | "Will run AUTO_EXTERNAL_IP\n"); | ||
872 | test_external_ip (ah); | ||
873 | break; | ||
874 | case AUTO_STUN: | ||
875 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
876 | "Will run AUTO_STUN\n"); | ||
877 | test_stun (ah); | ||
878 | break; | ||
879 | case AUTO_LOCAL_IP: | ||
880 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
881 | "Will run AUTO_LOCAL_IP\n"); | ||
882 | test_local_ip (ah); | ||
883 | break; | ||
884 | case AUTO_NAT_PUNCHED: | ||
885 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
886 | "Will run AUTO_NAT_PUNCHED\n"); | ||
887 | test_nat_punched (ah); | ||
888 | break; | ||
889 | case AUTO_UPNPC: | ||
890 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
891 | "Will run AUTO_UPNPC\n"); | ||
892 | test_upnpc (ah); | ||
893 | break; | ||
894 | case AUTO_ICMP_SERVER: | ||
895 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
896 | "Will run AUTO_ICMP_SERVER\n"); | ||
897 | test_icmp_server (ah); | ||
898 | break; | ||
899 | case AUTO_ICMP_CLIENT: | ||
900 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
901 | "Will run AUTO_ICMP_CLIENT\n"); | ||
902 | test_icmp_client (ah); | ||
903 | break; | ||
904 | case AUTO_DONE: | ||
905 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
906 | "Done with tests\n"); | ||
907 | if (!ah->internal_ip_is_public) | ||
908 | { | 858 | { |
909 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 859 | case AUTO_INIT: |
910 | "nat", | 860 | GNUNET_assert(0); |
911 | "BEHIND_NAT", | 861 | break; |
912 | "YES"); | 862 | |
913 | 863 | case AUTO_EXTERNAL_IP: | |
914 | if (ah->connected_back) | 864 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
915 | { | 865 | "Will run AUTO_EXTERNAL_IP\n"); |
916 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 866 | test_external_ip(ah); |
917 | "nat", | 867 | break; |
918 | "PUNCHED_NAT", | 868 | |
919 | "YES"); | 869 | case AUTO_STUN: |
920 | } | 870 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
921 | else | 871 | "Will run AUTO_STUN\n"); |
922 | { | 872 | test_stun(ah); |
923 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 873 | break; |
924 | "nat", | 874 | |
925 | "PUNCHED_NAT", | 875 | case AUTO_LOCAL_IP: |
926 | "NO"); | 876 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
927 | } | 877 | "Will run AUTO_LOCAL_IP\n"); |
928 | 878 | test_local_ip(ah); | |
929 | if (ah->stun_ip) | 879 | break; |
930 | { | 880 | |
931 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 881 | case AUTO_NAT_PUNCHED: |
932 | "nat", | 882 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
933 | "EXTERNAL_ADDRESS", | 883 | "Will run AUTO_NAT_PUNCHED\n"); |
934 | ah->stun_ip); | 884 | test_nat_punched(ah); |
935 | if (ah->connected_back) | 885 | break; |
886 | |||
887 | case AUTO_UPNPC: | ||
888 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
889 | "Will run AUTO_UPNPC\n"); | ||
890 | test_upnpc(ah); | ||
891 | break; | ||
892 | |||
893 | case AUTO_ICMP_SERVER: | ||
894 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
895 | "Will run AUTO_ICMP_SERVER\n"); | ||
896 | test_icmp_server(ah); | ||
897 | break; | ||
898 | |||
899 | case AUTO_ICMP_CLIENT: | ||
900 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
901 | "Will run AUTO_ICMP_CLIENT\n"); | ||
902 | test_icmp_client(ah); | ||
903 | break; | ||
904 | |||
905 | case AUTO_DONE: | ||
906 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
907 | "Done with tests\n"); | ||
908 | if (!ah->internal_ip_is_public) | ||
936 | { | 909 | { |
937 | ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT; | 910 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, |
938 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 911 | "nat", |
939 | "nat", | 912 | "BEHIND_NAT", |
940 | "USE_STUN", | 913 | "YES"); |
941 | "YES"); | 914 | |
915 | if (ah->connected_back) | ||
916 | { | ||
917 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
918 | "nat", | ||
919 | "PUNCHED_NAT", | ||
920 | "YES"); | ||
921 | } | ||
922 | else | ||
923 | { | ||
924 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
925 | "nat", | ||
926 | "PUNCHED_NAT", | ||
927 | "NO"); | ||
928 | } | ||
929 | |||
930 | if (ah->stun_ip) | ||
931 | { | ||
932 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
933 | "nat", | ||
934 | "EXTERNAL_ADDRESS", | ||
935 | ah->stun_ip); | ||
936 | if (ah->connected_back) | ||
937 | { | ||
938 | ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT; | ||
939 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
940 | "nat", | ||
941 | "USE_STUN", | ||
942 | "YES"); | ||
943 | } | ||
944 | else | ||
945 | { | ||
946 | ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT; | ||
947 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
948 | "nat", | ||
949 | "USE_STUN", | ||
950 | "NO"); | ||
951 | } | ||
952 | } | ||
953 | if (0 != ah->stun_port) | ||
954 | { | ||
955 | GNUNET_CONFIGURATION_set_value_number(ah->cfg, | ||
956 | "transport-udp", | ||
957 | "ADVERTISED_PORT", | ||
958 | ah->stun_port); | ||
959 | } | ||
942 | } | 960 | } |
943 | else | ||
944 | { | ||
945 | ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT; | ||
946 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | ||
947 | "nat", | ||
948 | "USE_STUN", | ||
949 | "NO"); | ||
950 | } | ||
951 | |||
952 | } | ||
953 | if (0 != ah->stun_port) | ||
954 | { | ||
955 | GNUNET_CONFIGURATION_set_value_number (ah->cfg, | ||
956 | "transport-udp", | ||
957 | "ADVERTISED_PORT", | ||
958 | ah->stun_port); | ||
959 | } | ||
960 | |||
961 | } | ||
962 | else | ||
963 | { | ||
964 | //The internal IP is the same as public, but we didn't got a incoming connection | ||
965 | if (ah->connected_back) | ||
966 | { | ||
967 | ah->type = GNUNET_NAT_TYPE_NO_NAT; | ||
968 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | ||
969 | "nat", | ||
970 | "BEHIND_NAT", | ||
971 | "NO"); | ||
972 | } | ||
973 | else | 961 | else |
974 | { | ||
975 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | ||
976 | "nat", | ||
977 | "BEHIND_NAT", | ||
978 | "YES"); | ||
979 | ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT; | ||
980 | if (ah->stun_ip) | ||
981 | { | 962 | { |
982 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 963 | //The internal IP is the same as public, but we didn't got a incoming connection |
983 | "nat", | 964 | if (ah->connected_back) |
984 | "EXTERNAL_ADDRESS", | 965 | { |
985 | ah->stun_ip); | 966 | ah->type = GNUNET_NAT_TYPE_NO_NAT; |
967 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
968 | "nat", | ||
969 | "BEHIND_NAT", | ||
970 | "NO"); | ||
971 | } | ||
972 | else | ||
973 | { | ||
974 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
975 | "nat", | ||
976 | "BEHIND_NAT", | ||
977 | "YES"); | ||
978 | ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT; | ||
979 | if (ah->stun_ip) | ||
980 | { | ||
981 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, | ||
982 | "nat", | ||
983 | "EXTERNAL_ADDRESS", | ||
984 | ah->stun_ip); | ||
985 | } | ||
986 | if (0 != ah->stun_port) | ||
987 | { | ||
988 | GNUNET_CONFIGURATION_set_value_number(ah->cfg, | ||
989 | "transport-udp", | ||
990 | "ADVERTISED_PORT", | ||
991 | ah->stun_port); | ||
992 | } | ||
993 | } | ||
986 | } | 994 | } |
987 | if (0 != ah->stun_port) | ||
988 | { | ||
989 | GNUNET_CONFIGURATION_set_value_number (ah->cfg, | ||
990 | "transport-udp", | ||
991 | "ADVERTISED_PORT", | ||
992 | ah->stun_port); | ||
993 | 995 | ||
994 | } | 996 | diff = GNUNET_CONFIGURATION_get_diff(ah->initial_cfg, |
995 | } | 997 | ah->cfg); |
996 | } | ||
997 | |||
998 | diff = GNUNET_CONFIGURATION_get_diff (ah->initial_cfg, | ||
999 | ah->cfg); | ||
1000 | 998 | ||
1001 | 999 | ||
1002 | ah->fin_cb (ah->fin_cb_cls, | 1000 | ah->fin_cb(ah->fin_cb_cls, |
1003 | diff, | 1001 | diff, |
1004 | ah->ret, | 1002 | ah->ret, |
1005 | ah->type); | 1003 | ah->type); |
1006 | GNUNET_CONFIGURATION_destroy (diff); | 1004 | GNUNET_CONFIGURATION_destroy(diff); |
1007 | GNUNET_NAT_autoconfig_cancel (ah); | 1005 | GNUNET_NAT_autoconfig_cancel(ah); |
1008 | } | 1006 | } |
1009 | } | 1007 | } |
1010 | 1008 | ||
1011 | 1009 | ||
@@ -1019,26 +1017,26 @@ next_phase (struct GNUNET_NAT_AutoHandle *ah) | |||
1019 | * @return handle to cancel operation | 1017 | * @return handle to cancel operation |
1020 | */ | 1018 | */ |
1021 | struct GNUNET_NAT_AutoHandle * | 1019 | struct GNUNET_NAT_AutoHandle * |
1022 | GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | 1020 | GNUNET_NAT_autoconfig_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
1023 | GNUNET_NAT_AutoResultCallback cb, | 1021 | GNUNET_NAT_AutoResultCallback cb, |
1024 | void *cb_cls) | 1022 | void *cb_cls) |
1025 | { | 1023 | { |
1026 | struct GNUNET_NAT_AutoHandle *ah; | 1024 | struct GNUNET_NAT_AutoHandle *ah; |
1027 | 1025 | ||
1028 | ah = GNUNET_new (struct GNUNET_NAT_AutoHandle); | 1026 | ah = GNUNET_new(struct GNUNET_NAT_AutoHandle); |
1029 | ah->fin_cb = cb; | 1027 | ah->fin_cb = cb; |
1030 | ah->fin_cb_cls = cb_cls; | 1028 | ah->fin_cb_cls = cb_cls; |
1031 | ah->ret = GNUNET_NAT_ERROR_SUCCESS; | 1029 | ah->ret = GNUNET_NAT_ERROR_SUCCESS; |
1032 | ah->cfg = GNUNET_CONFIGURATION_dup (cfg); | 1030 | ah->cfg = GNUNET_CONFIGURATION_dup(cfg); |
1033 | ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg); | 1031 | ah->initial_cfg = GNUNET_CONFIGURATION_dup(cfg); |
1034 | 1032 | ||
1035 | /* never use loopback addresses if user wanted autoconfiguration */ | 1033 | /* never use loopback addresses if user wanted autoconfiguration */ |
1036 | GNUNET_CONFIGURATION_set_value_string (ah->cfg, | 1034 | GNUNET_CONFIGURATION_set_value_string(ah->cfg, |
1037 | "nat", | 1035 | "nat", |
1038 | "USE_LOCALADDR", | 1036 | "USE_LOCALADDR", |
1039 | "NO"); | 1037 | "NO"); |
1040 | 1038 | ||
1041 | next_phase (ah); | 1039 | next_phase(ah); |
1042 | return ah; | 1040 | return ah; |
1043 | } | 1041 | } |
1044 | 1042 | ||
@@ -1049,31 +1047,31 @@ GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
1049 | * @param ah handle for operation to abort | 1047 | * @param ah handle for operation to abort |
1050 | */ | 1048 | */ |
1051 | void | 1049 | void |
1052 | GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah) | 1050 | GNUNET_NAT_autoconfig_cancel(struct GNUNET_NAT_AutoHandle *ah) |
1053 | { | 1051 | { |
1054 | if (NULL != ah->tst) | 1052 | if (NULL != ah->tst) |
1055 | { | 1053 | { |
1056 | GNUNET_NAT_test_stop (ah->tst); | 1054 | GNUNET_NAT_test_stop(ah->tst); |
1057 | ah->tst = NULL; | 1055 | ah->tst = NULL; |
1058 | } | 1056 | } |
1059 | if (NULL != ah->eh) | 1057 | if (NULL != ah->eh) |
1060 | { | 1058 | { |
1061 | GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh); | 1059 | GNUNET_NAT_mini_get_external_ipv4_cancel(ah->eh); |
1062 | ah->eh = NULL; | 1060 | ah->eh = NULL; |
1063 | } | 1061 | } |
1064 | if (NULL != ah->mq) | 1062 | if (NULL != ah->mq) |
1065 | { | 1063 | { |
1066 | GNUNET_MQ_destroy (ah->mq); | 1064 | GNUNET_MQ_destroy(ah->mq); |
1067 | ah->mq = NULL; | 1065 | ah->mq = NULL; |
1068 | } | 1066 | } |
1069 | if (NULL != ah->task) | 1067 | if (NULL != ah->task) |
1070 | { | 1068 | { |
1071 | GNUNET_SCHEDULER_cancel (ah->task); | 1069 | GNUNET_SCHEDULER_cancel(ah->task); |
1072 | ah->task = NULL; | 1070 | ah->task = NULL; |
1073 | } | 1071 | } |
1074 | GNUNET_CONFIGURATION_destroy (ah->cfg); | 1072 | GNUNET_CONFIGURATION_destroy(ah->cfg); |
1075 | GNUNET_CONFIGURATION_destroy (ah->initial_cfg); | 1073 | GNUNET_CONFIGURATION_destroy(ah->initial_cfg); |
1076 | GNUNET_free (ah); | 1074 | GNUNET_free(ah); |
1077 | } | 1075 | } |
1078 | 1076 | ||
1079 | 1077 | ||
diff --git a/src/nat-auto/nat-auto.h b/src/nat-auto/nat-auto.h index 76d877dd3..6ef9b7e1e 100644 --- a/src/nat-auto/nat-auto.h +++ b/src/nat-auto/nat-auto.h | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/nat-auto/nat-auto.h | 22 | * @file src/nat-auto/nat-auto.h |
@@ -36,8 +36,7 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
36 | * Request to test NAT traversal, sent to the gnunet-nat-server | 36 | * Request to test NAT traversal, sent to the gnunet-nat-server |
37 | * (not the service!). | 37 | * (not the service!). |
38 | */ | 38 | */ |
39 | struct GNUNET_NAT_AUTO_TestMessage | 39 | struct GNUNET_NAT_AUTO_TestMessage { |
40 | { | ||
41 | /** | 40 | /** |
42 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_TEST | 41 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_TEST |
43 | */ | 42 | */ |
@@ -62,35 +61,31 @@ struct GNUNET_NAT_AUTO_TestMessage | |||
62 | * #GNUNET_YES for TCP, #GNUNET_NO for UDP. | 61 | * #GNUNET_YES for TCP, #GNUNET_NO for UDP. |
63 | */ | 62 | */ |
64 | int32_t is_tcp; | 63 | int32_t is_tcp; |
65 | |||
66 | }; | 64 | }; |
67 | 65 | ||
68 | 66 | ||
69 | /** | 67 | /** |
70 | * Client requesting automatic configuration. | 68 | * Client requesting automatic configuration. |
71 | */ | 69 | */ |
72 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage | 70 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage { |
73 | { | ||
74 | /** | 71 | /** |
75 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REQUEST_AUTO_CFG | 72 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REQUEST_AUTO_CFG |
76 | */ | 73 | */ |
77 | struct GNUNET_MessageHeader header; | 74 | struct GNUNET_MessageHeader header; |
78 | 75 | ||
79 | /* Followed by configuration (diff, serialized, compressed) */ | 76 | /* Followed by configuration (diff, serialized, compressed) */ |
80 | |||
81 | }; | 77 | }; |
82 | 78 | ||
83 | 79 | ||
84 | /** | 80 | /** |
85 | * Service responding with proposed configuration. | 81 | * Service responding with proposed configuration. |
86 | */ | 82 | */ |
87 | struct GNUNET_NAT_AUTO_AutoconfigResultMessage | 83 | struct GNUNET_NAT_AUTO_AutoconfigResultMessage { |
88 | { | ||
89 | /** | 84 | /** |
90 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT | 85 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT |
91 | */ | 86 | */ |
92 | struct GNUNET_MessageHeader header; | 87 | struct GNUNET_MessageHeader header; |
93 | 88 | ||
94 | /** | 89 | /** |
95 | * An `enum GNUNET_NAT_StatusCode` in NBO. | 90 | * An `enum GNUNET_NAT_StatusCode` in NBO. |
96 | */ | 91 | */ |
diff --git a/src/nat-auto/nat_auto_api.c b/src/nat-auto/nat_auto_api.c index d7c081e49..ae7bb6514 100644 --- a/src/nat-auto/nat_auto_api.c +++ b/src/nat-auto/nat_auto_api.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @author Christian Grothoff | 22 | * @author Christian Grothoff |
@@ -35,9 +35,7 @@ | |||
35 | /** | 35 | /** |
36 | * Handle to auto-configuration in progress. | 36 | * Handle to auto-configuration in progress. |
37 | */ | 37 | */ |
38 | struct GNUNET_NAT_AUTO_AutoHandle | 38 | struct GNUNET_NAT_AUTO_AutoHandle { |
39 | { | ||
40 | |||
41 | /** | 39 | /** |
42 | * Configuration we use. | 40 | * Configuration we use. |
43 | */ | 41 | */ |
@@ -57,7 +55,6 @@ struct GNUNET_NAT_AUTO_AutoHandle | |||
57 | * Closure for @e arc. | 55 | * Closure for @e arc. |
58 | */ | 56 | */ |
59 | void *arc_cls; | 57 | void *arc_cls; |
60 | |||
61 | }; | 58 | }; |
62 | 59 | ||
63 | 60 | ||
@@ -68,51 +65,70 @@ struct GNUNET_NAT_AUTO_AutoHandle | |||
68 | * @return point to a static string containing the error code | 65 | * @return point to a static string containing the error code |
69 | */ | 66 | */ |
70 | const char * | 67 | const char * |
71 | GNUNET_NAT_AUTO_status2string (enum GNUNET_NAT_StatusCode err) | 68 | GNUNET_NAT_AUTO_status2string(enum GNUNET_NAT_StatusCode err) |
72 | { | 69 | { |
73 | switch (err) | 70 | switch (err) |
74 | { | 71 | { |
75 | case GNUNET_NAT_ERROR_SUCCESS: | 72 | case GNUNET_NAT_ERROR_SUCCESS: |
76 | return _ ("Operation Successful"); | 73 | return _("Operation Successful"); |
77 | case GNUNET_NAT_ERROR_IPC_FAILURE: | 74 | |
78 | return _ ("IPC failure"); | 75 | case GNUNET_NAT_ERROR_IPC_FAILURE: |
79 | case GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR: | 76 | return _("IPC failure"); |
80 | return _ ("Failure in network subsystem, check permissions."); | 77 | |
81 | case GNUNET_NAT_ERROR_TIMEOUT: | 78 | case GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR: |
82 | return _ ("Encountered timeout while performing operation"); | 79 | return _("Failure in network subsystem, check permissions."); |
83 | case GNUNET_NAT_ERROR_NOT_ONLINE: | 80 | |
84 | return _ ("detected that we are offline"); | 81 | case GNUNET_NAT_ERROR_TIMEOUT: |
85 | case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND: | 82 | return _("Encountered timeout while performing operation"); |
86 | return _ ("`upnpc` command not found"); | 83 | |
87 | case GNUNET_NAT_ERROR_UPNPC_FAILED: | 84 | case GNUNET_NAT_ERROR_NOT_ONLINE: |
88 | return _ ("Failed to run `upnpc` command"); | 85 | return _("detected that we are offline"); |
89 | case GNUNET_NAT_ERROR_UPNPC_TIMEOUT: | 86 | |
90 | return _ ("`upnpc' command took too long, process killed"); | 87 | case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND: |
91 | case GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED: | 88 | return _("`upnpc` command not found"); |
92 | return _ ("`upnpc' command failed to establish port mapping"); | 89 | |
93 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND: | 90 | case GNUNET_NAT_ERROR_UPNPC_FAILED: |
94 | return _ ("`external-ip' command not found"); | 91 | return _("Failed to run `upnpc` command"); |
95 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED: | 92 | |
96 | return _ ("Failed to run `external-ip` command"); | 93 | case GNUNET_NAT_ERROR_UPNPC_TIMEOUT: |
97 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID: | 94 | return _("`upnpc' command took too long, process killed"); |
98 | return _ ("`external-ip' command output invalid"); | 95 | |
99 | case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID: | 96 | case GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED: |
100 | return _ ("no valid address was returned by `external-ip'"); | 97 | return _("`upnpc' command failed to establish port mapping"); |
101 | case GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO: | 98 | |
102 | return _ ("Could not determine interface with internal/local network address"); | 99 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND: |
103 | case GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND: | 100 | return _("`external-ip' command not found"); |
104 | return _ ("No functioning gnunet-helper-nat-server installation found"); | 101 | |
105 | case GNUNET_NAT_ERROR_NAT_TEST_START_FAILED: | 102 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED: |
106 | return _ ("NAT test could not be initialized"); | 103 | return _("Failed to run `external-ip` command"); |
107 | case GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT: | 104 | |
108 | return _ ("NAT test timeout reached"); | 105 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID: |
109 | case GNUNET_NAT_ERROR_NAT_REGISTER_FAILED: | 106 | return _("`external-ip' command output invalid"); |
110 | return _ ("could not register NAT"); | 107 | |
111 | case GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND: | 108 | case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID: |
112 | return _ ("No working gnunet-helper-nat-client installation found"); | 109 | return _("no valid address was returned by `external-ip'"); |
113 | default: | 110 | |
114 | return "unknown status code"; | 111 | case GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO: |
115 | } | 112 | return _("Could not determine interface with internal/local network address"); |
113 | |||
114 | case GNUNET_NAT_ERROR_HELPER_NAT_SERVER_NOT_FOUND: | ||
115 | return _("No functioning gnunet-helper-nat-server installation found"); | ||
116 | |||
117 | case GNUNET_NAT_ERROR_NAT_TEST_START_FAILED: | ||
118 | return _("NAT test could not be initialized"); | ||
119 | |||
120 | case GNUNET_NAT_ERROR_NAT_TEST_TIMEOUT: | ||
121 | return _("NAT test timeout reached"); | ||
122 | |||
123 | case GNUNET_NAT_ERROR_NAT_REGISTER_FAILED: | ||
124 | return _("could not register NAT"); | ||
125 | |||
126 | case GNUNET_NAT_ERROR_HELPER_NAT_CLIENT_NOT_FOUND: | ||
127 | return _("No working gnunet-helper-nat-client installation found"); | ||
128 | |||
129 | default: | ||
130 | return "unknown status code"; | ||
131 | } | ||
116 | } | 132 | } |
117 | 133 | ||
118 | 134 | ||
@@ -124,8 +140,8 @@ GNUNET_NAT_AUTO_status2string (enum GNUNET_NAT_StatusCode err) | |||
124 | * @return #GNUNET_OK if @a res is well-formed (always for now) | 140 | * @return #GNUNET_OK if @a res is well-formed (always for now) |
125 | */ | 141 | */ |
126 | static int | 142 | static int |
127 | check_auto_result (void *cls, | 143 | check_auto_result(void *cls, |
128 | const struct GNUNET_NAT_AUTO_AutoconfigResultMessage *res) | 144 | const struct GNUNET_NAT_AUTO_AutoconfigResultMessage *res) |
129 | { | 145 | { |
130 | return GNUNET_OK; | 146 | return GNUNET_OK; |
131 | } | 147 | } |
@@ -138,40 +154,40 @@ check_auto_result (void *cls, | |||
138 | * @param res the result | 154 | * @param res the result |
139 | */ | 155 | */ |
140 | static void | 156 | static void |
141 | handle_auto_result (void *cls, | 157 | handle_auto_result(void *cls, |
142 | const struct GNUNET_NAT_AUTO_AutoconfigResultMessage *res) | 158 | const struct GNUNET_NAT_AUTO_AutoconfigResultMessage *res) |
143 | { | 159 | { |
144 | struct GNUNET_NAT_AUTO_AutoHandle *ah = cls; | 160 | struct GNUNET_NAT_AUTO_AutoHandle *ah = cls; |
145 | size_t left; | 161 | size_t left; |
146 | struct GNUNET_CONFIGURATION_Handle *cfg; | 162 | struct GNUNET_CONFIGURATION_Handle *cfg; |
147 | enum GNUNET_NAT_Type type | 163 | enum GNUNET_NAT_Type type |
148 | = (enum GNUNET_NAT_Type) ntohl (res->type); | 164 | = (enum GNUNET_NAT_Type)ntohl(res->type); |
149 | enum GNUNET_NAT_StatusCode status | 165 | enum GNUNET_NAT_StatusCode status |
150 | = (enum GNUNET_NAT_StatusCode) ntohl (res->status_code); | 166 | = (enum GNUNET_NAT_StatusCode)ntohl(res->status_code); |
151 | 167 | ||
152 | left = ntohs (res->header.size) - sizeof (*res); | 168 | left = ntohs(res->header.size) - sizeof(*res); |
153 | cfg = GNUNET_CONFIGURATION_create (); | 169 | cfg = GNUNET_CONFIGURATION_create(); |
154 | if (GNUNET_OK != | 170 | if (GNUNET_OK != |
155 | GNUNET_CONFIGURATION_deserialize (cfg, | 171 | GNUNET_CONFIGURATION_deserialize(cfg, |
156 | (const char *) &res[1], | 172 | (const char *)&res[1], |
157 | left, | 173 | left, |
158 | NULL)) | 174 | NULL)) |
159 | { | 175 | { |
160 | GNUNET_break (0); | 176 | GNUNET_break(0); |
161 | ah->arc (ah->arc_cls, | 177 | ah->arc(ah->arc_cls, |
162 | NULL, | 178 | NULL, |
163 | GNUNET_NAT_ERROR_IPC_FAILURE, | 179 | GNUNET_NAT_ERROR_IPC_FAILURE, |
164 | type); | 180 | type); |
165 | } | 181 | } |
166 | else | 182 | else |
167 | { | 183 | { |
168 | ah->arc (ah->arc_cls, | 184 | ah->arc(ah->arc_cls, |
169 | cfg, | 185 | cfg, |
170 | status, | 186 | status, |
171 | type); | 187 | type); |
172 | } | 188 | } |
173 | GNUNET_CONFIGURATION_destroy (cfg); | 189 | GNUNET_CONFIGURATION_destroy(cfg); |
174 | GNUNET_NAT_AUTO_autoconfig_cancel (ah); | 190 | GNUNET_NAT_AUTO_autoconfig_cancel(ah); |
175 | } | 191 | } |
176 | 192 | ||
177 | 193 | ||
@@ -182,16 +198,16 @@ handle_auto_result (void *cls, | |||
182 | * @param error details about the error | 198 | * @param error details about the error |
183 | */ | 199 | */ |
184 | static void | 200 | static void |
185 | ah_error_handler (void *cls, | 201 | ah_error_handler(void *cls, |
186 | enum GNUNET_MQ_Error error) | 202 | enum GNUNET_MQ_Error error) |
187 | { | 203 | { |
188 | struct GNUNET_NAT_AUTO_AutoHandle *ah = cls; | 204 | struct GNUNET_NAT_AUTO_AutoHandle *ah = cls; |
189 | 205 | ||
190 | ah->arc (ah->arc_cls, | 206 | ah->arc(ah->arc_cls, |
191 | NULL, | 207 | NULL, |
192 | GNUNET_NAT_ERROR_IPC_FAILURE, | 208 | GNUNET_NAT_ERROR_IPC_FAILURE, |
193 | GNUNET_NAT_TYPE_UNKNOWN); | 209 | GNUNET_NAT_TYPE_UNKNOWN); |
194 | GNUNET_NAT_AUTO_autoconfig_cancel (ah); | 210 | GNUNET_NAT_AUTO_autoconfig_cancel(ah); |
195 | } | 211 | } |
196 | 212 | ||
197 | 213 | ||
@@ -205,55 +221,55 @@ ah_error_handler (void *cls, | |||
205 | * @return handle to cancel operation | 221 | * @return handle to cancel operation |
206 | */ | 222 | */ |
207 | struct GNUNET_NAT_AUTO_AutoHandle * | 223 | struct GNUNET_NAT_AUTO_AutoHandle * |
208 | GNUNET_NAT_AUTO_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | 224 | GNUNET_NAT_AUTO_autoconfig_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
209 | GNUNET_NAT_AUTO_AutoResultCallback cb, | 225 | GNUNET_NAT_AUTO_AutoResultCallback cb, |
210 | void *cb_cls) | 226 | void *cb_cls) |
211 | { | 227 | { |
212 | struct GNUNET_NAT_AUTO_AutoHandle *ah = GNUNET_new (struct GNUNET_NAT_AUTO_AutoHandle); | 228 | struct GNUNET_NAT_AUTO_AutoHandle *ah = GNUNET_new(struct GNUNET_NAT_AUTO_AutoHandle); |
213 | struct GNUNET_MQ_MessageHandler handlers[] = { | 229 | struct GNUNET_MQ_MessageHandler handlers[] = { |
214 | GNUNET_MQ_hd_var_size (auto_result, | 230 | GNUNET_MQ_hd_var_size(auto_result, |
215 | GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT, | 231 | GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT, |
216 | struct GNUNET_NAT_AUTO_AutoconfigResultMessage, | 232 | struct GNUNET_NAT_AUTO_AutoconfigResultMessage, |
217 | ah), | 233 | ah), |
218 | GNUNET_MQ_handler_end () | 234 | GNUNET_MQ_handler_end() |
219 | }; | 235 | }; |
220 | struct GNUNET_MQ_Envelope *env; | 236 | struct GNUNET_MQ_Envelope *env; |
221 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *req; | 237 | struct GNUNET_NAT_AUTO_AutoconfigRequestMessage *req; |
222 | char *buf; | 238 | char *buf; |
223 | size_t size; | 239 | size_t size; |
224 | 240 | ||
225 | buf = GNUNET_CONFIGURATION_serialize (cfg, | 241 | buf = GNUNET_CONFIGURATION_serialize(cfg, |
226 | &size); | 242 | &size); |
227 | if (size > GNUNET_MAX_MESSAGE_SIZE - sizeof (*req)) | 243 | if (size > GNUNET_MAX_MESSAGE_SIZE - sizeof(*req)) |
228 | { | 244 | { |
229 | GNUNET_break (0); | 245 | GNUNET_break(0); |
230 | GNUNET_free (buf); | 246 | GNUNET_free(buf); |
231 | GNUNET_free (ah); | 247 | GNUNET_free(ah); |
232 | return NULL; | 248 | return NULL; |
233 | } | 249 | } |
234 | ah->arc = cb; | 250 | ah->arc = cb; |
235 | ah->arc_cls = cb_cls; | 251 | ah->arc_cls = cb_cls; |
236 | ah->mq = GNUNET_CLIENT_connect (cfg, | 252 | ah->mq = GNUNET_CLIENT_connect(cfg, |
237 | "nat", | 253 | "nat", |
238 | handlers, | 254 | handlers, |
239 | &ah_error_handler, | 255 | &ah_error_handler, |
240 | ah); | 256 | ah); |
241 | if (NULL == ah->mq) | 257 | if (NULL == ah->mq) |
242 | { | 258 | { |
243 | GNUNET_break (0); | 259 | GNUNET_break(0); |
244 | GNUNET_free (buf); | 260 | GNUNET_free(buf); |
245 | GNUNET_free (ah); | 261 | GNUNET_free(ah); |
246 | return NULL; | 262 | return NULL; |
247 | } | 263 | } |
248 | env = GNUNET_MQ_msg_extra (req, | 264 | env = GNUNET_MQ_msg_extra(req, |
249 | size, | 265 | size, |
250 | GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG); | 266 | GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG); |
251 | GNUNET_memcpy (&req[1], | 267 | GNUNET_memcpy(&req[1], |
252 | buf, | 268 | buf, |
253 | size); | 269 | size); |
254 | GNUNET_free (buf); | 270 | GNUNET_free(buf); |
255 | GNUNET_MQ_send (ah->mq, | 271 | GNUNET_MQ_send(ah->mq, |
256 | env); | 272 | env); |
257 | return ah; | 273 | return ah; |
258 | } | 274 | } |
259 | 275 | ||
@@ -264,10 +280,10 @@ GNUNET_NAT_AUTO_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
264 | * @param ah handle for operation to abort | 280 | * @param ah handle for operation to abort |
265 | */ | 281 | */ |
266 | void | 282 | void |
267 | GNUNET_NAT_AUTO_autoconfig_cancel (struct GNUNET_NAT_AUTO_AutoHandle *ah) | 283 | GNUNET_NAT_AUTO_autoconfig_cancel(struct GNUNET_NAT_AUTO_AutoHandle *ah) |
268 | { | 284 | { |
269 | GNUNET_MQ_destroy (ah->mq); | 285 | GNUNET_MQ_destroy(ah->mq); |
270 | GNUNET_free (ah); | 286 | GNUNET_free(ah); |
271 | } | 287 | } |
272 | 288 | ||
273 | /* end of nat_api_auto.c */ | 289 | /* end of nat_api_auto.c */ |
diff --git a/src/nat-auto/nat_auto_api_test.c b/src/nat-auto/nat_auto_api_test.c index 56a2b8d72..daea3063c 100644 --- a/src/nat-auto/nat_auto_api_test.c +++ b/src/nat-auto/nat_auto_api_test.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file nat/nat_auto_api_test.c | 21 | * @file nat/nat_auto_api_test.c |
22 | * @brief functions to test if the NAT configuration is successful at achieving NAT traversal (with the help of a gnunet-nat-server) | 22 | * @brief functions to test if the NAT configuration is successful at achieving NAT traversal (with the help of a gnunet-nat-server) |
@@ -28,16 +28,15 @@ | |||
28 | #include "gnunet_nat_auto_service.h" | 28 | #include "gnunet_nat_auto_service.h" |
29 | #include "nat-auto.h" | 29 | #include "nat-auto.h" |
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from (kind, "nat-auto", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat-auto", __VA_ARGS__) |
32 | 32 | ||
33 | #define NAT_SERVER_TIMEOUT \ | 33 | #define NAT_SERVER_TIMEOUT \ |
34 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 34 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30) |
35 | 35 | ||
36 | /** | 36 | /** |
37 | * Entry we keep for each incoming connection. | 37 | * Entry we keep for each incoming connection. |
38 | */ | 38 | */ |
39 | struct NatActivity | 39 | struct NatActivity { |
40 | { | ||
41 | /** | 40 | /** |
42 | * This is a doubly-linked list. | 41 | * This is a doubly-linked list. |
43 | */ | 42 | */ |
@@ -68,8 +67,7 @@ struct NatActivity | |||
68 | /** | 67 | /** |
69 | * Entry we keep for each connection to the gnunet-nat-service. | 68 | * Entry we keep for each connection to the gnunet-nat-service. |
70 | */ | 69 | */ |
71 | struct ClientActivity | 70 | struct ClientActivity { |
72 | { | ||
73 | /** | 71 | /** |
74 | * This is a doubly-linked list. | 72 | * This is a doubly-linked list. |
75 | */ | 73 | */ |
@@ -95,9 +93,7 @@ struct ClientActivity | |||
95 | /** | 93 | /** |
96 | * Handle to a NAT test. | 94 | * Handle to a NAT test. |
97 | */ | 95 | */ |
98 | struct GNUNET_NAT_AUTO_Test | 96 | struct GNUNET_NAT_AUTO_Test { |
99 | { | ||
100 | |||
101 | /** | 97 | /** |
102 | * Configuration used | 98 | * Configuration used |
103 | */ | 99 | */ |
@@ -184,22 +180,22 @@ struct GNUNET_NAT_AUTO_Test | |||
184 | * @param addrlen actual lenght of the @a addr | 180 | * @param addrlen actual lenght of the @a addr |
185 | */ | 181 | */ |
186 | static void | 182 | static void |
187 | reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) | 183 | reversal_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen) |
188 | { | 184 | { |
189 | struct GNUNET_NAT_AUTO_Test *h = cls; | 185 | struct GNUNET_NAT_AUTO_Test *h = cls; |
190 | const struct sockaddr_in *sa; | 186 | const struct sockaddr_in *sa; |
191 | 187 | ||
192 | if (sizeof (struct sockaddr_in) != addrlen) | 188 | if (sizeof(struct sockaddr_in) != addrlen) |
193 | return; | 189 | return; |
194 | sa = (const struct sockaddr_in *) addr; | 190 | sa = (const struct sockaddr_in *)addr; |
195 | if (h->data != sa->sin_port) | 191 | if (h->data != sa->sin_port) |
196 | { | 192 | { |
197 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 193 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
198 | "Received connection reversal request for wrong port\n"); | 194 | "Received connection reversal request for wrong port\n"); |
199 | return; /* wrong port */ | 195 | return; /* wrong port */ |
200 | } | 196 | } |
201 | /* report success */ | 197 | /* report success */ |
202 | h->report (h->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 198 | h->report(h->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
203 | } | 199 | } |
204 | 200 | ||
205 | 201 | ||
@@ -210,31 +206,31 @@ reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) | |||
210 | * @param cls the `struct GNUNET_NAT_AUTO_Test` | 206 | * @param cls the `struct GNUNET_NAT_AUTO_Test` |
211 | */ | 207 | */ |
212 | static void | 208 | static void |
213 | do_udp_read (void *cls) | 209 | do_udp_read(void *cls) |
214 | { | 210 | { |
215 | struct GNUNET_NAT_AUTO_Test *tst = cls; | 211 | struct GNUNET_NAT_AUTO_Test *tst = cls; |
216 | uint16_t data; | 212 | uint16_t data; |
217 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 213 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
218 | 214 | ||
219 | tc = GNUNET_SCHEDULER_get_task_context (); | 215 | tc = GNUNET_SCHEDULER_get_task_context(); |
220 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 216 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
221 | tst->lsock, | 217 | tst->lsock, |
222 | &do_udp_read, | 218 | &do_udp_read, |
223 | tst); | 219 | tst); |
224 | if ((NULL != tc->write_ready) && | 220 | if ((NULL != tc->write_ready) && |
225 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, tst->lsock)) && | 221 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, tst->lsock)) && |
226 | (sizeof (data) == | 222 | (sizeof(data) == |
227 | GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof (data)))) | 223 | GNUNET_NETWORK_socket_recv(tst->lsock, &data, sizeof(data)))) |
228 | { | 224 | { |
229 | if (data == tst->data) | 225 | if (data == tst->data) |
230 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 226 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
231 | else | 227 | else |
232 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 228 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
233 | "Received data mismatches expected value\n"); | 229 | "Received data mismatches expected value\n"); |
234 | } | 230 | } |
235 | else | 231 | else |
236 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 232 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
237 | "Failed to receive data from inbound connection\n"); | 233 | "Failed to receive data from inbound connection\n"); |
238 | } | 234 | } |
239 | 235 | ||
240 | 236 | ||
@@ -245,33 +241,33 @@ do_udp_read (void *cls) | |||
245 | * @param cls the `struct NatActivity` | 241 | * @param cls the `struct NatActivity` |
246 | */ | 242 | */ |
247 | static void | 243 | static void |
248 | do_read (void *cls) | 244 | do_read(void *cls) |
249 | { | 245 | { |
250 | struct NatActivity *na = cls; | 246 | struct NatActivity *na = cls; |
251 | struct GNUNET_NAT_AUTO_Test *tst; | 247 | struct GNUNET_NAT_AUTO_Test *tst; |
252 | uint16_t data; | 248 | uint16_t data; |
253 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 249 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
254 | 250 | ||
255 | tc = GNUNET_SCHEDULER_get_task_context (); | 251 | tc = GNUNET_SCHEDULER_get_task_context(); |
256 | na->rtask = NULL; | 252 | na->rtask = NULL; |
257 | tst = na->h; | 253 | tst = na->h; |
258 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na); | 254 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, na); |
259 | if ((NULL != tc->write_ready) && | 255 | if ((NULL != tc->write_ready) && |
260 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, na->sock)) && | 256 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, na->sock)) && |
261 | (sizeof (data) == | 257 | (sizeof(data) == |
262 | GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof (data)))) | 258 | GNUNET_NETWORK_socket_recv(na->sock, &data, sizeof(data)))) |
263 | { | 259 | { |
264 | if (data == tst->data) | 260 | if (data == tst->data) |
265 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 261 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
266 | else | 262 | else |
267 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 263 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
268 | "Received data does not match expected value\n"); | 264 | "Received data does not match expected value\n"); |
269 | } | 265 | } |
270 | else | 266 | else |
271 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 267 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
272 | "Failed to receive data from inbound connection\n"); | 268 | "Failed to receive data from inbound connection\n"); |
273 | GNUNET_NETWORK_socket_close (na->sock); | 269 | GNUNET_NETWORK_socket_close(na->sock); |
274 | GNUNET_free (na); | 270 | GNUNET_free(na); |
275 | } | 271 | } |
276 | 272 | ||
277 | 273 | ||
@@ -282,32 +278,32 @@ do_read (void *cls) | |||
282 | * @param cls the `struct GNUNET_NAT_AUTO_Test` | 278 | * @param cls the `struct GNUNET_NAT_AUTO_Test` |
283 | */ | 279 | */ |
284 | static void | 280 | static void |
285 | do_accept (void *cls) | 281 | do_accept(void *cls) |
286 | { | 282 | { |
287 | struct GNUNET_NAT_AUTO_Test *tst = cls; | 283 | struct GNUNET_NAT_AUTO_Test *tst = cls; |
288 | struct GNUNET_NETWORK_Handle *s; | 284 | struct GNUNET_NETWORK_Handle *s; |
289 | struct NatActivity *wl; | 285 | struct NatActivity *wl; |
290 | 286 | ||
291 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 287 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
292 | tst->lsock, | 288 | tst->lsock, |
293 | &do_accept, | 289 | &do_accept, |
294 | tst); | 290 | tst); |
295 | s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL); | 291 | s = GNUNET_NETWORK_socket_accept(tst->lsock, NULL, NULL); |
296 | if (NULL == s) | 292 | if (NULL == s) |
297 | { | 293 | { |
298 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept"); | 294 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, "accept"); |
299 | return; /* odd error */ | 295 | return; /* odd error */ |
300 | } | 296 | } |
301 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 297 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
302 | "Got an inbound connection, waiting for data\n"); | 298 | "Got an inbound connection, waiting for data\n"); |
303 | wl = GNUNET_new (struct NatActivity); | 299 | wl = GNUNET_new(struct NatActivity); |
304 | wl->sock = s; | 300 | wl->sock = s; |
305 | wl->h = tst; | 301 | wl->h = tst; |
306 | wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 302 | wl->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
307 | wl->sock, | 303 | wl->sock, |
308 | &do_read, | 304 | &do_read, |
309 | wl); | 305 | wl); |
310 | GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl); | 306 | GNUNET_CONTAINER_DLL_insert(tst->na_head, tst->na_tail, wl); |
311 | } | 307 | } |
312 | 308 | ||
313 | 309 | ||
@@ -319,14 +315,14 @@ do_accept (void *cls) | |||
319 | * @param error error code | 315 | * @param error error code |
320 | */ | 316 | */ |
321 | static void | 317 | static void |
322 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) | 318 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) |
323 | { | 319 | { |
324 | struct ClientActivity *ca = cls; | 320 | struct ClientActivity *ca = cls; |
325 | struct GNUNET_NAT_AUTO_Test *tst = ca->h; | 321 | struct GNUNET_NAT_AUTO_Test *tst = ca->h; |
326 | 322 | ||
327 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca); | 323 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, ca); |
328 | GNUNET_MQ_destroy (ca->mq); | 324 | GNUNET_MQ_destroy(ca->mq); |
329 | GNUNET_free (ca); | 325 | GNUNET_free(ca); |
330 | } | 326 | } |
331 | 327 | ||
332 | 328 | ||
@@ -343,12 +339,12 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error) | |||
343 | * @param addrlen actual length of the @a addr | 339 | * @param addrlen actual length of the @a addr |
344 | */ | 340 | */ |
345 | static void | 341 | static void |
346 | addr_cb (void *cls, | 342 | addr_cb(void *cls, |
347 | void **app_ctx, | 343 | void **app_ctx, |
348 | int add_remove, | 344 | int add_remove, |
349 | enum GNUNET_NAT_AddressClass ac, | 345 | enum GNUNET_NAT_AddressClass ac, |
350 | const struct sockaddr *addr, | 346 | const struct sockaddr *addr, |
351 | socklen_t addrlen) | 347 | socklen_t addrlen) |
352 | { | 348 | { |
353 | struct GNUNET_NAT_AUTO_Test *h = cls; | 349 | struct GNUNET_NAT_AUTO_Test *h = cls; |
354 | struct ClientActivity *ca; | 350 | struct ClientActivity *ca; |
@@ -356,42 +352,42 @@ addr_cb (void *cls, | |||
356 | struct GNUNET_NAT_AUTO_TestMessage *msg; | 352 | struct GNUNET_NAT_AUTO_TestMessage *msg; |
357 | const struct sockaddr_in *sa; | 353 | const struct sockaddr_in *sa; |
358 | 354 | ||
359 | (void) app_ctx; | 355 | (void)app_ctx; |
360 | if (GNUNET_YES != add_remove) | 356 | if (GNUNET_YES != add_remove) |
361 | return; | 357 | return; |
362 | if (addrlen != sizeof (struct sockaddr_in)) | 358 | if (addrlen != sizeof(struct sockaddr_in)) |
363 | { | 359 | { |
364 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 360 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
365 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", | 361 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", |
366 | GNUNET_a2s (addr, addrlen)); | 362 | GNUNET_a2s(addr, addrlen)); |
367 | return; /* ignore IPv6 here */ | 363 | return; /* ignore IPv6 here */ |
368 | } | 364 | } |
369 | LOG (GNUNET_ERROR_TYPE_INFO, | 365 | LOG(GNUNET_ERROR_TYPE_INFO, |
370 | "Asking gnunet-nat-server to connect to `%s'\n", | 366 | "Asking gnunet-nat-server to connect to `%s'\n", |
371 | GNUNET_a2s (addr, addrlen)); | 367 | GNUNET_a2s(addr, addrlen)); |
372 | 368 | ||
373 | ca = GNUNET_new (struct ClientActivity); | 369 | ca = GNUNET_new(struct ClientActivity); |
374 | ca->h = h; | 370 | ca->h = h; |
375 | ca->mq = GNUNET_CLIENT_connect (h->cfg, | 371 | ca->mq = GNUNET_CLIENT_connect(h->cfg, |
376 | "gnunet-nat-server", | 372 | "gnunet-nat-server", |
377 | NULL, | 373 | NULL, |
378 | &mq_error_handler, | 374 | &mq_error_handler, |
379 | ca); | 375 | ca); |
380 | if (NULL == ca->mq) | 376 | if (NULL == ca->mq) |
381 | { | 377 | { |
382 | GNUNET_free (ca); | 378 | GNUNET_free(ca); |
383 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 379 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
384 | _ ("Failed to connect to `gnunet-nat-server'\n")); | 380 | _("Failed to connect to `gnunet-nat-server'\n")); |
385 | return; | 381 | return; |
386 | } | 382 | } |
387 | GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca); | 383 | GNUNET_CONTAINER_DLL_insert(h->ca_head, h->ca_tail, ca); |
388 | sa = (const struct sockaddr_in *) addr; | 384 | sa = (const struct sockaddr_in *)addr; |
389 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST); | 385 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAT_TEST); |
390 | msg->dst_ipv4 = sa->sin_addr.s_addr; | 386 | msg->dst_ipv4 = sa->sin_addr.s_addr; |
391 | msg->dport = sa->sin_port; | 387 | msg->dport = sa->sin_port; |
392 | msg->data = h->data; | 388 | msg->data = h->data; |
393 | msg->is_tcp = htonl ((uint32_t) (h->proto == IPPROTO_TCP)); | 389 | msg->is_tcp = htonl((uint32_t)(h->proto == IPPROTO_TCP)); |
394 | GNUNET_MQ_send (ca->mq, env); | 390 | GNUNET_MQ_send(ca->mq, env); |
395 | } | 391 | } |
396 | 392 | ||
397 | 393 | ||
@@ -403,12 +399,12 @@ addr_cb (void *cls, | |||
403 | * @param cls handle to the timed out NAT test | 399 | * @param cls handle to the timed out NAT test |
404 | */ | 400 | */ |
405 | static void | 401 | static void |
406 | do_fail (void *cls) | 402 | do_fail(void *cls) |
407 | { | 403 | { |
408 | struct GNUNET_NAT_AUTO_Test *nh = cls; | 404 | struct GNUNET_NAT_AUTO_Test *nh = cls; |
409 | 405 | ||
410 | nh->ttask = NULL; | 406 | nh->ttask = NULL; |
411 | nh->report (nh->report_cls, nh->status); | 407 | nh->report(nh->report_cls, nh->status); |
412 | } | 408 | } |
413 | 409 | ||
414 | 410 | ||
@@ -424,128 +420,128 @@ do_fail (void *cls) | |||
424 | * @return handle to cancel NAT test | 420 | * @return handle to cancel NAT test |
425 | */ | 421 | */ |
426 | struct GNUNET_NAT_AUTO_Test * | 422 | struct GNUNET_NAT_AUTO_Test * |
427 | GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | 423 | GNUNET_NAT_AUTO_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
428 | uint8_t proto, | 424 | uint8_t proto, |
429 | const char *section_name, | 425 | const char *section_name, |
430 | GNUNET_NAT_TestCallback report, | 426 | GNUNET_NAT_TestCallback report, |
431 | void *report_cls) | 427 | void *report_cls) |
432 | { | 428 | { |
433 | struct GNUNET_NAT_AUTO_Test *nh; | 429 | struct GNUNET_NAT_AUTO_Test *nh; |
434 | unsigned long long bnd_port; | 430 | unsigned long long bnd_port; |
435 | struct sockaddr_in sa; | 431 | struct sockaddr_in sa; |
436 | const struct sockaddr *addrs[] = {(const struct sockaddr *) &sa}; | 432 | const struct sockaddr *addrs[] = { (const struct sockaddr *)&sa }; |
437 | const socklen_t addrlens[] = {sizeof (sa)}; | 433 | const socklen_t addrlens[] = { sizeof(sa) }; |
438 | 434 | ||
439 | if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | 435 | if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, |
440 | section_name, | 436 | section_name, |
441 | "PORT", | 437 | "PORT", |
442 | &bnd_port)) || | 438 | &bnd_port)) || |
443 | (bnd_port > 65535)) | 439 | (bnd_port > 65535)) |
444 | { | 440 | { |
445 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 441 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
446 | _ ("Failed to find valid PORT in section `%s'\n"), | 442 | _("Failed to find valid PORT in section `%s'\n"), |
447 | section_name); | 443 | section_name); |
448 | return NULL; | 444 | return NULL; |
449 | } | 445 | } |
450 | 446 | ||
451 | memset (&sa, 0, sizeof (sa)); | 447 | memset(&sa, 0, sizeof(sa)); |
452 | sa.sin_family = AF_INET; | 448 | sa.sin_family = AF_INET; |
453 | sa.sin_port = htons ((uint16_t) bnd_port); | 449 | sa.sin_port = htons((uint16_t)bnd_port); |
454 | #if HAVE_SOCKADDR_IN_SIN_LEN | 450 | #if HAVE_SOCKADDR_IN_SIN_LEN |
455 | sa.sin_len = sizeof (sa); | 451 | sa.sin_len = sizeof(sa); |
456 | #endif | 452 | #endif |
457 | 453 | ||
458 | nh = GNUNET_new (struct GNUNET_NAT_AUTO_Test); | 454 | nh = GNUNET_new(struct GNUNET_NAT_AUTO_Test); |
459 | nh->cfg = cfg; | 455 | nh->cfg = cfg; |
460 | nh->proto = proto; | 456 | nh->proto = proto; |
461 | nh->section_name = GNUNET_strdup (section_name); | 457 | nh->section_name = GNUNET_strdup(section_name); |
462 | nh->report = report; | 458 | nh->report = report; |
463 | nh->report_cls = report_cls; | 459 | nh->report_cls = report_cls; |
464 | nh->status = GNUNET_NAT_ERROR_SUCCESS; | 460 | nh->status = GNUNET_NAT_ERROR_SUCCESS; |
465 | if (0 == bnd_port) | 461 | if (0 == bnd_port) |
466 | { | ||
467 | nh->nat = GNUNET_NAT_register (cfg, | ||
468 | section_name, | ||
469 | proto, | ||
470 | 0, | ||
471 | NULL, | ||
472 | NULL, | ||
473 | &addr_cb, | ||
474 | &reversal_cb, | ||
475 | nh); | ||
476 | } | ||
477 | else | ||
478 | { | ||
479 | nh->lsock = | ||
480 | GNUNET_NETWORK_socket_create (AF_INET, | ||
481 | (IPPROTO_UDP == proto) ? SOCK_DGRAM | ||
482 | : SOCK_STREAM, | ||
483 | proto); | ||
484 | if ((NULL == nh->lsock) || | ||
485 | (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock, | ||
486 | (const struct sockaddr *) &sa, | ||
487 | sizeof (sa)))) | ||
488 | { | ||
489 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
490 | _ ("Failed to create socket bound to `%s' for NAT test: %s\n"), | ||
491 | GNUNET_a2s ((const struct sockaddr *) &sa, sizeof (sa)), | ||
492 | strerror (errno)); | ||
493 | if (NULL != nh->lsock) | ||
494 | { | ||
495 | GNUNET_NETWORK_socket_close (nh->lsock); | ||
496 | nh->lsock = NULL; | ||
497 | } | ||
498 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
499 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh); | ||
500 | return nh; | ||
501 | } | ||
502 | if (IPPROTO_TCP == proto) | ||
503 | { | 462 | { |
504 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5)); | 463 | nh->nat = GNUNET_NAT_register(cfg, |
505 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 464 | section_name, |
506 | nh->lsock, | 465 | proto, |
507 | &do_accept, | 466 | 0, |
508 | nh); | 467 | NULL, |
468 | NULL, | ||
469 | &addr_cb, | ||
470 | &reversal_cb, | ||
471 | nh); | ||
509 | } | 472 | } |
510 | else | 473 | else |
511 | { | ||
512 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
513 | nh->lsock, | ||
514 | &do_udp_read, | ||
515 | nh); | ||
516 | } | ||
517 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
518 | "NAT test listens on port %llu (%s)\n", | ||
519 | bnd_port, | ||
520 | (IPPROTO_TCP == proto) ? "tcp" : "udp"); | ||
521 | nh->nat = GNUNET_NAT_register (cfg, | ||
522 | section_name, | ||
523 | proto, | ||
524 | 1, | ||
525 | addrs, | ||
526 | addrlens, | ||
527 | &addr_cb, | ||
528 | NULL, | ||
529 | nh); | ||
530 | if (NULL == nh->nat) | ||
531 | { | 474 | { |
532 | LOG (GNUNET_ERROR_TYPE_INFO, | 475 | nh->lsock = |
533 | _ ("NAT test failed to start NAT library\n")); | 476 | GNUNET_NETWORK_socket_create(AF_INET, |
534 | if (NULL != nh->ltask) | 477 | (IPPROTO_UDP == proto) ? SOCK_DGRAM |
535 | { | 478 | : SOCK_STREAM, |
536 | GNUNET_SCHEDULER_cancel (nh->ltask); | 479 | proto); |
537 | nh->ltask = NULL; | 480 | if ((NULL == nh->lsock) || |
538 | } | 481 | (GNUNET_OK != GNUNET_NETWORK_socket_bind(nh->lsock, |
539 | if (NULL != nh->lsock) | 482 | (const struct sockaddr *)&sa, |
540 | { | 483 | sizeof(sa)))) |
541 | GNUNET_NETWORK_socket_close (nh->lsock); | 484 | { |
542 | nh->lsock = NULL; | 485 | LOG(GNUNET_ERROR_TYPE_ERROR, |
543 | } | 486 | _("Failed to create socket bound to `%s' for NAT test: %s\n"), |
544 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | 487 | GNUNET_a2s((const struct sockaddr *)&sa, sizeof(sa)), |
545 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh); | 488 | strerror(errno)); |
546 | return nh; | 489 | if (NULL != nh->lsock) |
490 | { | ||
491 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
492 | nh->lsock = NULL; | ||
493 | } | ||
494 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
495 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh); | ||
496 | return nh; | ||
497 | } | ||
498 | if (IPPROTO_TCP == proto) | ||
499 | { | ||
500 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_listen(nh->lsock, 5)); | ||
501 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
502 | nh->lsock, | ||
503 | &do_accept, | ||
504 | nh); | ||
505 | } | ||
506 | else | ||
507 | { | ||
508 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
509 | nh->lsock, | ||
510 | &do_udp_read, | ||
511 | nh); | ||
512 | } | ||
513 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
514 | "NAT test listens on port %llu (%s)\n", | ||
515 | bnd_port, | ||
516 | (IPPROTO_TCP == proto) ? "tcp" : "udp"); | ||
517 | nh->nat = GNUNET_NAT_register(cfg, | ||
518 | section_name, | ||
519 | proto, | ||
520 | 1, | ||
521 | addrs, | ||
522 | addrlens, | ||
523 | &addr_cb, | ||
524 | NULL, | ||
525 | nh); | ||
526 | if (NULL == nh->nat) | ||
527 | { | ||
528 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
529 | _("NAT test failed to start NAT library\n")); | ||
530 | if (NULL != nh->ltask) | ||
531 | { | ||
532 | GNUNET_SCHEDULER_cancel(nh->ltask); | ||
533 | nh->ltask = NULL; | ||
534 | } | ||
535 | if (NULL != nh->lsock) | ||
536 | { | ||
537 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
538 | nh->lsock = NULL; | ||
539 | } | ||
540 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | ||
541 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh); | ||
542 | return nh; | ||
543 | } | ||
547 | } | 544 | } |
548 | } | ||
549 | return nh; | 545 | return nh; |
550 | } | 546 | } |
551 | 547 | ||
@@ -556,47 +552,47 @@ GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
556 | * @param tst test to stop. | 552 | * @param tst test to stop. |
557 | */ | 553 | */ |
558 | void | 554 | void |
559 | GNUNET_NAT_AUTO_test_stop (struct GNUNET_NAT_AUTO_Test *tst) | 555 | GNUNET_NAT_AUTO_test_stop(struct GNUNET_NAT_AUTO_Test *tst) |
560 | { | 556 | { |
561 | struct NatActivity *pos; | 557 | struct NatActivity *pos; |
562 | struct ClientActivity *cpos; | 558 | struct ClientActivity *cpos; |
563 | 559 | ||
564 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); | 560 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); |
565 | while (NULL != (cpos = tst->ca_head)) | 561 | while (NULL != (cpos = tst->ca_head)) |
566 | { | 562 | { |
567 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos); | 563 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, cpos); |
568 | GNUNET_MQ_destroy (cpos->mq); | 564 | GNUNET_MQ_destroy(cpos->mq); |
569 | GNUNET_free (cpos); | 565 | GNUNET_free(cpos); |
570 | } | 566 | } |
571 | while (NULL != (pos = tst->na_head)) | 567 | while (NULL != (pos = tst->na_head)) |
572 | { | 568 | { |
573 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos); | 569 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, pos); |
574 | GNUNET_SCHEDULER_cancel (pos->rtask); | 570 | GNUNET_SCHEDULER_cancel(pos->rtask); |
575 | GNUNET_NETWORK_socket_close (pos->sock); | 571 | GNUNET_NETWORK_socket_close(pos->sock); |
576 | GNUNET_free (pos); | 572 | GNUNET_free(pos); |
577 | } | 573 | } |
578 | if (NULL != tst->ttask) | 574 | if (NULL != tst->ttask) |
579 | { | 575 | { |
580 | GNUNET_SCHEDULER_cancel (tst->ttask); | 576 | GNUNET_SCHEDULER_cancel(tst->ttask); |
581 | tst->ttask = NULL; | 577 | tst->ttask = NULL; |
582 | } | 578 | } |
583 | if (NULL != tst->ltask) | 579 | if (NULL != tst->ltask) |
584 | { | 580 | { |
585 | GNUNET_SCHEDULER_cancel (tst->ltask); | 581 | GNUNET_SCHEDULER_cancel(tst->ltask); |
586 | tst->ltask = NULL; | 582 | tst->ltask = NULL; |
587 | } | 583 | } |
588 | if (NULL != tst->lsock) | 584 | if (NULL != tst->lsock) |
589 | { | 585 | { |
590 | GNUNET_NETWORK_socket_close (tst->lsock); | 586 | GNUNET_NETWORK_socket_close(tst->lsock); |
591 | tst->lsock = NULL; | 587 | tst->lsock = NULL; |
592 | } | 588 | } |
593 | if (NULL != tst->nat) | 589 | if (NULL != tst->nat) |
594 | { | 590 | { |
595 | GNUNET_NAT_unregister (tst->nat); | 591 | GNUNET_NAT_unregister(tst->nat); |
596 | tst->nat = NULL; | 592 | tst->nat = NULL; |
597 | } | 593 | } |
598 | GNUNET_free (tst->section_name); | 594 | GNUNET_free(tst->section_name); |
599 | GNUNET_free (tst); | 595 | GNUNET_free(tst); |
600 | } | 596 | } |
601 | 597 | ||
602 | /* end of nat_auto_api_test.c */ | 598 | /* end of nat_auto_api_test.c */ |