nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright (c) 1994, 1995, 1996
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 the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the Computer Systems
16 * Engineering Group at Lawrence Berkeley Laboratory.
17 * 4. Neither the name of the University nor of the Laboratory may be used
18 * to endorse or promote products derived from this software without
19 * specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33  
34 #ifndef pcap_int_h
35 #define pcap_int_h
36  
37 #include <pcap/pcap.h>
38  
39 #ifdef __cplusplus
40 extern "C" {
41 #endif
42  
43 #ifdef WIN32
44 #include <Packet32.h>
45 extern CRITICAL_SECTION g_PcapCompileCriticalSection;
46 #endif /* WIN32 */
47  
48 #ifdef MSDOS
49 #include <fcntl.h>
50 #include <io.h>
51 #endif
52  
53 #if (defined(_MSC_VER) && (_MSC_VER <= 1200)) /* we are compiling with Visual Studio 6, that doesn't support the LL suffix*/
54  
55 /*
56 * Swap byte ordering of unsigned long long timestamp on a big endian
57 * machine.
58 */
59 #define SWAPLL(ull) ((ull & 0xff00000000000000) >> 56) | \
60 ((ull & 0x00ff000000000000) >> 40) | \
61 ((ull & 0x0000ff0000000000) >> 24) | \
62 ((ull & 0x000000ff00000000) >> 8) | \
63 ((ull & 0x00000000ff000000) << 8) | \
64 ((ull & 0x0000000000ff0000) << 24) | \
65 ((ull & 0x000000000000ff00) << 40) | \
66 ((ull & 0x00000000000000ff) << 56)
67  
68 #else /* A recent Visual studio compiler or not VC */
69  
70 /*
71 * Swap byte ordering of unsigned long long timestamp on a big endian
72 * machine.
73 */
74 #define SWAPLL(ull) ((ull & 0xff00000000000000LL) >> 56) | \
75 ((ull & 0x00ff000000000000LL) >> 40) | \
76 ((ull & 0x0000ff0000000000LL) >> 24) | \
77 ((ull & 0x000000ff00000000LL) >> 8) | \
78 ((ull & 0x00000000ff000000LL) << 8) | \
79 ((ull & 0x0000000000ff0000LL) << 24) | \
80 ((ull & 0x000000000000ff00LL) << 40) | \
81 ((ull & 0x00000000000000ffLL) << 56)
82  
83 #endif /* _MSC_VER */
84  
85 /*
86 * Maximum snapshot length.
87 *
88 * Somewhat arbitrary, but chosen to be:
89 *
90 * 1) big enough for maximum-size Linux loopback packets (65549)
91 * and some USB packets captured with USBPcap:
92 *
93 * http://desowin.org/usbpcap/
94 *
95 * (> 131072, < 262144)
96 *
97 * and
98 *
99 * 2) small enough not to cause attempts to allocate huge amounts of
100 * memory; some applications might use the snapshot length in a
101 * savefile header to control the size of the buffer they allocate,
102 * so a size of, say, 2^31-1 might not work well.
103 *
104 * We don't enforce this in pcap_set_snaplen(), but we use it internally.
105 */
106 #define MAXIMUM_SNAPLEN 262144
107  
108 struct pcap_opt {
109 char *source;
110 int timeout; /* timeout for buffering */
111 int buffer_size;
112 int promisc;
113 int rfmon; /* monitor mode */
114 int immediate; /* immediate mode - deliver packets as soon as they arrive */
115 int tstamp_type;
116 int tstamp_precision;
117 };
118  
119 typedef int (*activate_op_t)(pcap_t *);
120 typedef int (*can_set_rfmon_op_t)(pcap_t *);
121 typedef int (*read_op_t)(pcap_t *, int cnt, pcap_handler, u_char *);
122 typedef int (*inject_op_t)(pcap_t *, const void *, size_t);
123 typedef int (*setfilter_op_t)(pcap_t *, struct bpf_program *);
124 typedef int (*setdirection_op_t)(pcap_t *, pcap_direction_t);
125 typedef int (*set_datalink_op_t)(pcap_t *, int);
126 typedef int (*getnonblock_op_t)(pcap_t *, char *);
127 typedef int (*setnonblock_op_t)(pcap_t *, int, char *);
128 typedef int (*stats_op_t)(pcap_t *, struct pcap_stat *);
129 #ifdef WIN32
130 typedef int (*setbuff_op_t)(pcap_t *, int);
131 typedef int (*setmode_op_t)(pcap_t *, int);
132 typedef int (*setmintocopy_op_t)(pcap_t *, int);
133 typedef Adapter *(*getadapter_op_t)(pcap_t *);
134 #endif
135 typedef void (*cleanup_op_t)(pcap_t *);
136  
137 /*
138 * We put all the stuff used in the read code path at the beginning,
139 * to try to keep it together in the same cache line or lines.
140 */
141 struct pcap {
142 /*
143 * Method to call to read packets on a live capture.
144 */
145 read_op_t read_op;
146  
147 /*
148 * Method to call to read to read packets from a savefile.
149 */
150 int (*next_packet_op)(pcap_t *, struct pcap_pkthdr *, u_char **);
151  
152 #ifdef WIN32
153 ADAPTER *adapter;
154 LPPACKET Packet;
155 int nonblock;
156 #else
157 int fd;
158 int selectable_fd;
159 #endif /* WIN32 */
160  
161 /*
162 * Read buffer.
163 */
164 int bufsize;
165 u_char *buffer;
166 u_char *bp;
167 int cc;
168  
169 int break_loop; /* flag set to force break from packet-reading loop */
170  
171 void *priv; /* private data for methods */
172  
173 int swapped;
174 FILE *rfile; /* null if live capture, non-null if savefile */
175 int fddipad;
176 struct pcap *next; /* list of open pcaps that need stuff cleared on close */
177  
178 /*
179 * File version number; meaningful only for a savefile, but we
180 * keep it here so that apps that (mistakenly) ask for the
181 * version numbers will get the same zero values that they
182 * always did.
183 */
184 int version_major;
185 int version_minor;
186  
187 int snapshot;
188 int linktype; /* Network linktype */
189 int linktype_ext; /* Extended information stored in the linktype field of a file */
190 int tzoff; /* timezone offset */
191 int offset; /* offset for proper alignment */
192 int activated; /* true if the capture is really started */
193 int oldstyle; /* if we're opening with pcap_open_live() */
194  
195 struct pcap_opt opt;
196  
197 /*
198 * Place holder for pcap_next().
199 */
200 u_char *pkt;
201  
202 /* We're accepting only packets in this direction/these directions. */
203 pcap_direction_t direction;
204  
205 /*
206 * Flags to affect BPF code generation.
207 */
208 int bpf_codegen_flags;
209  
210 /*
211 * Placeholder for filter code if bpf not in kernel.
212 */
213 struct bpf_program fcode;
214  
215 char errbuf[PCAP_ERRBUF_SIZE + 1];
216 int dlt_count;
217 u_int *dlt_list;
218 int tstamp_type_count;
219 u_int *tstamp_type_list;
220 int tstamp_precision_count;
221 u_int *tstamp_precision_list;
222  
223 struct pcap_pkthdr pcap_header; /* This is needed for the pcap_next_ex() to work */
224  
225 /*
226 * More methods.
227 */
228 activate_op_t activate_op;
229 can_set_rfmon_op_t can_set_rfmon_op;
230 inject_op_t inject_op;
231 setfilter_op_t setfilter_op;
232 setdirection_op_t setdirection_op;
233 set_datalink_op_t set_datalink_op;
234 getnonblock_op_t getnonblock_op;
235 setnonblock_op_t setnonblock_op;
236 stats_op_t stats_op;
237  
238 /*
239 * Routine to use as callback for pcap_next()/pcap_next_ex().
240 */
241 pcap_handler oneshot_callback;
242  
243 #ifdef WIN32
244 /*
245 * These are, at least currently, specific to the Win32 NPF
246 * driver.
247 */
248 setbuff_op_t setbuff_op;
249 setmode_op_t setmode_op;
250 setmintocopy_op_t setmintocopy_op;
251 getadapter_op_t getadapter_op;
252 #endif
253 cleanup_op_t cleanup_op;
254 };
255  
256 /*
257 * BPF code generation flags.
258 */
259 #define BPF_SPECIAL_VLAN_HANDLING 0x00000001 /* special VLAN handling for Linux */
260  
261 /*
262 * This is a timeval as stored in a savefile.
263 * It has to use the same types everywhere, independent of the actual
264 * `struct timeval'; `struct timeval' has 32-bit tv_sec values on some
265 * platforms and 64-bit tv_sec values on other platforms, and writing
266 * out native `struct timeval' values would mean files could only be
267 * read on systems with the same tv_sec size as the system on which
268 * the file was written.
269 */
270  
271 struct pcap_timeval {
272 bpf_int32 tv_sec; /* seconds */
273 bpf_int32 tv_usec; /* microseconds */
274 };
275  
276 /*
277 * This is a `pcap_pkthdr' as actually stored in a savefile.
278 *
279 * Do not change the format of this structure, in any way (this includes
280 * changes that only affect the length of fields in this structure),
281 * and do not make the time stamp anything other than seconds and
282 * microseconds (e.g., seconds and nanoseconds). Instead:
283 *
284 * introduce a new structure for the new format;
285 *
286 * send mail to "tcpdump-workers@lists.tcpdump.org", requesting
287 * a new magic number for your new capture file format, and, when
288 * you get the new magic number, put it in "savefile.c";
289 *
290 * use that magic number for save files with the changed record
291 * header;
292 *
293 * make the code in "savefile.c" capable of reading files with
294 * the old record header as well as files with the new record header
295 * (using the magic number to determine the header format).
296 *
297 * Then supply the changes by forking the branch at
298 *
299 * https://github.com/the-tcpdump-group/libpcap/issues
300 *
301 * and issuing a pull request, so that future versions of libpcap and
302 * programs that use it (such as tcpdump) will be able to read your new
303 * capture file format.
304 */
305  
306 struct pcap_sf_pkthdr {
307 struct pcap_timeval ts; /* time stamp */
308 bpf_u_int32 caplen; /* length of portion present */
309 bpf_u_int32 len; /* length this packet (off wire) */
310 };
311  
312 /*
313 * How a `pcap_pkthdr' is actually stored in savefiles written
314 * by some patched versions of libpcap (e.g. the ones in Red
315 * Hat Linux 6.1 and 6.2).
316 *
317 * Do not change the format of this structure, in any way (this includes
318 * changes that only affect the length of fields in this structure).
319 * Instead, introduce a new structure, as per the above.
320 */
321  
322 struct pcap_sf_patched_pkthdr {
323 struct pcap_timeval ts; /* time stamp */
324 bpf_u_int32 caplen; /* length of portion present */
325 bpf_u_int32 len; /* length this packet (off wire) */
326 int index;
327 unsigned short protocol;
328 unsigned char pkt_type;
329 };
330  
331 /*
332 * User data structure for the one-shot callback used for pcap_next()
333 * and pcap_next_ex().
334 */
335 struct oneshot_userdata {
336 struct pcap_pkthdr *hdr;
337 const u_char **pkt;
338 pcap_t *pd;
339 };
340  
341 int yylex(void);
342  
343 #ifndef min
344 #define min(a, b) ((a) > (b) ? (b) : (a))
345 #endif
346  
347 /* XXX should these be in pcap.h? */
348 int pcap_offline_read(pcap_t *, int, pcap_handler, u_char *);
349 int pcap_read(pcap_t *, int cnt, pcap_handler, u_char *);
350  
351 #ifndef HAVE_STRLCPY
352 #define strlcpy(x, y, z) \
353 (strncpy((x), (y), (z)), \
354 ((z) <= 0 ? 0 : ((x)[(z) - 1] = '\0')), \
355 strlen((y)))
356 #endif
357  
358 #include <stdarg.h>
359  
360 #if !defined(HAVE_SNPRINTF)
361 #define snprintf pcap_snprintf
362 extern int snprintf (char *, size_t, const char *, ...);
363 #endif
364  
365 #if !defined(HAVE_VSNPRINTF)
366 #define vsnprintf pcap_vsnprintf
367 extern int vsnprintf (char *, size_t, const char *, va_list ap);
368 #endif
369  
370 /*
371 * Does the packet count argument to a module's read routine say
372 * "supply packets until you run out of packets"?
373 */
374 #define PACKET_COUNT_IS_UNLIMITED(count) ((count) <= 0)
375  
376 /*
377 * Routines that most pcap implementations can use for non-blocking mode.
378 */
379 #if !defined(WIN32) && !defined(MSDOS)
380 int pcap_getnonblock_fd(pcap_t *, char *);
381 int pcap_setnonblock_fd(pcap_t *p, int, char *);
382 #endif
383  
384 /*
385 * Internal interfaces for "pcap_create()".
386 *
387 * "pcap_create_interface()" is the routine to do a pcap_create on
388 * a regular network interface. There are multiple implementations
389 * of this, one for each platform type (Linux, BPF, DLPI, etc.),
390 * with the one used chosen by the configure script.
391 *
392 * "pcap_create_common()" allocates and fills in a pcap_t, for use
393 * by pcap_create routines.
394 */
395 pcap_t *pcap_create_interface(const char *, char *);
396 pcap_t *pcap_create_common(const char *, char *, size_t);
397 int pcap_do_addexit(pcap_t *);
398 void pcap_add_to_pcaps_to_close(pcap_t *);
399 void pcap_remove_from_pcaps_to_close(pcap_t *);
400 void pcap_cleanup_live_common(pcap_t *);
401 int pcap_not_initialized(pcap_t *);
402 int pcap_check_activated(pcap_t *);
403  
404 /*
405 * Internal interfaces for "pcap_findalldevs()".
406 *
407 * "pcap_findalldevs_interfaces()" finds interfaces using the
408 * "standard" mechanisms (SIOCGIFCONF, "getifaddrs()", etc.).
409 *
410 * "pcap_platform_finddevs()" is a platform-dependent routine to
411 * add devices not found by the "standard" mechanisms.
412 *
413 * "pcap_add_if()" adds an interface to the list of interfaces, for
414 * use by various "find interfaces" routines.
415 */
416 int pcap_findalldevs_interfaces(pcap_if_t **, char *);
417 int pcap_platform_finddevs(pcap_if_t **, char *);
418 int add_addr_to_iflist(pcap_if_t **, const char *, u_int, struct sockaddr *,
419 size_t, struct sockaddr *, size_t, struct sockaddr *, size_t,
420 struct sockaddr *, size_t, char *);
421 int add_addr_to_dev(pcap_if_t *, struct sockaddr *, size_t,
422 struct sockaddr *, size_t, struct sockaddr *, size_t,
423 struct sockaddr *dstaddr, size_t, char *errbuf);
424 int pcap_add_if(pcap_if_t **, const char *, u_int, const char *, char *);
425 struct sockaddr *dup_sockaddr(struct sockaddr *, size_t);
426 int add_or_find_if(pcap_if_t **, pcap_if_t **, const char *, u_int,
427 const char *, char *);
428  
429 /*
430 * Internal interfaces for "pcap_open_offline()".
431 *
432 * "pcap_open_offline_common()" allocates and fills in a pcap_t, for use
433 * by pcap_open_offline routines.
434 *
435 * "sf_cleanup()" closes the file handle associated with a pcap_t, if
436 * appropriate, and frees all data common to all modules for handling
437 * savefile types.
438 */
439 pcap_t *pcap_open_offline_common(char *ebuf, size_t size);
440 void sf_cleanup(pcap_t *p);
441  
442 /*
443 * Internal interfaces for both "pcap_create()" and routines that
444 * open savefiles.
445 *
446 * "pcap_oneshot()" is the standard one-shot callback for "pcap_next()"
447 * and "pcap_next_ex()".
448 */
449 void pcap_oneshot(u_char *, const struct pcap_pkthdr *, const u_char *);
450  
451 #ifdef WIN32
452 char *pcap_win32strerror(void);
453 #endif
454  
455 int install_bpf_program(pcap_t *, struct bpf_program *);
456  
457 int pcap_strcasecmp(const char *, const char *);
458  
459 #ifdef __cplusplus
460 }
461 #endif
462  
463 #endif