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 }