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)  

filtertest.c
Go to the documentation of this file.
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 *
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
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
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 *
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
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;
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,
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
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 }
u_int bpf_u_int32
Definition: bpf.h:98
void bpf_dump(const struct bpf_program *p, int option)
Definition: bpf_dump.c:32
int bpf_validate(const struct bpf_insn *f, int len)
Definition: bpf_filter.c:543
static pcap_t * pd
Definition: capturetest.c:63
#define MAXIMUM_SNAPLEN
Definition: filtertest.c:60
static char * copy_argv(register char **argv)
Definition: filtertest.c:176
static void error(const char *,...)
Definition: filtertest.c:138
static char * program_name
Definition: filtertest.c:74
static const char copyright[]
Definition: filtertest.c:25
#define O_BINARY
Definition: filtertest.c:88
int main(int argc, char **argv)
Definition: filtertest.c:207
static void warn(const char *,...)
Definition: filtertest.c:157
static void usage(void)
Definition: filtertest.c:370
static char * read_infile(char *fname)
Definition: filtertest.c:92
#define PCAP_NORETURN
Definition: funcattrs.h:248
#define PCAP_API
Definition: funcattrs.h:147
#define PCAP_PRINTFLIKE(x, y)
Definition: funcattrs.h:270
int pcap_compile(pcap_t *p, struct bpf_program *program, const char *buf, int optimize, bpf_u_int32 mask)
Definition: gencode.c:724
void pcap_freecode(struct bpf_program *program)
Definition: gencode.c:900
int optind
Definition: getopt.c:45
char * optarg
Definition: getopt.c:48
int opterr
Definition: getopt.c:44
int getopt(int, char *const *, const char *)
Definition: getopt.c:59
long strtol(const char *, char **, int)
int read(int, char *, u_int)
int fstat(int, struct stat *)
int printf(const char *,...)
int close(int)
const char * pcap_lib_version(void)
Definition: pcap-bpf.c:3590
#define _U_
Definition: pcap-dos.h:93
int errno
struct pcap_stat stat
Definition: pcap-septel.c:51
#define PCAP_NETMASK_UNKNOWN
Definition: pcap.h:365
const char * pcap_strerror(int errnum)
Definition: pcap.c:3669
int pcap_datalink_name_to_val(const char *name)
Definition: pcap.c:3308
pcap_t * pcap_open_dead(int linktype, int snaplen)
Definition: pcap.c:4408
char * pcap_geterr(pcap_t *p)
Definition: pcap.c:3505
void pcap_close(pcap_t *p)
Definition: pcap.c:4065
struct bpf_insn * bf_insns
Definition: bpf.h:119
u_int bf_len
Definition: bpf.h:118
Definition: pcap-int.h:200