mirror of
https://git.rtems.org/rtems-libbsd/
synced 2025-10-14 00:38:39 +08:00
Update libpcap to FreeBSD head 2017-04-04
Update libpcap from Git mirror commit 99a648a912e81e29d9c4c159cbbe263462f2d719 to 642b174daddbd0efd9bb5f242c43f4ab4db6869f.
This commit is contained in:
Sebastian Huber
@@ -37,6 +37,11 @@ GENERATED += $(LOCAL_SRC)/rtwn-rtl8188eufw.c
|
||||
GENERATED += $(LOCAL_SRC)/runfw.c
|
||||
GENERATED += rtemsbsd/include/machine/rtems-bsd-regdomain.h
|
||||
GENERATED += rtemsbsd/rtems/rtems-bsd-regdomain.c
|
||||
GENERATED += freebsd/contrib/libpcap/grammar.h
|
||||
GENERATED += freebsd/contrib/libpcap/grammar.c
|
||||
GENERATED += freebsd/contrib/libpcap/pcap_version.h
|
||||
GENERATED += freebsd/contrib/libpcap/scanner.h
|
||||
GENERATED += freebsd/contrib/libpcap/scanner.c
|
||||
|
||||
all: $(GENERATED)
|
||||
|
||||
@@ -198,5 +203,22 @@ rtemsbsd/include/machine/rtems-bsd-regdomain.h: $(FREEBSD_SRC)/etc/regdomain.xml
|
||||
rtemsbsd/rtems/rtems-bsd-regdomain.c: $(FREEBSD_SRC)/etc/regdomain.xml
|
||||
rtems-bin2c -C $< $@
|
||||
|
||||
freebsd/contrib/libpcap/grammar.h: freebsd/contrib/libpcap/grammar.c
|
||||
|
||||
freebsd/contrib/libpcap/grammar.c: freebsd-org/contrib/libpcap/grammar.y
|
||||
cd freebsd-org/contrib/libpcap && yacc -p pcap_ -o grammar.c -d grammar.y
|
||||
mv freebsd-org/contrib/libpcap/grammar.h freebsd/contrib/libpcap/grammar.h
|
||||
mv freebsd-org/contrib/libpcap/grammar.c $@
|
||||
|
||||
freebsd/contrib/libpcap/pcap_version.h: freebsd-org/contrib/libpcap/VERSION
|
||||
freebsd-org/contrib/libpcap/gen_version_header.sh $< freebsd-org/contrib/libpcap/pcap_version.h.in $@
|
||||
|
||||
freebsd/contrib/libpcap/scanner.h: freebsd/contrib/libpcap/scanner.c
|
||||
|
||||
freebsd/contrib/libpcap/scanner.c: freebsd-org/contrib/libpcap/scanner.l
|
||||
cd freebsd-org/contrib/libpcap && lex -P pcap_ --header-file=scanner.h --nounput -o scanner.c scanner.l
|
||||
mv freebsd-org/contrib/libpcap/scanner.h freebsd/contrib/libpcap/scanner.h
|
||||
mv freebsd-org/contrib/libpcap/scanner.c $@
|
||||
|
||||
clean:
|
||||
rm $(GENERATED)
|
||||
|
||||
@@ -30,8 +30,6 @@
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Id: arcnet.h,v 1.2 2001-04-24 02:17:52 guy Exp $ (LBL)
|
||||
*
|
||||
* from: NetBSD: if_arc.h,v 1.13 1999/11/19 20:41:19 thorpej Exp
|
||||
*/
|
||||
|
||||
|
||||
@@ -28,8 +28,6 @@
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/atmuni31.h,v 1.3 2007-10-22 19:28:58 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/* Based on UNI3.1 standard by ATM Forum */
|
||||
|
||||
@@ -21,18 +21,13 @@
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/bpf_image.c,v 1.28 2008-01-02 04:16:46 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
@@ -42,7 +37,7 @@ static const char rcsid[] _U_ =
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
@@ -55,7 +50,7 @@ static const char rcsid[] _U_ =
|
||||
|
||||
char *
|
||||
bpf_image(p, n)
|
||||
struct bpf_insn *p;
|
||||
const struct bpf_insn *p;
|
||||
int n;
|
||||
{
|
||||
int v;
|
||||
@@ -218,6 +213,11 @@ bpf_image(p, n)
|
||||
fmt = "x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_MOD|BPF_X:
|
||||
op = "mod";
|
||||
fmt = "x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_AND|BPF_X:
|
||||
op = "and";
|
||||
fmt = "x";
|
||||
@@ -228,6 +228,11 @@ bpf_image(p, n)
|
||||
fmt = "x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_XOR|BPF_X:
|
||||
op = "xor";
|
||||
fmt = "x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_LSH|BPF_X:
|
||||
op = "lsh";
|
||||
fmt = "x";
|
||||
@@ -258,6 +263,11 @@ bpf_image(p, n)
|
||||
fmt = "#%d";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_MOD|BPF_K:
|
||||
op = "mod";
|
||||
fmt = "#%d";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_AND|BPF_K:
|
||||
op = "and";
|
||||
fmt = "#0x%x";
|
||||
@@ -268,6 +278,11 @@ bpf_image(p, n)
|
||||
fmt = "#0x%x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_XOR|BPF_K:
|
||||
op = "xor";
|
||||
fmt = "#0x%x";
|
||||
break;
|
||||
|
||||
case BPF_ALU|BPF_LSH|BPF_K:
|
||||
op = "lsh";
|
||||
fmt = "#%d";
|
||||
@@ -293,13 +308,13 @@ bpf_image(p, n)
|
||||
fmt = "";
|
||||
break;
|
||||
}
|
||||
(void)snprintf(operand, sizeof operand, fmt, v);
|
||||
(void)pcap_snprintf(operand, sizeof operand, fmt, v);
|
||||
if (BPF_CLASS(p->code) == BPF_JMP && BPF_OP(p->code) != BPF_JA) {
|
||||
(void)snprintf(image, sizeof image,
|
||||
(void)pcap_snprintf(image, sizeof image,
|
||||
"(%03d) %-8s %-16s jt %d\tjf %d",
|
||||
n, op, operand, n + 1 + p->jt, n + 1 + p->jf);
|
||||
} else {
|
||||
(void)snprintf(image, sizeof image,
|
||||
(void)pcap_snprintf(image, sizeof image,
|
||||
"(%03d) %-8s %s",
|
||||
n, op, operand);
|
||||
}
|
||||
|
||||
@@ -21,18 +21,13 @@
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/etherent.c,v 1.23 2006-10-04 18:09:22 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
@@ -42,7 +37,7 @@ static const char rcsid[] _U_ =
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <memory.h>
|
||||
|
||||
@@ -17,8 +17,6 @@
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/ethertype.h,v 1.14 2005-09-05 09:06:58 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -114,6 +112,9 @@
|
||||
#ifndef ETHERTYPE_PPPOES
|
||||
#define ETHERTYPE_PPPOES 0x8864
|
||||
#endif
|
||||
#ifndef ETHERTYPE_8021AD
|
||||
#define ETHERTYPE_8021AD 0x88a8
|
||||
#endif
|
||||
#ifndef ETHERTYPE_LOOPBACK
|
||||
#define ETHERTYPE_LOOPBACK 0x9000
|
||||
#endif
|
||||
|
||||
221
freebsd/contrib/libpcap/extract.h
Normal file
221
freebsd/contrib/libpcap/extract.h
Normal file
@@ -0,0 +1,221 @@
|
||||
/*
|
||||
* Copyright (c) 1992, 1993, 1994, 1995, 1996
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that: (1) source code distributions
|
||||
* retain the above copyright notice and this paragraph in its entirety, (2)
|
||||
* distributions including binary code include the above copyright notice and
|
||||
* this paragraph in its entirety in the documentation or other materials
|
||||
* provided with the distribution, and (3) all advertising materials mentioning
|
||||
* features or use of this software display the following acknowledgement:
|
||||
* ``This product includes software developed by the University of California,
|
||||
* Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
|
||||
* the University nor the names of its contributors may be used to endorse
|
||||
* or promote products derived from this software without specific prior
|
||||
* written permission.
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*/
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <arpa/inet.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Macros to extract possibly-unaligned big-endian integral values.
|
||||
*/
|
||||
#ifdef LBL_ALIGN
|
||||
/*
|
||||
* The processor doesn't natively handle unaligned loads.
|
||||
*/
|
||||
#if defined(__GNUC__) && defined(HAVE___ATTRIBUTE__) && \
|
||||
(defined(__alpha) || defined(__alpha__) || \
|
||||
defined(__mips) || defined(__mips__))
|
||||
|
||||
/*
|
||||
* This is a GCC-compatible compiler and we have __attribute__, which
|
||||
* we assume that mean we have __attribute__((packed)), and this is
|
||||
* MIPS or Alpha, which has instructions that can help when doing
|
||||
* unaligned loads.
|
||||
*
|
||||
* Declare packed structures containing a uint16_t and a uint32_t,
|
||||
* cast the pointer to point to one of those, and fetch through it;
|
||||
* the GCC manual doesn't appear to explicitly say that
|
||||
* __attribute__((packed)) causes the compiler to generate unaligned-safe
|
||||
* code, but it apppears to do so.
|
||||
*
|
||||
* We do this in case the compiler can generate code using those
|
||||
* instructions to do an unaligned load and pass stuff to "ntohs()" or
|
||||
* "ntohl()", which might be better than than the code to fetch the
|
||||
* bytes one at a time and assemble them. (That might not be the
|
||||
* case on a little-endian platform, such as DEC's MIPS machines and
|
||||
* Alpha machines, where "ntohs()" and "ntohl()" might not be done
|
||||
* inline.)
|
||||
*
|
||||
* We do this only for specific architectures because, for example,
|
||||
* at least some versions of GCC, when compiling for 64-bit SPARC,
|
||||
* generate code that assumes alignment if we do this.
|
||||
*
|
||||
* XXX - add other architectures and compilers as possible and
|
||||
* appropriate.
|
||||
*
|
||||
* HP's C compiler, indicated by __HP_cc being defined, supports
|
||||
* "#pragma unaligned N" in version A.05.50 and later, where "N"
|
||||
* specifies a number of bytes at which the typedef on the next
|
||||
* line is aligned, e.g.
|
||||
*
|
||||
* #pragma unalign 1
|
||||
* typedef uint16_t unaligned_uint16_t;
|
||||
*
|
||||
* to define unaligned_uint16_t as a 16-bit unaligned data type.
|
||||
* This could be presumably used, in sufficiently recent versions of
|
||||
* the compiler, with macros similar to those below. This would be
|
||||
* useful only if that compiler could generate better code for PA-RISC
|
||||
* or Itanium than would be generated by a bunch of shifts-and-ORs.
|
||||
*
|
||||
* DEC C, indicated by __DECC being defined, has, at least on Alpha,
|
||||
* an __unaligned qualifier that can be applied to pointers to get the
|
||||
* compiler to generate code that does unaligned loads and stores when
|
||||
* dereferencing the pointer in question.
|
||||
*
|
||||
* XXX - what if the native C compiler doesn't support
|
||||
* __attribute__((packed))? How can we get it to generate unaligned
|
||||
* accesses for *specific* items?
|
||||
*/
|
||||
typedef struct {
|
||||
uint16_t val;
|
||||
} __attribute__((packed)) unaligned_uint16_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t val;
|
||||
} __attribute__((packed)) unaligned_uint32_t;
|
||||
|
||||
static inline uint16_t
|
||||
EXTRACT_16BITS(const void *p)
|
||||
{
|
||||
return ((uint16_t)ntohs(((const unaligned_uint16_t *)(p))->val));
|
||||
}
|
||||
|
||||
static inline uint32_t
|
||||
EXTRACT_32BITS(const void *p)
|
||||
{
|
||||
return ((uint32_t)ntohl(((const unaligned_uint32_t *)(p))->val));
|
||||
}
|
||||
|
||||
static inline uint64_t
|
||||
EXTRACT_64BITS(const void *p)
|
||||
{
|
||||
return ((uint64_t)(((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 0)->val)) << 32 | \
|
||||
((uint64_t)ntohl(((const unaligned_uint32_t *)(p) + 1)->val)) << 0));
|
||||
}
|
||||
|
||||
#else /* have to do it a byte at a time */
|
||||
/*
|
||||
* This isn't a GCC-compatible compiler, we don't have __attribute__,
|
||||
* or we do but we don't know of any better way with this instruction
|
||||
* set to do unaligned loads, so do unaligned loads of big-endian
|
||||
* quantities the hard way - fetch the bytes one at a time and
|
||||
* assemble them.
|
||||
*/
|
||||
#define EXTRACT_16BITS(p) \
|
||||
((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 0)) << 8) | \
|
||||
((uint16_t)(*((const uint8_t *)(p) + 1)) << 0)))
|
||||
#define EXTRACT_32BITS(p) \
|
||||
((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 24) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 1)) << 16) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 2)) << 8) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 3)) << 0)))
|
||||
#define EXTRACT_64BITS(p) \
|
||||
((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 56) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 1)) << 48) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 2)) << 40) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 3)) << 32) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 4)) << 24) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 5)) << 16) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 6)) << 8) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 7)) << 0)))
|
||||
#endif /* must special-case unaligned accesses */
|
||||
#else /* LBL_ALIGN */
|
||||
/*
|
||||
* The processor natively handles unaligned loads, so we can just
|
||||
* cast the pointer and fetch through it.
|
||||
*/
|
||||
static inline uint16_t
|
||||
EXTRACT_16BITS(const void *p)
|
||||
{
|
||||
return ((uint16_t)ntohs(*(const uint16_t *)(p)));
|
||||
}
|
||||
|
||||
static inline uint32_t
|
||||
EXTRACT_32BITS(const void *p)
|
||||
{
|
||||
return ((uint32_t)ntohl(*(const uint32_t *)(p)));
|
||||
}
|
||||
|
||||
static inline uint64_t
|
||||
EXTRACT_64BITS(const void *p)
|
||||
{
|
||||
return ((uint64_t)(((uint64_t)ntohl(*((const uint32_t *)(p) + 0))) << 32 | \
|
||||
((uint64_t)ntohl(*((const uint32_t *)(p) + 1))) << 0));
|
||||
|
||||
}
|
||||
|
||||
#endif /* LBL_ALIGN */
|
||||
|
||||
#define EXTRACT_24BITS(p) \
|
||||
((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 0)) << 16) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 2)) << 0)))
|
||||
|
||||
#define EXTRACT_40BITS(p) \
|
||||
((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 32) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 1)) << 24) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 3)) << 8) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 4)) << 0)))
|
||||
|
||||
#define EXTRACT_48BITS(p) \
|
||||
((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 40) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 1)) << 32) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 2)) << 24) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 3)) << 16) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 4)) << 8) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 5)) << 0)))
|
||||
|
||||
#define EXTRACT_56BITS(p) \
|
||||
((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 0)) << 48) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 1)) << 40) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 2)) << 32) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 4)) << 16) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 5)) << 8) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 6)) << 0)))
|
||||
|
||||
/*
|
||||
* Macros to extract possibly-unaligned little-endian integral values.
|
||||
* XXX - do loads on little-endian machines that support unaligned loads?
|
||||
*/
|
||||
#define EXTRACT_LE_8BITS(p) (*(p))
|
||||
#define EXTRACT_LE_16BITS(p) \
|
||||
((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
|
||||
((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
|
||||
#define EXTRACT_LE_32BITS(p) \
|
||||
((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
|
||||
#define EXTRACT_LE_24BITS(p) \
|
||||
((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
|
||||
((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
|
||||
#define EXTRACT_LE_64BITS(p) \
|
||||
((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
|
||||
((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
|
||||
@@ -34,11 +34,6 @@
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/fad-getad.c,v 1.12 2007-09-14 00:44:55 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
@@ -62,9 +57,15 @@ static const char rcsid[] _U_ =
|
||||
#include "os-proto.h"
|
||||
#endif
|
||||
|
||||
#ifdef AF_PACKET
|
||||
/*
|
||||
* We don't do this on Solaris 11 and later, as it appears there aren't
|
||||
* any AF_PACKET addresses on interfaces, so we don't need this, and
|
||||
* we end up including both the OS's <net/bpf.h> and our <pcap/bpf.h>,
|
||||
* and their definitions of some data structures collide.
|
||||
*/
|
||||
#if (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET)
|
||||
# ifdef HAVE_NETPACKET_PACKET_H
|
||||
/* Solaris 11 and later, Linux distributions with newer glibc */
|
||||
/* Linux distributions with newer glibc */
|
||||
# include <netpacket/packet.h>
|
||||
# else /* HAVE_NETPACKET_PACKET_H */
|
||||
/* LynxOS, Linux distributions with older glibc */
|
||||
@@ -77,7 +78,7 @@ static const char rcsid[] _U_ =
|
||||
# include <linux/if_packet.h>
|
||||
# endif /* __Lynx__ */
|
||||
# endif /* HAVE_NETPACKET_PACKET_H */
|
||||
#endif /* AF_PACKET */
|
||||
#endif /* (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET) */
|
||||
|
||||
/*
|
||||
* This is fun.
|
||||
@@ -122,7 +123,7 @@ get_sa_len(struct sockaddr *addr)
|
||||
return (sizeof (struct sockaddr_in6));
|
||||
#endif
|
||||
|
||||
#ifdef AF_PACKET
|
||||
#if (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET)
|
||||
case AF_PACKET:
|
||||
return (sizeof (struct sockaddr_ll));
|
||||
#endif
|
||||
@@ -142,10 +143,11 @@ get_sa_len(struct sockaddr *addr)
|
||||
* Get a list of all interfaces that are up and that we can open.
|
||||
* Returns -1 on error, 0 otherwise.
|
||||
* The list, as returned through "alldevsp", may be null if no interfaces
|
||||
* were up and could be opened.
|
||||
* could be opened.
|
||||
*/
|
||||
int
|
||||
pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
|
||||
pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf,
|
||||
int (*check_usable)(const char *))
|
||||
{
|
||||
pcap_if_t *devlist = NULL;
|
||||
struct ifaddrs *ifap, *ifa;
|
||||
@@ -158,10 +160,10 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
|
||||
* Get the list of interface addresses.
|
||||
*
|
||||
* Note: this won't return information about interfaces
|
||||
* with no addresses; are there any such interfaces
|
||||
* that would be capable of receiving packets?
|
||||
* (Interfaces incapable of receiving packets aren't
|
||||
* very interesting from libpcap's point of view.)
|
||||
* with no addresses, so, if a platform has interfaces
|
||||
* with no interfaces on which traffic can be captured,
|
||||
* we must check for those interfaces as well (see, for
|
||||
* example, what's done on Linux).
|
||||
*
|
||||
* LAN interfaces will probably have link-layer
|
||||
* addresses; I don't know whether all implementations
|
||||
@@ -169,67 +171,11 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
|
||||
* those.
|
||||
*/
|
||||
if (getifaddrs(&ifap) != 0) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"getifaddrs: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
|
||||
/*
|
||||
* Is this interface up?
|
||||
*/
|
||||
if (!(ifa->ifa_flags & IFF_UP)) {
|
||||
/*
|
||||
* No, so don't add it to the list.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* "ifa_addr" was apparently null on at least one
|
||||
* interface on some system.
|
||||
*
|
||||
* "ifa_broadaddr" may be non-null even on
|
||||
* non-broadcast interfaces, and was null on
|
||||
* at least one OpenBSD 3.4 system on at least
|
||||
* one interface with IFF_BROADCAST set.
|
||||
*
|
||||
* "ifa_dstaddr" was, on at least one FreeBSD 4.1
|
||||
* system, non-null on a non-point-to-point
|
||||
* interface.
|
||||
*
|
||||
* Therefore, we supply the address and netmask only
|
||||
* if "ifa_addr" is non-null (if there's no address,
|
||||
* there's obviously no netmask), and supply the
|
||||
* broadcast and destination addresses if the appropriate
|
||||
* flag is set *and* the appropriate "ifa_" entry doesn't
|
||||
* evaluate to a null pointer.
|
||||
*/
|
||||
if (ifa->ifa_addr != NULL) {
|
||||
addr = ifa->ifa_addr;
|
||||
addr_size = SA_LEN(addr);
|
||||
netmask = ifa->ifa_netmask;
|
||||
} else {
|
||||
addr = NULL;
|
||||
addr_size = 0;
|
||||
netmask = NULL;
|
||||
}
|
||||
if (ifa->ifa_flags & IFF_BROADCAST &&
|
||||
ifa->ifa_broadaddr != NULL) {
|
||||
broadaddr = ifa->ifa_broadaddr;
|
||||
broadaddr_size = SA_LEN(broadaddr);
|
||||
} else {
|
||||
broadaddr = NULL;
|
||||
broadaddr_size = 0;
|
||||
}
|
||||
if (ifa->ifa_flags & IFF_POINTOPOINT &&
|
||||
ifa->ifa_dstaddr != NULL) {
|
||||
dstaddr = ifa->ifa_dstaddr;
|
||||
dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
|
||||
} else {
|
||||
dstaddr = NULL;
|
||||
dstaddr_size = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If this entry has a colon followed by a number at
|
||||
* the end, we assume it's a logical interface. Those
|
||||
@@ -259,11 +205,71 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Can we capture on this device?
|
||||
*/
|
||||
if (!(*check_usable)(ifa->ifa_name)) {
|
||||
/*
|
||||
* No.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* "ifa_addr" was apparently null on at least one
|
||||
* interface on some system. Therefore, we supply
|
||||
* the address and netmask only if "ifa_addr" is
|
||||
* non-null (if there's no address, there's obviously
|
||||
* no netmask).
|
||||
*/
|
||||
if (ifa->ifa_addr != NULL) {
|
||||
addr = ifa->ifa_addr;
|
||||
addr_size = SA_LEN(addr);
|
||||
netmask = ifa->ifa_netmask;
|
||||
} else {
|
||||
addr = NULL;
|
||||
addr_size = 0;
|
||||
netmask = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Note that, on some platforms, ifa_broadaddr and
|
||||
* ifa_dstaddr could be the same field (true on at
|
||||
* least some versions of *BSD and OS X), so we
|
||||
* can't just check whether the broadcast address
|
||||
* is null and add it if so and check whether the
|
||||
* destination address is null and add it if so.
|
||||
*
|
||||
* Therefore, we must also check the IFF_BROADCAST
|
||||
* flag, and only add a broadcast address if it's
|
||||
* set, and check the IFF_POINTTOPOINT flag, and
|
||||
* only add a destination address if it's set (as
|
||||
* per man page recommendations on some of those
|
||||
* platforms).
|
||||
*/
|
||||
if (ifa->ifa_flags & IFF_BROADCAST &&
|
||||
ifa->ifa_broadaddr != NULL) {
|
||||
broadaddr = ifa->ifa_broadaddr;
|
||||
broadaddr_size = SA_LEN(broadaddr);
|
||||
} else {
|
||||
broadaddr = NULL;
|
||||
broadaddr_size = 0;
|
||||
}
|
||||
if (ifa->ifa_flags & IFF_POINTOPOINT &&
|
||||
ifa->ifa_dstaddr != NULL) {
|
||||
dstaddr = ifa->ifa_dstaddr;
|
||||
dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
|
||||
} else {
|
||||
dstaddr = NULL;
|
||||
dstaddr_size = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add information for this address to the list.
|
||||
*/
|
||||
if (add_addr_to_iflist(&devlist, ifa->ifa_name,
|
||||
ifa->ifa_flags, addr, addr_size, netmask, addr_size,
|
||||
if_flags_to_pcap_flags(ifa->ifa_name, ifa->ifa_flags),
|
||||
addr, addr_size, netmask, addr_size,
|
||||
broadaddr, broadaddr_size, dstaddr, dstaddr_size,
|
||||
errbuf) < 0) {
|
||||
ret = -1;
|
||||
|
||||
890
freebsd/contrib/libpcap/fad-helpers.c
Normal file
890
freebsd/contrib/libpcap/fad-helpers.c
Normal file
@@ -0,0 +1,890 @@
|
||||
#include <machine/rtems-bsd-user-space.h>
|
||||
|
||||
/* -*- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -*- */
|
||||
/*
|
||||
* Copyright (c) 1994, 1995, 1996, 1997, 1998
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the Computer Systems
|
||||
* Engineering Group at Lawrence Berkeley Laboratory.
|
||||
* 4. Neither the name of the University nor of the Laboratory may be used
|
||||
* to endorse or promote products derived from this software without
|
||||
* specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* _WIN32 */
|
||||
|
||||
#include <sys/param.h>
|
||||
#ifndef MSDOS
|
||||
#include <sys/file.h>
|
||||
#endif
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/socket.h>
|
||||
#ifdef HAVE_SYS_SOCKIO_H
|
||||
#include <sys/sockio.h>
|
||||
#endif
|
||||
|
||||
struct mbuf; /* Squelch compiler warnings on some platforms for */
|
||||
struct rtentry; /* declarations in <net/if.h> */
|
||||
#include <net/if.h>
|
||||
#include <netinet/in.h>
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <memory.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#if !defined(_WIN32) && !defined(__BORLANDC__)
|
||||
#include <unistd.h>
|
||||
#endif /* !_WIN32 && !__BORLANDC__ */
|
||||
#ifdef HAVE_LIMITS_H
|
||||
#include <limits.h>
|
||||
#else
|
||||
#define INT_MAX 2147483647
|
||||
#endif
|
||||
|
||||
#include "pcap-int.h"
|
||||
|
||||
#ifdef HAVE_OS_PROTO_H
|
||||
#include "os-proto.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
/* Not all systems have IFF_LOOPBACK */
|
||||
#ifdef IFF_LOOPBACK
|
||||
#define ISLOOPBACK(name, flags) ((flags) & IFF_LOOPBACK)
|
||||
#else
|
||||
#define ISLOOPBACK(name, flags) ((name)[0] == 'l' && (name)[1] == 'o' && \
|
||||
(isdigit((unsigned char)((name)[2])) || (name)[2] == '\0'))
|
||||
#endif
|
||||
|
||||
#ifdef IFF_UP
|
||||
#define ISUP(flags) ((flags) & IFF_UP)
|
||||
#else
|
||||
#define ISUP(flags) 0
|
||||
#endif
|
||||
|
||||
#ifdef IFF_RUNNING
|
||||
#define ISRUNNING(flags) ((flags) & IFF_RUNNING)
|
||||
#else
|
||||
#define ISRUNNING(flags) 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Map UN*X-style interface flags to libpcap flags.
|
||||
*/
|
||||
bpf_u_int32
|
||||
if_flags_to_pcap_flags(const char *name _U_, u_int if_flags)
|
||||
{
|
||||
bpf_u_int32 pcap_flags;
|
||||
|
||||
pcap_flags = 0;
|
||||
if (ISLOOPBACK(name, if_flags))
|
||||
pcap_flags |= PCAP_IF_LOOPBACK;
|
||||
if (ISUP(if_flags))
|
||||
pcap_flags |= PCAP_IF_UP;
|
||||
if (ISRUNNING(if_flags))
|
||||
pcap_flags |= PCAP_IF_RUNNING;
|
||||
return (pcap_flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct sockaddr *
|
||||
dup_sockaddr(struct sockaddr *sa, size_t sa_length)
|
||||
{
|
||||
struct sockaddr *newsa;
|
||||
|
||||
if ((newsa = malloc(sa_length)) == NULL)
|
||||
return (NULL);
|
||||
return (memcpy(newsa, sa, sa_length));
|
||||
}
|
||||
|
||||
/*
|
||||
* Construct a "figure of merit" for an interface, for use when sorting
|
||||
* the list of interfaces, in which interfaces that are up are superior
|
||||
* to interfaces that aren't up, interfaces that are up and running are
|
||||
* superior to interfaces that are up but not running, and non-loopback
|
||||
* interfaces that are up and running are superior to loopback interfaces,
|
||||
* and interfaces with the same flags have a figure of merit that's higher
|
||||
* the lower the instance number.
|
||||
*
|
||||
* The goal is to try to put the interfaces most likely to be useful for
|
||||
* capture at the beginning of the list.
|
||||
*
|
||||
* The figure of merit, which is lower the "better" the interface is,
|
||||
* has the uppermost bit set if the interface isn't running, the bit
|
||||
* below that set if the interface isn't up, the bit below that set
|
||||
* if the interface is a loopback interface, and the interface index
|
||||
* in the 29 bits below that. (Yes, we assume u_int is 32 bits.)
|
||||
*/
|
||||
static u_int
|
||||
get_figure_of_merit(pcap_if_t *dev)
|
||||
{
|
||||
const char *cp;
|
||||
u_int n;
|
||||
|
||||
if (strcmp(dev->name, "any") == 0) {
|
||||
/*
|
||||
* Give the "any" device an artificially high instance
|
||||
* number, so it shows up after all other non-loopback
|
||||
* interfaces.
|
||||
*/
|
||||
n = 0x1FFFFFFF; /* 29 all-1 bits */
|
||||
} else {
|
||||
/*
|
||||
* A number at the end of the device name string is
|
||||
* assumed to be a unit number.
|
||||
*/
|
||||
cp = dev->name + strlen(dev->name) - 1;
|
||||
while (cp-1 >= dev->name && *(cp-1) >= '0' && *(cp-1) <= '9')
|
||||
cp--;
|
||||
if (*cp >= '0' && *cp <= '9')
|
||||
n = atoi(cp);
|
||||
else
|
||||
n = 0;
|
||||
}
|
||||
if (!(dev->flags & PCAP_IF_RUNNING))
|
||||
n |= 0x80000000;
|
||||
if (!(dev->flags & PCAP_IF_UP))
|
||||
n |= 0x40000000;
|
||||
if (dev->flags & PCAP_IF_LOOPBACK)
|
||||
n |= 0x20000000;
|
||||
return (n);
|
||||
}
|
||||
|
||||
/*
|
||||
* Try to get a description for a given device.
|
||||
* Returns a mallocated description if it could and NULL if it couldn't.
|
||||
*
|
||||
* XXX - on FreeBSDs that support it, should it get the sysctl named
|
||||
* "dev.{adapter family name}.{adapter unit}.%desc" to get a description
|
||||
* of the adapter? Note that "dev.an.0.%desc" is "Aironet PC4500/PC4800"
|
||||
* with my Cisco 350 card, so the name isn't entirely descriptive. The
|
||||
* "dev.an.0.%pnpinfo" has a better description, although one might argue
|
||||
* that the problem is really a driver bug - if it can find out that it's
|
||||
* a Cisco 340 or 350, rather than an old Aironet card, it should use
|
||||
* that in the description.
|
||||
*
|
||||
* Do NetBSD, DragonflyBSD, or OpenBSD support this as well? FreeBSD
|
||||
* and OpenBSD let you get a description, but it's not generated by the OS,
|
||||
* it's set with another ioctl that ifconfig supports; we use that to get
|
||||
* a description in FreeBSD and OpenBSD, but if there is no such
|
||||
* description available, it still might be nice to get some description
|
||||
* string based on the device type or something such as that.
|
||||
*
|
||||
* In OS X, the System Configuration framework can apparently return
|
||||
* names in 10.4 and later.
|
||||
*
|
||||
* It also appears that freedesktop.org's HAL offers an "info.product"
|
||||
* string, but the HAL specification says it "should not be used in any
|
||||
* UI" and "subsystem/capability specific properties" should be used
|
||||
* instead and, in any case, I think HAL is being deprecated in
|
||||
* favor of other stuff such as DeviceKit. DeviceKit doesn't appear
|
||||
* to have any obvious product information for devices, but maybe
|
||||
* I haven't looked hard enough.
|
||||
*
|
||||
* Using the System Configuration framework, or HAL, or DeviceKit, or
|
||||
* whatever, would require that libpcap applications be linked with
|
||||
* the frameworks/libraries in question. That shouldn't be a problem
|
||||
* for programs linking with the shared version of libpcap (unless
|
||||
* you're running on AIX - which I think is the only UN*X that doesn't
|
||||
* support linking a shared library with other libraries on which it
|
||||
* depends, and having an executable linked only with the first shared
|
||||
* library automatically pick up the other libraries when started -
|
||||
* and using HAL or whatever). Programs linked with the static
|
||||
* version of libpcap would have to use pcap-config with the --static
|
||||
* flag in order to get the right linker flags in order to pick up
|
||||
* the additional libraries/frameworks; those programs need that anyway
|
||||
* for libpcap 1.1 and beyond on Linux, as, by default, it requires
|
||||
* -lnl.
|
||||
*
|
||||
* Do any other UN*Xes, or desktop environments support getting a
|
||||
* description?
|
||||
*/
|
||||
static char *
|
||||
get_if_description(const char *name)
|
||||
{
|
||||
#ifdef SIOCGIFDESCR
|
||||
char *description = NULL;
|
||||
int s;
|
||||
struct ifreq ifrdesc;
|
||||
#ifndef IFDESCRSIZE
|
||||
size_t descrlen = 64;
|
||||
#else
|
||||
size_t descrlen = IFDESCRSIZE;
|
||||
#endif /* IFDESCRSIZE */
|
||||
|
||||
/*
|
||||
* Get the description for the interface.
|
||||
*/
|
||||
memset(&ifrdesc, 0, sizeof ifrdesc);
|
||||
strlcpy(ifrdesc.ifr_name, name, sizeof ifrdesc.ifr_name);
|
||||
s = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (s >= 0) {
|
||||
#ifdef __FreeBSD__
|
||||
/*
|
||||
* On FreeBSD, if the buffer isn't big enough for the
|
||||
* description, the ioctl succeeds, but the description
|
||||
* isn't copied, ifr_buffer.length is set to the description
|
||||
* length, and ifr_buffer.buffer is set to NULL.
|
||||
*/
|
||||
for (;;) {
|
||||
free(description);
|
||||
if ((description = malloc(descrlen)) != NULL) {
|
||||
ifrdesc.ifr_buffer.buffer = description;
|
||||
ifrdesc.ifr_buffer.length = descrlen;
|
||||
if (ioctl(s, SIOCGIFDESCR, &ifrdesc) == 0) {
|
||||
if (ifrdesc.ifr_buffer.buffer ==
|
||||
description)
|
||||
break;
|
||||
else
|
||||
descrlen = ifrdesc.ifr_buffer.length;
|
||||
} else {
|
||||
/*
|
||||
* Failed to get interface description.
|
||||
*/
|
||||
free(description);
|
||||
description = NULL;
|
||||
break;
|
||||
}
|
||||
} else
|
||||
break;
|
||||
}
|
||||
#else /* __FreeBSD__ */
|
||||
/*
|
||||
* The only other OS that currently supports
|
||||
* SIOCGIFDESCR is OpenBSD, and it has no way
|
||||
* to get the description length - it's clamped
|
||||
* to a maximum of IFDESCRSIZE.
|
||||
*/
|
||||
if ((description = malloc(descrlen)) != NULL) {
|
||||
ifrdesc.ifr_data = (caddr_t)description;
|
||||
if (ioctl(s, SIOCGIFDESCR, &ifrdesc) != 0) {
|
||||
/*
|
||||
* Failed to get interface description.
|
||||
*/
|
||||
free(description);
|
||||
description = NULL;
|
||||
}
|
||||
}
|
||||
#endif /* __FreeBSD__ */
|
||||
close(s);
|
||||
if (description != NULL && strlen(description) == 0) {
|
||||
/*
|
||||
* Description is empty, so discard it.
|
||||
*/
|
||||
free(description);
|
||||
description = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __FreeBSD__
|
||||
/*
|
||||
* For FreeBSD, if we didn't get a description, and this is
|
||||
* a device with a name of the form usbusN, label it as a USB
|
||||
* bus.
|
||||
*/
|
||||
if (description == NULL) {
|
||||
if (strncmp(name, "usbus", 5) == 0) {
|
||||
/*
|
||||
* OK, it begins with "usbus".
|
||||
*/
|
||||
long busnum;
|
||||
char *p;
|
||||
|
||||
errno = 0;
|
||||
busnum = strtol(name + 5, &p, 10);
|
||||
if (errno == 0 && p != name + 5 && *p == '\0' &&
|
||||
busnum >= 0 && busnum <= INT_MAX) {
|
||||
/*
|
||||
* OK, it's a valid number that's not
|
||||
* bigger than INT_MAX. Construct
|
||||
* a description from it.
|
||||
*/
|
||||
static const char descr_prefix[] = "USB bus number ";
|
||||
size_t descr_size;
|
||||
|
||||
/*
|
||||
* Allow enough room for a 32-bit bus number.
|
||||
* sizeof (descr_prefix) includes the
|
||||
* terminating NUL.
|
||||
*/
|
||||
descr_size = sizeof (descr_prefix) + 10;
|
||||
description = malloc(descr_size);
|
||||
if (description != NULL) {
|
||||
pcap_snprintf(description, descr_size,
|
||||
"%s%ld", descr_prefix, busnum);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return (description);
|
||||
#else /* SIOCGIFDESCR */
|
||||
return (NULL);
|
||||
#endif /* SIOCGIFDESCR */
|
||||
}
|
||||
|
||||
/*
|
||||
* Look for a given device in the specified list of devices.
|
||||
*
|
||||
* If we find it, return 0 and set *curdev_ret to point to it.
|
||||
*
|
||||
* If we don't find it, check whether we can open it:
|
||||
*
|
||||
* If that fails with PCAP_ERROR_NO_SUCH_DEVICE or
|
||||
* PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for
|
||||
* it, as that probably means it exists but doesn't support
|
||||
* packet capture.
|
||||
*
|
||||
* Otherwise, attempt to add an entry for it, with the specified
|
||||
* ifnet flags and description, and, if that succeeds, return 0
|
||||
* and set *curdev_ret to point to the new entry, otherwise
|
||||
* return PCAP_ERROR and set errbuf to an error message. If we
|
||||
* weren't given a description, try to get one.
|
||||
*/
|
||||
int
|
||||
add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
|
||||
bpf_u_int32 flags, const char *description, char *errbuf)
|
||||
{
|
||||
pcap_t *p;
|
||||
pcap_if_t *curdev, *prevdev, *nextdev;
|
||||
u_int this_figure_of_merit, nextdev_figure_of_merit;
|
||||
char open_errbuf[PCAP_ERRBUF_SIZE];
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* Is there already an entry in the list for this interface?
|
||||
*/
|
||||
for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) {
|
||||
if (strcmp(name, curdev->name) == 0)
|
||||
break; /* yes, we found it */
|
||||
}
|
||||
|
||||
if (curdev == NULL) {
|
||||
/*
|
||||
* No, we didn't find it.
|
||||
*
|
||||
* Can we open this interface for live capture?
|
||||
*
|
||||
* We do this check so that interfaces that are
|
||||
* supplied by the interface enumeration mechanism
|
||||
* we're using but that don't support packet capture
|
||||
* aren't included in the list. Loopback interfaces
|
||||
* on Solaris are an example of this; we don't just
|
||||
* omit loopback interfaces on all platforms because
|
||||
* you *can* capture on loopback interfaces on some
|
||||
* OSes.
|
||||
*
|
||||
* On OS X, we don't do this check if the device
|
||||
* name begins with "wlt"; at least some versions
|
||||
* of OS X offer monitor mode capturing by having
|
||||
* a separate "monitor mode" device for each wireless
|
||||
* adapter, rather than by implementing the ioctls
|
||||
* that {Free,Net,Open,DragonFly}BSD provide.
|
||||
* Opening that device puts the adapter into monitor
|
||||
* mode, which, at least for some adapters, causes
|
||||
* them to deassociate from the network with which
|
||||
* they're associated.
|
||||
*
|
||||
* Instead, we try to open the corresponding "en"
|
||||
* device (so that we don't end up with, for users
|
||||
* without sufficient privilege to open capture
|
||||
* devices, a list of adapters that only includes
|
||||
* the wlt devices).
|
||||
*/
|
||||
#ifdef __APPLE__
|
||||
if (strncmp(name, "wlt", 3) == 0) {
|
||||
char *en_name;
|
||||
size_t en_name_len;
|
||||
|
||||
/*
|
||||
* Try to allocate a buffer for the "en"
|
||||
* device's name.
|
||||
*/
|
||||
en_name_len = strlen(name) - 1;
|
||||
en_name = malloc(en_name_len + 1);
|
||||
if (en_name == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
strcpy(en_name, "en");
|
||||
strcat(en_name, name + 3);
|
||||
p = pcap_create(en_name, open_errbuf);
|
||||
free(en_name);
|
||||
} else
|
||||
#endif /* __APPLE */
|
||||
p = pcap_create(name, open_errbuf);
|
||||
if (p == NULL) {
|
||||
/*
|
||||
* The attempt to create the pcap_t failed;
|
||||
* that's probably an indication that we're
|
||||
* out of memory.
|
||||
*
|
||||
* Don't bother including this interface,
|
||||
* but don't treat it as an error.
|
||||
*/
|
||||
*curdev_ret = NULL;
|
||||
return (0);
|
||||
}
|
||||
/* Small snaplen, so we don't try to allocate much memory. */
|
||||
pcap_set_snaplen(p, 68);
|
||||
ret = pcap_activate(p);
|
||||
pcap_close(p);
|
||||
switch (ret) {
|
||||
|
||||
case PCAP_ERROR_NO_SUCH_DEVICE:
|
||||
case PCAP_ERROR_IFACE_NOT_UP:
|
||||
/*
|
||||
* We expect these two errors - they're the
|
||||
* reason we try to open the device.
|
||||
*
|
||||
* PCAP_ERROR_NO_SUCH_DEVICE typically means
|
||||
* "there's no such device *known to the
|
||||
* OS's capture mechanism*", so, even though
|
||||
* it might be a valid network interface, you
|
||||
* can't capture on it (e.g., the loopback
|
||||
* device in Solaris up to Solaris 10, or
|
||||
* the vmnet devices in OS X with VMware
|
||||
* Fusion). We don't include those devices
|
||||
* in our list of devices, as there's no
|
||||
* point in doing so - they're not available
|
||||
* for capture.
|
||||
*
|
||||
* PCAP_ERROR_IFACE_NOT_UP means that the
|
||||
* OS's capture mechanism doesn't work on
|
||||
* interfaces not marked as up; some capture
|
||||
* mechanisms *do* support that, so we no
|
||||
* longer reject those interfaces out of hand,
|
||||
* but we *do* want to reject them if they
|
||||
* can't be opened for capture.
|
||||
*/
|
||||
*curdev_ret = NULL;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Yes, we can open it, or we can't, for some other
|
||||
* reason.
|
||||
*
|
||||
* If we can open it, we want to offer it for
|
||||
* capture, as you can capture on it. If we can't,
|
||||
* we want to offer it for capture, so that, if
|
||||
* the user tries to capture on it, they'll get
|
||||
* an error and they'll know why they can't
|
||||
* capture on it (e.g., insufficient permissions)
|
||||
* or they'll report it as a problem (and then
|
||||
* have the error message to provide as information).
|
||||
*
|
||||
* Allocate a new entry.
|
||||
*/
|
||||
curdev = malloc(sizeof(pcap_if_t));
|
||||
if (curdev == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Fill in the entry.
|
||||
*/
|
||||
curdev->next = NULL;
|
||||
curdev->name = strdup(name);
|
||||
if (curdev->name == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curdev);
|
||||
return (-1);
|
||||
}
|
||||
if (description == NULL) {
|
||||
/*
|
||||
* We weren't handed a description for the
|
||||
* interface, so see if we can generate one
|
||||
* ourselves.
|
||||
*/
|
||||
curdev->description = get_if_description(name);
|
||||
} else {
|
||||
/*
|
||||
* We were handed a description; make a copy.
|
||||
*/
|
||||
curdev->description = strdup(description);
|
||||
if (curdev->description == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curdev->name);
|
||||
free(curdev);
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
curdev->addresses = NULL; /* list starts out as empty */
|
||||
curdev->flags = flags;
|
||||
|
||||
/*
|
||||
* Add it to the list, in the appropriate location.
|
||||
* First, get the "figure of merit" for this
|
||||
* interface.
|
||||
*/
|
||||
this_figure_of_merit = get_figure_of_merit(curdev);
|
||||
|
||||
/*
|
||||
* Now look for the last interface with an figure of merit
|
||||
* less than or equal to the new interface's figure of
|
||||
* merit.
|
||||
*
|
||||
* We start with "prevdev" being NULL, meaning we're before
|
||||
* the first element in the list.
|
||||
*/
|
||||
prevdev = NULL;
|
||||
for (;;) {
|
||||
/*
|
||||
* Get the interface after this one.
|
||||
*/
|
||||
if (prevdev == NULL) {
|
||||
/*
|
||||
* The next element is the first element.
|
||||
*/
|
||||
nextdev = *alldevs;
|
||||
} else
|
||||
nextdev = prevdev->next;
|
||||
|
||||
/*
|
||||
* Are we at the end of the list?
|
||||
*/
|
||||
if (nextdev == NULL) {
|
||||
/*
|
||||
* Yes - we have to put the new entry
|
||||
* after "prevdev".
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Is the new interface's figure of merit less
|
||||
* than the next interface's figure of merit,
|
||||
* meaning that the new interface is better
|
||||
* than the next interface?
|
||||
*/
|
||||
nextdev_figure_of_merit = get_figure_of_merit(nextdev);
|
||||
if (this_figure_of_merit < nextdev_figure_of_merit) {
|
||||
/*
|
||||
* Yes - we should put the new entry
|
||||
* before "nextdev", i.e. after "prevdev".
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
prevdev = nextdev;
|
||||
}
|
||||
|
||||
/*
|
||||
* Insert before "nextdev".
|
||||
*/
|
||||
curdev->next = nextdev;
|
||||
|
||||
/*
|
||||
* Insert after "prevdev" - unless "prevdev" is null,
|
||||
* in which case this is the first interface.
|
||||
*/
|
||||
if (prevdev == NULL) {
|
||||
/*
|
||||
* This is the first interface. Pass back a
|
||||
* pointer to it, and put "curdev" before
|
||||
* "nextdev".
|
||||
*/
|
||||
*alldevs = curdev;
|
||||
} else
|
||||
prevdev->next = curdev;
|
||||
}
|
||||
|
||||
*curdev_ret = curdev;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Try to get a description for a given device, and then look for that
|
||||
* device in the specified list of devices.
|
||||
*
|
||||
* If we find it, then, if the specified address isn't null, add it to
|
||||
* the list of addresses for the device and return 0.
|
||||
*
|
||||
* If we don't find it, check whether we can open it:
|
||||
*
|
||||
* If that fails with PCAP_ERROR_NO_SUCH_DEVICE or
|
||||
* PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for
|
||||
* it, as that probably means it exists but doesn't support
|
||||
* packet capture.
|
||||
*
|
||||
* Otherwise, attempt to add an entry for it, with the specified
|
||||
* ifnet flags, and, if that succeeds, add the specified address
|
||||
* to its list of addresses if that address is non-null, set
|
||||
* *curdev_ret to point to the new entry, and return 0, otherwise
|
||||
* return PCAP_ERROR and set errbuf to an error message.
|
||||
*
|
||||
* (We can get called with a null address because we might get a list
|
||||
* of interface name/address combinations from the underlying OS, with
|
||||
* the address being absent in some cases, rather than a list of
|
||||
* interfaces with each interface having a list of addresses, so this
|
||||
* call may be the only call made to add to the list, and we want to
|
||||
* add interfaces even if they have no addresses.)
|
||||
*/
|
||||
int
|
||||
add_addr_to_iflist(pcap_if_t **alldevs, const char *name, bpf_u_int32 flags,
|
||||
struct sockaddr *addr, size_t addr_size,
|
||||
struct sockaddr *netmask, size_t netmask_size,
|
||||
struct sockaddr *broadaddr, size_t broadaddr_size,
|
||||
struct sockaddr *dstaddr, size_t dstaddr_size,
|
||||
char *errbuf)
|
||||
{
|
||||
pcap_if_t *curdev;
|
||||
|
||||
if (add_or_find_if(&curdev, alldevs, name, flags, NULL, errbuf) == -1) {
|
||||
/*
|
||||
* Error - give up.
|
||||
*/
|
||||
return (-1);
|
||||
}
|
||||
if (curdev == NULL) {
|
||||
/*
|
||||
* Device wasn't added because it can't be opened.
|
||||
* Not a fatal error.
|
||||
*/
|
||||
return (0);
|
||||
}
|
||||
|
||||
if (addr == NULL) {
|
||||
/*
|
||||
* There's no address to add; this entry just meant
|
||||
* "here's a new interface".
|
||||
*/
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* "curdev" is an entry for this interface, and we have an
|
||||
* address for it; add an entry for that address to the
|
||||
* interface's list of addresses.
|
||||
*
|
||||
* Allocate the new entry and fill it in.
|
||||
*/
|
||||
return (add_addr_to_dev(curdev, addr, addr_size, netmask,
|
||||
netmask_size, broadaddr, broadaddr_size, dstaddr,
|
||||
dstaddr_size, errbuf));
|
||||
}
|
||||
|
||||
/*
|
||||
* Add an entry to the list of addresses for an interface.
|
||||
* "curdev" is the entry for that interface.
|
||||
* If this is the first IP address added to the interface, move it
|
||||
* in the list as appropriate.
|
||||
*/
|
||||
int
|
||||
add_addr_to_dev(pcap_if_t *curdev,
|
||||
struct sockaddr *addr, size_t addr_size,
|
||||
struct sockaddr *netmask, size_t netmask_size,
|
||||
struct sockaddr *broadaddr, size_t broadaddr_size,
|
||||
struct sockaddr *dstaddr, size_t dstaddr_size,
|
||||
char *errbuf)
|
||||
{
|
||||
pcap_addr_t *curaddr, *prevaddr, *nextaddr;
|
||||
|
||||
curaddr = malloc(sizeof(pcap_addr_t));
|
||||
if (curaddr == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
curaddr->next = NULL;
|
||||
if (addr != NULL) {
|
||||
curaddr->addr = dup_sockaddr(addr, addr_size);
|
||||
if (curaddr->addr == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->addr = NULL;
|
||||
|
||||
if (netmask != NULL) {
|
||||
curaddr->netmask = dup_sockaddr(netmask, netmask_size);
|
||||
if (curaddr->netmask == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->netmask = NULL;
|
||||
|
||||
if (broadaddr != NULL) {
|
||||
curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
|
||||
if (curaddr->broadaddr == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->netmask != NULL)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->broadaddr = NULL;
|
||||
|
||||
if (dstaddr != NULL) {
|
||||
curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
|
||||
if (curaddr->dstaddr == NULL) {
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->broadaddr != NULL)
|
||||
free(curaddr->broadaddr);
|
||||
if (curaddr->netmask != NULL)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->dstaddr = NULL;
|
||||
|
||||
/*
|
||||
* Find the end of the list of addresses.
|
||||
*/
|
||||
for (prevaddr = curdev->addresses; prevaddr != NULL; prevaddr = nextaddr) {
|
||||
nextaddr = prevaddr->next;
|
||||
if (nextaddr == NULL) {
|
||||
/*
|
||||
* This is the end of the list.
|
||||
*/
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (prevaddr == NULL) {
|
||||
/*
|
||||
* The list was empty; this is the first member.
|
||||
*/
|
||||
curdev->addresses = curaddr;
|
||||
} else {
|
||||
/*
|
||||
* "prevaddr" is the last member of the list; append
|
||||
* this member to it.
|
||||
*/
|
||||
prevaddr->next = curaddr;
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Look for a given device in the specified list of devices.
|
||||
*
|
||||
* If we find it, return 0.
|
||||
*
|
||||
* If we don't find it, check whether we can open it:
|
||||
*
|
||||
* If that fails with PCAP_ERROR_NO_SUCH_DEVICE or
|
||||
* PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for
|
||||
* it, as that probably means it exists but doesn't support
|
||||
* packet capture.
|
||||
*
|
||||
* Otherwise, attempt to add an entry for it, with the specified
|
||||
* ifnet flags and description, and, if that succeeds, return 0
|
||||
* and set *curdev_ret to point to the new entry, otherwise
|
||||
* return PCAP_ERROR and set errbuf to an error message.
|
||||
*/
|
||||
int
|
||||
#ifndef __rtems__
|
||||
pcap_add_if(pcap_if_t **devlist, const char *name, u_int flags,
|
||||
#else /* __rtems__ */
|
||||
pcap_add_if(pcap_if_t **devlist, const char *name, bpf_u_int32 flags,
|
||||
#endif /* __rtems__ */
|
||||
const char *description, char *errbuf)
|
||||
{
|
||||
pcap_if_t *curdev;
|
||||
|
||||
return (add_or_find_if(&curdev, devlist, name, flags, description,
|
||||
errbuf));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Free a list of interfaces.
|
||||
*/
|
||||
void
|
||||
pcap_freealldevs(pcap_if_t *alldevs)
|
||||
{
|
||||
pcap_if_t *curdev, *nextdev;
|
||||
pcap_addr_t *curaddr, *nextaddr;
|
||||
|
||||
for (curdev = alldevs; curdev != NULL; curdev = nextdev) {
|
||||
nextdev = curdev->next;
|
||||
|
||||
/*
|
||||
* Free all addresses.
|
||||
*/
|
||||
for (curaddr = curdev->addresses; curaddr != NULL; curaddr = nextaddr) {
|
||||
nextaddr = curaddr->next;
|
||||
if (curaddr->addr)
|
||||
free(curaddr->addr);
|
||||
if (curaddr->netmask)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->broadaddr)
|
||||
free(curaddr->broadaddr);
|
||||
if (curaddr->dstaddr)
|
||||
free(curaddr->dstaddr);
|
||||
free(curaddr);
|
||||
}
|
||||
|
||||
/*
|
||||
* Free the name string.
|
||||
*/
|
||||
free(curdev->name);
|
||||
|
||||
/*
|
||||
* Free the description string, if any.
|
||||
*/
|
||||
if (curdev->description != NULL)
|
||||
free(curdev->description);
|
||||
|
||||
/*
|
||||
* Free the interface.
|
||||
*/
|
||||
free(curdev);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -17,8 +17,6 @@
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/gencode.h,v 1.71 2007-11-18 02:03:52 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -163,7 +161,7 @@
|
||||
#define A_CONNECTACK 44 /* Connect Ack message */
|
||||
#define A_RELEASE 45 /* Release message */
|
||||
#define A_RELEASE_DONE 46 /* Release message */
|
||||
|
||||
|
||||
/* ATM field types */
|
||||
#define A_VPI 51
|
||||
#define A_VCI 52
|
||||
@@ -186,12 +184,23 @@
|
||||
#define M_LSSU 23 /* LSSU */
|
||||
#define M_MSU 24 /* MSU */
|
||||
|
||||
/* MTP2 HSL types */
|
||||
#define MH_FISU 25 /* FISU for HSL */
|
||||
#define MH_LSSU 26 /* LSSU */
|
||||
#define MH_MSU 27 /* MSU */
|
||||
|
||||
/* MTP3 field types */
|
||||
#define M_SIO 1
|
||||
#define M_OPC 2
|
||||
#define M_DPC 3
|
||||
#define M_SLS 4
|
||||
|
||||
/* MTP3 field types in case of MTP2 HSL */
|
||||
#define MH_SIO 5
|
||||
#define MH_OPC 6
|
||||
#define MH_DPC 7
|
||||
#define MH_SLS 8
|
||||
|
||||
|
||||
struct slist;
|
||||
|
||||
@@ -272,72 +281,115 @@ struct qual {
|
||||
unsigned char pad;
|
||||
};
|
||||
|
||||
struct arth *gen_loadi(int);
|
||||
struct arth *gen_load(int, struct arth *, int);
|
||||
struct arth *gen_loadlen(void);
|
||||
struct arth *gen_neg(struct arth *);
|
||||
struct arth *gen_arth(int, struct arth *, struct arth *);
|
||||
struct _compiler_state;
|
||||
|
||||
typedef struct _compiler_state compiler_state_t;
|
||||
|
||||
struct arth *gen_loadi(compiler_state_t *, int);
|
||||
struct arth *gen_load(compiler_state_t *, int, struct arth *, int);
|
||||
struct arth *gen_loadlen(compiler_state_t *);
|
||||
struct arth *gen_neg(compiler_state_t *, struct arth *);
|
||||
struct arth *gen_arth(compiler_state_t *, int, struct arth *, struct arth *);
|
||||
|
||||
void gen_and(struct block *, struct block *);
|
||||
void gen_or(struct block *, struct block *);
|
||||
void gen_not(struct block *);
|
||||
|
||||
struct block *gen_scode(const char *, struct qual);
|
||||
struct block *gen_ecode(const u_char *, struct qual);
|
||||
struct block *gen_acode(const u_char *, struct qual);
|
||||
struct block *gen_mcode(const char *, const char *, int, struct qual);
|
||||
struct block *gen_scode(compiler_state_t *, const char *, struct qual);
|
||||
struct block *gen_ecode(compiler_state_t *, const u_char *, struct qual);
|
||||
struct block *gen_acode(compiler_state_t *, const u_char *, struct qual);
|
||||
struct block *gen_mcode(compiler_state_t *, const char *, const char *,
|
||||
unsigned int, struct qual);
|
||||
#ifdef INET6
|
||||
struct block *gen_mcode6(const char *, const char *, int, struct qual);
|
||||
struct block *gen_mcode6(compiler_state_t *, const char *, const char *,
|
||||
unsigned int, struct qual);
|
||||
#endif
|
||||
struct block *gen_ncode(const char *, bpf_u_int32, struct qual);
|
||||
struct block *gen_proto_abbrev(int);
|
||||
struct block *gen_relation(int, struct arth *, struct arth *, int);
|
||||
struct block *gen_less(int);
|
||||
struct block *gen_greater(int);
|
||||
struct block *gen_byteop(int, int, int);
|
||||
struct block *gen_broadcast(int);
|
||||
struct block *gen_multicast(int);
|
||||
struct block *gen_inbound(int);
|
||||
struct block *gen_ncode(compiler_state_t *, const char *, bpf_u_int32,
|
||||
struct qual);
|
||||
struct block *gen_proto_abbrev(compiler_state_t *, int);
|
||||
struct block *gen_relation(compiler_state_t *, int, struct arth *,
|
||||
struct arth *, int);
|
||||
struct block *gen_less(compiler_state_t *, int);
|
||||
struct block *gen_greater(compiler_state_t *, int);
|
||||
struct block *gen_byteop(compiler_state_t *, int, int, int);
|
||||
struct block *gen_broadcast(compiler_state_t *, int);
|
||||
struct block *gen_multicast(compiler_state_t *, int);
|
||||
struct block *gen_inbound(compiler_state_t *, int);
|
||||
|
||||
struct block *gen_vlan(int);
|
||||
struct block *gen_mpls(int);
|
||||
struct block *gen_llc(compiler_state_t *);
|
||||
struct block *gen_llc_i(compiler_state_t *);
|
||||
struct block *gen_llc_s(compiler_state_t *);
|
||||
struct block *gen_llc_u(compiler_state_t *);
|
||||
struct block *gen_llc_s_subtype(compiler_state_t *, bpf_u_int32);
|
||||
struct block *gen_llc_u_subtype(compiler_state_t *, bpf_u_int32);
|
||||
|
||||
struct block *gen_pppoed(void);
|
||||
struct block *gen_pppoes(void);
|
||||
struct block *gen_vlan(compiler_state_t *, int);
|
||||
struct block *gen_mpls(compiler_state_t *, int);
|
||||
|
||||
struct block *gen_atmfield_code(int atmfield, bpf_int32 jvalue, bpf_u_int32 jtype, int reverse);
|
||||
struct block *gen_atmtype_abbrev(int type);
|
||||
struct block *gen_atmmulti_abbrev(int type);
|
||||
struct block *gen_pppoed(compiler_state_t *);
|
||||
struct block *gen_pppoes(compiler_state_t *, int);
|
||||
|
||||
struct block *gen_mtp2type_abbrev(int type);
|
||||
struct block *gen_mtp3field_code(int mtp3field, bpf_u_int32 jvalue, bpf_u_int32 jtype, int reverse);
|
||||
struct block *gen_geneve(compiler_state_t *, int);
|
||||
|
||||
struct block *gen_pf_ifname(const char *);
|
||||
struct block *gen_pf_rnr(int);
|
||||
struct block *gen_pf_srnr(int);
|
||||
struct block *gen_pf_ruleset(char *);
|
||||
struct block *gen_pf_reason(int);
|
||||
struct block *gen_pf_action(int);
|
||||
struct block *gen_pf_dir(int);
|
||||
struct block *gen_atmfield_code(compiler_state_t *, int, bpf_int32,
|
||||
bpf_u_int32, int);
|
||||
struct block *gen_atmtype_abbrev(compiler_state_t *, int type);
|
||||
struct block *gen_atmmulti_abbrev(compiler_state_t *, int type);
|
||||
|
||||
struct block *gen_p80211_type(int, int);
|
||||
struct block *gen_p80211_fcdir(int);
|
||||
struct block *gen_mtp2type_abbrev(compiler_state_t *, int type);
|
||||
struct block *gen_mtp3field_code(compiler_state_t *, int, bpf_u_int32,
|
||||
bpf_u_int32, int);
|
||||
|
||||
void bpf_optimize(struct block **);
|
||||
void bpf_error(const char *, ...)
|
||||
__attribute__((noreturn, format (printf, 1, 2)));
|
||||
struct block *gen_pf_ifname(compiler_state_t *, const char *);
|
||||
struct block *gen_pf_rnr(compiler_state_t *, int);
|
||||
struct block *gen_pf_srnr(compiler_state_t *, int);
|
||||
struct block *gen_pf_ruleset(compiler_state_t *, char *);
|
||||
struct block *gen_pf_reason(compiler_state_t *, int);
|
||||
struct block *gen_pf_action(compiler_state_t *, int);
|
||||
|
||||
void finish_parse(struct block *);
|
||||
char *sdup(const char *);
|
||||
struct block *gen_p80211_type(compiler_state_t *, int, int);
|
||||
struct block *gen_p80211_fcdir(compiler_state_t *, int);
|
||||
|
||||
struct bpf_insn *icode_to_fcode(struct block *, u_int *);
|
||||
int pcap_parse(void);
|
||||
void lex_init(const char *);
|
||||
void lex_cleanup(void);
|
||||
/*
|
||||
* Representation of a program as a tree of blocks, plus current mark.
|
||||
* A block is marked if only if its mark equals the current mark.
|
||||
* Rather than traverse the code array, marking each item, 'cur_mark'
|
||||
* is incremented. This automatically makes each element unmarked.
|
||||
*/
|
||||
#define isMarked(icp, p) ((p)->mark == (icp)->cur_mark)
|
||||
#define unMarkAll(icp) (icp)->cur_mark += 1
|
||||
#define Mark(icp, p) ((p)->mark = (icp)->cur_mark)
|
||||
|
||||
struct icode {
|
||||
struct block *root;
|
||||
int cur_mark;
|
||||
};
|
||||
|
||||
void bpf_optimize(compiler_state_t *, struct icode *ic);
|
||||
void bpf_syntax_error(compiler_state_t *, const char *);
|
||||
void bpf_error(compiler_state_t *, const char *, ...)
|
||||
__attribute__((noreturn))
|
||||
#ifdef __ATTRIBUTE___FORMAT_OK
|
||||
__attribute__((format (printf, 2, 3)))
|
||||
#endif /* __ATTRIBUTE___FORMAT_OK */
|
||||
;
|
||||
|
||||
void finish_parse(compiler_state_t *, struct block *);
|
||||
char *sdup(compiler_state_t *, const char *);
|
||||
|
||||
struct _opt_state;
|
||||
typedef struct _opt_state opt_state_t;
|
||||
|
||||
struct bpf_insn *icode_to_fcode(compiler_state_t *, struct icode *,
|
||||
struct block *, u_int *);
|
||||
void sappend(struct slist *, struct slist *);
|
||||
|
||||
/*
|
||||
* Older versions of Bison don't put this declaration in
|
||||
* grammar.h.
|
||||
*/
|
||||
int pcap_parse(void *, compiler_state_t *);
|
||||
|
||||
/* XXX */
|
||||
#define JT(b) ((b)->et.succ)
|
||||
#define JF(b) ((b)->ef.succ)
|
||||
|
||||
extern int no_optimize;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -70,45 +70,53 @@
|
||||
#define MPLS 326
|
||||
#define PPPOED 327
|
||||
#define PPPOES 328
|
||||
#define ISO 329
|
||||
#define ESIS 330
|
||||
#define CLNP 331
|
||||
#define ISIS 332
|
||||
#define L1 333
|
||||
#define L2 334
|
||||
#define IIH 335
|
||||
#define LSP 336
|
||||
#define SNP 337
|
||||
#define CSNP 338
|
||||
#define PSNP 339
|
||||
#define STP 340
|
||||
#define IPX 341
|
||||
#define NETBEUI 342
|
||||
#define LANE 343
|
||||
#define LLC 344
|
||||
#define METAC 345
|
||||
#define BCC 346
|
||||
#define SC 347
|
||||
#define ILMIC 348
|
||||
#define OAMF4EC 349
|
||||
#define OAMF4SC 350
|
||||
#define OAM 351
|
||||
#define OAMF4 352
|
||||
#define CONNECTMSG 353
|
||||
#define METACONNECT 354
|
||||
#define VPI 355
|
||||
#define VCI 356
|
||||
#define RADIO 357
|
||||
#define FISU 358
|
||||
#define LSSU 359
|
||||
#define MSU 360
|
||||
#define SIO 361
|
||||
#define OPC 362
|
||||
#define DPC 363
|
||||
#define SLS 364
|
||||
#define OR 365
|
||||
#define AND 366
|
||||
#define UMINUS 367
|
||||
#define GENEVE 329
|
||||
#define ISO 330
|
||||
#define ESIS 331
|
||||
#define CLNP 332
|
||||
#define ISIS 333
|
||||
#define L1 334
|
||||
#define L2 335
|
||||
#define IIH 336
|
||||
#define LSP 337
|
||||
#define SNP 338
|
||||
#define CSNP 339
|
||||
#define PSNP 340
|
||||
#define STP 341
|
||||
#define IPX 342
|
||||
#define NETBEUI 343
|
||||
#define LANE 344
|
||||
#define LLC 345
|
||||
#define METAC 346
|
||||
#define BCC 347
|
||||
#define SC 348
|
||||
#define ILMIC 349
|
||||
#define OAMF4EC 350
|
||||
#define OAMF4SC 351
|
||||
#define OAM 352
|
||||
#define OAMF4 353
|
||||
#define CONNECTMSG 354
|
||||
#define METACONNECT 355
|
||||
#define VPI 356
|
||||
#define VCI 357
|
||||
#define RADIO 358
|
||||
#define FISU 359
|
||||
#define LSSU 360
|
||||
#define MSU 361
|
||||
#define HFISU 362
|
||||
#define HLSSU 363
|
||||
#define HMSU 364
|
||||
#define SIO 365
|
||||
#define OPC 366
|
||||
#define DPC 367
|
||||
#define SLS 368
|
||||
#define HSIO 369
|
||||
#define HOPC 370
|
||||
#define HDPC 371
|
||||
#define HSLS 372
|
||||
#define OR 373
|
||||
#define AND 374
|
||||
#define UMINUS 375
|
||||
#ifdef YYSTYPE
|
||||
#undef YYSTYPE_IS_DECLARED
|
||||
#define YYSTYPE_IS_DECLARED 1
|
||||
@@ -131,4 +139,4 @@ typedef union {
|
||||
struct block *rblk;
|
||||
} YYSTYPE;
|
||||
#endif /* !YYSTYPE_IS_DECLARED */
|
||||
extern YYSTYPE pcaplval;
|
||||
extern YYSTYPE pcap_lval;
|
||||
@@ -1,3 +1,28 @@
|
||||
/*
|
||||
* We want a reentrant parser.
|
||||
*/
|
||||
%pure-parser
|
||||
|
||||
/*
|
||||
* We also want a reentrant scanner, so we have to pass the
|
||||
* handle for the reentrant scanner to the parser, and the
|
||||
* parser has to pass it to the lexical analyzer.
|
||||
*
|
||||
* We use void * rather than yyscan_t because, at least with some
|
||||
* versions of Flex and Bison, if you use yyscan_t in %parse-param and
|
||||
* %lex-param, you have to include scanner.h before grammar.h to get
|
||||
* yyscan_t declared, and you have to include grammar.h before scanner.h
|
||||
* to get YYSTYPE declared. Using void * breaks the cycle; the Flex
|
||||
* documentation says yyscan_t is just a void *.
|
||||
*/
|
||||
%parse-param {void *yyscanner}
|
||||
%lex-param {void *yyscanner}
|
||||
|
||||
/*
|
||||
* And we need to pass the compiler state to the scanner.
|
||||
*/
|
||||
%parse-param {compiler_state_t *cstate}
|
||||
|
||||
%{
|
||||
/*
|
||||
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
|
||||
@@ -21,25 +46,21 @@
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/grammar.y,v 1.101 2007-11-18 02:03:52 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
#if __STDC__
|
||||
struct mbuf;
|
||||
struct rtentry;
|
||||
@@ -47,18 +68,22 @@ struct rtentry;
|
||||
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "pcap-int.h"
|
||||
|
||||
#include "gencode.h"
|
||||
#include "grammar.h"
|
||||
#include "scanner.h"
|
||||
|
||||
#ifdef HAVE_NET_PFVAR_H
|
||||
#include <net/if.h>
|
||||
#include <net/pfvar.h>
|
||||
#include <netpfil/pf/pf.h>
|
||||
#include <net/if_pflog.h>
|
||||
#endif
|
||||
#include "llc.h"
|
||||
#include "ieee80211.h"
|
||||
#include <pcap/namedb.h>
|
||||
|
||||
@@ -133,6 +158,23 @@ static const struct tok ieee80211_data_subtypes[] = {
|
||||
{ IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA_CF_ACPL, "qos-cf-ack-poll" },
|
||||
{ 0, NULL }
|
||||
};
|
||||
static const struct tok llc_s_subtypes[] = {
|
||||
{ LLC_RR, "rr" },
|
||||
{ LLC_RNR, "rnr" },
|
||||
{ LLC_REJ, "rej" },
|
||||
{ 0, NULL }
|
||||
};
|
||||
static const struct tok llc_u_subtypes[] = {
|
||||
{ LLC_UI, "ui" },
|
||||
{ LLC_UA, "ua" },
|
||||
{ LLC_DISC, "disc" },
|
||||
{ LLC_DM, "dm" },
|
||||
{ LLC_SABME, "sabme" },
|
||||
{ LLC_TEST, "test" },
|
||||
{ LLC_XID, "xid" },
|
||||
{ LLC_FRMR, "frmr" },
|
||||
{ 0, NULL }
|
||||
};
|
||||
struct type2tok {
|
||||
int type;
|
||||
const struct tok *tok;
|
||||
@@ -156,31 +198,18 @@ str2tok(const char *str, const struct tok *toks)
|
||||
return (-1);
|
||||
}
|
||||
|
||||
int n_errors = 0;
|
||||
|
||||
static struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF };
|
||||
|
||||
static void
|
||||
yyerror(const char *msg)
|
||||
yyerror(void *yyscanner, compiler_state_t *cstate, const char *msg)
|
||||
{
|
||||
++n_errors;
|
||||
bpf_error("%s", msg);
|
||||
bpf_syntax_error(cstate, msg);
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
#ifdef NEED_YYPARSE_WRAPPER
|
||||
int yyparse(void);
|
||||
|
||||
int
|
||||
pcap_parse()
|
||||
{
|
||||
return (yyparse());
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_NET_PFVAR_H
|
||||
static int
|
||||
pfreason_to_num(const char *reason)
|
||||
pfreason_to_num(compiler_state_t *cstate, const char *reason)
|
||||
{
|
||||
const char *reasons[] = PFRES_NAMES;
|
||||
int i;
|
||||
@@ -189,12 +218,12 @@ pfreason_to_num(const char *reason)
|
||||
if (pcap_strcasecmp(reason, reasons[i]) == 0)
|
||||
return (i);
|
||||
}
|
||||
bpf_error("unknown PF reason");
|
||||
bpf_error(cstate, "unknown PF reason");
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
static int
|
||||
pfaction_to_num(const char *action)
|
||||
pfaction_to_num(compiler_state_t *cstate, const char *action)
|
||||
{
|
||||
if (pcap_strcasecmp(action, "pass") == 0 ||
|
||||
pcap_strcasecmp(action, "accept") == 0)
|
||||
@@ -213,15 +242,15 @@ pfaction_to_num(const char *action)
|
||||
return (PF_NORDR);
|
||||
#endif
|
||||
else {
|
||||
bpf_error("unknown PF action");
|
||||
bpf_error(cstate, "unknown PF action");
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
}
|
||||
#else /* !HAVE_NET_PFVAR_H */
|
||||
static int
|
||||
pfreason_to_num(const char *reason)
|
||||
pfreason_to_num(compiler_state_t *cstate, const char *reason)
|
||||
{
|
||||
bpf_error("libpcap was compiled on a machine without pf support");
|
||||
bpf_error(cstate, "libpcap was compiled on a machine without pf support");
|
||||
/*NOTREACHED*/
|
||||
|
||||
/* this is to make the VC compiler happy */
|
||||
@@ -229,9 +258,9 @@ pfreason_to_num(const char *reason)
|
||||
}
|
||||
|
||||
static int
|
||||
pfaction_to_num(const char *action)
|
||||
pfaction_to_num(compiler_state_t *cstate, const char *action)
|
||||
{
|
||||
bpf_error("libpcap was compiled on a machine without pf support");
|
||||
bpf_error(cstate, "libpcap was compiled on a machine without pf support");
|
||||
/*NOTREACHED*/
|
||||
|
||||
/* this is to make the VC compiler happy */
|
||||
@@ -262,7 +291,7 @@ pfaction_to_num(const char *action)
|
||||
%type <a> arth narth
|
||||
%type <i> byteop pname pnum relop irelop
|
||||
%type <blk> and or paren not null prog
|
||||
%type <rblk> other pfvar p80211
|
||||
%type <rblk> other pfvar p80211 pllc
|
||||
%type <i> atmtype atmmultitype
|
||||
%type <blk> atmfield
|
||||
%type <blk> atmfieldvalue atmvalue atmlistvalue
|
||||
@@ -286,8 +315,8 @@ pfaction_to_num(const char *action)
|
||||
%token LEN
|
||||
%token IPV6 ICMPV6 AH ESP
|
||||
%token VLAN MPLS
|
||||
%token PPPOED PPPOES
|
||||
%token ISO ESIS CLNP ISIS L1 L2 IIH LSP SNP CSNP PSNP
|
||||
%token PPPOED PPPOES GENEVE
|
||||
%token ISO ESIS CLNP ISIS L1 L2 IIH LSP SNP CSNP PSNP
|
||||
%token STP
|
||||
%token IPX
|
||||
%token NETBEUI
|
||||
@@ -295,8 +324,9 @@ pfaction_to_num(const char *action)
|
||||
%token OAM OAMF4 CONNECTMSG METACONNECT
|
||||
%token VPI VCI
|
||||
%token RADIO
|
||||
%token FISU LSSU MSU
|
||||
%token SIO OPC DPC SLS
|
||||
%token FISU LSSU MSU HFISU HLSSU HMSU
|
||||
%token SIO OPC DPC SLS HSIO HOPC HDPC HSLS
|
||||
|
||||
|
||||
%type <s> ID
|
||||
%type <e> EID
|
||||
@@ -315,7 +345,7 @@ pfaction_to_num(const char *action)
|
||||
%%
|
||||
prog: null expr
|
||||
{
|
||||
finish_parse($2.b);
|
||||
finish_parse(cstate, $2.b);
|
||||
}
|
||||
| null
|
||||
;
|
||||
@@ -332,48 +362,48 @@ and: AND { $$ = $<blk>0; }
|
||||
or: OR { $$ = $<blk>0; }
|
||||
;
|
||||
id: nid
|
||||
| pnum { $$.b = gen_ncode(NULL, (bpf_u_int32)$1,
|
||||
| pnum { $$.b = gen_ncode(cstate, NULL, (bpf_u_int32)$1,
|
||||
$$.q = $<blk>0.q); }
|
||||
| paren pid ')' { $$ = $2; }
|
||||
;
|
||||
nid: ID { $$.b = gen_scode($1, $$.q = $<blk>0.q); }
|
||||
| HID '/' NUM { $$.b = gen_mcode($1, NULL, $3,
|
||||
nid: ID { $$.b = gen_scode(cstate, $1, $$.q = $<blk>0.q); }
|
||||
| HID '/' NUM { $$.b = gen_mcode(cstate, $1, NULL, $3,
|
||||
$$.q = $<blk>0.q); }
|
||||
| HID NETMASK HID { $$.b = gen_mcode($1, $3, 0,
|
||||
| HID NETMASK HID { $$.b = gen_mcode(cstate, $1, $3, 0,
|
||||
$$.q = $<blk>0.q); }
|
||||
| HID {
|
||||
/* Decide how to parse HID based on proto */
|
||||
$$.q = $<blk>0.q;
|
||||
if ($$.q.addr == Q_PORT)
|
||||
bpf_error("'port' modifier applied to ip host");
|
||||
bpf_error(cstate, "'port' modifier applied to ip host");
|
||||
else if ($$.q.addr == Q_PORTRANGE)
|
||||
bpf_error("'portrange' modifier applied to ip host");
|
||||
bpf_error(cstate, "'portrange' modifier applied to ip host");
|
||||
else if ($$.q.addr == Q_PROTO)
|
||||
bpf_error("'proto' modifier applied to ip host");
|
||||
bpf_error(cstate, "'proto' modifier applied to ip host");
|
||||
else if ($$.q.addr == Q_PROTOCHAIN)
|
||||
bpf_error("'protochain' modifier applied to ip host");
|
||||
$$.b = gen_ncode($1, 0, $$.q);
|
||||
bpf_error(cstate, "'protochain' modifier applied to ip host");
|
||||
$$.b = gen_ncode(cstate, $1, 0, $$.q);
|
||||
}
|
||||
| HID6 '/' NUM {
|
||||
#ifdef INET6
|
||||
$$.b = gen_mcode6($1, NULL, $3,
|
||||
$$.b = gen_mcode6(cstate, $1, NULL, $3,
|
||||
$$.q = $<blk>0.q);
|
||||
#else
|
||||
bpf_error("'ip6addr/prefixlen' not supported "
|
||||
bpf_error(cstate, "'ip6addr/prefixlen' not supported "
|
||||
"in this configuration");
|
||||
#endif /*INET6*/
|
||||
}
|
||||
| HID6 {
|
||||
#ifdef INET6
|
||||
$$.b = gen_mcode6($1, 0, 128,
|
||||
$$.b = gen_mcode6(cstate, $1, 0, 128,
|
||||
$$.q = $<blk>0.q);
|
||||
#else
|
||||
bpf_error("'ip6addr' not supported "
|
||||
bpf_error(cstate, "'ip6addr' not supported "
|
||||
"in this configuration");
|
||||
#endif /*INET6*/
|
||||
}
|
||||
| EID {
|
||||
$$.b = gen_ecode($1, $$.q = $<blk>0.q);
|
||||
| EID {
|
||||
$$.b = gen_ecode(cstate, $1, $$.q = $<blk>0.q);
|
||||
/*
|
||||
* $1 was allocated by "pcap_ether_aton()",
|
||||
* so we must free it now that we're done
|
||||
@@ -382,7 +412,7 @@ nid: ID { $$.b = gen_scode($1, $$.q = $<blk>0.q); }
|
||||
free($1);
|
||||
}
|
||||
| AID {
|
||||
$$.b = gen_acode($1, $$.q = $<blk>0.q);
|
||||
$$.b = gen_acode(cstate, $1, $$.q = $<blk>0.q);
|
||||
/*
|
||||
* $1 was allocated by "pcap_ether_aton()",
|
||||
* so we must free it now that we're done
|
||||
@@ -400,7 +430,7 @@ pid: nid
|
||||
| qid and id { gen_and($1.b, $3.b); $$ = $3; }
|
||||
| qid or id { gen_or($1.b, $3.b); $$ = $3; }
|
||||
;
|
||||
qid: pnum { $$.b = gen_ncode(NULL, (bpf_u_int32)$1,
|
||||
qid: pnum { $$.b = gen_ncode(cstate, NULL, (bpf_u_int32)$1,
|
||||
$$.q = $<blk>0.q); }
|
||||
| pid
|
||||
;
|
||||
@@ -416,16 +446,16 @@ head: pqual dqual aqual { QSET($$.q, $1, $2, $3); }
|
||||
;
|
||||
rterm: head id { $$ = $2; }
|
||||
| paren expr ')' { $$.b = $2.b; $$.q = $1.q; }
|
||||
| pname { $$.b = gen_proto_abbrev($1); $$.q = qerr; }
|
||||
| arth relop arth { $$.b = gen_relation($2, $1, $3, 0);
|
||||
| pname { $$.b = gen_proto_abbrev(cstate, $1); $$.q = qerr; }
|
||||
| arth relop arth { $$.b = gen_relation(cstate, $2, $1, $3, 0);
|
||||
$$.q = qerr; }
|
||||
| arth irelop arth { $$.b = gen_relation($2, $1, $3, 1);
|
||||
| arth irelop arth { $$.b = gen_relation(cstate, $2, $1, $3, 1);
|
||||
$$.q = qerr; }
|
||||
| other { $$.b = $1; $$.q = qerr; }
|
||||
| atmtype { $$.b = gen_atmtype_abbrev($1); $$.q = qerr; }
|
||||
| atmmultitype { $$.b = gen_atmmulti_abbrev($1); $$.q = qerr; }
|
||||
| atmtype { $$.b = gen_atmtype_abbrev(cstate, $1); $$.q = qerr; }
|
||||
| atmmultitype { $$.b = gen_atmmulti_abbrev(cstate, $1); $$.q = qerr; }
|
||||
| atmfield atmvalue { $$.b = $2.b; $$.q = qerr; }
|
||||
| mtp2type { $$.b = gen_mtp2type_abbrev($1); $$.q = qerr; }
|
||||
| mtp2type { $$.b = gen_mtp2type_abbrev(cstate, $1); $$.q = qerr; }
|
||||
| mtp3field mtp3value { $$.b = $2.b; $$.q = qerr; }
|
||||
;
|
||||
/* protocol level qualifiers */
|
||||
@@ -495,50 +525,54 @@ pname: LINK { $$ = Q_LINK; }
|
||||
| NETBEUI { $$ = Q_NETBEUI; }
|
||||
| RADIO { $$ = Q_RADIO; }
|
||||
;
|
||||
other: pqual TK_BROADCAST { $$ = gen_broadcast($1); }
|
||||
| pqual TK_MULTICAST { $$ = gen_multicast($1); }
|
||||
| LESS NUM { $$ = gen_less($2); }
|
||||
| GREATER NUM { $$ = gen_greater($2); }
|
||||
| CBYTE NUM byteop NUM { $$ = gen_byteop($3, $2, $4); }
|
||||
| INBOUND { $$ = gen_inbound(0); }
|
||||
| OUTBOUND { $$ = gen_inbound(1); }
|
||||
| VLAN pnum { $$ = gen_vlan($2); }
|
||||
| VLAN { $$ = gen_vlan(-1); }
|
||||
| MPLS pnum { $$ = gen_mpls($2); }
|
||||
| MPLS { $$ = gen_mpls(-1); }
|
||||
| PPPOED { $$ = gen_pppoed(); }
|
||||
| PPPOES { $$ = gen_pppoes(); }
|
||||
other: pqual TK_BROADCAST { $$ = gen_broadcast(cstate, $1); }
|
||||
| pqual TK_MULTICAST { $$ = gen_multicast(cstate, $1); }
|
||||
| LESS NUM { $$ = gen_less(cstate, $2); }
|
||||
| GREATER NUM { $$ = gen_greater(cstate, $2); }
|
||||
| CBYTE NUM byteop NUM { $$ = gen_byteop(cstate, $3, $2, $4); }
|
||||
| INBOUND { $$ = gen_inbound(cstate, 0); }
|
||||
| OUTBOUND { $$ = gen_inbound(cstate, 1); }
|
||||
| VLAN pnum { $$ = gen_vlan(cstate, $2); }
|
||||
| VLAN { $$ = gen_vlan(cstate, -1); }
|
||||
| MPLS pnum { $$ = gen_mpls(cstate, $2); }
|
||||
| MPLS { $$ = gen_mpls(cstate, -1); }
|
||||
| PPPOED { $$ = gen_pppoed(cstate); }
|
||||
| PPPOES pnum { $$ = gen_pppoes(cstate, $2); }
|
||||
| PPPOES { $$ = gen_pppoes(cstate, -1); }
|
||||
| GENEVE pnum { $$ = gen_geneve(cstate, $2); }
|
||||
| GENEVE { $$ = gen_geneve(cstate, -1); }
|
||||
| pfvar { $$ = $1; }
|
||||
| pqual p80211 { $$ = $2; }
|
||||
| pllc { $$ = $1; }
|
||||
;
|
||||
|
||||
pfvar: PF_IFNAME ID { $$ = gen_pf_ifname($2); }
|
||||
| PF_RSET ID { $$ = gen_pf_ruleset($2); }
|
||||
| PF_RNR NUM { $$ = gen_pf_rnr($2); }
|
||||
| PF_SRNR NUM { $$ = gen_pf_srnr($2); }
|
||||
| PF_REASON reason { $$ = gen_pf_reason($2); }
|
||||
| PF_ACTION action { $$ = gen_pf_action($2); }
|
||||
pfvar: PF_IFNAME ID { $$ = gen_pf_ifname(cstate, $2); }
|
||||
| PF_RSET ID { $$ = gen_pf_ruleset(cstate, $2); }
|
||||
| PF_RNR NUM { $$ = gen_pf_rnr(cstate, $2); }
|
||||
| PF_SRNR NUM { $$ = gen_pf_srnr(cstate, $2); }
|
||||
| PF_REASON reason { $$ = gen_pf_reason(cstate, $2); }
|
||||
| PF_ACTION action { $$ = gen_pf_action(cstate, $2); }
|
||||
;
|
||||
|
||||
p80211: TYPE type SUBTYPE subtype
|
||||
{ $$ = gen_p80211_type($2 | $4,
|
||||
{ $$ = gen_p80211_type(cstate, $2 | $4,
|
||||
IEEE80211_FC0_TYPE_MASK |
|
||||
IEEE80211_FC0_SUBTYPE_MASK);
|
||||
}
|
||||
| TYPE type { $$ = gen_p80211_type($2,
|
||||
| TYPE type { $$ = gen_p80211_type(cstate, $2,
|
||||
IEEE80211_FC0_TYPE_MASK);
|
||||
}
|
||||
| SUBTYPE type_subtype { $$ = gen_p80211_type($2,
|
||||
| SUBTYPE type_subtype { $$ = gen_p80211_type(cstate, $2,
|
||||
IEEE80211_FC0_TYPE_MASK |
|
||||
IEEE80211_FC0_SUBTYPE_MASK);
|
||||
}
|
||||
| DIR dir { $$ = gen_p80211_fcdir($2); }
|
||||
| DIR dir { $$ = gen_p80211_fcdir(cstate, $2); }
|
||||
;
|
||||
|
||||
type: NUM
|
||||
| ID { $$ = str2tok($1, ieee80211_types);
|
||||
if ($$ == -1)
|
||||
bpf_error("unknown 802.11 type name");
|
||||
bpf_error(cstate, "unknown 802.11 type name");
|
||||
}
|
||||
;
|
||||
|
||||
@@ -548,7 +582,7 @@ subtype: NUM
|
||||
for (i = 0;; i++) {
|
||||
if (ieee80211_type_subtypes[i].tok == NULL) {
|
||||
/* Ran out of types */
|
||||
bpf_error("unknown 802.11 type");
|
||||
bpf_error(cstate, "unknown 802.11 type");
|
||||
break;
|
||||
}
|
||||
if ($<i>-1 == ieee80211_type_subtypes[i].type) {
|
||||
@@ -559,7 +593,7 @@ subtype: NUM
|
||||
|
||||
$$ = str2tok($1, types);
|
||||
if ($$ == -1)
|
||||
bpf_error("unknown 802.11 subtype name");
|
||||
bpf_error(cstate, "unknown 802.11 subtype name");
|
||||
}
|
||||
;
|
||||
|
||||
@@ -567,7 +601,7 @@ type_subtype: ID { int i;
|
||||
for (i = 0;; i++) {
|
||||
if (ieee80211_type_subtypes[i].tok == NULL) {
|
||||
/* Ran out of types */
|
||||
bpf_error("unknown 802.11 type name");
|
||||
bpf_error(cstate, "unknown 802.11 type name");
|
||||
break;
|
||||
}
|
||||
$$ = str2tok($1, ieee80211_type_subtypes[i].tok);
|
||||
@@ -579,6 +613,31 @@ type_subtype: ID { int i;
|
||||
}
|
||||
;
|
||||
|
||||
pllc: LLC { $$ = gen_llc(cstate); }
|
||||
| LLC ID { if (pcap_strcasecmp($2, "i") == 0)
|
||||
$$ = gen_llc_i(cstate);
|
||||
else if (pcap_strcasecmp($2, "s") == 0)
|
||||
$$ = gen_llc_s(cstate);
|
||||
else if (pcap_strcasecmp($2, "u") == 0)
|
||||
$$ = gen_llc_u(cstate);
|
||||
else {
|
||||
int subtype;
|
||||
|
||||
subtype = str2tok($2, llc_s_subtypes);
|
||||
if (subtype != -1)
|
||||
$$ = gen_llc_s_subtype(cstate, subtype);
|
||||
else {
|
||||
subtype = str2tok($2, llc_u_subtypes);
|
||||
if (subtype == -1)
|
||||
bpf_error(cstate, "unknown LLC type name \"%s\"", $2);
|
||||
$$ = gen_llc_u_subtype(cstate, subtype);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* sigh, "rnr" is already a keyword for PF */
|
||||
| LLC PF_RNR { $$ = gen_llc_s_subtype(cstate, LLC_RNR); }
|
||||
;
|
||||
|
||||
dir: NUM
|
||||
| ID { if (pcap_strcasecmp($1, "nods") == 0)
|
||||
$$ = IEEE80211_FC1_DIR_NODS;
|
||||
@@ -589,15 +648,15 @@ dir: NUM
|
||||
else if (pcap_strcasecmp($1, "dstods") == 0)
|
||||
$$ = IEEE80211_FC1_DIR_DSTODS;
|
||||
else
|
||||
bpf_error("unknown 802.11 direction");
|
||||
bpf_error(cstate, "unknown 802.11 direction");
|
||||
}
|
||||
;
|
||||
|
||||
reason: NUM { $$ = $1; }
|
||||
| ID { $$ = pfreason_to_num($1); }
|
||||
| ID { $$ = pfreason_to_num(cstate, $1); }
|
||||
;
|
||||
|
||||
action: ID { $$ = pfaction_to_num($1); }
|
||||
action: ID { $$ = pfaction_to_num(cstate, $1); }
|
||||
;
|
||||
|
||||
relop: '>' { $$ = BPF_JGT; }
|
||||
@@ -608,22 +667,24 @@ irelop: LEQ { $$ = BPF_JGT; }
|
||||
| '<' { $$ = BPF_JGE; }
|
||||
| NEQ { $$ = BPF_JEQ; }
|
||||
;
|
||||
arth: pnum { $$ = gen_loadi($1); }
|
||||
arth: pnum { $$ = gen_loadi(cstate, $1); }
|
||||
| narth
|
||||
;
|
||||
narth: pname '[' arth ']' { $$ = gen_load($1, $3, 1); }
|
||||
| pname '[' arth ':' NUM ']' { $$ = gen_load($1, $3, $5); }
|
||||
| arth '+' arth { $$ = gen_arth(BPF_ADD, $1, $3); }
|
||||
| arth '-' arth { $$ = gen_arth(BPF_SUB, $1, $3); }
|
||||
| arth '*' arth { $$ = gen_arth(BPF_MUL, $1, $3); }
|
||||
| arth '/' arth { $$ = gen_arth(BPF_DIV, $1, $3); }
|
||||
| arth '&' arth { $$ = gen_arth(BPF_AND, $1, $3); }
|
||||
| arth '|' arth { $$ = gen_arth(BPF_OR, $1, $3); }
|
||||
| arth LSH arth { $$ = gen_arth(BPF_LSH, $1, $3); }
|
||||
| arth RSH arth { $$ = gen_arth(BPF_RSH, $1, $3); }
|
||||
| '-' arth %prec UMINUS { $$ = gen_neg($2); }
|
||||
narth: pname '[' arth ']' { $$ = gen_load(cstate, $1, $3, 1); }
|
||||
| pname '[' arth ':' NUM ']' { $$ = gen_load(cstate, $1, $3, $5); }
|
||||
| arth '+' arth { $$ = gen_arth(cstate, BPF_ADD, $1, $3); }
|
||||
| arth '-' arth { $$ = gen_arth(cstate, BPF_SUB, $1, $3); }
|
||||
| arth '*' arth { $$ = gen_arth(cstate, BPF_MUL, $1, $3); }
|
||||
| arth '/' arth { $$ = gen_arth(cstate, BPF_DIV, $1, $3); }
|
||||
| arth '%' arth { $$ = gen_arth(cstate, BPF_MOD, $1, $3); }
|
||||
| arth '&' arth { $$ = gen_arth(cstate, BPF_AND, $1, $3); }
|
||||
| arth '|' arth { $$ = gen_arth(cstate, BPF_OR, $1, $3); }
|
||||
| arth '^' arth { $$ = gen_arth(cstate, BPF_XOR, $1, $3); }
|
||||
| arth LSH arth { $$ = gen_arth(cstate, BPF_LSH, $1, $3); }
|
||||
| arth RSH arth { $$ = gen_arth(cstate, BPF_RSH, $1, $3); }
|
||||
| '-' arth %prec UMINUS { $$ = gen_neg(cstate, $2); }
|
||||
| paren narth ')' { $$ = $2; }
|
||||
| LEN { $$ = gen_loadlen(); }
|
||||
| LEN { $$ = gen_loadlen(cstate); }
|
||||
;
|
||||
byteop: '&' { $$ = '&'; }
|
||||
| '|' { $$ = '|'; }
|
||||
@@ -635,7 +696,6 @@ pnum: NUM
|
||||
| paren pnum ')' { $$ = $2; }
|
||||
;
|
||||
atmtype: LANE { $$ = A_LANE; }
|
||||
| LLC { $$ = A_LLC; }
|
||||
| METAC { $$ = A_METAC; }
|
||||
| BCC { $$ = A_BCC; }
|
||||
| OAMF4EC { $$ = A_OAMF4EC; }
|
||||
@@ -653,15 +713,15 @@ atmfield: VPI { $$.atmfieldtype = A_VPI; }
|
||||
| VCI { $$.atmfieldtype = A_VCI; }
|
||||
;
|
||||
atmvalue: atmfieldvalue
|
||||
| relop NUM { $$.b = gen_atmfield_code($<blk>0.atmfieldtype, (bpf_int32)$2, (bpf_u_int32)$1, 0); }
|
||||
| irelop NUM { $$.b = gen_atmfield_code($<blk>0.atmfieldtype, (bpf_int32)$2, (bpf_u_int32)$1, 1); }
|
||||
| relop NUM { $$.b = gen_atmfield_code(cstate, $<blk>0.atmfieldtype, (bpf_int32)$2, (bpf_u_int32)$1, 0); }
|
||||
| irelop NUM { $$.b = gen_atmfield_code(cstate, $<blk>0.atmfieldtype, (bpf_int32)$2, (bpf_u_int32)$1, 1); }
|
||||
| paren atmlistvalue ')' { $$.b = $2.b; $$.q = qerr; }
|
||||
;
|
||||
atmfieldvalue: NUM {
|
||||
$$.atmfieldtype = $<blk>0.atmfieldtype;
|
||||
if ($$.atmfieldtype == A_VPI ||
|
||||
$$.atmfieldtype == A_VCI)
|
||||
$$.b = gen_atmfield_code($$.atmfieldtype, (bpf_int32) $1, BPF_JEQ, 0);
|
||||
$$.b = gen_atmfield_code(cstate, $$.atmfieldtype, (bpf_int32) $1, BPF_JEQ, 0);
|
||||
}
|
||||
;
|
||||
atmlistvalue: atmfieldvalue
|
||||
@@ -671,16 +731,23 @@ atmlistvalue: atmfieldvalue
|
||||
mtp2type: FISU { $$ = M_FISU; }
|
||||
| LSSU { $$ = M_LSSU; }
|
||||
| MSU { $$ = M_MSU; }
|
||||
| HFISU { $$ = MH_FISU; }
|
||||
| HLSSU { $$ = MH_LSSU; }
|
||||
| HMSU { $$ = MH_MSU; }
|
||||
;
|
||||
/* MTP3 field types quantifier */
|
||||
mtp3field: SIO { $$.mtp3fieldtype = M_SIO; }
|
||||
| OPC { $$.mtp3fieldtype = M_OPC; }
|
||||
| DPC { $$.mtp3fieldtype = M_DPC; }
|
||||
| SLS { $$.mtp3fieldtype = M_SLS; }
|
||||
| HSIO { $$.mtp3fieldtype = MH_SIO; }
|
||||
| HOPC { $$.mtp3fieldtype = MH_OPC; }
|
||||
| HDPC { $$.mtp3fieldtype = MH_DPC; }
|
||||
| HSLS { $$.mtp3fieldtype = MH_SLS; }
|
||||
;
|
||||
mtp3value: mtp3fieldvalue
|
||||
| relop NUM { $$.b = gen_mtp3field_code($<blk>0.mtp3fieldtype, (u_int)$2, (u_int)$1, 0); }
|
||||
| irelop NUM { $$.b = gen_mtp3field_code($<blk>0.mtp3fieldtype, (u_int)$2, (u_int)$1, 1); }
|
||||
| relop NUM { $$.b = gen_mtp3field_code(cstate, $<blk>0.mtp3fieldtype, (u_int)$2, (u_int)$1, 0); }
|
||||
| irelop NUM { $$.b = gen_mtp3field_code(cstate, $<blk>0.mtp3fieldtype, (u_int)$2, (u_int)$1, 1); }
|
||||
| paren mtp3listvalue ')' { $$.b = $2.b; $$.q = qerr; }
|
||||
;
|
||||
mtp3fieldvalue: NUM {
|
||||
@@ -688,8 +755,12 @@ mtp3fieldvalue: NUM {
|
||||
if ($$.mtp3fieldtype == M_SIO ||
|
||||
$$.mtp3fieldtype == M_OPC ||
|
||||
$$.mtp3fieldtype == M_DPC ||
|
||||
$$.mtp3fieldtype == M_SLS )
|
||||
$$.b = gen_mtp3field_code($$.mtp3fieldtype, (u_int) $1, BPF_JEQ, 0);
|
||||
$$.mtp3fieldtype == M_SLS ||
|
||||
$$.mtp3fieldtype == MH_SIO ||
|
||||
$$.mtp3fieldtype == MH_OPC ||
|
||||
$$.mtp3fieldtype == MH_DPC ||
|
||||
$$.mtp3fieldtype == MH_SLS)
|
||||
$$.b = gen_mtp3field_code(cstate, $$.mtp3fieldtype, (u_int) $1, BPF_JEQ, 0);
|
||||
}
|
||||
;
|
||||
mtp3listvalue: mtp3fieldvalue
|
||||
|
||||
@@ -90,7 +90,7 @@
|
||||
#define IEEE80211_FC1_RETRY 0x08
|
||||
#define IEEE80211_FC1_PWR_MGT 0x10
|
||||
#define IEEE80211_FC1_MORE_DATA 0x20
|
||||
#define IEEE80211_FC1_WEP 0x40
|
||||
#define IEEE80211_FC1_PROTECTED 0x40
|
||||
#define IEEE80211_FC1_ORDER 0x80
|
||||
|
||||
#define IEEE80211_SEQ_FRAG_MASK 0x000f
|
||||
|
||||
@@ -34,18 +34,13 @@
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/inet.c,v 1.79 2008-04-20 18:19:02 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
|
||||
#include <sys/param.h>
|
||||
#ifndef MSDOS
|
||||
@@ -61,22 +56,16 @@ struct mbuf; /* Squelch compiler warnings on some platforms for */
|
||||
struct rtentry; /* declarations in <net/if.h> */
|
||||
#include <net/if.h>
|
||||
#include <netinet/in.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <memory.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#if !defined(WIN32) && !defined(__BORLANDC__)
|
||||
#if !defined(_WIN32) && !defined(__BORLANDC__)
|
||||
#include <unistd.h>
|
||||
#endif /* !WIN32 && !__BORLANDC__ */
|
||||
#ifdef HAVE_LIMITS_H
|
||||
#include <limits.h>
|
||||
#else
|
||||
#define INT_MAX 2147483647
|
||||
#endif
|
||||
#endif /* !_WIN32 && !__BORLANDC__ */
|
||||
|
||||
#include "pcap-int.h"
|
||||
|
||||
@@ -84,585 +73,7 @@ struct rtentry; /* declarations in <net/if.h> */
|
||||
#include "os-proto.h"
|
||||
#endif
|
||||
|
||||
/* Not all systems have IFF_LOOPBACK */
|
||||
#ifdef IFF_LOOPBACK
|
||||
#define ISLOOPBACK(name, flags) ((flags) & IFF_LOOPBACK)
|
||||
#else
|
||||
#define ISLOOPBACK(name, flags) ((name)[0] == 'l' && (name)[1] == 'o' && \
|
||||
(isdigit((unsigned char)((name)[2])) || (name)[2] == '\0'))
|
||||
#endif
|
||||
|
||||
struct sockaddr *
|
||||
dup_sockaddr(struct sockaddr *sa, size_t sa_length)
|
||||
{
|
||||
struct sockaddr *newsa;
|
||||
|
||||
if ((newsa = malloc(sa_length)) == NULL)
|
||||
return (NULL);
|
||||
return (memcpy(newsa, sa, sa_length));
|
||||
}
|
||||
|
||||
static int
|
||||
get_instance(const char *name)
|
||||
{
|
||||
const char *cp, *endcp;
|
||||
int n;
|
||||
|
||||
if (strcmp(name, "any") == 0) {
|
||||
/*
|
||||
* Give the "any" device an artificially high instance
|
||||
* number, so it shows up after all other non-loopback
|
||||
* interfaces.
|
||||
*/
|
||||
return INT_MAX;
|
||||
}
|
||||
|
||||
endcp = name + strlen(name);
|
||||
for (cp = name; cp < endcp && !isdigit((unsigned char)*cp); ++cp)
|
||||
continue;
|
||||
|
||||
if (isdigit((unsigned char)*cp))
|
||||
n = atoi(cp);
|
||||
else
|
||||
n = 0;
|
||||
return (n);
|
||||
}
|
||||
|
||||
int
|
||||
add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
|
||||
u_int flags, const char *description, char *errbuf)
|
||||
{
|
||||
pcap_t *p;
|
||||
pcap_if_t *curdev, *prevdev, *nextdev;
|
||||
int this_instance;
|
||||
char open_errbuf[PCAP_ERRBUF_SIZE];
|
||||
|
||||
/*
|
||||
* Is there already an entry in the list for this interface?
|
||||
*/
|
||||
for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) {
|
||||
if (strcmp(name, curdev->name) == 0)
|
||||
break; /* yes, we found it */
|
||||
}
|
||||
|
||||
if (curdev == NULL) {
|
||||
/*
|
||||
* No, we didn't find it.
|
||||
*
|
||||
* Can we open this interface for live capture?
|
||||
*
|
||||
* We do this check so that interfaces that are
|
||||
* supplied by the interface enumeration mechanism
|
||||
* we're using but that don't support packet capture
|
||||
* aren't included in the list. Loopback interfaces
|
||||
* on Solaris are an example of this; we don't just
|
||||
* omit loopback interfaces on all platforms because
|
||||
* you *can* capture on loopback interfaces on some
|
||||
* OSes.
|
||||
*
|
||||
* On OS X, we don't do this check if the device
|
||||
* name begins with "wlt"; at least some versions
|
||||
* of OS X offer monitor mode capturing by having
|
||||
* a separate "monitor mode" device for each wireless
|
||||
* adapter, rather than by implementing the ioctls
|
||||
* that {Free,Net,Open,DragonFly}BSD provide.
|
||||
* Opening that device puts the adapter into monitor
|
||||
* mode, which, at least for some adapters, causes
|
||||
* them to deassociate from the network with which
|
||||
* they're associated.
|
||||
*
|
||||
* Instead, we try to open the corresponding "en"
|
||||
* device (so that we don't end up with, for users
|
||||
* without sufficient privilege to open capture
|
||||
* devices, a list of adapters that only includes
|
||||
* the wlt devices).
|
||||
*/
|
||||
#ifdef __APPLE__
|
||||
if (strncmp(name, "wlt", 3) == 0) {
|
||||
char *en_name;
|
||||
size_t en_name_len;
|
||||
|
||||
/*
|
||||
* Try to allocate a buffer for the "en"
|
||||
* device's name.
|
||||
*/
|
||||
en_name_len = strlen(name) - 1;
|
||||
en_name = malloc(en_name_len + 1);
|
||||
if (en_name == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
strcpy(en_name, "en");
|
||||
strcat(en_name, name + 3);
|
||||
p = pcap_open_live(en_name, 68, 0, 0, open_errbuf);
|
||||
free(en_name);
|
||||
} else
|
||||
#endif /* __APPLE */
|
||||
p = pcap_open_live(name, 68, 0, 0, open_errbuf);
|
||||
if (p == NULL) {
|
||||
/*
|
||||
* No. Don't bother including it.
|
||||
* Don't treat this as an error, though.
|
||||
*/
|
||||
*curdev_ret = NULL;
|
||||
return (0);
|
||||
}
|
||||
pcap_close(p);
|
||||
|
||||
/*
|
||||
* Yes, we can open it.
|
||||
* Allocate a new entry.
|
||||
*/
|
||||
curdev = malloc(sizeof(pcap_if_t));
|
||||
if (curdev == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Fill in the entry.
|
||||
*/
|
||||
curdev->next = NULL;
|
||||
curdev->name = strdup(name);
|
||||
if (curdev->name == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curdev);
|
||||
return (-1);
|
||||
}
|
||||
if (description != NULL) {
|
||||
/*
|
||||
* We have a description for this interface.
|
||||
*/
|
||||
curdev->description = strdup(description);
|
||||
if (curdev->description == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curdev->name);
|
||||
free(curdev);
|
||||
return (-1);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* We don't.
|
||||
*/
|
||||
curdev->description = NULL;
|
||||
}
|
||||
curdev->addresses = NULL; /* list starts out as empty */
|
||||
curdev->flags = 0;
|
||||
if (ISLOOPBACK(name, flags))
|
||||
curdev->flags |= PCAP_IF_LOOPBACK;
|
||||
|
||||
/*
|
||||
* Add it to the list, in the appropriate location.
|
||||
* First, get the instance number of this interface.
|
||||
*/
|
||||
this_instance = get_instance(name);
|
||||
|
||||
/*
|
||||
* Now look for the last interface with an instance number
|
||||
* less than or equal to the new interface's instance
|
||||
* number - except that non-loopback interfaces are
|
||||
* arbitrarily treated as having interface numbers less
|
||||
* than those of loopback interfaces, so the loopback
|
||||
* interfaces are put at the end of the list.
|
||||
*
|
||||
* We start with "prevdev" being NULL, meaning we're before
|
||||
* the first element in the list.
|
||||
*/
|
||||
prevdev = NULL;
|
||||
for (;;) {
|
||||
/*
|
||||
* Get the interface after this one.
|
||||
*/
|
||||
if (prevdev == NULL) {
|
||||
/*
|
||||
* The next element is the first element.
|
||||
*/
|
||||
nextdev = *alldevs;
|
||||
} else
|
||||
nextdev = prevdev->next;
|
||||
|
||||
/*
|
||||
* Are we at the end of the list?
|
||||
*/
|
||||
if (nextdev == NULL) {
|
||||
/*
|
||||
* Yes - we have to put the new entry
|
||||
* after "prevdev".
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Is the new interface a non-loopback interface
|
||||
* and the next interface a loopback interface?
|
||||
*/
|
||||
if (!(curdev->flags & PCAP_IF_LOOPBACK) &&
|
||||
(nextdev->flags & PCAP_IF_LOOPBACK)) {
|
||||
/*
|
||||
* Yes, we should put the new entry
|
||||
* before "nextdev", i.e. after "prevdev".
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Is the new interface's instance number less
|
||||
* than the next interface's instance number,
|
||||
* and is it the case that the new interface is a
|
||||
* non-loopback interface or the next interface is
|
||||
* a loopback interface?
|
||||
*
|
||||
* (The goal of both loopback tests is to make
|
||||
* sure that we never put a loopback interface
|
||||
* before any non-loopback interface and that we
|
||||
* always put a non-loopback interface before all
|
||||
* loopback interfaces.)
|
||||
*/
|
||||
if (this_instance < get_instance(nextdev->name) &&
|
||||
(!(curdev->flags & PCAP_IF_LOOPBACK) ||
|
||||
(nextdev->flags & PCAP_IF_LOOPBACK))) {
|
||||
/*
|
||||
* Yes - we should put the new entry
|
||||
* before "nextdev", i.e. after "prevdev".
|
||||
*/
|
||||
break;
|
||||
}
|
||||
|
||||
prevdev = nextdev;
|
||||
}
|
||||
|
||||
/*
|
||||
* Insert before "nextdev".
|
||||
*/
|
||||
curdev->next = nextdev;
|
||||
|
||||
/*
|
||||
* Insert after "prevdev" - unless "prevdev" is null,
|
||||
* in which case this is the first interface.
|
||||
*/
|
||||
if (prevdev == NULL) {
|
||||
/*
|
||||
* This is the first interface. Pass back a
|
||||
* pointer to it, and put "curdev" before
|
||||
* "nextdev".
|
||||
*/
|
||||
*alldevs = curdev;
|
||||
} else
|
||||
prevdev->next = curdev;
|
||||
}
|
||||
|
||||
*curdev_ret = curdev;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX - on FreeBSDs that support it, should it get the sysctl named
|
||||
* "dev.{adapter family name}.{adapter unit}.%desc" to get a description
|
||||
* of the adapter? Note that "dev.an.0.%desc" is "Aironet PC4500/PC4800"
|
||||
* with my Cisco 350 card, so the name isn't entirely descriptive. The
|
||||
* "dev.an.0.%pnpinfo" has a better description, although one might argue
|
||||
* that the problem is really a driver bug - if it can find out that it's
|
||||
* a Cisco 340 or 350, rather than an old Aironet card, it should use
|
||||
* that in the description.
|
||||
*
|
||||
* Do NetBSD, DragonflyBSD, or OpenBSD support this as well? FreeBSD
|
||||
* and OpenBSD let you get a description, but it's not generated by the OS,
|
||||
* it's set with another ioctl that ifconfig supports; we use that to get
|
||||
* a description in FreeBSD and OpenBSD, but if there is no such
|
||||
* description available, it still might be nice to get some description
|
||||
* string based on the device type or something such as that.
|
||||
*
|
||||
* In OS X, the System Configuration framework can apparently return
|
||||
* names in 10.4 and later.
|
||||
*
|
||||
* It also appears that freedesktop.org's HAL offers an "info.product"
|
||||
* string, but the HAL specification says it "should not be used in any
|
||||
* UI" and "subsystem/capability specific properties" should be used
|
||||
* instead and, in any case, I think HAL is being deprecated in
|
||||
* favor of other stuff such as DeviceKit. DeviceKit doesn't appear
|
||||
* to have any obvious product information for devices, but maybe
|
||||
* I haven't looked hard enough.
|
||||
*
|
||||
* Using the System Configuration framework, or HAL, or DeviceKit, or
|
||||
* whatever, would require that libpcap applications be linked with
|
||||
* the frameworks/libraries in question. That shouldn't be a problem
|
||||
* for programs linking with the shared version of libpcap (unless
|
||||
* you're running on AIX - which I think is the only UN*X that doesn't
|
||||
* support linking a shared library with other libraries on which it
|
||||
* depends, and having an executable linked only with the first shared
|
||||
* library automatically pick up the other libraries when started -
|
||||
* and using HAL or whatever). Programs linked with the static
|
||||
* version of libpcap would have to use pcap-config with the --static
|
||||
* flag in order to get the right linker flags in order to pick up
|
||||
* the additional libraries/frameworks; those programs need that anyway
|
||||
* for libpcap 1.1 and beyond on Linux, as, by default, it requires
|
||||
* -lnl.
|
||||
*
|
||||
* Do any other UN*Xes, or desktop environments support getting a
|
||||
* description?
|
||||
*/
|
||||
int
|
||||
add_addr_to_iflist(pcap_if_t **alldevs, const char *name, u_int flags,
|
||||
struct sockaddr *addr, size_t addr_size,
|
||||
struct sockaddr *netmask, size_t netmask_size,
|
||||
struct sockaddr *broadaddr, size_t broadaddr_size,
|
||||
struct sockaddr *dstaddr, size_t dstaddr_size,
|
||||
char *errbuf)
|
||||
{
|
||||
pcap_if_t *curdev;
|
||||
char *description = NULL;
|
||||
pcap_addr_t *curaddr, *prevaddr, *nextaddr;
|
||||
#ifdef SIOCGIFDESCR
|
||||
int s;
|
||||
struct ifreq ifrdesc;
|
||||
#ifndef IFDESCRSIZE
|
||||
size_t descrlen = 64;
|
||||
#else
|
||||
size_t descrlen = IFDESCRSIZE;
|
||||
#endif /* IFDESCRSIZE */
|
||||
#endif /* SIOCGIFDESCR */
|
||||
|
||||
#ifdef SIOCGIFDESCR
|
||||
/*
|
||||
* Get the description for the interface.
|
||||
*/
|
||||
memset(&ifrdesc, 0, sizeof ifrdesc);
|
||||
strlcpy(ifrdesc.ifr_name, name, sizeof ifrdesc.ifr_name);
|
||||
s = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (s >= 0) {
|
||||
#ifdef __FreeBSD__
|
||||
/*
|
||||
* On FreeBSD, if the buffer isn't big enough for the
|
||||
* description, the ioctl succeeds, but the description
|
||||
* isn't copied, ifr_buffer.length is set to the description
|
||||
* length, and ifr_buffer.buffer is set to NULL.
|
||||
*/
|
||||
for (;;) {
|
||||
free(description);
|
||||
if ((description = malloc(descrlen)) != NULL) {
|
||||
ifrdesc.ifr_buffer.buffer = description;
|
||||
ifrdesc.ifr_buffer.length = descrlen;
|
||||
if (ioctl(s, SIOCGIFDESCR, &ifrdesc) == 0) {
|
||||
if (ifrdesc.ifr_buffer.buffer ==
|
||||
description)
|
||||
break;
|
||||
else
|
||||
descrlen = ifrdesc.ifr_buffer.length;
|
||||
} else {
|
||||
/*
|
||||
* Failed to get interface description.
|
||||
*/
|
||||
free(description);
|
||||
description = NULL;
|
||||
break;
|
||||
}
|
||||
} else
|
||||
break;
|
||||
}
|
||||
#else /* __FreeBSD__ */
|
||||
/*
|
||||
* The only other OS that currently supports
|
||||
* SIOCGIFDESCR is OpenBSD, and it has no way
|
||||
* to get the description length - it's clamped
|
||||
* to a maximum of IFDESCRSIZE.
|
||||
*/
|
||||
if ((description = malloc(descrlen)) != NULL) {
|
||||
ifrdesc.ifr_data = (caddr_t)description;
|
||||
if (ioctl(s, SIOCGIFDESCR, &ifrdesc) != 0) {
|
||||
/*
|
||||
* Failed to get interface description.
|
||||
*/
|
||||
free(description);
|
||||
description = NULL;
|
||||
}
|
||||
}
|
||||
#endif /* __FreeBSD__ */
|
||||
close(s);
|
||||
if (description != NULL && strlen(description) == 0) {
|
||||
free(description);
|
||||
description = NULL;
|
||||
}
|
||||
}
|
||||
#endif /* SIOCGIFDESCR */
|
||||
|
||||
if (add_or_find_if(&curdev, alldevs, name, flags, description,
|
||||
errbuf) == -1) {
|
||||
free(description);
|
||||
/*
|
||||
* Error - give up.
|
||||
*/
|
||||
return (-1);
|
||||
}
|
||||
free(description);
|
||||
if (curdev == NULL) {
|
||||
/*
|
||||
* Device wasn't added because it can't be opened.
|
||||
* Not a fatal error.
|
||||
*/
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* "curdev" is an entry for this interface; add an entry for this
|
||||
* address to its list of addresses.
|
||||
*
|
||||
* Allocate the new entry and fill it in.
|
||||
*/
|
||||
curaddr = malloc(sizeof(pcap_addr_t));
|
||||
if (curaddr == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
|
||||
curaddr->next = NULL;
|
||||
if (addr != NULL) {
|
||||
curaddr->addr = dup_sockaddr(addr, addr_size);
|
||||
if (curaddr->addr == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->addr = NULL;
|
||||
|
||||
if (netmask != NULL) {
|
||||
curaddr->netmask = dup_sockaddr(netmask, netmask_size);
|
||||
if (curaddr->netmask == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->netmask = NULL;
|
||||
|
||||
if (broadaddr != NULL) {
|
||||
curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
|
||||
if (curaddr->broadaddr == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->netmask != NULL)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->broadaddr = NULL;
|
||||
|
||||
if (dstaddr != NULL) {
|
||||
curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
|
||||
if (curaddr->dstaddr == NULL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"malloc: %s", pcap_strerror(errno));
|
||||
if (curaddr->broadaddr != NULL)
|
||||
free(curaddr->broadaddr);
|
||||
if (curaddr->netmask != NULL)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->addr != NULL)
|
||||
free(curaddr->addr);
|
||||
free(curaddr);
|
||||
return (-1);
|
||||
}
|
||||
} else
|
||||
curaddr->dstaddr = NULL;
|
||||
|
||||
/*
|
||||
* Find the end of the list of addresses.
|
||||
*/
|
||||
for (prevaddr = curdev->addresses; prevaddr != NULL; prevaddr = nextaddr) {
|
||||
nextaddr = prevaddr->next;
|
||||
if (nextaddr == NULL) {
|
||||
/*
|
||||
* This is the end of the list.
|
||||
*/
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (prevaddr == NULL) {
|
||||
/*
|
||||
* The list was empty; this is the first member.
|
||||
*/
|
||||
curdev->addresses = curaddr;
|
||||
} else {
|
||||
/*
|
||||
* "prevaddr" is the last member of the list; append
|
||||
* this member to it.
|
||||
*/
|
||||
prevaddr->next = curaddr;
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
pcap_add_if(pcap_if_t **devlist, const char *name, u_int flags,
|
||||
const char *description, char *errbuf)
|
||||
{
|
||||
pcap_if_t *curdev;
|
||||
|
||||
return (add_or_find_if(&curdev, devlist, name, flags, description,
|
||||
errbuf));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Free a list of interfaces.
|
||||
*/
|
||||
void
|
||||
pcap_freealldevs(pcap_if_t *alldevs)
|
||||
{
|
||||
pcap_if_t *curdev, *nextdev;
|
||||
pcap_addr_t *curaddr, *nextaddr;
|
||||
|
||||
for (curdev = alldevs; curdev != NULL; curdev = nextdev) {
|
||||
nextdev = curdev->next;
|
||||
|
||||
/*
|
||||
* Free all addresses.
|
||||
*/
|
||||
for (curaddr = curdev->addresses; curaddr != NULL; curaddr = nextaddr) {
|
||||
nextaddr = curaddr->next;
|
||||
if (curaddr->addr)
|
||||
free(curaddr->addr);
|
||||
if (curaddr->netmask)
|
||||
free(curaddr->netmask);
|
||||
if (curaddr->broadaddr)
|
||||
free(curaddr->broadaddr);
|
||||
if (curaddr->dstaddr)
|
||||
free(curaddr->dstaddr);
|
||||
free(curaddr);
|
||||
}
|
||||
|
||||
/*
|
||||
* Free the name string.
|
||||
*/
|
||||
free(curdev->name);
|
||||
|
||||
/*
|
||||
* Free the description string, if any.
|
||||
*/
|
||||
if (curdev->description != NULL)
|
||||
free(curdev->description);
|
||||
|
||||
/*
|
||||
* Free the interface.
|
||||
*/
|
||||
free(curdev);
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(WIN32) && !defined(MSDOS)
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
|
||||
/*
|
||||
* Return the name of a network interface attached to the system, or NULL
|
||||
@@ -739,6 +150,10 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
#ifdef PCAP_SUPPORT_USB
|
||||
|| strstr(device, "usbmon") != NULL
|
||||
#endif
|
||||
#ifdef PCAP_SUPPORT_NETMAP
|
||||
|| !strncmp(device, "netmap:", 7)
|
||||
|| !strncmp(device, "vale", 4)
|
||||
#endif
|
||||
#ifdef HAVE_SNF_API
|
||||
|| strstr(device, "snf") != NULL
|
||||
#endif
|
||||
@@ -749,7 +164,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
|
||||
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (fd < 0) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s",
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s",
|
||||
pcap_strerror(errno));
|
||||
return (-1);
|
||||
}
|
||||
@@ -758,13 +173,13 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
/* XXX Work around Linux kernel bug */
|
||||
ifr.ifr_addr.sa_family = AF_INET;
|
||||
#endif
|
||||
(void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
|
||||
(void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
|
||||
if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) {
|
||||
if (errno == EADDRNOTAVAIL) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: no IPv4 address assigned", device);
|
||||
} else {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"SIOCGIFADDR: %s: %s",
|
||||
device, pcap_strerror(errno));
|
||||
}
|
||||
@@ -778,9 +193,9 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
/* XXX Work around Linux kernel bug */
|
||||
ifr.ifr_addr.sa_family = AF_INET;
|
||||
#endif
|
||||
(void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
|
||||
(void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
|
||||
if (ioctl(fd, SIOCGIFNETMASK, (char *)&ifr) < 0) {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"SIOCGIFNETMASK: %s: %s", device, pcap_strerror(errno));
|
||||
(void)close(fd);
|
||||
return (-1);
|
||||
@@ -795,7 +210,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
else if (IN_CLASSC(*netp))
|
||||
*maskp = IN_CLASSC_NET;
|
||||
else {
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"inet class for 0x%x unknown", *netp);
|
||||
return (-1);
|
||||
}
|
||||
@@ -804,92 +219,151 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
return (0);
|
||||
}
|
||||
|
||||
#elif defined(WIN32)
|
||||
#elif defined(_WIN32)
|
||||
|
||||
/*
|
||||
* Return the name of a network interface attached to the system, or NULL
|
||||
* if none can be found. The interface must be configured up; the
|
||||
* lowest unit number is preferred; loopback is ignored.
|
||||
*
|
||||
* In the best of all possible worlds, this would be the same as on
|
||||
* UN*X, but there may be software that expects this to return a
|
||||
* full list of devices after the first device.
|
||||
*/
|
||||
#define ADAPTERSNAME_LEN 8192
|
||||
char *
|
||||
pcap_lookupdev(errbuf)
|
||||
register char *errbuf;
|
||||
{
|
||||
DWORD dwVersion;
|
||||
DWORD dwWindowsMajorVersion;
|
||||
char our_errbuf[PCAP_ERRBUF_SIZE+1];
|
||||
|
||||
#pragma warning (push)
|
||||
#pragma warning (disable: 4996) /* disable MSVC's GetVersion() deprecated warning here */
|
||||
dwVersion = GetVersion(); /* get the OS version */
|
||||
#pragma warning (pop)
|
||||
dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
|
||||
|
||||
|
||||
if (dwVersion >= 0x80000000 && dwWindowsMajorVersion >= 4) {
|
||||
/*
|
||||
* Windows 95, 98, ME.
|
||||
*/
|
||||
ULONG NameLength = 8192;
|
||||
static char AdaptersName[8192];
|
||||
|
||||
ULONG NameLength = ADAPTERSNAME_LEN;
|
||||
static char AdaptersName[ADAPTERSNAME_LEN];
|
||||
|
||||
if (PacketGetAdapterNames(AdaptersName,&NameLength) )
|
||||
return (AdaptersName);
|
||||
else
|
||||
return NULL;
|
||||
} else {
|
||||
/*
|
||||
* Windows NT (NT 4.0, W2K, WXP). Convert the names to UNICODE for backward compatibility
|
||||
* Windows NT (NT 4.0 and later).
|
||||
* Convert the names to Unicode for backward compatibility.
|
||||
*/
|
||||
ULONG NameLength = 8192;
|
||||
static WCHAR AdaptersName[8192];
|
||||
ULONG NameLength = ADAPTERSNAME_LEN;
|
||||
static WCHAR AdaptersName[ADAPTERSNAME_LEN];
|
||||
size_t BufferSpaceLeft;
|
||||
char *tAstr;
|
||||
WCHAR *tUstr;
|
||||
WCHAR *TAdaptersName = (WCHAR*)malloc(8192 * sizeof(WCHAR));
|
||||
WCHAR *Unameptr;
|
||||
char *Adescptr;
|
||||
size_t namelen, i;
|
||||
WCHAR *TAdaptersName = (WCHAR*)malloc(ADAPTERSNAME_LEN * sizeof(WCHAR));
|
||||
int NAdapts = 0;
|
||||
|
||||
if(TAdaptersName == NULL)
|
||||
{
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure");
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ( !PacketGetAdapterNames((PTSTR)TAdaptersName,&NameLength) )
|
||||
{
|
||||
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"PacketGetAdapterNames: %s",
|
||||
pcap_win32strerror());
|
||||
pcap_win32_err_to_str(GetLastError(), our_errbuf);
|
||||
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"PacketGetAdapterNames: %s", our_errbuf);
|
||||
free(TAdaptersName);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
BufferSpaceLeft = ADAPTERSNAME_LEN * sizeof(WCHAR);
|
||||
tAstr = (char*)TAdaptersName;
|
||||
tUstr = (WCHAR*)AdaptersName;
|
||||
Unameptr = AdaptersName;
|
||||
|
||||
/*
|
||||
* Convert and copy the device names
|
||||
* Convert the device names to Unicode into AdapterName.
|
||||
*/
|
||||
while(sscanf(tAstr, "%S", tUstr) > 0)
|
||||
{
|
||||
tAstr += strlen(tAstr) + 1;
|
||||
tUstr += wcslen(tUstr) + 1;
|
||||
NAdapts ++;
|
||||
}
|
||||
do {
|
||||
/*
|
||||
* Length of the name, including the terminating
|
||||
* NUL.
|
||||
*/
|
||||
namelen = strlen(tAstr) + 1;
|
||||
|
||||
tAstr++;
|
||||
*tUstr = 0;
|
||||
tUstr++;
|
||||
/*
|
||||
* Do we have room for the name in the Unicode
|
||||
* buffer?
|
||||
*/
|
||||
if (BufferSpaceLeft < namelen * sizeof(WCHAR)) {
|
||||
/*
|
||||
* No.
|
||||
*/
|
||||
goto quit;
|
||||
}
|
||||
BufferSpaceLeft -= namelen * sizeof(WCHAR);
|
||||
|
||||
/*
|
||||
* Copy the name, converting ASCII to Unicode.
|
||||
* namelen includes the NUL, so we copy it as
|
||||
* well.
|
||||
*/
|
||||
for (i = 0; i < namelen; i++)
|
||||
*Unameptr++ = *tAstr++;
|
||||
|
||||
/*
|
||||
* Count this adapter.
|
||||
*/
|
||||
NAdapts++;
|
||||
} while (namelen != 1);
|
||||
|
||||
/*
|
||||
* Copy the descriptions
|
||||
* Copy the descriptions, but don't convert them from
|
||||
* ASCII to Unicode.
|
||||
*/
|
||||
Adescptr = (char *)Unameptr;
|
||||
while(NAdapts--)
|
||||
{
|
||||
char* tmp = (char*)tUstr;
|
||||
strcpy(tmp, tAstr);
|
||||
tmp += strlen(tAstr) + 1;
|
||||
tUstr = (WCHAR*)tmp;
|
||||
tAstr += strlen(tAstr) + 1;
|
||||
size_t desclen;
|
||||
|
||||
desclen = strlen(tAstr) + 1;
|
||||
|
||||
/*
|
||||
* Do we have room for the name in the Unicode
|
||||
* buffer?
|
||||
*/
|
||||
if (BufferSpaceLeft < desclen) {
|
||||
/*
|
||||
* No.
|
||||
*/
|
||||
goto quit;
|
||||
}
|
||||
|
||||
/*
|
||||
* Just copy the ASCII string.
|
||||
* namelen includes the NUL, so we copy it as
|
||||
* well.
|
||||
*/
|
||||
memcpy(Adescptr, tAstr, desclen);
|
||||
Adescptr += desclen;
|
||||
tAstr += desclen;
|
||||
BufferSpaceLeft -= desclen;
|
||||
}
|
||||
|
||||
quit:
|
||||
free(TAdaptersName);
|
||||
return (char *)(AdaptersName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -899,7 +373,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
register bpf_u_int32 *netp, *maskp;
|
||||
register char *errbuf;
|
||||
{
|
||||
/*
|
||||
/*
|
||||
* We need only the first IPv4 address, so we must scan the array returned by PacketGetNetInfo()
|
||||
* in order to skip non IPv4 (i.e. IPv6 addresses)
|
||||
*/
|
||||
@@ -925,11 +399,11 @@ pcap_lookupnet(device, netp, maskp, errbuf)
|
||||
*netp &= *maskp;
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
*netp = *maskp = 0;
|
||||
return (0);
|
||||
}
|
||||
|
||||
#endif /* !WIN32 && !MSDOS */
|
||||
#endif /* !_WIN32 && !MSDOS */
|
||||
|
||||
@@ -17,10 +17,39 @@
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/llc.h,v 1.2 2001-01-28 09:44:50 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
* Definitions for information in the LLC header.
|
||||
*/
|
||||
|
||||
#define LLC_U_FMT 3
|
||||
#define LLC_GSAP 1
|
||||
#define LLC_IG 1 /* Individual / Group */
|
||||
#define LLC_S_FMT 1
|
||||
|
||||
#define LLC_U_POLL 0x10
|
||||
#define LLC_IS_POLL 0x0100
|
||||
#define LLC_XID_FI 0x81
|
||||
|
||||
#define LLC_U_CMD_MASK 0xef
|
||||
#define LLC_UI 0x03
|
||||
#define LLC_UA 0x63
|
||||
#define LLC_DISC 0x43
|
||||
#define LLC_DM 0x0f
|
||||
#define LLC_SABME 0x6f
|
||||
#define LLC_TEST 0xe3
|
||||
#define LLC_XID 0xaf
|
||||
#define LLC_FRMR 0x87
|
||||
|
||||
#define LLC_S_CMD_MASK 0x0f
|
||||
#define LLC_RR 0x0001
|
||||
#define LLC_RNR 0x0005
|
||||
#define LLC_REJ 0x0009
|
||||
|
||||
#define LLC_IS_NR(is) (((is) >> 9) & 0x7f)
|
||||
#define LLC_I_NS(is) (((is) >> 1) & 0x7f)
|
||||
|
||||
/*
|
||||
* 802.2 LLC SAP values.
|
||||
*/
|
||||
@@ -31,10 +60,10 @@
|
||||
#ifndef LLCSAP_GLOBAL
|
||||
#define LLCSAP_GLOBAL 0xff
|
||||
#endif
|
||||
#ifndef LLCSAP_8021B
|
||||
#ifndef LLCSAP_8021B_I
|
||||
#define LLCSAP_8021B_I 0x02
|
||||
#endif
|
||||
#ifndef LLCSAP_8021B
|
||||
#ifndef LLCSAP_8021B_G
|
||||
#define LLCSAP_8021B_G 0x03
|
||||
#endif
|
||||
#ifndef LLCSAP_IP
|
||||
|
||||
@@ -26,11 +26,6 @@
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/nametoaddr.c,v 1.83 2008-02-06 10:21:30 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
@@ -40,10 +35,36 @@ static const char rcsid[] _U_ =
|
||||
#include <netdnet/dnetdb.h>
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
|
||||
#else /* WIN32 */
|
||||
#ifdef INET6
|
||||
/*
|
||||
* To quote the MSDN page for getaddrinfo() at
|
||||
*
|
||||
* https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520(v=vs.85).aspx
|
||||
*
|
||||
* "Support for getaddrinfo on Windows 2000 and older versions
|
||||
* The getaddrinfo function was added to the Ws2_32.dll on Windows XP and
|
||||
* later. To execute an application that uses this function on earlier
|
||||
* versions of Windows, then you need to include the Ws2tcpip.h and
|
||||
* Wspiapi.h files. When the Wspiapi.h include file is added, the
|
||||
* getaddrinfo function is defined to the WspiapiGetAddrInfo inline
|
||||
* function in the Wspiapi.h file. At runtime, the WspiapiGetAddrInfo
|
||||
* function is implemented in such a way that if the Ws2_32.dll or the
|
||||
* Wship6.dll (the file containing getaddrinfo in the IPv6 Technology
|
||||
* Preview for Windows 2000) does not include getaddrinfo, then a
|
||||
* version of getaddrinfo is implemented inline based on code in the
|
||||
* Wspiapi.h header file. This inline code will be used on older Windows
|
||||
* platforms that do not natively support the getaddrinfo function."
|
||||
*
|
||||
* We use getaddrinfo(), so we include Wspiapi.h here. pcap-stdinc.h
|
||||
* includes Ws2tcpip.h, so we don't need to include it ourselves.
|
||||
*/
|
||||
#include <Wspiapi.h>
|
||||
#endif
|
||||
|
||||
#else /* _WIN32 */
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/types.h> /* concession to AIX */
|
||||
@@ -51,9 +72,9 @@ static const char rcsid[] _U_ =
|
||||
#include <sys/time.h>
|
||||
|
||||
#include <netinet/in.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
#ifdef HAVE_ETHER_HOSTTON
|
||||
/*
|
||||
* XXX - do we need any of this if <netinet/if_ether.h> doesn't declare
|
||||
@@ -71,7 +92,7 @@ struct rtentry; /* declarations in <net/if.h> */
|
||||
#endif /* HAVE_ETHER_HOSTTON */
|
||||
#include <arpa/inet.h>
|
||||
#include <netdb.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
@@ -83,6 +104,7 @@ struct rtentry; /* declarations in <net/if.h> */
|
||||
|
||||
#include "gencode.h"
|
||||
#include <pcap/namedb.h>
|
||||
#include "nametoaddr.h"
|
||||
|
||||
#ifdef HAVE_OS_PROTO_H
|
||||
#include "os-proto.h"
|
||||
@@ -149,7 +171,7 @@ pcap_nametoaddrinfo(const char *name)
|
||||
bpf_u_int32
|
||||
pcap_nametonetaddr(const char *name)
|
||||
{
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
struct netent *np;
|
||||
|
||||
if ((np = getnetbyname(name)) != NULL)
|
||||
@@ -159,6 +181,15 @@ pcap_nametonetaddr(const char *name)
|
||||
#else
|
||||
/*
|
||||
* There's no "getnetbyname()" on Windows.
|
||||
*
|
||||
* XXX - I guess we could use the BSD code to read
|
||||
* C:\Windows\System32\drivers\etc/networks, assuming
|
||||
* that's its home on all the versions of Windows
|
||||
* we use, but that file probably just has the loopback
|
||||
* network on 127/24 on 99 44/100% of Windows machines.
|
||||
*
|
||||
* (Heck, these days it probably just has that on 99 44/100%
|
||||
* of *UN*X* machines.)
|
||||
*/
|
||||
return 0;
|
||||
#endif
|
||||
@@ -283,8 +314,14 @@ struct eproto {
|
||||
u_short p;
|
||||
};
|
||||
|
||||
/* Static data base of ether protocol types. */
|
||||
struct eproto eproto_db[] = {
|
||||
/*
|
||||
* Static data base of ether protocol types.
|
||||
* tcpdump used to import this, and it's declared as an export on
|
||||
* Debian, at least, so make it a public symbol, even though we
|
||||
* don't officially export it by declaring it in a header file.
|
||||
* (Programs *should* do this themselves, as tcpdump now does.)
|
||||
*/
|
||||
PCAP_API_DEF struct eproto eproto_db[] = {
|
||||
#if 0
|
||||
/* The FreeBSD elf linker generates a request to copy this array
|
||||
* (including its size) when you link with -lpcap. In order to
|
||||
@@ -401,7 +438,7 @@ __pcap_atodn(const char *s, bpf_u_int32 *addr)
|
||||
u_int node, area;
|
||||
|
||||
if (sscanf(s, "%d.%d", &area, &node) != 2)
|
||||
bpf_error("malformed decnet address '%s'", s);
|
||||
return(0);
|
||||
|
||||
*addr = (area << AREASHIFT) & AREAMASK;
|
||||
*addr |= (node & NODEMASK);
|
||||
@@ -428,6 +465,8 @@ pcap_ether_aton(const char *s)
|
||||
register u_int d;
|
||||
|
||||
e = ep = (u_char *)malloc(6);
|
||||
if (e == NULL)
|
||||
return (NULL);
|
||||
|
||||
while (*s) {
|
||||
if (*s == ':' || *s == '.' || *s == '-')
|
||||
@@ -503,23 +542,20 @@ pcap_ether_hostton(const char *name)
|
||||
}
|
||||
#endif
|
||||
|
||||
u_short
|
||||
__pcap_nametodnaddr(const char *name)
|
||||
int
|
||||
__pcap_nametodnaddr(const char *name, u_short *res)
|
||||
{
|
||||
#ifdef DECNETLIB
|
||||
struct nodeent *getnodebyname();
|
||||
struct nodeent *nep;
|
||||
unsigned short res;
|
||||
|
||||
nep = getnodebyname(name);
|
||||
if (nep == ((struct nodeent *)0))
|
||||
bpf_error("unknown decnet host name '%s'\n", name);
|
||||
return(0);
|
||||
|
||||
memcpy((char *)&res, (char *)nep->n_addr, sizeof(unsigned short));
|
||||
return(res);
|
||||
memcpy((char *)res, (char *)nep->n_addr, sizeof(unsigned short));
|
||||
return(1);
|
||||
#else
|
||||
bpf_error("decnet name support not included, '%s' cannot be translated\n",
|
||||
name);
|
||||
return(0);
|
||||
#endif
|
||||
}
|
||||
|
||||
48
freebsd/contrib/libpcap/nametoaddr.h
Normal file
48
freebsd/contrib/libpcap/nametoaddr.h
Normal file
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* Copyright (c) 1994, 1996
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the Computer Systems
|
||||
* Engineering Group at Lawrence Berkeley Laboratory.
|
||||
* 4. Neither the name of the University nor of the Laboratory may be used
|
||||
* to endorse or promote products derived from this software without
|
||||
* specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Routines used for name-or-address-string-to-address resolution
|
||||
* that are *not* exported to code using libpcap.
|
||||
*/
|
||||
int __pcap_atodn(const char *, bpf_u_int32 *);
|
||||
int __pcap_atoin(const char *, bpf_u_int32 *);
|
||||
int __pcap_nametodnaddr(const char *, u_short *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -14,8 +14,6 @@
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/nlpid.h,v 1.2 2002-12-06 00:01:34 hannes Exp $ (Juniper)
|
||||
*/
|
||||
|
||||
/* Types missing from some systems */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -27,9 +27,9 @@
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
@@ -39,10 +39,14 @@
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include "pcap-int.h"
|
||||
#include "extract.h"
|
||||
#include "pcap/sll.h"
|
||||
#include "pcap/usb.h"
|
||||
#include "pcap/nflog.h"
|
||||
#include "pcap/can_socketcan.h"
|
||||
|
||||
#include "pcap-common.h"
|
||||
|
||||
@@ -352,7 +356,7 @@
|
||||
|
||||
#define LINKTYPE_GPRS_LLC 169 /* GPRS LLC */
|
||||
#define LINKTYPE_GPF_T 170 /* GPF-T (ITU-T G.7041/Y.1303) */
|
||||
#define LINKTYPE_GPF_F 171 /* GPF-T (ITU-T G.7041/Y.1303) */
|
||||
#define LINKTYPE_GPF_F 171 /* GPF-F (ITU-T G.7041/Y.1303) */
|
||||
|
||||
/*
|
||||
* Requested by Oolan Zimmer <oz@gcom.com> for use in Gcom's T1/E1 line
|
||||
@@ -387,7 +391,7 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* The Link Types are used for prepending meta-information
|
||||
* like interface index, interface name
|
||||
* before standard Ethernet, PPP, Frelay & C-HDLC Frames
|
||||
@@ -404,7 +408,7 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* The DLT_ is used for internal communication with a
|
||||
* voice Adapter Card (PIC)
|
||||
*/
|
||||
@@ -427,10 +431,17 @@
|
||||
#define LINKTYPE_A653_ICM 185
|
||||
|
||||
/*
|
||||
* USB packets, beginning with a USB setup header; requested by
|
||||
* Paolo Abeni <paolo.abeni@email.it>.
|
||||
* This used to be "USB packets, beginning with a USB setup header;
|
||||
* requested by Paolo Abeni <paolo.abeni@email.it>."
|
||||
*
|
||||
* However, that header didn't work all that well - it left out some
|
||||
* useful information - and was abandoned in favor of the DLT_USB_LINUX
|
||||
* header.
|
||||
*
|
||||
* This is now used by FreeBSD for its BPF taps for USB; that has its
|
||||
* own headers. So it is written, so it is done.
|
||||
*/
|
||||
#define LINKTYPE_USB 186
|
||||
#define LINKTYPE_USB_FREEBSD 186
|
||||
|
||||
/*
|
||||
* Bluetooth HCI UART transport layer (part H:4); requested by
|
||||
@@ -479,7 +490,7 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* The DLT_ is used for internal communication with a
|
||||
* integrated service module (ISM).
|
||||
*/
|
||||
@@ -520,7 +531,7 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* The DLT_ is used for capturing data on a secure tunnel interface.
|
||||
*/
|
||||
#define LINKTYPE_JUNIPER_ST 200
|
||||
@@ -612,11 +623,11 @@
|
||||
*/
|
||||
#define LINKTYPE_IEEE802_15_4_NONASK_PHY 215
|
||||
|
||||
/*
|
||||
/*
|
||||
* David Gibson <david@gibson.dropbear.id.au> requested this for
|
||||
* captures from the Linux kernel /dev/input/eventN devices. This
|
||||
* is used to communicate keystrokes and mouse movements from the
|
||||
* Linux kernel to display systems, such as Xorg.
|
||||
* Linux kernel to display systems, such as Xorg.
|
||||
*/
|
||||
#define LINKTYPE_LINUX_EVDEV 216
|
||||
|
||||
@@ -737,8 +748,10 @@
|
||||
|
||||
/*
|
||||
* CAN (Controller Area Network) frames, with a pseudo-header as supplied
|
||||
* by Linux SocketCAN. See Documentation/networking/can.txt in the Linux
|
||||
* source.
|
||||
* by Linux SocketCAN, and with multi-byte numerical fields in that header
|
||||
* in big-endian byte order.
|
||||
*
|
||||
* See Documentation/networking/can.txt in the Linux source.
|
||||
*
|
||||
* Requested by Felix Obenhuber <felix@obenhuber.de>.
|
||||
*/
|
||||
@@ -778,7 +791,7 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
*/
|
||||
#define LINKTYPE_JUNIPER_VS 232
|
||||
#define LINKTYPE_JUNIPER_SRX_E2E 233
|
||||
@@ -810,12 +823,12 @@
|
||||
|
||||
/*
|
||||
* Juniper-private data link type, as per request from
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
* Hannes Gredler <hannes@juniper.net>.
|
||||
*/
|
||||
#define LINKTYPE_JUNIPER_ATM_CEMIC 238
|
||||
|
||||
/*
|
||||
* NetFilter LOG messages
|
||||
* NetFilter LOG messages
|
||||
* (payload of netlink NFNL_SUBSYS_ULOG/NFULNL_MSG_PACKET packets)
|
||||
*
|
||||
* Requested by Jakub Zawadzki <darkjames-ws@darkjames.pl>
|
||||
@@ -899,7 +912,125 @@
|
||||
*/
|
||||
#define LINKTYPE_SCTP 248
|
||||
|
||||
#define LINKTYPE_MATCHING_MAX 248 /* highest value in the "matching" range */
|
||||
/*
|
||||
* USB packets, beginning with a USBPcap header.
|
||||
*
|
||||
* Requested by Tomasz Mon <desowin@gmail.com>
|
||||
*/
|
||||
#define LINKTYPE_USBPCAP 249
|
||||
|
||||
/*
|
||||
* Schweitzer Engineering Laboratories "RTAC" product serial-line
|
||||
* packets.
|
||||
*
|
||||
* Requested by Chris Bontje <chris_bontje@selinc.com>.
|
||||
*/
|
||||
#define DLT_RTAC_SERIAL 250
|
||||
|
||||
/*
|
||||
* Bluetooth Low Energy air interface link-layer packets.
|
||||
*
|
||||
* Requested by Mike Kershaw <dragorn@kismetwireless.net>.
|
||||
*/
|
||||
#define LINKTYPE_BLUETOOTH_LE_LL 251
|
||||
|
||||
/*
|
||||
* Link-layer header type for upper-protocol layer PDU saves from wireshark.
|
||||
*
|
||||
* the actual contents are determined by two TAGs stored with each
|
||||
* packet:
|
||||
* EXP_PDU_TAG_LINKTYPE the link type (LINKTYPE_ value) of the
|
||||
* original packet.
|
||||
*
|
||||
* EXP_PDU_TAG_PROTO_NAME the name of the wireshark dissector
|
||||
* that can make sense of the data stored.
|
||||
*/
|
||||
#define LINKTYPE_WIRESHARK_UPPER_PDU 252
|
||||
|
||||
/*
|
||||
* Link-layer header type for the netlink protocol (nlmon devices).
|
||||
*/
|
||||
#define LINKTYPE_NETLINK 253
|
||||
|
||||
/*
|
||||
* Bluetooth Linux Monitor headers for the BlueZ stack.
|
||||
*/
|
||||
#define LINKTYPE_BLUETOOTH_LINUX_MONITOR 254
|
||||
|
||||
/*
|
||||
* Bluetooth Basic Rate/Enhanced Data Rate baseband packets, as
|
||||
* captured by Ubertooth.
|
||||
*/
|
||||
#define LINKTYPE_BLUETOOTH_BREDR_BB 255
|
||||
|
||||
/*
|
||||
* Bluetooth Low Energy link layer packets, as captured by Ubertooth.
|
||||
*/
|
||||
#define LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR 256
|
||||
|
||||
/*
|
||||
* PROFIBUS data link layer.
|
||||
*/
|
||||
#define LINKTYPE_PROFIBUS_DL 257
|
||||
|
||||
/*
|
||||
* Apple's DLT_PKTAP headers.
|
||||
*
|
||||
* Sadly, the folks at Apple either had no clue that the DLT_USERn values
|
||||
* are for internal use within an organization and partners only, and
|
||||
* didn't know that the right way to get a link-layer header type is to
|
||||
* ask tcpdump.org for one, or knew and didn't care, so they just
|
||||
* used DLT_USER2, which causes problems for everything except for
|
||||
* their version of tcpdump.
|
||||
*
|
||||
* So I'll just give them one; hopefully this will show up in a
|
||||
* libpcap release in time for them to get this into 10.10 Big Sur
|
||||
* or whatever Mavericks' successor is called. LINKTYPE_PKTAP
|
||||
* will be 258 *even on OS X*; that is *intentional*, so that
|
||||
* PKTAP files look the same on *all* OSes (different OSes can have
|
||||
* different numerical values for a given DLT_, but *MUST NOT* have
|
||||
* different values for what goes in a file, as files can be moved
|
||||
* between OSes!).
|
||||
*/
|
||||
#define LINKTYPE_PKTAP 258
|
||||
|
||||
/*
|
||||
* Ethernet packets preceded by a header giving the last 6 octets
|
||||
* of the preamble specified by 802.3-2012 Clause 65, section
|
||||
* 65.1.3.2 "Transmit".
|
||||
*/
|
||||
#define LINKTYPE_EPON 259
|
||||
|
||||
/*
|
||||
* IPMI trace packets, as specified by Table 3-20 "Trace Data Block Format"
|
||||
* in the PICMG HPM.2 specification.
|
||||
*/
|
||||
#define LINKTYPE_IPMI_HPM_2 260
|
||||
|
||||
/*
|
||||
* per Joshua Wright <jwright@hasborg.com>, formats for Zwave captures.
|
||||
*/
|
||||
#define LINKTYPE_ZWAVE_R1_R2 261
|
||||
#define LINKTYPE_ZWAVE_R3 262
|
||||
|
||||
/*
|
||||
* per Steve Karg <skarg@users.sourceforge.net>, formats for Wattstopper
|
||||
* Digital Lighting Management room bus serial protocol captures.
|
||||
*/
|
||||
#define LINKTYPE_WATTSTOPPER_DLM 263
|
||||
|
||||
/*
|
||||
* ISO 14443 contactless smart card messages.
|
||||
*/
|
||||
#define LINKTYPE_ISO_14443 264
|
||||
|
||||
/*
|
||||
* Radio data system (RDS) groups. IEC 62106.
|
||||
* Per Jonathan Brucker <jonathan.brucke@gmail.com>.
|
||||
*/
|
||||
#define LINKTYPE_RDS 265
|
||||
|
||||
#define LINKTYPE_MATCHING_MAX 265 /* highest value in the "matching" range */
|
||||
|
||||
static struct linktype_map {
|
||||
int dlt;
|
||||
@@ -972,13 +1103,20 @@ dlt_to_linktype(int dlt)
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Map DLT_PFSYNC, whatever it might be, to LINKTYPE_PFSYNC.
|
||||
* DLTs that, on some platforms, have values in the matching range
|
||||
* but that *don't* have the same value as the corresponding
|
||||
* LINKTYPE because, for some reason, not all OSes have the
|
||||
* same value for that DLT (note that the DLT's value might be
|
||||
* outside the matching range on some of those OSes).
|
||||
*/
|
||||
if (dlt == DLT_PFSYNC)
|
||||
return (LINKTYPE_PFSYNC);
|
||||
if (dlt == DLT_PKTAP)
|
||||
return (LINKTYPE_PKTAP);
|
||||
|
||||
/*
|
||||
* Map the values in the matching range.
|
||||
* For all other values in the matching range, the DLT
|
||||
* value is the same as the LINKTYPE value.
|
||||
*/
|
||||
if (dlt >= DLT_MATCHING_MIN && dlt <= DLT_MATCHING_MAX)
|
||||
return (dlt);
|
||||
@@ -992,9 +1130,9 @@ dlt_to_linktype(int dlt)
|
||||
}
|
||||
|
||||
/*
|
||||
* If we don't have a mapping for this DLT_ code, return an
|
||||
* If we don't have a mapping for this DLT, return an
|
||||
* error; that means that this is a value with no corresponding
|
||||
* LINKTYPE_ code, and we need to assign one.
|
||||
* LINKTYPE, and we need to assign one.
|
||||
*/
|
||||
return (-1);
|
||||
}
|
||||
@@ -1005,16 +1143,19 @@ linktype_to_dlt(int linktype)
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Map LINKTYPE_PFSYNC to DLT_PFSYNC, whatever it might be.
|
||||
* LINKTYPE_PFSYNC is in the matching range, to make sure
|
||||
* it's as safe from reuse as we can arrange, so we do
|
||||
* this test first.
|
||||
* LINKTYPEs in the matching range that *don't*
|
||||
* have the same value as the corresponding DLTs
|
||||
* because, for some reason, not all OSes have the
|
||||
* same value for that DLT.
|
||||
*/
|
||||
if (linktype == LINKTYPE_PFSYNC)
|
||||
return (DLT_PFSYNC);
|
||||
if (linktype == LINKTYPE_PKTAP)
|
||||
return (DLT_PKTAP);
|
||||
|
||||
/*
|
||||
* Map the values in the matching range.
|
||||
* For all other values in the matching range, the LINKTYPE
|
||||
* value is the same as the DLT value.
|
||||
*/
|
||||
if (linktype >= LINKTYPE_MATCHING_MIN &&
|
||||
linktype <= LINKTYPE_MATCHING_MAX)
|
||||
@@ -1029,30 +1170,70 @@ linktype_to_dlt(int linktype)
|
||||
}
|
||||
|
||||
/*
|
||||
* If we don't have an entry for this link type, return
|
||||
* the link type value; it may be a DLT_ value from an
|
||||
* older version of libpcap.
|
||||
* If we don't have an entry for this LINKTYPE, return
|
||||
* the link type value; it may be a DLT from an older
|
||||
* version of libpcap.
|
||||
*/
|
||||
return linktype;
|
||||
}
|
||||
|
||||
#define EXTRACT_
|
||||
|
||||
/*
|
||||
* DLT_LINUX_SLL packets with a protocol type of LINUX_SLL_P_CAN or
|
||||
* LINUX_SLL_P_CANFD have SocketCAN headers in front of the payload,
|
||||
* with the CAN ID being in host byte order.
|
||||
*
|
||||
* When reading a DLT_LINUX_SLL capture file, we need to check for those
|
||||
* packets and convert the CAN ID from the byte order of the host that
|
||||
* wrote the file to this host's byte order.
|
||||
*/
|
||||
static void
|
||||
swap_linux_sll_header(const struct pcap_pkthdr *hdr, u_char *buf)
|
||||
{
|
||||
u_int caplen = hdr->caplen;
|
||||
u_int length = hdr->len;
|
||||
struct sll_header *shdr = (struct sll_header *)buf;
|
||||
u_int16_t protocol;
|
||||
pcap_can_socketcan_hdr *chdr;
|
||||
|
||||
if (caplen < (u_int) sizeof(struct sll_header) ||
|
||||
length < (u_int) sizeof(struct sll_header)) {
|
||||
/* Not enough data to have the protocol field */
|
||||
return;
|
||||
}
|
||||
|
||||
protocol = EXTRACT_16BITS(&shdr->sll_protocol);
|
||||
if (protocol != LINUX_SLL_P_CAN && protocol != LINUX_SLL_P_CANFD)
|
||||
return;
|
||||
|
||||
/*
|
||||
* SocketCAN packet; fix up the packet's header.
|
||||
*/
|
||||
chdr = (pcap_can_socketcan_hdr *)(buf + sizeof(struct sll_header));
|
||||
if (caplen < (u_int) sizeof(struct sll_header) + sizeof(chdr->can_id) ||
|
||||
length < (u_int) sizeof(struct sll_header) + sizeof(chdr->can_id)) {
|
||||
/* Not enough data to have the CAN ID */
|
||||
return;
|
||||
}
|
||||
chdr->can_id = SWAPLONG(chdr->can_id);
|
||||
}
|
||||
|
||||
/*
|
||||
* The DLT_USB_LINUX and DLT_USB_LINUX_MMAPPED headers are in host
|
||||
* byte order when capturing (it's supplied directly from a
|
||||
* memory-mapped buffer shared by the kernel).
|
||||
*
|
||||
* When reading a DLT_USB_LINUX or DLT_USB_LINUX_MMAPPED capture file,
|
||||
* we need to convert it from the capturing host's byte order to
|
||||
* the reading host's byte order.
|
||||
* we need to convert it from the byte order of the host that wrote
|
||||
* the file to this host's byte order.
|
||||
*/
|
||||
void
|
||||
static void
|
||||
swap_linux_usb_header(const struct pcap_pkthdr *hdr, u_char *buf,
|
||||
int header_len_64_bytes)
|
||||
{
|
||||
pcap_usb_header_mmapped *uhdr = (pcap_usb_header_mmapped *)buf;
|
||||
bpf_u_int32 offset = 0;
|
||||
usb_isodesc *pisodesc;
|
||||
int32_t numdesc, i;
|
||||
|
||||
/*
|
||||
* "offset" is the offset *past* the field we're swapping;
|
||||
@@ -1061,7 +1242,7 @@ swap_linux_usb_header(const struct pcap_pkthdr *hdr, u_char *buf,
|
||||
*/
|
||||
|
||||
/*
|
||||
* The URB id is a totally opaque value; do we really need to
|
||||
* The URB id is a totally opaque value; do we really need to
|
||||
* convert it to the reading host's byte order???
|
||||
*/
|
||||
offset += 8; /* skip past id */
|
||||
@@ -1116,6 +1297,17 @@ swap_linux_usb_header(const struct pcap_pkthdr *hdr, u_char *buf,
|
||||
} else
|
||||
offset += 8; /* skip USB setup header */
|
||||
|
||||
/*
|
||||
* With the old header, there are no isochronous descriptors
|
||||
* after the header.
|
||||
*
|
||||
* With the new header, the actual number of descriptors in
|
||||
* the header is not s.iso.numdesc, it's ndesc - only the
|
||||
* first N descriptors, for some value of N, are put into
|
||||
* the header, and ndesc is set to the actual number copied.
|
||||
* In addition, if s.iso.numdesc is negative, no descriptors
|
||||
* are captured, and ndesc is set to 0.
|
||||
*/
|
||||
if (header_len_64_bytes) {
|
||||
/*
|
||||
* This is either the "version 1" header, with
|
||||
@@ -1144,31 +1336,128 @@ swap_linux_usb_header(const struct pcap_pkthdr *hdr, u_char *buf,
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
uhdr->ndesc = SWAPLONG(uhdr->ndesc);
|
||||
}
|
||||
|
||||
if (uhdr->transfer_type == URB_ISOCHRONOUS) {
|
||||
/* swap the values in struct linux_usb_isodesc */
|
||||
pisodesc = (usb_isodesc *)(void *)(buf+offset);
|
||||
numdesc = uhdr->s.iso.numdesc;
|
||||
for (i = 0; i < numdesc; i++) {
|
||||
offset += 4; /* skip past status */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->status = SWAPLONG(pisodesc->status);
|
||||
if (uhdr->transfer_type == URB_ISOCHRONOUS) {
|
||||
/* swap the values in struct linux_usb_isodesc */
|
||||
usb_isodesc *pisodesc;
|
||||
u_int32_t i;
|
||||
|
||||
offset += 4; /* skip past offset */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->offset = SWAPLONG(pisodesc->offset);
|
||||
pisodesc = (usb_isodesc *)(void *)(buf+offset);
|
||||
for (i = 0; i < uhdr->ndesc; i++) {
|
||||
offset += 4; /* skip past status */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->status = SWAPLONG(pisodesc->status);
|
||||
|
||||
offset += 4; /* skip past len */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->len = SWAPLONG(pisodesc->len);
|
||||
offset += 4; /* skip past offset */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->offset = SWAPLONG(pisodesc->offset);
|
||||
|
||||
offset += 4; /* skip past padding */
|
||||
offset += 4; /* skip past len */
|
||||
if (hdr->caplen < offset)
|
||||
return;
|
||||
pisodesc->len = SWAPLONG(pisodesc->len);
|
||||
|
||||
pisodesc++;
|
||||
offset += 4; /* skip past padding */
|
||||
|
||||
pisodesc++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* The DLT_NFLOG "packets" have a mixture of big-endian and host-byte-order
|
||||
* data. They begin with a fixed-length header with big-endian fields,
|
||||
* followed by a set of TLVs, where the type and length are in host
|
||||
* byte order but the values are either big-endian or are a raw byte
|
||||
* sequence that's the same regardless of the host's byte order.
|
||||
*
|
||||
* When reading a DLT_NFLOG capture file, we need to convert the type
|
||||
* and length values from the byte order of the host that wrote the
|
||||
* file to the byte order of this host.
|
||||
*/
|
||||
static void
|
||||
swap_nflog_header(const struct pcap_pkthdr *hdr, u_char *buf)
|
||||
{
|
||||
u_char *p = buf;
|
||||
nflog_hdr_t *nfhdr = (nflog_hdr_t *)buf;
|
||||
nflog_tlv_t *tlv;
|
||||
u_int caplen = hdr->caplen;
|
||||
u_int length = hdr->len;
|
||||
u_int16_t size;
|
||||
|
||||
if (caplen < (u_int) sizeof(nflog_hdr_t) ||
|
||||
length < (u_int) sizeof(nflog_hdr_t)) {
|
||||
/* Not enough data to have any TLVs. */
|
||||
return;
|
||||
}
|
||||
|
||||
if (nfhdr->nflog_version != 0) {
|
||||
/* Unknown NFLOG version */
|
||||
return;
|
||||
}
|
||||
|
||||
length -= sizeof(nflog_hdr_t);
|
||||
caplen -= sizeof(nflog_hdr_t);
|
||||
p += sizeof(nflog_hdr_t);
|
||||
|
||||
while (caplen >= sizeof(nflog_tlv_t)) {
|
||||
tlv = (nflog_tlv_t *) p;
|
||||
|
||||
/* Swap the type and length. */
|
||||
tlv->tlv_type = SWAPSHORT(tlv->tlv_type);
|
||||
tlv->tlv_length = SWAPSHORT(tlv->tlv_length);
|
||||
|
||||
/* Get the length of the TLV. */
|
||||
size = tlv->tlv_length;
|
||||
if (size % 4 != 0)
|
||||
size += 4 - size % 4;
|
||||
|
||||
/* Is the TLV's length less than the minimum? */
|
||||
if (size < sizeof(nflog_tlv_t)) {
|
||||
/* Yes. Give up now. */
|
||||
return;
|
||||
}
|
||||
|
||||
/* Do we have enough data for the full TLV? */
|
||||
if (caplen < size || length < size) {
|
||||
/* No. */
|
||||
return;
|
||||
}
|
||||
|
||||
/* Skip over the TLV. */
|
||||
length -= size;
|
||||
caplen -= size;
|
||||
p += size;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
swap_pseudo_headers(int linktype, struct pcap_pkthdr *hdr, u_char *data)
|
||||
{
|
||||
/*
|
||||
* Convert pseudo-headers from the byte order of
|
||||
* the host on which the file was saved to our
|
||||
* byte order, as necessary.
|
||||
*/
|
||||
switch (linktype) {
|
||||
|
||||
case DLT_LINUX_SLL:
|
||||
swap_linux_sll_header(hdr, data);
|
||||
break;
|
||||
|
||||
case DLT_USB_LINUX:
|
||||
swap_linux_usb_header(hdr, data, 0);
|
||||
break;
|
||||
|
||||
case DLT_USB_LINUX_MMAPPED:
|
||||
swap_linux_usb_header(hdr, data, 1);
|
||||
break;
|
||||
|
||||
case DLT_NFLOG:
|
||||
swap_nflog_header(hdr, data);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,5 +21,5 @@ extern int dlt_to_linktype(int dlt);
|
||||
|
||||
extern int linktype_to_dlt(int linktype);
|
||||
|
||||
extern void swap_linux_usb_header(const struct pcap_pkthdr *hdr, u_char *buf,
|
||||
int header_len_64_bytes);
|
||||
extern void swap_pseudo_headers(int linktype, struct pcap_pkthdr *hdr,
|
||||
u_char *data);
|
||||
|
||||
@@ -29,8 +29,6 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap-int.h,v 1.94 2008-09-16 00:20:23 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
#ifndef pcap_int_h
|
||||
@@ -42,22 +40,16 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_LIBDLPI
|
||||
#include <libdlpi.h>
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#include <Packet32.h>
|
||||
extern CRITICAL_SECTION g_PcapCompileCriticalSection;
|
||||
#endif /* WIN32 */
|
||||
|
||||
#ifdef MSDOS
|
||||
#include <fcntl.h>
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SNF_API
|
||||
#include <snf.h>
|
||||
#if defined(_WIN32)
|
||||
/*
|
||||
* Make sure Packet32.h doesn't define BPF structures that we've
|
||||
* probably already defined as a result of including <pcap/pcap.h>.
|
||||
*/
|
||||
#define BPF_MAJOR_VERSION
|
||||
#include <Packet32.h>
|
||||
#elif defined(MSDOS)
|
||||
#include <fcntl.h>
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#if (defined(_MSC_VER) && (_MSC_VER <= 1200)) /* we are compiling with Visual Studio 6, that doesn't support the LL suffix*/
|
||||
@@ -93,139 +85,39 @@ extern CRITICAL_SECTION g_PcapCompileCriticalSection;
|
||||
#endif /* _MSC_VER */
|
||||
|
||||
/*
|
||||
* Savefile
|
||||
* Maximum snapshot length.
|
||||
*
|
||||
* Somewhat arbitrary, but chosen to be:
|
||||
*
|
||||
* 1) big enough for maximum-size Linux loopback packets (65549)
|
||||
* and some USB packets captured with USBPcap:
|
||||
*
|
||||
* http://desowin.org/usbpcap/
|
||||
*
|
||||
* (> 131072, < 262144)
|
||||
*
|
||||
* and
|
||||
*
|
||||
* 2) small enough not to cause attempts to allocate huge amounts of
|
||||
* memory; some applications might use the snapshot length in a
|
||||
* savefile header to control the size of the buffer they allocate,
|
||||
* so a size of, say, 2^31-1 might not work well.
|
||||
*
|
||||
* We don't enforce this in pcap_set_snaplen(), but we use it internally.
|
||||
*/
|
||||
typedef enum {
|
||||
NOT_SWAPPED,
|
||||
SWAPPED,
|
||||
MAYBE_SWAPPED
|
||||
} swapped_type_t;
|
||||
|
||||
/*
|
||||
* Used when reading a savefile.
|
||||
*/
|
||||
struct pcap_sf {
|
||||
FILE *rfile;
|
||||
int (*next_packet_op)(pcap_t *, struct pcap_pkthdr *, u_char **);
|
||||
int swapped;
|
||||
size_t hdrsize;
|
||||
swapped_type_t lengths_swapped;
|
||||
int version_major;
|
||||
int version_minor;
|
||||
bpf_u_int32 ifcount; /* number of interfaces seen in this capture */
|
||||
u_int tsresol; /* time stamp resolution */
|
||||
u_int tsscale; /* scaling factor for resolution -> microseconds */
|
||||
u_int64_t tsoffset; /* time stamp offset */
|
||||
};
|
||||
|
||||
/*
|
||||
* Used when doing a live capture.
|
||||
*/
|
||||
struct pcap_md {
|
||||
struct pcap_stat stat;
|
||||
/*XXX*/
|
||||
int use_bpf; /* using kernel filter */
|
||||
u_long TotPkts; /* can't oflow for 79 hrs on ether */
|
||||
u_long TotAccepted; /* count accepted by filter */
|
||||
u_long TotDrops; /* count of dropped packets */
|
||||
long TotMissed; /* missed by i/f during this run */
|
||||
long OrigMissed; /* missed by i/f before this run */
|
||||
char *device; /* device name */
|
||||
int timeout; /* timeout for buffering */
|
||||
int must_do_on_close; /* stuff we must do when we close */
|
||||
struct pcap *next; /* list of open pcaps that need stuff cleared on close */
|
||||
#ifdef linux
|
||||
int sock_packet; /* using Linux 2.0 compatible interface */
|
||||
int cooked; /* using SOCK_DGRAM rather than SOCK_RAW */
|
||||
int ifindex; /* interface index of device we're bound to */
|
||||
int lo_ifindex; /* interface index of the loopback device */
|
||||
u_int packets_read; /* count of packets read with recvfrom() */
|
||||
bpf_u_int32 oldmode; /* mode to restore when turning monitor mode off */
|
||||
char *mondevice; /* mac80211 monitor device we created */
|
||||
u_char *mmapbuf; /* memory-mapped region pointer */
|
||||
size_t mmapbuflen; /* size of region */
|
||||
int vlan_offset; /* offset at which to insert vlan tags; if -1, don't insert */
|
||||
u_int tp_version; /* version of tpacket_hdr for mmaped ring */
|
||||
u_int tp_hdrlen; /* hdrlen of tpacket_hdr for mmaped ring */
|
||||
u_char *oneshot_buffer; /* buffer for copy of packet */
|
||||
long proc_dropped; /* packets reported dropped by /proc/net/dev */
|
||||
#endif /* linux */
|
||||
|
||||
#ifdef HAVE_DAG_API
|
||||
#ifdef HAVE_DAG_STREAMS_API
|
||||
u_char *dag_mem_bottom; /* DAG card current memory bottom pointer */
|
||||
u_char *dag_mem_top; /* DAG card current memory top pointer */
|
||||
#else /* HAVE_DAG_STREAMS_API */
|
||||
void *dag_mem_base; /* DAG card memory base address */
|
||||
u_int dag_mem_bottom; /* DAG card current memory bottom offset */
|
||||
u_int dag_mem_top; /* DAG card current memory top offset */
|
||||
#endif /* HAVE_DAG_STREAMS_API */
|
||||
int dag_fcs_bits; /* Number of checksum bits from link layer */
|
||||
int dag_offset_flags; /* Flags to pass to dag_offset(). */
|
||||
int dag_stream; /* DAG stream number */
|
||||
int dag_timeout; /* timeout specified to pcap_open_live.
|
||||
* Same as in linux above, introduce
|
||||
* generally? */
|
||||
#endif /* HAVE_DAG_API */
|
||||
#ifdef HAVE_SNF_API
|
||||
snf_handle_t snf_handle; /* opaque device handle */
|
||||
snf_ring_t snf_ring; /* opaque device ring handle */
|
||||
int snf_timeout;
|
||||
int snf_boardnum;
|
||||
#endif /*HAVE_SNF_API*/
|
||||
|
||||
#ifdef HAVE_ZEROCOPY_BPF
|
||||
/*
|
||||
* Zero-copy read buffer -- for zero-copy BPF. 'buffer' above will
|
||||
* alternative between these two actual mmap'd buffers as required.
|
||||
* As there is a header on the front size of the mmap'd buffer, only
|
||||
* some of the buffer is exposed to libpcap as a whole via bufsize;
|
||||
* zbufsize is the true size. zbuffer tracks the current zbuf
|
||||
* assocated with buffer so that it can be used to decide which the
|
||||
* next buffer to read will be.
|
||||
*/
|
||||
u_char *zbuf1, *zbuf2, *zbuffer;
|
||||
u_int zbufsize;
|
||||
u_int zerocopy;
|
||||
u_int interrupted;
|
||||
struct timespec firstsel;
|
||||
/*
|
||||
* If there's currently a buffer being actively processed, then it is
|
||||
* referenced here; 'buffer' is also pointed at it, but offset by the
|
||||
* size of the header.
|
||||
*/
|
||||
struct bpf_zbuf_header *bzh;
|
||||
#endif /* HAVE_ZEROCOPY_BPF */
|
||||
};
|
||||
|
||||
/*
|
||||
* Stuff to do when we close.
|
||||
*/
|
||||
#define MUST_CLEAR_PROMISC 0x00000001 /* clear promiscuous mode */
|
||||
#define MUST_CLEAR_RFMON 0x00000002 /* clear rfmon (monitor) mode */
|
||||
#define MUST_DELETE_MONIF 0x00000004 /* delete monitor-mode interface */
|
||||
#define MAXIMUM_SNAPLEN 262144
|
||||
|
||||
struct pcap_opt {
|
||||
int buffer_size;
|
||||
char *source;
|
||||
char *device;
|
||||
int timeout; /* timeout for buffering */
|
||||
u_int buffer_size;
|
||||
int promisc;
|
||||
int rfmon;
|
||||
int rfmon; /* monitor mode */
|
||||
int immediate; /* immediate mode - deliver packets as soon as they arrive */
|
||||
int tstamp_type;
|
||||
int tstamp_precision;
|
||||
};
|
||||
|
||||
/*
|
||||
* Ultrix, DEC OSF/1^H^H^H^H^H^H^H^H^HDigital UNIX^H^H^H^H^H^H^H^H^H^H^H^H
|
||||
* Tru64 UNIX, and some versions of NetBSD pad FDDI packets to make everything
|
||||
* line up on a nice boundary.
|
||||
*/
|
||||
#ifdef __NetBSD__
|
||||
#include <sys/param.h> /* needed to declare __NetBSD_Version__ */
|
||||
#endif
|
||||
|
||||
#if defined(ultrix) || defined(__osf__) || (defined(__NetBSD__) && __NetBSD_Version__ > 106000000)
|
||||
#define PCAP_FDDIPAD 3
|
||||
#endif
|
||||
|
||||
typedef int (*activate_op_t)(pcap_t *);
|
||||
typedef int (*can_set_rfmon_op_t)(pcap_t *);
|
||||
typedef int (*read_op_t)(pcap_t *, int cnt, pcap_handler, u_char *);
|
||||
@@ -236,27 +128,70 @@ typedef int (*set_datalink_op_t)(pcap_t *, int);
|
||||
typedef int (*getnonblock_op_t)(pcap_t *, char *);
|
||||
typedef int (*setnonblock_op_t)(pcap_t *, int, char *);
|
||||
typedef int (*stats_op_t)(pcap_t *, struct pcap_stat *);
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
typedef struct pcap_stat *(*stats_ex_op_t)(pcap_t *, int *);
|
||||
typedef int (*setbuff_op_t)(pcap_t *, int);
|
||||
typedef int (*setmode_op_t)(pcap_t *, int);
|
||||
typedef int (*setmintocopy_op_t)(pcap_t *, int);
|
||||
typedef HANDLE (*getevent_op_t)(pcap_t *);
|
||||
typedef int (*oid_get_request_op_t)(pcap_t *, bpf_u_int32, void *, size_t *);
|
||||
typedef int (*oid_set_request_op_t)(pcap_t *, bpf_u_int32, const void *, size_t *);
|
||||
typedef u_int (*sendqueue_transmit_op_t)(pcap_t *, pcap_send_queue *, int);
|
||||
typedef int (*setuserbuffer_op_t)(pcap_t *, int);
|
||||
typedef int (*live_dump_op_t)(pcap_t *, char *, int, int);
|
||||
typedef int (*live_dump_ended_op_t)(pcap_t *, int);
|
||||
typedef PAirpcapHandle (*get_airpcap_handle_op_t)(pcap_t *);
|
||||
#endif
|
||||
typedef void (*cleanup_op_t)(pcap_t *);
|
||||
|
||||
/*
|
||||
* We put all the stuff used in the read code path at the beginning,
|
||||
* to try to keep it together in the same cache line or lines.
|
||||
*/
|
||||
struct pcap {
|
||||
#ifdef WIN32
|
||||
/*
|
||||
* Method to call to read packets on a live capture.
|
||||
*/
|
||||
read_op_t read_op;
|
||||
|
||||
/*
|
||||
* Method to call to read packets from a savefile.
|
||||
*/
|
||||
int (*next_packet_op)(pcap_t *, struct pcap_pkthdr *, u_char **);
|
||||
|
||||
#ifdef _WIN32
|
||||
ADAPTER *adapter;
|
||||
LPPACKET Packet;
|
||||
int nonblock;
|
||||
#else
|
||||
int fd;
|
||||
int selectable_fd;
|
||||
int send_fd;
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/*
|
||||
* Read buffer.
|
||||
*/
|
||||
u_int bufsize;
|
||||
void *buffer;
|
||||
u_char *bp;
|
||||
int cc;
|
||||
|
||||
int break_loop; /* flag set to force break from packet-reading loop */
|
||||
|
||||
void *priv; /* private data for methods */
|
||||
|
||||
int swapped;
|
||||
FILE *rfile; /* null if live capture, non-null if savefile */
|
||||
u_int fddipad;
|
||||
struct pcap *next; /* list of open pcaps that need stuff cleared on close */
|
||||
|
||||
/*
|
||||
* File version number; meaningful only for a savefile, but we
|
||||
* keep it here so that apps that (mistakenly) ask for the
|
||||
* version numbers will get the same zero values that they
|
||||
* always did.
|
||||
*/
|
||||
int version_major;
|
||||
int version_minor;
|
||||
|
||||
#ifdef HAVE_LIBDLPI
|
||||
dlpi_handle_t dlpi_hd;
|
||||
#endif
|
||||
int snapshot;
|
||||
int linktype; /* Network linktype */
|
||||
int linktype_ext; /* Extended information stored in the linktype field of a file */
|
||||
@@ -265,42 +200,45 @@ struct pcap {
|
||||
int activated; /* true if the capture is really started */
|
||||
int oldstyle; /* if we're opening with pcap_open_live() */
|
||||
|
||||
int break_loop; /* flag set to force break from packet-reading loop */
|
||||
|
||||
#ifdef PCAP_FDDIPAD
|
||||
int fddipad;
|
||||
#endif
|
||||
|
||||
#ifdef MSDOS
|
||||
void (*wait_proc)(void); /* call proc while waiting */
|
||||
#endif
|
||||
|
||||
struct pcap_sf sf;
|
||||
struct pcap_md md;
|
||||
struct pcap_opt opt;
|
||||
|
||||
/*
|
||||
* Read buffer.
|
||||
*/
|
||||
int bufsize;
|
||||
u_char *buffer;
|
||||
u_char *bp;
|
||||
int cc;
|
||||
|
||||
/*
|
||||
* Place holder for pcap_next().
|
||||
*/
|
||||
u_char *pkt;
|
||||
|
||||
#ifdef _WIN32
|
||||
struct pcap_stat stat; /* used for pcap_stats_ex() */
|
||||
#endif
|
||||
|
||||
/* We're accepting only packets in this direction/these directions. */
|
||||
pcap_direction_t direction;
|
||||
|
||||
/*
|
||||
* Methods.
|
||||
* Flags to affect BPF code generation.
|
||||
*/
|
||||
int bpf_codegen_flags;
|
||||
|
||||
/*
|
||||
* Placeholder for filter code if bpf not in kernel.
|
||||
*/
|
||||
struct bpf_program fcode;
|
||||
|
||||
char errbuf[PCAP_ERRBUF_SIZE + 1];
|
||||
int dlt_count;
|
||||
u_int *dlt_list;
|
||||
int tstamp_type_count;
|
||||
u_int *tstamp_type_list;
|
||||
int tstamp_precision_count;
|
||||
u_int *tstamp_precision_list;
|
||||
|
||||
struct pcap_pkthdr pcap_header; /* This is needed for the pcap_next_ex() to work */
|
||||
|
||||
/*
|
||||
* More methods.
|
||||
*/
|
||||
activate_op_t activate_op;
|
||||
can_set_rfmon_op_t can_set_rfmon_op;
|
||||
read_op_t read_op;
|
||||
inject_op_t inject_op;
|
||||
setfilter_op_t setfilter_op;
|
||||
setdirection_op_t setdirection_op;
|
||||
@@ -314,31 +252,32 @@ struct pcap {
|
||||
*/
|
||||
pcap_handler oneshot_callback;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
* These are, at least currently, specific to the Win32 NPF
|
||||
* driver.
|
||||
*/
|
||||
stats_ex_op_t stats_ex_op;
|
||||
setbuff_op_t setbuff_op;
|
||||
setmode_op_t setmode_op;
|
||||
setmintocopy_op_t setmintocopy_op;
|
||||
getevent_op_t getevent_op;
|
||||
oid_get_request_op_t oid_get_request_op;
|
||||
oid_set_request_op_t oid_set_request_op;
|
||||
sendqueue_transmit_op_t sendqueue_transmit_op;
|
||||
setuserbuffer_op_t setuserbuffer_op;
|
||||
live_dump_op_t live_dump_op;
|
||||
live_dump_ended_op_t live_dump_ended_op;
|
||||
get_airpcap_handle_op_t get_airpcap_handle_op;
|
||||
#endif
|
||||
cleanup_op_t cleanup_op;
|
||||
|
||||
/*
|
||||
* Placeholder for filter code if bpf not in kernel.
|
||||
*/
|
||||
struct bpf_program fcode;
|
||||
|
||||
char errbuf[PCAP_ERRBUF_SIZE + 1];
|
||||
int dlt_count;
|
||||
u_int *dlt_list;
|
||||
int tstamp_type_count;
|
||||
u_int *tstamp_type_list;
|
||||
|
||||
struct pcap_pkthdr pcap_header; /* This is needed for the pcap_next_ex() to work */
|
||||
};
|
||||
|
||||
/*
|
||||
* BPF code generation flags.
|
||||
*/
|
||||
#define BPF_SPECIAL_VLAN_HANDLING 0x00000001 /* special VLAN handling for Linux */
|
||||
|
||||
/*
|
||||
* This is a timeval as stored in a savefile.
|
||||
* It has to use the same types everywhere, independent of the actual
|
||||
@@ -377,7 +316,7 @@ struct pcap_timeval {
|
||||
*
|
||||
* Then supply the changes by forking the branch at
|
||||
*
|
||||
* https://github.com/mcr/libpcap/issues
|
||||
* https://github.com/the-tcpdump-group/libpcap/issues
|
||||
*
|
||||
* and issuing a pull request, so that future versions of libpcap and
|
||||
* programs that use it (such as tcpdump) will be able to read your new
|
||||
@@ -419,39 +358,26 @@ struct oneshot_userdata {
|
||||
pcap_t *pd;
|
||||
};
|
||||
|
||||
int yylex(void);
|
||||
|
||||
#ifndef min
|
||||
#define min(a, b) ((a) > (b) ? (b) : (a))
|
||||
#endif
|
||||
|
||||
/* XXX should these be in pcap.h? */
|
||||
int pcap_offline_read(pcap_t *, int, pcap_handler, u_char *);
|
||||
int pcap_read(pcap_t *, int cnt, pcap_handler, u_char *);
|
||||
|
||||
#ifndef HAVE_STRLCPY
|
||||
#define strlcpy(x, y, z) \
|
||||
(strncpy((x), (y), (z)), \
|
||||
((z) <= 0 ? 0 : ((x)[(z) - 1] = '\0')), \
|
||||
strlen((y)))
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#if !defined(HAVE_SNPRINTF)
|
||||
#define snprintf pcap_snprintf
|
||||
extern int snprintf (char *, size_t, const char *, ...);
|
||||
#endif
|
||||
#include "portability.h"
|
||||
|
||||
#if !defined(HAVE_VSNPRINTF)
|
||||
#define vsnprintf pcap_vsnprintf
|
||||
extern int vsnprintf (char *, size_t, const char *, va_list ap);
|
||||
#endif
|
||||
/*
|
||||
* Does the packet count argument to a module's read routine say
|
||||
* "supply packets until you run out of packets"?
|
||||
*/
|
||||
#define PACKET_COUNT_IS_UNLIMITED(count) ((count) <= 0)
|
||||
|
||||
/*
|
||||
* Routines that most pcap implementations can use for non-blocking mode.
|
||||
*/
|
||||
#if !defined(WIN32) && !defined(MSDOS)
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
int pcap_getnonblock_fd(pcap_t *, char *);
|
||||
int pcap_setnonblock_fd(pcap_t *p, int, char *);
|
||||
#endif
|
||||
@@ -468,38 +394,68 @@ int pcap_setnonblock_fd(pcap_t *p, int, char *);
|
||||
* by pcap_create routines.
|
||||
*/
|
||||
pcap_t *pcap_create_interface(const char *, char *);
|
||||
pcap_t *pcap_create_common(const char *, char *);
|
||||
pcap_t *pcap_create_common(char *, size_t);
|
||||
int pcap_do_addexit(pcap_t *);
|
||||
void pcap_add_to_pcaps_to_close(pcap_t *);
|
||||
void pcap_remove_from_pcaps_to_close(pcap_t *);
|
||||
void pcap_cleanup_live_common(pcap_t *);
|
||||
int pcap_not_initialized(pcap_t *);
|
||||
int pcap_check_activated(pcap_t *);
|
||||
|
||||
/*
|
||||
* Internal interfaces for "pcap_findalldevs()".
|
||||
*
|
||||
* "pcap_findalldevs_interfaces()" finds interfaces using the
|
||||
* "standard" mechanisms (SIOCGIFCONF, "getifaddrs()", etc.).
|
||||
*
|
||||
* "pcap_platform_finddevs()" is a platform-dependent routine to
|
||||
* add devices not found by the "standard" mechanisms.
|
||||
* find local network interfaces.
|
||||
*
|
||||
* "pcap_findalldevs_interfaces()" is a helper to find those interfaces
|
||||
* using the "standard" mechanisms (SIOCGIFCONF, "getifaddrs()", etc.).
|
||||
*
|
||||
* "pcap_add_if()" adds an interface to the list of interfaces, for
|
||||
* use by various "find interfaces" routines.
|
||||
*/
|
||||
int pcap_findalldevs_interfaces(pcap_if_t **, char *);
|
||||
int pcap_platform_finddevs(pcap_if_t **, char *);
|
||||
int add_addr_to_iflist(pcap_if_t **, const char *, u_int, struct sockaddr *,
|
||||
size_t, struct sockaddr *, size_t, struct sockaddr *, size_t,
|
||||
struct sockaddr *, size_t, char *);
|
||||
int pcap_add_if(pcap_if_t **, const char *, u_int, const char *, char *);
|
||||
struct sockaddr *dup_sockaddr(struct sockaddr *, size_t);
|
||||
int add_or_find_if(pcap_if_t **, pcap_if_t **, const char *, u_int,
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
int pcap_findalldevs_interfaces(pcap_if_t **, char *,
|
||||
int (*)(const char *));
|
||||
#endif
|
||||
int add_addr_to_iflist(pcap_if_t **, const char *, bpf_u_int32,
|
||||
struct sockaddr *, size_t, struct sockaddr *, size_t,
|
||||
struct sockaddr *, size_t, struct sockaddr *, size_t, char *);
|
||||
int add_addr_to_dev(pcap_if_t *, struct sockaddr *, size_t,
|
||||
struct sockaddr *, size_t, struct sockaddr *, size_t,
|
||||
struct sockaddr *dstaddr, size_t, char *errbuf);
|
||||
int pcap_add_if(pcap_if_t **, const char *, bpf_u_int32, const char *,
|
||||
char *);
|
||||
int add_or_find_if(pcap_if_t **, pcap_if_t **, const char *, bpf_u_int32,
|
||||
const char *, char *);
|
||||
#ifndef _WIN32
|
||||
bpf_u_int32 if_flags_to_pcap_flags(const char *, u_int);
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
char *pcap_win32strerror(void);
|
||||
/*
|
||||
* Internal interfaces for "pcap_open_offline()".
|
||||
*
|
||||
* "pcap_open_offline_common()" allocates and fills in a pcap_t, for use
|
||||
* by pcap_open_offline routines.
|
||||
*
|
||||
* "sf_cleanup()" closes the file handle associated with a pcap_t, if
|
||||
* appropriate, and frees all data common to all modules for handling
|
||||
* savefile types.
|
||||
*/
|
||||
pcap_t *pcap_open_offline_common(char *ebuf, size_t size);
|
||||
void sf_cleanup(pcap_t *p);
|
||||
|
||||
/*
|
||||
* Internal interfaces for both "pcap_create()" and routines that
|
||||
* open savefiles.
|
||||
*
|
||||
* "pcap_oneshot()" is the standard one-shot callback for "pcap_next()"
|
||||
* and "pcap_next_ex()".
|
||||
*/
|
||||
void pcap_oneshot(u_char *, const struct pcap_pkthdr *, const u_char *);
|
||||
|
||||
#ifdef _WIN32
|
||||
void pcap_win32_err_to_str(DWORD, char *);
|
||||
#endif
|
||||
|
||||
int install_bpf_program(pcap_t *, struct bpf_program *);
|
||||
|
||||
@@ -29,8 +29,6 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap-namedb.h,v 1.13 2006-10-04 18:13:32 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -29,8 +29,6 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap.h,v 1.59 2006-10-04 18:09:22 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
54
freebsd/contrib/libpcap/pcap/can_socketcan.h
Normal file
54
freebsd/contrib/libpcap/pcap/can_socketcan.h
Normal file
@@ -0,0 +1,54 @@
|
||||
/*-
|
||||
* Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from the Stanford/CMU enet packet filter,
|
||||
* (net/enet.c) distributed as part of 4.3BSD, and code contributed
|
||||
* to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
|
||||
* Berkeley Laboratory.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lib_pcap_can_socketcan_h
|
||||
#define lib_pcap_can_socketcan_h
|
||||
|
||||
/*
|
||||
* SocketCAN header, as per Documentation/networking/can.txt in the
|
||||
* Linux source.
|
||||
*/
|
||||
typedef struct {
|
||||
u_int32_t can_id;
|
||||
u_int8_t payload_length;
|
||||
u_int8_t pad;
|
||||
u_int8_t reserved1;
|
||||
u_int8_t reserved2;
|
||||
} pcap_can_socketcan_hdr;
|
||||
|
||||
#endif
|
||||
108
freebsd/contrib/libpcap/pcap/export-defs.h
Normal file
108
freebsd/contrib/libpcap/pcap/export-defs.h
Normal file
@@ -0,0 +1,108 @@
|
||||
/* -*- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -*- */
|
||||
/*
|
||||
* Copyright (c) 1993, 1994, 1995, 1996, 1997
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the Computer Systems
|
||||
* Engineering Group at Lawrence Berkeley Laboratory.
|
||||
* 4. Neither the name of the University nor of the Laboratory may be used
|
||||
* to endorse or promote products derived from this software without
|
||||
* specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lib_pcap_export_defs_h
|
||||
#define lib_pcap_export_defs_h
|
||||
|
||||
/*
|
||||
* PCAP_API_DEF must be used when defining *data* exported from
|
||||
* libpcap. It can be used when defining *functions* exported
|
||||
* from libpcap, but it doesn't have to be used there. It
|
||||
* should not be used in declarations in headers.
|
||||
*
|
||||
* PCAP_API must be used when *declaring* data or functions
|
||||
* exported from libpcap; PCAP_API_DEF won't work on all platforms.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Check whether this is GCC major.minor or a later release, or some
|
||||
* compiler that claims to be "just like GCC" of that version or a
|
||||
* later release.
|
||||
*/
|
||||
#define IS_AT_LEAST_GNUC_VERSION(major, minor) \
|
||||
(defined(__GNUC__) && \
|
||||
(__GNUC__ > (major) || \
|
||||
(__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))))
|
||||
|
||||
#if defined(_WIN32)
|
||||
#ifdef BUILDING_PCAP
|
||||
/*
|
||||
* We're compiling libpcap, so we should export functions in our
|
||||
* API.
|
||||
*/
|
||||
#define PCAP_API_DEF __declspec(dllexport)
|
||||
#else
|
||||
#define PCAP_API_DEF __declspec(dllimport)
|
||||
#endif
|
||||
#elif defined(MSDOS)
|
||||
/* XXX - does this need special treatment? */
|
||||
#define PCAP_API_DEF
|
||||
#else /* UN*X */
|
||||
#ifdef BUILDING_PCAP
|
||||
/*
|
||||
* We're compiling libpcap, so we should export functions in our API.
|
||||
* The compiler might be configured not to export functions from a
|
||||
* shared library by default, so we might have to explicitly mark
|
||||
* functions as exported.
|
||||
*/
|
||||
#if IS_AT_LEAST_GNUC_VERSION(3, 4)
|
||||
/*
|
||||
* GCC 3.4 or later, or some compiler asserting compatibility with
|
||||
* GCC 3.4 or later, so we have __attribute__((visibility()).
|
||||
*/
|
||||
#define PCAP_API_DEF __attribute__((visibility("default")))
|
||||
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
|
||||
/*
|
||||
* Sun C 5.5 or later, so we have __global.
|
||||
* (Sun C 5.9 and later also have __attribute__((visibility()),
|
||||
* but there's no reason to prefer it with Sun C.)
|
||||
*/
|
||||
#define PCAP_API_DEF __global
|
||||
#else
|
||||
/*
|
||||
* We don't have anything to say.
|
||||
*/
|
||||
#define PCAP_API_DEF
|
||||
#endif
|
||||
#else
|
||||
/*
|
||||
* We're not building libpcap.
|
||||
*/
|
||||
#define PCAP_API_DEF
|
||||
#endif
|
||||
#endif /* _WIN32/MSDOS/UN*X */
|
||||
|
||||
#define PCAP_API PCAP_API_DEF extern
|
||||
|
||||
#endif /* lib_pcap_export_defs_h */
|
||||
@@ -29,8 +29,6 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap/namedb.h,v 1.1 2006-10-04 18:09:22 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
#ifndef lib_pcap_namedb_h
|
||||
@@ -45,7 +43,10 @@ extern "C" {
|
||||
* XXX this stuff doesn't belong in this interface, but this
|
||||
* library already must do name to address translation, so
|
||||
* on systems that don't have support for /etc/ethers, we
|
||||
* export these hooks since they'll
|
||||
* export these hooks since they're already being used by
|
||||
* some applications (such as tcpdump) and already being
|
||||
* marked as exported in some OSes offering libpcap (such
|
||||
* as Debian).
|
||||
*/
|
||||
struct pcap_etherent {
|
||||
u_char addr[6];
|
||||
@@ -54,21 +55,21 @@ struct pcap_etherent {
|
||||
#ifndef PCAP_ETHERS_FILE
|
||||
#define PCAP_ETHERS_FILE "/etc/ethers"
|
||||
#endif
|
||||
struct pcap_etherent *pcap_next_etherent(FILE *);
|
||||
u_char *pcap_ether_hostton(const char*);
|
||||
u_char *pcap_ether_aton(const char *);
|
||||
PCAP_API struct pcap_etherent *pcap_next_etherent(FILE *);
|
||||
PCAP_API u_char *pcap_ether_hostton(const char*);
|
||||
PCAP_API u_char *pcap_ether_aton(const char *);
|
||||
|
||||
bpf_u_int32 **pcap_nametoaddr(const char *);
|
||||
PCAP_API bpf_u_int32 **pcap_nametoaddr(const char *);
|
||||
#ifdef INET6
|
||||
struct addrinfo *pcap_nametoaddrinfo(const char *);
|
||||
PCAP_API struct addrinfo *pcap_nametoaddrinfo(const char *);
|
||||
#endif
|
||||
bpf_u_int32 pcap_nametonetaddr(const char *);
|
||||
PCAP_API bpf_u_int32 pcap_nametonetaddr(const char *);
|
||||
|
||||
int pcap_nametoport(const char *, int *, int *);
|
||||
int pcap_nametoportrange(const char *, int *, int *, int *);
|
||||
int pcap_nametoproto(const char *);
|
||||
int pcap_nametoeproto(const char *);
|
||||
int pcap_nametollc(const char *);
|
||||
PCAP_API int pcap_nametoport(const char *, int *, int *);
|
||||
PCAP_API int pcap_nametoportrange(const char *, int *, int *, int *);
|
||||
PCAP_API int pcap_nametoproto(const char *);
|
||||
PCAP_API int pcap_nametoeproto(const char *);
|
||||
PCAP_API int pcap_nametollc(const char *);
|
||||
/*
|
||||
* If a protocol is unknown, PROTO_UNDEF is returned.
|
||||
* Also, pcap_nametoport() returns the protocol along with the port number.
|
||||
@@ -77,11 +78,6 @@ int pcap_nametollc(const char *);
|
||||
*/
|
||||
#define PROTO_UNDEF -1
|
||||
|
||||
/* XXX move these to pcap-int.h? */
|
||||
int __pcap_atodn(const char *, bpf_u_int32 *);
|
||||
int __pcap_atoin(const char *, bpf_u_int32 *);
|
||||
u_short __pcap_nametodnaddr(const char *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
92
freebsd/contrib/libpcap/pcap/nflog.h
Normal file
92
freebsd/contrib/libpcap/pcap/nflog.h
Normal file
@@ -0,0 +1,92 @@
|
||||
/*
|
||||
* Copyright (c) 2013, Petar Alilovic,
|
||||
* Faculty of Electrical Engineering and Computing, University of Zagreb
|
||||
* All rights reserved
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
* DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef lib_pcap_nflog_h
|
||||
#define lib_pcap_nflog_h
|
||||
|
||||
/*
|
||||
* Structure of an NFLOG header and TLV parts, as described at
|
||||
* http://www.tcpdump.org/linktypes/LINKTYPE_NFLOG.html
|
||||
*
|
||||
* The NFLOG header is big-endian.
|
||||
*
|
||||
* The TLV length and type are in host byte order. The value is either
|
||||
* big-endian or is an array of bytes in some externally-specified byte
|
||||
* order (text string, link-layer address, link-layer header, packet
|
||||
* data, etc.).
|
||||
*/
|
||||
typedef struct nflog_hdr {
|
||||
u_int8_t nflog_family; /* address family */
|
||||
u_int8_t nflog_version; /* version */
|
||||
u_int16_t nflog_rid; /* resource ID */
|
||||
} nflog_hdr_t;
|
||||
|
||||
typedef struct nflog_tlv {
|
||||
u_int16_t tlv_length; /* tlv length */
|
||||
u_int16_t tlv_type; /* tlv type */
|
||||
/* value follows this */
|
||||
} nflog_tlv_t;
|
||||
|
||||
typedef struct nflog_packet_hdr {
|
||||
u_int16_t hw_protocol; /* hw protocol */
|
||||
u_int8_t hook; /* netfilter hook */
|
||||
u_int8_t pad; /* padding to 32 bits */
|
||||
} nflog_packet_hdr_t;
|
||||
|
||||
typedef struct nflog_hwaddr {
|
||||
u_int16_t hw_addrlen; /* address length */
|
||||
u_int16_t pad; /* padding to 32-bit boundary */
|
||||
u_int8_t hw_addr[8]; /* address, up to 8 bytes */
|
||||
} nflog_hwaddr_t;
|
||||
|
||||
typedef struct nflog_timestamp {
|
||||
u_int64_t sec;
|
||||
u_int64_t usec;
|
||||
} nflog_timestamp_t;
|
||||
|
||||
/*
|
||||
* TLV types.
|
||||
*/
|
||||
#define NFULA_PACKET_HDR 1 /* nflog_packet_hdr_t */
|
||||
#define NFULA_MARK 2 /* packet mark from skbuff */
|
||||
#define NFULA_TIMESTAMP 3 /* nflog_timestamp_t for skbuff's time stamp */
|
||||
#define NFULA_IFINDEX_INDEV 4 /* ifindex of device on which packet received (possibly bridge group) */
|
||||
#define NFULA_IFINDEX_OUTDEV 5 /* ifindex of device on which packet transmitted (possibly bridge group) */
|
||||
#define NFULA_IFINDEX_PHYSINDEV 6 /* ifindex of physical device on which packet received (not bridge group) */
|
||||
#define NFULA_IFINDEX_PHYSOUTDEV 7 /* ifindex of physical device on which packet transmitted (not bridge group) */
|
||||
#define NFULA_HWADDR 8 /* nflog_hwaddr_t for hardware address */
|
||||
#define NFULA_PAYLOAD 9 /* packet payload */
|
||||
#define NFULA_PREFIX 10 /* text string - null-terminated, count includes NUL */
|
||||
#define NFULA_UID 11 /* UID owning socket on which packet was sent/received */
|
||||
#define NFULA_SEQ 12 /* sequence number of packets on this NFLOG socket */
|
||||
#define NFULA_SEQ_GLOBAL 13 /* sequence number of pakets on all NFLOG sockets */
|
||||
#define NFULA_GID 14 /* GID owning socket on which packet was sent/received */
|
||||
#define NFULA_HWTYPE 15 /* ARPHRD_ type of skbuff's device */
|
||||
#define NFULA_HWHEADER 16 /* skbuff's MAC-layer header */
|
||||
#define NFULA_HWLEN 17 /* length of skbuff's MAC-layer header */
|
||||
|
||||
#endif
|
||||
@@ -30,14 +30,14 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap/pcap.h,v 1.15 2008-10-06 15:27:32 gianluca Exp $ (LBL)
|
||||
*/
|
||||
|
||||
#ifndef lib_pcap_pcap_h
|
||||
#define lib_pcap_pcap_h
|
||||
|
||||
#if defined(WIN32)
|
||||
#include <pcap/export-defs.h>
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <pcap-stdinc.h>
|
||||
#elif defined(MSDOS)
|
||||
#include <sys/types.h>
|
||||
@@ -45,7 +45,7 @@
|
||||
#else /* UN*X */
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#endif /* WIN32/MSDOS/UN*X */
|
||||
#endif /* _WIN32/MSDOS/UN*X */
|
||||
|
||||
#include <net/bpf.h>
|
||||
|
||||
@@ -113,7 +113,7 @@ typedef struct pcap_addr pcap_addr_t;
|
||||
*
|
||||
* Then supply the changes by forking the branch at
|
||||
*
|
||||
* https://github.com/mcr/libpcap/issues
|
||||
* https://github.com/the-tcpdump-group/libpcap/issues
|
||||
*
|
||||
* and issuing a pull request, so that future versions of libpcap and
|
||||
* programs that use it (such as tcpdump) will be able to read your new
|
||||
@@ -170,9 +170,11 @@ struct pcap_stat {
|
||||
u_int ps_recv; /* number of packets received */
|
||||
u_int ps_drop; /* number of packets dropped */
|
||||
u_int ps_ifdrop; /* drops by interface -- only supported on some platforms */
|
||||
#ifdef WIN32
|
||||
u_int bs_capt; /* number of packets that reach the application */
|
||||
#endif /* WIN32 */
|
||||
#if defined(_WIN32) && defined(HAVE_REMOTE)
|
||||
u_int ps_capt; /* number of packets that reach the application */
|
||||
u_int ps_sent; /* number of packets sent by the server on the network */
|
||||
u_int ps_netdrop; /* number of packets lost on the network */
|
||||
#endif /* _WIN32 && HAVE_REMOTE */
|
||||
};
|
||||
|
||||
#ifdef MSDOS
|
||||
@@ -220,6 +222,8 @@ struct pcap_if {
|
||||
};
|
||||
|
||||
#define PCAP_IF_LOOPBACK 0x00000001 /* interface is loopback */
|
||||
#define PCAP_IF_UP 0x00000002 /* interface is up */
|
||||
#define PCAP_IF_RUNNING 0x00000004 /* interface is running */
|
||||
|
||||
/*
|
||||
* Representation of an interface address.
|
||||
@@ -252,6 +256,7 @@ typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *,
|
||||
#define PCAP_ERROR_IFACE_NOT_UP -9 /* interface isn't up */
|
||||
#define PCAP_ERROR_CANTSET_TSTAMP_TYPE -10 /* this device doesn't support setting the time stamp type */
|
||||
#define PCAP_ERROR_PROMISC_PERM_DENIED -11 /* you don't have permission to capture in promiscuous mode */
|
||||
#define PCAP_ERROR_TSTAMP_PRECISION_NOTSUP -12 /* the requested time stamp precision is not supported */
|
||||
|
||||
/*
|
||||
* Warning codes for the pcap API.
|
||||
@@ -268,24 +273,27 @@ typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *,
|
||||
*/
|
||||
#define PCAP_NETMASK_UNKNOWN 0xffffffff
|
||||
|
||||
char *pcap_lookupdev(char *);
|
||||
int pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
|
||||
PCAP_API char *pcap_lookupdev(char *);
|
||||
PCAP_API int pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
|
||||
|
||||
pcap_t *pcap_create(const char *, char *);
|
||||
int pcap_set_snaplen(pcap_t *, int);
|
||||
int pcap_set_promisc(pcap_t *, int);
|
||||
int pcap_can_set_rfmon(pcap_t *);
|
||||
int pcap_set_rfmon(pcap_t *, int);
|
||||
int pcap_set_timeout(pcap_t *, int);
|
||||
int pcap_set_tstamp_type(pcap_t *, int);
|
||||
int pcap_set_buffer_size(pcap_t *, int);
|
||||
int pcap_activate(pcap_t *);
|
||||
PCAP_API pcap_t *pcap_create(const char *, char *);
|
||||
PCAP_API int pcap_set_snaplen(pcap_t *, int);
|
||||
PCAP_API int pcap_set_promisc(pcap_t *, int);
|
||||
PCAP_API int pcap_can_set_rfmon(pcap_t *);
|
||||
PCAP_API int pcap_set_rfmon(pcap_t *, int);
|
||||
PCAP_API int pcap_set_timeout(pcap_t *, int);
|
||||
PCAP_API int pcap_set_tstamp_type(pcap_t *, int);
|
||||
PCAP_API int pcap_set_immediate_mode(pcap_t *, int);
|
||||
PCAP_API int pcap_set_buffer_size(pcap_t *, int);
|
||||
PCAP_API int pcap_set_tstamp_precision(pcap_t *, int);
|
||||
PCAP_API int pcap_get_tstamp_precision(pcap_t *);
|
||||
PCAP_API int pcap_activate(pcap_t *);
|
||||
|
||||
int pcap_list_tstamp_types(pcap_t *, int **);
|
||||
void pcap_free_tstamp_types(int *);
|
||||
int pcap_tstamp_type_name_to_val(const char *);
|
||||
const char *pcap_tstamp_type_val_to_name(int);
|
||||
const char *pcap_tstamp_type_val_to_description(int);
|
||||
PCAP_API int pcap_list_tstamp_types(pcap_t *, int **);
|
||||
PCAP_API void pcap_free_tstamp_types(int *);
|
||||
PCAP_API int pcap_tstamp_type_name_to_val(const char *);
|
||||
PCAP_API const char *pcap_tstamp_type_val_to_name(int);
|
||||
PCAP_API const char *pcap_tstamp_type_val_to_description(int);
|
||||
|
||||
/*
|
||||
* Time stamp types.
|
||||
@@ -331,128 +339,195 @@ const char *pcap_tstamp_type_val_to_description(int);
|
||||
#define PCAP_TSTAMP_ADAPTER 3 /* device-provided, synced with the system clock */
|
||||
#define PCAP_TSTAMP_ADAPTER_UNSYNCED 4 /* device-provided, not synced with the system clock */
|
||||
|
||||
pcap_t *pcap_open_live(const char *, int, int, int, char *);
|
||||
pcap_t *pcap_open_dead(int, int);
|
||||
pcap_t *pcap_open_offline(const char *, char *);
|
||||
#if defined(WIN32)
|
||||
pcap_t *pcap_hopen_offline(intptr_t, char *);
|
||||
#if !defined(LIBPCAP_EXPORTS)
|
||||
#define pcap_fopen_offline(f,b) \
|
||||
pcap_hopen_offline(_get_osfhandle(_fileno(f)), b)
|
||||
#else /*LIBPCAP_EXPORTS*/
|
||||
static pcap_t *pcap_fopen_offline(FILE *, char *);
|
||||
#endif
|
||||
#else /*WIN32*/
|
||||
pcap_t *pcap_fopen_offline(FILE *, char *);
|
||||
#endif /*WIN32*/
|
||||
/*
|
||||
* Time stamp resolution types.
|
||||
* Not all systems and interfaces will necessarily support all of these
|
||||
* resolutions when doing live captures; all of them can be requested
|
||||
* when reading a savefile.
|
||||
*/
|
||||
#define PCAP_TSTAMP_PRECISION_MICRO 0 /* use timestamps with microsecond precision, default */
|
||||
#define PCAP_TSTAMP_PRECISION_NANO 1 /* use timestamps with nanosecond precision */
|
||||
|
||||
void pcap_close(pcap_t *);
|
||||
int pcap_loop(pcap_t *, int, pcap_handler, u_char *);
|
||||
int pcap_dispatch(pcap_t *, int, pcap_handler, u_char *);
|
||||
const u_char*
|
||||
pcap_next(pcap_t *, struct pcap_pkthdr *);
|
||||
int pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const u_char **);
|
||||
void pcap_breakloop(pcap_t *);
|
||||
int pcap_stats(pcap_t *, struct pcap_stat *);
|
||||
int pcap_setfilter(pcap_t *, struct bpf_program *);
|
||||
int pcap_setdirection(pcap_t *, pcap_direction_t);
|
||||
int pcap_getnonblock(pcap_t *, char *);
|
||||
int pcap_setnonblock(pcap_t *, int, char *);
|
||||
int pcap_inject(pcap_t *, const void *, size_t);
|
||||
int pcap_sendpacket(pcap_t *, const u_char *, int);
|
||||
const char *pcap_statustostr(int);
|
||||
const char *pcap_strerror(int);
|
||||
char *pcap_geterr(pcap_t *);
|
||||
void pcap_perror(pcap_t *, char *);
|
||||
int pcap_compile(pcap_t *, struct bpf_program *, const char *, int,
|
||||
PCAP_API pcap_t *pcap_open_live(const char *, int, int, int, char *);
|
||||
PCAP_API pcap_t *pcap_open_dead(int, int);
|
||||
PCAP_API pcap_t *pcap_open_dead_with_tstamp_precision(int, int, u_int);
|
||||
PCAP_API pcap_t *pcap_open_offline_with_tstamp_precision(const char *, u_int, char *);
|
||||
PCAP_API pcap_t *pcap_open_offline(const char *, char *);
|
||||
#ifdef _WIN32
|
||||
PCAP_API pcap_t *pcap_hopen_offline_with_tstamp_precision(intptr_t, u_int, char *);
|
||||
PCAP_API pcap_t *pcap_hopen_offline(intptr_t, char *);
|
||||
/*
|
||||
* If we're building libpcap, these are internal routines in savefile.c,
|
||||
* so we mustn't define them as macros.
|
||||
*/
|
||||
#ifndef BUILDING_PCAP
|
||||
#define pcap_fopen_offline_with_tstamp_precision(f,p,b) \
|
||||
pcap_hopen_offline_with_tstamp_precision(_get_osfhandle(_fileno(f)), p, b)
|
||||
#define pcap_fopen_offline(f,b) \
|
||||
pcap_hopen_offline(_get_osfhandle(_fileno(f)), b)
|
||||
#endif
|
||||
#else /*_WIN32*/
|
||||
PCAP_API pcap_t *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
|
||||
PCAP_API pcap_t *pcap_fopen_offline(FILE *, char *);
|
||||
#endif /*_WIN32*/
|
||||
|
||||
PCAP_API void pcap_close(pcap_t *);
|
||||
PCAP_API int pcap_loop(pcap_t *, int, pcap_handler, u_char *);
|
||||
PCAP_API int pcap_dispatch(pcap_t *, int, pcap_handler, u_char *);
|
||||
PCAP_API const u_char *pcap_next(pcap_t *, struct pcap_pkthdr *);
|
||||
PCAP_API int pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const u_char **);
|
||||
PCAP_API void pcap_breakloop(pcap_t *);
|
||||
PCAP_API int pcap_stats(pcap_t *, struct pcap_stat *);
|
||||
PCAP_API int pcap_setfilter(pcap_t *, struct bpf_program *);
|
||||
PCAP_API int pcap_setdirection(pcap_t *, pcap_direction_t);
|
||||
PCAP_API int pcap_getnonblock(pcap_t *, char *);
|
||||
PCAP_API int pcap_setnonblock(pcap_t *, int, char *);
|
||||
PCAP_API int pcap_inject(pcap_t *, const void *, size_t);
|
||||
PCAP_API int pcap_sendpacket(pcap_t *, const u_char *, int);
|
||||
PCAP_API const char *pcap_statustostr(int);
|
||||
PCAP_API const char *pcap_strerror(int);
|
||||
PCAP_API char *pcap_geterr(pcap_t *);
|
||||
PCAP_API void pcap_perror(pcap_t *, const char *);
|
||||
PCAP_API int pcap_compile(pcap_t *, struct bpf_program *, const char *, int,
|
||||
bpf_u_int32);
|
||||
int pcap_compile_nopcap(int, int, struct bpf_program *,
|
||||
PCAP_API int pcap_compile_nopcap(int, int, struct bpf_program *,
|
||||
const char *, int, bpf_u_int32);
|
||||
void pcap_freecode(struct bpf_program *);
|
||||
int pcap_offline_filter(const struct bpf_program *,
|
||||
PCAP_API void pcap_freecode(struct bpf_program *);
|
||||
PCAP_API int pcap_offline_filter(const struct bpf_program *,
|
||||
const struct pcap_pkthdr *, const u_char *);
|
||||
int pcap_datalink(pcap_t *);
|
||||
int pcap_datalink_ext(pcap_t *);
|
||||
int pcap_list_datalinks(pcap_t *, int **);
|
||||
int pcap_set_datalink(pcap_t *, int);
|
||||
void pcap_free_datalinks(int *);
|
||||
int pcap_datalink_name_to_val(const char *);
|
||||
const char *pcap_datalink_val_to_name(int);
|
||||
const char *pcap_datalink_val_to_description(int);
|
||||
int pcap_snapshot(pcap_t *);
|
||||
int pcap_is_swapped(pcap_t *);
|
||||
int pcap_major_version(pcap_t *);
|
||||
int pcap_minor_version(pcap_t *);
|
||||
PCAP_API int pcap_datalink(pcap_t *);
|
||||
PCAP_API int pcap_datalink_ext(pcap_t *);
|
||||
PCAP_API int pcap_list_datalinks(pcap_t *, int **);
|
||||
PCAP_API int pcap_set_datalink(pcap_t *, int);
|
||||
PCAP_API void pcap_free_datalinks(int *);
|
||||
PCAP_API int pcap_datalink_name_to_val(const char *);
|
||||
PCAP_API const char *pcap_datalink_val_to_name(int);
|
||||
PCAP_API const char *pcap_datalink_val_to_description(int);
|
||||
PCAP_API int pcap_snapshot(pcap_t *);
|
||||
PCAP_API int pcap_is_swapped(pcap_t *);
|
||||
PCAP_API int pcap_major_version(pcap_t *);
|
||||
PCAP_API int pcap_minor_version(pcap_t *);
|
||||
|
||||
/* XXX */
|
||||
FILE *pcap_file(pcap_t *);
|
||||
int pcap_fileno(pcap_t *);
|
||||
PCAP_API FILE *pcap_file(pcap_t *);
|
||||
PCAP_API int pcap_fileno(pcap_t *);
|
||||
|
||||
pcap_dumper_t *pcap_dump_open(pcap_t *, const char *);
|
||||
pcap_dumper_t *pcap_dump_fopen(pcap_t *, FILE *fp);
|
||||
FILE *pcap_dump_file(pcap_dumper_t *);
|
||||
long pcap_dump_ftell(pcap_dumper_t *);
|
||||
int pcap_dump_flush(pcap_dumper_t *);
|
||||
void pcap_dump_close(pcap_dumper_t *);
|
||||
void pcap_dump(u_char *, const struct pcap_pkthdr *, const u_char *);
|
||||
#ifdef _WIN32
|
||||
PCAP_API int pcap_wsockinit(void);
|
||||
#endif
|
||||
|
||||
int pcap_findalldevs(pcap_if_t **, char *);
|
||||
void pcap_freealldevs(pcap_if_t *);
|
||||
PCAP_API pcap_dumper_t *pcap_dump_open(pcap_t *, const char *);
|
||||
PCAP_API pcap_dumper_t *pcap_dump_fopen(pcap_t *, FILE *fp);
|
||||
PCAP_API pcap_dumper_t *pcap_dump_open_append(pcap_t *, const char *);
|
||||
PCAP_API FILE *pcap_dump_file(pcap_dumper_t *);
|
||||
PCAP_API long pcap_dump_ftell(pcap_dumper_t *);
|
||||
PCAP_API int pcap_dump_flush(pcap_dumper_t *);
|
||||
PCAP_API void pcap_dump_close(pcap_dumper_t *);
|
||||
PCAP_API void pcap_dump(u_char *, const struct pcap_pkthdr *, const u_char *);
|
||||
|
||||
const char *pcap_lib_version(void);
|
||||
PCAP_API int pcap_findalldevs(pcap_if_t **, char *);
|
||||
PCAP_API void pcap_freealldevs(pcap_if_t *);
|
||||
|
||||
PCAP_API const char *pcap_lib_version(void);
|
||||
|
||||
/*
|
||||
* On at least some versions of NetBSD, we don't want to declare
|
||||
* On at least some versions of NetBSD and QNX, we don't want to declare
|
||||
* bpf_filter() here, as it's also be declared in <net/bpf.h>, with a
|
||||
* different signature, but, on other BSD-flavored UN*Xes, it's not
|
||||
* declared in <net/bpf.h>, so we *do* want to declare it here, so it's
|
||||
* declared when we build pcap-bpf.c.
|
||||
*/
|
||||
#ifndef __NetBSD__
|
||||
u_int bpf_filter(struct bpf_insn *, u_char *, u_int, u_int);
|
||||
#if !defined(__NetBSD__) && !defined(__QNX__)
|
||||
PCAP_API u_int bpf_filter(const struct bpf_insn *, const u_char *, u_int, u_int);
|
||||
#endif
|
||||
int bpf_validate(const struct bpf_insn *f, int len);
|
||||
char *bpf_image(struct bpf_insn *, int);
|
||||
void bpf_dump(const struct bpf_program *, int);
|
||||
PCAP_API int bpf_validate(const struct bpf_insn *f, int len);
|
||||
PCAP_API char *bpf_image(const struct bpf_insn *, int);
|
||||
PCAP_API void bpf_dump(const struct bpf_program *, int);
|
||||
|
||||
#if defined(WIN32)
|
||||
#if defined(_WIN32)
|
||||
|
||||
/*
|
||||
* Win32 definitions
|
||||
*/
|
||||
/*
|
||||
* Win32 definitions
|
||||
*/
|
||||
|
||||
int pcap_setbuff(pcap_t *p, int dim);
|
||||
int pcap_setmode(pcap_t *p, int mode);
|
||||
int pcap_setmintocopy(pcap_t *p, int size);
|
||||
/*!
|
||||
\brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
|
||||
*/
|
||||
struct pcap_send_queue
|
||||
{
|
||||
u_int maxlen; /* Maximum size of the the queue, in bytes. This
|
||||
variable contains the size of the buffer field. */
|
||||
u_int len; /* Current size of the queue, in bytes. */
|
||||
char *buffer; /* Buffer containing the packets to be sent. */
|
||||
};
|
||||
|
||||
#ifdef WPCAP
|
||||
/* Include file with the wpcap-specific extensions */
|
||||
#include <Win32-Extensions.h>
|
||||
#endif /* WPCAP */
|
||||
typedef struct pcap_send_queue pcap_send_queue;
|
||||
|
||||
#define MODE_CAPT 0
|
||||
#define MODE_STAT 1
|
||||
#define MODE_MON 2
|
||||
/*!
|
||||
\brief This typedef is a support for the pcap_get_airpcap_handle() function
|
||||
*/
|
||||
#if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)
|
||||
#define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
|
||||
typedef struct _AirpcapHandle *PAirpcapHandle;
|
||||
#endif
|
||||
|
||||
PCAP_API int pcap_setbuff(pcap_t *p, int dim);
|
||||
PCAP_API int pcap_setmode(pcap_t *p, int mode);
|
||||
PCAP_API int pcap_setmintocopy(pcap_t *p, int size);
|
||||
|
||||
PCAP_API HANDLE pcap_getevent(pcap_t *p);
|
||||
|
||||
PCAP_API int pcap_oid_get_request(pcap_t *, bpf_u_int32, void *, size_t *);
|
||||
PCAP_API int pcap_oid_set_request(pcap_t *, bpf_u_int32, const void *, size_t *);
|
||||
|
||||
PCAP_API pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);
|
||||
|
||||
PCAP_API void pcap_sendqueue_destroy(pcap_send_queue* queue);
|
||||
|
||||
PCAP_API int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);
|
||||
|
||||
PCAP_API u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);
|
||||
|
||||
PCAP_API struct pcap_stat *pcap_stats_ex(pcap_t *p, int *pcap_stat_size);
|
||||
|
||||
PCAP_API int pcap_setuserbuffer(pcap_t *p, int size);
|
||||
|
||||
PCAP_API int pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks);
|
||||
|
||||
PCAP_API int pcap_live_dump_ended(pcap_t *p, int sync);
|
||||
|
||||
PCAP_API int pcap_start_oem(char* err_str, int flags);
|
||||
|
||||
PCAP_API PAirpcapHandle pcap_get_airpcap_handle(pcap_t *p);
|
||||
|
||||
#define MODE_CAPT 0
|
||||
#define MODE_STAT 1
|
||||
#define MODE_MON 2
|
||||
|
||||
#elif defined(MSDOS)
|
||||
|
||||
/*
|
||||
* MS-DOS definitions
|
||||
*/
|
||||
/*
|
||||
* MS-DOS definitions
|
||||
*/
|
||||
|
||||
int pcap_stats_ex (pcap_t *, struct pcap_stat_ex *);
|
||||
void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait);
|
||||
u_long pcap_mac_packets (void);
|
||||
PCAP_API int pcap_stats_ex (pcap_t *, struct pcap_stat_ex *);
|
||||
PCAP_API void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait);
|
||||
PCAP_API u_long pcap_mac_packets (void);
|
||||
|
||||
#else /* UN*X */
|
||||
|
||||
/*
|
||||
* UN*X definitions
|
||||
*/
|
||||
/*
|
||||
* UN*X definitions
|
||||
*/
|
||||
|
||||
int pcap_get_selectable_fd(pcap_t *);
|
||||
PCAP_API int pcap_get_selectable_fd(pcap_t *);
|
||||
|
||||
#endif /* WIN32/MSDOS/UN*X */
|
||||
#endif /* _WIN32/MSDOS/UN*X */
|
||||
|
||||
#ifdef HAVE_REMOTE
|
||||
/* Includes most of the public stuff that is needed for the remote capture */
|
||||
#include <remote-ext.h>
|
||||
#endif /* HAVE_REMOTE */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@@ -34,8 +34,6 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap/sll.h,v 1.3 2008-05-30 01:35:33 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -125,5 +123,7 @@ struct sll_header {
|
||||
*/
|
||||
#define LINUX_SLL_P_802_3 0x0001 /* Novell 802.3 frames without 802.2 LLC header */
|
||||
#define LINUX_SLL_P_802_2 0x0004 /* 802.2 frames (not D/I/X Ethernet) */
|
||||
#define LINUX_SLL_P_CAN 0x000C /* CAN frames, with SocketCAN pseudo-headers */
|
||||
#define LINUX_SLL_P_CANFD 0x000D /* CAN FD frames, with SocketCAN pseudo-headers */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -11,8 +11,8 @@
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote
|
||||
* products derived from this software without specific prior written
|
||||
* 3. The name of the author may not be used to endorse or promote
|
||||
* products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
@@ -29,14 +29,12 @@
|
||||
*
|
||||
* Basic USB data struct
|
||||
* By Paolo Abeni <paolo.abeni@email.it>
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/pcap/usb.h,v 1.9 2008-12-23 20:13:29 guy Exp $
|
||||
*/
|
||||
|
||||
#ifndef _PCAP_USB_STRUCTS_H__
|
||||
#define _PCAP_USB_STRUCTS_H__
|
||||
|
||||
/*
|
||||
#ifndef lib_pcap_usb_h
|
||||
#define lib_pcap_usb_h
|
||||
|
||||
/*
|
||||
* possible transfer mode
|
||||
*/
|
||||
#define URB_TRANSFER_IN 0x80
|
||||
|
||||
13
freebsd/contrib/libpcap/pcap_version.h
Normal file
13
freebsd/contrib/libpcap/pcap_version.h
Normal file
@@ -0,0 +1,13 @@
|
||||
/*
|
||||
* We make the version string static, and return a pointer to it, rather
|
||||
* than exporting the version string directly. On at least some UNIXes,
|
||||
* if you import data from a shared library into an program, the data is
|
||||
* bound into the program binary, so if the string in the version of the
|
||||
* library with which the program was linked isn't the same as the
|
||||
* string in the version of the library with which the program is being
|
||||
* run, various undesirable things may happen (warnings, the string
|
||||
* being the one from the version of the library with which the program
|
||||
* was linked, or even weirder things, such as the string being the one
|
||||
* from the library but being truncated).
|
||||
*/
|
||||
static const char pcap_version_string[] = "libpcap version 1.8.1";
|
||||
216
freebsd/contrib/libpcap/portability.h
Normal file
216
freebsd/contrib/libpcap/portability.h
Normal file
@@ -0,0 +1,216 @@
|
||||
/*
|
||||
* Copyright (c) 1994, 1995, 1996
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the Computer Systems
|
||||
* Engineering Group at Lawrence Berkeley Laboratory.
|
||||
* 4. Neither the name of the University nor of the Laboratory may be used
|
||||
* to endorse or promote products derived from this software without
|
||||
* specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef portability_h
|
||||
#define portability_h
|
||||
|
||||
/*
|
||||
* Helpers for portability between Windows and UN*X and between different
|
||||
* flavors of UN*X.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRLCPY
|
||||
/*
|
||||
* Macro that does the same thing as strlcpy().
|
||||
*/
|
||||
#ifdef _MSC_VER
|
||||
/*
|
||||
* strncpy_s() is supported at least back to Visual
|
||||
* Studio 2005.
|
||||
*/
|
||||
#define strlcpy(x, y, z) \
|
||||
strncpy_s((x), (z), (y), _TRUNCATE)
|
||||
|
||||
#else
|
||||
#define strlcpy(x, y, z) \
|
||||
(strncpy((x), (y), (z)), \
|
||||
((z) <= 0 ? 0 : ((x)[(z) - 1] = '\0')), \
|
||||
(void) strlen((y)))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* For flagging arguments as format strings in MSVC.
|
||||
*/
|
||||
#if _MSC_VER >= 1400
|
||||
#include <sal.h>
|
||||
#if _MSC_VER > 1400
|
||||
#define FORMAT_STRING(p) _Printf_format_string_ p
|
||||
#else
|
||||
#define FORMAT_STRING(p) __format_string p
|
||||
#endif
|
||||
#else
|
||||
#define FORMAT_STRING(p) p
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define strdup _strdup
|
||||
#define sscanf sscanf_s
|
||||
#define setbuf(x, y) \
|
||||
setvbuf((x), (y), _IONBF, 0)
|
||||
#define fopen(x, y) \
|
||||
fopen_safe((x), (y))
|
||||
FILE *fopen_safe(const char *filename, const char* mode);
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
#define strlcat(x, y, z) \
|
||||
strncat_s((x), (z), (y), _TRUNCATE)
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
/*
|
||||
* MSVC.
|
||||
*/
|
||||
#if _MSC_VER >= 1900
|
||||
/*
|
||||
* VS 2015 or newer; we have snprintf() function.
|
||||
*/
|
||||
#define HAVE_SNPRINTF
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* On Windows, snprintf(), with that name and with C99 behavior - i.e.,
|
||||
* guaranteeing that the formatted string is null-terminated - didn't
|
||||
* appear until Visual Studio 2015. Prior to that, the C runtime had
|
||||
* only _snprintf(), which *doesn't* guarantee that the string is
|
||||
* null-terminated if it is truncated due to the buffer being too
|
||||
* small. We therefore can't just define snprintf to be _snprintf
|
||||
* and define vsnprintf to be _vsnprintf, as we're relying on null-
|
||||
* termination of strings in all cases.
|
||||
*
|
||||
* We also want to allow this to be built with versions of Visual Studio
|
||||
* prior to VS 2015, so we can't rely on snprintf() being present.
|
||||
*
|
||||
* And we want to make sure that, if we support plugins in the future,
|
||||
* a routine with C99 snprintf() behavior will be available to them.
|
||||
* We also don't want it to collide with the C library snprintf() if
|
||||
* there is one.
|
||||
*
|
||||
* So we make pcap_snprintf() and pcap_vsnprintf() available, either by
|
||||
* #defining them to be snprintf or vsnprintf, respectively, or by
|
||||
* defining our own versions and exporting them.
|
||||
*/
|
||||
#ifdef HAVE_SNPRINTF
|
||||
#define pcap_snprintf snprintf
|
||||
#else
|
||||
extern int pcap_snprintf(char *, size_t, FORMAT_STRING(const char *), ...)
|
||||
#ifdef __ATTRIBUTE___FORMAT_OK
|
||||
__attribute__((format (printf, 3, 4)))
|
||||
#endif /* __ATTRIBUTE___FORMAT_OK */
|
||||
;
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_VSNPRINTF
|
||||
#define pcap_vsnprintf vsnprintf
|
||||
#else
|
||||
extern int pcap_vsnprintf(char *, size_t, const char *, va_list ap);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_STRTOK_R
|
||||
#define pcap_strtok_r strtok_r
|
||||
#else
|
||||
#ifdef _MSC_VER
|
||||
/*
|
||||
* Microsoft gives it a different name.
|
||||
*/
|
||||
#define pcap_strtok_r strtok_s
|
||||
#else
|
||||
/*
|
||||
* Define it ourselves.
|
||||
*/
|
||||
#define NEED_STRTOK_R
|
||||
extern int pcap_strtok_r(char *, const char *, char **);
|
||||
#endif
|
||||
#endif /* HAVE_STRTOK_R */
|
||||
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
* These may be defined by <inttypes.h>.
|
||||
*
|
||||
* XXX - for MSVC, we always want the _MSC_EXTENSIONS versions.
|
||||
* What about other compilers? If, as the MinGW Web site says MinGW
|
||||
* does, the other compilers just use Microsoft's run-time library,
|
||||
* then they should probably use the _MSC_EXTENSIONS even if the
|
||||
* compiler doesn't define _MSC_EXTENSIONS.
|
||||
*
|
||||
* XXX - we currently aren't using any of these, but this allows
|
||||
* their use in the future.
|
||||
*/
|
||||
#ifndef PRId64
|
||||
#ifdef _MSC_EXTENSIONS
|
||||
#define PRId64 "I64d"
|
||||
#else
|
||||
#define PRId64 "lld"
|
||||
#endif
|
||||
#endif /* PRId64 */
|
||||
|
||||
#ifndef PRIo64
|
||||
#ifdef _MSC_EXTENSIONS
|
||||
#define PRIo64 "I64o"
|
||||
#else
|
||||
#define PRIo64 "llo"
|
||||
#endif
|
||||
#endif /* PRIo64 */
|
||||
|
||||
#ifndef PRIx64
|
||||
#ifdef _MSC_EXTENSIONS
|
||||
#define PRIx64 "I64x"
|
||||
#else
|
||||
#define PRIx64 "llx"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef PRIu64
|
||||
#ifdef _MSC_EXTENSIONS
|
||||
#define PRIu64 "I64u"
|
||||
#else
|
||||
#define PRIu64 "llu"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(__cplusplus)
|
||||
#define inline __inline
|
||||
#endif
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,4 +1,3 @@
|
||||
/* @(#) $Header: /tcpdump/master/libpcap/ppp.h,v 1.12 2005-02-08 19:52:19 guy Exp $ (LBL) */
|
||||
/*
|
||||
* Point to Point Protocol (PPP) RFC1331
|
||||
*
|
||||
|
||||
@@ -30,18 +30,13 @@
|
||||
* dependent values so we can print the dump file on any architecture.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/savefile.c,v 1.183 2008-12-23 20:13:29 guy Exp $ (LBL)";
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
@@ -51,7 +46,7 @@ static const char rcsid[] _U_ =
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <errno.h>
|
||||
#include <memory.h>
|
||||
@@ -60,7 +55,6 @@ static const char rcsid[] _U_ =
|
||||
#include <string.h>
|
||||
|
||||
#include "pcap-int.h"
|
||||
#include "pcap/usb.h"
|
||||
|
||||
#ifdef HAVE_OS_PROTO_H
|
||||
#include "os-proto.h"
|
||||
@@ -69,10 +63,27 @@ static const char rcsid[] _U_ =
|
||||
#include "sf-pcap.h"
|
||||
#include "sf-pcap-ng.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
* These aren't exported on Windows, because they would only work if both
|
||||
* WinPcap and the code using it were to use the Universal CRT; otherwise,
|
||||
* a FILE structure in WinPcap and a FILE structure in the code using it
|
||||
* could be different if they're using different versions of the C runtime.
|
||||
*
|
||||
* Instead, pcap/pcap.h defines them as macros that wrap the hopen versions,
|
||||
* with the wrappers calling _fileno() and _get_osfhandle() themselves,
|
||||
* so that they convert the appropriate CRT version's FILE structure to
|
||||
* a HANDLE (which is OS-defined, not CRT-defined, and is part of the Win32
|
||||
* and Win64 ABIs).
|
||||
*/
|
||||
static pcap_t *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
|
||||
static pcap_t *pcap_fopen_offline(FILE *, char *);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Setting O_BINARY on DOS/Windows is a bit tricky
|
||||
*/
|
||||
#if defined(WIN32)
|
||||
#if defined(_WIN32)
|
||||
#define SET_BINMODE(f) _setmode(_fileno(f), _O_BINARY)
|
||||
#elif defined(MSDOS)
|
||||
#if defined(__HIGHC__)
|
||||
@@ -103,7 +114,7 @@ sf_setnonblock(pcap_t *p, int nonblock, char *errbuf)
|
||||
* as it would have to handle reading partial packets and
|
||||
* keeping the state of the read.)
|
||||
*/
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"Savefiles cannot be put into non-blocking mode");
|
||||
return (-1);
|
||||
}
|
||||
@@ -111,16 +122,24 @@ sf_setnonblock(pcap_t *p, int nonblock, char *errbuf)
|
||||
static int
|
||||
sf_stats(pcap_t *p, struct pcap_stat *ps)
|
||||
{
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"Statistics aren't available from savefiles");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
static struct pcap_stat *
|
||||
sf_stats_ex(pcap_t *p, int *size)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"Statistics aren't available from savefiles");
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_setbuff(pcap_t *p, int dim)
|
||||
{
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"The kernel buffer size cannot be set while reading from a file");
|
||||
return (-1);
|
||||
}
|
||||
@@ -128,7 +147,7 @@ sf_setbuff(pcap_t *p, int dim)
|
||||
static int
|
||||
sf_setmode(pcap_t *p, int mode)
|
||||
{
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"impossible to set mode while reading from a file");
|
||||
return (-1);
|
||||
}
|
||||
@@ -136,10 +155,74 @@ sf_setmode(pcap_t *p, int mode)
|
||||
static int
|
||||
sf_setmintocopy(pcap_t *p, int size)
|
||||
{
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"The mintocopy parameter cannot be set while reading from a file");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static HANDLE
|
||||
sf_getevent(pcap_t *pcap)
|
||||
{
|
||||
(void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),
|
||||
"The read event cannot be retrieved while reading from a file");
|
||||
return (INVALID_HANDLE_VALUE);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_oid_get_request(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_,
|
||||
size_t *lenp _U_)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"An OID get request cannot be performed on a file");
|
||||
return (PCAP_ERROR);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_oid_set_request(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
|
||||
size_t *lenp _U_)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"An OID set request cannot be performed on a file");
|
||||
return (PCAP_ERROR);
|
||||
}
|
||||
|
||||
static u_int
|
||||
sf_sendqueue_transmit(pcap_t *p, pcap_send_queue *queue, int sync)
|
||||
{
|
||||
strlcpy(p->errbuf, "Sending packets isn't supported on savefiles",
|
||||
PCAP_ERRBUF_SIZE);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_setuserbuffer(pcap_t *p, int size)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"The user buffer cannot be set when reading from a file");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"Live packet dumping cannot be performed when reading from a file");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_live_dump_ended(pcap_t *p, int sync)
|
||||
{
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static PAirpcapHandle
|
||||
sf_get_airpcap_handle(pcap_t *pcap)
|
||||
{
|
||||
return (NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int
|
||||
@@ -157,31 +240,53 @@ sf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
|
||||
static int
|
||||
sf_setdirection(pcap_t *p, pcap_direction_t d)
|
||||
{
|
||||
snprintf(p->errbuf, sizeof(p->errbuf),
|
||||
pcap_snprintf(p->errbuf, sizeof(p->errbuf),
|
||||
"Setting direction is not supported on savefiles");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static void
|
||||
void
|
||||
sf_cleanup(pcap_t *p)
|
||||
{
|
||||
if (p->sf.rfile != stdin)
|
||||
(void)fclose(p->sf.rfile);
|
||||
if (p->rfile != stdin)
|
||||
(void)fclose(p->rfile);
|
||||
if (p->buffer != NULL)
|
||||
free(p->buffer);
|
||||
pcap_freecode(&p->fcode);
|
||||
}
|
||||
|
||||
/*
|
||||
* fopen's safe version on Windows.
|
||||
*/
|
||||
#ifdef _MSC_VER
|
||||
FILE *fopen_safe(const char *filename, const char* mode)
|
||||
{
|
||||
FILE *fp = NULL;
|
||||
errno_t errno;
|
||||
errno = fopen_s(&fp, filename, mode);
|
||||
if (errno == 0)
|
||||
return fp;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
pcap_t *
|
||||
pcap_open_offline(const char *fname, char *errbuf)
|
||||
pcap_open_offline_with_tstamp_precision(const char *fname, u_int precision,
|
||||
char *errbuf)
|
||||
{
|
||||
FILE *fp;
|
||||
pcap_t *p;
|
||||
|
||||
if (fname == NULL) {
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"A null pointer was supplied as the file name");
|
||||
return (NULL);
|
||||
}
|
||||
if (fname[0] == '-' && fname[1] == '\0')
|
||||
{
|
||||
fp = stdin;
|
||||
#if defined(WIN32) || defined(MSDOS)
|
||||
#if defined(_WIN32) || defined(MSDOS)
|
||||
/*
|
||||
* We're reading from the standard input, so put it in binary
|
||||
* mode, as savefiles are binary files.
|
||||
@@ -190,18 +295,18 @@ pcap_open_offline(const char *fname, char *errbuf)
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
#if !defined(WIN32) && !defined(MSDOS)
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
fp = fopen(fname, "r");
|
||||
#else
|
||||
fp = fopen(fname, "rb");
|
||||
#endif
|
||||
if (fp == NULL) {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", fname,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", fname,
|
||||
pcap_strerror(errno));
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
p = pcap_fopen_offline(fp, errbuf);
|
||||
p = pcap_fopen_offline_with_tstamp_precision(fp, precision, errbuf);
|
||||
if (p == NULL) {
|
||||
if (fp != stdin)
|
||||
fclose(fp);
|
||||
@@ -209,51 +314,64 @@ pcap_open_offline(const char *fname, char *errbuf)
|
||||
return (p);
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
pcap_t* pcap_hopen_offline(intptr_t osfd, char *errbuf)
|
||||
pcap_t *
|
||||
pcap_open_offline(const char *fname, char *errbuf)
|
||||
{
|
||||
return (pcap_open_offline_with_tstamp_precision(fname,
|
||||
PCAP_TSTAMP_PRECISION_MICRO, errbuf));
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
pcap_t* pcap_hopen_offline_with_tstamp_precision(intptr_t osfd, u_int precision,
|
||||
char *errbuf)
|
||||
{
|
||||
int fd;
|
||||
FILE *file;
|
||||
|
||||
fd = _open_osfhandle(osfd, _O_RDONLY);
|
||||
if ( fd < 0 )
|
||||
if ( fd < 0 )
|
||||
{
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
file = _fdopen(fd, "rb");
|
||||
if ( file == NULL )
|
||||
if ( file == NULL )
|
||||
{
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return pcap_fopen_offline(file, errbuf);
|
||||
return pcap_fopen_offline_with_tstamp_precision(file, precision,
|
||||
errbuf);
|
||||
}
|
||||
|
||||
pcap_t* pcap_hopen_offline(intptr_t osfd, char *errbuf)
|
||||
{
|
||||
return pcap_hopen_offline_with_tstamp_precision(osfd,
|
||||
PCAP_TSTAMP_PRECISION_MICRO, errbuf);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int (*check_headers[])(pcap_t *, bpf_u_int32, FILE *, char *) = {
|
||||
static pcap_t *(*check_headers[])(bpf_u_int32, FILE *, u_int, char *, int *) = {
|
||||
pcap_check_header,
|
||||
pcap_ng_check_header
|
||||
};
|
||||
|
||||
#define N_FILE_TYPES (sizeof check_headers / sizeof check_headers[0])
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
static
|
||||
#endif
|
||||
pcap_t *
|
||||
pcap_fopen_offline(FILE *fp, char *errbuf)
|
||||
pcap_fopen_offline_with_tstamp_precision(FILE *fp, u_int precision,
|
||||
char *errbuf)
|
||||
{
|
||||
register pcap_t *p;
|
||||
bpf_u_int32 magic;
|
||||
size_t amt_read;
|
||||
u_int i;
|
||||
|
||||
p = pcap_create_common("(savefile)", errbuf);
|
||||
if (p == NULL)
|
||||
return (NULL);
|
||||
int err;
|
||||
|
||||
/*
|
||||
* Read the first 4 bytes of the file; the network analyzer dump
|
||||
@@ -265,53 +383,48 @@ pcap_fopen_offline(FILE *fp, char *errbuf)
|
||||
amt_read = fread((char *)&magic, 1, sizeof(magic), fp);
|
||||
if (amt_read != sizeof(magic)) {
|
||||
if (ferror(fp)) {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
} else {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %lu file header bytes, only got %lu",
|
||||
(unsigned long)sizeof(magic),
|
||||
(unsigned long)amt_read);
|
||||
}
|
||||
goto bad;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Try all file types.
|
||||
*/
|
||||
for (i = 0; i < N_FILE_TYPES; i++) {
|
||||
switch ((*check_headers[i])(p, magic, fp, errbuf)) {
|
||||
|
||||
case -1:
|
||||
p = (*check_headers[i])(magic, fp, precision, errbuf, &err);
|
||||
if (p != NULL) {
|
||||
/* Yup, that's it. */
|
||||
goto found;
|
||||
}
|
||||
if (err) {
|
||||
/*
|
||||
* Error trying to read the header.
|
||||
*/
|
||||
goto bad;
|
||||
|
||||
case 1:
|
||||
/*
|
||||
* Yup, that's it.
|
||||
*/
|
||||
goto found;
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Well, who knows what this mess is....
|
||||
*/
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown file format");
|
||||
goto bad;
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown file format");
|
||||
return (NULL);
|
||||
|
||||
found:
|
||||
p->sf.rfile = fp;
|
||||
p->rfile = fp;
|
||||
|
||||
#ifdef PCAP_FDDIPAD
|
||||
/* Padding only needed for live capture fcode */
|
||||
p->fddipad = 0;
|
||||
#endif
|
||||
|
||||
#if !defined(WIN32) && !defined(MSDOS)
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
/*
|
||||
* You can do "select()" and "poll()" on plain files on most
|
||||
* platforms, and should be able to do so on pipes.
|
||||
@@ -330,18 +443,45 @@ found:
|
||||
p->getnonblock_op = sf_getnonblock;
|
||||
p->setnonblock_op = sf_setnonblock;
|
||||
p->stats_op = sf_stats;
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
p->stats_ex_op = sf_stats_ex;
|
||||
p->setbuff_op = sf_setbuff;
|
||||
p->setmode_op = sf_setmode;
|
||||
p->setmintocopy_op = sf_setmintocopy;
|
||||
p->getevent_op = sf_getevent;
|
||||
p->oid_get_request_op = sf_oid_get_request;
|
||||
p->oid_set_request_op = sf_oid_set_request;
|
||||
p->sendqueue_transmit_op = sf_sendqueue_transmit;
|
||||
p->setuserbuffer_op = sf_setuserbuffer;
|
||||
p->live_dump_op = sf_live_dump;
|
||||
p->live_dump_ended_op = sf_live_dump_ended;
|
||||
p->get_airpcap_handle_op = sf_get_airpcap_handle;
|
||||
#endif
|
||||
p->cleanup_op = sf_cleanup;
|
||||
|
||||
/*
|
||||
* For offline captures, the standard one-shot callback can
|
||||
* be used for pcap_next()/pcap_next_ex().
|
||||
*/
|
||||
p->oneshot_callback = pcap_oneshot;
|
||||
|
||||
/*
|
||||
* Savefiles never require special BPF code generation.
|
||||
*/
|
||||
p->bpf_codegen_flags = 0;
|
||||
|
||||
p->activated = 1;
|
||||
|
||||
return (p);
|
||||
bad:
|
||||
free(p);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
static
|
||||
#endif
|
||||
pcap_t *
|
||||
pcap_fopen_offline(FILE *fp, char *errbuf)
|
||||
{
|
||||
return (pcap_fopen_offline_with_tstamp_precision(fp,
|
||||
PCAP_TSTAMP_PRECISION_MICRO, errbuf));
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -377,7 +517,7 @@ pcap_offline_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
|
||||
return (n);
|
||||
}
|
||||
|
||||
status = p->sf.next_packet_op(p, &h, &data);
|
||||
status = p->next_packet_op(p, &h, &data);
|
||||
if (status) {
|
||||
if (status == 1)
|
||||
return (0);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
362
freebsd/contrib/libpcap/scanner.h
Normal file
362
freebsd/contrib/libpcap/scanner.h
Normal file
@@ -0,0 +1,362 @@
|
||||
#ifndef pcap_HEADER_H
|
||||
#define pcap_HEADER_H 1
|
||||
#define pcap_IN_HEADER 1
|
||||
|
||||
#line 6 "scanner.h"
|
||||
#line 2 "scanner.l"
|
||||
/* Must come first for _LARGE_FILE_API on AIX. */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#line 15 "scanner.h"
|
||||
|
||||
#define YY_INT_ALIGNED short int
|
||||
|
||||
/* A lexical scanner generated by flex */
|
||||
|
||||
#define FLEX_SCANNER
|
||||
#define YY_FLEX_MAJOR_VERSION 2
|
||||
#define YY_FLEX_MINOR_VERSION 5
|
||||
#define YY_FLEX_SUBMINOR_VERSION 37
|
||||
#if YY_FLEX_SUBMINOR_VERSION > 0
|
||||
#define FLEX_BETA
|
||||
#endif
|
||||
|
||||
/* First, we deal with platform-specific or compiler-specific issues. */
|
||||
|
||||
#if defined(__FreeBSD__)
|
||||
#ifndef __STDC_LIMIT_MACROS
|
||||
#define __STDC_LIMIT_MACROS
|
||||
#endif
|
||||
#include <sys/cdefs.h>
|
||||
#include <stdint.h>
|
||||
#else
|
||||
#define __dead2
|
||||
#endif
|
||||
|
||||
/* begin standard C headers. */
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* end standard C headers. */
|
||||
|
||||
/* flex integer type definitions */
|
||||
|
||||
#ifndef FLEXINT_H
|
||||
#define FLEXINT_H
|
||||
|
||||
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
|
||||
|
||||
#if defined(__FreeBSD__) || \
|
||||
(defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
|
||||
|
||||
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
|
||||
* if you want the limit (max/min) macros for int types.
|
||||
*/
|
||||
#ifndef __STDC_LIMIT_MACROS
|
||||
#define __STDC_LIMIT_MACROS 1
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
typedef int8_t flex_int8_t;
|
||||
typedef uint8_t flex_uint8_t;
|
||||
typedef int16_t flex_int16_t;
|
||||
typedef uint16_t flex_uint16_t;
|
||||
typedef int32_t flex_int32_t;
|
||||
typedef uint32_t flex_uint32_t;
|
||||
#else
|
||||
typedef signed char flex_int8_t;
|
||||
typedef short int flex_int16_t;
|
||||
typedef int flex_int32_t;
|
||||
typedef unsigned char flex_uint8_t;
|
||||
typedef unsigned short int flex_uint16_t;
|
||||
typedef unsigned int flex_uint32_t;
|
||||
|
||||
/* Limits of integral types. */
|
||||
#ifndef INT8_MIN
|
||||
#define INT8_MIN (-128)
|
||||
#endif
|
||||
#ifndef INT16_MIN
|
||||
#define INT16_MIN (-32767-1)
|
||||
#endif
|
||||
#ifndef INT32_MIN
|
||||
#define INT32_MIN (-2147483647-1)
|
||||
#endif
|
||||
#ifndef INT8_MAX
|
||||
#define INT8_MAX (127)
|
||||
#endif
|
||||
#ifndef INT16_MAX
|
||||
#define INT16_MAX (32767)
|
||||
#endif
|
||||
#ifndef INT32_MAX
|
||||
#define INT32_MAX (2147483647)
|
||||
#endif
|
||||
#ifndef UINT8_MAX
|
||||
#define UINT8_MAX (255U)
|
||||
#endif
|
||||
#ifndef UINT16_MAX
|
||||
#define UINT16_MAX (65535U)
|
||||
#endif
|
||||
#ifndef UINT32_MAX
|
||||
#define UINT32_MAX (4294967295U)
|
||||
#endif
|
||||
|
||||
#endif /* ! C99 */
|
||||
|
||||
#endif /* ! FLEXINT_H */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
/* The "const" storage-class-modifier is valid. */
|
||||
#define YY_USE_CONST
|
||||
|
||||
#else /* ! __cplusplus */
|
||||
|
||||
/* C99 requires __STDC__ to be defined as 1. */
|
||||
#if defined (__STDC__)
|
||||
|
||||
#define YY_USE_CONST
|
||||
|
||||
#endif /* defined (__STDC__) */
|
||||
#endif /* ! __cplusplus */
|
||||
|
||||
#ifdef YY_USE_CONST
|
||||
#define yyconst const
|
||||
#else
|
||||
#define yyconst
|
||||
#endif
|
||||
|
||||
/* An opaque pointer. */
|
||||
#ifndef YY_TYPEDEF_YY_SCANNER_T
|
||||
#define YY_TYPEDEF_YY_SCANNER_T
|
||||
typedef void* yyscan_t;
|
||||
#endif
|
||||
|
||||
/* For convenience, these vars (plus the bison vars far below)
|
||||
are macros in the reentrant scanner. */
|
||||
#define yyin yyg->yyin_r
|
||||
#define yyout yyg->yyout_r
|
||||
#define yyextra yyg->yyextra_r
|
||||
#define yyleng yyg->yyleng_r
|
||||
#define yytext yyg->yytext_r
|
||||
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
|
||||
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
|
||||
#define yy_flex_debug yyg->yy_flex_debug_r
|
||||
|
||||
/* Size of default input buffer. */
|
||||
#ifndef YY_BUF_SIZE
|
||||
#define YY_BUF_SIZE 16384
|
||||
#endif
|
||||
|
||||
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
|
||||
#define YY_TYPEDEF_YY_BUFFER_STATE
|
||||
typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
||||
#endif
|
||||
|
||||
#ifndef YY_TYPEDEF_YY_SIZE_T
|
||||
#define YY_TYPEDEF_YY_SIZE_T
|
||||
typedef size_t yy_size_t;
|
||||
#endif
|
||||
|
||||
#ifndef YY_STRUCT_YY_BUFFER_STATE
|
||||
#define YY_STRUCT_YY_BUFFER_STATE
|
||||
struct yy_buffer_state
|
||||
{
|
||||
FILE *yy_input_file;
|
||||
|
||||
char *yy_ch_buf; /* input buffer */
|
||||
char *yy_buf_pos; /* current position in input buffer */
|
||||
|
||||
/* Size of input buffer in bytes, not including room for EOB
|
||||
* characters.
|
||||
*/
|
||||
yy_size_t yy_buf_size;
|
||||
|
||||
/* Number of characters read into yy_ch_buf, not including EOB
|
||||
* characters.
|
||||
*/
|
||||
yy_size_t yy_n_chars;
|
||||
|
||||
/* Whether we "own" the buffer - i.e., we know we created it,
|
||||
* and can realloc() it to grow it, and should free() it to
|
||||
* delete it.
|
||||
*/
|
||||
int yy_is_our_buffer;
|
||||
|
||||
/* Whether this is an "interactive" input source; if so, and
|
||||
* if we're using stdio for input, then we want to use getc()
|
||||
* instead of fread(), to make sure we stop fetching input after
|
||||
* each newline.
|
||||
*/
|
||||
int yy_is_interactive;
|
||||
|
||||
/* Whether we're considered to be at the beginning of a line.
|
||||
* If so, '^' rules will be active on the next match, otherwise
|
||||
* not.
|
||||
*/
|
||||
int yy_at_bol;
|
||||
|
||||
int yy_bs_lineno; /**< The line count. */
|
||||
int yy_bs_column; /**< The column count. */
|
||||
|
||||
/* Whether to try to fill the input buffer when we reach the
|
||||
* end of it.
|
||||
*/
|
||||
int yy_fill_buffer;
|
||||
|
||||
int yy_buffer_status;
|
||||
|
||||
};
|
||||
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
|
||||
|
||||
void pcap_restart (FILE *input_file ,yyscan_t yyscanner );
|
||||
void pcap__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE pcap__create_buffer (FILE *file,int size ,yyscan_t yyscanner );
|
||||
void pcap__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void pcap__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void pcap_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
void pcap_pop_buffer_state (yyscan_t yyscanner );
|
||||
|
||||
YY_BUFFER_STATE pcap__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE pcap__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE pcap__scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
|
||||
|
||||
void *pcap_alloc (yy_size_t ,yyscan_t yyscanner );
|
||||
void *pcap_realloc (void *,yy_size_t ,yyscan_t yyscanner );
|
||||
void pcap_free (void * ,yyscan_t yyscanner );
|
||||
|
||||
/* Begin user sect3 */
|
||||
|
||||
#define pcap_wrap(yyscanner) 1
|
||||
#define YY_SKIP_YYWRAP
|
||||
|
||||
#define yytext_ptr yytext_r
|
||||
|
||||
#ifdef YY_HEADER_EXPORT_START_CONDITIONS
|
||||
#define INITIAL 0
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef YY_NO_UNISTD_H
|
||||
/* Special case for "unistd.h", since it is non-ANSI. We include it way
|
||||
* down here because we want the user's section 1 to have been scanned first.
|
||||
* The user has a chance to override it with an option.
|
||||
*/
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#define YY_EXTRA_TYPE compiler_state_t *
|
||||
|
||||
int pcap_lex_init (yyscan_t* scanner);
|
||||
|
||||
int pcap_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
|
||||
|
||||
/* Accessor methods to globals.
|
||||
These are made visible to non-reentrant scanners for convenience. */
|
||||
|
||||
int pcap_lex_destroy (yyscan_t yyscanner );
|
||||
|
||||
int pcap_get_debug (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_debug (int debug_flag ,yyscan_t yyscanner );
|
||||
|
||||
YY_EXTRA_TYPE pcap_get_extra (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
|
||||
|
||||
FILE *pcap_get_in (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_in (FILE * in_str ,yyscan_t yyscanner );
|
||||
|
||||
FILE *pcap_get_out (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_out (FILE * out_str ,yyscan_t yyscanner );
|
||||
|
||||
yy_size_t pcap_get_leng (yyscan_t yyscanner );
|
||||
|
||||
char *pcap_get_text (yyscan_t yyscanner );
|
||||
|
||||
int pcap_get_lineno (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_lineno (int line_number ,yyscan_t yyscanner );
|
||||
|
||||
int pcap_get_column (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_column (int column_no ,yyscan_t yyscanner );
|
||||
|
||||
YYSTYPE * pcap_get_lval (yyscan_t yyscanner );
|
||||
|
||||
void pcap_set_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
|
||||
|
||||
/* Macros after this point can all be overridden by user definitions in
|
||||
* section 1.
|
||||
*/
|
||||
|
||||
#ifndef YY_SKIP_YYWRAP
|
||||
#ifdef __cplusplus
|
||||
extern "C" int pcap_wrap (yyscan_t yyscanner );
|
||||
#else
|
||||
extern int pcap_wrap (yyscan_t yyscanner );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef yytext_ptr
|
||||
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
|
||||
#endif
|
||||
|
||||
#ifdef YY_NEED_STRLEN
|
||||
static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
|
||||
#endif
|
||||
|
||||
#ifndef YY_NO_INPUT
|
||||
|
||||
#endif
|
||||
|
||||
/* Amount of stuff to slurp up with each read. */
|
||||
#ifndef YY_READ_BUF_SIZE
|
||||
#define YY_READ_BUF_SIZE 8192
|
||||
#endif
|
||||
|
||||
/* Number of entries by which start-condition stack grows. */
|
||||
#ifndef YY_START_STACK_INCR
|
||||
#define YY_START_STACK_INCR 25
|
||||
#endif
|
||||
|
||||
/* Default declaration of generated scanner - a define so the user can
|
||||
* easily add parameters.
|
||||
*/
|
||||
#ifndef YY_DECL
|
||||
#define YY_DECL_IS_OURS 1
|
||||
|
||||
extern int pcap_lex \
|
||||
(YYSTYPE * yylval_param ,yyscan_t yyscanner);
|
||||
|
||||
#define YY_DECL int pcap_lex \
|
||||
(YYSTYPE * yylval_param , yyscan_t yyscanner)
|
||||
#endif /* !YY_DECL */
|
||||
|
||||
/* yy_get_previous_state - get the state just before the EOB char was reached */
|
||||
|
||||
#undef YY_NEW_FILE
|
||||
#undef YY_FLUSH_BUFFER
|
||||
#undef yy_set_bol
|
||||
#undef yy_new_buffer
|
||||
#undef yy_set_interactive
|
||||
#undef YY_DO_BEFORE_ACTION
|
||||
|
||||
#ifdef YY_DECL_IS_OURS
|
||||
#undef YY_DECL_IS_OURS
|
||||
#undef YY_DECL
|
||||
#endif
|
||||
|
||||
#line 448 "scanner.l"
|
||||
|
||||
|
||||
#line 361 "scanner.h"
|
||||
#undef pcap_IN_HEADER
|
||||
#endif /* pcap_HEADER_H */
|
||||
@@ -1,3 +1,46 @@
|
||||
%top {
|
||||
/* Must come first for _LARGE_FILE_API on AIX. */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* We want a reentrant scanner.
|
||||
*/
|
||||
%option reentrant
|
||||
|
||||
/*
|
||||
* And we need to pass the compiler state to the scanner.
|
||||
*/
|
||||
%option extra-type="compiler_state_t *"
|
||||
|
||||
/*
|
||||
* We don't use input, so don't generate code for it.
|
||||
*/
|
||||
%option noinput
|
||||
|
||||
/*
|
||||
* We don't use unput, so don't generate code for it.
|
||||
*/
|
||||
%option nounput
|
||||
|
||||
/*
|
||||
* We don't read from the terminal.
|
||||
*/
|
||||
%option never-interactive
|
||||
|
||||
/*
|
||||
* We want to stop processing when we get to the end of the input.
|
||||
*/
|
||||
%option noyywrap
|
||||
|
||||
/*
|
||||
* We want to generate code that can be used by a reentrant parser
|
||||
* generated by Bison or Berkeley YACC.
|
||||
*/
|
||||
%option bison-bridge
|
||||
|
||||
%{
|
||||
/*
|
||||
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
|
||||
@@ -22,54 +65,76 @@
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static const char rcsid[] _U_ =
|
||||
"@(#) $Header: /tcpdump/master/libpcap/scanner.l,v 1.112 2008-02-06 10:21:30 guy Exp $ (LBL)";
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#ifdef HAVE_SYS_BITYPES_H
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#ifdef HAVE_SYS_BITYPES_H
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "pcap-int.h"
|
||||
|
||||
#include "gencode.h"
|
||||
#ifdef INET6
|
||||
#ifdef WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
|
||||
#ifdef __MINGW32__
|
||||
#include "ip6_misc.h"
|
||||
#endif
|
||||
#else /* WIN32 */
|
||||
#include "grammar.h"
|
||||
|
||||
/*
|
||||
* Earlier versions of Flex don't declare these, so we declare them
|
||||
* ourselves to squelch warnings.
|
||||
*/
|
||||
int pcap_get_column(yyscan_t);
|
||||
void pcap_set_column(int, yyscan_t);
|
||||
|
||||
#ifdef INET6
|
||||
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
* To quote the MSDN page for getaddrinfo() at
|
||||
*
|
||||
* https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520(v=vs.85).aspx
|
||||
*
|
||||
* "Support for getaddrinfo on Windows 2000 and older versions
|
||||
* The getaddrinfo function was added to the Ws2_32.dll on Windows XP and
|
||||
* later. To execute an application that uses this function on earlier
|
||||
* versions of Windows, then you need to include the Ws2tcpip.h and
|
||||
* Wspiapi.h files. When the Wspiapi.h include file is added, the
|
||||
* getaddrinfo function is defined to the WspiapiGetAddrInfo inline
|
||||
* function in the Wspiapi.h file. At runtime, the WspiapiGetAddrInfo
|
||||
* function is implemented in such a way that if the Ws2_32.dll or the
|
||||
* Wship6.dll (the file containing getaddrinfo in the IPv6 Technology
|
||||
* Preview for Windows 2000) does not include getaddrinfo, then a
|
||||
* version of getaddrinfo is implemented inline based on code in the
|
||||
* Wspiapi.h header file. This inline code will be used on older Windows
|
||||
* platforms that do not natively support the getaddrinfo function."
|
||||
*
|
||||
* We use getaddrinfo(), so we include Wspiapi.h here. pcap-stdinc.h
|
||||
* includes Ws2tcpip.h, so we don't need to include it ourselves.
|
||||
*/
|
||||
#include <Wspiapi.h>
|
||||
#else /* _WIN32 */
|
||||
#include <sys/socket.h> /* for "struct sockaddr" in "struct addrinfo" */
|
||||
#include <netdb.h> /* for "struct addrinfo" */
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* Workaround for AIX 4.3 */
|
||||
#if !defined(AI_NUMERICHOST)
|
||||
#define AI_NUMERICHOST 0x04
|
||||
#endif
|
||||
|
||||
#endif /*INET6*/
|
||||
|
||||
#include <pcap/namedb.h>
|
||||
#include "tokdefs.h"
|
||||
#include "grammar.h"
|
||||
|
||||
#ifdef HAVE_OS_PROTO_H
|
||||
#include "os-proto.h"
|
||||
@@ -78,19 +143,6 @@ static const char rcsid[] _U_ =
|
||||
static int stoi(char *);
|
||||
static inline int xdtoi(int);
|
||||
|
||||
#ifdef FLEX_SCANNER
|
||||
#define YY_NO_INPUT
|
||||
#define YY_NO_UNPUT
|
||||
static YY_BUFFER_STATE in_buffer;
|
||||
#else
|
||||
static const char *in_buffer;
|
||||
|
||||
#undef getc
|
||||
#define getc(fp) (*in_buffer == 0 ? EOF : *in_buffer++)
|
||||
#endif
|
||||
|
||||
extern YYSTYPE yylval;
|
||||
|
||||
%}
|
||||
|
||||
N ([0-9]+|(0X|0x)[0-9A-Fa-f]+)
|
||||
@@ -249,7 +301,7 @@ portrange return PORTRANGE;
|
||||
proto return PROTO;
|
||||
protochain {
|
||||
#ifdef NO_PROTOCHAIN
|
||||
bpf_error("%s not supported", yytext);
|
||||
bpf_error(yyextra, "%s not supported", yytext);
|
||||
#else
|
||||
return PROTOCHAIN;
|
||||
#endif
|
||||
@@ -285,6 +337,7 @@ vlan return VLAN;
|
||||
mpls return MPLS;
|
||||
pppoed return PPPOED;
|
||||
pppoes return PPPOES;
|
||||
geneve return GENEVE;
|
||||
|
||||
lane return LANE;
|
||||
llc return LLC;
|
||||
@@ -312,26 +365,37 @@ fisu return FISU;
|
||||
lssu return LSSU;
|
||||
lsu return LSSU;
|
||||
msu return MSU;
|
||||
hfisu return HFISU;
|
||||
hlssu return HLSSU;
|
||||
hmsu return HMSU;
|
||||
sio return SIO;
|
||||
opc return OPC;
|
||||
dpc return DPC;
|
||||
sls return SLS;
|
||||
hsio return HSIO;
|
||||
hopc return HOPC;
|
||||
hdpc return HDPC;
|
||||
hsls return HSLS;
|
||||
|
||||
[ \r\n\t] ;
|
||||
[+\-*/:\[\]!<>()&|=] return yytext[0];
|
||||
[+\-*/%:\[\]!<>()&|\^=] return yytext[0];
|
||||
">=" return GEQ;
|
||||
"<=" return LEQ;
|
||||
"!=" return NEQ;
|
||||
"==" return '=';
|
||||
"<<" return LSH;
|
||||
">>" return RSH;
|
||||
${B} { yylval.e = pcap_ether_aton(((char *)yytext)+1);
|
||||
${B} { yylval->e = pcap_ether_aton(((char *)yytext)+1);
|
||||
if (yylval->e == NULL)
|
||||
bpf_error(yyextra, "malloc");
|
||||
return AID; }
|
||||
{MAC} { yylval.e = pcap_ether_aton((char *)yytext);
|
||||
{MAC} { yylval->e = pcap_ether_aton((char *)yytext);
|
||||
if (yylval->e == NULL)
|
||||
bpf_error(yyextra, "malloc");
|
||||
return EID; }
|
||||
{N} { yylval.i = stoi((char *)yytext); return NUM; }
|
||||
{N} { yylval->i = stoi((char *)yytext); return NUM; }
|
||||
({N}\.{N})|({N}\.{N}\.{N})|({N}\.{N}\.{N}\.{N}) {
|
||||
yylval.s = sdup((char *)yytext); return HID; }
|
||||
yylval->s = sdup(yyextra, (char *)yytext); return HID; }
|
||||
{V6} {
|
||||
#ifdef INET6
|
||||
struct addrinfo hints, *res;
|
||||
@@ -339,80 +403,49 @@ ${B} { yylval.e = pcap_ether_aton(((char *)yytext)+1);
|
||||
hints.ai_family = AF_INET6;
|
||||
hints.ai_flags = AI_NUMERICHOST;
|
||||
if (getaddrinfo(yytext, NULL, &hints, &res))
|
||||
bpf_error("bogus IPv6 address %s", yytext);
|
||||
bpf_error(yyextra, "bogus IPv6 address %s", yytext);
|
||||
else {
|
||||
freeaddrinfo(res);
|
||||
yylval.s = sdup((char *)yytext); return HID6;
|
||||
yylval->s = sdup(yyextra, (char *)yytext); return HID6;
|
||||
}
|
||||
#else
|
||||
bpf_error("IPv6 address %s not supported", yytext);
|
||||
bpf_error(yyextra, "IPv6 address %s not supported", yytext);
|
||||
#endif /*INET6*/
|
||||
}
|
||||
{B}:+({B}:+)+ { bpf_error("bogus ethernet address %s", yytext); }
|
||||
icmptype { yylval.i = 0; return NUM; }
|
||||
icmpcode { yylval.i = 1; return NUM; }
|
||||
icmp-echoreply { yylval.i = 0; return NUM; }
|
||||
icmp-unreach { yylval.i = 3; return NUM; }
|
||||
icmp-sourcequench { yylval.i = 4; return NUM; }
|
||||
icmp-redirect { yylval.i = 5; return NUM; }
|
||||
icmp-echo { yylval.i = 8; return NUM; }
|
||||
icmp-routeradvert { yylval.i = 9; return NUM; }
|
||||
icmp-routersolicit { yylval.i = 10; return NUM; }
|
||||
icmp-timxceed { yylval.i = 11; return NUM; }
|
||||
icmp-paramprob { yylval.i = 12; return NUM; }
|
||||
icmp-tstamp { yylval.i = 13; return NUM; }
|
||||
icmp-tstampreply { yylval.i = 14; return NUM; }
|
||||
icmp-ireq { yylval.i = 15; return NUM; }
|
||||
icmp-ireqreply { yylval.i = 16; return NUM; }
|
||||
icmp-maskreq { yylval.i = 17; return NUM; }
|
||||
icmp-maskreply { yylval.i = 18; return NUM; }
|
||||
tcpflags { yylval.i = 13; return NUM; }
|
||||
tcp-fin { yylval.i = 0x01; return NUM; }
|
||||
tcp-syn { yylval.i = 0x02; return NUM; }
|
||||
tcp-rst { yylval.i = 0x04; return NUM; }
|
||||
tcp-push { yylval.i = 0x08; return NUM; }
|
||||
tcp-ack { yylval.i = 0x10; return NUM; }
|
||||
tcp-urg { yylval.i = 0x20; return NUM; }
|
||||
{B}:+({B}:+)+ { bpf_error(yyextra, "bogus ethernet address %s", yytext); }
|
||||
icmptype { yylval->i = 0; return NUM; }
|
||||
icmpcode { yylval->i = 1; return NUM; }
|
||||
icmp-echoreply { yylval->i = 0; return NUM; }
|
||||
icmp-unreach { yylval->i = 3; return NUM; }
|
||||
icmp-sourcequench { yylval->i = 4; return NUM; }
|
||||
icmp-redirect { yylval->i = 5; return NUM; }
|
||||
icmp-echo { yylval->i = 8; return NUM; }
|
||||
icmp-routeradvert { yylval->i = 9; return NUM; }
|
||||
icmp-routersolicit { yylval->i = 10; return NUM; }
|
||||
icmp-timxceed { yylval->i = 11; return NUM; }
|
||||
icmp-paramprob { yylval->i = 12; return NUM; }
|
||||
icmp-tstamp { yylval->i = 13; return NUM; }
|
||||
icmp-tstampreply { yylval->i = 14; return NUM; }
|
||||
icmp-ireq { yylval->i = 15; return NUM; }
|
||||
icmp-ireqreply { yylval->i = 16; return NUM; }
|
||||
icmp-maskreq { yylval->i = 17; return NUM; }
|
||||
icmp-maskreply { yylval->i = 18; return NUM; }
|
||||
tcpflags { yylval->i = 13; return NUM; }
|
||||
tcp-fin { yylval->i = 0x01; return NUM; }
|
||||
tcp-syn { yylval->i = 0x02; return NUM; }
|
||||
tcp-rst { yylval->i = 0x04; return NUM; }
|
||||
tcp-push { yylval->i = 0x08; return NUM; }
|
||||
tcp-ack { yylval->i = 0x10; return NUM; }
|
||||
tcp-urg { yylval->i = 0x20; return NUM; }
|
||||
tcp-ece { yylval->i = 0x40; return NUM; }
|
||||
tcp-cwr { yylval->i = 0x80; return NUM; }
|
||||
[A-Za-z0-9]([-_.A-Za-z0-9]*[.A-Za-z0-9])? {
|
||||
yylval.s = sdup((char *)yytext); return ID; }
|
||||
"\\"[^ !()\n\t]+ { yylval.s = sdup((char *)yytext + 1); return ID; }
|
||||
yylval->s = sdup(yyextra, (char *)yytext); return ID; }
|
||||
"\\"[^ !()\n\t]+ { yylval->s = sdup(yyextra, (char *)yytext + 1); return ID; }
|
||||
[^ \[\]\t\n\-_.A-Za-z0-9!<>()&|=]+ {
|
||||
bpf_error("illegal token: %s", yytext); }
|
||||
. { bpf_error("illegal char '%c'", *yytext); }
|
||||
bpf_error(yyextra, "illegal token: %s", yytext); }
|
||||
. { bpf_error(yyextra, "illegal char '%c'", *yytext); }
|
||||
%%
|
||||
void
|
||||
lex_init(buf)
|
||||
const char *buf;
|
||||
{
|
||||
#ifdef FLEX_SCANNER
|
||||
in_buffer = yy_scan_string(buf);
|
||||
#else
|
||||
in_buffer = buf;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Do any cleanup necessary after parsing.
|
||||
*/
|
||||
void
|
||||
lex_cleanup()
|
||||
{
|
||||
#ifdef FLEX_SCANNER
|
||||
if (in_buffer != NULL)
|
||||
yy_delete_buffer(in_buffer);
|
||||
in_buffer = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Also define a yywrap. Note that if we're using flex, it will
|
||||
* define a macro to map this identifier to pcap_wrap.
|
||||
*/
|
||||
int
|
||||
yywrap()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Hex digit to integer. */
|
||||
static inline int
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -26,6 +26,7 @@
|
||||
#ifndef sf_pcap_ng_h
|
||||
#define sf_pcap_ng_h
|
||||
|
||||
extern int pcap_ng_check_header(pcap_t *, bpf_u_int32, FILE *, char *);
|
||||
extern pcap_t *pcap_ng_check_header(bpf_u_int32 magic, FILE *fp,
|
||||
u_int precision, char *errbuf, int *err);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -39,9 +39,9 @@ static const char rcsid[] _U_ =
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#include <pcap-stdinc.h>
|
||||
#else /* WIN32 */
|
||||
#else /* _WIN32 */
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#elif HAVE_STDINT_H
|
||||
@@ -51,7 +51,7 @@ static const char rcsid[] _U_ =
|
||||
#include <sys/bitypes.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#endif /* WIN32 */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include <errno.h>
|
||||
#include <memory.h>
|
||||
@@ -72,7 +72,7 @@ static const char rcsid[] _U_ =
|
||||
/*
|
||||
* Setting O_BINARY on DOS/Windows is a bit tricky
|
||||
*/
|
||||
#if defined(WIN32)
|
||||
#if defined(_WIN32)
|
||||
#define SET_BINMODE(f) _setmode(_fileno(f), _O_BINARY)
|
||||
#elif defined(MSDOS)
|
||||
#if defined(__HIGHC__)
|
||||
@@ -124,26 +124,58 @@ static const char rcsid[] _U_ =
|
||||
|
||||
static int pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **datap);
|
||||
|
||||
/*
|
||||
* Private data for reading pcap savefiles.
|
||||
*/
|
||||
typedef enum {
|
||||
NOT_SWAPPED,
|
||||
SWAPPED,
|
||||
MAYBE_SWAPPED
|
||||
} swapped_type_t;
|
||||
|
||||
typedef enum {
|
||||
PASS_THROUGH,
|
||||
SCALE_UP,
|
||||
SCALE_DOWN
|
||||
} tstamp_scale_type_t;
|
||||
|
||||
struct pcap_sf {
|
||||
size_t hdrsize;
|
||||
swapped_type_t lengths_swapped;
|
||||
tstamp_scale_type_t scale_type;
|
||||
};
|
||||
|
||||
/*
|
||||
* Check whether this is a pcap savefile and, if it is, extract the
|
||||
* relevant information from the header.
|
||||
*/
|
||||
int
|
||||
pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
pcap_t *
|
||||
pcap_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
|
||||
int *err)
|
||||
{
|
||||
struct pcap_file_header hdr;
|
||||
size_t amt_read;
|
||||
pcap_t *p;
|
||||
int swapped = 0;
|
||||
struct pcap_sf *ps;
|
||||
|
||||
/*
|
||||
* Assume no read errors.
|
||||
*/
|
||||
*err = 0;
|
||||
|
||||
/*
|
||||
* Check whether the first 4 bytes of the file are the magic
|
||||
* number for a pcap savefile, or for a byte-swapped pcap
|
||||
* savefile.
|
||||
*/
|
||||
if (magic != TCPDUMP_MAGIC && magic != KUZNETZOV_TCPDUMP_MAGIC) {
|
||||
if (magic != TCPDUMP_MAGIC && magic != KUZNETZOV_TCPDUMP_MAGIC &&
|
||||
magic != NSEC_TCPDUMP_MAGIC) {
|
||||
magic = SWAPLONG(magic);
|
||||
if (magic != TCPDUMP_MAGIC && magic != KUZNETZOV_TCPDUMP_MAGIC)
|
||||
return (0); /* nope */
|
||||
p->sf.swapped = 1;
|
||||
if (magic != TCPDUMP_MAGIC && magic != KUZNETZOV_TCPDUMP_MAGIC &&
|
||||
magic != NSEC_TCPDUMP_MAGIC)
|
||||
return (NULL); /* nope */
|
||||
swapped = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -155,22 +187,23 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
sizeof(hdr) - sizeof(hdr.magic), fp);
|
||||
if (amt_read != sizeof(hdr) - sizeof(hdr.magic)) {
|
||||
if (ferror(fp)) {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
} else {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %lu file header bytes, only got %lu",
|
||||
(unsigned long)sizeof(hdr),
|
||||
(unsigned long)amt_read);
|
||||
}
|
||||
return (-1);
|
||||
*err = 1;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* If it's a byte-swapped capture file, byte-swap the header.
|
||||
*/
|
||||
if (p->sf.swapped) {
|
||||
if (swapped) {
|
||||
hdr.version_major = SWAPSHORT(hdr.version_major);
|
||||
hdr.version_minor = SWAPSHORT(hdr.version_minor);
|
||||
hdr.thiszone = SWAPLONG(hdr.thiszone);
|
||||
@@ -180,18 +213,106 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
}
|
||||
|
||||
if (hdr.version_major < PCAP_VERSION_MAJOR) {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"archaic pcap savefile format");
|
||||
return (-1);
|
||||
*err = 1;
|
||||
return (NULL);
|
||||
}
|
||||
p->sf.version_major = hdr.version_major;
|
||||
p->sf.version_minor = hdr.version_minor;
|
||||
|
||||
/*
|
||||
* currently only versions 2.[0-4] are supported with
|
||||
* the exception of 543.0 for DG/UX tcpdump.
|
||||
*/
|
||||
if (! ((hdr.version_major == PCAP_VERSION_MAJOR &&
|
||||
hdr.version_minor <= PCAP_VERSION_MINOR) ||
|
||||
(hdr.version_major == 543 &&
|
||||
hdr.version_minor == 0))) {
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"unsupported pcap savefile version %u.%u",
|
||||
hdr.version_major, hdr.version_minor);
|
||||
*err = 1;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (hdr.snaplen > MAXIMUM_SNAPLEN) {
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"invalid file capture length %u, bigger than "
|
||||
"maximum of %u", hdr.snaplen, MAXIMUM_SNAPLEN);
|
||||
*err = 1;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* OK, this is a good pcap file.
|
||||
* Allocate a pcap_t for it.
|
||||
*/
|
||||
p = pcap_open_offline_common(errbuf, sizeof (struct pcap_sf));
|
||||
if (p == NULL) {
|
||||
/* Allocation failed. */
|
||||
*err = 1;
|
||||
return (NULL);
|
||||
}
|
||||
p->swapped = swapped;
|
||||
p->version_major = hdr.version_major;
|
||||
p->version_minor = hdr.version_minor;
|
||||
p->tzoff = hdr.thiszone;
|
||||
p->snapshot = hdr.snaplen;
|
||||
p->linktype = linktype_to_dlt(LT_LINKTYPE(hdr.linktype));
|
||||
p->linktype_ext = LT_LINKTYPE_EXT(hdr.linktype);
|
||||
|
||||
p->sf.next_packet_op = pcap_next_packet;
|
||||
p->next_packet_op = pcap_next_packet;
|
||||
|
||||
ps = p->priv;
|
||||
|
||||
p->opt.tstamp_precision = precision;
|
||||
|
||||
/*
|
||||
* Will we need to scale the timestamps to match what the
|
||||
* user wants?
|
||||
*/
|
||||
switch (precision) {
|
||||
|
||||
case PCAP_TSTAMP_PRECISION_MICRO:
|
||||
if (magic == NSEC_TCPDUMP_MAGIC) {
|
||||
/*
|
||||
* The file has nanoseconds, the user
|
||||
* wants microseconds; scale the
|
||||
* precision down.
|
||||
*/
|
||||
ps->scale_type = SCALE_DOWN;
|
||||
} else {
|
||||
/*
|
||||
* The file has microseconds, the
|
||||
* user wants microseconds; nothing to do.
|
||||
*/
|
||||
ps->scale_type = PASS_THROUGH;
|
||||
}
|
||||
break;
|
||||
|
||||
case PCAP_TSTAMP_PRECISION_NANO:
|
||||
if (magic == NSEC_TCPDUMP_MAGIC) {
|
||||
/*
|
||||
* The file has nanoseconds, the
|
||||
* user wants nanoseconds; nothing to do.
|
||||
*/
|
||||
ps->scale_type = PASS_THROUGH;
|
||||
} else {
|
||||
/*
|
||||
* The file has microoseconds, the user
|
||||
* wants nanoseconds; scale the
|
||||
* precision up.
|
||||
*/
|
||||
ps->scale_type = SCALE_UP;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
||||
"unknown time stamp resolution %u", precision);
|
||||
free(p);
|
||||
*err = 1;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* We interchanged the caplen and len fields at version 2.3,
|
||||
@@ -207,19 +328,19 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
|
||||
case 2:
|
||||
if (hdr.version_minor < 3)
|
||||
p->sf.lengths_swapped = SWAPPED;
|
||||
ps->lengths_swapped = SWAPPED;
|
||||
else if (hdr.version_minor == 3)
|
||||
p->sf.lengths_swapped = MAYBE_SWAPPED;
|
||||
ps->lengths_swapped = MAYBE_SWAPPED;
|
||||
else
|
||||
p->sf.lengths_swapped = NOT_SWAPPED;
|
||||
ps->lengths_swapped = NOT_SWAPPED;
|
||||
break;
|
||||
|
||||
case 543:
|
||||
p->sf.lengths_swapped = SWAPPED;
|
||||
ps->lengths_swapped = SWAPPED;
|
||||
break;
|
||||
|
||||
default:
|
||||
p->sf.lengths_swapped = NOT_SWAPPED;
|
||||
ps->lengths_swapped = NOT_SWAPPED;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -241,7 +362,7 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
* data ourselves and read from that buffer in order to
|
||||
* make that work.
|
||||
*/
|
||||
p->sf.hdrsize = sizeof(struct pcap_sf_patched_pkthdr);
|
||||
ps->hdrsize = sizeof(struct pcap_sf_patched_pkthdr);
|
||||
|
||||
if (p->linktype == DLT_EN10MB) {
|
||||
/*
|
||||
@@ -267,7 +388,7 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
p->snapshot += 14;
|
||||
}
|
||||
} else
|
||||
p->sf.hdrsize = sizeof(struct pcap_sf_pkthdr);
|
||||
ps->hdrsize = sizeof(struct pcap_sf_pkthdr);
|
||||
|
||||
/*
|
||||
* Allocate a buffer for the packet data.
|
||||
@@ -275,17 +396,21 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
p->bufsize = p->snapshot;
|
||||
if (p->bufsize <= 0) {
|
||||
/*
|
||||
* Bogus snapshot length; use 64KiB as a fallback.
|
||||
* Bogus snapshot length; use the maximum as a fallback.
|
||||
*/
|
||||
p->bufsize = 65536;
|
||||
p->bufsize = MAXIMUM_SNAPLEN;
|
||||
}
|
||||
p->buffer = malloc(p->bufsize);
|
||||
if (p->buffer == NULL) {
|
||||
snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");
|
||||
return (-1);
|
||||
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");
|
||||
free(p);
|
||||
*err = 1;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
return (1);
|
||||
p->cleanup_op = sf_cleanup;
|
||||
|
||||
return (p);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -296,8 +421,9 @@ pcap_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf)
|
||||
static int
|
||||
pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
{
|
||||
struct pcap_sf *ps = p->priv;
|
||||
struct pcap_sf_patched_pkthdr sf_hdr;
|
||||
FILE *fp = p->sf.rfile;
|
||||
FILE *fp = p->rfile;
|
||||
size_t amt_read;
|
||||
bpf_u_int32 t;
|
||||
|
||||
@@ -308,18 +434,18 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
* unpatched libpcap we only read as many bytes as the regular
|
||||
* header has.
|
||||
*/
|
||||
amt_read = fread(&sf_hdr, 1, p->sf.hdrsize, fp);
|
||||
if (amt_read != p->sf.hdrsize) {
|
||||
amt_read = fread(&sf_hdr, 1, ps->hdrsize, fp);
|
||||
if (amt_read != ps->hdrsize) {
|
||||
if (ferror(fp)) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
return (-1);
|
||||
} else {
|
||||
if (amt_read != 0) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %lu header bytes, only got %lu",
|
||||
(unsigned long)p->sf.hdrsize,
|
||||
(unsigned long)ps->hdrsize,
|
||||
(unsigned long)amt_read);
|
||||
return (-1);
|
||||
}
|
||||
@@ -328,7 +454,7 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
}
|
||||
}
|
||||
|
||||
if (p->sf.swapped) {
|
||||
if (p->swapped) {
|
||||
/* these were written in opposite byte order */
|
||||
hdr->caplen = SWAPLONG(sf_hdr.caplen);
|
||||
hdr->len = SWAPLONG(sf_hdr.len);
|
||||
@@ -340,8 +466,34 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
hdr->ts.tv_sec = sf_hdr.ts.tv_sec;
|
||||
hdr->ts.tv_usec = sf_hdr.ts.tv_usec;
|
||||
}
|
||||
|
||||
switch (ps->scale_type) {
|
||||
|
||||
case PASS_THROUGH:
|
||||
/*
|
||||
* Just pass the time stamp through.
|
||||
*/
|
||||
break;
|
||||
|
||||
case SCALE_UP:
|
||||
/*
|
||||
* File has microseconds, user wants nanoseconds; convert
|
||||
* it.
|
||||
*/
|
||||
hdr->ts.tv_usec = hdr->ts.tv_usec * 1000;
|
||||
break;
|
||||
|
||||
case SCALE_DOWN:
|
||||
/*
|
||||
* File has nanoseconds, user wants microseconds; convert
|
||||
* it.
|
||||
*/
|
||||
hdr->ts.tv_usec = hdr->ts.tv_usec / 1000;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Swap the caplen and len fields, if necessary. */
|
||||
switch (p->sf.lengths_swapped) {
|
||||
switch (ps->lengths_swapped) {
|
||||
|
||||
case NOT_SWAPPED:
|
||||
break;
|
||||
@@ -367,63 +519,93 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
/*
|
||||
* This can happen due to Solaris 2.3 systems tripping
|
||||
* over the BUFMOD problem and not setting the snapshot
|
||||
* correctly in the savefile header. If the caplen isn't
|
||||
* grossly wrong, try to salvage.
|
||||
* correctly in the savefile header.
|
||||
* This can also happen with a corrupted savefile or a
|
||||
* savefile built/modified by a fuzz tester.
|
||||
* If the caplen isn't grossly wrong, try to salvage.
|
||||
*/
|
||||
static u_char *tp = NULL;
|
||||
static size_t tsize = 0;
|
||||
size_t bytes_to_discard;
|
||||
size_t bytes_to_read, bytes_read;
|
||||
char discard_buf[4096];
|
||||
|
||||
if (hdr->caplen > 65535) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"bogus savefile header");
|
||||
if (hdr->caplen > MAXIMUM_SNAPLEN) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"invalid packet capture length %u, bigger than "
|
||||
"maximum of %u", hdr->caplen, MAXIMUM_SNAPLEN);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (tsize < hdr->caplen) {
|
||||
tsize = ((hdr->caplen + 1023) / 1024) * 1024;
|
||||
if (tp != NULL)
|
||||
free((u_char *)tp);
|
||||
tp = (u_char *)malloc(tsize);
|
||||
if (tp == NULL) {
|
||||
tsize = 0;
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"BUFMOD hack malloc");
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
amt_read = fread((char *)tp, 1, hdr->caplen, fp);
|
||||
if (amt_read != hdr->caplen) {
|
||||
/*
|
||||
* XXX - we don't grow the buffer here because some
|
||||
* program might assume that it will never get packets
|
||||
* bigger than the snapshot length; for example, it might
|
||||
* copy data from our buffer to a buffer of its own,
|
||||
* allocated based on the return value of pcap_snapshot().
|
||||
*
|
||||
* Read the first p->bufsize bytes into the buffer.
|
||||
*/
|
||||
amt_read = fread(p->buffer, 1, p->bufsize, fp);
|
||||
if (amt_read != p->bufsize) {
|
||||
if (ferror(fp)) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
} else {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
/*
|
||||
* Yes, this uses hdr->caplen; technically,
|
||||
* it's true, because we would try to read
|
||||
* and discard the rest of those bytes, and
|
||||
* that would fail because we got EOF before
|
||||
* the read finished.
|
||||
*/
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %u captured bytes, only got %lu",
|
||||
hdr->caplen, (unsigned long)amt_read);
|
||||
}
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/*
|
||||
* We can only keep up to p->bufsize bytes. Since
|
||||
* caplen > p->bufsize is exactly how we got here,
|
||||
* we know we can only keep the first p->bufsize bytes
|
||||
* and must drop the remainder. Adjust caplen accordingly,
|
||||
* so we don't get confused later as to how many bytes we
|
||||
* have to play with.
|
||||
* Now read and discard what's left.
|
||||
*/
|
||||
bytes_to_discard = hdr->caplen - p->bufsize;
|
||||
bytes_read = amt_read;
|
||||
while (bytes_to_discard != 0) {
|
||||
bytes_to_read = bytes_to_discard;
|
||||
if (bytes_to_read > sizeof (discard_buf))
|
||||
bytes_to_read = sizeof (discard_buf);
|
||||
amt_read = fread(discard_buf, 1, bytes_to_read, fp);
|
||||
bytes_read += amt_read;
|
||||
if (amt_read != bytes_to_read) {
|
||||
if (ferror(fp)) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
} else {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %u captured bytes, only got %lu",
|
||||
hdr->caplen, (unsigned long)bytes_read);
|
||||
}
|
||||
return (-1);
|
||||
}
|
||||
bytes_to_discard -= amt_read;
|
||||
}
|
||||
|
||||
/*
|
||||
* Adjust caplen accordingly, so we don't get confused later
|
||||
* as to how many bytes we have to play with.
|
||||
*/
|
||||
hdr->caplen = p->bufsize;
|
||||
memcpy(p->buffer, (char *)tp, p->bufsize);
|
||||
} else {
|
||||
/* read the packet itself */
|
||||
amt_read = fread(p->buffer, 1, hdr->caplen, fp);
|
||||
if (amt_read != hdr->caplen) {
|
||||
if (ferror(fp)) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"error reading dump file: %s",
|
||||
pcap_strerror(errno));
|
||||
} else {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"truncated dump file; tried to read %u captured bytes, only got %lu",
|
||||
hdr->caplen, (unsigned long)amt_read);
|
||||
}
|
||||
@@ -432,33 +614,18 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
|
||||
}
|
||||
*data = p->buffer;
|
||||
|
||||
if (p->sf.swapped) {
|
||||
/*
|
||||
* Convert pseudo-headers from the byte order of
|
||||
* the host on which the file was saved to our
|
||||
* byte order, as necessary.
|
||||
*/
|
||||
switch (p->linktype) {
|
||||
|
||||
case DLT_USB_LINUX:
|
||||
swap_linux_usb_header(hdr, *data, 0);
|
||||
break;
|
||||
|
||||
case DLT_USB_LINUX_MMAPPED:
|
||||
swap_linux_usb_header(hdr, *data, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (p->swapped)
|
||||
swap_pseudo_headers(p->linktype, hdr, *data);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int
|
||||
sf_write_header(FILE *fp, int linktype, int thiszone, int snaplen)
|
||||
sf_write_header(pcap_t *p, FILE *fp, int linktype, int thiszone, int snaplen)
|
||||
{
|
||||
struct pcap_file_header hdr;
|
||||
|
||||
hdr.magic = TCPDUMP_MAGIC;
|
||||
hdr.magic = p->opt.tstamp_precision == PCAP_TSTAMP_PRECISION_NANO ? NSEC_TCPDUMP_MAGIC : TCPDUMP_MAGIC;
|
||||
hdr.version_major = PCAP_VERSION_MAJOR;
|
||||
hdr.version_minor = PCAP_VERSION_MINOR;
|
||||
|
||||
@@ -496,7 +663,7 @@ static pcap_dumper_t *
|
||||
pcap_setup_dump(pcap_t *p, int linktype, FILE *f, const char *fname)
|
||||
{
|
||||
|
||||
#if defined(WIN32) || defined(MSDOS)
|
||||
#if defined(_WIN32) || defined(MSDOS)
|
||||
/*
|
||||
* If we're writing to the standard output, put it in binary
|
||||
* mode, as savefiles are binary files.
|
||||
@@ -509,8 +676,8 @@ pcap_setup_dump(pcap_t *p, int linktype, FILE *f, const char *fname)
|
||||
else
|
||||
setbuf(f, NULL);
|
||||
#endif
|
||||
if (sf_write_header(f, linktype, p->tzoff, p->snapshot) == -1) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",
|
||||
if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
if (f != stdout)
|
||||
(void)fclose(f);
|
||||
@@ -533,31 +700,36 @@ pcap_dump_open(pcap_t *p, const char *fname)
|
||||
* link-layer type, so we can't use it.
|
||||
*/
|
||||
if (!p->activated) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: not-yet-activated pcap_t passed to pcap_dump_open",
|
||||
fname);
|
||||
return (NULL);
|
||||
}
|
||||
linktype = dlt_to_linktype(p->linktype);
|
||||
if (linktype == -1) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: link-layer type %d isn't supported in savefiles",
|
||||
fname, p->linktype);
|
||||
return (NULL);
|
||||
}
|
||||
linktype |= p->linktype_ext;
|
||||
|
||||
if (fname == NULL) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"A null pointer was supplied as the file name");
|
||||
return NULL;
|
||||
}
|
||||
if (fname[0] == '-' && fname[1] == '\0') {
|
||||
f = stdout;
|
||||
fname = "standard output";
|
||||
} else {
|
||||
#if !defined(WIN32) && !defined(MSDOS)
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
f = fopen(fname, "w");
|
||||
#else
|
||||
f = fopen(fname, "wb");
|
||||
#endif
|
||||
if (f == NULL) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
return (NULL);
|
||||
}
|
||||
@@ -570,12 +742,12 @@ pcap_dump_open(pcap_t *p, const char *fname)
|
||||
*/
|
||||
pcap_dumper_t *
|
||||
pcap_dump_fopen(pcap_t *p, FILE *f)
|
||||
{
|
||||
{
|
||||
int linktype;
|
||||
|
||||
linktype = dlt_to_linktype(p->linktype);
|
||||
if (linktype == -1) {
|
||||
snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"stream: link-layer type %d isn't supported in savefiles",
|
||||
p->linktype);
|
||||
return (NULL);
|
||||
@@ -585,6 +757,174 @@ pcap_dump_fopen(pcap_t *p, FILE *f)
|
||||
return (pcap_setup_dump(p, linktype, f, "stream"));
|
||||
}
|
||||
|
||||
pcap_dumper_t *
|
||||
pcap_dump_open_append(pcap_t *p, const char *fname)
|
||||
{
|
||||
FILE *f;
|
||||
int linktype;
|
||||
size_t amt_read;
|
||||
struct pcap_file_header ph;
|
||||
|
||||
linktype = dlt_to_linktype(p->linktype);
|
||||
if (linktype == -1) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: link-layer type %d isn't supported in savefiles",
|
||||
fname, linktype);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
if (fname == NULL) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"A null pointer was supplied as the file name");
|
||||
return NULL;
|
||||
}
|
||||
if (fname[0] == '-' && fname[1] == '\0')
|
||||
return (pcap_setup_dump(p, linktype, stdout, "standard output"));
|
||||
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
f = fopen(fname, "r+");
|
||||
#else
|
||||
f = fopen(fname, "rb+");
|
||||
#endif
|
||||
if (f == NULL) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Try to read a pcap header.
|
||||
*/
|
||||
amt_read = fread(&ph, 1, sizeof (ph), f);
|
||||
if (amt_read != sizeof (ph)) {
|
||||
if (ferror(f)) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
} else if (feof(f) && amt_read > 0) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: truncated pcap file header", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_WIN32) || defined(MSDOS)
|
||||
/*
|
||||
* We turn off buffering.
|
||||
* XXX - why? And why not on the standard output?
|
||||
*/
|
||||
setbuf(f, NULL);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* If a header is already present and:
|
||||
*
|
||||
* it's not for a pcap file of the appropriate resolution
|
||||
* and the right byte order for this machine;
|
||||
*
|
||||
* the link-layer header types don't match;
|
||||
*
|
||||
* the snapshot lengths don't match;
|
||||
*
|
||||
* return an error.
|
||||
*/
|
||||
if (amt_read > 0) {
|
||||
/*
|
||||
* A header is already present.
|
||||
* Do the checks.
|
||||
*/
|
||||
switch (ph.magic) {
|
||||
|
||||
case TCPDUMP_MAGIC:
|
||||
if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_MICRO) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: different time stamp precision, cannot append to file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
break;
|
||||
|
||||
case NSEC_TCPDUMP_MAGIC:
|
||||
if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_NANO) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: different time stamp precision, cannot append to file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
break;
|
||||
|
||||
case SWAPLONG(TCPDUMP_MAGIC):
|
||||
case SWAPLONG(NSEC_TCPDUMP_MAGIC):
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: different byte order, cannot append to file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
|
||||
case KUZNETZOV_TCPDUMP_MAGIC:
|
||||
case SWAPLONG(KUZNETZOV_TCPDUMP_MAGIC):
|
||||
case NAVTEL_TCPDUMP_MAGIC:
|
||||
case SWAPLONG(NAVTEL_TCPDUMP_MAGIC):
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: not a pcap file to which we can append", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
|
||||
default:
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: not a pcap file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Good version?
|
||||
*/
|
||||
if (ph.version_major != PCAP_VERSION_MAJOR ||
|
||||
ph.version_minor != PCAP_VERSION_MINOR) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: version is %u.%u, cannot append to file", fname,
|
||||
ph.version_major, ph.version_minor);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
if ((bpf_u_int32)linktype != ph.linktype) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: different linktype, cannot append to file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
if ((bpf_u_int32)p->snapshot != ph.snaplen) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
|
||||
"%s: different snaplen, cannot append to file", fname);
|
||||
fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* A header isn't present; attempt to write it.
|
||||
*/
|
||||
if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
(void)fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Start writing at the end of the file.
|
||||
*/
|
||||
if (fseek(f, 0, SEEK_END) == -1) {
|
||||
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't seek to end of %s: %s",
|
||||
fname, pcap_strerror(errno));
|
||||
(void)fclose(f);
|
||||
return (NULL);
|
||||
}
|
||||
return ((pcap_dumper_t *)f);
|
||||
}
|
||||
|
||||
FILE *
|
||||
pcap_dump_file(pcap_dumper_t *p)
|
||||
{
|
||||
|
||||
@@ -31,6 +31,7 @@
|
||||
#ifndef sf_pcap_h
|
||||
#define sf_pcap_h
|
||||
|
||||
extern int pcap_check_header(pcap_t *, bpf_u_int32, FILE *, char *);
|
||||
extern pcap_t *pcap_check_header(bpf_u_int32 magic, FILE *fp,
|
||||
u_int precision, char *errbuf, int *err);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -28,8 +28,6 @@
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* @(#) $Header: /tcpdump/master/libpcap/sunatmpos.h,v 1.1 2002-07-11 09:06:47 guy Exp $ (LBL)
|
||||
*/
|
||||
|
||||
/* SunATM header for ATM packet */
|
||||
|
||||
@@ -3660,19 +3660,25 @@ def contrib_libpcap(mm):
|
||||
'contrib/libpcap/arcnet.h',
|
||||
'contrib/libpcap/atmuni31.h',
|
||||
'contrib/libpcap/ethertype.h',
|
||||
'contrib/libpcap/extract.h',
|
||||
'contrib/libpcap/gencode.h',
|
||||
'contrib/libpcap/ieee80211.h',
|
||||
'contrib/libpcap/llc.h',
|
||||
'contrib/libpcap/nametoaddr.h',
|
||||
'contrib/libpcap/nlpid.h',
|
||||
'contrib/libpcap/pcap-common.h',
|
||||
'contrib/libpcap/pcap-int.h',
|
||||
'contrib/libpcap/pcap-namedb.h',
|
||||
'contrib/libpcap/pcap.h',
|
||||
'contrib/libpcap/pcap/can_socketcan.h',
|
||||
'contrib/libpcap/pcap/export-defs.h',
|
||||
'contrib/libpcap/pcap/ipnet.h',
|
||||
'contrib/libpcap/pcap/namedb.h',
|
||||
'contrib/libpcap/pcap/nflog.h',
|
||||
'contrib/libpcap/pcap/pcap.h',
|
||||
'contrib/libpcap/pcap/sll.h',
|
||||
'contrib/libpcap/pcap/usb.h',
|
||||
'contrib/libpcap/portability.h',
|
||||
'contrib/libpcap/ppp.h',
|
||||
'contrib/libpcap/sf-pcap-ng.h',
|
||||
'contrib/libpcap/sf-pcap.h',
|
||||
@@ -3700,6 +3706,7 @@ def contrib_libpcap(mm):
|
||||
'contrib/libpcap/bpf_image.c',
|
||||
'contrib/libpcap/etherent.c',
|
||||
'contrib/libpcap/fad-getad.c',
|
||||
'contrib/libpcap/fad-helpers.c',
|
||||
'contrib/libpcap/gencode.c',
|
||||
'contrib/libpcap/inet.c',
|
||||
'contrib/libpcap/pcap.c',
|
||||
|
||||
@@ -1384,6 +1384,7 @@ def build(bld):
|
||||
objs07_source = ['freebsd/contrib/libpcap/bpf_image.c',
|
||||
'freebsd/contrib/libpcap/etherent.c',
|
||||
'freebsd/contrib/libpcap/fad-getad.c',
|
||||
'freebsd/contrib/libpcap/fad-helpers.c',
|
||||
'freebsd/contrib/libpcap/gencode.c',
|
||||
'freebsd/contrib/libpcap/inet.c',
|
||||
'freebsd/contrib/libpcap/nametoaddr.c',
|
||||
|
||||
Reference in New Issue
Block a user