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 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #ifdef DECNETLIB
  30 #include <sys/types.h>
  31 #include <netdnet/dnetdb.h>
  32 #endif
  33
  34 #ifdef _WIN32
  35   #include <winsock2.h>
  36   #include <ws2tcpip.h>
  37
  38   #ifdef INET6
  39     /*
  40      * To quote the MSDN page for getaddrinfo() at
  41      *
  42      *    https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520(v=vs.85).aspx
  43      *
  44      * "Support for getaddrinfo on Windows 2000 and older versions
  45      * The getaddrinfo function was added to the Ws2_32.dll on Windows XP and
  46      * later. To execute an application that uses this function on earlier
  47      * versions of Windows, then you need to include the Ws2tcpip.h and
  48      * Wspiapi.h files. When the Wspiapi.h include file is added, the
  49      * getaddrinfo function is defined to the WspiapiGetAddrInfo inline
  50      * function in the Wspiapi.h file. At runtime, the WspiapiGetAddrInfo
  51      * function is implemented in such a way that if the Ws2_32.dll or the
  52      * Wship6.dll (the file containing getaddrinfo in the IPv6 Technology
  53      * Preview for Windows 2000) does not include getaddrinfo, then a
  54      * version of getaddrinfo is implemented inline based on code in the
  55      * Wspiapi.h header file. This inline code will be used on older Windows
  56      * platforms that do not natively support the getaddrinfo function."
  57      *
  58      * We use getaddrinfo(), so we include Wspiapi.h here.
  59      */
  60     #include <wspiapi.h>
  61   #endif /* INET6 */
  62 #else /* _WIN32 */
  63   #include <sys/param.h>
  64   #include <sys/types.h>
  65   #include <sys/socket.h>
  66   #include <sys/time.h>
  67
  68   #include <netinet/in.h>
  69
  70   #ifdef HAVE_ETHER_HOSTTON
  71     #if defined(NET_ETHERNET_H_DECLARES_ETHER_HOSTTON)
  72       /*
  73        * OK, just include <net/ethernet.h>.
  74        */
  75       #include <net/ethernet.h>
  76     #elif defined(NETINET_ETHER_H_DECLARES_ETHER_HOSTTON)
  77       /*
  78        * OK, just include <netinet/ether.h>
  79        */
  80       #include <netinet/ether.h>
  81     #elif defined(SYS_ETHERNET_H_DECLARES_ETHER_HOSTTON)
  82       /*
  83        * OK, just include <sys/ethernet.h>
  84        */
  85       #include <sys/ethernet.h>
  86     #elif defined(ARPA_INET_H_DECLARES_ETHER_HOSTTON)
  87       /*
  88        * OK, just include <arpa/inet.h>
  89        */
  90       #include <arpa/inet.h>
  91     #elif defined(NETINET_IF_ETHER_H_DECLARES_ETHER_HOSTTON)
  92       /*
  93        * OK, include <netinet/if_ether.h>, after all the other stuff we
  94        * need to include or define for its benefit.
  95        */
  96       #define NEED_NETINET_IF_ETHER_H
  97     #else
  98       /*
  99        * We'll have to declare it ourselves.
 100        * If <netinet/if_ether.h> defines struct ether_addr, include
 101        * it.  Otherwise, define it ourselves.
 102        */
 103       #ifdef HAVE_STRUCT_ETHER_ADDR
 104         #define NEED_NETINET_IF_ETHER_H
 105       #else /* HAVE_STRUCT_ETHER_ADDR */
 106         struct ether_addr {
 107                 unsigned char ether_addr_octet[6];
 108         };
 109       #endif /* HAVE_STRUCT_ETHER_ADDR */
 110     #endif /* what declares ether_hostton() */
 111
 112     #ifdef NEED_NETINET_IF_ETHER_H
 113       #include <net/if.h>       /* Needed on some platforms */
 114       #include <netinet/in.h>   /* Needed on some platforms */
 115       #include <netinet/if_ether.h>
 116     #endif /* NEED_NETINET_IF_ETHER_H */
 117
 118     #ifndef HAVE_DECL_ETHER_HOSTTON
 119       /*
 120        * No header declares it, so declare it ourselves.
 121        */
 122       extern int ether_hostton(const char *, struct ether_addr *);
 123     #endif /* !defined(HAVE_DECL_ETHER_HOSTTON) */
 124   #endif /* HAVE_ETHER_HOSTTON */
 125
 126   #include <arpa/inet.h>
 127   #include <netdb.h>
 128 #endif /* _WIN32 */
 129
 130 #include <ctype.h>
 131 #include <errno.h>
 132 #include <stdlib.h>
 133 #include <string.h>
 134 #include <stdio.h>
 135
 136 #include "pcap-int.h"
 137
 138 #include "diag-control.h"
 139
 140 #include "gencode.h"
 141 #include <pcap/namedb.h>
 142 #include "nametoaddr.h"
 143
 144 #ifdef HAVE_OS_PROTO_H
 145 #include "os-proto.h"
 146 #endif
 147
 148 #ifndef NTOHL
 149 #define NTOHL(x) (x) = ntohl(x)
 150 #define NTOHS(x) (x) = ntohs(x)
 151 #endif
 152
 153 /*
 154  *  Convert host name to internet address.
 155  *  Return 0 upon failure.
 156  *  XXX - not thread-safe; don't use it inside libpcap.
 157  */
 158 bpf_u_int32 **
 159 pcap_nametoaddr(const char *name)
 160 {
 161 #ifndef h_addr
 162         static bpf_u_int32 *hlist[2];
 163 #endif
 164         bpf_u_int32 **p;
 165         struct hostent *hp;
 166
 167         /*
 168          * gethostbyname() is deprecated on Windows, perhaps because
 169          * it's not thread-safe, or because it doesn't support IPv6,
 170          * or both.
 171          *
 172          * We deprecate pcap_nametoaddr() on all platforms because
 173          * it's not thread-safe; we supply it for backwards compatibility,
 174          * so suppress the deprecation warning.  We could, I guess,
 175          * use getaddrinfo() and construct the array ourselves, but
 176          * that's probably not worth the effort, as that wouldn't make
 177          * this thread-safe - we can't change the API to require that
 178          * our caller free the address array, so we still have to reuse
 179          * a local array.
 180          */
 181 DIAG_OFF_DEPRECATION
 182         if ((hp = gethostbyname(name)) != NULL) {
 183 DIAG_ON_DEPRECATION
 184 #ifndef h_addr
 185                 hlist[0] = (bpf_u_int32 *)hp->h_addr;
 186                 NTOHL(hp->h_addr);
 187                 return hlist;
 188 #else
 189                 for (p = (bpf_u_int32 **)hp->h_addr_list; *p; ++p)
 190                         NTOHL(**p);
 191                 return (bpf_u_int32 **)hp->h_addr_list;
 192 #endif
 193         }
 194         else
 195                 return 0;
 196 }
 197
 198 struct addrinfo *
 199 pcap_nametoaddrinfo(const char *name)
 200 {
 201         struct addrinfo hints, *res;
 202         int error;
 203
 204         memset(&hints, 0, sizeof(hints));
 205         hints.ai_family = PF_UNSPEC;
 206         hints.ai_socktype = SOCK_STREAM;        /*not really*/
 207         hints.ai_protocol = IPPROTO_TCP;        /*not really*/
 208         error = getaddrinfo(name, NULL, &hints, &res);
 209         if (error)
 210                 return NULL;
 211         else
 212                 return res;
 213 }
 214
 215 /*
 216  *  Convert net name to internet address.
 217  *  Return 0 upon failure.
 218  *  XXX - not guaranteed to be thread-safe!  See below for platforms
 219  *  on which it is thread-safe and on which it isn't.
 220  */
 221 bpf_u_int32
 222 pcap_nametonetaddr(const char *name)
 223 {
 224 #ifdef _WIN32
 225         /*
 226          * There's no "getnetbyname()" on Windows.
 227          *
 228          * XXX - I guess we could use the BSD code to read
 229          * C:\Windows\System32\drivers\etc/networks, assuming
 230          * that's its home on all the versions of Windows
 231          * we use, but that file probably just has the loopback
 232          * network on 127/24 on 99 44/100% of Windows machines.
 233          *
 234          * (Heck, these days it probably just has that on 99 44/100%
 235          * of *UN*X* machines.)
 236          */
 237         return 0;
 238 #else
 239         /*
 240          * UN*X.
 241          */
 242         struct netent *np = NULL;
 243   #if defined(HAVE_LINUX_GETNETBYNAME_R)
 244         /*
 245          * We have Linux's reentrant getnetbyname_r().
 246          */
 247         struct netent result_buf;
 248         char buf[1024]; /* arbitrary size */
 249         int h_errnoval;
 250         int err;
 251
 252         err = getnetbyname_r(name, &result_buf, buf, sizeof buf, &np,
 253             &h_errnoval);
 254         if (err != 0) {
 255                 /*
 256                  * XXX - dynamically allocate the buffer, and make it
 257                  * bigger if we get ERANGE back?
 258                  */
 259                 return 0;
 260         }
 261   #elif defined(HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
 262         /*
 263          * We have Solaris's and IRIX's reentrant getnetbyname_r().
 264          */
 265         struct netent result_buf;
 266         char buf[1024]; /* arbitrary size */
 267
 268         np = getnetbyname_r(name, &result_buf, buf, (int)sizeof buf);
 269   #elif defined(HAVE_AIX_GETNETBYNAME_R)
 270         /*
 271          * We have AIX's reentrant getnetbyname_r().
 272          */
 273         struct netent result_buf;
 274         struct netent_data net_data;
 275
 276         if (getnetbyname_r(name, &result_buf, &net_data) == -1)
 277                 np = NULL;
 278         else
 279                 np = &result_buf;
 280   #else
 281         /*
 282          * We don't have any getnetbyname_r(); either we have a
 283          * getnetbyname() that uses thread-specific data, in which
 284          * case we're thread-safe (sufficiently recent FreeBSD,
 285          * sufficiently recent Darwin-based OS, sufficiently recent
 286          * HP-UX, sufficiently recent Tru64 UNIX), or we have the
 287          * traditional getnetbyname() (everything else, including
 288          * current NetBSD and OpenBSD), in which case we're not
 289          * thread-safe.
 290          */
 291         np = getnetbyname(name);
 292   #endif
 293         if (np != NULL)
 294                 return np->n_net;
 295         else
 296                 return 0;
 297 #endif /* _WIN32 */
 298 }
 299
 300 /*
 301  * Convert a port name to its port and protocol numbers.
 302  * We assume only TCP or UDP.
 303  * Return 0 upon failure.
 304  */
 305 int
 306 pcap_nametoport(const char *name, int *port, int *proto)
 307 {
 308         struct addrinfo hints, *res, *ai;
 309         int error;
 310         struct sockaddr_in *in4;
 311 #ifdef INET6
 312         struct sockaddr_in6 *in6;
 313 #endif
 314         int tcp_port = -1;
 315         int udp_port = -1;
 316
 317         /*
 318          * We check for both TCP and UDP in case there are
 319          * ambiguous entries.
 320          */
 321         memset(&hints, 0, sizeof(hints));
 322         hints.ai_family = PF_UNSPEC;
 323         hints.ai_socktype = SOCK_STREAM;
 324         hints.ai_protocol = IPPROTO_TCP;
 325         error = getaddrinfo(NULL, name, &hints, &res);
 326         if (error != 0) {
 327                 if (error != EAI_NONAME &&
 328                     error != EAI_SERVICE) {
 329                         /*
 330                          * This is a real error, not just "there's
 331                          * no such service name".
 332                          * XXX - this doesn't return an error string.
 333                          */
 334                         return 0;
 335                 }
 336         } else {
 337                 /*
 338                  * OK, we found it.  Did it find anything?
 339                  */
 340                 for (ai = res; ai != NULL; ai = ai->ai_next) {
 341                         /*
 342                          * Does it have an address?
 343                          */
 344                         if (ai->ai_addr != NULL) {
 345                                 /*
 346                                  * Yes.  Get a port number; we're done.
 347                                  */
 348                                 if (ai->ai_addr->sa_family == AF_INET) {
 349                                         in4 = (struct sockaddr_in *)ai->ai_addr;
 350                                         tcp_port = ntohs(in4->sin_port);
 351                                         break;
 352                                 }
 353 #ifdef INET6
 354                                 if (ai->ai_addr->sa_family == AF_INET6) {
 355                                         in6 = (struct sockaddr_in6 *)ai->ai_addr;
 356                                         tcp_port = ntohs(in6->sin6_port);
 357                                         break;
 358                                 }
 359 #endif
 360                         }
 361                 }
 362                 freeaddrinfo(res);
 363         }
 364
 365         memset(&hints, 0, sizeof(hints));
 366         hints.ai_family = PF_UNSPEC;
 367         hints.ai_socktype = SOCK_DGRAM;
 368         hints.ai_protocol = IPPROTO_UDP;
 369         error = getaddrinfo(NULL, name, &hints, &res);
 370         if (error != 0) {
 371                 if (error != EAI_NONAME &&
 372                     error != EAI_SERVICE) {
 373                         /*
 374                          * This is a real error, not just "there's
 375                          * no such service name".
 376                          * XXX - this doesn't return an error string.
 377                          */
 378                         return 0;
 379                 }
 380         } else {
 381                 /*
 382                  * OK, we found it.  Did it find anything?
 383                  */
 384                 for (ai = res; ai != NULL; ai = ai->ai_next) {
 385                         /*
 386                          * Does it have an address?
 387                          */
 388                         if (ai->ai_addr != NULL) {
 389                                 /*
 390                                  * Yes.  Get a port number; we're done.
 391                                  */
 392                                 if (ai->ai_addr->sa_family == AF_INET) {
 393                                         in4 = (struct sockaddr_in *)ai->ai_addr;
 394                                         udp_port = ntohs(in4->sin_port);
 395                                         break;
 396                                 }
 397 #ifdef INET6
 398                                 if (ai->ai_addr->sa_family == AF_INET6) {
 399                                         in6 = (struct sockaddr_in6 *)ai->ai_addr;
 400                                         udp_port = ntohs(in6->sin6_port);
 401                                         break;
 402                                 }
 403 #endif
 404                         }
 405                 }
 406                 freeaddrinfo(res);
 407         }
 408
 409         /*
 410          * We need to check /etc/services for ambiguous entries.
 411          * If we find an ambiguous entry, and it has the
 412          * same port number, change the proto to PROTO_UNDEF
 413          * so both TCP and UDP will be checked.
 414          */
 415         if (tcp_port >= 0) {
 416                 *port = tcp_port;
 417                 *proto = IPPROTO_TCP;
 418                 if (udp_port >= 0) {
 419                         if (udp_port == tcp_port)
 420                                 *proto = PROTO_UNDEF;
 421 #ifdef notdef
 422                         else
 423                                 /* Can't handle ambiguous names that refer
 424                                    to different port numbers. */
 425                                 warning("ambiguous port %s in /etc/services",
 426                                         name);
 427 #endif
 428                 }
 429                 return 1;
 430         }
 431         if (udp_port >= 0) {
 432                 *port = udp_port;
 433                 *proto = IPPROTO_UDP;
 434                 return 1;
 435         }
 436 #if defined(ultrix) || defined(__osf__)
 437         /* Special hack in case NFS isn't in /etc/services */
 438         if (strcmp(name, "nfs") == 0) {
 439                 *port = 2049;
 440                 *proto = PROTO_UNDEF;
 441                 return 1;
 442         }
 443 #endif
 444         return 0;
 445 }
 446
 447 /*
 448  * Convert a string in the form PPP-PPP, where correspond to ports, to
 449  * a starting and ending port in a port range.
 450  * Return 0 on failure.
 451  */
 452 int
 453 pcap_nametoportrange(const char *name, int *port1, int *port2, int *proto)
 454 {
 455         u_int p1, p2;
 456         char *off, *cpy;
 457         int save_proto;
 458
 459         if (sscanf(name, "%d-%d", &p1, &p2) != 2) {
 460                 if ((cpy = strdup(name)) == NULL)
 461                         return 0;
 462
 463                 if ((off = strchr(cpy, '-')) == NULL) {
 464                         free(cpy);
 465                         return 0;
 466                 }
 467
 468                 *off = '\0';
 469
 470                 if (pcap_nametoport(cpy, port1, proto) == 0) {
 471                         free(cpy);
 472                         return 0;
 473                 }
 474                 save_proto = *proto;
 475
 476                 if (pcap_nametoport(off + 1, port2, proto) == 0) {
 477                         free(cpy);
 478                         return 0;
 479                 }
 480                 free(cpy);
 481
 482                 if (*proto != save_proto)
 483                         *proto = PROTO_UNDEF;
 484         } else {
 485                 *port1 = p1;
 486                 *port2 = p2;
 487                 *proto = PROTO_UNDEF;
 488         }
 489
 490         return 1;
 491 }
 492
 493 /*
 494  * XXX - not guaranteed to be thread-safe!  See below for platforms
 495  * on which it is thread-safe and on which it isn't.
 496  */
 497 int
 498 pcap_nametoproto(const char *str)
 499 {
 500         struct protoent *p;
 501   #if defined(HAVE_LINUX_GETNETBYNAME_R)
 502         /*
 503          * We have Linux's reentrant getprotobyname_r().
 504          */
 505         struct protoent result_buf;
 506         char buf[1024]; /* arbitrary size */
 507         int err;
 508
 509         err = getprotobyname_r(str, &result_buf, buf, sizeof buf, &p);
 510         if (err != 0) {
 511                 /*
 512                  * XXX - dynamically allocate the buffer, and make it
 513                  * bigger if we get ERANGE back?
 514                  */
 515                 return 0;
 516         }
 517   #elif defined(HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
 518         /*
 519          * We have Solaris's and IRIX's reentrant getprotobyname_r().
 520          */
 521         struct protoent result_buf;
 522         char buf[1024]; /* arbitrary size */
 523
 524         p = getprotobyname_r(str, &result_buf, buf, (int)sizeof buf);
 525   #elif defined(HAVE_AIX_GETNETBYNAME_R)
 526         /*
 527          * We have AIX's reentrant getprotobyname_r().
 528          */
 529         struct protoent result_buf;
 530         struct protoent_data proto_data;
 531
 532         if (getprotobyname_r(str, &result_buf, &proto_data) == -1)
 533                 p = NULL;
 534         else
 535                 p = &result_buf;
 536   #else
 537         /*
 538          * We don't have any getprotobyname_r(); either we have a
 539          * getprotobyname() that uses thread-specific data, in which
 540          * case we're thread-safe (sufficiently recent FreeBSD,
 541          * sufficiently recent Darwin-based OS, sufficiently recent
 542          * HP-UX, sufficiently recent Tru64 UNIX, Windows), or we have
 543          * the traditional getprotobyname() (everything else, including
 544          * current NetBSD and OpenBSD), in which case we're not
 545          * thread-safe.
 546          */
 547         p = getprotobyname(str);
 548   #endif
 549         if (p != 0)
 550                 return p->p_proto;
 551         else
 552                 return PROTO_UNDEF;
 553 }
 554
 555 #include "ethertype.h"
 556
 557 struct eproto {
 558         const char *s;
 559         u_short p;
 560 };
 561
 562 /*
 563  * Static data base of ether protocol types.
 564  * tcpdump used to import this, and it's declared as an export on
 565  * Debian, at least, so make it a public symbol, even though we
 566  * don't officially export it by declaring it in a header file.
 567  * (Programs *should* do this themselves, as tcpdump now does.)
 568  *
 569  * We declare it here, right before defining it, to squelch any
 570  * warnings we might get from compilers about the lack of a
 571  * declaration.
 572  */
 573 PCAP_API struct eproto eproto_db[];
 574 PCAP_API_DEF struct eproto eproto_db[] = {
 575         { "pup", ETHERTYPE_PUP },
 576         { "xns", ETHERTYPE_NS },
 577         { "ip", ETHERTYPE_IP },
 578 #ifdef INET6
 579         { "ip6", ETHERTYPE_IPV6 },
 580 #endif
 581         { "arp", ETHERTYPE_ARP },
 582         { "rarp", ETHERTYPE_REVARP },
 583         { "sprite", ETHERTYPE_SPRITE },
 584         { "mopdl", ETHERTYPE_MOPDL },
 585         { "moprc", ETHERTYPE_MOPRC },
 586         { "decnet", ETHERTYPE_DN },
 587         { "lat", ETHERTYPE_LAT },
 588         { "sca", ETHERTYPE_SCA },
 589         { "lanbridge", ETHERTYPE_LANBRIDGE },
 590         { "vexp", ETHERTYPE_VEXP },
 591         { "vprod", ETHERTYPE_VPROD },
 592         { "atalk", ETHERTYPE_ATALK },
 593         { "atalkarp", ETHERTYPE_AARP },
 594         { "loopback", ETHERTYPE_LOOPBACK },
 595         { "decdts", ETHERTYPE_DECDTS },
 596         { "decdns", ETHERTYPE_DECDNS },
 597         { (char *)0, 0 }
 598 };
 599
 600 int
 601 pcap_nametoeproto(const char *s)
 602 {
 603         struct eproto *p = eproto_db;
 604
 605         while (p->s != 0) {
 606                 if (strcmp(p->s, s) == 0)
 607                         return p->p;
 608                 p += 1;
 609         }
 610         return PROTO_UNDEF;
 611 }
 612
 613 #include "llc.h"
 614
 615 /* Static data base of LLC values. */
 616 static struct eproto llc_db[] = {
 617         { "iso", LLCSAP_ISONS },
 618         { "stp", LLCSAP_8021D },
 619         { "ipx", LLCSAP_IPX },
 620         { "netbeui", LLCSAP_NETBEUI },
 621         { (char *)0, 0 }
 622 };
 623
 624 int
 625 pcap_nametollc(const char *s)
 626 {
 627         struct eproto *p = llc_db;
 628
 629         while (p->s != 0) {
 630                 if (strcmp(p->s, s) == 0)
 631                         return p->p;
 632                 p += 1;
 633         }
 634         return PROTO_UNDEF;
 635 }
 636
 637 /* Hex digit to 8-bit unsigned integer. */
 638 static inline u_char
 639 xdtoi(u_char c)
 640 {
 641         if (isdigit(c))
 642                 return (u_char)(c - '0');
 643         else if (islower(c))
 644                 return (u_char)(c - 'a' + 10);
 645         else
 646                 return (u_char)(c - 'A' + 10);
 647 }
 648
 649 int
 650 __pcap_atoin(const char *s, bpf_u_int32 *addr)
 651 {
 652         u_int n;
 653         int len;
 654
 655         *addr = 0;
 656         len = 0;
 657         for (;;) {
 658                 n = 0;
 659                 while (*s && *s != '.')
 660                         n = n * 10 + *s++ - '0';
 661                 *addr <<= 8;
 662                 *addr |= n & 0xff;
 663                 len += 8;
 664                 if (*s == '\0')
 665                         return len;
 666                 ++s;
 667         }
 668         /* NOTREACHED */
 669 }
 670
 671 int
 672 __pcap_atodn(const char *s, bpf_u_int32 *addr)
 673 {
 674 #define AREASHIFT 10
 675 #define AREAMASK 0176000
 676 #define NODEMASK 01777
 677
 678         u_int node, area;
 679
 680         if (sscanf(s, "%d.%d", &area, &node) != 2)
 681                 return(0);
 682
 683         *addr = (area << AREASHIFT) & AREAMASK;
 684         *addr |= (node & NODEMASK);
 685
 686         return(32);
 687 }
 688
 689 /*
 690  * Convert 's', which can have the one of the forms:
 691  *
 692  *      "xx:xx:xx:xx:xx:xx"
 693  *      "xx.xx.xx.xx.xx.xx"
 694  *      "xx-xx-xx-xx-xx-xx"
 695  *      "xxxx.xxxx.xxxx"
 696  *      "xxxxxxxxxxxx"
 697  *
 698  * (or various mixes of ':', '.', and '-') into a new
 699  * ethernet address.  Assumes 's' is well formed.
 700  */
 701 u_char *
 702 pcap_ether_aton(const char *s)
 703 {
 704         register u_char *ep, *e;
 705         register u_char d;
 706
 707         e = ep = (u_char *)malloc(6);
 708         if (e == NULL)
 709                 return (NULL);
 710
 711         while (*s) {
 712                 if (*s == ':' || *s == '.' || *s == '-')
 713                         s += 1;
 714                 d = xdtoi(*s++);
 715                 if (isxdigit((unsigned char)*s)) {
 716                         d <<= 4;
 717                         d |= xdtoi(*s++);
 718                 }
 719                 *ep++ = d;
 720         }
 721
 722         return (e);
 723 }
 724
 725 #ifndef HAVE_ETHER_HOSTTON
 726 /*
 727  * Roll our own.
 728  * XXX - not thread-safe, because pcap_next_etherent() isn't thread-
 729  * safe!  Needs a mutex or a thread-safe pcap_next_etherent().
 730  */
 731 u_char *
 732 pcap_ether_hostton(const char *name)
 733 {
 734         register struct pcap_etherent *ep;
 735         register u_char *ap;
 736         static FILE *fp = NULL;
 737         static int init = 0;
 738
 739         if (!init) {
 740                 fp = fopen(PCAP_ETHERS_FILE, "r");
 741                 ++init;
 742                 if (fp == NULL)
 743                         return (NULL);
 744         } else if (fp == NULL)
 745                 return (NULL);
 746         else
 747                 rewind(fp);
 748
 749         while ((ep = pcap_next_etherent(fp)) != NULL) {
 750                 if (strcmp(ep->name, name) == 0) {
 751                         ap = (u_char *)malloc(6);
 752                         if (ap != NULL) {
 753                                 memcpy(ap, ep->addr, 6);
 754                                 return (ap);
 755                         }
 756                         break;
 757                 }
 758         }
 759         return (NULL);
 760 }
 761 #else
 762 /*
 763  * Use the OS-supplied routine.
 764  * This *should* be thread-safe; the API doesn't have a static buffer.
 765  */
 766 u_char *
 767 pcap_ether_hostton(const char *name)
 768 {
 769         register u_char *ap;
 770         u_char a[6];
 771
 772         ap = NULL;
 773         if (ether_hostton(name, (struct ether_addr *)a) == 0) {
 774                 ap = (u_char *)malloc(6);
 775                 if (ap != NULL)
 776                         memcpy((char *)ap, (char *)a, 6);
 777         }
 778         return (ap);
 779 }
 780 #endif
 781
 782 /*
 783  * XXX - not guaranteed to be thread-safe!
 784  */
 785 int
 786 #ifdef  DECNETLIB
 787 __pcap_nametodnaddr(const char *name, u_short *res)
 788 {
 789         struct nodeent *getnodebyname();
 790         struct nodeent *nep;
 791
 792         nep = getnodebyname(name);
 793         if (nep == ((struct nodeent *)0))
 794                 return(0);
 795
 796         memcpy((char *)res, (char *)nep->n_addr, sizeof(unsigned short));
 797         return(1);
 798 #else
 799 __pcap_nametodnaddr(const char *name _U_, u_short *res _U_)
 800 {
 801         return(0);
 802 #endif
 803 }