(test_hosts): Don't segfault if gethostname returns NULL.
[kopensolaris-gnu/glibc.git] / nss / test-netdb.c
1 /* Copyright (C) 1998,99,2000,01 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Andreas Jaeger <aj@suse.de>, 1998.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 /*
21   Testing of some network related lookup functions.
22   The system databases looked up are:
23   - /etc/services
24   - /etc/hosts
25   - /etc/networks
26   - /etc/protocols
27   - /etc/rpc
28   The tests try to be fairly generic and simple so that they work on
29   every possible setup (and might therefore not detect some possible
30   errors).
31 */
32
33 #include <netdb.h>
34 #include <rpc/netdb.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <arpa/inet.h>
39 #include <netinet/in.h>
40 #include <sys/param.h>
41 #include <sys/socket.h>
42 #include <unistd.h>
43 #include <errno.h>
44 #include "nss.h"
45
46 /*
47   The following define is necessary for glibc 2.0.6
48 */
49 #ifndef INET6_ADDRSTRLEN
50 # define INET6_ADDRSTRLEN 46
51 #endif
52
53 int error_count;
54
55 static void
56 output_servent (const char *call, struct servent *sptr)
57 {
58   char **pptr;
59
60   if (sptr == NULL)
61     printf ("Call: %s returned NULL\n", call);
62   else
63     {
64       printf ("Call: %s, returned: s_name: %s, s_port: %d, s_proto: %s\n",
65               call, sptr->s_name, ntohs(sptr->s_port), sptr->s_proto);
66       for (pptr = sptr->s_aliases; *pptr != NULL; pptr++)
67         printf ("  alias: %s\n", *pptr);
68     }
69 }
70
71
72 static void
73 test_services (void)
74 {
75   struct servent *sptr;
76
77   sptr = getservbyname ("domain", "tcp");
78   output_servent ("getservbyname (\"domain\", \"tcp\")", sptr);
79
80   sptr = getservbyname ("domain", "udp");
81   output_servent ("getservbyname (\"domain\", \"udp\")", sptr);
82
83   sptr = getservbyname ("domain", NULL);
84   output_servent ("getservbyname (\"domain\", NULL)", sptr);
85
86   sptr = getservbyname ("not-existant", NULL);
87   output_servent ("getservbyname (\"not-existant\", NULL)", sptr);
88
89   /* This shouldn't return anything.  */
90   sptr = getservbyname ("", "");
91   output_servent ("getservbyname (\"\", \"\")", sptr);
92
93   sptr = getservbyname ("", "tcp");
94   output_servent ("getservbyname (\"\", \"tcp\")", sptr);
95
96   sptr = getservbyport (htons(53), "tcp");
97   output_servent ("getservbyport (htons(53), \"tcp\")", sptr);
98
99   sptr = getservbyport (htons(53), NULL);
100   output_servent ("getservbyport (htons(53), NULL)", sptr);
101
102   sptr = getservbyport (htons(1), "udp"); /* shouldn't exist */
103   output_servent ("getservbyport (htons(1), \"udp\")", sptr);
104
105   setservent (0);
106   do
107     {
108       sptr = getservent ();
109       output_servent ("getservent ()", sptr);
110     }
111   while (sptr != NULL);
112   endservent ();
113 }
114
115
116 static void
117 output_hostent (const char *call, struct hostent *hptr)
118 {
119   char **pptr;
120   char buf[INET6_ADDRSTRLEN];
121
122   if (hptr == NULL)
123     printf ("Call: %s returned NULL\n", call);
124   else
125     {
126       printf ("Call: %s returned: name: %s, addr_type: %d\n",
127               call, hptr->h_name, hptr->h_addrtype);
128       if (hptr->h_aliases)
129         for (pptr = hptr->h_aliases; *pptr != NULL; pptr++)
130           printf ("  alias: %s\n", *pptr);
131
132       for (pptr = hptr->h_addr_list; *pptr != NULL; pptr++)
133         printf ("  ip: %s\n",
134                 inet_ntop (hptr->h_addrtype, *pptr, buf, sizeof (buf)));
135     }
136 }
137
138 static void
139 test_hosts (void)
140 {
141   struct hostent *hptr1, *hptr2;
142   char *name = NULL;
143   size_t namelen = 0;
144   struct in_addr ip;
145
146   hptr1 = gethostbyname ("localhost");
147   hptr2 = gethostbyname ("LocalHost");
148   if (hptr1 != NULL || hptr2 != NULL)
149     {
150       if (hptr1 == NULL)
151         {
152           printf ("localhost not found - but LocalHost found:-(\n");
153           ++error_count;
154         }
155       else if (hptr2 == NULL)
156         {
157           printf ("LocalHost not found - but localhost found:-(\n");
158           ++error_count;
159         }
160       else if (strcmp (hptr1->h_name, hptr2->h_name) != 0)
161         {
162           printf ("localhost and LocalHost have different canoncial name\n");
163           printf ("gethostbyname (\"localhost\")->%s\n", hptr1->h_name);
164           printf ("gethostbyname (\"LocalHost\")->%s\n", hptr2->h_name);
165           ++error_count;
166         }
167       else
168         output_hostent ("gethostbyname(\"localhost\")", hptr1);
169     }
170
171   hptr1 = gethostbyname ("127.0.0.1");
172   output_hostent ("gethostbyname (\"127.0.0.1\")", hptr1);
173
174   hptr1 = gethostbyname ("10.1234");
175   output_hostent ("gethostbyname (\"10.1234\")", hptr1);
176
177   hptr1 = gethostbyname2 ("localhost", AF_INET);
178   output_hostent ("gethostbyname2 (\"localhost\", AF_INET)", hptr1);
179
180   while (gethostname (name, namelen) < 0 && errno == ENAMETOOLONG)
181     {
182       namelen += 2;             /* tiny increments to test a lot */
183       name = realloc (name, namelen);
184     }
185   if (gethostname (name, namelen) == 0)
186     {
187       printf ("Hostname: %s\n", name);
188       if (name != NULL)
189         {
190           hptr1 = gethostbyname (name);
191           output_hostent ("gethostbyname (gethostname(...))", hptr1);
192         }
193     }
194
195   ip.s_addr = htonl (INADDR_LOOPBACK);
196   hptr1 = gethostbyaddr ((char *) &ip, sizeof(ip), AF_INET);
197   if (hptr1 != NULL)
198     {
199       printf ("official name of 127.0.0.1: %s\n", hptr1->h_name);
200     }
201
202   sethostent (0);
203   do
204     {
205       hptr1 = gethostent ();
206       output_hostent ("gethostent ()", hptr1);
207     }
208   while (hptr1 != NULL);
209   endhostent ();
210
211 }
212
213
214 static void
215 output_netent (const char *call, struct netent *nptr)
216 {
217   char **pptr;
218
219   if (nptr == NULL)
220     printf ("Call: %s returned NULL\n", call);
221   else
222     {
223       struct in_addr ip;
224
225       ip.s_addr = htonl(nptr->n_net);
226       printf ("Call: %s, returned: n_name: %s, network_number: %s\n",
227               call, nptr->n_name, inet_ntoa (ip));
228
229       for (pptr = nptr->n_aliases; *pptr != NULL; pptr++)
230         printf ("  alias: %s\n", *pptr);
231     }
232 }
233
234 static void
235 test_network (void)
236 {
237   struct netent *nptr;
238   u_int32_t ip;
239
240   /*
241      This test needs the following line in /etc/networks:
242      loopback        127.0.0.0
243   */
244   nptr = getnetbyname ("loopback");
245   output_netent ("getnetbyname (\"loopback\")",nptr);
246
247   nptr = getnetbyname ("LoopBACK");
248   output_netent ("getnetbyname (\"LoopBACK\")",nptr);
249
250   ip = inet_network ("127.0.0.0");
251   nptr = getnetbyaddr (ip, AF_INET);
252   output_netent ("getnetbyaddr (inet_network (\"127.0.0.0\"), AF_INET)",nptr);
253
254   setnetent (0);
255   do
256     {
257       nptr = getnetent ();
258       output_netent ("getnetent ()", nptr);
259     }
260   while (nptr != NULL);
261   endnetent ();
262 }
263
264
265 static void
266 output_protoent (const char *call, struct protoent *prptr)
267 {
268   char **pptr;
269
270   if (prptr == NULL)
271     printf ("Call: %s returned NULL\n", call);
272   else
273     {
274       printf ("Call: %s, returned: p_name: %s, p_proto: %d\n",
275               call, prptr->p_name, prptr->p_proto);
276       for (pptr = prptr->p_aliases; *pptr != NULL; pptr++)
277         printf ("  alias: %s\n", *pptr);
278     }
279 }
280
281
282 static void
283 test_protocols (void)
284 {
285   struct protoent *prptr;
286
287   prptr = getprotobyname ("IP");
288   output_protoent ("getprotobyname (\"IP\")", prptr);
289
290   prptr = getprotobynumber (1);
291   output_protoent ("getprotobynumber (1)", prptr);
292
293   setprotoent (0);
294   do
295     {
296       prptr = getprotoent ();
297       output_protoent ("getprotoent ()", prptr);
298     }
299   while (prptr != NULL);
300   endprotoent ();
301 }
302
303
304 static void
305 output_rpcent (const char *call, struct rpcent *rptr)
306 {
307   char **pptr;
308
309   if (rptr == NULL)
310     printf ("Call: %s returned NULL\n", call);
311   else
312     {
313       printf ("Call: %s, returned: r_name: %s, r_number: %d\n",
314                 call, rptr->r_name, rptr->r_number);
315       for (pptr = rptr->r_aliases; *pptr != NULL; pptr++)
316         printf ("  alias: %s\n", *pptr);
317     }
318 }
319
320 static void
321 test_rpc (void)
322 {
323   struct rpcent *rptr;
324
325   rptr = getrpcbyname ("portmap");
326   output_rpcent ("getrpcyname (\"portmap\")", rptr);
327
328   rptr = getrpcbynumber (100000);
329   output_rpcent ("getrpcbynumber (100000)", rptr);
330
331   setrpcent (0);
332   do
333     {
334       rptr = getrpcent ();
335       output_rpcent ("getrpcent ()", rptr);
336     }
337   while (rptr != NULL);
338   endrpcent ();
339 }
340
341 /* Override /etc/nsswitch.conf for this program.  This is mainly
342    useful for developers. */
343 static void  __attribute__ ((unused))
344 setdb (const char *dbname)
345 {
346   if (strcmp ("db", dbname))
347       {
348         /*
349           db is not implemented for hosts, networks
350         */
351         __nss_configure_lookup ("hosts", dbname);
352         __nss_configure_lookup ("networks", dbname);
353       }
354   __nss_configure_lookup ("protocols", dbname);
355   __nss_configure_lookup ("rpc", dbname);
356   __nss_configure_lookup ("services", dbname);
357 }
358
359
360 int
361 main (void)
362 {
363   /*
364     setdb ("db");
365   */
366
367   test_hosts ();
368   test_network ();
369   test_protocols ();
370   test_rpc ();
371   test_services ();
372
373   if (error_count)
374     printf ("\n %d errors occurred!\n", error_count);
375   else
376     printf ("No visible errors occurred!\n");
377
378   return (error_count != 0);
379 }