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 <pcap-stdinc.h>
36
37 #ifdef INET6
38 /*
39 * To quote the MSDN page for getaddrinfo() at
40 *
41 * https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520(v=vs.85).aspx
42 *
43 * "Support for getaddrinfo on Windows 2000 and older versions
44 * The getaddrinfo function was added to the Ws2_32.dll on Windows XP and
45 * later. To execute an application that uses this function on earlier
46 * versions of Windows, then you need to include the Ws2tcpip.h and
47 * Wspiapi.h files. When the Wspiapi.h include file is added, the
48 * getaddrinfo function is defined to the WspiapiGetAddrInfo inline
49 * function in the Wspiapi.h file. At runtime, the WspiapiGetAddrInfo
50 * function is implemented in such a way that if the Ws2_32.dll or the
51 * Wship6.dll (the file containing getaddrinfo in the IPv6 Technology
52 * Preview for Windows 2000) does not include getaddrinfo, then a
53 * version of getaddrinfo is implemented inline based on code in the
54 * Wspiapi.h header file. This inline code will be used on older Windows
55 * platforms that do not natively support the getaddrinfo function."
56 *
57 * We use getaddrinfo(), so we include Wspiapi.h here. pcap-stdinc.h
58 * includes Ws2tcpip.h, so we don't need to include it ourselves.
59 */
60 #include <Wspiapi.h>
61 #endif
62
63 #else /* _WIN32 */
64
65 #include <sys/param.h>
66 #include <sys/types.h> /* concession to AIX */
67 #include <sys/socket.h>
68 #include <sys/time.h>
69
70 #include <netinet/in.h>
71 #endif /* _WIN32 */
72
73 #ifndef _WIN32
74 #ifdef HAVE_ETHER_HOSTTON
75 /*
76 * XXX - do we need any of this if <netinet/if_ether.h> doesn't declare
77 * ether_hostton()?
78 */
79 #ifdef HAVE_NETINET_IF_ETHER_H
80 struct mbuf; /* Squelch compiler warnings on some platforms for */
81 struct rtentry; /* declarations in <net/if.h> */
82 #include <net/if.h> /* for "struct ifnet" in "struct arpcom" on Solaris */
83 #include <netinet/if_ether.h>
84 #endif /* HAVE_NETINET_IF_ETHER_H */
85 #ifdef NETINET_ETHER_H_DECLARES_ETHER_HOSTTON
86 #include <netinet/ether.h>
87 #endif /* NETINET_ETHER_H_DECLARES_ETHER_HOSTTON */
88 #endif /* HAVE_ETHER_HOSTTON */
89 #include <arpa/inet.h>
90 #include <netdb.h>
91 #endif /* _WIN32 */
92
93 #include <ctype.h>
94 #include <errno.h>
95 #include <stdlib.h>
96 #include <string.h>
97 #include <stdio.h>
98
99 #include "pcap-int.h"
100
101 #include "gencode.h"
102 #include <pcap/namedb.h>
103 #include "nametoaddr.h"
104
105 #ifdef HAVE_OS_PROTO_H
106 #include "os-proto.h"
107 #endif
108
109 #ifndef NTOHL
110 #define NTOHL(x) (x) = ntohl(x)
111 #define NTOHS(x) (x) = ntohs(x)
112 #endif
113
114 static inline int xdtoi(int);
115
116 /*
117 * Convert host name to internet address.
118 * Return 0 upon failure.
119 */
120 bpf_u_int32 **
pcap_nametoaddr(const char * name)121 pcap_nametoaddr(const char *name)
122 {
123 #ifndef h_addr
124 static bpf_u_int32 *hlist[2];
125 #endif
126 bpf_u_int32 **p;
127 struct hostent *hp;
128
129 if ((hp = gethostbyname(name)) != NULL) {
130 #ifndef h_addr
131 hlist[0] = (bpf_u_int32 *)hp->h_addr;
132 NTOHL(hp->h_addr);
133 return hlist;
134 #else
135 for (p = (bpf_u_int32 **)hp->h_addr_list; *p; ++p)
136 NTOHL(**p);
137 return (bpf_u_int32 **)hp->h_addr_list;
138 #endif
139 }
140 else
141 return 0;
142 }
143
144 #ifdef INET6
145 struct addrinfo *
pcap_nametoaddrinfo(const char * name)146 pcap_nametoaddrinfo(const char *name)
147 {
148 struct addrinfo hints, *res;
149 int error;
150
151 memset(&hints, 0, sizeof(hints));
152 hints.ai_family = PF_UNSPEC;
153 hints.ai_socktype = SOCK_STREAM; /*not really*/
154 hints.ai_protocol = IPPROTO_TCP; /*not really*/
155 error = getaddrinfo(name, NULL, &hints, &res);
156 if (error)
157 return NULL;
158 else
159 return res;
160 }
161 #endif /*INET6*/
162
163 /*
164 * Convert net name to internet address.
165 * Return 0 upon failure.
166 */
167 bpf_u_int32
pcap_nametonetaddr(const char * name)168 pcap_nametonetaddr(const char *name)
169 {
170 #ifndef _WIN32
171 struct netent *np;
172
173 if ((np = getnetbyname(name)) != NULL)
174 return np->n_net;
175 else
176 return 0;
177 #else
178 /*
179 * There's no "getnetbyname()" on Windows.
180 *
181 * XXX - I guess we could use the BSD code to read
182 * C:\Windows\System32\drivers\etc/networks, assuming
183 * that's its home on all the versions of Windows
184 * we use, but that file probably just has the loopback
185 * network on 127/24 on 99 44/100% of Windows machines.
186 *
187 * (Heck, these days it probably just has that on 99 44/100%
188 * of *UN*X* machines.)
189 */
190 return 0;
191 #endif
192 }
193
194 /*
195 * Convert a port name to its port and protocol numbers.
196 * We assume only TCP or UDP.
197 * Return 0 upon failure.
198 */
199 int
pcap_nametoport(const char * name,int * port,int * proto)200 pcap_nametoport(const char *name, int *port, int *proto)
201 {
202 struct servent *sp;
203 int tcp_port = -1;
204 int udp_port = -1;
205
206 /*
207 * We need to check /etc/services for ambiguous entries.
208 * If we find the ambiguous entry, and it has the
209 * same port number, change the proto to PROTO_UNDEF
210 * so both TCP and UDP will be checked.
211 */
212 sp = getservbyname(name, "tcp");
213 if (sp != NULL) tcp_port = ntohs(sp->s_port);
214 sp = getservbyname(name, "udp");
215 if (sp != NULL) udp_port = ntohs(sp->s_port);
216 if (tcp_port >= 0) {
217 *port = tcp_port;
218 *proto = IPPROTO_TCP;
219 if (udp_port >= 0) {
220 if (udp_port == tcp_port)
221 *proto = PROTO_UNDEF;
222 #ifdef notdef
223 else
224 /* Can't handle ambiguous names that refer
225 to different port numbers. */
226 warning("ambiguous port %s in /etc/services",
227 name);
228 #endif
229 }
230 return 1;
231 }
232 if (udp_port >= 0) {
233 *port = udp_port;
234 *proto = IPPROTO_UDP;
235 return 1;
236 }
237 #if defined(ultrix) || defined(__osf__)
238 /* Special hack in case NFS isn't in /etc/services */
239 if (strcmp(name, "nfs") == 0) {
240 *port = 2049;
241 *proto = PROTO_UNDEF;
242 return 1;
243 }
244 #endif
245 return 0;
246 }
247
248 /*
249 * Convert a string in the form PPP-PPP, where correspond to ports, to
250 * a starting and ending port in a port range.
251 * Return 0 on failure.
252 */
253 int
pcap_nametoportrange(const char * name,int * port1,int * port2,int * proto)254 pcap_nametoportrange(const char *name, int *port1, int *port2, int *proto)
255 {
256 u_int p1, p2;
257 char *off, *cpy;
258 int save_proto;
259
260 if (sscanf(name, "%d-%d", &p1, &p2) != 2) {
261 if ((cpy = strdup(name)) == NULL)
262 return 0;
263
264 if ((off = strchr(cpy, '-')) == NULL) {
265 free(cpy);
266 return 0;
267 }
268
269 *off = '\0';
270
271 if (pcap_nametoport(cpy, port1, proto) == 0) {
272 free(cpy);
273 return 0;
274 }
275 save_proto = *proto;
276
277 if (pcap_nametoport(off + 1, port2, proto) == 0) {
278 free(cpy);
279 return 0;
280 }
281 free(cpy);
282
283 if (*proto != save_proto)
284 *proto = PROTO_UNDEF;
285 } else {
286 *port1 = p1;
287 *port2 = p2;
288 *proto = PROTO_UNDEF;
289 }
290
291 return 1;
292 }
293
294 int
pcap_nametoproto(const char * str)295 pcap_nametoproto(const char *str)
296 {
297 struct protoent *p;
298
299 p = getprotobyname(str);
300 if (p != 0)
301 return p->p_proto;
302 else
303 return PROTO_UNDEF;
304 }
305
306 #include "ethertype.h"
307
308 struct eproto {
309 const char *s;
310 u_short p;
311 };
312
313 /*
314 * Static data base of ether protocol types.
315 * tcpdump used to import this, and it's declared as an export on
316 * Debian, at least, so make it a public symbol, even though we
317 * don't officially export it by declaring it in a header file.
318 * (Programs *should* do this themselves, as tcpdump now does.)
319 */
320 PCAP_API_DEF struct eproto eproto_db[] = {
321 { "pup", ETHERTYPE_PUP },
322 { "xns", ETHERTYPE_NS },
323 { "ip", ETHERTYPE_IP },
324 #ifdef INET6
325 { "ip6", ETHERTYPE_IPV6 },
326 #endif
327 { "arp", ETHERTYPE_ARP },
328 { "rarp", ETHERTYPE_REVARP },
329 { "sprite", ETHERTYPE_SPRITE },
330 { "mopdl", ETHERTYPE_MOPDL },
331 { "moprc", ETHERTYPE_MOPRC },
332 { "decnet", ETHERTYPE_DN },
333 { "lat", ETHERTYPE_LAT },
334 { "sca", ETHERTYPE_SCA },
335 { "lanbridge", ETHERTYPE_LANBRIDGE },
336 { "vexp", ETHERTYPE_VEXP },
337 { "vprod", ETHERTYPE_VPROD },
338 { "atalk", ETHERTYPE_ATALK },
339 { "atalkarp", ETHERTYPE_AARP },
340 { "loopback", ETHERTYPE_LOOPBACK },
341 { "decdts", ETHERTYPE_DECDTS },
342 { "decdns", ETHERTYPE_DECDNS },
343 { (char *)0, 0 }
344 };
345
346 int
pcap_nametoeproto(const char * s)347 pcap_nametoeproto(const char *s)
348 {
349 struct eproto *p = eproto_db;
350
351 while (p->s != 0) {
352 if (strcmp(p->s, s) == 0)
353 return p->p;
354 p += 1;
355 }
356 return PROTO_UNDEF;
357 }
358
359 #include "llc.h"
360
361 /* Static data base of LLC values. */
362 static struct eproto llc_db[] = {
363 { "iso", LLCSAP_ISONS },
364 { "stp", LLCSAP_8021D },
365 { "ipx", LLCSAP_IPX },
366 { "netbeui", LLCSAP_NETBEUI },
367 { (char *)0, 0 }
368 };
369
370 int
pcap_nametollc(const char * s)371 pcap_nametollc(const char *s)
372 {
373 struct eproto *p = llc_db;
374
375 while (p->s != 0) {
376 if (strcmp(p->s, s) == 0)
377 return p->p;
378 p += 1;
379 }
380 return PROTO_UNDEF;
381 }
382
383 /* Hex digit to integer. */
384 static inline int
xdtoi(c)385 xdtoi(c)
386 register int c;
387 {
388 if (isdigit(c))
389 return c - '0';
390 else if (islower(c))
391 return c - 'a' + 10;
392 else
393 return c - 'A' + 10;
394 }
395
396 int
__pcap_atoin(const char * s,bpf_u_int32 * addr)397 __pcap_atoin(const char *s, bpf_u_int32 *addr)
398 {
399 u_int n;
400 int len;
401
402 *addr = 0;
403 len = 0;
404 while (1) {
405 n = 0;
406 while (*s && *s != '.')
407 n = n * 10 + *s++ - '0';
408 *addr <<= 8;
409 *addr |= n & 0xff;
410 len += 8;
411 if (*s == '\0')
412 return len;
413 ++s;
414 }
415 /* NOTREACHED */
416 }
417
418 int
__pcap_atodn(const char * s,bpf_u_int32 * addr)419 __pcap_atodn(const char *s, bpf_u_int32 *addr)
420 {
421 #define AREASHIFT 10
422 #define AREAMASK 0176000
423 #define NODEMASK 01777
424
425 u_int node, area;
426
427 if (sscanf(s, "%d.%d", &area, &node) != 2)
428 return(0);
429
430 *addr = (area << AREASHIFT) & AREAMASK;
431 *addr |= (node & NODEMASK);
432
433 return(32);
434 }
435
436 /*
437 * Convert 's', which can have the one of the forms:
438 *
439 * "xx:xx:xx:xx:xx:xx"
440 * "xx.xx.xx.xx.xx.xx"
441 * "xx-xx-xx-xx-xx-xx"
442 * "xxxx.xxxx.xxxx"
443 * "xxxxxxxxxxxx"
444 *
445 * (or various mixes of ':', '.', and '-') into a new
446 * ethernet address. Assumes 's' is well formed.
447 */
448 u_char *
pcap_ether_aton(const char * s)449 pcap_ether_aton(const char *s)
450 {
451 register u_char *ep, *e;
452 register u_int d;
453
454 e = ep = (u_char *)malloc(6);
455 if (e == NULL)
456 return (NULL);
457
458 while (*s) {
459 if (*s == ':' || *s == '.' || *s == '-')
460 s += 1;
461 d = xdtoi(*s++);
462 if (isxdigit((unsigned char)*s)) {
463 d <<= 4;
464 d |= xdtoi(*s++);
465 }
466 *ep++ = d;
467 }
468
469 return (e);
470 }
471
472 #ifndef HAVE_ETHER_HOSTTON
473 /* Roll our own */
474 u_char *
pcap_ether_hostton(const char * name)475 pcap_ether_hostton(const char *name)
476 {
477 register struct pcap_etherent *ep;
478 register u_char *ap;
479 static FILE *fp = NULL;
480 static int init = 0;
481
482 if (!init) {
483 fp = fopen(PCAP_ETHERS_FILE, "r");
484 ++init;
485 if (fp == NULL)
486 return (NULL);
487 } else if (fp == NULL)
488 return (NULL);
489 else
490 rewind(fp);
491
492 while ((ep = pcap_next_etherent(fp)) != NULL) {
493 if (strcmp(ep->name, name) == 0) {
494 ap = (u_char *)malloc(6);
495 if (ap != NULL) {
496 memcpy(ap, ep->addr, 6);
497 return (ap);
498 }
499 break;
500 }
501 }
502 return (NULL);
503 }
504 #else
505
506 #if !defined(HAVE_DECL_ETHER_HOSTTON) || !HAVE_DECL_ETHER_HOSTTON
507 #ifndef HAVE_STRUCT_ETHER_ADDR
508 struct ether_addr {
509 unsigned char ether_addr_octet[6];
510 };
511 #endif
512 extern int ether_hostton(const char *, struct ether_addr *);
513 #endif
514
515 /* Use the os supplied routines */
516 u_char *
pcap_ether_hostton(const char * name)517 pcap_ether_hostton(const char *name)
518 {
519 register u_char *ap;
520 u_char a[6];
521
522 ap = NULL;
523 if (ether_hostton(name, (struct ether_addr *)a) == 0) {
524 ap = (u_char *)malloc(6);
525 if (ap != NULL)
526 memcpy((char *)ap, (char *)a, 6);
527 }
528 return (ap);
529 }
530 #endif
531
532 int
__pcap_nametodnaddr(const char * name,u_short * res)533 __pcap_nametodnaddr(const char *name, u_short *res)
534 {
535 #ifdef DECNETLIB
536 struct nodeent *getnodebyname();
537 struct nodeent *nep;
538
539 nep = getnodebyname(name);
540 if (nep == ((struct nodeent *)0))
541 return(0);
542
543 memcpy((char *)res, (char *)nep->n_addr, sizeof(unsigned short));
544 return(1);
545 #else
546 return(0);
547 #endif
548 }
549