summaryrefslogtreecommitdiff
path: root/src/util/test_resolver_api.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/test_resolver_api.c')
-rw-r--r--src/util/test_resolver_api.c386
1 files changed, 193 insertions, 193 deletions
diff --git a/src/util/test_resolver_api.c b/src/util/test_resolver_api.c
index 0b27a2eff..13fda53bf 100644
--- a/src/util/test_resolver_api.c
+++ b/src/util/test_resolver_api.c
@@ -40,300 +40,300 @@ static int disable_rootserver_check;
40 40
41 41
42static void 42static void
43check_hostname(void *cls, 43check_hostname (void *cls,
44 const struct sockaddr *sa, 44 const struct sockaddr *sa,
45 socklen_t salen) 45 socklen_t salen)
46{ 46{
47 int *ok = cls; 47 int *ok = cls;
48 48
49 if (0 == salen) 49 if (0 == salen)
50 { 50 {
51 (*ok) &= ~8; 51 (*ok) &= ~8;
52 return; 52 return;
53 } 53 }
54 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 54 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
55 "Got IP address `%s' for our host.\n", 55 "Got IP address `%s' for our host.\n",
56 GNUNET_a2s(sa, salen)); 56 GNUNET_a2s (sa, salen));
57} 57}
58 58
59 59
60static void 60static void
61check_localhost_num(void *cls, 61check_localhost_num (void *cls,
62 const char *hostname) 62 const char *hostname)
63{ 63{
64 int *ok = cls; 64 int *ok = cls;
65 65
66 if (hostname == NULL) 66 if (hostname == NULL)
67 return; 67 return;
68 if (0 == strcmp(hostname, "127.0.0.1")) 68 if (0 == strcmp (hostname, "127.0.0.1"))
69 { 69 {
70 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 70 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
71 "Received correct hostname `%s'.\n", 71 "Received correct hostname `%s'.\n",
72 hostname); 72 hostname);
73 (*ok) &= ~4; 73 (*ok) &= ~4;
74 } 74 }
75 else 75 else
76 { 76 {
77 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 77 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
78 "Received invalid hostname `%s'.\n", 78 "Received invalid hostname `%s'.\n",
79 hostname); 79 hostname);
80 GNUNET_break(0); 80 GNUNET_break (0);
81 } 81 }
82} 82}
83 83
84 84
85static void 85static void
86check_localhost(void *cls, 86check_localhost (void *cls,
87 const char *hostname) 87 const char *hostname)
88{ 88{
89 int *ok = cls; 89 int *ok = cls;
90 90
91 if (NULL == hostname) 91 if (NULL == hostname)
92 return; 92 return;
93 if (0 == strcmp(hostname, "localhost")) 93 if (0 == strcmp (hostname, "localhost"))
94 { 94 {
95 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 95 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
96 "Received correct hostname `%s'.\n", 96 "Received correct hostname `%s'.\n",
97 hostname); 97 hostname);
98 (*ok) &= ~2; 98 (*ok) &= ~2;
99 } 99 }
100 else 100 else
101 { 101 {
102 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 102 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
103 "Received unexpected hostname `%s', expected `localhost' (this could be OK).\n", 103 "Received unexpected hostname `%s', expected `localhost' (this could be OK).\n",
104 hostname); 104 hostname);
105 } 105 }
106} 106}
107 107
108 108
109static void 109static void
110check_127(void *cls, const struct sockaddr *sa, socklen_t salen) 110check_127 (void *cls, const struct sockaddr *sa, socklen_t salen)
111{ 111{
112 int *ok = cls; 112 int *ok = cls;
113 const struct sockaddr_in *sai = (const struct sockaddr_in *)sa; 113 const struct sockaddr_in *sai = (const struct sockaddr_in *) sa;
114 114
115 if (NULL == sa) 115 if (NULL == sa)
116 return; 116 return;
117 GNUNET_assert(sizeof(struct sockaddr_in) == salen); 117 GNUNET_assert (sizeof(struct sockaddr_in) == salen);
118 if (sai->sin_addr.s_addr == htonl(INADDR_LOOPBACK)) 118 if (sai->sin_addr.s_addr == htonl (INADDR_LOOPBACK))
119 { 119 {
120 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 120 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
121 "Received correct address.\n"); 121 "Received correct address.\n");
122 (*ok) &= ~1; 122 (*ok) &= ~1;
123 } 123 }
124 else 124 else
125 { 125 {
126 char buf[INET_ADDRSTRLEN]; 126 char buf[INET_ADDRSTRLEN];
127 127
128 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 128 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
129 "Received incorrect address `%s'.\n", 129 "Received incorrect address `%s'.\n",
130 inet_ntop(AF_INET, 130 inet_ntop (AF_INET,
131 &sai->sin_addr, 131 &sai->sin_addr,
132 buf, 132 buf,
133 sizeof(buf))); 133 sizeof(buf)));
134 GNUNET_break(0); 134 GNUNET_break (0);
135 } 135 }
136} 136}
137 137
138 138
139static void 139static void
140check_rootserver_ip(void *cls, const struct sockaddr *sa, socklen_t salen) 140check_rootserver_ip (void *cls, const struct sockaddr *sa, socklen_t salen)
141{ 141{
142 int *ok = cls; 142 int *ok = cls;
143 const struct sockaddr_in *sai = (const struct sockaddr_in *)sa; 143 const struct sockaddr_in *sai = (const struct sockaddr_in *) sa;
144 144
145 if (NULL == sa) 145 if (NULL == sa)
146 return; 146 return;
147 GNUNET_assert(sizeof(struct sockaddr_in) == salen); 147 GNUNET_assert (sizeof(struct sockaddr_in) == salen);
148 148
149 if (0 == strcmp(inet_ntoa(sai->sin_addr), ROOTSERVER_IP)) 149 if (0 == strcmp (inet_ntoa (sai->sin_addr), ROOTSERVER_IP))
150 { 150 {
151 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 151 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
152 "Received correct rootserver ip address.\n"); 152 "Received correct rootserver ip address.\n");
153 (*ok) &= ~1; 153 (*ok) &= ~1;
154 } 154 }
155 else 155 else
156 { 156 {
157 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 157 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
158 "Received incorrect rootserver ip address.\n"); 158 "Received incorrect rootserver ip address.\n");
159 GNUNET_break(0); 159 GNUNET_break (0);
160 } 160 }
161} 161}
162 162
163 163
164static void 164static void
165check_rootserver_name(void *cls, 165check_rootserver_name (void *cls,
166 const char *hostname) 166 const char *hostname)
167{ 167{
168 int *ok = cls; 168 int *ok = cls;
169 169
170 if (NULL == hostname) 170 if (NULL == hostname)
171 return; 171 return;
172 172
173 if (0 == strcmp(hostname, ROOTSERVER_NAME)) 173 if (0 == strcmp (hostname, ROOTSERVER_NAME))
174 { 174 {
175 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 175 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
176 "Received correct rootserver hostname `%s'.\n", 176 "Received correct rootserver hostname `%s'.\n",
177 hostname); 177 hostname);
178 (*ok) &= ~2; 178 (*ok) &= ~2;
179 } 179 }
180 else 180 else
181 { 181 {
182 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 182 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
183 "Received invalid rootserver hostname `%s', expected `%s'\n", 183 "Received invalid rootserver hostname `%s', expected `%s'\n",
184 hostname, 184 hostname,
185 ROOTSERVER_NAME); 185 ROOTSERVER_NAME);
186 GNUNET_break(disable_rootserver_check); 186 GNUNET_break (disable_rootserver_check);
187 } 187 }
188} 188}
189 189
190 190
191static void 191static void
192run(void *cls, char *const *args, const char *cfgfile, 192run (void *cls, char *const *args, const char *cfgfile,
193 const struct GNUNET_CONFIGURATION_Handle *cfg) 193 const struct GNUNET_CONFIGURATION_Handle *cfg)
194{ 194{
195 int *ok = cls; 195 int *ok = cls;
196 struct sockaddr_in sa; 196 struct sockaddr_in sa;
197 struct GNUNET_TIME_Relative timeout = 197 struct GNUNET_TIME_Relative timeout =
198 GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30); 198 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
199 int count_ips = 0; 199 int count_ips = 0;
200 char *own_fqdn; 200 char *own_fqdn;
201 const char *rootserver_name = ROOTSERVER_NAME; 201 const char *rootserver_name = ROOTSERVER_NAME;
202 struct hostent *rootserver; 202 struct hostent *rootserver;
203 struct in_addr rootserver_addr; 203 struct in_addr rootserver_addr;
204 204
205 memset(&sa, 0, sizeof(sa)); 205 memset (&sa, 0, sizeof(sa));
206 sa.sin_family = AF_INET; 206 sa.sin_family = AF_INET;
207#if HAVE_SOCKADDR_IN_SIN_LEN 207#if HAVE_SOCKADDR_IN_SIN_LEN
208 sa.sin_len = (u_char)sizeof(sa); 208 sa.sin_len = (u_char) sizeof(sa);
209#endif 209#endif
210 sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 210 sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
211 211
212 /* 212 /*
213 * Looking up our own fqdn 213 * Looking up our own fqdn
214 */ 214 */
215 own_fqdn = GNUNET_RESOLVER_local_fqdn_get(); 215 own_fqdn = GNUNET_RESOLVER_local_fqdn_get ();
216 /* can't really check, only thing we can safely 216 /* can't really check, only thing we can safely
217 compare against is our own identical logic... */ 217 compare against is our own identical logic... */
218 GNUNET_free_non_null(own_fqdn); 218 GNUNET_free_non_null (own_fqdn);
219 219
220 /* 220 /*
221 * Testing non-local DNS resolution 221 * Testing non-local DNS resolution
222 * DNS rootserver to test: a.root-servers.net - 198.41.0.4 222 * DNS rootserver to test: a.root-servers.net - 198.41.0.4
223 */ 223 */
224 224
225 rootserver = gethostbyname(rootserver_name); 225 rootserver = gethostbyname (rootserver_name);
226 if (NULL == rootserver) 226 if (NULL == rootserver)
227 { 227 {
228 /* Error: resolving ip addresses does not work */ 228 /* Error: resolving ip addresses does not work */
229 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 229 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
230 _("gethostbyname() could not lookup IP address: %s\n"), 230 _ ("gethostbyname() could not lookup IP address: %s\n"),
231 hstrerror(h_errno)); 231 hstrerror (h_errno));
232 fprintf(stderr, 232 fprintf (stderr,
233 "%s", 233 "%s",
234 "System seems to be off-line, will not run all DNS tests\n"); 234 "System seems to be off-line, will not run all DNS tests\n");
235 *ok = 0; /* mark test as passing anyway */ 235 *ok = 0; /* mark test as passing anyway */
236 return; 236 return;
237 } 237 }
238 238
239 /* Counting returned IP addresses */ 239 /* Counting returned IP addresses */
240 while (NULL != rootserver->h_addr_list[count_ips]) 240 while (NULL != rootserver->h_addr_list[count_ips])
241 count_ips++; 241 count_ips++;
242 if (count_ips > 1) 242 if (count_ips > 1)
243 { 243 {
244 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 244 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
245 "IP received range for root name server, but a root name server has only 1 IP\n"); 245 "IP received range for root name server, but a root name server has only 1 IP\n");
246 GNUNET_break(0); 246 GNUNET_break (0);
247 } 247 }
248 248
249 /* Comparing to resolved address to the address the root name server should have */ 249 /* Comparing to resolved address to the address the root name server should have */
250 if (0 != 250 if (0 !=
251 strcmp(inet_ntoa(*(struct in_addr *)rootserver->h_addr_list[0]), 251 strcmp (inet_ntoa (*(struct in_addr *) rootserver->h_addr_list[0]),
252 ROOTSERVER_IP)) 252 ROOTSERVER_IP))
253 { 253 {
254 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 254 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
255 "IP received and IP for root name server differ\n"); 255 "IP received and IP for root name server differ\n");
256 GNUNET_break(0); 256 GNUNET_break (0);
257 } 257 }
258 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 258 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
259 "System's own forward name resolution is working\n"); 259 "System's own forward name resolution is working\n");
260 /* Resolve the same using GNUNET */ 260 /* Resolve the same using GNUNET */
261 GNUNET_RESOLVER_ip_get(ROOTSERVER_NAME, AF_INET, timeout, 261 GNUNET_RESOLVER_ip_get (ROOTSERVER_NAME, AF_INET, timeout,
262 &check_rootserver_ip, cls); 262 &check_rootserver_ip, cls);
263 GNUNET_RESOLVER_ip_get(ROOTSERVER_NAME, AF_INET, timeout, 263 GNUNET_RESOLVER_ip_get (ROOTSERVER_NAME, AF_INET, timeout,
264 &check_rootserver_ip, cls); 264 &check_rootserver_ip, cls);
265 265
266 /* 266 /*
267 * Success: forward lookups work as expected 267 * Success: forward lookups work as expected
268 * Next step: reverse lookups 268 * Next step: reverse lookups
269 */ 269 */
270 if (1 != inet_pton(AF_INET, 270 if (1 != inet_pton (AF_INET,
271 ROOTSERVER_IP, 271 ROOTSERVER_IP,
272 &rootserver_addr)) 272 &rootserver_addr))
273 { 273 {
274 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 274 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
275 "Could not transform root name server IP address\n"); 275 "Could not transform root name server IP address\n");
276 GNUNET_break(0); 276 GNUNET_break (0);
277 } 277 }
278 278
279 rootserver = 279 rootserver =
280 gethostbyaddr((const void *)&rootserver_addr, 280 gethostbyaddr ((const void *) &rootserver_addr,
281 sizeof(rootserver_addr), 281 sizeof(rootserver_addr),
282 AF_INET); 282 AF_INET);
283 if (NULL == rootserver) 283 if (NULL == rootserver)
284 { 284 {
285 /* Error: resolving IP addresses does not work */ 285 /* Error: resolving IP addresses does not work */
286 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 286 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
287 "gethostbyaddr() could not lookup hostname: %s\n", 287 "gethostbyaddr() could not lookup hostname: %s\n",
288 hstrerror(h_errno)); 288 hstrerror (h_errno));
289 disable_rootserver_check = GNUNET_YES; 289 disable_rootserver_check = GNUNET_YES;
290 } 290 }
291 else 291 else
292 {
293 if (0 != strcmp (rootserver->h_name,
294 ROOTSERVER_NAME))
292 { 295 {
293 if (0 != strcmp(rootserver->h_name, 296 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
294 ROOTSERVER_NAME)) 297 "Received hostname and hostname for root name server differ\n");
295 { 298 disable_rootserver_check = GNUNET_YES;
296 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
297 "Received hostname and hostname for root name server differ\n");
298 disable_rootserver_check = GNUNET_YES;
299 }
300 } 299 }
300 }
301 301
302 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 302 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
303 "System's own reverse name resolution is working\n"); 303 "System's own reverse name resolution is working\n");
304 /* Resolve the same using GNUNET */ 304 /* Resolve the same using GNUNET */
305 memset(&sa, 0, sizeof(sa)); 305 memset (&sa, 0, sizeof(sa));
306 sa.sin_family = AF_INET; 306 sa.sin_family = AF_INET;
307#if HAVE_SOCKADDR_IN_SIN_LEN 307#if HAVE_SOCKADDR_IN_SIN_LEN
308 sa.sin_len = (u_char)sizeof(sa); 308 sa.sin_len = (u_char) sizeof(sa);
309#endif 309#endif
310 inet_aton(ROOTSERVER_IP, &sa.sin_addr); 310 inet_aton (ROOTSERVER_IP, &sa.sin_addr);
311 311
312 GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa, 312 GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
313 sizeof(struct sockaddr), GNUNET_YES, timeout, 313 sizeof(struct sockaddr), GNUNET_YES, timeout,
314 &check_rootserver_name, cls); 314 &check_rootserver_name, cls);
315 315
316 memset(&sa, 0, sizeof(sa)); 316 memset (&sa, 0, sizeof(sa));
317 sa.sin_family = AF_INET; 317 sa.sin_family = AF_INET;
318#if HAVE_SOCKADDR_IN_SIN_LEN 318#if HAVE_SOCKADDR_IN_SIN_LEN
319 sa.sin_len = (u_char)sizeof(sa); 319 sa.sin_len = (u_char) sizeof(sa);
320#endif 320#endif
321 sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 321 sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
322 322
323 GNUNET_RESOLVER_ip_get("localhost", AF_INET, timeout, &check_127, cls); 323 GNUNET_RESOLVER_ip_get ("localhost", AF_INET, timeout, &check_127, cls);
324 GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa, 324 GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
325 sizeof(struct sockaddr), GNUNET_YES, timeout, 325 sizeof(struct sockaddr), GNUNET_YES, timeout,
326 &check_localhost, cls); 326 &check_localhost, cls);
327 327
328 GNUNET_RESOLVER_hostname_get((const struct sockaddr *)&sa, 328 GNUNET_RESOLVER_hostname_get ((const struct sockaddr *) &sa,
329 sizeof(struct sockaddr), GNUNET_NO, timeout, 329 sizeof(struct sockaddr), GNUNET_NO, timeout,
330 &check_localhost_num, cls); 330 &check_localhost_num, cls);
331 GNUNET_RESOLVER_hostname_resolve(AF_UNSPEC, timeout, &check_hostname, cls); 331 GNUNET_RESOLVER_hostname_resolve (AF_UNSPEC, timeout, &check_hostname, cls);
332} 332}
333 333
334 334
335int 335int
336main(int argc, char *argv[]) 336main (int argc, char *argv[])
337{ 337{
338 int ok = 1 + 2 + 4 + 8; 338 int ok = 1 + 2 + 4 + 8;
339 char *fn; 339 char *fn;
@@ -344,32 +344,32 @@ main(int argc, char *argv[])
344 struct GNUNET_GETOPT_CommandLineOption options[] = 344 struct GNUNET_GETOPT_CommandLineOption options[] =
345 { GNUNET_GETOPT_OPTION_END }; 345 { GNUNET_GETOPT_OPTION_END };
346 346
347 GNUNET_log_setup("test-resolver-api", 347 GNUNET_log_setup ("test-resolver-api",
348 "WARNING", 348 "WARNING",
349 NULL); 349 NULL);
350 fn = GNUNET_OS_get_libexec_binary_path("gnunet-service-resolver"); 350 fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
351 proc = GNUNET_OS_start_process(GNUNET_YES, 351 proc = GNUNET_OS_start_process (GNUNET_YES,
352 GNUNET_OS_INHERIT_STD_OUT_AND_ERR, 352 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
353 NULL, NULL, NULL, 353 NULL, NULL, NULL,
354 fn, 354 fn,
355 "gnunet-service-resolver", 355 "gnunet-service-resolver",
356 "-c", "test_resolver_api_data.conf", NULL); 356 "-c", "test_resolver_api_data.conf", NULL);
357 GNUNET_assert(NULL != proc); 357 GNUNET_assert (NULL != proc);
358 GNUNET_free(fn); 358 GNUNET_free (fn);
359 GNUNET_assert(GNUNET_OK == 359 GNUNET_assert (GNUNET_OK ==
360 GNUNET_PROGRAM_run((sizeof(argvx) / sizeof(char *)) - 1, 360 GNUNET_PROGRAM_run ((sizeof(argvx) / sizeof(char *)) - 1,
361 argvx, "test-resolver-api", "nohelp", 361 argvx, "test-resolver-api", "nohelp",
362 options, &run, &ok)); 362 options, &run, &ok));
363 if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) 363 if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
364 { 364 {
365 GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); 365 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
366 ok = 1; 366 ok = 1;
367 } 367 }
368 GNUNET_OS_process_wait(proc); 368 GNUNET_OS_process_wait (proc);
369 GNUNET_OS_process_destroy(proc); 369 GNUNET_OS_process_destroy (proc);
370 proc = NULL; 370 proc = NULL;
371 if (0 != ok) 371 if (0 != ok)
372 fprintf(stderr, "Missed some resolutions: %u\n", ok); 372 fprintf (stderr, "Missed some resolutions: %u\n", ok);
373 return ok; 373 return ok;
374} 374}
375 375