1 /*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
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
22 #include "varattrs.h"
23
24 #ifndef lint
25 static const char copyright[] _U_ =
26 "@(#) Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000\n\
27 The Regents of the University of California. All rights reserved.\n";
28 #endif
29
30 #ifdef HAVE_CONFIG_H
31 #include <config.h>
32 #endif
33
34 #include <pcap.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdarg.h>
39 #include <limits.h>
40 #ifdef _WIN32
41 #include "getopt.h"
42 #include "unix.h"
43 #else
44 #include <unistd.h>
45 #endif
46 #include <fcntl.h>
47 #include <errno.h>
48 #ifdef _WIN32
49 #include <winsock2.h>
50 #include <ws2tcpip.h>
51 #else
52 #include <sys/socket.h>
53 #include <arpa/inet.h>
54 #endif
55 #include <sys/types.h>
56 #include <sys/stat.h>
57
58 #include "pcap/funcattrs.h"
59
60 #define MAXIMUM_SNAPLEN 262144
61
62 #ifdef BDEBUG
63 /*
64 * We have pcap_set_optimizer_debug() and pcap_set_print_dot_graph() in
65 * libpcap; declare them (they're not declared by any libpcap header,
66 * because they're special hacks, only available if libpcap was configured
67 * to include them, and only intended for use by libpcap developers trying
68 * to debug the optimizer for filter expressions).
69 */
70 PCAP_API void pcap_set_optimizer_debug(int);
71 PCAP_API void pcap_set_print_dot_graph(int);
72 #endif
73
74 static char *program_name;
75
76 /* Forwards */
77 static void PCAP_NORETURN usage(void);
78 static void PCAP_NORETURN error(const char *, ...) PCAP_PRINTFLIKE(1, 2);
79 static void warn(const char *, ...) PCAP_PRINTFLIKE(1, 2);
80
81 /*
82 * On Windows, we need to open the file in binary mode, so that
83 * we get all the bytes specified by the size we get from "fstat()".
84 * On UNIX, that's not necessary. O_BINARY is defined on Windows;
85 * we define it as 0 if it's not defined, so it does nothing.
86 */
87 #ifndef O_BINARY
88 #define O_BINARY 0
89 #endif
90
91 static char *
read_infile(char * fname)92 read_infile(char *fname)
93 {
94 register int i, fd, cc;
95 register char *cp;
96 struct stat buf;
97
98 fd = open(fname, O_RDONLY|O_BINARY);
99 if (fd < 0)
100 error("can't open %s: %s", fname, pcap_strerror(errno));
101
102 if (fstat(fd, &buf) < 0)
103 error("can't stat %s: %s", fname, pcap_strerror(errno));
104
105 /*
106 * _read(), on Windows, has an unsigned int byte count and an
107 * int return value, so we can't handle a file bigger than
108 * INT_MAX - 1 bytes (and have no reason to do so; a filter *that*
109 * big will take forever to compile). (The -1 is for the '\0' at
110 * the end of the string.)
111 */
112 if (buf.st_size > INT_MAX - 1)
113 error("%s is larger than %d bytes; that's too large", fname,
114 INT_MAX - 1);
115 cp = malloc((u_int)buf.st_size + 1);
116 if (cp == NULL)
117 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
118 fname, pcap_strerror(errno));
119 cc = (int)read(fd, cp, (u_int)buf.st_size);
120 if (cc < 0)
121 error("read %s: %s", fname, pcap_strerror(errno));
122 if (cc != buf.st_size)
123 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
124
125 close(fd);
126 /* replace "# comment" with spaces */
127 for (i = 0; i < cc; i++) {
128 if (cp[i] == '#')
129 while (i < cc && cp[i] != '\n')
130 cp[i++] = ' ';
131 }
132 cp[cc] = '\0';
133 return (cp);
134 }
135
136 /* VARARGS */
137 static void
error(const char * fmt,...)138 error(const char *fmt, ...)
139 {
140 va_list ap;
141
142 (void)fprintf(stderr, "%s: ", program_name);
143 va_start(ap, fmt);
144 (void)vfprintf(stderr, fmt, ap);
145 va_end(ap);
146 if (*fmt) {
147 fmt += strlen(fmt);
148 if (fmt[-1] != '\n')
149 (void)fputc('\n', stderr);
150 }
151 exit(1);
152 /* NOTREACHED */
153 }
154
155 /* VARARGS */
156 static void
warn(const char * fmt,...)157 warn(const char *fmt, ...)
158 {
159 va_list ap;
160
161 (void)fprintf(stderr, "%s: WARNING: ", program_name);
162 va_start(ap, fmt);
163 (void)vfprintf(stderr, fmt, ap);
164 va_end(ap);
165 if (*fmt) {
166 fmt += strlen(fmt);
167 if (fmt[-1] != '\n')
168 (void)fputc('\n', stderr);
169 }
170 }
171
172 /*
173 * Copy arg vector into a new buffer, concatenating arguments with spaces.
174 */
175 static char *
copy_argv(register char ** argv)176 copy_argv(register char **argv)
177 {
178 register char **p;
179 register size_t len = 0;
180 char *buf;
181 char *src, *dst;
182
183 p = argv;
184 if (*p == 0)
185 return 0;
186
187 while (*p)
188 len += strlen(*p++) + 1;
189
190 buf = (char *)malloc(len);
191 if (buf == NULL)
192 error("copy_argv: malloc");
193
194 p = argv;
195 dst = buf;
196 while ((src = *p++) != NULL) {
197 while ((*dst++ = *src++) != '\0')
198 ;
199 dst[-1] = ' ';
200 }
201 dst[-1] = '\0';
202
203 return buf;
204 }
205
206 int
main(int argc,char ** argv)207 main(int argc, char **argv)
208 {
209 char *cp;
210 int op;
211 int dflag;
212 #ifdef BDEBUG
213 int gflag;
214 #endif
215 char *infile;
216 int Oflag;
217 int snaplen;
218 char *p;
219 int dlt;
220 int have_fcode = 0;
221 bpf_u_int32 netmask = PCAP_NETMASK_UNKNOWN;
222 char *cmdbuf;
223 pcap_t *pd;
224 struct bpf_program fcode;
225
226 #ifdef _WIN32
227 if (pcap_wsockinit() != 0)
228 return 1;
229 #endif /* _WIN32 */
230
231 dflag = 1;
232 #ifdef BDEBUG
233 gflag = 0;
234 #endif
235
236 infile = NULL;
237 Oflag = 1;
238 snaplen = MAXIMUM_SNAPLEN;
239
240 if ((cp = strrchr(argv[0], '/')) != NULL)
241 program_name = cp + 1;
242 else
243 program_name = argv[0];
244
245 opterr = 0;
246 while ((op = getopt(argc, argv, "dF:gm:Os:")) != -1) {
247 switch (op) {
248
249 case 'd':
250 ++dflag;
251 break;
252
253 case 'g':
254 #ifdef BDEBUG
255 ++gflag;
256 #else
257 error("libpcap and filtertest not built with optimizer debugging enabled");
258 #endif
259 break;
260
261 case 'F':
262 infile = optarg;
263 break;
264
265 case 'O':
266 Oflag = 0;
267 break;
268
269 case 'm': {
270 bpf_u_int32 addr;
271
272 switch (inet_pton(AF_INET, optarg, &addr)) {
273
274 case 0:
275 error("invalid netmask %s", optarg);
276 break;
277
278 case -1:
279 error("invalid netmask %s: %s", optarg,
280 pcap_strerror(errno));
281 break;
282
283 case 1:
284 netmask = addr;
285 break;
286 }
287 break;
288 }
289
290 case 's': {
291 char *end;
292 long long_snaplen;
293
294 long_snaplen = strtol(optarg, &end, 0);
295 if (optarg == end || *end != '\0'
296 || long_snaplen < 0
297 || long_snaplen > MAXIMUM_SNAPLEN)
298 error("invalid snaplen %s", optarg);
299 else {
300 if (snaplen == 0)
301 snaplen = MAXIMUM_SNAPLEN;
302 else
303 snaplen = (int)long_snaplen;
304 }
305 break;
306 }
307
308 default:
309 usage();
310 /* NOTREACHED */
311 }
312 }
313
314 if (optind >= argc) {
315 usage();
316 /* NOTREACHED */
317 }
318
319 dlt = pcap_datalink_name_to_val(argv[optind]);
320 if (dlt < 0) {
321 dlt = (int)strtol(argv[optind], &p, 10);
322 if (p == argv[optind] || *p != '\0')
323 error("invalid data link type %s", argv[optind]);
324 }
325
326 if (infile)
327 cmdbuf = read_infile(infile);
328 else
329 cmdbuf = copy_argv(&argv[optind+1]);
330
331 #ifdef BDEBUG
332 pcap_set_optimizer_debug(dflag);
333 pcap_set_print_dot_graph(gflag);
334 #endif
335
336 pd = pcap_open_dead(dlt, snaplen);
337 if (pd == NULL)
338 error("Can't open fake pcap_t");
339
340 if (pcap_compile(pd, &fcode, cmdbuf, Oflag, netmask) < 0)
341 error("%s", pcap_geterr(pd));
342
343 have_fcode = 1;
344 if (!bpf_validate(fcode.bf_insns, fcode.bf_len))
345 warn("Filter doesn't pass validation");
346
347 #ifdef BDEBUG
348 if (cmdbuf != NULL) {
349 // replace line feed with space
350 for (cp = cmdbuf; *cp != '\0'; ++cp) {
351 if (*cp == '\r' || *cp == '\n') {
352 *cp = ' ';
353 }
354 }
355 // only show machine code if BDEBUG defined, since dflag > 3
356 printf("machine codes for filter: %s\n", cmdbuf);
357 } else
358 printf("machine codes for empty filter:\n");
359 #endif
360
361 bpf_dump(&fcode, dflag);
362 free(cmdbuf);
363 if (have_fcode)
364 pcap_freecode (&fcode);
365 pcap_close(pd);
366 exit(0);
367 }
368
369 static void
usage(void)370 usage(void)
371 {
372 (void)fprintf(stderr, "%s, with %s\n", program_name,
373 pcap_lib_version());
374 (void)fprintf(stderr,
375 #ifdef BDEBUG
376 "Usage: %s [-dgO] [ -F file ] [ -m netmask] [ -s snaplen ] dlt [ expression ]\n",
377 #else
378 "Usage: %s [-dO] [ -F file ] [ -m netmask] [ -s snaplen ] dlt [ expression ]\n",
379 #endif
380 program_name);
381 exit(1);
382 }
383