The Tcpdump Group git mirrors - libpcap/blob - nametoaddr.c

   1 /*
   2  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * Name to id translation routines used by the scanner.
  22  * These functions are not time critical.
  23  */
  24
  25 #ifndef lint
  26 static const char rcsid[] _U_ =
  27     "@(#) $Header: /tcpdump/master/libpcap/nametoaddr.c,v 1.73 2003-12-24 09:14:21 itojun Exp $ (LBL)";
  28 #endif
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif
  33
  34 #ifdef WIN32
  35 #include <pcap-stdinc.h>
  36
  37 #else /* WIN32 */
  38
  39 #include <sys/param.h>
  40 #include <sys/types.h>                          /* concession to AIX */
  41 #include <sys/socket.h>
  42 #include <sys/time.h>
  43
  44 #include <netinet/in.h>
  45 #endif /* WIN32 */
  46
  47 /*
  48  * XXX - why was this included even on UNIX?
  49  */
  50 #ifdef __MINGW32__
  51 #include "IP6_misc.h"
  52 #endif
  53
  54 #ifndef WIN32
  55 #ifdef HAVE_ETHER_HOSTTON
  56 #ifdef HAVE_NETINET_IF_ETHER_H
  57 struct mbuf;            /* Squelch compiler warnings on some platforms for */
  58 struct rtentry;         /* declarations in <net/if.h> */
  59 #include <net/if.h>     /* for "struct ifnet" in "struct arpcom" on Solaris */
  60 #include <netinet/if_ether.h>
  61 #endif /* HAVE_NETINET_IF_ETHER_H */
  62 #endif /* HAVE_ETHER_HOSTTON */
  63 #include <arpa/inet.h>
  64 #include <netdb.h>
  65 #endif /* WIN32 */
  66
  67 #include <ctype.h>
  68 #include <errno.h>
  69 #include <stdlib.h>
  70 #include <memory.h>
  71 #include <stdio.h>
  72
  73 #include "pcap-int.h"
  74
  75 #include "gencode.h"
  76 #include <pcap-namedb.h>
  77
  78 #ifdef HAVE_OS_PROTO_H
  79 #include "os-proto.h"
  80 #endif
  81
  82 #ifndef NTOHL
  83 #define NTOHL(x) (x) = ntohl(x)
  84 #define NTOHS(x) (x) = ntohs(x)
  85 #endif
  86
  87 static inline int xdtoi(int);
  88
  89 /*
  90  *  Convert host name to internet address.
  91  *  Return 0 upon failure.
  92  */
  93 bpf_u_int32 **
  94 pcap_nametoaddr(const char *name)
  95 {
  96 #ifndef h_addr
  97         static bpf_u_int32 *hlist[2];
  98 #endif
  99         bpf_u_int32 **p;
 100         struct hostent *hp;
 101
 102         if ((hp = gethostbyname(name)) != NULL) {
 103 #ifndef h_addr
 104                 hlist[0] = (bpf_u_int32 *)hp->h_addr;
 105                 NTOHL(hp->h_addr);
 106                 return hlist;
 107 #else
 108                 for (p = (bpf_u_int32 **)hp->h_addr_list; *p; ++p)
 109                         NTOHL(**p);
 110                 return (bpf_u_int32 **)hp->h_addr_list;
 111 #endif
 112         }
 113         else
 114                 return 0;
 115 }
 116
 117 #ifdef INET6
 118 struct addrinfo *
 119 pcap_nametoaddrinfo(const char *name)
 120 {
 121         struct addrinfo hints, *res;
 122         int error;
 123
 124         memset(&hints, 0, sizeof(hints));
 125         hints.ai_family = PF_UNSPEC;
 126         hints.ai_socktype = SOCK_STREAM;        /*not really*/
 127         hints.ai_protocol = IPPROTO_TCP;        /*not really*/
 128         error = getaddrinfo(name, NULL, &hints, &res);
 129         if (error)
 130                 return NULL;
 131         else
 132                 return res;
 133 }
 134 #endif /*INET6*/
 135
 136 /*
 137  *  Convert net name to internet address.
 138  *  Return 0 upon failure.
 139  */
 140 bpf_u_int32
 141 pcap_nametonetaddr(const char *name)
 142 {
 143 #ifndef WIN32
 144         struct netent *np;
 145
 146         if ((np = getnetbyname(name)) != NULL)
 147                 return np->n_net;
 148         else
 149                 return 0;
 150 #else
 151         /*
 152          * There's no "getnetbyname()" on Windows.
 153          */
 154         return 0;
 155 #endif
 156 }
 157
 158 /*
 159  * Convert a port name to its port and protocol numbers.
 160  * We assume only TCP or UDP.
 161  * Return 0 upon failure.
 162  */
 163 int
 164 pcap_nametoport(const char *name, int *port, int *proto)
 165 {
 166         struct servent *sp;
 167         int tcp_port = -1;
 168         int udp_port = -1;
 169
 170         /*
 171          * We need to check /etc/services for ambiguous entries.
 172          * If we find the ambiguous entry, and it has the
 173          * same port number, change the proto to PROTO_UNDEF
 174          * so both TCP and UDP will be checked.
 175          */
 176         sp = getservbyname(name, "tcp");
 177         if (sp != NULL) tcp_port = ntohs(sp->s_port);
 178         sp = getservbyname(name, "udp");
 179         if (sp != NULL) udp_port = ntohs(sp->s_port);
 180         if (tcp_port >= 0) {
 181                 *port = tcp_port;
 182                 *proto = IPPROTO_TCP;
 183                 if (udp_port >= 0) {
 184                         if (udp_port == tcp_port)
 185                                 *proto = PROTO_UNDEF;
 186 #ifdef notdef
 187                         else
 188                                 /* Can't handle ambiguous names that refer
 189                                    to different port numbers. */
 190                                 warning("ambiguous port %s in /etc/services",
 191                                         name);
 192 #endif
 193                 }
 194                 return 1;
 195         }
 196         if (udp_port >= 0) {
 197                 *port = udp_port;
 198                 *proto = IPPROTO_UDP;
 199                 return 1;
 200         }
 201 #if defined(ultrix) || defined(__osf__)
 202         /* Special hack in case NFS isn't in /etc/services */
 203         if (strcmp(name, "nfs") == 0) {
 204                 *port = 2049;
 205                 *proto = PROTO_UNDEF;
 206                 return 1;
 207         }
 208 #endif
 209         return 0;
 210 }
 211
 212 int
 213 pcap_nametoproto(const char *str)
 214 {
 215         struct protoent *p;
 216
 217         p = getprotobyname(str);
 218         if (p != 0)
 219                 return p->p_proto;
 220         else
 221                 return PROTO_UNDEF;
 222 }
 223
 224 #include "ethertype.h"
 225
 226 struct eproto {
 227         char *s;
 228         u_short p;
 229 };
 230
 231 /* Static data base of ether protocol types. */
 232 struct eproto eproto_db[] = {
 233         { "pup", ETHERTYPE_PUP },
 234         { "xns", ETHERTYPE_NS },
 235         { "ip", ETHERTYPE_IP },
 236 #ifdef INET6
 237         { "ip6", ETHERTYPE_IPV6 },
 238 #endif
 239         { "arp", ETHERTYPE_ARP },
 240         { "rarp", ETHERTYPE_REVARP },
 241         { "sprite", ETHERTYPE_SPRITE },
 242         { "mopdl", ETHERTYPE_MOPDL },
 243         { "moprc", ETHERTYPE_MOPRC },
 244         { "decnet", ETHERTYPE_DN },
 245         { "lat", ETHERTYPE_LAT },
 246         { "sca", ETHERTYPE_SCA },
 247         { "lanbridge", ETHERTYPE_LANBRIDGE },
 248         { "vexp", ETHERTYPE_VEXP },
 249         { "vprod", ETHERTYPE_VPROD },
 250         { "atalk", ETHERTYPE_ATALK },
 251         { "atalkarp", ETHERTYPE_AARP },
 252         { "loopback", ETHERTYPE_LOOPBACK },
 253         { "decdts", ETHERTYPE_DECDTS },
 254         { "decdns", ETHERTYPE_DECDNS },
 255         { (char *)0, 0 }
 256 };
 257
 258 int
 259 pcap_nametoeproto(const char *s)
 260 {
 261         struct eproto *p = eproto_db;
 262
 263         while (p->s != 0) {
 264                 if (strcmp(p->s, s) == 0)
 265                         return p->p;
 266                 p += 1;
 267         }
 268         return PROTO_UNDEF;
 269 }
 270
 271 /* Hex digit to integer. */
 272 static inline int
 273 xdtoi(c)
 274         register int c;
 275 {
 276         if (isdigit(c))
 277                 return c - '0';
 278         else if (islower(c))
 279                 return c - 'a' + 10;
 280         else
 281                 return c - 'A' + 10;
 282 }
 283
 284 int
 285 __pcap_atoin(const char *s, bpf_u_int32 *addr)
 286 {
 287         u_int n;
 288         int len;
 289
 290         *addr = 0;
 291         len = 0;
 292         while (1) {
 293                 n = 0;
 294                 while (*s && *s != '.')
 295                         n = n * 10 + *s++ - '0';
 296                 *addr <<= 8;
 297                 *addr |= n & 0xff;
 298                 len += 8;
 299                 if (*s == '\0')
 300                         return len;
 301                 ++s;
 302         }
 303         /* NOTREACHED */
 304 }
 305
 306 int
 307 __pcap_atodn(const char *s, bpf_u_int32 *addr)
 308 {
 309 #define AREASHIFT 10
 310 #define AREAMASK 0176000
 311 #define NODEMASK 01777
 312
 313         u_int node, area;
 314
 315         if (sscanf((char *)s, "%d.%d", &area, &node) != 2)
 316                 bpf_error("malformed decnet address '%s'", s);
 317
 318         *addr = (area << AREASHIFT) & AREAMASK;
 319         *addr |= (node & NODEMASK);
 320
 321         return(32);
 322 }
 323
 324 /*
 325  * Convert 's' which has the form "xx:xx:xx:xx:xx:xx" into a new
 326  * ethernet address.  Assumes 's' is well formed.
 327  */
 328 u_char *
 329 pcap_ether_aton(const char *s)
 330 {
 331         register u_char *ep, *e;
 332         register u_int d;
 333
 334         e = ep = (u_char *)malloc(6);
 335
 336         while (*s) {
 337                 if (*s == ':')
 338                         s += 1;
 339                 d = xdtoi(*s++);
 340                 if (isxdigit((unsigned char)*s)) {
 341                         d <<= 4;
 342                         d |= xdtoi(*s++);
 343                 }
 344                 *ep++ = d;
 345         }
 346
 347         return (e);
 348 }
 349
 350 #ifndef HAVE_ETHER_HOSTTON
 351 /* Roll our own */
 352 u_char *
 353 pcap_ether_hostton(const char *name)
 354 {
 355         register struct pcap_etherent *ep;
 356         register u_char *ap;
 357         static FILE *fp = NULL;
 358         static int init = 0;
 359
 360         if (!init) {
 361                 fp = fopen(PCAP_ETHERS_FILE, "r");
 362                 ++init;
 363                 if (fp == NULL)
 364                         return (NULL);
 365         } else if (fp == NULL)
 366                 return (NULL);
 367         else
 368                 rewind(fp);
 369
 370         while ((ep = pcap_next_etherent(fp)) != NULL) {
 371                 if (strcmp(ep->name, name) == 0) {
 372                         ap = (u_char *)malloc(6);
 373                         if (ap != NULL) {
 374                                 memcpy(ap, ep->addr, 6);
 375                                 return (ap);
 376                         }
 377                         break;
 378                 }
 379         }
 380         return (NULL);
 381 }
 382 #else
 383
 384 /*
 385  * XXX - perhaps this should, instead, be declared in "lbl/os-XXX.h" files,
 386  * for those OS versions that don't declare it, rather than being declared
 387  * here?  That way, for example, we could declare it on FreeBSD 2.x (which
 388  * doesn't declare it), but not on FreeBSD 3.x (which declares it like
 389  * this) or FreeBSD 4.x (which declares it with its first argument as
 390  * "const char *", so no matter how we declare it here, it'll fail to
 391  * compile on one of 3.x or 4.x).
 392  */
 393 #if !defined(sgi) && !defined(__NetBSD__) && !defined(__FreeBSD__) && \
 394        !defined(_UNICOSMP)
 395 extern int ether_hostton(char *, struct ether_addr *);
 396 #endif
 397
 398 /* Use the os supplied routines */
 399 u_char *
 400 pcap_ether_hostton(const char *name)
 401 {
 402         register u_char *ap;
 403         u_char a[6];
 404
 405         ap = NULL;
 406         if (ether_hostton((char *)name, (struct ether_addr *)a) == 0) {
 407                 ap = (u_char *)malloc(6);
 408                 if (ap != NULL)
 409                         memcpy((char *)ap, (char *)a, 6);
 410         }
 411         return (ap);
 412 }
 413 #endif
 414
 415 u_short
 416 __pcap_nametodnaddr(const char *name)
 417 {
 418 #ifdef  DECNETLIB
 419         struct nodeent *getnodebyname();
 420         struct nodeent *nep;
 421         unsigned short res;
 422
 423         nep = getnodebyname(name);
 424         if (nep == ((struct nodeent *)0))
 425                 bpf_error("unknown decnet host name '%s'\n", name);
 426
 427         memcpy((char *)&res, (char *)nep->n_addr, sizeof(unsigned short));
 428         return(res);
 429 #else
 430         bpf_error("decnet name support not included, '%s' cannot be translated\n",
 431                 name);
 432         return(0);
 433 #endif
 434 }