libpcap  1.10.1
About: libpcap is a packet filter library used by tools like tcpdump.
  Fossies Dox: libpcap-1.10.1.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

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