gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2025-09-14. You can view files and clone it, but cannot push or open issues or pull requests.
Files
0c1d52f5d25372a186f309cfeb29bd30c4f2e7d3
stellar-stellar/tools/monitor/stellar-dump.patch
lijia e734af76d8 rebase onto develop-2.0
2024-11-07 18:30:58 +08:00

11401 lines
348 KiB
Diff
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

diff -uNr tcpdump-tcpdump-4.99.4/addrtoname.c tcpdump-for-stellar/addrtoname.c
--- tcpdump-tcpdump-4.99.4/addrtoname.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/addrtoname.c 2024-10-30 17:34:05.502498703 +0800
@@ -1323,8 +1323,8 @@
{
static char buf[128];
snprintf(buf, sizeof(buf), "vlan %u, p %u%s",
- tci & 0xfff,
- tci >> 13,
+ (uint16_t)(tci & 0xfff),
+ (uint16_t)(tci >> 13),
(tci & 0x1000) ? ", DEI" : "");
return buf;
}
diff -uNr tcpdump-tcpdump-4.99.4/addrtostr.c tcpdump-for-stellar/addrtostr.c
--- tcpdump-tcpdump-4.99.4/addrtostr.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/addrtostr.c 2024-10-30 17:34:05.502498703 +0800
@@ -51,52 +51,62 @@
*/
#ifndef IN6ADDRSZ
-#define IN6ADDRSZ 16 /* IPv6 T_AAAA */
+#define IN6ADDRSZ 16 /* IPv6 T_AAAA */
#endif
#ifndef INT16SZ
-#define INT16SZ 2 /* word size */
+#define INT16SZ 2 /* word size */
#endif
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
const char *
-addrtostr (const void *src, char *dst, size_t size)
+addrtostr(const void *src, char *dst, size_t size)
{
- const u_char *srcaddr = (const u_char *)src;
- const char digits[] = "0123456789";
- int i;
- const char *orig_dst = dst;
-
- if (size < INET_ADDRSTRLEN) {
- errno = ENOSPC;
- return NULL;
- }
- for (i = 0; i < 4; ++i) {
- int n = *srcaddr++;
- int non_zerop = 0;
-
- if (non_zerop || n / 100 > 0) {
- *dst++ = digits[n / 100];
- n %= 100;
- non_zerop = 1;
- }
- if (non_zerop || n / 10 > 0) {
- *dst++ = digits[n / 10];
- n %= 10;
- non_zerop = 1;
- }
- *dst++ = digits[n];
- if (i != 3)
- *dst++ = '.';
+ const u_char *srcaddr = (const u_char *)src;
+ const char digits[] = "0123456789";
+ int i;
+ const char *orig_dst = dst;
+
+ if (size < INET_ADDRSTRLEN)
+ {
+ errno = ENOSPC;
+ return NULL;
+ }
+ for (i = 0; i < 4; ++i)
+ {
+ int n = *srcaddr++;
+ int non_zerop = 0;
+#if 0
+ if (non_zerop || n / 100 > 0)
+#else
+ if (n / 100 > 0) //for cppcheck
+#endif
+ {
+ *dst++ = digits[n / 100];
+ n %= 100;
+ non_zerop = 1;
}
- *dst++ = '\0';
- return orig_dst;
+ if (non_zerop || n / 10 > 0)
+ {
+ *dst++ = digits[n / 10];
+ n %= 10;
+ non_zerop = 1;
+ }
+ *dst++ = digits[n];
+ if (i != 3)
+ *dst++ = '.';
+ }
+ *dst++ = '\0';
+ return orig_dst;
}
+#pragma GCC diagnostic pop
/*
* Convert IPv6 binary address into presentation (printable) format.
*/
const char *
-addrtostr6 (const void *src, char *dst, size_t size)
+addrtostr6(const void *src, char *dst, size_t size)
{
/*
* Note that int32_t and int16_t need only be "at least" large enough
@@ -109,57 +119,60 @@
char *dp;
size_t space_left, added_space;
int snprintfed;
- struct {
+ struct
+ {
int base;
int len;
} best, cur;
- uint16_t words [IN6ADDRSZ / INT16SZ];
- int i;
+ uint16_t words[IN6ADDRSZ / INT16SZ];
+ int i;
/* Preprocess:
* Copy the input (bytewise) array into a wordwise array.
* Find the longest run of 0x00's in src[] for :: shorthanding.
*/
for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++)
- words[i] = (srcaddr[2*i] << 8) | srcaddr[2*i + 1];
+ words[i] = (srcaddr[2 * i] << 8) | srcaddr[2 * i + 1];
best.len = 0;
best.base = -1;
cur.len = 0;
- cur.base = -1;
+ cur.base = -1;
for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++)
{
if (words[i] == 0)
{
if (cur.base == -1)
- cur.base = i, cur.len = 1;
- else cur.len++;
+ cur.base = i, cur.len = 1;
+ else
+ cur.len++;
}
else if (cur.base != -1)
{
if (best.base == -1 || cur.len > best.len)
- best = cur;
+ best = cur;
cur.base = -1;
}
}
if ((cur.base != -1) && (best.base == -1 || cur.len > best.len))
- best = cur;
+ best = cur;
if (best.base != -1 && best.len < 2)
- best.base = -1;
+ best.base = -1;
/* Format the result.
*/
dp = dst;
space_left = size;
-#define APPEND_CHAR(c) \
- { \
- if (space_left == 0) { \
- errno = ENOSPC; \
- return (NULL); \
- } \
- *dp++ = c; \
- space_left--; \
- }
+#define APPEND_CHAR(c) \
+ { \
+ if (space_left == 0) \
+ { \
+ errno = ENOSPC; \
+ return (NULL); \
+ } \
+ *dp++ = c; \
+ space_left--; \
+ }
for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++)
{
/* Are we inside the best run of 0x00's?
@@ -167,21 +180,21 @@
if (best.base != -1 && i >= best.base && i < (best.base + best.len))
{
if (i == best.base)
- APPEND_CHAR(':');
+ APPEND_CHAR(':');
continue;
}
/* Are we following an initial run of 0x00s or any real hex?
*/
if (i != 0)
- APPEND_CHAR(':');
+ APPEND_CHAR(':');
/* Is this address an encapsulated IPv4?
*/
if (i == 6 && best.base == 0 &&
(best.len == 6 || (best.len == 5 && words[5] == 0xffff)))
{
- if (!addrtostr(srcaddr+12, dp, space_left))
+ if (!addrtostr(srcaddr + 12, dp, space_left))
{
errno = ENOSPC;
return (NULL);
@@ -191,13 +204,13 @@
space_left -= added_space;
break;
}
- snprintfed = snprintf (dp, space_left, "%x", words[i]);
+ snprintfed = snprintf(dp, space_left, "%x", words[i]);
if (snprintfed < 0)
- return (NULL);
- if ((size_t) snprintfed >= space_left)
+ return (NULL);
+ if ((size_t)snprintfed >= space_left)
{
- errno = ENOSPC;
- return (NULL);
+ errno = ENOSPC;
+ return (NULL);
}
dp += snprintfed;
space_left -= snprintfed;
@@ -206,7 +219,7 @@
/* Was it a trailing run of 0x00's?
*/
if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ))
- APPEND_CHAR(':');
+ APPEND_CHAR(':');
APPEND_CHAR('\0');
return (dst);
diff -uNr tcpdump-tcpdump-4.99.4/checksum.c tcpdump-for-stellar/checksum.c
--- tcpdump-tcpdump-4.99.4/checksum.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/checksum.c 2024-10-30 17:34:05.522498702 +0800
@@ -37,75 +37,73 @@
crc_table = []
for i in range(256):
- accum = i << 2
- for j in range(8):
- accum <<= 1
- if accum & 0x400:
- accum ^= 0x633
- crc_table.append(accum)
+ accum = i << 2
+ for j in range(8):
+ accum <<= 1
+ if accum & 0x400:
+ accum ^= 0x633
+ crc_table.append(accum)
for i in range(len(crc_table)/8):
- for j in range(8):
- sys.stdout.write("0x%04x, " % crc_table[i*8+j])
- sys.stdout.write("\n")
+ for j in range(8):
+ sys.stdout.write("0x%04x, " % crc_table[i*8+j])
+ sys.stdout.write("\n")
*/
static const uint16_t crc10_table[256] =
-{
- 0x0000, 0x0233, 0x0255, 0x0066, 0x0299, 0x00aa, 0x00cc, 0x02ff,
- 0x0301, 0x0132, 0x0154, 0x0367, 0x0198, 0x03ab, 0x03cd, 0x01fe,
- 0x0031, 0x0202, 0x0264, 0x0057, 0x02a8, 0x009b, 0x00fd, 0x02ce,
- 0x0330, 0x0103, 0x0165, 0x0356, 0x01a9, 0x039a, 0x03fc, 0x01cf,
- 0x0062, 0x0251, 0x0237, 0x0004, 0x02fb, 0x00c8, 0x00ae, 0x029d,
- 0x0363, 0x0150, 0x0136, 0x0305, 0x01fa, 0x03c9, 0x03af, 0x019c,
- 0x0053, 0x0260, 0x0206, 0x0035, 0x02ca, 0x00f9, 0x009f, 0x02ac,
- 0x0352, 0x0161, 0x0107, 0x0334, 0x01cb, 0x03f8, 0x039e, 0x01ad,
- 0x00c4, 0x02f7, 0x0291, 0x00a2, 0x025d, 0x006e, 0x0008, 0x023b,
- 0x03c5, 0x01f6, 0x0190, 0x03a3, 0x015c, 0x036f, 0x0309, 0x013a,
- 0x00f5, 0x02c6, 0x02a0, 0x0093, 0x026c, 0x005f, 0x0039, 0x020a,
- 0x03f4, 0x01c7, 0x01a1, 0x0392, 0x016d, 0x035e, 0x0338, 0x010b,
- 0x00a6, 0x0295, 0x02f3, 0x00c0, 0x023f, 0x000c, 0x006a, 0x0259,
- 0x03a7, 0x0194, 0x01f2, 0x03c1, 0x013e, 0x030d, 0x036b, 0x0158,
- 0x0097, 0x02a4, 0x02c2, 0x00f1, 0x020e, 0x003d, 0x005b, 0x0268,
- 0x0396, 0x01a5, 0x01c3, 0x03f0, 0x010f, 0x033c, 0x035a, 0x0169,
- 0x0188, 0x03bb, 0x03dd, 0x01ee, 0x0311, 0x0122, 0x0144, 0x0377,
- 0x0289, 0x00ba, 0x00dc, 0x02ef, 0x0010, 0x0223, 0x0245, 0x0076,
- 0x01b9, 0x038a, 0x03ec, 0x01df, 0x0320, 0x0113, 0x0175, 0x0346,
- 0x02b8, 0x008b, 0x00ed, 0x02de, 0x0021, 0x0212, 0x0274, 0x0047,
- 0x01ea, 0x03d9, 0x03bf, 0x018c, 0x0373, 0x0140, 0x0126, 0x0315,
- 0x02eb, 0x00d8, 0x00be, 0x028d, 0x0072, 0x0241, 0x0227, 0x0014,
- 0x01db, 0x03e8, 0x038e, 0x01bd, 0x0342, 0x0171, 0x0117, 0x0324,
- 0x02da, 0x00e9, 0x008f, 0x02bc, 0x0043, 0x0270, 0x0216, 0x0025,
- 0x014c, 0x037f, 0x0319, 0x012a, 0x03d5, 0x01e6, 0x0180, 0x03b3,
- 0x024d, 0x007e, 0x0018, 0x022b, 0x00d4, 0x02e7, 0x0281, 0x00b2,
- 0x017d, 0x034e, 0x0328, 0x011b, 0x03e4, 0x01d7, 0x01b1, 0x0382,
- 0x027c, 0x004f, 0x0029, 0x021a, 0x00e5, 0x02d6, 0x02b0, 0x0083,
- 0x012e, 0x031d, 0x037b, 0x0148, 0x03b7, 0x0184, 0x01e2, 0x03d1,
- 0x022f, 0x001c, 0x007a, 0x0249, 0x00b6, 0x0285, 0x02e3, 0x00d0,
- 0x011f, 0x032c, 0x034a, 0x0179, 0x0386, 0x01b5, 0x01d3, 0x03e0,
- 0x021e, 0x002d, 0x004b, 0x0278, 0x0087, 0x02b4, 0x02d2, 0x00e1
-};
+ {
+ 0x0000, 0x0233, 0x0255, 0x0066, 0x0299, 0x00aa, 0x00cc, 0x02ff,
+ 0x0301, 0x0132, 0x0154, 0x0367, 0x0198, 0x03ab, 0x03cd, 0x01fe,
+ 0x0031, 0x0202, 0x0264, 0x0057, 0x02a8, 0x009b, 0x00fd, 0x02ce,
+ 0x0330, 0x0103, 0x0165, 0x0356, 0x01a9, 0x039a, 0x03fc, 0x01cf,
+ 0x0062, 0x0251, 0x0237, 0x0004, 0x02fb, 0x00c8, 0x00ae, 0x029d,
+ 0x0363, 0x0150, 0x0136, 0x0305, 0x01fa, 0x03c9, 0x03af, 0x019c,
+ 0x0053, 0x0260, 0x0206, 0x0035, 0x02ca, 0x00f9, 0x009f, 0x02ac,
+ 0x0352, 0x0161, 0x0107, 0x0334, 0x01cb, 0x03f8, 0x039e, 0x01ad,
+ 0x00c4, 0x02f7, 0x0291, 0x00a2, 0x025d, 0x006e, 0x0008, 0x023b,
+ 0x03c5, 0x01f6, 0x0190, 0x03a3, 0x015c, 0x036f, 0x0309, 0x013a,
+ 0x00f5, 0x02c6, 0x02a0, 0x0093, 0x026c, 0x005f, 0x0039, 0x020a,
+ 0x03f4, 0x01c7, 0x01a1, 0x0392, 0x016d, 0x035e, 0x0338, 0x010b,
+ 0x00a6, 0x0295, 0x02f3, 0x00c0, 0x023f, 0x000c, 0x006a, 0x0259,
+ 0x03a7, 0x0194, 0x01f2, 0x03c1, 0x013e, 0x030d, 0x036b, 0x0158,
+ 0x0097, 0x02a4, 0x02c2, 0x00f1, 0x020e, 0x003d, 0x005b, 0x0268,
+ 0x0396, 0x01a5, 0x01c3, 0x03f0, 0x010f, 0x033c, 0x035a, 0x0169,
+ 0x0188, 0x03bb, 0x03dd, 0x01ee, 0x0311, 0x0122, 0x0144, 0x0377,
+ 0x0289, 0x00ba, 0x00dc, 0x02ef, 0x0010, 0x0223, 0x0245, 0x0076,
+ 0x01b9, 0x038a, 0x03ec, 0x01df, 0x0320, 0x0113, 0x0175, 0x0346,
+ 0x02b8, 0x008b, 0x00ed, 0x02de, 0x0021, 0x0212, 0x0274, 0x0047,
+ 0x01ea, 0x03d9, 0x03bf, 0x018c, 0x0373, 0x0140, 0x0126, 0x0315,
+ 0x02eb, 0x00d8, 0x00be, 0x028d, 0x0072, 0x0241, 0x0227, 0x0014,
+ 0x01db, 0x03e8, 0x038e, 0x01bd, 0x0342, 0x0171, 0x0117, 0x0324,
+ 0x02da, 0x00e9, 0x008f, 0x02bc, 0x0043, 0x0270, 0x0216, 0x0025,
+ 0x014c, 0x037f, 0x0319, 0x012a, 0x03d5, 0x01e6, 0x0180, 0x03b3,
+ 0x024d, 0x007e, 0x0018, 0x022b, 0x00d4, 0x02e7, 0x0281, 0x00b2,
+ 0x017d, 0x034e, 0x0328, 0x011b, 0x03e4, 0x01d7, 0x01b1, 0x0382,
+ 0x027c, 0x004f, 0x0029, 0x021a, 0x00e5, 0x02d6, 0x02b0, 0x0083,
+ 0x012e, 0x031d, 0x037b, 0x0148, 0x03b7, 0x0184, 0x01e2, 0x03d1,
+ 0x022f, 0x001c, 0x007a, 0x0249, 0x00b6, 0x0285, 0x02e3, 0x00d0,
+ 0x011f, 0x032c, 0x034a, 0x0179, 0x0386, 0x01b5, 0x01d3, 0x03e0,
+ 0x021e, 0x002d, 0x004b, 0x0278, 0x0087, 0x02b4, 0x02d2, 0x00e1};
-static void
-init_crc10_table(void)
+static int init_crc10_table(void)
{
#define CRC10_POLYNOMIAL 0x633
int i, j;
uint16_t accum;
uint16_t verify_crc10_table[256];
- for ( i = 0; i < 256; i++ )
+ for (i = 0; i < 256; i++)
{
- accum = ((unsigned short) i << 2);
- for ( j = 0; j < 8; j++ )
+ accum = ((unsigned short)i << 2);
+ for (j = 0; j < 8; j++)
{
- if ((accum <<= 1) & 0x400) accum ^= CRC10_POLYNOMIAL;
+ if ((accum <<= 1) & 0x400)
+ accum ^= CRC10_POLYNOMIAL;
}
verify_crc10_table[i] = accum;
}
- assert(memcmp(verify_crc10_table,
- crc10_table,
- sizeof(verify_crc10_table)) == 0);
+ assert(memcmp(verify_crc10_table, crc10_table, sizeof(verify_crc10_table)) == 0);
+ return memcmp(verify_crc10_table, crc10_table, sizeof(verify_crc10_table));
#undef CRC10_POLYNOMIAL
}
@@ -114,21 +112,18 @@
{
int i;
- for ( i = 0; i < length; i++ )
+ for (i = 0; i < length; i++)
{
- accum = ((accum << 8) & 0x3ff)
- ^ crc10_table[( accum >> 2) & 0xff]
- ^ *p++;
+ accum = ((accum << 8) & 0x3ff) ^ crc10_table[(accum >> 2) & 0xff] ^ *p++;
}
return accum;
}
/* precompute checksum tables */
-void
-init_checksum(void) {
+void init_checksum(void)
+{
init_crc10_table();
-
}
/*
@@ -136,7 +131,7 @@
* The checksum field of the passed PDU does not need to be reset to zero.
*/
uint16_t
-create_osi_cksum (const uint8_t *pptr, int checksum_offset, int length)
+create_osi_cksum(const uint8_t *pptr, int checksum_offset, int length)
{
int x;
@@ -150,15 +145,19 @@
c0 = 0;
c1 = 0;
- for (idx = 0; idx < length; idx++) {
+ for (idx = 0; idx < length; idx++)
+ {
/*
* Ignore the contents of the checksum field.
*/
if (idx == checksum_offset ||
- idx == checksum_offset+1) {
+ idx == checksum_offset + 1)
+ {
c1 += c0;
pptr++;
- } else {
+ }
+ else
+ {
c0 = c0 + *(pptr++);
c1 += c0;
}
@@ -167,20 +166,23 @@
c0 = c0 % 255;
c1 = c1 % 255;
- mul = (length - checksum_offset)*(c0);
+ mul = (length - checksum_offset) * (c0);
x = mul - c0 - c1;
y = c1 - mul - 1;
- if ( y >= 0 ) y++;
- if ( x < 0 ) x--;
+ if (y >= 0)
+ y++;
+ if (x < 0)
+ x--;
x %= 255;
y %= 255;
-
- if (x == 0) x = 255;
- if (y == 0) y = 255;
+ if (x == 0)
+ x = 255;
+ if (y == 0)
+ y = 255;
y &= 0x00FF;
checksum = ((x << 8) | y);
diff -uNr tcpdump-tcpdump-4.99.4/CMakeLists.txt tcpdump-for-stellar/CMakeLists.txt
--- tcpdump-tcpdump-4.99.4/CMakeLists.txt 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/CMakeLists.txt 2024-10-30 17:34:05.478498703 +0800
@@ -82,7 +82,7 @@
#
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)
#
# OK, this is a royal pain.
@@ -206,11 +206,26 @@
# Parameters
###################################################################
-option(WITH_SMI "Build with libsmi, if available" ON)
-option(WITH_CRYPTO "Build with OpenSSL/libressl libcrypto, if available" ON)
+option(WITH_SMI "Build with libsmi, if available" OFF)
+option(WITH_CRYPTO "Build with OpenSSL/libressl libcrypto, if available" OFF)
option(WITH_CAPSICUM "Build with Capsicum security functions, if available" ON)
option(WITH_CAP_NG "Use libcap-ng, if available" ON)
option(ENABLE_SMB "Build with the SMB dissector" OFF)
+option(STELLAR_SOURCE_DIR"stellar src root dir" "")
+option(STELLAR_BINARY_DIR "stellar build root dir" "")
+option(ASAN_OPTION "asan" OFF)
+
+if(ASAN_OPTION MATCHES "ADDRESS")
+ set(CMAKE_C_FLAGS "${CMAKADDRESS} -g -DCMAKE_BUILD_TYPE=Debug -fsanitize=address -fno-omit-frame-pointer")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DCMAKE_BUILD_TYPE=Debug -fsanitize=address -fno-omit-frame-pointer")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lasan")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lasan")
+elseif(ASAN_OPTION MATCHES "THREAD")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -DCMAKE_BUILD_TYPE=Debug -fsanitize=thread -fno-omit-frame-pointer")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DCMAKE_BUILD_TYPE=Debug -fsanitize=thread -fno-omit-frame-pointer")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lasan")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lasan")
+endif()
#
# String parameters. Neither of them are set, initially; only if the
@@ -1235,6 +1250,15 @@
set(TCPDUMP_SOURCE_LIST_C ${TCPDUMP_SOURCE_LIST_C} missing/dlnames.c)
endif((NOT HAVE_PCAP_DATALINK_NAME_TO_VAL) OR (NOT HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION))
+set(TCPDUMP_SOURCE_LIST_C ${TCPDUMP_SOURCE_LIST_C} stellar_dump_ctrl_link.c)
+set(TCPDUMP_SOURCE_LIST_C ${TCPDUMP_SOURCE_LIST_C} stellar_dump_data_link.c)
+include_directories(${STELLAR_SOURCE_DIR}/include/)
+include_directories(${STELLAR_SOURCE_DIR}/infra/)
+include_directories(${STELLAR_BINARY_DIR}/vendors/libevent/include/)
+
+link_directories(${STELLAR_BINARY_DIR}/vendors/libevent/lib/)
+link_directories(${STELLAR_BINARY_DIR}/infra/packet_manager/)
+
set(PROJECT_SOURCE_LIST_C ${NETDISSECT_SOURCE_LIST_C} ${TCPDUMP_SOURCE_LIST_C})
file(GLOB PROJECT_SOURCE_LIST_H
@@ -1297,11 +1321,17 @@
# Register targets
######################################
-add_executable(tcpdump ${TCPDUMP_SOURCE_LIST_C})
+# add_executable(tcpdump ${TCPDUMP_SOURCE_LIST_C})
+add_library(tcpdump_stellar ${TCPDUMP_SOURCE_LIST_C})
if(NOT C_ADDITIONAL_FLAGS STREQUAL "")
- set_target_properties(tcpdump PROPERTIES COMPILE_FLAGS ${C_ADDITIONAL_FLAGS})
+ set_target_properties(tcpdump_stellar PROPERTIES COMPILE_FLAGS ${C_ADDITIONAL_FLAGS})
endif()
-target_link_libraries(tcpdump netdissect ${TCPDUMP_LINK_LIBRARIES})
+target_link_libraries(tcpdump_stellar netdissect ${TCPDUMP_LINK_LIBRARIES})
+
+##like redis-cli, use hyphen('-') not underscore('_') to separate words
+add_executable(stellar-dump main.c)
+target_link_libraries(stellar-dump tcpdump_stellar pthread packet_manager)
+target_link_libraries(stellar-dump ${STELLAR_BINARY_DIR}/vendors/libevent/lib/libevent.a)
######################################
# Write out the config.h file
@@ -1325,7 +1355,7 @@
if(WIN32)
# XXX TODO where to install on Windows?
else(WIN32)
- install(TARGETS tcpdump DESTINATION bin)
+ install(TARGETS tcpdump_stellar DESTINATION bin)
endif(WIN32)
# On UN*X, and on Windows when not using MSVC, process man pages and
@@ -1340,7 +1370,7 @@
set(MAN1 "")
foreach(TEMPLATE_MANPAGE ${MAN1_EXPAND})
string(REPLACE ".in" "" MANPAGE ${TEMPLATE_MANPAGE})
- configure_file(${CMAKE_SOURCE_DIR}/${TEMPLATE_MANPAGE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE} @ONLY)
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${TEMPLATE_MANPAGE} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE} @ONLY)
set(MAN1 ${MAN1} ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE})
endforeach(TEMPLATE_MANPAGE)
install(FILES ${MAN1} DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
@@ -1361,11 +1391,11 @@
# rule run tests/TESTrun with it, because just trying to run the TESTrun
# script as a command won't work on Windows.
#
-find_program(PERL perl)
-if(PERL)
- message(STATUS "Found perl at ${PERL}")
- add_custom_target(check
- COMMAND ${PERL} ${CMAKE_SOURCE_DIR}/tests/TESTrun)
-else()
- message(STATUS "Didn't find perl")
-endif()
+# find_program(PERL perl)
+# if(PERL)
+# message(STATUS "Found perl at ${PERL}")
+# add_custom_target(check
+# COMMAND ${PERL} ${CMAKE_SOURCE_DIR}/tests/TESTrun)
+# else()
+# message(STATUS "Didn't find perl")
+# endif()
diff -uNr tcpdump-tcpdump-4.99.4/ftmacros.h tcpdump-for-stellar/ftmacros.h
--- tcpdump-tcpdump-4.99.4/ftmacros.h 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/ftmacros.h 2024-10-30 17:34:05.573498702 +0800
@@ -101,7 +101,9 @@
* this might, for example, be GNU/HURD or one of Debian's kFreeBSD
* OSes ("GNU/FreeBSD").
*/
+ #ifndef _GNU_SOURCE
#define _GNU_SOURCE
+ #endif
/*
* We turn on both _DEFAULT_SOURCE and _BSD_SOURCE to try to get
diff -uNr tcpdump-tcpdump-4.99.4/.gitattributes tcpdump-for-stellar/.gitattributes
--- tcpdump-tcpdump-4.99.4/.gitattributes 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/.gitattributes 1970-01-01 08:00:00.000000000 +0800
@@ -1,9 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-
-# Normalize line endings to LF on checkin and
-# prevents conversion to CRLF when the file is checked out
-tests/*.out text eol=lf
-
-# things that only make sense on github.com
-.github export-ignore
diff -uNr tcpdump-tcpdump-4.99.4/.gitignore tcpdump-for-stellar/.gitignore
--- tcpdump-tcpdump-4.99.4/.gitignore 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/.gitignore 1970-01-01 08:00:00.000000000 +0800
@@ -1,41 +0,0 @@
-*.orig
-*.rej
-Makefile
-*~
-*.o
-libnetdissect.a
-config.h
-config.log
-config.cache
-config.status
-.devel
-os-proto.h
-stamp-h
-stamp-h.in
-tcpdump
-tcpdump.1
-tcpdump-*.tar.gz
-failure-outputs.txt
-autom4te.cache/
-*.VC.db
-*.VC.opendb
-ALL_BUILD.vcxproj*
-ZERO_CHECK.vcxproj*
-check.vcxproj*
-netdissect.vcxproj*
-tcpdump.vcxproj*
-uninstall.vcxproj*
-CMakeCache.txt
-CMakeFiles/
-Debug/
-Release/
-MinSizeRel/
-RelWithDebInfo/
-cmake_install.cmake
-cmake_uninstall.cmake
-netdissect.dir/
-tcpdump.dir/
-tcpdump.sln
-.vs/
-.passed
-.failed
diff -uNr tcpdump-tcpdump-4.99.4/main.c tcpdump-for-stellar/main.c
--- tcpdump-tcpdump-4.99.4/main.c 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/main.c 2024-10-30 17:34:06.260498697 +0800
@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <pcap/pcap.h>
+#include "netdissect.h"
+
+extern int stellar_dump(int argc, char **argv);
+
+int main(int argc, char const *argv[])
+{
+ return stellar_dump(argc, (char **)argv);
+}
diff -uNr tcpdump-tcpdump-4.99.4/netdissect.h tcpdump-for-stellar/netdissect.h
--- tcpdump-tcpdump-4.99.4/netdissect.h 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/netdissect.h 2024-10-30 17:34:05.601498702 +0800
@@ -21,17 +21,17 @@
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
-
#ifndef netdissect_h
#define netdissect_h
#ifdef HAVE_OS_PROTO_H
#include "os-proto.h"
#endif
+#include <time.h>
#include <sys/types.h>
#include <setjmp.h>
#include "status-exit-codes.h"
-#include "funcattrs.h" /* for PRINTFLIKE_FUNCPTR() */
+#include "funcattrs.h" /* for PRINTFLIKE_FUNCPTR() */
#include "diag-control.h" /* for ND_UNREACHABLE */
/*
@@ -63,7 +63,7 @@
typedef unsigned char nd_int32_t[4];
typedef unsigned char nd_int64_t[8];
-#define FMAXINT (4294967296.0) /* floating point rep. of MAXINT */
+#define FMAXINT (4294967296.0) /* floating point rep. of MAXINT */
/*
* Use this for IPv4 addresses and netmasks.
@@ -101,7 +101,7 @@
/*
* Use this for MAC addresses.
*/
-#define MAC_ADDR_LEN 6U /* length of MAC addresses */
+#define MAC_ADDR_LEN 6U /* length of MAC addresses */
typedef unsigned char nd_mac_addr[MAC_ADDR_LEN];
/*
@@ -113,33 +113,34 @@
* Round up x to a multiple of y; y must be a power of 2.
*/
#ifndef roundup2
-#define roundup2(x, y) (((x)+((u_int)((y)-1)))&(~((u_int)((y)-1))))
+#define roundup2(x, y) (((x) + ((u_int)((y) - 1))) & (~((u_int)((y) - 1))))
#endif
#include <stdarg.h>
#include <pcap.h>
-#include "ip.h" /* struct ip for nextproto4_cksum() */
-#include "ip6.h" /* struct ip6 for nextproto6_cksum() */
+#include "tcpdump_ip.h" /* struct ip for nextproto4_cksum() */
+#include "tcpdump_ip6.h" /* struct ip6 for nextproto6_cksum() */
#ifndef HAVE_STRLCAT
-extern size_t strlcat (char *, const char *, size_t);
+extern size_t strlcat(char *, const char *, size_t);
#endif
#ifndef HAVE_STRLCPY
-extern size_t strlcpy (char *, const char *, size_t);
+extern size_t strlcpy(char *, const char *, size_t);
#endif
#ifndef HAVE_STRDUP
-extern char *strdup (const char *str);
+extern char *strdup(const char *str);
#endif
#ifndef HAVE_STRSEP
extern char *strsep(char **, const char *);
#endif
-struct tok {
- u_int v; /* value */
- const char *s; /* string */
+struct tok
+{
+ u_int v; /* value */
+ const char *s; /* string */
};
/* tok2str is deprecated */
@@ -165,7 +166,7 @@
#define IF_PRINTER_ARGS (netdissect_options *, const struct pcap_pkthdr *, const u_char *)
-typedef void (*if_printer) IF_PRINTER_ARGS;
+typedef void(*if_printer) IF_PRINTER_ARGS;
/*
* In case the data in a buffer needs to be processed by being decrypted,
@@ -186,52 +187,54 @@
* on the stack with null buffer pointer, meaning there's nothing to
* free.
*/
-struct netdissect_saved_packet_info {
- u_char *ndspi_buffer; /* pointer to allocated buffer data */
- const u_char *ndspi_packetp; /* saved beginning of data */
- const u_char *ndspi_snapend; /* saved end of data */
- struct netdissect_saved_packet_info *ndspi_prev; /* previous buffer on the stack */
+struct netdissect_saved_packet_info
+{
+ u_char *ndspi_buffer; /* pointer to allocated buffer data */
+ const u_char *ndspi_packetp; /* saved beginning of data */
+ const u_char *ndspi_snapend; /* saved end of data */
+ struct netdissect_saved_packet_info *ndspi_prev; /* previous buffer on the stack */
};
/* 'val' value(s) for longjmp */
#define ND_TRUNCATED 1
-struct netdissect_options {
- int ndo_bflag; /* print 4 byte ASes in ASDOT notation */
- int ndo_eflag; /* print ethernet header */
- int ndo_fflag; /* don't translate "foreign" IP address */
- int ndo_Kflag; /* don't check IP, TCP or UDP checksums */
- int ndo_nflag; /* leave addresses as numbers */
- int ndo_Nflag; /* remove domains from printed host names */
- int ndo_qflag; /* quick (shorter) output */
- int ndo_Sflag; /* print raw TCP sequence numbers */
- int ndo_tflag; /* print packet arrival time */
- int ndo_uflag; /* Print undecoded NFS handles */
- int ndo_vflag; /* verbosity level */
- int ndo_xflag; /* print packet in hex */
- int ndo_Xflag; /* print packet in hex/ASCII */
- int ndo_Aflag; /* print packet only in ASCII observing TAB,
- * LF, CR and SPACE as graphical chars
- */
- int ndo_Hflag; /* dissect 802.11s draft mesh standard */
- const char *ndo_protocol; /* protocol */
- jmp_buf ndo_early_end; /* jmp_buf for setjmp()/longjmp() */
- void *ndo_last_mem_p; /* pointer to the last allocated memory chunk */
- int ndo_packet_number; /* print a packet number in the beginning of line */
+struct netdissect_options
+{
+ int ndo_bflag; /* print 4 byte ASes in ASDOT notation */
+ int ndo_eflag; /* print ethernet header */
+ int ndo_fflag; /* don't translate "foreign" IP address */
+ int ndo_Kflag; /* don't check IP, TCP or UDP checksums */
+ int ndo_nflag; /* leave addresses as numbers */
+ int ndo_Nflag; /* remove domains from printed host names */
+ int ndo_qflag; /* quick (shorter) output */
+ int ndo_Sflag; /* print raw TCP sequence numbers */
+ int ndo_tflag; /* print packet arrival time */
+ int ndo_uflag; /* Print undecoded NFS handles */
+ int ndo_vflag; /* verbosity level */
+ int ndo_xflag; /* print packet in hex */
+ int ndo_Xflag; /* print packet in hex/ASCII */
+ int ndo_Aflag; /* print packet only in ASCII observing TAB,
+ * LF, CR and SPACE as graphical chars
+ */
+ int ndo_Hflag; /* dissect 802.11s draft mesh standard */
+ const char *ndo_protocol; /* protocol */
+ jmp_buf ndo_early_end; /* jmp_buf for setjmp()/longjmp() */
+ void *ndo_last_mem_p; /* pointer to the last allocated memory chunk */
+ int ndo_packet_number; /* print a packet number in the beginning of line */
int ndo_suppress_default_print; /* don't use default_print() for unknown packet types */
- int ndo_tstamp_precision; /* requested time stamp precision */
- const char *program_name; /* Name of the program using the library */
+ int ndo_tstamp_precision; /* requested time stamp precision */
+ const char *program_name; /* Name of the program using the library */
char *ndo_espsecret;
- struct sa_list *ndo_sa_list_head; /* used by print-esp.c */
+ struct sa_list *ndo_sa_list_head; /* used by print-esp.c */
struct sa_list *ndo_sa_default;
- char *ndo_sigsecret; /* Signature verification secret key */
+ char *ndo_sigsecret; /* Signature verification secret key */
- int ndo_packettype; /* as specified by -T */
+ int ndo_packettype; /* as specified by -T */
- int ndo_snaplen;
- int ndo_ll_hdr_len; /* link-layer header length */
+ int ndo_snaplen;
+ int ndo_ll_hdr_len; /* link-layer header length */
/*global pointers to beginning and end of current packet (during printing) */
const u_char *ndo_packetp;
@@ -245,21 +248,21 @@
/* pointer to void function to output stuff */
void (*ndo_default_print)(netdissect_options *,
- const u_char *bp, u_int length);
+ const u_char *bp, u_int length);
/* pointer to function to do regular output */
- int (*ndo_printf)(netdissect_options *,
- const char *fmt, ...)
- PRINTFLIKE_FUNCPTR(2, 3);
+ int (*ndo_printf)(netdissect_options *,
+ const char *fmt, ...)
+ PRINTFLIKE_FUNCPTR(2, 3);
/* pointer to function to output errors */
void NORETURN_FUNCPTR (*ndo_error)(netdissect_options *,
- status_exit_codes_t status,
- const char *fmt, ...)
- PRINTFLIKE_FUNCPTR(3, 4);
+ status_exit_codes_t status,
+ const char *fmt, ...)
+ PRINTFLIKE_FUNCPTR(3, 4);
/* pointer to function to output warnings */
void (*ndo_warning)(netdissect_options *,
- const char *fmt, ...)
- PRINTFLIKE_FUNCPTR(2, 3);
+ const char *fmt, ...)
+ PRINTFLIKE_FUNCPTR(2, 3);
};
extern WARN_UNUSED_RESULT int nd_push_buffer(netdissect_options *, u_char *, const u_char *, const u_int);
@@ -271,43 +274,40 @@
static inline NORETURN void
nd_trunc_longjmp(netdissect_options *ndo)
{
- longjmp(ndo->ndo_early_end, ND_TRUNCATED);
+ longjmp(ndo->ndo_early_end, ND_TRUNCATED);
#ifdef _AIX
- /*
- * In AIX <setjmp.h> decorates longjmp() with "#pragma leaves", which tells
- * XL C that the function is noreturn, but GCC remains unaware of that and
- * yields a "'noreturn' function does return" warning.
- */
- ND_UNREACHABLE
+ /*
+ * In AIX <setjmp.h> decorates longjmp() with "#pragma leaves", which tells
+ * XL C that the function is noreturn, but GCC remains unaware of that and
+ * yields a "'noreturn' function does return" warning.
+ */
+ ND_UNREACHABLE
#endif /* _AIX */
}
-#define PT_VAT 1 /* Visual Audio Tool */
-#define PT_WB 2 /* distributed White Board */
-#define PT_RPC 3 /* Remote Procedure Call */
-#define PT_RTP 4 /* Real-Time Applications protocol */
-#define PT_RTCP 5 /* Real-Time Applications control protocol */
-#define PT_SNMP 6 /* Simple Network Management Protocol */
-#define PT_CNFP 7 /* Cisco NetFlow protocol */
-#define PT_TFTP 8 /* trivial file transfer protocol */
-#define PT_AODV 9 /* Ad-hoc On-demand Distance Vector Protocol */
-#define PT_CARP 10 /* Common Address Redundancy Protocol */
-#define PT_RADIUS 11 /* RADIUS authentication Protocol */
-#define PT_ZMTP1 12 /* ZeroMQ Message Transport Protocol 1.0 */
-#define PT_VXLAN 13 /* Virtual eXtensible Local Area Network */
-#define PT_PGM 14 /* [UDP-encapsulated] Pragmatic General Multicast */
-#define PT_PGM_ZMTP1 15 /* ZMTP/1.0 inside PGM (native or UDP-encapsulated) */
-#define PT_LMP 16 /* Link Management Protocol */
-#define PT_RESP 17 /* RESP */
-#define PT_PTP 18 /* PTP */
-#define PT_SOMEIP 19 /* Autosar SOME/IP Protocol */
-#define PT_DOMAIN 20 /* Domain Name System (DNS) */
-
-#define ND_MIN(a,b) ((a)>(b)?(b):(a))
-#define ND_MAX(a,b) ((b)>(a)?(b):(a))
+#define PT_VAT 1 /* Visual Audio Tool */
+#define PT_WB 2 /* distributed White Board */
+#define PT_RPC 3 /* Remote Procedure Call */
+#define PT_RTP 4 /* Real-Time Applications protocol */
+#define PT_RTCP 5 /* Real-Time Applications control protocol */
+#define PT_SNMP 6 /* Simple Network Management Protocol */
+#define PT_CNFP 7 /* Cisco NetFlow protocol */
+#define PT_TFTP 8 /* trivial file transfer protocol */
+#define PT_AODV 9 /* Ad-hoc On-demand Distance Vector Protocol */
+#define PT_CARP 10 /* Common Address Redundancy Protocol */
+#define PT_RADIUS 11 /* RADIUS authentication Protocol */
+#define PT_ZMTP1 12 /* ZeroMQ Message Transport Protocol 1.0 */
+#define PT_VXLAN 13 /* Virtual eXtensible Local Area Network */
+#define PT_PGM 14 /* [UDP-encapsulated] Pragmatic General Multicast */
+#define PT_PGM_ZMTP1 15 /* ZMTP/1.0 inside PGM (native or UDP-encapsulated) */
+#define PT_LMP 16 /* Link Management Protocol */
+#define PT_RESP 17 /* RESP */
+#define PT_PTP 18 /* PTP */
+#define PT_SOMEIP 19 /* Autosar SOME/IP Protocol */
+#define PT_DOMAIN 20 /* Domain Name System (DNS) */
-/* For source or destination ports tests (UDP, TCP, ...) */
-#define IS_SRC_OR_DST_PORT(p) (sport == (p) || dport == (p))
+#define ND_MIN(a, b) ((a) > (b) ? (b) : (a))
+#define ND_MAX(a, b) ((b) > (a) ? (b) : (a))
/*
* Maximum snapshot length. This should be enough to capture the full
@@ -336,7 +336,7 @@
* let libpcap choose a snapshot length; newer versions may choose a bigger
* value than 262144 for D-Bus, for example.
*/
-#define MAXIMUM_SNAPLEN 262144
+#define MAXIMUM_SNAPLEN 262144
/*
* True if "l" bytes from "p" were captured.
@@ -365,19 +365,23 @@
*/
#define IS_NOT_NEGATIVE(x) (((x) > 0) || ((x) == 0))
-#define ND_TTEST_LEN(p, l) \
- (IS_NOT_NEGATIVE(l) && \
- ((uintptr_t)ndo->ndo_snapend - (l) <= (uintptr_t)ndo->ndo_snapend && \
- (uintptr_t)(p) <= (uintptr_t)ndo->ndo_snapend - (l)))
+#define ND_TTEST_LEN(p, l) \
+ (IS_NOT_NEGATIVE(l) && \
+ ((uintptr_t)ndo->ndo_snapend - (l) <= (uintptr_t)ndo->ndo_snapend && \
+ (uintptr_t)(p) <= (uintptr_t)ndo->ndo_snapend - (l)))
/* True if "*(p)" was captured */
#define ND_TTEST_SIZE(p) ND_TTEST_LEN(p, sizeof(*(p)))
/* Bail out if "l" bytes from "p" were not captured */
#ifdef ND_LONGJMP_FROM_TCHECK
-#define ND_TCHECK_LEN(p, l) if (!ND_TTEST_LEN(p, l)) nd_trunc_longjmp(ndo)
+#define ND_TCHECK_LEN(p, l) \
+ if (!ND_TTEST_LEN(p, l)) \
+ nd_trunc_longjmp(ndo)
#else
-#define ND_TCHECK_LEN(p, l) if (!ND_TTEST_LEN(p, l)) goto trunc
+#define ND_TCHECK_LEN(p, l) \
+ if (!ND_TTEST_LEN(p, l)) \
+ goto trunc
#endif
/* Bail out if "*(p)" was not captured */
@@ -395,26 +399,28 @@
#define ND_BYTES_AVAILABLE_AFTER(p) ND_BYTES_BETWEEN(ndo->ndo_snapend, (p))
/* Check length < minimum for invalid packet with a custom message, format %u */
-#define ND_LCHECKMSG_U(length, minimum, what) \
-if ((length) < (minimum)) { \
-ND_PRINT(" [%s %u < %u]", (what), (length), (minimum)); \
-goto invalid; \
-}
+#define ND_LCHECKMSG_U(length, minimum, what) \
+ if ((length) < (minimum)) \
+ { \
+ ND_PRINT(" [%s %u < %u]", (what), (length), (minimum)); \
+ goto invalid; \
+ }
/* Check length < minimum for invalid packet with #length message, format %u */
#define ND_LCHECK_U(length, minimum) \
-ND_LCHECKMSG_U((length), (minimum), (#length))
+ ND_LCHECKMSG_U((length), (minimum), (#length))
/* Check length < minimum for invalid packet with a custom message, format %zu */
-#define ND_LCHECKMSG_ZU(length, minimum, what) \
-if ((length) < (minimum)) { \
-ND_PRINT(" [%s %u < %zu]", (what), (length), (minimum)); \
-goto invalid; \
-}
+#define ND_LCHECKMSG_ZU(length, minimum, what) \
+ if ((length) < (minimum)) \
+ { \
+ ND_PRINT(" [%s %u < %zu]", (what), (length), (minimum)); \
+ goto invalid; \
+ }
/* Check length < minimum for invalid packet with #length message, format %zu */
#define ND_LCHECK_ZU(length, minimum) \
-ND_LCHECKMSG_ZU((length), (minimum), (#length))
+ ND_LCHECKMSG_ZU((length), (minimum), (#length))
#define ND_PRINT(...) (ndo->ndo_printf)(ndo, __VA_ARGS__)
#define ND_DEFAULTPRINT(ap, length) (*ndo->ndo_default_print)(ndo, ap, length)
@@ -424,7 +430,7 @@
extern void unsigned_relts_print(netdissect_options *, uint32_t);
extern const char *nd_format_time(char *buf, size_t bufsize,
- const char *format, const struct tm *timeptr);
+ const char *format, const struct tm *timeptr);
extern void fn_print_char(netdissect_options *, u_char);
extern void fn_print_str(netdissect_options *, const u_char *);
@@ -435,16 +441,16 @@
/*
* Flags for txtproto_print().
*/
-#define RESP_CODE_SECOND_TOKEN 0x00000001 /* response code is second token in response line */
+#define RESP_CODE_SECOND_TOKEN 0x00000001 /* response code is second token in response line */
extern void txtproto_print(netdissect_options *, const u_char *, u_int,
- const char **, u_int);
+ const char **, u_int);
-#if (defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(__x86_64__) || defined(_M_X64)) || \
- (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__)) || \
- (defined(__m68k__) && (!defined(__mc68000__) && !defined(__mc68010__))) || \
+#if (defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(__x86_64__) || defined(_M_X64)) || \
+ (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__)) || \
+ (defined(__m68k__) && (!defined(__mc68000__) && !defined(__mc68010__))) || \
(defined(__ppc__) || defined(__ppc64__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PPC64)) || \
- (defined(__s390__) || defined(__s390x__) || defined(__zarch__)) || \
+ (defined(__s390__) || defined(__s390x__) || defined(__zarch__)) || \
defined(__vax__)
/*
* The processor natively handles unaligned loads, so just use memcpy()
@@ -461,8 +467,8 @@
* XXX - do we need to test for both 32-bit and 64-bit versions of those
* architectures in all cases?
*/
-#define UNALIGNED_MEMCPY(p, q, l) memcpy((p), (q), (l))
-#define UNALIGNED_MEMCMP(p, q, l) memcmp((p), (q), (l))
+#define UNALIGNED_MEMCPY(p, q, l) memcpy((p), (q), (l))
+#define UNALIGNED_MEMCMP(p, q, l) memcmp((p), (q), (l))
#else
/*
* The processor doesn't natively handle unaligned loads,
@@ -477,28 +483,32 @@
*/
extern void unaligned_memcpy(void *, const void *, size_t);
extern int unaligned_memcmp(const void *, const void *, size_t);
-#define UNALIGNED_MEMCPY(p, q, l) unaligned_memcpy((p), (q), (l))
-#define UNALIGNED_MEMCMP(p, q, l) unaligned_memcmp((p), (q), (l))
+#define UNALIGNED_MEMCPY(p, q, l) unaligned_memcpy((p), (q), (l))
+#define UNALIGNED_MEMCMP(p, q, l) unaligned_memcmp((p), (q), (l))
#endif
#define PLURAL_SUFFIX(n) \
- (((n) != 1) ? "s" : "")
+ (((n) != 1) ? "s" : "")
extern const char *tok2strary_internal(const char **, int, const char *, int);
-#define tok2strary(a,f,i) tok2strary_internal(a, sizeof(a)/sizeof(a[0]),f,i)
+#define tok2strary(a, f, i) tok2strary_internal(a, sizeof(a) / sizeof(a[0]), f, i)
struct uint_tokary
{
- u_int uintval;
- const struct tok *tokary;
+ u_int uintval;
+ const struct tok *tokary;
};
extern const struct tok *uint2tokary_internal(const struct uint_tokary[], const size_t, const u_int);
-#define uint2tokary(a, i) uint2tokary_internal(a, sizeof(a)/sizeof(a[0]), i)
+#define uint2tokary(a, i) uint2tokary_internal(a, sizeof(a) / sizeof(a[0]), i)
extern if_printer lookup_printer(int);
-#define ND_DEBUG {printf(" [%s:%d %s] ", __FILE__, __LINE__, __func__); fflush(stdout);}
+#define ND_DEBUG \
+ { \
+ printf(" [%s:%d %s] ", __FILE__, __LINE__, __func__); \
+ fflush(stdout); \
+ }
/* The DLT printer routines */
@@ -577,9 +587,10 @@
* This contains a pointer to an address and a pointer to a routine
* to which we pass that pointer in order to get a string.
*/
-struct lladdr_info {
- const char *(*addr_string)(netdissect_options *, const u_char *);
- const u_char *addr;
+struct lladdr_info
+{
+ const char *(*addr_string)(netdissect_options *, const u_char *);
+ const u_char *addr;
};
/* The printer routines. */
@@ -589,7 +600,7 @@
extern void ahcp_print(netdissect_options *, const u_char *, u_int);
extern void aodv_print(netdissect_options *, const u_char *, u_int, int);
extern void aoe_print(netdissect_options *, const u_char *, const u_int);
-extern int arista_ethertype_print(netdissect_options *,const u_char *, u_int);
+extern int arista_ethertype_print(netdissect_options *, const u_char *, u_int);
extern void arp_print(netdissect_options *, const u_char *, u_int, u_int);
extern void ascii_print(netdissect_options *, const u_char *, u_int);
extern void atalk_print(netdissect_options *, const u_char *, u_int);
@@ -668,8 +679,8 @@
extern void lwres_print(netdissect_options *, const u_char *, u_int);
extern void m3ua_print(netdissect_options *, const u_char *, const u_int);
extern int macsec_print(netdissect_options *, const u_char **,
- u_int *, u_int *, u_int *, const struct lladdr_info *,
- const struct lladdr_info *);
+ u_int *, u_int *, u_int *, const struct lladdr_info *,
+ const struct lladdr_info *);
extern u_int mfr_print(netdissect_options *, const u_char *, u_int);
extern void mobile_print(netdissect_options *, const u_char *, u_int);
extern int mobility_print(netdissect_options *, const u_char *, const u_char *);
@@ -756,9 +767,10 @@
extern uint16_t verify_crc10_cksum(uint16_t, const u_char *, int);
extern uint16_t create_osi_cksum(const uint8_t *, int, int);
-struct cksum_vec {
- const uint8_t *ptr;
- int len;
+struct cksum_vec
+{
+ const uint8_t *ptr;
+ int len;
};
extern uint16_t in_cksum(const struct cksum_vec *, int);
extern uint16_t in_cksum_shouldbe(uint16_t, uint16_t);
@@ -766,10 +778,10 @@
/* IP protocol demuxing routines */
extern void ip_demux_print(netdissect_options *, const u_char *, u_int, u_int, int, u_int, uint8_t, const u_char *);
-extern uint16_t nextproto4_cksum(netdissect_options *, const struct ip *, const uint8_t *, u_int, u_int, uint8_t);
+extern uint16_t nextproto4_cksum(netdissect_options *, const struct tcpdump_ip *, const uint8_t *, u_int, u_int, uint8_t);
/* in print-ip6.c */
-extern uint16_t nextproto6_cksum(netdissect_options *, const struct ip6_hdr *, const uint8_t *, u_int, u_int, uint8_t);
+extern uint16_t nextproto6_cksum(netdissect_options *, const struct tcpdump_ip6_hdr *, const uint8_t *, u_int, u_int, uint8_t);
/* Utilities */
extern void nd_print_trunc(netdissect_options *);
@@ -787,8 +799,8 @@
extern void esp_decodesecret_print(netdissect_options *);
extern int esp_decrypt_buffer_by_ikev2_print(netdissect_options *, int,
- const u_char spii[8],
- const u_char spir[8],
- const u_char *, const u_char *);
+ const u_char spii[8],
+ const u_char spir[8],
+ const u_char *, const u_char *);
#endif /* netdissect_h */
diff -uNr tcpdump-tcpdump-4.99.4/netdissect-stdinc.h tcpdump-for-stellar/netdissect-stdinc.h
--- tcpdump-tcpdump-4.99.4/netdissect-stdinc.h 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/netdissect-stdinc.h 2024-10-30 17:34:05.601498702 +0800
@@ -35,9 +35,9 @@
* various items as needed, to isolate most of netdissect's platform
* differences to this one file.
*/
-
-#ifndef netdissect_stdinc_h
-#define netdissect_stdinc_h
+#pragma once
+// #ifndef netdissect_stdinc_h
+// #define netdissect_stdinc_h
#include "ftmacros.h"
@@ -379,4 +379,4 @@
# define ND_FALL_THROUGH
#endif /* __has_attribute(fallthrough) */
-#endif /* netdissect_stdinc_h */
+// #endif /* netdissect_stdinc_h */
diff -uNr tcpdump-tcpdump-4.99.4/packet_parser.c tcpdump-for-stellar/packet_parser.c
--- tcpdump-tcpdump-4.99.4/packet_parser.c 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/packet_parser.c 2024-10-30 17:34:06.264498697 +0800
@@ -0,0 +1,980 @@
+#include <string.h>
+#include <stdlib.h>
+#include <netinet/icmp6.h>
+#include <netinet/ip_icmp.h>
+#include <linux/ppp_defs.h>
+
+#include "log_internal.h"
+#include "packet_helper.h"
+#include "packet_internal.h"
+#include "packet_parser.h"
+
+#define PACKET_PARSE_LOG_DEBUG(format, ...) // STELLAR_LOG_DEBUG(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
+#define PACKET_PARSE_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
+#define PACKET_PARSE_LOG_WARN(format, ...) STELLAR_LOG_WARN(__thread_local_logger, "packet parse", format, ##__VA_ARGS__)
+
+#define PACKET_LOG_DATA_INSUFFICIENCY(pkt, layer) \
+ { \
+ PACKET_PARSE_LOG_WARN("pkt: %p, layer: %s, data insufficiency", \
+ (pkt), layer_proto_to_str(layer)); \
+ }
+
+#define PACKET_LOG_UNSUPPORT_PROTO(pkt, layer, next_proto) \
+ { \
+ PACKET_PARSE_LOG_WARN("pkt: %p, layer: %s, unsupport next proto: %d", \
+ (pkt), layer_proto_to_str(layer), (next_proto)); \
+ }
+
+#define PACKET_LOG_UNSUPPORT_ETHPROTO(pkt, next_proto) \
+ { \
+ PACKET_PARSE_LOG_WARN("pkt: %p, layer: L3, unsupport next proto: %d %s", \
+ (pkt), (next_proto), eth_proto_to_str(next_proto)); \
+ }
+
+#define PACKET_LOG_UNSUPPORT_IPPROTO(pkt, next_proto) \
+ { \
+ PACKET_PARSE_LOG_WARN("pkt: %p, layer: L4, unsupport next proto: %d %s", \
+ (pkt), (next_proto), ip_proto_to_str(next_proto)); \
+ }
+
+/******************************************************************************
+ * Static API
+ ******************************************************************************/
+
+static inline struct layer_private *get_free_layer(struct packet *pkt);
+
+// 数据链路层
+static inline const char *parse_ether(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_pweth(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_ppp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_l2tpv2_over_udp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_l2tpv3_over_udp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_l2tpv3_over_ip(struct packet *pkt, const char *data, uint16_t len);
+
+// 数据链路层 -- 隧道
+static inline const char *parse_vlan(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_pppoe_ses(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_mpls(struct packet *pkt, const char *data, uint16_t len);
+// 网络层
+static inline const char *parse_ipv4(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_auth(struct packet *pkt, const char *data, uint16_t len);
+// 网络层 -- 隧道
+static inline const char *parse_gre(struct packet *pkt, const char *data, uint16_t len);
+// 传输层
+static inline const char *parse_udp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_tcp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_icmp(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_icmp6(struct packet *pkt, const char *data, uint16_t len);
+// 传输层 -- 隧道
+static inline const char *parse_vxlan(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_gtp_u(struct packet *pkt, const char *data, uint16_t len);
+static inline const char *parse_gtp_c(struct packet *pkt, const char *data, uint16_t len);
+// L3/L4
+static inline const char *parse_l3(struct packet *pkt, uint16_t next_proto, const char *data, uint16_t len);
+static inline const char *parse_l4(struct packet *pkt, uint8_t next_proto, const char *data, uint16_t len);
+
+/******************************************************************************
+ * Private API -- Utils
+ ******************************************************************************/
+
+static inline struct layer_private *get_free_layer(struct packet *pkt)
+{
+ if (pkt->layers_used >= pkt->layers_size)
+ {
+ return NULL;
+ }
+
+ return &pkt->layers[pkt->layers_used];
+}
+
+#define SET_LAYER(_pkt, _layer, _proto, _hdr_len, _data, _len, _trim) \
+ { \
+ (_layer)->proto = (_proto); \
+ (_layer)->hdr_offset = (_pkt)->data_len - (_pkt)->trim_len - (_len); \
+ (_layer)->hdr_ptr = (_data); \
+ (_layer)->hdr_len = (_hdr_len); \
+ (_layer)->pld_ptr = (_data) + (_hdr_len); \
+ (_layer)->pld_len = (_len) - (_hdr_len) - (_trim); \
+ (_pkt)->trim_len += (_trim); \
+ (_pkt)->layers_used++; \
+ PACKET_PARSE_LOG_DEBUG("layer[%d/%d]: %s, header: {offset: %d, ptr: %p, len: %d}, payload: {ptr: %p, len: %d}", \
+ (_pkt)->layers_used - 1, (_pkt)->layers_size, layer_proto_to_str((_proto)), \
+ (_layer)->hdr_offset, (_layer)->hdr_ptr, (_layer)->hdr_len, (_layer)->pld_ptr, (_layer)->pld_len); \
+ }
+
+/******************************************************************************
+ * Private API -- Parses
+ ******************************************************************************/
+
+static inline const char *parse_ether(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct ethhdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ETHER);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ uint16_t next_proto = eth_hdr_get_proto((const struct ethhdr *)data);
+ SET_LAYER(pkt, layer, LAYER_PROTO_ETHER, sizeof(struct ethhdr), data, len, 0);
+
+ return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_pweth(struct packet *pkt, const char *data, uint16_t len)
+{
+ /*
+ * PW Ethernet Control Word
+ * 0 1 2 3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |0 0 0 0| Reserved | Sequence Number |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * Reference: https://tools.ietf.org/html/rfc4448
+ */
+ if (unlikely(len < 4))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PWETH);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_PWETH, 4, data, len, 0);
+
+ return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
+}
+
+static inline int is_ppp_proto(uint16_t proto)
+{
+ // /usr/include/linux/ppp_defs.h.html
+ switch (proto)
+ {
+ case PPP_IP: /* Internet Protocol */
+ case PPP_AT: /* AppleTalk Protocol */
+ case PPP_IPX: /* IPX protocol */
+ case PPP_VJC_COMP: /* VJ compressed TCP */
+ case PPP_VJC_UNCOMP: /* VJ uncompressed TCP */
+ case PPP_MP: /* Multilink protocol */
+ case PPP_IPV6: /* Internet Protocol Version 6 */
+ case PPP_COMPFRAG: /* fragment compressed below bundle */
+ case PPP_COMP: /* compressed packet */
+ case PPP_MPLS_UC: /* Multi Protocol Label Switching - Unicast */
+ case PPP_MPLS_MC: /* Multi Protocol Label Switching - Multicast */
+ case PPP_IPCP: /* IP Control Protocol */
+ case PPP_ATCP: /* AppleTalk Control Protocol */
+ case PPP_IPXCP: /* IPX Control Protocol */
+ case PPP_IPV6CP: /* IPv6 Control Protocol */
+ case PPP_CCPFRAG: /* CCP at link level (below MP bundle) */
+ // case PPP_CCP: /* Compression Control Protocol */ (same as PPP_CCPFRAG)
+ case PPP_MPLSCP: /* MPLS Control Protocol */
+ case PPP_LCP: /* Link Control Protocol */
+ case PPP_PAP: /* Password Authentication Protocol */
+ case PPP_LQR: /* Link Quality Report protocol */
+ case PPP_CHAP: /* Cryptographic Handshake Auth. Protocol */
+ case PPP_CBCP: /* Callback Control Protocol */
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static inline const char *parse_ppp(struct packet *pkt, const char *data, uint16_t len)
+{
+ /*
+ * https://datatracker.ietf.org/doc/html/rfc1661#section-2
+ * +----------+-------------+---------+
+ * | Protocol | Information | Padding |
+ * | 8/16 bits| * | * |
+ * +----------+-------------+---------+
+ *
+ * https://datatracker.ietf.org/doc/html/rfc1331#section-3.1
+ * +----------+----------+----------+----------+------------
+ * | Flag | Address | Control | Protocol | Information
+ * | 01111110 | 11111111 | 00000011 | 16 bits | *
+ * +----------+----------+----------+----------+------------
+ * ---+----------+----------+-----------------
+ * | FCS | Flag | Inter-frame Fill
+ * | 16 bits | 01111110 | or next Address
+ * ---+----------+----------+-----------------
+ */
+ if (unlikely(len < 4))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PPP);
+ return data;
+ }
+
+ uint16_t hdr_len = 0;
+ uint16_t next_proto = 0;
+ struct layer_private *layer = NULL;
+
+ // ppp header 1 byte
+ next_proto = *((uint8_t *)data);
+ if (is_ppp_proto(next_proto))
+ {
+ hdr_len = 1;
+ goto success;
+ }
+
+ // ppp header 2 bytes
+ next_proto = ntohs(*((uint16_t *)data));
+ if (is_ppp_proto(next_proto))
+ {
+ hdr_len = 2;
+ goto success;
+ }
+
+ // ppp header 4 bytes
+ next_proto = ntohs(*((uint16_t *)data + 1));
+ hdr_len = 4;
+
+success:
+ layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_PPP, hdr_len, data, len, 0);
+ switch (next_proto)
+ {
+ case PPP_IP:
+ return parse_ipv4(pkt, layer->pld_ptr, layer->pld_len);
+ case PPP_IPV6:
+ return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
+ default:
+ PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_PROTO_PPP, next_proto);
+ return layer->pld_ptr;
+ }
+}
+
+static inline const char *parse_l2tpv2_over_udp(struct packet *pkt, const char *data, uint16_t len)
+{
+ uint16_t hdr_len = calc_udp_l2tpv2_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
+
+ // control message
+ if (l2tp_hdr_get_type((const struct l2tp_hdr *)data))
+ {
+ return layer->pld_ptr;
+ }
+ // data message
+ else
+ {
+ return parse_ppp(pkt, layer->pld_ptr, layer->pld_len);
+ }
+}
+
+static inline const char *parse_l2tpv3_over_udp(struct packet *pkt, const char *data, uint16_t len)
+{
+ uint16_t hdr_len = calc_udp_l2tpv3_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
+
+ // control message
+ if (l2tp_hdr_get_type((const struct l2tp_hdr *)data))
+ {
+ return layer->pld_ptr;
+ }
+ // data message
+ else
+ {
+ // TOOD
+ return layer->pld_ptr;
+ }
+}
+
+static inline const char *parse_l2tpv3_over_ip(struct packet *pkt, const char *data, uint16_t len)
+{
+ uint16_t hdr_len = calc_ip_l2tpv3_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
+
+ // data message
+ if (ntohl(*((uint32_t *)data)))
+ {
+ // TOOD
+ return layer->pld_ptr;
+ }
+ // control message
+ else
+ {
+ return layer->pld_ptr;
+ }
+}
+
+static inline const char *parse_vlan(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct vlan_hdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_VLAN);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ uint16_t next_proto = vlan_hdr_get_ethertype((const struct vlan_hdr *)data);
+ SET_LAYER(pkt, layer, LAYER_PROTO_VLAN, sizeof(struct vlan_hdr), data, len, 0);
+
+ return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_pppoe_ses(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < 6))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PPPOE);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_PPPOE, 6, data, len, 0);
+
+ return parse_ppp(pkt, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_mpls(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < 4))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_MPLS);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+
+ if (mpls_label_get_bos((const struct mpls_label *)data))
+ {
+ SET_LAYER(pkt, layer, LAYER_PROTO_MPLS, 4, data, len, 0);
+ if (layer->pld_len == 0)
+ {
+ return layer->pld_ptr;
+ }
+ uint8_t next_proto = layer->pld_ptr[0] >> 4;
+ switch (next_proto)
+ {
+ case 0:
+ // the first four digits of the PW Ethernet control word must be "00000", but the first four digits of Ethernet may also be "0000"
+ if (layer->pld_len >= sizeof(struct ethhdr) && is_eth_proto(eth_hdr_get_proto((const struct ethhdr *)layer->pld_ptr)))
+ {
+ return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
+ }
+ else
+ {
+ return parse_pweth(pkt, layer->pld_ptr, layer->pld_len);
+ }
+ case 4:
+ return parse_ipv4(pkt, layer->pld_ptr, layer->pld_len);
+ case 6:
+ return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
+ default:
+ return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
+ }
+ }
+ else
+ {
+ SET_LAYER(pkt, layer, LAYER_PROTO_MPLS, 4, data, len, 0);
+ return parse_mpls(pkt, layer->pld_ptr, layer->pld_len);
+ }
+}
+
+static inline const char *parse_ipv4(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct ip)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+
+ const struct ip *hdr = (const struct ip *)data;
+ uint8_t version = ip4_hdr_get_version(hdr);
+ if (unlikely(version != 4))
+ {
+ PACKET_PARSE_LOG_ERROR("packet %p ipv4 version %d != 4", pkt, version);
+ return data;
+ }
+
+ uint16_t hdr_len = ip4_hdr_get_hdr_len(hdr);
+ if (unlikely(hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
+ return data;
+ }
+
+ uint16_t total_len = ip4_hdr_get_total_len(hdr);
+ if (unlikely(total_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
+ return data;
+ }
+ if (unlikely(total_len < hdr_len))
+ {
+ PACKET_PARSE_LOG_ERROR("packet %p ip total_len %d < hdr_len %d", pkt, total_len, hdr_len);
+ return data;
+ }
+ uint16_t trim_len = len - total_len;
+ SET_LAYER(pkt, layer, LAYER_PROTO_IPV4, hdr_len, data, len, trim_len);
+
+ // ip fragmented
+ if (ip4_hdr_get_mf_flag(hdr) || ip4_hdr_get_frag_offset(hdr))
+ {
+ PACKET_PARSE_LOG_DEBUG("packet %p ip layer %p is fragmented", pkt, layer);
+ pkt->frag_layer = layer;
+ return layer->pld_ptr;
+ }
+
+ uint8_t next_proto = ip4_hdr_get_proto(hdr);
+ return parse_l4(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint16_t len)
+{
+ /*
+ * IP6 Extension Headers
+ *
+ * Internet Protocol, Version 6 (IPv6) : https://datatracker.ietf.org/doc/html/rfc2460
+ * IP Encapsulating Security Payload (ESP) : https://datatracker.ietf.org/doc/html/rfc2406
+ * IP Authentication Header : https://datatracker.ietf.org/doc/html/rfc4302
+ *
+ * skip next header
+ * #define IPPROTO_HOPOPTS 0 // IP6 hop-by-hop options
+ * #define IPPROTO_ROUTING 43 // IP6 routing header
+ * #define IPPROTO_AH 51 // IP6 Auth Header
+ * #define IPPROTO_DSTOPTS 60 // IP6 destination option
+ *
+ * not skip next header
+ * #define IPPROTO_FRAGMENT 44 // IP6 fragmentation header
+ * #define IPPROTO_ESP 50 // IP6 Encap Sec. Payload
+ * #define IPPROTO_NONE 59 // IP6 no next header
+ */
+
+ if (unlikely(len < sizeof(struct ip6_hdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ const struct ip6_hdr *hdr = (const struct ip6_hdr *)data;
+ uint8_t version = ip6_hdr_get_version(hdr);
+ if (unlikely(version != 6))
+ {
+ PACKET_PARSE_LOG_ERROR("packet %p ipv6 version %d != 6", pkt, version);
+ return data;
+ }
+
+ uint16_t pld_len = ip6_hdr_get_payload_len(hdr);
+ if (unlikely(pld_len + sizeof(struct ip6_hdr) > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
+ return data;
+ }
+ uint8_t next_proto = ip6_hdr_get_next_header(hdr);
+ uint16_t hdr_len = sizeof(struct ip6_hdr);
+ uint16_t trim_len = len - pld_len - sizeof(struct ip6_hdr);
+ const char *next_hdr_ptr = data + hdr_len;
+ while (next_proto == IPPROTO_HOPOPTS || next_proto == IPPROTO_ROUTING || next_proto == IPPROTO_AH || next_proto == IPPROTO_DSTOPTS)
+ {
+ if (unlikely(pld_len < 2))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
+ return data;
+ }
+ struct ip6_ext *ext = (struct ip6_ext *)next_hdr_ptr;
+ uint16_t skip_len = 0;
+ if (next_proto == IPPROTO_AH)
+ {
+ /*
+ * https://datatracker.ietf.org/doc/html/rfc4302#section-2
+ * For IPv6, the total length of the header must be a multiple of 8-octet units.
+ * (Note that although IPv6 [DH98] characterizes AH as an extension header,
+ * its length is measured in 32-bit words, not the 64-bit words used by other IPv6 extension headers.)
+ */
+ skip_len = ext->ip6e_len * 4 + 8;
+ }
+ else
+ {
+ skip_len = ext->ip6e_len * 8 + 8;
+ }
+ if (unlikely(skip_len > pld_len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
+ return data;
+ }
+ hdr_len += skip_len;
+ pld_len -= skip_len;
+ next_hdr_ptr += skip_len;
+ next_proto = ext->ip6e_nxt;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_IPV6, hdr_len, data, len, trim_len);
+
+ // ipv6 fragment
+ if (next_proto == IPPROTO_FRAGMENT)
+ {
+ PACKET_PARSE_LOG_DEBUG("packet %p ipv6 layer %p is fragmented", pkt, layer);
+ pkt->frag_layer = layer;
+ return layer->pld_ptr;
+ }
+
+ return parse_l4(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_auth(struct packet *pkt, const char *data, uint16_t len)
+{
+ /*
+ * https://datatracker.ietf.org/doc/html/rfc4302#section-2
+ * For IPv4: AH not IPv4 option, as an single layer
+ * For IPv6: AH as IPv6 extension header
+ *
+ * AH Format
+ *
+ * 0 1 2 3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Next Header | Payload Len | RESERVED |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Security Parameters Index (SPI) |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Sequence Number Field |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | |
+ * + Integrity Check Value-ICV (variable) |
+ * | |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+ if (unlikely(len < 12))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPAH);
+ return data;
+ }
+ /*
+ * https://datatracker.ietf.org/doc/html/rfc4302#section-2
+ * For IPv4, This 8-bit field specifies the length of AH in 32-bit words (4-byte units), minus "2".
+ * Thus, for example, if an integrity algorithm yields a 96-bit authentication value,
+ * this length field will be "4" (3 32-bit word fixed fields plus 3 32-bit words for the ICV, minus 2).
+ */
+ uint8_t next_proto = ((const uint8_t *)data)[0];
+ uint16_t hdr_len = ((const uint8_t *)data)[1] * 4 + 8;
+ if (unlikely(len < hdr_len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPAH);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_IPAH, hdr_len, data, len, 0);
+
+ return parse_l4(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_gre(struct packet *pkt, const char *data, uint16_t len)
+{
+ uint16_t hdr_len = calc_gre_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_GRE);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ uint16_t next_proto = peek_gre_proto(data, len);
+ SET_LAYER(pkt, layer, LAYER_PROTO_GRE, hdr_len, data, len, 0);
+
+ return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_udp(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct udphdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_UDP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ const struct udphdr *udp_hdr = (struct udphdr *)data;
+ SET_LAYER(pkt, layer, LAYER_PROTO_UDP, sizeof(struct udphdr), data, len, 0);
+
+ uint16_t src_port = udp_hdr_get_src_port(udp_hdr);
+ uint16_t dst_port = udp_hdr_get_dst_port(udp_hdr);
+
+ if (dst_port == 4789)
+ {
+ // VXLAN_DPORT 4789
+ return parse_vxlan(pkt, layer->pld_ptr, layer->pld_len);
+ }
+
+ if (dst_port == 2152 || src_port == 2152)
+ {
+ // only GTPv1-U, no GTPv2-U
+ return parse_gtp_u(pkt, layer->pld_ptr, layer->pld_len);
+ }
+
+ if (dst_port == 2123 || src_port == 2123)
+ {
+ // GTPv1-C or GTPv2-C
+ return parse_gtp_c(pkt, layer->pld_ptr, layer->pld_len);
+ }
+
+ if (dst_port == 1701 || src_port == 1701)
+ {
+ // L2TP_DPORT 1701
+ if (unlikely(layer->pld_len < 8))
+ {
+ return layer->pld_ptr;
+ }
+
+ switch (l2tp_hdr_get_ver((const struct l2tp_hdr *)layer->pld_ptr))
+ {
+ case 2:
+ return parse_l2tpv2_over_udp(pkt, layer->pld_ptr, layer->pld_len);
+ case 3:
+ return parse_l2tpv3_over_udp(pkt, layer->pld_ptr, layer->pld_len);
+ default:
+ return layer->pld_ptr;
+ }
+ }
+
+ if (dst_port == 3544 || src_port == 3544)
+ {
+ // Teredo IPv6 tunneling 3544
+ if (unlikely(layer->pld_len < sizeof(struct ip6_hdr)))
+ {
+ return layer->pld_ptr;
+ }
+ const struct ip6_hdr *ipv6_hdr = (const struct ip6_hdr *)layer->pld_ptr;
+ if (ip6_hdr_get_version(ipv6_hdr) != 6)
+ {
+ return layer->pld_ptr;
+ }
+ return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
+ }
+
+ return layer->pld_ptr;
+}
+
+static inline const char *parse_tcp(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct tcphdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_TCP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ uint16_t hdr_len = tcp_hdr_get_hdr_len((const struct tcphdr *)data);
+ if (unlikely(hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_TCP);
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_TCP, hdr_len, data, len, 0);
+
+ return layer->pld_ptr;
+}
+
+static inline const char *parse_icmp(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct icmphdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ICMP);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_ICMP, sizeof(struct icmphdr), data, len, 0);
+
+ return layer->pld_ptr;
+}
+
+static inline const char *parse_icmp6(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct icmp6_hdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ICMP6);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_ICMP6, sizeof(struct icmp6_hdr), data, len, 0);
+
+ return layer->pld_ptr;
+}
+
+static inline const char *parse_vxlan(struct packet *pkt, const char *data, uint16_t len)
+{
+ if (unlikely(len < sizeof(struct vxlan_hdr)))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_VXLAN);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_VXLAN, sizeof(struct vxlan_hdr), data, len, 0);
+
+ return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
+}
+
+static inline const char *parse_gtp_u(struct packet *pkt, const char *data, uint16_t len)
+{
+ // only GTPv1-U, no GTPv2-U
+ uint8_t version = peek_gtp_version(data, len);
+ if (unlikely(version != 1))
+ {
+ return data;
+ }
+
+ uint16_t hdr_len = calc_gtp_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_GTP_U);
+ return data;
+ }
+
+ uint8_t next_proto = (((const uint8_t *)(data + hdr_len))[0]) >> 4;
+ if (next_proto != 4 && next_proto != 6)
+ {
+ // next_proto is not IPv4 or IPv6, this is not a normal GTP-U packet, fallback to UDP
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_GTP_U, hdr_len, data, len, 0);
+
+ switch (next_proto)
+ {
+ case 4:
+ return parse_ipv4(pkt, layer->pld_ptr, layer->pld_len);
+ case 6:
+ return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
+ default:
+ PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_PROTO_GTP_U, next_proto);
+ return layer->pld_ptr;
+ }
+}
+
+static inline const char *parse_gtp_c(struct packet *pkt, const char *data, uint16_t len)
+{
+ // GTPv1-C or GTPv2-C
+ uint16_t hdr_len = calc_gtp_hdr_len(data, len);
+ if (unlikely(hdr_len == 0 || hdr_len > len))
+ {
+ PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_GTP_C);
+ return data;
+ }
+
+ struct layer_private *layer = get_free_layer(pkt);
+ if (unlikely(layer == NULL))
+ {
+ return data;
+ }
+ SET_LAYER(pkt, layer, LAYER_PROTO_GTP_C, hdr_len, data, len, 0);
+
+ return layer->pld_ptr;
+}
+
+static inline const char *parse_l3(struct packet *pkt, uint16_t next_proto, const char *data, uint16_t len)
+{
+ switch (next_proto)
+ {
+ case ETH_P_8021Q:
+ case ETH_P_8021AD:
+ return parse_vlan(pkt, data, len);
+ case ETH_P_IP:
+ return parse_ipv4(pkt, data, len);
+ case ETH_P_IPV6:
+ return parse_ipv6(pkt, data, len);
+ case ETH_P_PPP_SES:
+ return parse_pppoe_ses(pkt, data, len);
+ case ETH_P_MPLS_UC:
+ return parse_mpls(pkt, data, len);
+ case 0x880b:
+ return parse_ppp(pkt, data, len);
+ default:
+ PACKET_LOG_UNSUPPORT_ETHPROTO(pkt, next_proto);
+ return data;
+ }
+}
+
+static inline const char *parse_l4(struct packet *pkt, uint8_t next_proto, const char *data, uint16_t len)
+{
+ switch (next_proto)
+ {
+ case IPPROTO_AH:
+ return parse_auth(pkt, data, len);
+ case IPPROTO_TCP:
+ return parse_tcp(pkt, data, len);
+ case IPPROTO_UDP:
+ return parse_udp(pkt, data, len);
+ case IPPROTO_IPIP:
+ return parse_ipv4(pkt, data, len);
+ case IPPROTO_IPV6:
+ return parse_ipv6(pkt, data, len);
+ case IPPROTO_GRE:
+ return parse_gre(pkt, data, len);
+ case IPPROTO_ICMP:
+ return parse_icmp(pkt, data, len);
+ case IPPROTO_ICMPV6:
+ return parse_icmp6(pkt, data, len);
+ case 115:
+ // L2TP
+ return parse_l2tpv3_over_ip(pkt, data, len);
+ default:
+ PACKET_LOG_UNSUPPORT_IPPROTO(pkt, next_proto);
+ return data;
+ }
+}
+
+/******************************************************************************
+ * Public API
+ ******************************************************************************/
+
+// return innermost payload
+const char *packet_parse(struct packet *pkt, const char *data, uint16_t len)
+{
+ pkt->frag_layer = NULL;
+ pkt->layers_used = 0;
+ pkt->layers_size = PACKET_MAX_LAYERS;
+ pkt->data_ptr = data;
+ pkt->data_len = len;
+ pkt->trim_len = 0;
+
+ return parse_ether(pkt, data, len);
+}
+
+const char *layer_proto_to_str(enum layer_proto proto)
+{
+ switch (proto)
+ {
+ case LAYER_PROTO_ETHER:
+ return "ETH";
+ case LAYER_PROTO_PWETH:
+ return "PWETH";
+ case LAYER_PROTO_PPP:
+ return "PPP";
+ case LAYER_PROTO_L2TP:
+ return "L2TP";
+ case LAYER_PROTO_VLAN:
+ return "VLAN";
+ case LAYER_PROTO_PPPOE:
+ return "PPPOE";
+ case LAYER_PROTO_MPLS:
+ return "MPLS";
+ case LAYER_PROTO_IPV4:
+ return "IPV4";
+ case LAYER_PROTO_IPV6:
+ return "IPV6";
+ case LAYER_PROTO_IPAH:
+ return "IPAH";
+ case LAYER_PROTO_GRE:
+ return "GRE";
+ case LAYER_PROTO_UDP:
+ return "UDP";
+ case LAYER_PROTO_TCP:
+ return "TCP";
+ case LAYER_PROTO_ICMP:
+ return "ICMP";
+ case LAYER_PROTO_ICMP6:
+ return "ICMP6";
+ case LAYER_PROTO_VXLAN:
+ return "VXLAN";
+ case LAYER_PROTO_GTP_C:
+ return "GTP-C";
+ case LAYER_PROTO_GTP_U:
+ return "GTP-U";
+ default:
+ return "UNKNOWN";
+ }
+}
\ No newline at end of file
diff -uNr tcpdump-tcpdump-4.99.4/packet_utils.c tcpdump-for-stellar/packet_utils.c
--- tcpdump-tcpdump-4.99.4/packet_utils.c 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/packet_utils.c 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,966 @@
+#include <assert.h>
+
+#include "tuple.h"
+#include "uthash.h"
+#include "log_internal.h"
+#include "packet_helper.h"
+#include "packet_internal.h"
+#include "stellar/exdata.h"
+
+#define PACKET_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "packet", format, ##__VA_ARGS__)
+
+/******************************************************************************
+ * metadata utils
+ ******************************************************************************/
+
+void packet_set_route_ctx(struct packet *pkt, const struct route_ctx *ctx)
+{
+ pkt->meta.route_ctx = *ctx;
+}
+
+const struct route_ctx *packet_get_route_ctx(const struct packet *pkt)
+{
+ return &pkt->meta.route_ctx;
+}
+
+void packet_set_origin_ctx(struct packet *pkt, void *ctx)
+{
+ pkt->meta.origin_ctx = ctx;
+}
+
+const void *packet_get_origin_ctx(const struct packet *pkt)
+{
+ return pkt->meta.origin_ctx;
+}
+
+void packet_set_sids(struct packet *pkt, const struct sids *sids)
+{
+ pkt->meta.sids = *sids;
+}
+
+const struct sids *packet_get_sids(const struct packet *pkt)
+{
+ return &pkt->meta.sids;
+}
+
+void packet_prepend_sids(struct packet *pkt, const struct sids *sids)
+{
+ if (pkt->meta.sids.used + sids->used > MAX_SIDS)
+ {
+ PACKET_LOG_ERROR("sids overflow");
+ return;
+ }
+ else
+ {
+ for (int i = pkt->meta.sids.used - 1; i >= 0; i--)
+ {
+ pkt->meta.sids.sid[i + sids->used] = pkt->meta.sids.sid[i];
+ }
+ for (int i = 0; i < sids->used; i++)
+ {
+ pkt->meta.sids.sid[i] = sids->sid[i];
+ }
+ pkt->meta.sids.used += sids->used;
+ }
+}
+
+void packet_set_session_id(struct packet *pkt, uint64_t id)
+{
+ pkt->meta.session_id = id;
+}
+
+uint64_t packet_get_session_id(const struct packet *pkt)
+{
+ return pkt->meta.session_id;
+}
+
+void packet_set_domain(struct packet *pkt, uint64_t domain)
+{
+ pkt->meta.domain = domain;
+}
+
+uint64_t packet_get_domain(const struct packet *pkt)
+{
+ return pkt->meta.domain;
+}
+
+void packet_set_link_id(struct packet *pkt, uint16_t id)
+{
+ pkt->meta.link_id = id;
+}
+
+uint16_t packet_get_link_id(const struct packet *pkt)
+{
+ return pkt->meta.link_id;
+}
+
+void packet_set_ctrl(struct packet *pkt, bool ctrl)
+{
+ pkt->meta.is_ctrl = ctrl;
+}
+
+bool packet_is_ctrl(const struct packet *pkt)
+{
+ return pkt->meta.is_ctrl;
+}
+
+void packet_set_claim(struct packet *pkt, bool claim)
+{
+ pkt->meta.is_claim = claim;
+}
+
+bool packet_is_claim(const struct packet *pkt)
+{
+ return pkt->meta.is_claim;
+}
+
+void packet_set_direction(struct packet *pkt, enum packet_direction dir)
+{
+ pkt->meta.direction = dir;
+}
+
+enum packet_direction packet_get_direction(const struct packet *pkt)
+{
+ return pkt->meta.direction;
+}
+
+void packet_set_action(struct packet *pkt, enum packet_action action)
+{
+ pkt->meta.action = action;
+}
+
+enum packet_action packet_get_action(const struct packet *pkt)
+{
+ return pkt->meta.action;
+}
+
+void packet_set_timeval(struct packet *pkt, const struct timeval *tv)
+{
+ pkt->meta.tv = *tv;
+}
+
+const struct timeval *packet_get_timeval(const struct packet *pkt)
+{
+ return &pkt->meta.tv;
+}
+
+void packet_set_user_data(struct packet *pkt, void *data)
+{
+ pkt->user_data = data;
+}
+
+void *packet_get_user_data(struct packet *pkt)
+{
+ return pkt->user_data;
+}
+
+/******************************************************************************
+ * tuple uitls
+ ******************************************************************************/
+
+// return 0 : found
+// return -1 : not found
+int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple2));
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
+ {
+ layer = &pkt->layers[i];
+
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ return 0;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+// return 0 : found
+// return -1 : not found
+int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple2));
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = 0; i < pkt->layers_used; i++)
+ {
+ layer = &pkt->layers[i];
+
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ return 0;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+// return 0 : found
+// return -1 : not found
+int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple4));
+ const struct layer_private *layer_l3 = NULL;
+ const struct layer_private *layer_l4 = NULL;
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
+ {
+ layer = &pkt->layers[i];
+
+ // first get L4 layer
+ if (layer->proto == LAYER_PROTO_UDP)
+ {
+ const struct udphdr *udp_hdr = (const struct udphdr *)layer->hdr_ptr;
+ tuple->src_port = udp_hdr->uh_sport;
+ tuple->dst_port = udp_hdr->uh_dport;
+ layer_l4 = layer;
+ continue;
+ }
+ if (layer->proto == LAYER_PROTO_TCP)
+ {
+ const struct tcphdr *tcp_hdr = (const struct tcphdr *)layer->hdr_ptr;
+ tuple->src_port = tcp_hdr->th_sport;
+ tuple->dst_port = tcp_hdr->th_dport;
+ layer_l4 = layer;
+ continue;
+ }
+
+ // second get L3 layer
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ layer_l3 = layer;
+ break;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ layer_l3 = layer;
+ break;
+ }
+ }
+
+ if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+// return 0 : found
+// return -1 : not found
+int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple4));
+ const struct layer_private *layer_l3 = NULL;
+ const struct layer_private *layer_l4 = NULL;
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = 0; i < pkt->layers_used; i++)
+ {
+ layer = &pkt->layers[i];
+
+ // first get L3 layer
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ layer_l3 = layer;
+ continue;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ layer_l3 = layer;
+ continue;
+ }
+
+ // second get L4 layer
+ if (layer->proto == LAYER_PROTO_UDP)
+ {
+ const struct udphdr *udp_hdr = (const struct udphdr *)layer->hdr_ptr;
+ tuple->src_port = udp_hdr->uh_sport;
+ tuple->dst_port = udp_hdr->uh_dport;
+ layer_l4 = layer;
+ break;
+ }
+ if (layer->proto == LAYER_PROTO_TCP)
+ {
+ const struct tcphdr *tcp_hdr = (const struct tcphdr *)layer->hdr_ptr;
+ tuple->src_port = tcp_hdr->th_sport;
+ tuple->dst_port = tcp_hdr->th_dport;
+ layer_l4 = layer;
+ break;
+ }
+ }
+
+ if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+// return 0 : found
+// return -1 : not found
+int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple6));
+ const struct layer_private *layer_l3 = NULL;
+ const struct layer_private *layer_l4 = NULL;
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
+ {
+ layer = &pkt->layers[i];
+
+ // first get L4 layer
+ if (layer->proto == LAYER_PROTO_UDP)
+ {
+ const struct udphdr *udp_hdr = (const struct udphdr *)layer->hdr_ptr;
+ tuple->ip_proto = IPPROTO_UDP;
+ tuple->src_port = udp_hdr->uh_sport;
+ tuple->dst_port = udp_hdr->uh_dport;
+ layer_l4 = layer;
+ continue;
+ }
+ if (layer->proto == LAYER_PROTO_TCP)
+ {
+ const struct tcphdr *tcp_hdr = (const struct tcphdr *)layer->hdr_ptr;
+ tuple->ip_proto = IPPROTO_TCP;
+ tuple->src_port = tcp_hdr->th_sport;
+ tuple->dst_port = tcp_hdr->th_dport;
+ layer_l4 = layer;
+ continue;
+ }
+
+ // second get L3 layer
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ layer_l3 = layer;
+ break;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ layer_l3 = layer;
+ break;
+ }
+ }
+
+ if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
+ {
+ tuple->domain = packet_get_domain(pkt);
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+// return 0 : found
+// return -1 : not found
+int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
+{
+ memset(tuple, 0, sizeof(struct tuple6));
+ const struct layer_private *layer_l3 = NULL;
+ const struct layer_private *layer_l4 = NULL;
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = 0; i < pkt->layers_used; i++)
+ {
+ layer = &pkt->layers[i];
+
+ // first get L3 layer
+ if (layer->proto == LAYER_PROTO_IPV4)
+ {
+ const struct ip *ip4_hdr = (const struct ip *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET;
+ tuple->src_addr.v4 = ip4_hdr_get_src_in_addr(ip4_hdr);
+ tuple->dst_addr.v4 = ip4_hdr_get_dst_in_addr(ip4_hdr);
+ layer_l3 = layer;
+ continue;
+ }
+ if (layer->proto == LAYER_PROTO_IPV6)
+ {
+ const struct ip6_hdr *ip6_hdr = (const struct ip6_hdr *)layer->hdr_ptr;
+ tuple->addr_family = AF_INET6;
+ tuple->src_addr.v6 = ip6_hdr_get_src_in6_addr(ip6_hdr);
+ tuple->dst_addr.v6 = ip6_hdr_get_dst_in6_addr(ip6_hdr);
+ layer_l3 = layer;
+ continue;
+ }
+
+ // second get L4 layer
+ if (layer->proto == LAYER_PROTO_UDP)
+ {
+ const struct udphdr *udp_hdr = (const struct udphdr *)layer->hdr_ptr;
+ tuple->ip_proto = IPPROTO_UDP;
+ tuple->src_port = udp_hdr->uh_sport;
+ tuple->dst_port = udp_hdr->uh_dport;
+ layer_l4 = layer;
+ break;
+ }
+ if (layer->proto == LAYER_PROTO_TCP)
+ {
+ const struct tcphdr *tcp_hdr = (const struct tcphdr *)layer->hdr_ptr;
+ tuple->ip_proto = IPPROTO_TCP;
+ tuple->src_port = tcp_hdr->th_sport;
+ tuple->dst_port = tcp_hdr->th_dport;
+ layer_l4 = layer;
+ break;
+ }
+ }
+
+ if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
+ {
+ tuple->domain = packet_get_domain(pkt);
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+/******************************************************************************
+ * layer uitls
+ ******************************************************************************/
+
+int packet_get_layer_count(const struct packet *pkt)
+{
+ return pkt->layers_used;
+}
+
+const struct layer *packet_get_layer_by_idx(const struct packet *pkt, int idx)
+{
+ const struct layer_private *layer = packet_get_layer(pkt, idx);
+ if (layer == NULL)
+ {
+ return NULL;
+ }
+ else
+ {
+ return (const struct layer *)layer;
+ }
+}
+
+const struct layer_private *packet_get_layer(const struct packet *pkt, int idx)
+{
+ if (idx < 0 || idx >= pkt->layers_used)
+ {
+ return NULL;
+ }
+ return &pkt->layers[idx];
+}
+
+const struct layer_private *packet_get_innermost_layer(const struct packet *pkt, enum layer_proto proto)
+{
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
+ {
+ layer = &pkt->layers[i];
+ if (layer->proto == proto)
+ {
+ return layer;
+ }
+ }
+
+ return NULL;
+}
+
+const struct layer_private *packet_get_outermost_layer(const struct packet *pkt, enum layer_proto proto)
+{
+ const struct layer_private *layer = NULL;
+
+ for (int8_t i = 0; i < pkt->layers_used; i++)
+ {
+ layer = &pkt->layers[i];
+ if (layer->proto == proto)
+ {
+ return layer;
+ }
+ }
+
+ return NULL;
+}
+
+/******************************************************************************
+ * tunnel uitls
+ ******************************************************************************/
+
+struct tunnel_detector
+{
+ enum tunnel_type type;
+ int contain_layers;
+ int (*identify_func)(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2);
+};
+
+static int is_ipv4_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2 __attribute__((unused)))
+{
+ if (curr && curr->proto == LAYER_PROTO_IPV4 &&
+ next1 && (next1->proto == LAYER_PROTO_IPV4 || next1->proto == LAYER_PROTO_IPV6))
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_ipv6_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2 __attribute__((unused)))
+{
+ if (curr && curr->proto == LAYER_PROTO_IPV6 &&
+ next1 && (next1->proto == LAYER_PROTO_IPV4 || next1->proto == LAYER_PROTO_IPV6))
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_gre_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2 __attribute__((unused)))
+{
+ if (curr && (curr->proto == LAYER_PROTO_IPV4 || curr->proto == LAYER_PROTO_IPV6) &&
+ next1 && next1->proto == LAYER_PROTO_GRE)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_gtp_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2)
+{
+ if (curr && (curr->proto == LAYER_PROTO_IPV4 || curr->proto == LAYER_PROTO_IPV6) &&
+ next1 && next1->proto == LAYER_PROTO_UDP &&
+ next2 && next2->proto == LAYER_PROTO_GTP_U)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_vxlan_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2)
+{
+ if (curr && (curr->proto == LAYER_PROTO_IPV4 || curr->proto == LAYER_PROTO_IPV6) &&
+ next1 && next1->proto == LAYER_PROTO_UDP &&
+ next2 && next2->proto == LAYER_PROTO_VXLAN)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_l2tp_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2)
+{
+ if (curr && (curr->proto == LAYER_PROTO_IPV4 || curr->proto == LAYER_PROTO_IPV6) &&
+ next1 && next1->proto == LAYER_PROTO_UDP &&
+ next2 && next2->proto == LAYER_PROTO_L2TP)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static int is_teredo_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2)
+{
+ if (curr && curr->proto == LAYER_PROTO_IPV4 &&
+ next1 && next1->proto == LAYER_PROTO_UDP &&
+ next2 && next2->proto == LAYER_PROTO_IPV6)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+static struct tunnel_detector detectors[] = {
+ {TUNNEL_IPV4, 1, is_ipv4_tunnel},
+ {TUNNEL_IPV6, 1, is_ipv6_tunnel},
+ {TUNNEL_GRE, 2, is_gre_tunnel},
+ {TUNNEL_GTP, 3, is_gtp_tunnel},
+ {TUNNEL_VXLAN, 3, is_vxlan_tunnel},
+ {TUNNEL_L2TP, 3, is_l2tp_tunnel},
+ {TUNNEL_TEREDO, 2, is_teredo_tunnel},
+};
+
+// return index of detectors
+static int detect_tunnel(const struct layer_private *curr, const struct layer_private *next1, const struct layer_private *next2)
+{
+ for (int i = 0; i < (int)(sizeof(detectors) / sizeof(detectors[0])); i++)
+ {
+ if (detectors[i].identify_func(curr, next1, next2))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+int packet_get_tunnel_count(const struct packet *pkt)
+{
+ int count = 0;
+ int used = packet_get_layer_count(pkt);
+ const struct layer_private *curr = NULL;
+ const struct layer_private *next1 = NULL;
+ const struct layer_private *next2 = NULL;
+
+ for (int i = 0; i < used; i++)
+ {
+ curr = packet_get_layer(pkt, i);
+ next1 = packet_get_layer(pkt, i + 1);
+ next2 = packet_get_layer(pkt, i + 2);
+ if (detect_tunnel(curr, next1, next2) >= 0)
+ {
+ count++;
+ }
+ }
+
+ return count;
+}
+
+// return 0: success 
+// return -1: failed
+int packet_get_tunnel_by_idx(const struct packet *pkt, int idx, struct tunnel *out)
+{
+ int ret = -1;
+ int count = 0;
+ int used = packet_get_layer_count(pkt);
+ const struct layer_private *curr = NULL;
+ const struct layer_private *next1 = NULL;
+ const struct layer_private *next2 = NULL;
+ memset(out, 0, sizeof(struct tunnel));
+
+ for (int i = 0; i < used; i++)
+ {
+ curr = packet_get_layer(pkt, i);
+ next1 = packet_get_layer(pkt, i + 1);
+ next2 = packet_get_layer(pkt, i + 2);
+ ret = detect_tunnel(curr, next1, next2);
+ if (ret >= 0 && count++ == idx)
+ {
+ struct tunnel_detector *hit = &detectors[ret];
+ out->type = hit->type;
+ out->layer_count = hit->contain_layers;
+ if (out->layer_count >= 1)
+ out->layers[0] = (const struct layer *)curr;
+ if (out->layer_count >= 2)
+ out->layers[1] = (const struct layer *)next1;
+ if (out->layer_count >= 3)
+ out->layers[2] = (const struct layer *)next2;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+/******************************************************************************
+ * load balance uitls
+ ******************************************************************************/
+
+uint64_t packet_ldbc_hash(const struct packet *pkt, enum packet_load_balance_method method, enum packet_direction direction)
+{
+ uint64_t temp = 0;
+ uint64_t hash_value = 1;
+
+ int inner_addr_len = 0;
+ int outer_addr_len = 0;
+ const char *inner_src_addr = NULL;
+ const char *inner_dst_addr = NULL;
+ const char *outer_src_addr = NULL;
+ const char *outer_dst_addr = NULL;
+
+ struct tuple2 inner_addr;
+ struct tuple2 outer_addr;
+
+ if (pkt == NULL)
+ {
+ return hash_value;
+ }
+
+ if (packet_get_innermost_tuple2(pkt, &inner_addr) == -1)
+ {
+ return hash_value;
+ }
+
+ if (packet_get_outermost_tuple2(pkt, &outer_addr) == -1)
+ {
+ return hash_value;
+ }
+
+ if (inner_addr.addr_family == AF_INET)
+ {
+ inner_src_addr = (const char *)&inner_addr.src_addr.v4;
+ inner_dst_addr = (const char *)&inner_addr.dst_addr.v4;
+ inner_addr_len = sizeof(struct in_addr);
+ }
+ else
+ {
+ inner_src_addr = (const char *)&inner_addr.src_addr.v6;
+ inner_dst_addr = (const char *)&inner_addr.dst_addr.v6;
+ inner_addr_len = sizeof(struct in6_addr);
+ }
+
+ if (outer_addr.addr_family == AF_INET)
+ {
+ outer_src_addr = (const char *)&outer_addr.src_addr.v4;
+ outer_dst_addr = (const char *)&outer_addr.dst_addr.v4;
+ outer_addr_len = sizeof(struct in_addr);
+ }
+ else
+ {
+ outer_src_addr = (const char *)&outer_addr.src_addr.v6;
+ outer_dst_addr = (const char *)&outer_addr.dst_addr.v6;
+ outer_addr_len = sizeof(struct in6_addr);
+ }
+
+ switch (method)
+ {
+ case PKT_LDBC_METH_OUTERMOST_INT_IP:
+ if (direction == PACKET_DIRECTION_INCOMING)
+ {
+ // direction 1: E2I
+ HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
+ }
+ else
+ {
+ // direction 0: I2E
+ HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+ }
+ break;
+ case PKT_LDBC_METH_OUTERMOST_EXT_IP:
+ if (direction == PACKET_DIRECTION_INCOMING)
+ {
+ // direction 1: E2I
+ HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+ }
+ else
+ {
+ // direction 0: I2E
+ HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
+ }
+ break;
+ case PKT_LDBC_METH_OUTERMOST_INT_EXT_IP:
+ HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+ HASH_VALUE(outer_dst_addr, outer_addr_len, temp);
+ hash_value = hash_value ^ temp;
+ break;
+ case PKT_LDBC_METH_INNERMOST_INT_IP:
+ if (direction == PACKET_DIRECTION_INCOMING)
+ {
+ // direction 1: E2I
+ HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
+ }
+ else
+ {
+ // direction 0: I2E
+ HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
+ }
+ break;
+ case PKT_LDBC_METH_INNERMOST_EXT_IP:
+ if (direction == PACKET_DIRECTION_INCOMING)
+ {
+ // direction 1: E2I
+ HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
+ }
+ else
+ {
+ // direction 0: I2E
+ HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
+ }
+ break;
+ default:
+ return hash_value;
+ }
+
+ return hash_value;
+}
+
+/******************************************************************************
+ * other uitls
+ ******************************************************************************/
+
+const char *packet_get_raw_data(const struct packet *pkt)
+{
+ return pkt->data_ptr;
+}
+
+uint16_t packet_get_raw_len(const struct packet *pkt)
+{
+ return pkt->data_len;
+}
+
+const char *packet_get_payload(const struct packet *pkt)
+{
+ if (pkt == NULL || pkt->layers_used == 0)
+ {
+ return NULL;
+ }
+
+ if (pkt->layers[pkt->layers_used - 1].pld_len)
+ {
+ return pkt->layers[pkt->layers_used - 1].pld_ptr;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+uint16_t packet_get_payload_len(const struct packet *pkt)
+{
+ if (pkt == NULL || pkt->layers_used == 0)
+ {
+ return 0;
+ }
+ return pkt->layers[pkt->layers_used - 1].pld_len;
+}
+
+struct packet *packet_new(uint16_t pkt_len)
+{
+ struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + pkt_len);
+ if (pkt == NULL)
+ {
+ return NULL;
+ }
+ pkt->data_len = pkt_len;
+ pkt->data_ptr = (const char *)pkt + sizeof(struct packet);
+ pkt->need_free = 1;
+
+ return pkt;
+}
+
+struct packet *packet_dup(const struct packet *pkt)
+{
+ if (pkt == NULL)
+ {
+ return NULL;
+ }
+
+ struct packet *dup_pkt = packet_new(pkt->data_len);
+ if (dup_pkt == NULL)
+ {
+ return NULL;
+ }
+
+ dup_pkt->layers_used = pkt->layers_used;
+ dup_pkt->layers_size = pkt->layers_size;
+
+ memcpy((char *)dup_pkt->data_ptr, pkt->data_ptr, pkt->data_len);
+ dup_pkt->data_len = pkt->data_len;
+ packet_set_action(dup_pkt, PACKET_ACTION_DROP);
+
+ for (int8_t i = 0; i < pkt->layers_used; i++)
+ {
+ dup_pkt->layers[i].proto = pkt->layers[i].proto;
+ dup_pkt->layers[i].hdr_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset;
+ dup_pkt->layers[i].pld_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
+ dup_pkt->layers[i].hdr_offset = pkt->layers[i].hdr_offset;
+ dup_pkt->layers[i].hdr_len = pkt->layers[i].hdr_len;
+ dup_pkt->layers[i].pld_len = pkt->layers[i].pld_len;
+ }
+
+ // update frag_layer
+ if (pkt->frag_layer)
+ {
+ dup_pkt->frag_layer = &dup_pkt->layers[pkt->frag_layer - pkt->layers];
+ }
+ memcpy(&dup_pkt->meta, &pkt->meta, sizeof(struct metadata));
+ packet_set_origin_ctx(dup_pkt, (void *)NULL);
+
+ return dup_pkt;
+}
+
+void packet_free(struct packet *pkt)
+{
+ if (pkt)
+ {
+ if (packet_is_claim(pkt))
+ {
+ PACKET_LOG_ERROR("packet has been claimed and cannot be released, please check the module arrangement order");
+ assert(0);
+ return;
+ }
+
+ if (pkt->need_free)
+ {
+ free((void *)pkt);
+ }
+ }
+}
+
+int packet_is_fragment(const struct packet *pkt)
+{
+ return (pkt->frag_layer) ? 1 : 0;
+}
+
+void packet_set_exdata(struct packet *pkt, int idx, void *ex_ptr)
+{
+ struct exdata_runtime *exdata_rt = (struct exdata_runtime *)packet_get_user_data(pkt);
+ exdata_set(exdata_rt, idx, ex_ptr);
+}
+
+void *packet_get_exdata(struct packet *pkt, int idx)
+{
+ struct exdata_runtime *exdata_rt = (struct exdata_runtime *)packet_get_user_data(pkt);
+ return exdata_get(exdata_rt, idx);
+}
diff -uNr tcpdump-tcpdump-4.99.4/print-bfd.c tcpdump-for-stellar/print-bfd.c
--- tcpdump-tcpdump-4.99.4/print-bfd.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-bfd.c 2024-10-30 17:34:05.612498702 +0800
@@ -30,7 +30,7 @@
#include "netdissect.h"
#include "extract.h"
-#include "udp.h"
+#include "print-udp.h"
/*
* Control packet, BFDv0, draft-ietf-bfd-base-01
@@ -144,9 +144,9 @@
};
static const struct tok bfd_port_values[] = {
- { BFD_CONTROL_PORT, "Control" },
- { BFD_MULTIHOP_PORT, "Multihop" },
- { BFD_LAG_PORT, "Lag" },
+ { TCPDUMP_BFD_CONTROL_PORT, "Control" },
+ { TCPDUMP_BFD_MULTIHOP_PORT, "Multihop" },
+ { TCPDUMP_BFD_LAG_PORT, "Lag" },
{ 0, NULL }
};
@@ -292,9 +292,9 @@
u_int len, u_int port)
{
ndo->ndo_protocol = "bfd";
- if (port == BFD_CONTROL_PORT ||
- port == BFD_MULTIHOP_PORT ||
- port == BFD_LAG_PORT) {
+ if (port == TCPDUMP_BFD_CONTROL_PORT ||
+ port == TCPDUMP_BFD_MULTIHOP_PORT ||
+ port == TCPDUMP_BFD_LAG_PORT) {
/*
* Control packet.
*/
@@ -401,7 +401,7 @@
}
break;
}
- } else if (port == BFD_ECHO_PORT) {
+ } else if (port == TCPDUMP_BFD_ECHO_PORT) {
/*
* Echo packet.
*/
diff -uNr tcpdump-tcpdump-4.99.4/print-cnfp.c tcpdump-for-stellar/print-cnfp.c
--- tcpdump-tcpdump-4.99.4/print-cnfp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-cnfp.c 2024-10-30 17:34:05.613498702 +0800
@@ -52,7 +52,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "tcp.h"
+#include "print-tcp.h"
#include "ipproto.h"
struct nfhdr_v1 {
diff -uNr tcpdump-tcpdump-4.99.4/print-dccp.c tcpdump-for-stellar/print-dccp.c
--- tcpdump-tcpdump-4.99.4/print-dccp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-dccp.c 2024-10-30 17:34:05.614498702 +0800
@@ -20,8 +20,8 @@
#include "netdissect.h"
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
/* RFC4340: Datagram Congestion Control Protocol (DCCP) */
@@ -199,14 +199,14 @@
return (cov > len)? len : cov;
}
-static uint16_t dccp_cksum(netdissect_options *ndo, const struct ip *ip,
+static uint16_t dccp_cksum(netdissect_options *ndo, const struct tcpdump_ip *ip,
const struct dccp_hdr *dh, u_int len)
{
return nextproto4_cksum(ndo, ip, (const uint8_t *)(const void *)dh, len,
dccp_csum_coverage(ndo, dh, len), IPPROTO_DCCP);
}
-static uint16_t dccp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
+static uint16_t dccp6_cksum(netdissect_options *ndo, const struct tcpdump_ip6_hdr *ip6,
const struct dccp_hdr *dh, u_int len)
{
return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)dh, len,
@@ -270,8 +270,8 @@
u_int len)
{
const struct dccp_hdr *dh;
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
const u_char *cp;
u_short sport, dport;
u_int hlen;
@@ -281,9 +281,9 @@
ndo->ndo_protocol = "dccp";
dh = (const struct dccp_hdr *)bp;
- ip = (const struct ip *)data2;
+ ip = (const struct tcpdump_ip *)data2;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)data2;
+ ip6 = (const struct tcpdump_ip6_hdr *)data2;
else
ip6 = NULL;
diff -uNr tcpdump-tcpdump-4.99.4/print-esp.c tcpdump-for-stellar/print-esp.c
--- tcpdump-tcpdump-4.99.4/print-esp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-esp.c 2024-10-30 17:34:05.615498702 +0800
@@ -54,8 +54,8 @@
#include "ascii_strcasecmp.h"
#endif
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -737,7 +737,7 @@
#ifdef HAVE_LIBCRYPTO
const struct ip *ip;
struct sa_list *sa = NULL;
- const struct ip6_hdr *ip6 = NULL;
+ const struct tcpdump_ip6_hdr *ip6 = NULL;
const u_char *iv;
u_int ivlen;
u_int payloadlen;
@@ -776,7 +776,7 @@
ip = (const struct ip *)bp2;
switch (ver) {
case 6:
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
/* we do not attempt to decrypt jumbograms */
if (!GET_BE_U_2(ip6->ip6_plen))
return;
diff -uNr tcpdump-tcpdump-4.99.4/print-frag6.c tcpdump-for-stellar/print-frag6.c
--- tcpdump-tcpdump-4.99.4/print-frag6.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-frag6.c 2024-10-30 17:34:05.616498702 +0800
@@ -30,29 +30,29 @@
#include "netdissect.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
int
frag6_print(netdissect_options *ndo, const u_char *bp, const u_char *bp2)
{
- const struct ip6_frag *dp;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_frag *dp;
+ const struct tcpdump_ip6_hdr *ip6;
ndo->ndo_protocol = "frag6";
- dp = (const struct ip6_frag *)bp;
- ip6 = (const struct ip6_hdr *)bp2;
+ dp = (const struct tcpdump_ip6_frag *)bp;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
if (ndo->ndo_vflag) {
ND_PRINT("frag (0x%08x:%u|%zu)",
GET_BE_U_4(dp->ip6f_ident),
GET_BE_U_2(dp->ip6f_offlg) & IP6F_OFF_MASK,
- sizeof(struct ip6_hdr) + GET_BE_U_2(ip6->ip6_plen) -
- (bp - bp2) - sizeof(struct ip6_frag));
+ sizeof(struct tcpdump_ip6_hdr) + GET_BE_U_2(ip6->ip6_plen) -
+ (bp - bp2) - sizeof(struct tcpdump_ip6_frag));
} else {
ND_PRINT("frag (%u|%zu)",
GET_BE_U_2(dp->ip6f_offlg) & IP6F_OFF_MASK,
- sizeof(struct ip6_hdr) + GET_BE_U_2(ip6->ip6_plen) -
- (bp - bp2) - sizeof(struct ip6_frag));
+ sizeof(struct tcpdump_ip6_hdr) + GET_BE_U_2(ip6->ip6_plen) -
+ (bp - bp2) - sizeof(struct tcpdump_ip6_frag));
}
/* it is meaningless to decode non-first fragment */
@@ -61,6 +61,6 @@
else
{
ND_PRINT(" ");
- return sizeof(struct ip6_frag);
+ return sizeof(struct tcpdump_ip6_frag);
}
}
diff -uNr tcpdump-tcpdump-4.99.4/print-icmp6.c tcpdump-for-stellar/print-icmp6.c
--- tcpdump-tcpdump-4.99.4/print-icmp6.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-icmp6.c 2024-10-30 17:34:05.617498702 +0800
@@ -35,10 +35,10 @@
#include "addrtostr.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
-#include "udp.h"
+#include "print-udp.h"
#include "ah.h"
/* NetBSD: icmp6.h,v 1.13 2000/08/03 16:30:37 itojun Exp */
@@ -769,7 +769,7 @@
}
}
-static uint16_t icmp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
+static uint16_t icmp6_cksum(netdissect_options *ndo, const struct tcpdump_ip6_hdr *ip6,
const struct icmp6_hdr *icp, u_int len)
{
return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)icp, len, len,
@@ -1011,8 +1011,8 @@
{
const struct icmp6_hdr *dp;
uint8_t icmp6_type, icmp6_code;
- const struct ip6_hdr *ip;
- const struct ip6_hdr *oip;
+ const struct tcpdump_ip6_hdr *ip;
+ const struct tcpdump_ip6_hdr *oip;
const struct udphdr *ouh;
uint16_t dport;
const u_char *ep;
@@ -1020,8 +1020,8 @@
ndo->ndo_protocol = "icmp6";
dp = (const struct icmp6_hdr *)bp;
- ip = (const struct ip6_hdr *)bp2;
- oip = (const struct ip6_hdr *)(dp + 1);
+ ip = (const struct tcpdump_ip6_hdr *)bp2;
+ oip = (const struct tcpdump_ip6_hdr *)(dp + 1);
/* 'ep' points to the end of available data. */
ep = ndo->ndo_snapend;
if (length == 0) {
@@ -1319,10 +1319,10 @@
get_upperlayer(netdissect_options *ndo, const u_char *bp, u_int *prot)
{
const u_char *ep;
- const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp;
+ const struct tcpdump_ip6_hdr *ip6 = (const struct tcpdump_ip6_hdr *)bp;
const struct udphdr *uh;
- const struct ip6_hbh *hbh;
- const struct ip6_frag *fragh;
+ const struct tcpdump_ip6_hbh *hbh;
+ const struct tcpdump_ip6_frag *fragh;
const struct ah *ah;
u_int nh;
int hlen;
@@ -1334,7 +1334,7 @@
return NULL;
nh = GET_U_1(ip6->ip6_nxt);
- hlen = sizeof(struct ip6_hdr);
+ hlen = sizeof(struct tcpdump_ip6_hdr);
while (bp < ep) {
bp += hlen;
@@ -1354,7 +1354,7 @@
case IPPROTO_HOPOPTS:
case IPPROTO_DSTOPTS:
case IPPROTO_ROUTING:
- hbh = (const struct ip6_hbh *)bp;
+ hbh = (const struct tcpdump_ip6_hbh *)bp;
if (!ND_TTEST_1(hbh->ip6h_len))
return(NULL);
nh = GET_U_1(hbh->ip6h_nxt);
@@ -1362,14 +1362,14 @@
break;
case IPPROTO_FRAGMENT: /* this should be odd, but try anyway */
- fragh = (const struct ip6_frag *)bp;
+ fragh = (const struct tcpdump_ip6_frag *)bp;
if (!ND_TTEST_2(fragh->ip6f_offlg))
return(NULL);
/* fragments with non-zero offset are meaningless */
if ((GET_BE_U_2(fragh->ip6f_offlg) & IP6F_OFF_MASK) != 0)
return(NULL);
nh = GET_U_1(fragh->ip6f_nxt);
- hlen = sizeof(struct ip6_frag);
+ hlen = sizeof(struct tcpdump_ip6_frag);
break;
case IPPROTO_AH:
diff -uNr tcpdump-tcpdump-4.99.4/print-icmp.c tcpdump-for-stellar/print-icmp.c
--- tcpdump-tcpdump-4.99.4/print-icmp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-icmp.c 2024-10-30 17:34:05.617498702 +0800
@@ -34,8 +34,8 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "udp.h"
+#include "tcpdump_ip.h"
+#include "print-udp.h"
#include "ipproto.h"
#include "mpls.h"
@@ -72,7 +72,7 @@
nd_uint32_t its_ttime;
} id_ts;
struct id_ip {
- struct ip idi_ip;
+ struct tcpdump_ip idi_ip;
/* options and then 64 bits of data */
} id_ip;
nd_uint32_t id_mask;
@@ -95,10 +95,10 @@
* ip header length.
*/
#define ICMP_MINLEN 8 /* abs minimum */
-#define ICMP_EXTD_MINLEN (156 - sizeof (struct ip)) /* draft-bonica-internet-icmp-08 */
+#define ICMP_EXTD_MINLEN (156 - sizeof (struct tcpdump_ip)) /* draft-bonica-internet-icmp-08 */
#define ICMP_TSLEN (8 + 3 * sizeof (uint32_t)) /* timestamp */
#define ICMP_MASKLEN 12 /* address mask */
-#define ICMP_ADVLENMIN (8 + sizeof (struct ip) + 8) /* min */
+#define ICMP_ADVLENMIN (8 + sizeof (struct tcpdump_ip) + 8) /* min */
#define ICMP_ADVLEN(p) (8 + (IP_HL(&(p)->icmp_ip) << 2) + 8)
/* N.B.: must separately check that ip_hl >= 5 */
@@ -318,9 +318,9 @@
const struct icmp *dp;
uint8_t icmp_type, icmp_code;
const struct icmp_ext_t *ext_dp;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
const char *str;
- const struct ip *oip;
+ const struct tcpdump_ip *oip;
uint8_t ip_proto;
const struct udphdr *ouh;
const uint8_t *obj_tptr;
@@ -334,7 +334,7 @@
ndo->ndo_protocol = "icmp";
dp = (const struct icmp *)bp;
ext_dp = (const struct icmp_ext_t *)bp;
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
str = buf;
icmp_type = GET_U_1(dp->icmp_type);
@@ -674,7 +674,7 @@
bp += 8;
ND_PRINT("\n\t");
- ip = (const struct ip *)bp;
+ ip = (const struct tcpdump_ip *)bp;
snapend_save = ndo->ndo_snapend;
/*
* Update the snapend because extensions (MPLS, ...) may be
diff -uNr tcpdump-tcpdump-4.99.4/print-ip6.c tcpdump-for-stellar/print-ip6.c
--- tcpdump-tcpdump-4.99.4/print-ip6.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-ip6.c 2024-10-30 17:34:05.618498702 +0800
@@ -33,7 +33,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
/*
@@ -45,20 +45,20 @@
*/
static void
ip6_finddst(netdissect_options *ndo, nd_ipv6 *dst,
- const struct ip6_hdr *ip6)
+ const struct tcpdump_ip6_hdr *ip6)
{
const u_char *cp;
u_int advance;
u_int nh;
const void *dst_addr;
- const struct ip6_rthdr *dp;
- const struct ip6_rthdr0 *dp0;
- const struct ip6_srh *srh;
+ const struct tcpdump_ip6_rthdr *dp;
+ const struct tcpdump_ip6_rthdr0 *dp0;
+ const struct tcpdump_ip6_srh *srh;
const u_char *p;
int i, len;
cp = (const u_char *)ip6;
- advance = sizeof(struct ip6_hdr);
+ advance = sizeof(struct tcpdump_ip6_hdr);
nh = GET_U_1(ip6->ip6_nxt);
dst_addr = (const void *)ip6->ip6_dst;
@@ -87,7 +87,7 @@
* marked as reserved, and the header is always
* the same size.
*/
- advance = sizeof(struct ip6_frag);
+ advance = sizeof(struct tcpdump_ip6_frag);
nh = GET_U_1(cp);
break;
@@ -95,14 +95,14 @@
/*
* OK, we found it.
*/
- dp = (const struct ip6_rthdr *)cp;
+ dp = (const struct tcpdump_ip6_rthdr *)cp;
ND_TCHECK_SIZE(dp);
len = GET_U_1(dp->ip6r_len);
switch (GET_U_1(dp->ip6r_type)) {
case IPV6_RTHDR_TYPE_0:
case IPV6_RTHDR_TYPE_2: /* Mobile IPv6 ID-20 */
- dp0 = (const struct ip6_rthdr0 *)dp;
+ dp0 = (const struct tcpdump_ip6_rthdr0 *)dp;
if (len % 2 == 1)
goto trunc;
len >>= 1;
@@ -115,7 +115,7 @@
break;
case IPV6_RTHDR_TYPE_4:
/* IPv6 Segment Routing Header (SRH) */
- srh = (const struct ip6_srh *)dp;
+ srh = (const struct tcpdump_ip6_srh *)dp;
if (len % 2 == 1)
goto trunc;
p = (const u_char *) srh->srh_segments;
@@ -171,7 +171,7 @@
*/
uint16_t
nextproto6_cksum(netdissect_options *ndo,
- const struct ip6_hdr *ip6, const uint8_t *data,
+ const struct tcpdump_ip6_hdr *ip6, const uint8_t *data,
u_int len, u_int covlen, uint8_t next_proto)
{
struct {
@@ -225,7 +225,7 @@
void
ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
{
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
int advance;
u_int len;
u_int total_advance;
@@ -239,10 +239,10 @@
int found_hbh;
ndo->ndo_protocol = "ip6";
- ip6 = (const struct ip6_hdr *)bp;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp;
ND_TCHECK_SIZE(ip6);
- if (length < sizeof (struct ip6_hdr)) {
+ if (length < sizeof (struct tcpdump_ip6_hdr)) {
ND_PRINT("truncated-ip6 %u", length);
return;
}
@@ -279,12 +279,12 @@
* a Jumbo Payload option, and fail if we haven't.
*/
if (payload_len != 0) {
- len = payload_len + sizeof(struct ip6_hdr);
+ len = payload_len + sizeof(struct tcpdump_ip6_hdr);
if (length < len)
ND_PRINT("truncated-ip6 - %u bytes missing!",
len - length);
} else
- len = length + sizeof(struct ip6_hdr);
+ len = length + sizeof(struct tcpdump_ip6_hdr);
ph = 255;
nh = GET_U_1(ip6->ip6_nxt);
@@ -313,7 +313,7 @@
}
cp = (const u_char *)ip6;
- advance = sizeof(struct ip6_hdr);
+ advance = sizeof(struct tcpdump_ip6_hdr);
total_advance = 0;
/* Process extension headers */
found_extension_header = 0;
@@ -433,7 +433,7 @@
* the total number of bytes we've
* processed so far.
*/
- len = payload_len + sizeof(struct ip6_hdr);
+ len = payload_len + sizeof(struct tcpdump_ip6_hdr);
if (len < total_advance)
goto trunc;
if (length < len)
@@ -471,7 +471,7 @@
* and change the snapshot length
* accordingly.
*/
- len = sizeof(struct ip6_hdr);
+ len = sizeof(struct tcpdump_ip6_hdr);
nd_change_snaplen(ndo, bp, len);
/*
diff -uNr tcpdump-tcpdump-4.99.4/print-ip6opts.c tcpdump-for-stellar/print-ip6opts.c
--- tcpdump-tcpdump-4.99.4/print-ip6opts.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-ip6opts.c 2024-10-30 17:34:05.618498702 +0800
@@ -39,7 +39,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
static int
ip6_sopt_print(netdissect_options *ndo, const u_char *bp, int len)
@@ -219,7 +219,7 @@
hbhopt_process(netdissect_options *ndo, const u_char *bp, int *found_jumbo,
uint32_t *jumbolen)
{
- const struct ip6_hbh *dp = (const struct ip6_hbh *)bp;
+ const struct tcpdump_ip6_hbh *dp = (const struct tcpdump_ip6_hbh *)bp;
u_int hbhlen = 0;
ndo->ndo_protocol = "hbhopt";
@@ -239,7 +239,7 @@
int
dstopt_process(netdissect_options *ndo, const u_char *bp)
{
- const struct ip6_dest *dp = (const struct ip6_dest *)bp;
+ const struct tcpdump_ip6_dest *dp = (const struct tcpdump_ip6_dest *)bp;
u_int dstoptlen = 0;
ndo->ndo_protocol = "dstopt";
diff -uNr tcpdump-tcpdump-4.99.4/print-ip.c tcpdump-for-stellar/print-ip.c
--- tcpdump-tcpdump-4.99.4/print-ip.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-ip.c 2024-10-30 17:34:05.618498702 +0800
@@ -31,7 +31,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
+#include "tcpdump_ip.h"
#include "ipproto.h"
@@ -89,7 +89,7 @@
*/
static uint32_t
ip_finddst(netdissect_options *ndo,
- const struct ip *ip)
+ const struct tcpdump_ip *ip)
{
u_int length;
u_int len;
@@ -97,9 +97,9 @@
cp = (const u_char *)(ip + 1);
length = IP_HL(ip) * 4;
- if (length < sizeof(struct ip))
+ if (length < sizeof(struct tcpdump_ip))
goto trunc;
- length -= sizeof(struct ip);
+ length -= sizeof(struct tcpdump_ip);
for (; length != 0; cp += len, length -= len) {
int tt;
@@ -135,7 +135,7 @@
*/
uint16_t
nextproto4_cksum(netdissect_options *ndo,
- const struct ip *ip, const uint8_t *data,
+ const struct tcpdump_ip *ip, const uint8_t *data,
u_int len, u_int covlen, uint8_t next_proto)
{
struct phdr {
@@ -320,7 +320,7 @@
const u_char *bp,
u_int length)
{
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
u_int off;
u_int hlen;
u_int len;
@@ -331,7 +331,7 @@
int truncated = 0;
ndo->ndo_protocol = "ip";
- ip = (const struct ip *)bp;
+ ip = (const struct tcpdump_ip *)bp;
if (IP_V(ip) != 4) { /* print version and fail if != 4 */
if (IP_V(ip) == 6)
ND_PRINT("IP6, wrong link-layer encapsulation");
@@ -344,12 +344,12 @@
ND_PRINT("IP ");
ND_TCHECK_SIZE(ip);
- if (length < sizeof (struct ip)) {
+ if (length < sizeof (struct tcpdump_ip)) {
ND_PRINT("truncated-ip %u", length);
return;
}
hlen = IP_HL(ip) * 4;
- if (hlen < sizeof (struct ip)) {
+ if (hlen < sizeof (struct tcpdump_ip)) {
ND_PRINT("bad-hlen %u", hlen);
return;
}
@@ -428,10 +428,10 @@
ND_PRINT(", length %u", GET_BE_U_2(ip->ip_len));
- if ((hlen - sizeof(struct ip)) > 0) {
+ if ((hlen - sizeof(struct tcpdump_ip)) > 0) {
ND_PRINT(", options (");
if (ip_optprint(ndo, (const u_char *)(ip + 1),
- hlen - sizeof(struct ip)) == -1) {
+ hlen - sizeof(struct tcpdump_ip)) == -1) {
ND_PRINT(" [truncated-option]");
truncated = 1;
}
diff -uNr tcpdump-tcpdump-4.99.4/print-ip-demux.c tcpdump-for-stellar/print-ip-demux.c
--- tcpdump-tcpdump-4.99.4/print-ip-demux.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-ip-demux.c 2024-10-30 17:34:05.618498702 +0800
@@ -31,7 +31,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
+#include "tcpdump_ip.h"
#include "ipproto.h"
void
diff -uNr tcpdump-tcpdump-4.99.4/print-isakmp.c tcpdump-for-stellar/print-isakmp.c
--- tcpdump-tcpdump-4.99.4/print-isakmp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-isakmp.c 2024-10-30 17:34:05.619498702 +0800
@@ -53,8 +53,8 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
typedef nd_byte cookie_t[8];
@@ -771,8 +771,8 @@
cookie_record(netdissect_options *ndo, const cookie_t *in, const u_char *bp2)
{
int i;
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
i = cookie_find(in);
if (0 <= i) {
@@ -780,7 +780,7 @@
return;
}
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
switch (IP_V(ip)) {
case 4:
cookiecache[ninitiator].version = 4;
@@ -790,7 +790,7 @@
ip->ip_dst, sizeof(nd_ipv4));
break;
case 6:
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
cookiecache[ninitiator].version = 6;
UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in6,
ip6->ip6_src, sizeof(nd_ipv6));
@@ -809,10 +809,10 @@
static int
cookie_sidecheck(netdissect_options *ndo, int i, const u_char *bp2, int initiator)
{
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
switch (IP_V(ip)) {
case 4:
if (cookiecache[i].version != 4)
@@ -828,7 +828,7 @@
case 6:
if (cookiecache[i].version != 6)
return 0;
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
if (initiator) {
if (UNALIGNED_MEMCMP(ip6->ip6_src, &cookiecache[i].iaddr.in6, sizeof(nd_ipv6)) == 0)
return 1;
diff -uNr tcpdump-tcpdump-4.99.4/print-lisp.c tcpdump-for-stellar/print-lisp.c
--- tcpdump-tcpdump-4.99.4/print-lisp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-lisp.c 2024-10-30 17:34:05.620498702 +0800
@@ -101,8 +101,8 @@
#include "netdissect-stdinc.h"
#include "netdissect.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "extract.h"
#include "addrtoname.h"
diff -uNr tcpdump-tcpdump-4.99.4/print-lldp.c tcpdump-for-stellar/print-lldp.c
--- tcpdump-tcpdump-4.99.4/print-lldp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-lldp.c 2024-10-30 17:34:05.620498702 +0800
@@ -41,9 +41,9 @@
*/
#define LLDP_END_TLV 0
#define LLDP_CHASSIS_ID_TLV 1
-#define LLDP_PORT_ID_TLV 2
+#define LTCPDUMP_LDP_PORT_ID_TLV 2
#define LLDP_TTL_TLV 3
-#define LLDP_PORT_DESCR_TLV 4
+#define LTCPDUMP_LDP_PORT_DESCR_TLV 4
#define LLDP_SYSTEM_NAME_TLV 5
#define LLDP_SYSTEM_DESCR_TLV 6
#define LLDP_SYSTEM_CAP_TLV 7
@@ -53,9 +53,9 @@
static const struct tok lldp_tlv_values[] = {
{ LLDP_END_TLV, "End" },
{ LLDP_CHASSIS_ID_TLV, "Chassis ID" },
- { LLDP_PORT_ID_TLV, "Port ID" },
+ { LTCPDUMP_LDP_PORT_ID_TLV, "Port ID" },
{ LLDP_TTL_TLV, "Time to Live" },
- { LLDP_PORT_DESCR_TLV, "Port Description" },
+ { LTCPDUMP_LDP_PORT_DESCR_TLV, "Port Description" },
{ LLDP_SYSTEM_NAME_TLV, "System Name" },
{ LLDP_SYSTEM_DESCR_TLV, "System Description" },
{ LLDP_SYSTEM_CAP_TLV, "System Capabilities" },
@@ -89,22 +89,22 @@
/*
* Port ID subtypes
*/
-#define LLDP_PORT_INTF_ALIAS_SUBTYPE 1
-#define LLDP_PORT_PORT_COMP_SUBTYPE 2
-#define LLDP_PORT_MAC_ADDR_SUBTYPE 3
-#define LLDP_PORT_NETWORK_ADDR_SUBTYPE 4
-#define LLDP_PORT_INTF_NAME_SUBTYPE 5
-#define LLDP_PORT_AGENT_CIRC_ID_SUBTYPE 6
-#define LLDP_PORT_LOCAL_SUBTYPE 7
+#define LTCPDUMP_LDP_PORT_INTF_ALIAS_SUBTYPE 1
+#define LTCPDUMP_LDP_PORT_PORT_COMP_SUBTYPE 2
+#define LTCPDUMP_LDP_PORT_MAC_ADDR_SUBTYPE 3
+#define LTCPDUMP_LDP_PORT_NETWORK_ADDR_SUBTYPE 4
+#define LTCPDUMP_LDP_PORT_INTF_NAME_SUBTYPE 5
+#define LTCPDUMP_LDP_PORT_AGENT_CIRC_ID_SUBTYPE 6
+#define LTCPDUMP_LDP_PORT_LOCAL_SUBTYPE 7
static const struct tok lldp_port_subtype_values[] = {
- { LLDP_PORT_INTF_ALIAS_SUBTYPE, "Interface alias"},
- { LLDP_PORT_PORT_COMP_SUBTYPE, "Port component"},
- { LLDP_PORT_MAC_ADDR_SUBTYPE, "MAC address"},
- { LLDP_PORT_NETWORK_ADDR_SUBTYPE, "Network Address"},
- { LLDP_PORT_INTF_NAME_SUBTYPE, "Interface Name"},
- { LLDP_PORT_AGENT_CIRC_ID_SUBTYPE, "Agent circuit ID"},
- { LLDP_PORT_LOCAL_SUBTYPE, "Local"},
+ { LTCPDUMP_LDP_PORT_INTF_ALIAS_SUBTYPE, "Interface alias"},
+ { LTCPDUMP_LDP_PORT_PORT_COMP_SUBTYPE, "Port component"},
+ { LTCPDUMP_LDP_PORT_MAC_ADDR_SUBTYPE, "MAC address"},
+ { LTCPDUMP_LDP_PORT_NETWORK_ADDR_SUBTYPE, "Network Address"},
+ { LTCPDUMP_LDP_PORT_INTF_NAME_SUBTYPE, "Interface Name"},
+ { LTCPDUMP_LDP_PORT_AGENT_CIRC_ID_SUBTYPE, "Agent circuit ID"},
+ { LTCPDUMP_LDP_PORT_LOCAL_SUBTYPE, "Local"},
{ 0, NULL}
};
@@ -1531,7 +1531,7 @@
}
break;
- case LLDP_PORT_ID_TLV:
+ case LTCPDUMP_LDP_PORT_ID_TLV:
if (ndo->ndo_vflag) {
if (tlv_len < 2) {
goto trunc;
@@ -1542,22 +1542,22 @@
subtype);
switch (subtype) {
- case LLDP_PORT_MAC_ADDR_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_MAC_ADDR_SUBTYPE:
if (tlv_len < 1+6) {
goto trunc;
}
ND_PRINT("%s", GET_ETHERADDR_STRING(tptr + 1));
break;
- case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
- case LLDP_PORT_LOCAL_SUBTYPE:
- case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE:
- case LLDP_PORT_INTF_ALIAS_SUBTYPE:
- case LLDP_PORT_PORT_COMP_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
+ case LTCPDUMP_LDP_PORT_LOCAL_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_AGENT_CIRC_ID_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_INTF_ALIAS_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_PORT_COMP_SUBTYPE:
nd_printjnp(ndo, tptr + 1, tlv_len - 1);
break;
- case LLDP_PORT_NETWORK_ADDR_SUBTYPE:
+ case LTCPDUMP_LDP_PORT_NETWORK_ADDR_SUBTYPE:
network_addr = lldp_network_addr_print(ndo, tptr+1, tlv_len-1);
if (network_addr == NULL) {
goto trunc;
@@ -1581,7 +1581,7 @@
}
break;
- case LLDP_PORT_DESCR_TLV:
+ case LTCPDUMP_LDP_PORT_DESCR_TLV:
if (ndo->ndo_vflag) {
ND_PRINT(": ");
nd_printjnp(ndo, tptr, tlv_len);
diff -uNr tcpdump-tcpdump-4.99.4/print-mobility.c tcpdump-for-stellar/print-mobility.c
--- tcpdump-tcpdump-4.99.4/print-mobility.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-mobility.c 2024-10-30 17:34:05.622498702 +0800
@@ -40,7 +40,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
/* Mobility header */
diff -uNr tcpdump-tcpdump-4.99.4/print-mptcp.c tcpdump-for-stellar/print-mptcp.c
--- tcpdump-tcpdump-4.99.4/print-mptcp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-mptcp.c 2024-10-30 17:34:05.622498702 +0800
@@ -46,7 +46,7 @@
#include "extract.h"
#include "addrtoname.h"
-#include "tcp.h"
+#include "print-tcp.h"
#define MPTCP_SUB_CAPABLE 0x0
#define MPTCP_SUB_JOIN 0x1
diff -uNr tcpdump-tcpdump-4.99.4/print-nfs.c tcpdump-for-stellar/print-nfs.c
--- tcpdump-tcpdump-4.99.4/print-nfs.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-nfs.c 2024-10-30 17:34:05.623498702 +0800
@@ -38,8 +38,8 @@
#include "nfs.h"
#include "nfsfh.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "rpc_auth.h"
#include "rpc_msg.h"
@@ -201,19 +201,19 @@
print_nfsaddr(netdissect_options *ndo,
const u_char *bp, const char *s, const char *d)
{
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN];
srcaddr[0] = dstaddr[0] = '\0';
- switch (IP_V((const struct ip *)bp)) {
+ switch (IP_V((const struct tcpdump_ip *)bp)) {
case 4:
- ip = (const struct ip *)bp;
+ ip = (const struct tcpdump_ip *)bp;
strlcpy(srcaddr, GET_IPADDR_STRING(ip->ip_src), sizeof(srcaddr));
strlcpy(dstaddr, GET_IPADDR_STRING(ip->ip_dst), sizeof(dstaddr));
break;
case 6:
- ip6 = (const struct ip6_hdr *)bp;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp;
strlcpy(srcaddr, GET_IP6ADDR_STRING(ip6->ip6_src),
sizeof(srcaddr));
strlcpy(dstaddr, GET_IP6ADDR_STRING(ip6->ip6_dst),
@@ -941,18 +941,18 @@
xid_map_enter(netdissect_options *ndo,
const struct sunrpc_msg *rp, const u_char *bp)
{
- const struct ip *ip = NULL;
- const struct ip6_hdr *ip6 = NULL;
+ const struct tcpdump_ip *ip = NULL;
+ const struct tcpdump_ip6_hdr *ip6 = NULL;
struct xid_map_entry *xmep;
if (!ND_TTEST_4(rp->rm_call.cb_proc))
return (0);
- switch (IP_V((const struct ip *)bp)) {
+ switch (IP_V((const struct tcpdump_ip *)bp)) {
case 4:
- ip = (const struct ip *)bp;
+ ip = (const struct tcpdump_ip *)bp;
break;
case 6:
- ip6 = (const struct ip6_hdr *)bp;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp;
break;
default:
return (1);
@@ -994,8 +994,8 @@
int i;
struct xid_map_entry *xmep;
uint32_t xid;
- const struct ip *ip = (const struct ip *)bp;
- const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp;
+ const struct tcpdump_ip *ip = (const struct tcpdump_ip *)bp;
+ const struct tcpdump_ip6_hdr *ip6 = (const struct tcpdump_ip6_hdr *)bp;
int cmp;
UNALIGNED_MEMCPY(&xid, &rp->rm_xid, sizeof(xmep->xid));
diff -uNr tcpdump-tcpdump-4.99.4/print-pgm.c tcpdump-for-stellar/print-pgm.c
--- tcpdump-tcpdump-4.99.4/print-pgm.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-pgm.c 2024-10-30 17:34:05.625498702 +0800
@@ -26,8 +26,8 @@
#include "addrtoname.h"
#include "addrtostr.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
#include "af.h"
@@ -148,20 +148,20 @@
const u_char *bp2)
{
const struct pgm_header *pgm;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
uint8_t pgm_type_val;
uint16_t sport, dport;
u_int nla_afnum;
char nla_buf[INET6_ADDRSTRLEN];
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
uint8_t opt_type, opt_len;
uint32_t seq, opts_len, len, offset;
ndo->ndo_protocol = "pgm";
pgm = (const struct pgm_header *)bp;
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
else
ip6 = NULL;
if (!ND_TTEST_2(pgm->pgm_dport)) {
diff -uNr tcpdump-tcpdump-4.99.4/print-pim.c tcpdump-for-stellar/print-pim.c
--- tcpdump-tcpdump-4.99.4/print-pim.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-pim.c 2024-10-30 17:34:05.625498702 +0800
@@ -31,8 +31,8 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
#define PIMV1_TYPE_QUERY 0
@@ -657,14 +657,14 @@
pimv2_check_checksum(netdissect_options *ndo, const u_char *bp,
const u_char *bp2, u_int len)
{
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
u_int cksum;
if (!ND_TTEST_LEN(bp, len)) {
/* We don't have all the data. */
return (UNVERIFIED);
}
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
if (IP_V(ip) == 4) {
struct cksum_vec vec[1];
@@ -673,9 +673,9 @@
cksum = in_cksum(vec, 1);
return (cksum ? INCORRECT : CORRECT);
} else if (IP_V(ip) == 6) {
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
cksum = nextproto6_cksum(ndo, ip6, bp, len, len, IPPROTO_PIM);
return (cksum ? INCORRECT : CORRECT);
} else {
@@ -882,7 +882,7 @@
case PIMV2_TYPE_REGISTER:
{
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
if (len < 4)
goto trunc;
@@ -897,7 +897,7 @@
/* encapsulated multicast packet */
if (len == 0)
goto trunc;
- ip = (const struct ip *)bp;
+ ip = (const struct tcpdump_ip *)bp;
switch (IP_V(ip)) {
case 0: /* Null header */
ND_PRINT("IP-Null-header %s > %s",
diff -uNr tcpdump-tcpdump-4.99.4/print-rt6.c tcpdump-for-stellar/print-rt6.c
--- tcpdump-tcpdump-4.99.4/print-rt6.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-rt6.c 2024-10-30 17:34:05.627498702 +0800
@@ -31,21 +31,21 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip6.h"
+#include "tcpdump_ip6.h"
int
rt6_print(netdissect_options *ndo, const u_char *bp, const u_char *bp2 _U_)
{
- const struct ip6_rthdr *dp;
- const struct ip6_rthdr0 *dp0;
- const struct ip6_srh *srh;
+ const struct tcpdump_ip6_rthdr *dp;
+ const struct tcpdump_ip6_rthdr0 *dp0;
+ const struct tcpdump_ip6_srh *srh;
u_int i, len, type;
const u_char *p;
ndo->ndo_protocol = "rt6";
nd_print_protocol_caps(ndo);
- dp = (const struct ip6_rthdr *)bp;
+ dp = (const struct tcpdump_ip6_rthdr *)bp;
len = GET_U_1(dp->ip6r_len);
ND_PRINT(" (len=%u", len); /*)*/
@@ -58,7 +58,7 @@
switch (type) {
case IPV6_RTHDR_TYPE_0:
case IPV6_RTHDR_TYPE_2: /* Mobile IPv6 ID-20 */
- dp0 = (const struct ip6_rthdr0 *)dp;
+ dp0 = (const struct tcpdump_ip6_rthdr0 *)dp;
if (GET_BE_U_4(dp0->ip6r0_reserved) || ndo->ndo_vflag) {
ND_PRINT(", rsv=0x%0x",
@@ -80,7 +80,7 @@
return((GET_U_1(dp0->ip6r0_len) + 1) << 3);
break;
case IPV6_RTHDR_TYPE_4:
- srh = (const struct ip6_srh *)dp;
+ srh = (const struct tcpdump_ip6_srh *)dp;
ND_PRINT(", last-entry=%u", GET_U_1(srh->srh_last_ent));
if (GET_U_1(srh->srh_flags) || ndo->ndo_vflag) {
diff -uNr tcpdump-tcpdump-4.99.4/print-rx.c tcpdump-for-stellar/print-rx.c
--- tcpdump-tcpdump-4.99.4/print-rx.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-rx.c 2024-10-30 17:34:05.628498702 +0800
@@ -47,7 +47,7 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
+#include "tcpdump_ip.h"
#define FS_RX_PORT 7000
#define CB_RX_PORT 7001
@@ -493,9 +493,9 @@
static uint32_t rx_cache_next = 0;
static uint32_t rx_cache_hint = 0;
-static void rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, uint16_t);
+static void rx_cache_insert(netdissect_options *, const u_char *, const struct tcpdump_ip *, uint16_t);
static int rx_cache_find(netdissect_options *, const struct rx_header *,
- const struct ip *, uint16_t, uint32_t *);
+ const struct tcpdump_ip *, uint16_t, uint32_t *);
static void fs_print(netdissect_options *, const u_char *, u_int);
static void fs_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
@@ -597,7 +597,7 @@
* have a chance to print out replies
*/
- rx_cache_insert(ndo, bp, (const struct ip *) bp2, dport);
+ rx_cache_insert(ndo, bp, (const struct tcpdump_ip *) bp2, dport);
switch (dport) {
case FS_RX_PORT: /* AFS file service */
@@ -636,7 +636,7 @@
GET_BE_U_4(rxh->seq) == 1) ||
type == RX_PACKET_TYPE_ABORT) &&
(flags & RX_CLIENT_INITIATED) == 0 &&
- rx_cache_find(ndo, rxh, (const struct ip *) bp2,
+ rx_cache_find(ndo, rxh, (const struct tcpdump_ip *) bp2,
sport, &opcode)) {
switch (sport) {
@@ -684,7 +684,7 @@
static void
rx_cache_insert(netdissect_options *ndo,
- const u_char *bp, const struct ip *ip, uint16_t dport)
+ const u_char *bp, const struct tcpdump_ip *ip, uint16_t dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
@@ -714,7 +714,7 @@
static int
rx_cache_find(netdissect_options *ndo, const struct rx_header *rxh,
- const struct ip *ip, uint16_t sport, uint32_t *opcode)
+ const struct tcpdump_ip *ip, uint16_t sport, uint32_t *opcode)
{
uint32_t i;
struct rx_cache_entry *rxent;
diff -uNr tcpdump-tcpdump-4.99.4/print-sctp.c tcpdump-for-stellar/print-sctp.c
--- tcpdump-tcpdump-4.99.4/print-sctp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-sctp.c 2024-10-30 17:34:05.628498702 +0800
@@ -44,8 +44,8 @@
#include "netdissect.h"
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
/* Definitions from:
*
@@ -455,8 +455,8 @@
{
u_int sctpPacketLengthRemaining;
const struct sctpHeader *sctpPktHdr;
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
uint8_t chunkID;
u_short sourcePort, destPort;
u_int chunkCount;
@@ -478,9 +478,9 @@
sourcePort = GET_BE_U_2(sctpPktHdr->source);
destPort = GET_BE_U_2(sctpPktHdr->destination);
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
else
ip6 = NULL;
diff -uNr tcpdump-tcpdump-4.99.4/print-sl.c tcpdump-for-stellar/print-sl.c
--- tcpdump-tcpdump-4.99.4/print-sl.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-sl.c 2024-10-30 17:34:05.628498702 +0800
@@ -31,8 +31,8 @@
#include "netdissect.h"
#include "extract.h"
-#include "ip.h"
-#include "tcp.h"
+#include "tcpdump_ip.h"
+#include "print-tcp.h"
#include "slcompress.h"
/*
@@ -51,15 +51,15 @@
static u_int lastlen[2][256];
static u_int lastconn = 255;
-static void sliplink_print(netdissect_options *, const u_char *, const struct ip *, u_int);
-static void compressed_sl_print(netdissect_options *, const u_char *, const struct ip *, u_int, int);
+static void sliplink_print(netdissect_options *, const u_char *, const struct tcpdump_ip *, u_int);
+static void compressed_sl_print(netdissect_options *, const u_char *, const struct tcpdump_ip *, u_int, int);
void
sl_if_print(netdissect_options *ndo,
const struct pcap_pkthdr *h, const u_char *p)
{
u_int length = h->len;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
ndo->ndo_protocol = "slip";
ND_TCHECK_LEN(p, SLIP_HDRLEN);
@@ -67,7 +67,7 @@
length -= SLIP_HDRLEN;
- ip = (const struct ip *)(p + SLIP_HDRLEN);
+ ip = (const struct tcpdump_ip *)(p + SLIP_HDRLEN);
if (ndo->ndo_eflag)
sliplink_print(ndo, p, ip, length);
@@ -89,7 +89,7 @@
const struct pcap_pkthdr *h, const u_char *p)
{
u_int length = h->len;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
ndo->ndo_protocol = "slip_bsdos";
ND_TCHECK_LEN(p, SLIP_HDRLEN);
@@ -97,7 +97,7 @@
length -= SLIP_HDRLEN;
- ip = (const struct ip *)(p + SLIP_HDRLEN);
+ ip = (const struct tcpdump_ip *)(p + SLIP_HDRLEN);
#ifdef notdef
if (ndo->ndo_eflag)
@@ -109,7 +109,7 @@
static void
sliplink_print(netdissect_options *ndo,
- const u_char *p, const struct ip *ip,
+ const u_char *p, const struct tcpdump_ip *ip,
u_int length)
{
int dir;
@@ -143,7 +143,7 @@
* Get it from the link layer since sl_uncompress_tcp()
* has restored the IP header copy to IPPROTO_TCP.
*/
- lastconn = GET_U_1(((const struct ip *)(p + SLX_CHDR))->ip_p);
+ lastconn = GET_U_1(((const struct tcpdump_ip *)(p + SLX_CHDR))->ip_p);
ND_PRINT("utcp %u: ", lastconn);
if (dir == -1) {
/* Direction is bogus, don't use it */
@@ -204,7 +204,7 @@
static void
compressed_sl_print(netdissect_options *ndo,
- const u_char *chdr, const struct ip *ip,
+ const u_char *chdr, const struct tcpdump_ip *ip,
u_int length, int dir)
{
const u_char *cp = chdr;
diff -uNr tcpdump-tcpdump-4.99.4/print-someip.c tcpdump-for-stellar/print-someip.c
--- tcpdump-tcpdump-4.99.4/print-someip.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-someip.c 2024-10-30 17:34:05.631498702 +0800
@@ -22,7 +22,7 @@
#include "netdissect-stdinc.h"
#include "netdissect.h"
#include "extract.h"
-#include "udp.h"
+#include "print-udp.h"
/*
* SOMEIP Header (R19-11)
diff -uNr tcpdump-tcpdump-4.99.4/print-sunrpc.c tcpdump-for-stellar/print-sunrpc.c
--- tcpdump-tcpdump-4.99.4/print-sunrpc.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-sunrpc.c 2024-10-30 17:34:05.631498702 +0800
@@ -57,8 +57,8 @@
#include "addrtoname.h"
#include "extract.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "rpc_auth.h"
#include "rpc_msg.h"
@@ -159,8 +159,8 @@
u_int length, const u_char *bp2)
{
const struct sunrpc_msg *rp;
- const struct ip *ip;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip *ip;
+ const struct tcpdump_ip6_hdr *ip6;
uint32_t x;
char srcid[20], dstid[20]; /*fits 32bit*/
@@ -178,15 +178,15 @@
snprintf(dstid, sizeof(dstid), "0x%x", SUNRPC_PMAPPORT);
}
- switch (IP_V((const struct ip *)bp2)) {
+ switch (IP_V((const struct tcpdump_ip *)bp2)) {
case 4:
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
ND_PRINT("%s.%s > %s.%s: %u",
GET_IPADDR_STRING(ip->ip_src), srcid,
GET_IPADDR_STRING(ip->ip_dst), dstid, length);
break;
case 6:
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
ND_PRINT("%s.%s > %s.%s: %u",
GET_IP6ADDR_STRING(ip6->ip6_src), srcid,
GET_IP6ADDR_STRING(ip6->ip6_dst), dstid, length);
diff -uNr tcpdump-tcpdump-4.99.4/print-tcp.c tcpdump-for-stellar/print-tcp.c
--- tcpdump-tcpdump-4.99.4/print-tcp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-tcp.c 2024-10-30 17:34:05.631498702 +0800
@@ -25,6 +25,12 @@
/* \summary: TCP printer */
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wall"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wall"
+#endif
+
#ifndef lint
#else
__RCSID("$NetBSD: print-tcp.c,v 1.8 2007/07/24 11:53:48 drochner Exp $");
@@ -45,10 +51,10 @@
#include "diag-control.h"
-#include "tcp.h"
+#include "print-tcp.h"
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
#include "rpc_auth.h"
#include "rpc_msg.h"
@@ -56,9 +62,8 @@
#ifdef HAVE_LIBCRYPTO
#include <openssl/md5.h>
#include "signature.h"
-
static int tcp_verify_signature(netdissect_options *ndo,
- const struct ip *ip, const struct tcphdr *tp,
+ const struct tcpdump_ip *ip, const struct tcphdr *tp,
const u_char *data, u_int length, const u_char *rcvsig);
#endif
@@ -66,29 +71,35 @@
static void print_tcp_fastopen_option(netdissect_options *ndo, const u_char *cp,
u_int datalen, int exp);
-#define MAX_RST_DATA_LEN 30
+#define MAX_RST_DATA_LEN 30
+/* For source or destination ports tests (UDP, TCP, ...) */
+#define IS_SRC_OR_DST_TCPPORT(p) (sport == (p) || dport == (p))
-struct tha {
+struct tha
+{
nd_ipv4 src;
nd_ipv4 dst;
u_int port;
};
-struct tcp_seq_hash {
+struct tcp_seq_hash
+{
struct tcp_seq_hash *nxt;
struct tha addr;
uint32_t seq;
uint32_t ack;
};
-struct tha6 {
+struct tha6
+{
nd_ipv6 src;
nd_ipv6 dst;
u_int port;
};
-struct tcp_seq_hash6 {
+struct tcp_seq_hash6
+{
struct tcp_seq_hash6 *nxt;
struct tha6 addr;
uint32_t seq;
@@ -104,43 +115,41 @@
static struct tcp_seq_hash6 tcp_seq_hash6[TSEQ_HASHSIZE];
static const struct tok tcp_flag_values[] = {
- { TH_FIN, "F" },
- { TH_SYN, "S" },
- { TH_RST, "R" },
- { TH_PUSH, "P" },
- { TH_ACK, "." },
- { TH_URG, "U" },
- { TH_ECNECHO, "E" },
- { TH_CWR, "W" },
- { 0, NULL }
-};
+ {TH_FIN, "F"},
+ {TH_SYN, "S"},
+ {TH_RST, "R"},
+ {TH_PUSH, "P"},
+ {TH_ACK, "."},
+ {TH_URG, "U"},
+ {TH_ECNECHO, "E"},
+ {TH_CWR, "W"},
+ {0, NULL}};
static const struct tok tcp_option_values[] = {
- { TCPOPT_EOL, "eol" },
- { TCPOPT_NOP, "nop" },
- { TCPOPT_MAXSEG, "mss" },
- { TCPOPT_WSCALE, "wscale" },
- { TCPOPT_SACKOK, "sackOK" },
- { TCPOPT_SACK, "sack" },
- { TCPOPT_ECHO, "echo" },
- { TCPOPT_ECHOREPLY, "echoreply" },
- { TCPOPT_TIMESTAMP, "TS" },
- { TCPOPT_CC, "cc" },
- { TCPOPT_CCNEW, "ccnew" },
- { TCPOPT_CCECHO, "" },
- { TCPOPT_SIGNATURE, "md5" },
- { TCPOPT_SCPS, "scps" },
- { TCPOPT_UTO, "uto" },
- { TCPOPT_TCPAO, "tcp-ao" },
- { TCPOPT_MPTCP, "mptcp" },
- { TCPOPT_FASTOPEN, "tfo" },
- { TCPOPT_EXPERIMENT2, "exp" },
- { 0, NULL }
-};
+ {TCPOPT_EOL, "eol"},
+ {TCPOPT_NOP, "nop"},
+ {TCPOPT_MAXSEG, "mss"},
+ {TCPOPT_WSCALE, "wscale"},
+ {TCPOPT_SACKOK, "sackOK"},
+ {TCPOPT_SACK, "sack"},
+ {TCPOPT_ECHO, "echo"},
+ {TCPOPT_ECHOREPLY, "echoreply"},
+ {TCPOPT_TIMESTAMP, "TS"},
+ {TCPOPT_CC, "cc"},
+ {TCPOPT_CCNEW, "ccnew"},
+ {TCPOPT_CCECHO, ""},
+ {TCPOPT_SIGNATURE, "md5"},
+ {TCPOPT_SCPS, "scps"},
+ {TCPOPT_UTO, "uto"},
+ {TCPOPT_TCPAO, "tcp-ao"},
+ {TCPOPT_MPTCP, "mptcp"},
+ {TCPOPT_FASTOPEN, "tfo"},
+ {TCPOPT_EXPERIMENT2, "exp"},
+ {0, NULL}};
static uint16_t
tcp_cksum(netdissect_options *ndo,
- const struct ip *ip,
+ const struct tcpdump_ip *ip,
const struct tcphdr *tp,
u_int len)
{
@@ -150,7 +159,7 @@
static uint16_t
tcp6_cksum(netdissect_options *ndo,
- const struct ip6_hdr *ip6,
+ const struct tcpdump_ip6_hdr *ip6,
const struct tcphdr *tp,
u_int len)
{
@@ -158,13 +167,12 @@
IPPROTO_TCP);
}
-void
-tcp_print(netdissect_options *ndo,
- const u_char *bp, u_int length,
- const u_char *bp2, int fragmented)
+void tcp_print(netdissect_options *ndo,
+ const u_char *bp, u_int length,
+ const u_char *bp2, int fragmented)
{
const struct tcphdr *tp;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
u_char flags;
u_int hlen;
char ch;
@@ -173,23 +181,27 @@
u_int utoval;
uint16_t magic;
int rev;
- const struct ip6_hdr *ip6;
- u_int header_len; /* Header length in bytes */
+ const struct tcpdump_ip6_hdr *ip6;
+ u_int header_len; /* Header length in bytes */
ndo->ndo_protocol = "tcp";
tp = (const struct tcphdr *)bp;
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
else
ip6 = NULL;
ch = '\0';
- if (!ND_TTEST_2(tp->th_dport)) {
- if (ip6) {
+ if (!ND_TTEST_2(tp->th_dport))
+ {
+ if (ip6)
+ {
ND_PRINT("%s > %s:",
GET_IP6ADDR_STRING(ip6->ip6_src),
GET_IP6ADDR_STRING(ip6->ip6_dst));
- } else {
+ }
+ else
+ {
ND_PRINT("%s > %s:",
GET_IPADDR_STRING(ip->ip_src),
GET_IPADDR_STRING(ip->ip_dst));
@@ -201,25 +213,34 @@
sport = GET_BE_U_2(tp->th_sport);
dport = GET_BE_U_2(tp->th_dport);
- if (ip6) {
- if (GET_U_1(ip6->ip6_nxt) == IPPROTO_TCP) {
+ if (ip6)
+ {
+ if (GET_U_1(ip6->ip6_nxt) == IPPROTO_TCP)
+ {
ND_PRINT("%s.%s > %s.%s: ",
GET_IP6ADDR_STRING(ip6->ip6_src),
tcpport_string(ndo, sport),
GET_IP6ADDR_STRING(ip6->ip6_dst),
tcpport_string(ndo, dport));
- } else {
+ }
+ else
+ {
ND_PRINT("%s > %s: ",
tcpport_string(ndo, sport), tcpport_string(ndo, dport));
}
- } else {
- if (GET_U_1(ip->ip_p) == IPPROTO_TCP) {
+ }
+ else
+ {
+ if (GET_U_1(ip->ip_p) == IPPROTO_TCP)
+ {
ND_PRINT("%s.%s > %s.%s: ",
GET_IPADDR_STRING(ip->ip_src),
tcpport_string(ndo, sport),
GET_IPADDR_STRING(ip->ip_dst),
tcpport_string(ndo, dport));
- } else {
+ }
+ else
+ {
ND_PRINT("%s > %s: ",
tcpport_string(ndo, sport), tcpport_string(ndo, dport));
}
@@ -229,7 +250,8 @@
hlen = TH_OFF(tp) * 4;
- if (hlen < sizeof(*tp)) {
+ if (hlen < sizeof(*tp))
+ {
ND_PRINT(" tcp %u [bad hdr length %u - too short, < %zu]",
length - hlen, hlen, sizeof(*tp));
return;
@@ -240,9 +262,11 @@
win = GET_BE_U_2(tp->th_win);
urp = GET_BE_U_2(tp->th_urp);
- if (ndo->ndo_qflag) {
+ if (ndo->ndo_qflag)
+ {
ND_PRINT("tcp %u", length - hlen);
- if (hlen > length) {
+ if (hlen > length)
+ {
ND_PRINT(" [bad hdr length %u - too long, > %u]",
hlen, length);
}
@@ -252,7 +276,8 @@
flags = GET_U_1(tp->th_flags);
ND_PRINT("Flags [%s]", bittok2str_nosep(tcp_flag_values, "none", flags));
- if (!ndo->ndo_Sflag && (flags & TH_ACK)) {
+ if (!ndo->ndo_Sflag && (flags & TH_ACK))
+ {
/*
* Find (or record) the initial sequence numbers for
* this conversation. (we pick an arbitrary
@@ -260,7 +285,8 @@
* both directions).
*/
rev = 0;
- if (ip6) {
+ if (ip6)
+ {
struct tcp_seq_hash6 *th;
struct tcp_seq_hash6 *tcp_seq_hash;
const void *src, *dst;
@@ -271,15 +297,19 @@
dst = (const void *)ip6->ip6_dst;
if (sport > dport)
rev = 1;
- else if (sport == dport) {
+ else if (sport == dport)
+ {
if (UNALIGNED_MEMCMP(src, dst, sizeof(ip6->ip6_dst)) > 0)
rev = 1;
}
- if (rev) {
+ if (rev)
+ {
UNALIGNED_MEMCPY(&tha.src, dst, sizeof(ip6->ip6_dst));
UNALIGNED_MEMCPY(&tha.dst, src, sizeof(ip6->ip6_src));
tha.port = ((u_int)dport) << 16 | sport;
- } else {
+ }
+ else
+ {
UNALIGNED_MEMCPY(&tha.dst, dst, sizeof(ip6->ip6_dst));
UNALIGNED_MEMCPY(&tha.src, src, sizeof(ip6->ip6_src));
tha.port = ((u_int)sport) << 16 | dport;
@@ -291,24 +321,28 @@
sizeof(th->addr)) == 0)
break;
- if (!th->nxt || (flags & TH_SYN)) {
+ if (!th->nxt || (flags & TH_SYN))
+ {
/* didn't find it or new conversation */
/* calloc() return used by the 'tcp_seq_hash6'
hash table: do not free() */
- if (th->nxt == NULL) {
+ if (th->nxt == NULL)
+ {
th->nxt = (struct tcp_seq_hash6 *)
- calloc(1, sizeof(*th));
+ calloc(1, sizeof(*th));
if (th->nxt == NULL)
(*ndo->ndo_error)(ndo,
- S_ERR_ND_MEM_ALLOC,
- "%s: calloc", __func__);
+ S_ERR_ND_MEM_ALLOC,
+ "%s: calloc", __func__);
}
th->addr = tha;
if (rev)
th->ack = seq, th->seq = ack - 1;
else
th->seq = seq, th->ack = ack - 1;
- } else {
+ }
+ else
+ {
if (rev)
seq -= th->ack, ack -= th->seq;
else
@@ -317,7 +351,9 @@
thseq = th->seq;
thack = th->ack;
- } else {
+ }
+ else
+ {
struct tcp_seq_hash *th;
struct tcp_seq_hash *tcp_seq_hash;
struct tha tha;
@@ -325,17 +361,21 @@
tcp_seq_hash = tcp_seq_hash4;
if (sport > dport)
rev = 1;
- else if (sport == dport) {
+ else if (sport == dport)
+ {
if (UNALIGNED_MEMCMP(ip->ip_src, ip->ip_dst, sizeof(ip->ip_dst)) > 0)
rev = 1;
}
- if (rev) {
+ if (rev)
+ {
UNALIGNED_MEMCPY(&tha.src, ip->ip_dst,
sizeof(ip->ip_dst));
UNALIGNED_MEMCPY(&tha.dst, ip->ip_src,
sizeof(ip->ip_src));
tha.port = ((u_int)dport) << 16 | sport;
- } else {
+ }
+ else
+ {
UNALIGNED_MEMCPY(&tha.dst, ip->ip_dst,
sizeof(ip->ip_dst));
UNALIGNED_MEMCPY(&tha.src, ip->ip_src,
@@ -349,24 +389,28 @@
sizeof(th->addr)) == 0)
break;
- if (!th->nxt || (flags & TH_SYN)) {
+ if (!th->nxt || (flags & TH_SYN))
+ {
/* didn't find it or new conversation */
/* calloc() return used by the 'tcp_seq_hash4'
hash table: do not free() */
- if (th->nxt == NULL) {
+ if (th->nxt == NULL)
+ {
th->nxt = (struct tcp_seq_hash *)
- calloc(1, sizeof(*th));
+ calloc(1, sizeof(*th));
if (th->nxt == NULL)
(*ndo->ndo_error)(ndo,
- S_ERR_ND_MEM_ALLOC,
- "%s: calloc", __func__);
+ S_ERR_ND_MEM_ALLOC,
+ "%s: calloc", __func__);
}
th->addr = tha;
if (rev)
th->ack = seq, th->seq = ack - 1;
else
th->seq = seq, th->ack = ack - 1;
- } else {
+ }
+ else
+ {
if (rev)
seq -= th->ack, ack -= th->seq;
else
@@ -376,58 +420,69 @@
thseq = th->seq;
thack = th->ack;
}
- } else {
+ }
+ else
+ {
/*fool gcc*/
thseq = thack = rev = 0;
}
- if (hlen > length) {
+ if (hlen > length)
+ {
ND_PRINT(" [bad hdr length %u - too long, > %u]",
hlen, length);
return;
}
- if (ndo->ndo_vflag && !ndo->ndo_Kflag && !fragmented) {
+ if (ndo->ndo_vflag && !ndo->ndo_Kflag && !fragmented)
+ {
/* Check the checksum, if possible. */
uint16_t sum, tcp_sum;
- if (IP_V(ip) == 4) {
- if (ND_TTEST_LEN(tp->th_sport, length)) {
+ if (IP_V(ip) == 4)
+ {
+ if (ND_TTEST_LEN(tp->th_sport, length))
+ {
sum = tcp_cksum(ndo, ip, tp, length);
tcp_sum = GET_BE_U_2(tp->th_sum);
ND_PRINT(", cksum 0x%04x", tcp_sum);
if (sum != 0)
ND_PRINT(" (incorrect -> 0x%04x)",
- in_cksum_shouldbe(tcp_sum, sum));
+ in_cksum_shouldbe(tcp_sum, sum));
else
ND_PRINT(" (correct)");
}
- } else if (IP_V(ip) == 6) {
- if (ND_TTEST_LEN(tp->th_sport, length)) {
+ }
+ else if (IP_V(ip) == 6)
+ {
+ if (ND_TTEST_LEN(tp->th_sport, length))
+ {
sum = tcp6_cksum(ndo, ip6, tp, length);
tcp_sum = GET_BE_U_2(tp->th_sum);
ND_PRINT(", cksum 0x%04x", tcp_sum);
if (sum != 0)
ND_PRINT(" (incorrect -> 0x%04x)",
- in_cksum_shouldbe(tcp_sum, sum));
+ in_cksum_shouldbe(tcp_sum, sum));
else
ND_PRINT(" (correct)");
-
}
}
}
length -= hlen;
- if (ndo->ndo_vflag > 1 || length > 0 || flags & (TH_SYN | TH_FIN | TH_RST)) {
+ if (ndo->ndo_vflag > 1 || length > 0 || flags & (TH_SYN | TH_FIN | TH_RST))
+ {
ND_PRINT(", seq %u", seq);
- if (length > 0) {
+ if (length > 0)
+ {
ND_PRINT(":%u", seq + length);
}
}
- if (flags & TH_ACK) {
+ if (flags & TH_ACK)
+ {
ND_PRINT(", ack %u", ack);
}
@@ -438,7 +493,8 @@
/*
* Handle any options.
*/
- if (hlen > sizeof(*tp)) {
+ if (hlen > sizeof(*tp))
+ {
const u_char *cp;
u_int i, opt, datalen;
u_int len;
@@ -446,30 +502,37 @@
hlen -= sizeof(*tp);
cp = (const u_char *)tp + sizeof(*tp);
ND_PRINT(", options [");
- while (hlen > 0) {
+ while (hlen > 0)
+ {
if (ch != '\0')
ND_PRINT("%c", ch);
opt = GET_U_1(cp);
cp++;
if (ZEROLENOPT(opt))
len = 1;
- else {
+ else
+ {
len = GET_U_1(cp);
- cp++; /* total including type, len */
+ cp++; /* total including type, len */
if (len < 2 || len > hlen)
goto bad;
- --hlen; /* account for length byte */
+ --hlen; /* account for length byte */
}
- --hlen; /* account for type byte */
+ --hlen; /* account for type byte */
datalen = 0;
/* Bail if "l" bytes of data are not left or were not captured */
-#define LENCHECK(l) { if ((l) > hlen) goto bad; ND_TCHECK_LEN(cp, l); }
-
+#define LENCHECK(l) \
+ { \
+ if ((l) > hlen) \
+ goto bad; \
+ ND_TCHECK_LEN(cp, l); \
+ }
ND_PRINT("%s", tok2str(tcp_option_values, "unknown-%u", opt));
- switch (opt) {
+ switch (opt)
+ {
case TCPOPT_MAXSEG:
datalen = 2;
@@ -485,21 +548,28 @@
case TCPOPT_SACK:
datalen = len - 2;
- if (datalen % 8 != 0) {
+ if (datalen % 8 != 0)
+ {
ND_PRINT(" invalid sack");
- } else {
+ }
+ else
+ {
uint32_t s, e;
ND_PRINT(" %u ", datalen / 8);
- for (i = 0; i < datalen; i += 8) {
+ for (i = 0; i < datalen; i += 8)
+ {
LENCHECK(i + 4);
s = GET_BE_U_4(cp + i);
LENCHECK(i + 8);
e = GET_BE_U_4(cp + i + 4);
- if (rev) {
+ if (rev)
+ {
s -= thseq;
e -= thseq;
- } else {
+ }
+ else
+ {
s -= thack;
e -= thack;
}
@@ -527,8 +597,8 @@
datalen = 8;
LENCHECK(datalen);
ND_PRINT(" val %u ecr %u",
- GET_BE_U_4(cp),
- GET_BE_U_4(cp + 4));
+ GET_BE_U_4(cp),
+ GET_BE_U_4(cp + 4));
break;
case TCPOPT_SIGNATURE:
@@ -537,7 +607,8 @@
ND_PRINT(" ");
#ifdef HAVE_LIBCRYPTO
switch (tcp_verify_signature(ndo, ip, tp,
- bp + TH_OFF(tp) * 4, length, cp)) {
+ bp + TH_OFF(tp) * 4, length, cp))
+ {
case SIGNATURE_VALID:
ND_PRINT("valid");
@@ -574,17 +645,22 @@
* (This includes the Kind and Length fields already processed
* at this point.)
*/
- if (datalen < 2) {
+ if (datalen < 2)
+ {
nd_print_invalid(ndo);
- } else {
+ }
+ else
+ {
LENCHECK(1);
ND_PRINT(" keyid %u", GET_U_1(cp));
LENCHECK(2);
ND_PRINT(" rnextkeyid %u",
GET_U_1(cp + 1));
- if (datalen > 2) {
+ if (datalen > 2)
+ {
ND_PRINT(" mac 0x");
- for (i = 2; i < datalen; i++) {
+ for (i = 2; i < datalen; i++)
+ {
LENCHECK(i + 1);
ND_PRINT("%02x",
GET_U_1(cp + i));
@@ -615,7 +691,7 @@
break;
case TCPOPT_MPTCP:
- {
+ {
const u_char *snapend_save;
int ret;
@@ -636,7 +712,7 @@
if (!ret)
goto bad;
break;
- }
+ }
case TCPOPT_FASTOPEN:
datalen = len - 2;
@@ -654,7 +730,8 @@
magic = GET_BE_U_2(cp);
ND_PRINT("-");
- switch(magic) {
+ switch (magic)
+ {
case 0xf989: /* TCP Fast Open RFC 7413 */
print_tcp_fastopen_option(ndo, cp + 2, datalen - 2, TRUE);
@@ -671,7 +748,8 @@
datalen = len - 2;
if (datalen)
ND_PRINT(" 0x");
- for (i = 0; i < datalen; ++i) {
+ for (i = 0; i < datalen; ++i)
+ {
LENCHECK(i + 1);
ND_PRINT("%02x", GET_U_1(cp + i));
}
@@ -683,9 +761,9 @@
hlen -= datalen;
/* Check specification against observed length */
- ++datalen; /* option octet */
+ ++datalen; /* option octet */
if (!ZEROLENOPT(opt))
- ++datalen; /* size octet */
+ ++datalen; /* size octet */
if (datalen != len)
ND_PRINT("[len %u]", len);
ch = ',';
@@ -711,19 +789,23 @@
* Do a bounds check before decoding the payload.
* At least the header data is required.
*/
- if (!ND_TTEST_LEN(bp, header_len)) {
+ if (!ND_TTEST_LEN(bp, header_len))
+ {
ND_PRINT(" [remaining caplen(%u) < header length(%u)]",
ND_BYTES_AVAILABLE_AFTER(bp), header_len);
nd_trunc_longjmp(ndo);
}
bp += header_len;
- if ((flags & TH_RST) && ndo->ndo_vflag) {
+ if ((flags & TH_RST) && ndo->ndo_vflag)
+ {
print_tcp_rst_data(ndo, bp, length);
return;
}
- if (ndo->ndo_packettype) {
- switch (ndo->ndo_packettype) {
+ if (ndo->ndo_packettype)
+ {
+ switch (ndo->ndo_packettype)
+ {
case PT_ZMTP1:
zmtp1_print(ndo, bp, length);
break;
@@ -738,52 +820,107 @@
return;
}
- if (IS_SRC_OR_DST_PORT(TELNET_PORT)) {
+ if (IS_SRC_OR_DST_TCPPORT(TELNET_PORT))
+ {
telnet_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(SMTP_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(SMTP_PORT))
+ {
ND_PRINT(": ");
smtp_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(WHOIS_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(WHOIS_PORT))
+ {
ND_PRINT(": ");
whois_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(BGP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(BGP_PORT))
+ {
bgp_print(ndo, bp, length);
- else if (IS_SRC_OR_DST_PORT(PPTP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(PPTP_PORT))
+ {
pptp_print(ndo, bp);
- else if (IS_SRC_OR_DST_PORT(REDIS_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(REDIS_PORT))
+ {
resp_print(ndo, bp, length);
- else if (IS_SRC_OR_DST_PORT(SSH_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(SSH_PORT))
+ {
ssh_print(ndo, bp, length);
+ return;
+ }
#ifdef ENABLE_SMB
- else if (IS_SRC_OR_DST_PORT(NETBIOS_SSN_PORT))
+ if (IS_SRC_OR_DST_TCPPORT(NETBIOS_SSN_PORT))
+ {
nbt_tcp_print(ndo, bp, length);
- else if (IS_SRC_OR_DST_PORT(SMB_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(SMB_PORT))
+ {
smb_tcp_print(ndo, bp, length);
+ return;
+ }
#endif
- else if (IS_SRC_OR_DST_PORT(BEEP_PORT))
+ if (IS_SRC_OR_DST_TCPPORT(BEEP_PORT))
+ {
beep_print(ndo, bp, length);
- else if (IS_SRC_OR_DST_PORT(OPENFLOW_PORT_OLD) || IS_SRC_OR_DST_PORT(OPENFLOW_PORT_IANA))
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(OPENFLOW_PORT_OLD) || IS_SRC_OR_DST_TCPPORT(OPENFLOW_PORT_IANA))
+ {
openflow_print(ndo, bp, length);
- else if (IS_SRC_OR_DST_PORT(FTP_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(FTP_PORT))
+ {
ND_PRINT(": ");
ftp_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(HTTP_PORT) || IS_SRC_OR_DST_PORT(HTTP_PORT_ALT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(HTTP_PORT) || IS_SRC_OR_DST_TCPPORT(HTTP_PORT_ALT))
+ {
ND_PRINT(": ");
http_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(RTSP_PORT) || IS_SRC_OR_DST_PORT(RTSP_PORT_ALT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(RTSP_PORT) || IS_SRC_OR_DST_TCPPORT(RTSP_PORT_ALT))
+ {
ND_PRINT(": ");
rtsp_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(NAMESERVER_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(TCPDUMP_NAMESERVER_TCP_PORT))
+ {
/* over_tcp: TRUE, is_mdns: FALSE */
domain_print(ndo, bp, length, TRUE, FALSE);
- } else if (IS_SRC_OR_DST_PORT(MSDP_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(MSDP_PORT))
+ {
msdp_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(RPKI_RTR_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(RPKI_RTR_PORT))
+ {
rpki_rtr_print(ndo, bp, length);
- } else if (IS_SRC_OR_DST_PORT(LDP_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_TCPPORT(TCPDUMP_LDP_PORT))
+ {
ldp_print(ndo, bp, length);
- } else if ((IS_SRC_OR_DST_PORT(NFS_PORT)) &&
- length >= 4 && ND_TTEST_4(bp)) {
+ return;
+ }
+ if ((IS_SRC_OR_DST_TCPPORT(NFS_PORT)) &&
+ length >= 4 && ND_TTEST_4(bp))
+ {
/*
* If data present, header length valid, and NFS port used,
* assume NFS.
@@ -795,24 +932,28 @@
enum sunrpc_msg_type direction;
fraglen = GET_BE_U_4(bp) & 0x7FFFFFFF;
- if (fraglen > (length) - 4)
- fraglen = (length) - 4;
+ if (fraglen > (length)-4)
+ fraglen = (length)-4;
rp = (const struct sunrpc_msg *)(bp + 4);
- if (ND_TTEST_4(rp->rm_direction)) {
- direction = (enum sunrpc_msg_type) GET_BE_U_4(rp->rm_direction);
- if (dport == NFS_PORT && direction == SUNRPC_CALL) {
+ if (ND_TTEST_4(rp->rm_direction))
+ {
+ direction = (enum sunrpc_msg_type)GET_BE_U_4(rp->rm_direction);
+ if (dport == NFS_PORT && direction == SUNRPC_CALL)
+ {
ND_PRINT(": NFS request xid %u ",
GET_BE_U_4(rp->rm_xid));
nfsreq_noaddr_print(ndo, (const u_char *)rp, fraglen, (const u_char *)ip);
return;
}
- if (sport == NFS_PORT && direction == SUNRPC_REPLY) {
+ if (sport == NFS_PORT && direction == SUNRPC_REPLY)
+ {
ND_PRINT(": NFS reply xid %u ",
GET_BE_U_4(rp->rm_xid));
nfsreply_noaddr_print(ndo, (const u_char *)rp, fraglen, (const u_char *)ip);
return;
}
}
+ return;
}
return;
@@ -849,12 +990,14 @@
u_char c;
ND_PRINT(ND_TTEST_LEN(sp, length) ? " [RST" : " [!RST");
- if (length > MAX_RST_DATA_LEN) {
- length = MAX_RST_DATA_LEN; /* can use -X for longer */
- ND_PRINT("+"); /* indicate we truncate */
+ if (length > MAX_RST_DATA_LEN)
+ {
+ length = MAX_RST_DATA_LEN; /* can use -X for longer */
+ ND_PRINT("+"); /* indicate we truncate */
}
ND_PRINT(" ");
- while (length && sp < ndo->ndo_snapend) {
+ while (length && sp < ndo->ndo_snapend)
+ {
c = GET_U_1(sp);
sp++;
fn_print_char(ndo, c);
@@ -872,14 +1015,20 @@
if (exp)
ND_PRINT("tfo");
- if (datalen == 0) {
+ if (datalen == 0)
+ {
/* Fast Open Cookie Request */
ND_PRINT(" cookiereq");
- } else {
+ }
+ else
+ {
/* Fast Open Cookie */
- if (datalen % 2 != 0 || datalen < 4 || datalen > 16) {
+ if (datalen % 2 != 0 || datalen < 4 || datalen > 16)
+ {
nd_print_invalid(ndo);
- } else {
+ }
+ else
+ {
ND_PRINT(" cookie ");
for (i = 0; i < datalen; ++i)
ND_PRINT("%02x", GET_U_1(cp + i));
@@ -891,7 +1040,7 @@
DIAG_OFF_DEPRECATION
static int
tcp_verify_signature(netdissect_options *ndo,
- const struct ip *ip, const struct tcphdr *tp,
+ const struct tcpdump_ip *ip, const struct tcphdr *tp,
const u_char *data, u_int length, const u_char *rcvsig)
{
struct tcphdr tp1;
@@ -899,18 +1048,20 @@
char zero_proto = 0;
MD5_CTX ctx;
uint16_t savecsum, tlen;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
uint32_t len32;
uint8_t nxt;
- if (data + length > ndo->ndo_snapend) {
+ if (data + length > ndo->ndo_snapend)
+ {
ND_PRINT("snaplen too short, ");
return (CANT_CHECK_SIGNATURE);
}
tp1 = *tp;
- if (ndo->ndo_sigsecret == NULL) {
+ if (ndo->ndo_sigsecret == NULL)
+ {
ND_PRINT("shared secret not supplied with -M, ");
return (CANT_CHECK_SIGNATURE);
}
@@ -919,7 +1070,8 @@
/*
* Step 1: Update MD5 hash with IP pseudo-header.
*/
- if (IP_V(ip) == 4) {
+ if (IP_V(ip) == 4)
+ {
MD5_Update(&ctx, (const char *)&ip->ip_src, sizeof(ip->ip_src));
MD5_Update(&ctx, (const char *)&ip->ip_dst, sizeof(ip->ip_dst));
MD5_Update(&ctx, (const char *)&zero_proto, sizeof(zero_proto));
@@ -927,8 +1079,10 @@
tlen = GET_BE_U_2(ip->ip_len) - IP_HL(ip) * 4;
tlen = htons(tlen);
MD5_Update(&ctx, (const char *)&tlen, sizeof(tlen));
- } else if (IP_V(ip) == 6) {
- ip6 = (const struct ip6_hdr *)ip;
+ }
+ else if (IP_V(ip) == 6)
+ {
+ ip6 = (const struct tcpdump_ip6_hdr *)ip;
MD5_Update(&ctx, (const char *)&ip6->ip6_src, sizeof(ip6->ip6_src));
MD5_Update(&ctx, (const char *)&ip6->ip6_dst, sizeof(ip6->ip6_dst));
len32 = htonl(GET_BE_U_2(ip6->ip6_plen));
@@ -939,7 +1093,9 @@
MD5_Update(&ctx, (const char *)&nxt, sizeof(nxt));
nxt = IPPROTO_TCP;
MD5_Update(&ctx, (const char *)&nxt, sizeof(nxt));
- } else {
+ }
+ else
+ {
ND_PRINT("IP version not 4 or 6, ");
return (CANT_CHECK_SIGNATURE);
}
diff -uNr tcpdump-tcpdump-4.99.4/print-tcp.h tcpdump-for-stellar/print-tcp.h
--- tcpdump-tcpdump-4.99.4/print-tcp.h 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/print-tcp.h 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 1982, 1986, 1993
+ * 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 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.
+ *
+ * @(#)tcp.h 8.1 (Berkeley) 6/10/93
+ */
+#pragma once
+/*
+ * TCP header.
+ * Per RFC 793, September, 1981.
+ */
+struct tcphdr
+{
+ nd_uint16_t th_sport; /* source port */
+ nd_uint16_t th_dport; /* destination port */
+ nd_uint32_t th_seq; /* sequence number */
+ nd_uint32_t th_ack; /* acknowledgement number */
+ nd_uint8_t th_offx2; /* data offset, rsvd */
+ nd_uint8_t th_flags;
+ nd_uint16_t th_win; /* window */
+ nd_uint16_t th_sum; /* checksum */
+ nd_uint16_t th_urp; /* urgent pointer */
+};
+
+#define TH_OFF(th) ((GET_U_1((th)->th_offx2) & 0xf0) >> 4)
+
+/* TCP flags */
+#define TH_FIN 0x01
+#define TH_SYN 0x02
+#define TH_RST 0x04
+#define TH_PUSH 0x08
+#define TH_ACK 0x10
+#define TH_URG 0x20
+#define TH_ECNECHO 0x40 /* ECN Echo */
+#define TH_CWR 0x80 /* ECN Cwnd Reduced */
+
+#define TCPOPT_EOL 0
+#define TCPOPT_NOP 1
+#define TCPOPT_MAXSEG 2
+#define TCPOLEN_MAXSEG 4
+#define TCPOPT_WSCALE 3 /* window scale factor (rfc1323) */
+#define TCPOPT_SACKOK 4 /* selective ack ok (rfc2018) */
+#define TCPOPT_SACK 5 /* selective ack (rfc2018) */
+#define TCPOPT_ECHO 6 /* echo (rfc1072) */
+#define TCPOPT_ECHOREPLY 7 /* echo (rfc1072) */
+#define TCPOPT_TIMESTAMP 8 /* timestamp (rfc1323) */
+#define TCPOLEN_TIMESTAMP 10
+#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP + 2) /* appendix A */
+#define TCPOPT_CC 11 /* T/TCP CC options (rfc1644) */
+#define TCPOPT_CCNEW 12 /* T/TCP CC options (rfc1644) */
+#define TCPOPT_CCECHO 13 /* T/TCP CC options (rfc1644) */
+#define TCPOPT_SIGNATURE 19 /* Keyed MD5 (rfc2385) */
+#define TCPOLEN_SIGNATURE 18
+#define TCP_SIGLEN 16 /* length of an option 19 digest */
+#define TCPOPT_SCPS 20 /* SCPS-TP (CCSDS 714.0-B-2) */
+#define TCPOPT_UTO 28 /* tcp user timeout (rfc5482) */
+#define TCPOLEN_UTO 4
+#define TCPOPT_TCPAO 29 /* TCP authentication option (rfc5925) */
+#define TCPOPT_MPTCP 30 /* MPTCP options */
+#define TCPOPT_FASTOPEN 34 /* TCP Fast Open (rfc7413) */
+#define TCPOPT_EXPERIMENT2 254 /* experimental headers (rfc4727) */
+
+#define TCPOPT_TSTAMP_HDR \
+ (TCPOPT_NOP << 24 | TCPOPT_NOP << 16 | TCPOPT_TIMESTAMP << 8 | TCPOLEN_TIMESTAMP)
+
+#ifndef FTP_PORT
+#define FTP_PORT 21
+#endif
+#ifndef SSH_PORT
+#define SSH_PORT 22
+#endif
+#ifndef TELNET_PORT
+#define TELNET_PORT 23
+#endif
+#ifndef SMTP_PORT
+#define SMTP_PORT 25
+#endif
+#ifndef WHOIS_PORT
+#define WHOIS_PORT 43
+#endif
+
+#define TCPDUMP_NAMESERVER_TCP_PORT 53
+
+#ifndef HTTP_PORT
+#define HTTP_PORT 80
+#endif
+#ifndef NETBIOS_SSN_PORT
+#define NETBIOS_SSN_PORT 139 /* RFC 1001, RFC 1002 */
+#endif
+#ifndef BGP_PORT
+#define BGP_PORT 179
+#endif
+#ifndef RPKI_RTR_PORT
+#define RPKI_RTR_PORT 323
+#endif
+#ifndef SMB_PORT
+#define SMB_PORT 445
+#endif
+#ifndef RTSP_PORT
+#define RTSP_PORT 554
+#endif
+#ifndef MSDP_PORT
+#define MSDP_PORT 639
+#endif
+#ifndef TCPDUMP_LDP_PORT
+#define TCPDUMP_LDP_PORT 646
+#endif
+#ifndef PPTP_PORT
+#define PPTP_PORT 1723
+#endif
+#ifndef NFS_PORT
+#define NFS_PORT 2049
+#endif
+#ifndef OPENFLOW_PORT_OLD
+#define OPENFLOW_PORT_OLD 6633
+#endif
+#ifndef OPENFLOW_PORT_IANA
+#define OPENFLOW_PORT_IANA 6653
+#endif
+#ifndef HTTP_PORT_ALT
+#define HTTP_PORT_ALT 8080
+#endif
+#ifndef RTSP_PORT_ALT
+#define RTSP_PORT_ALT 8554
+#endif
+#ifndef BEEP_PORT
+#define BEEP_PORT 10288
+#endif
+#ifndef REDIS_PORT
+#define REDIS_PORT 6379
+#endif
diff -uNr tcpdump-tcpdump-4.99.4/print-udp.c tcpdump-for-stellar/print-udp.c
--- tcpdump-tcpdump-4.99.4/print-udp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-udp.c 2024-10-30 17:34:05.631498702 +0800
@@ -20,109 +20,118 @@
*/
/* \summary: UDP printer */
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
-
#include "netdissect-stdinc.h"
-
#include "netdissect.h"
#include "addrtoname.h"
#include "extract.h"
#include "appletalk.h"
-
-#include "udp.h"
-
-#include "ip.h"
-#include "ip6.h"
+#include "tcpdump_ip.h"
+#include "tcpdump_ip6.h"
#include "ipproto.h"
#include "rpc_auth.h"
#include "rpc_msg.h"
-
#include "nfs.h"
+#include "print-udp.h"
-
-struct rtcphdr {
- nd_uint16_t rh_flags; /* T:2 P:1 CNT:5 PT:8 */
- nd_uint16_t rh_len; /* length of message (in words) */
- nd_uint32_t rh_ssrc; /* synchronization src id */
+struct rtcphdr
+{
+ nd_uint16_t rh_flags; /* T:2 P:1 CNT:5 PT:8 */
+ nd_uint16_t rh_len; /* length of message (in words) */
+ nd_uint32_t rh_ssrc; /* synchronization src id */
};
-typedef struct {
- nd_uint32_t upper; /* more significant 32 bits */
- nd_uint32_t lower; /* less significant 32 bits */
+typedef struct
+{
+ nd_uint32_t upper; /* more significant 32 bits */
+ nd_uint32_t lower; /* less significant 32 bits */
} ntp64;
/*
* Sender report.
*/
-struct rtcp_sr {
- ntp64 sr_ntp; /* 64-bit ntp timestamp */
- nd_uint32_t sr_ts; /* reference media timestamp */
- nd_uint32_t sr_np; /* no. packets sent */
- nd_uint32_t sr_nb; /* no. bytes sent */
+struct rtcp_sr
+{
+ ntp64 sr_ntp; /* 64-bit ntp timestamp */
+ nd_uint32_t sr_ts; /* reference media timestamp */
+ nd_uint32_t sr_np; /* no. packets sent */
+ nd_uint32_t sr_nb; /* no. bytes sent */
};
/*
* Receiver report.
* Time stamps are middle 32-bits of ntp timestamp.
*/
-struct rtcp_rr {
- nd_uint32_t rr_srcid; /* sender being reported */
- nd_uint32_t rr_nl; /* no. packets lost */
- nd_uint32_t rr_ls; /* extended last seq number received */
- nd_uint32_t rr_dv; /* jitter (delay variance) */
- nd_uint32_t rr_lsr; /* orig. ts from last rr from this src */
- nd_uint32_t rr_dlsr; /* time from recpt of last rr to xmit time */
+struct rtcp_rr
+{
+ nd_uint32_t rr_srcid; /* sender being reported */
+ nd_uint32_t rr_nl; /* no. packets lost */
+ nd_uint32_t rr_ls; /* extended last seq number received */
+ nd_uint32_t rr_dv; /* jitter (delay variance) */
+ nd_uint32_t rr_lsr; /* orig. ts from last rr from this src */
+ nd_uint32_t rr_dlsr; /* time from recpt of last rr to xmit time */
};
/*XXX*/
-#define RTCP_PT_SR 200
-#define RTCP_PT_RR 201
-#define RTCP_PT_SDES 202
-#define RTCP_SDES_CNAME 1
-#define RTCP_SDES_NAME 2
-#define RTCP_SDES_EMAIL 3
-#define RTCP_SDES_PHONE 4
-#define RTCP_SDES_LOC 5
-#define RTCP_SDES_TOOL 6
-#define RTCP_SDES_NOTE 7
-#define RTCP_SDES_PRIV 8
-#define RTCP_PT_BYE 203
-#define RTCP_PT_APP 204
+#define RTCP_PT_SR 200
+#define RTCP_PT_RR 201
+#define RTCP_PT_SDES 202
+#define RTCP_SDES_CNAME 1
+#define RTCP_SDES_NAME 2
+#define RTCP_SDES_EMAIL 3
+#define RTCP_SDES_PHONE 4
+#define RTCP_SDES_LOC 5
+#define RTCP_SDES_TOOL 6
+#define RTCP_SDES_NOTE 7
+#define RTCP_SDES_PRIV 8
+#define RTCP_PT_BYE 203
+#define RTCP_PT_APP 204
+
+#define IS_SRC_OR_DST_UDPPORT(p) (sport == (p) || dport == (p))
+
+static inline int CHECK_IS_SRC_OR_DST_PORT(unsigned short p, unsigned short sport, unsigned short dport)
+{
+ return (sport == (p) || dport == (p));
+}
-static void
-vat_print(netdissect_options *ndo, const u_char *hdr, u_int length)
+// cppcheck-suppress
+static void vat_print(netdissect_options *ndo, const u_char *hdr, u_int length)
{
/* vat/vt audio */
u_int ts;
ndo->ndo_protocol = "vat";
- if (length < 2) {
+ if (length < 2)
+ {
ND_PRINT("udp/va/vat, length %u < 2", length);
return;
}
ts = GET_BE_U_2(hdr);
- if ((ts & 0xf060) != 0) {
+ if ((ts & 0xf060) != 0)
+ {
/* probably vt */
ND_PRINT("udp/vt %u %u / %u",
- length,
- ts & 0x3ff, ts >> 10);
- } else {
+ length,
+ ts & 0x3ff, ts >> 10);
+ }
+ else
+ {
/* probably vat */
uint32_t i0, i1;
- if (length < 8) {
+ if (length < 8)
+ {
ND_PRINT("udp/vat, length %u < 8", length);
return;
}
i0 = GET_BE_U_4(&((const u_int *)hdr)[0]);
i1 = GET_BE_U_4(&((const u_int *)hdr)[1]);
ND_PRINT("udp/vat %u c%u %u%s",
- length - 8,
- i0 & 0xffff,
- i1, i0 & 0x800000? "*" : "");
+ length - 8,
+ i0 & 0xffff,
+ i1, i0 & 0x800000 ? "*" : "");
/* audio format */
if (i0 & 0x1f0000)
ND_PRINT(" f%u", (i0 >> 16) & 0x1f);
@@ -131,17 +140,18 @@
}
}
-static void
-rtp_print(netdissect_options *ndo, const u_char *hdr, u_int len)
+// cppcheck-suppress
+static void rtp_print(netdissect_options *ndo, const u_char *hdr, u_int len)
{
/* rtp v1 or v2 */
const u_int *ip = (const u_int *)hdr;
u_int hasopt, hasext, contype, hasmarker, dlen;
uint32_t i0, i1;
- const char * ptype;
+ const char *ptype;
ndo->ndo_protocol = "rtp";
- if (len < 8) {
+ if (len < 8)
+ {
ND_PRINT("udp/rtp, length %u < 8", len);
return;
}
@@ -153,15 +163,19 @@
len -= 2;
hasopt = 0;
hasext = 0;
- if ((i0 >> 30) == 1) {
+ if ((i0 >> 30) == 1)
+ {
/* rtp v1 - draft-ietf-avt-rtp-04 */
hasopt = i0 & 0x800000;
contype = (i0 >> 16) & 0x3f;
hasmarker = i0 & 0x400000;
ptype = "rtpv1";
- } else {
+ }
+ else
+ {
/* rtp v2 - RFC 3550 */
- if (dlen < 4) {
+ if (dlen < 4)
+ {
ND_PRINT("udp/rtp, length %u < 12", dlen + 8);
return;
}
@@ -174,21 +188,25 @@
len -= 1;
}
ND_PRINT("udp/%s %u c%u %s%s %u %u",
- ptype,
- dlen,
- contype,
- (hasopt || hasext)? "+" : "",
- hasmarker? "*" : "",
- i0 & 0xffff,
- i1);
- if (ndo->ndo_vflag) {
+ ptype,
+ dlen,
+ contype,
+ (hasopt || hasext) ? "+" : "",
+ hasmarker ? "*" : "",
+ i0 & 0xffff,
+ i1);
+ if (ndo->ndo_vflag)
+ {
ND_PRINT(" %u", GET_BE_U_4(&((const u_int *)hdr)[2]));
- if (hasopt) {
+ if (hasopt)
+ {
u_int i2, optlen;
- do {
+ do
+ {
i2 = GET_BE_U_4(ip);
optlen = (i2 >> 16) & 0xff;
- if (optlen == 0 || optlen > len) {
+ if (optlen == 0 || optlen > len)
+ {
ND_PRINT(" !opt");
return;
}
@@ -196,11 +214,13 @@
len -= optlen;
} while ((int)i2 >= 0);
}
- if (hasext) {
+ if (hasext)
+ {
u_int i2, extlen;
i2 = GET_BE_U_4(ip);
extlen = (i2 & 0xffff) + 1;
- if (extlen > len) {
+ if (extlen > len)
+ {
ND_PRINT(" !ext");
return;
}
@@ -211,8 +231,8 @@
}
}
-static const u_char *
-rtcp_print(netdissect_options *ndo, const u_char *hdr, const u_char *ep)
+// cppcheck-suppress
+static const u_char *rtcp_print(netdissect_options *ndo, const u_char *hdr, const u_char *ep)
{
/* rtp v2 control (rtcp) */
const struct rtcp_rr *rr = 0;
@@ -230,7 +250,8 @@
len = (GET_BE_U_2(rh->rh_len) + 1) * 4;
flags = GET_BE_U_2(rh->rh_flags);
cnt = (flags >> 8) & 0x1f;
- switch (flags & 0xff) {
+ switch (flags & 0xff)
+ {
case RTCP_PT_SR:
sr = (const struct rtcp_sr *)(rh + 1);
ND_PRINT(" sr");
@@ -242,10 +263,10 @@
goto trunc;
ND_TCHECK_SIZE(sr);
ts = (double)(GET_BE_U_4(sr->sr_ntp.upper)) +
- ((double)(GET_BE_U_4(sr->sr_ntp.lower)) /
- FMAXINT);
+ ((double)(GET_BE_U_4(sr->sr_ntp.lower)) /
+ FMAXINT);
ND_PRINT(" @%.2f %u %up %ub", ts, GET_BE_U_4(sr->sr_ts),
- GET_BE_U_4(sr->sr_np), GET_BE_U_4(sr->sr_nb));
+ GET_BE_U_4(sr->sr_np), GET_BE_U_4(sr->sr_nb));
rr = (const struct rtcp_rr *)(sr + 1);
break;
case RTCP_PT_RR:
@@ -275,7 +296,8 @@
}
if (cnt > 1)
ND_PRINT(" c%u", cnt);
- while (cnt != 0) {
+ while (cnt != 0)
+ {
if ((const u_char *)(rr + 1) > ep)
goto trunc;
ND_TCHECK_SIZE(rr);
@@ -284,9 +306,9 @@
ts = (double)(GET_BE_U_4(rr->rr_lsr)) / 65536.;
dts = (double)(GET_BE_U_4(rr->rr_dlsr)) / 65536.;
ND_PRINT(" %ul %us %uj @%.2f+%.2f",
- GET_BE_U_4(rr->rr_nl) & 0x00ffffff,
- GET_BE_U_4(rr->rr_ls),
- GET_BE_U_4(rr->rr_dv), ts, dts);
+ GET_BE_U_4(rr->rr_nl) & 0x00ffffff,
+ GET_BE_U_4(rr->rr_ls),
+ GET_BE_U_4(rr->rr_dv), ts, dts);
cnt--;
}
return (hdr + len);
@@ -296,94 +318,112 @@
return ep;
}
-static uint16_t udp_cksum(netdissect_options *ndo, const struct ip *ip,
- const struct udphdr *up,
- u_int len)
+// cppcheck-suppress
+static uint16_t udp_cksum(netdissect_options *ndo, const struct tcpdump_ip *ip,
+ const struct udphdr *up,
+ u_int len)
{
return nextproto4_cksum(ndo, ip, (const uint8_t *)(const void *)up, len, len,
- IPPROTO_UDP);
+ IPPROTO_UDP);
}
-
-static uint16_t udp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
- const struct udphdr *up, u_int len)
+// cppcheck-suppress
+static uint16_t udp6_cksum(netdissect_options *ndo, const struct tcpdump_ip6_hdr *ip6,
+ const struct udphdr *up, u_int len)
{
return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)up, len, len,
- IPPROTO_UDP);
+ IPPROTO_UDP);
}
-static void
-udpipaddr_print(netdissect_options *ndo, const struct ip *ip, int sport, int dport)
+// cppcheck-suppress
+static void udpipaddr_print(netdissect_options *ndo, const struct tcpdump_ip *ip, int sport, int dport)
{
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)ip;
+ ip6 = (const struct tcpdump_ip6_hdr *)ip;
else
ip6 = NULL;
- if (ip6) {
- if (GET_U_1(ip6->ip6_nxt) == IPPROTO_UDP) {
- if (sport == -1) {
+ if (ip6)
+ {
+ if (GET_U_1(ip6->ip6_nxt) == IPPROTO_UDP)
+ {
+ if (sport == -1)
+ {
ND_PRINT("%s > %s: ",
- GET_IP6ADDR_STRING(ip6->ip6_src),
- GET_IP6ADDR_STRING(ip6->ip6_dst));
- } else {
+ GET_IP6ADDR_STRING(ip6->ip6_src),
+ GET_IP6ADDR_STRING(ip6->ip6_dst));
+ }
+ else
+ {
ND_PRINT("%s.%s > %s.%s: ",
- GET_IP6ADDR_STRING(ip6->ip6_src),
- udpport_string(ndo, (uint16_t)sport),
- GET_IP6ADDR_STRING(ip6->ip6_dst),
- udpport_string(ndo, (uint16_t)dport));
+ GET_IP6ADDR_STRING(ip6->ip6_src),
+ udpport_string(ndo, (uint16_t)sport),
+ GET_IP6ADDR_STRING(ip6->ip6_dst),
+ udpport_string(ndo, (uint16_t)dport));
}
- } else {
- if (sport != -1) {
+ }
+ else
+ {
+ if (sport != -1)
+ {
ND_PRINT("%s > %s: ",
- udpport_string(ndo, (uint16_t)sport),
- udpport_string(ndo, (uint16_t)dport));
+ udpport_string(ndo, (uint16_t)sport),
+ udpport_string(ndo, (uint16_t)dport));
}
}
- } else {
- if (GET_U_1(ip->ip_p) == IPPROTO_UDP) {
- if (sport == -1) {
+ }
+ else
+ {
+ if (GET_U_1(ip->ip_p) == IPPROTO_UDP)
+ {
+ if (sport == -1)
+ {
ND_PRINT("%s > %s: ",
- GET_IPADDR_STRING(ip->ip_src),
- GET_IPADDR_STRING(ip->ip_dst));
- } else {
+ GET_IPADDR_STRING(ip->ip_src),
+ GET_IPADDR_STRING(ip->ip_dst));
+ }
+ else
+ {
ND_PRINT("%s.%s > %s.%s: ",
- GET_IPADDR_STRING(ip->ip_src),
- udpport_string(ndo, (uint16_t)sport),
- GET_IPADDR_STRING(ip->ip_dst),
- udpport_string(ndo, (uint16_t)dport));
+ GET_IPADDR_STRING(ip->ip_src),
+ udpport_string(ndo, (uint16_t)sport),
+ GET_IPADDR_STRING(ip->ip_dst),
+ udpport_string(ndo, (uint16_t)dport));
}
- } else {
- if (sport != -1) {
+ }
+ else
+ {
+ if (sport != -1)
+ {
ND_PRINT("%s > %s: ",
- udpport_string(ndo, (uint16_t)sport),
- udpport_string(ndo, (uint16_t)dport));
+ udpport_string(ndo, (uint16_t)sport),
+ udpport_string(ndo, (uint16_t)dport));
}
}
}
}
-void
-udp_print(netdissect_options *ndo, const u_char *bp, u_int length,
- const u_char *bp2, int fragmented, u_int ttl_hl)
+// cppcheck-suppress
+void udp_print(netdissect_options *ndo, const u_char *bp, u_int length, const u_char *bp2, int fragmented, u_int ttl_hl)
{
const struct udphdr *up;
- const struct ip *ip;
+ const struct tcpdump_ip *ip;
const u_char *cp;
const u_char *ep = ndo->ndo_snapend;
uint16_t sport, dport;
u_int ulen;
- const struct ip6_hdr *ip6;
+ const struct tcpdump_ip6_hdr *ip6;
ndo->ndo_protocol = "udp";
up = (const struct udphdr *)bp;
- ip = (const struct ip *)bp2;
+ ip = (const struct tcpdump_ip *)bp2;
if (IP_V(ip) == 6)
- ip6 = (const struct ip6_hdr *)bp2;
+ ip6 = (const struct tcpdump_ip6_hdr *)bp2;
else
ip6 = NULL;
- if (!ND_TTEST_2(up->uh_dport)) {
+ if (!ND_TTEST_2(up->uh_dport))
+ {
udpipaddr_print(ndo, ip, -1, -1);
goto trunc;
}
@@ -391,12 +431,14 @@
sport = GET_BE_U_2(up->uh_sport);
dport = GET_BE_U_2(up->uh_dport);
- if (length < sizeof(struct udphdr)) {
+ if (length < sizeof(struct udphdr))
+ {
udpipaddr_print(ndo, ip, sport, dport);
ND_PRINT("truncated-udp %u", length);
return;
}
- if (!ND_TTEST_2(up->uh_ulen)) {
+ if (!ND_TTEST_2(up->uh_ulen))
+ {
udpipaddr_print(ndo, ip, sport, dport);
goto trunc;
}
@@ -408,7 +450,8 @@
*/
if (ulen == 0 && length > 65535)
ulen = length;
- if (ulen < sizeof(struct udphdr)) {
+ if (ulen < sizeof(struct udphdr))
+ {
udpipaddr_print(ndo, ip, sport, dport);
ND_PRINT("truncated-udplength %u", ulen);
return;
@@ -419,16 +462,19 @@
length = ulen;
cp = (const u_char *)(up + 1);
- if (cp > ndo->ndo_snapend) {
+ if (cp > ndo->ndo_snapend)
+ {
udpipaddr_print(ndo, ip, sport, dport);
goto trunc;
}
- if (ndo->ndo_packettype) {
+ if (ndo->ndo_packettype)
+ {
const struct sunrpc_msg *rp;
enum sunrpc_msg_type direction;
- switch (ndo->ndo_packettype) {
+ switch (ndo->ndo_packettype)
+ {
case PT_VAT:
udpipaddr_print(ndo, ip, sport, dport);
@@ -442,13 +488,13 @@
case PT_RPC:
rp = (const struct sunrpc_msg *)cp;
- direction = (enum sunrpc_msg_type) GET_BE_U_4(rp->rm_direction);
+ direction = (enum sunrpc_msg_type)GET_BE_U_4(rp->rm_direction);
if (direction == SUNRPC_CALL)
sunrpc_print(ndo, (const u_char *)rp, length,
- (const u_char *)ip);
+ (const u_char *)ip);
else
nfsreply_print(ndo, (const u_char *)rp, length,
- (const u_char *)ip); /*XXX*/
+ (const u_char *)ip); /*XXX*/
break;
case PT_RTP:
@@ -480,7 +526,7 @@
case PT_AODV:
udpipaddr_print(ndo, ip, sport, dport);
aodv_print(ndo, cp, length,
- ip6 != NULL);
+ ip6 != NULL);
break;
case PT_RADIUS:
@@ -520,29 +566,34 @@
}
udpipaddr_print(ndo, ip, sport, dport);
- if (!ndo->ndo_qflag) {
+ if (!ndo->ndo_qflag)
+ {
const struct sunrpc_msg *rp;
enum sunrpc_msg_type direction;
rp = (const struct sunrpc_msg *)cp;
- if (ND_TTEST_4(rp->rm_direction)) {
- direction = (enum sunrpc_msg_type) GET_BE_U_4(rp->rm_direction);
- if (dport == NFS_PORT && direction == SUNRPC_CALL) {
+ if (ND_TTEST_4(rp->rm_direction))
+ {
+ direction = (enum sunrpc_msg_type)GET_BE_U_4(rp->rm_direction);
+ if (dport == NFS_PORT && direction == SUNRPC_CALL)
+ {
ND_PRINT("NFS request xid %u ",
- GET_BE_U_4(rp->rm_xid));
+ GET_BE_U_4(rp->rm_xid));
nfsreq_noaddr_print(ndo, (const u_char *)rp, length,
- (const u_char *)ip);
+ (const u_char *)ip);
return;
}
- if (sport == NFS_PORT && direction == SUNRPC_REPLY) {
+ if (sport == NFS_PORT && direction == SUNRPC_REPLY)
+ {
ND_PRINT("NFS reply xid %u ",
- GET_BE_U_4(rp->rm_xid));
+ GET_BE_U_4(rp->rm_xid));
nfsreply_noaddr_print(ndo, (const u_char *)rp, length,
- (const u_char *)ip);
+ (const u_char *)ip);
return;
}
#ifdef notdef
- if (dport == SUNRPC_PORT && direction == SUNRPC_CALL) {
+ if (dport == 111 /*TCPDUMP_SUNRPC_PORT*/ && direction == SUNRPC_CALL)
+ {
sunrpc_print((const u_char *)rp, length, (const u_char *)ip);
return;
}
@@ -550,7 +601,8 @@
}
}
- if (ndo->ndo_vflag && !ndo->ndo_Kflag && !fragmented) {
+ if (ndo->ndo_vflag && !ndo->ndo_Kflag && !fragmented)
+ {
/* Check the checksum, if possible. */
uint16_t sum, udp_sum;
@@ -558,181 +610,353 @@
* XXX - do this even if vflag == 1?
* TCP does, and we do so for UDP-over-IPv6.
*/
- if (IP_V(ip) == 4 && (ndo->ndo_vflag > 1)) {
+ if (IP_V(ip) == 4 && (ndo->ndo_vflag > 1))
+ {
udp_sum = GET_BE_U_2(up->uh_sum);
- if (udp_sum == 0) {
+ if (udp_sum == 0)
+ {
ND_PRINT("[no cksum] ");
- } else if (ND_TTEST_LEN(cp, length)) {
+ }
+ else if (ND_TTEST_LEN(cp, length))
+ {
sum = udp_cksum(ndo, ip, up, length + sizeof(struct udphdr));
- if (sum != 0) {
+ if (sum != 0)
+ {
ND_PRINT("[bad udp cksum 0x%04x -> 0x%04x!] ",
- udp_sum,
- in_cksum_shouldbe(udp_sum, sum));
- } else
+ udp_sum,
+ in_cksum_shouldbe(udp_sum, sum));
+ }
+ else
ND_PRINT("[udp sum ok] ");
}
}
- else if (IP_V(ip) == 6) {
+ else if (IP_V(ip) == 6)
+ {
/* for IPv6, UDP checksum is mandatory */
- if (ND_TTEST_LEN(cp, length)) {
+ if (ND_TTEST_LEN(cp, length))
+ {
sum = udp6_cksum(ndo, ip6, up, length + sizeof(struct udphdr));
udp_sum = GET_BE_U_2(up->uh_sum);
- if (sum != 0) {
+ if (sum != 0)
+ {
ND_PRINT("[bad udp cksum 0x%04x -> 0x%04x!] ",
- udp_sum,
- in_cksum_shouldbe(udp_sum, sum));
- } else
+ udp_sum,
+ in_cksum_shouldbe(udp_sum, sum));
+ }
+ else
ND_PRINT("[udp sum ok] ");
}
}
}
- if (!ndo->ndo_qflag) {
- if (IS_SRC_OR_DST_PORT(NAMESERVER_PORT))
+ if (!ndo->ndo_qflag)
+ {
+ if (CHECK_IS_SRC_OR_DST_PORT(53 /*TCPDUMP_NAMESERVER_PORT*/, sport, dport))
+ {
/* over_tcp: FALSE, is_mdns: FALSE */
domain_print(ndo, cp, length, FALSE, FALSE);
- else if (IS_SRC_OR_DST_PORT(MULTICASTDNS_PORT))
+ return;
+ }
+
+ if (CHECK_IS_SRC_OR_DST_PORT(5353 /*TCPDUMP_MULTICASTDNS_PORT*/, sport, dport))
+ {
/* over_tcp: FALSE, is_mdns: TRUE */
domain_print(ndo, cp, length, FALSE, TRUE);
- else if (IS_SRC_OR_DST_PORT(TIMED_PORT))
+ return;
+ }
+
+ if (CHECK_IS_SRC_OR_DST_PORT(525 /*TCPDUMP_TIMED_PORT*/, sport, dport))
+ {
timed_print(ndo, (const u_char *)cp);
- else if (IS_SRC_OR_DST_PORT(TFTP_PORT))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(69 /*TCPDUMP_TFTP_PORT*/, sport, dport))
+ {
tftp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(BOOTPC_PORT) || IS_SRC_OR_DST_PORT(BOOTPS_PORT))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(68 /*TCPDUMP_BOOTPC_PORT*/, sport, dport) || CHECK_IS_SRC_OR_DST_PORT(67 /*TCPDUMP_BOOTPS_PORT*/, sport, dport))
+ {
bootp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(RIP_PORT))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(520 /*TCPDUMP_RIP_PORT*/, sport, dport))
+ {
rip_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(AODV_PORT))
- aodv_print(ndo, cp, length,
- ip6 != NULL);
- else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT))
- isakmp_print(ndo, cp, length, bp2);
- else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT_NATT))
- isakmp_rfc3948_print(ndo, cp, length, bp2, IP_V(ip), fragmented, ttl_hl);
- else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT_USER1) || IS_SRC_OR_DST_PORT(ISAKMP_PORT_USER2))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(654 /*AODV_PORT*/, sport, dport))
+ {
+ aodv_print(ndo, cp, length, ip6 != NULL);
+ return;
+ }
+
+ if (CHECK_IS_SRC_OR_DST_PORT(500 /*TCPDUMP_ISAKMP_PORT*/, sport, dport))
+ {
+ isakmp_print(ndo, cp, length, bp2);
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(4500 /*TCPDUMP_ISAKMP_PORT_NATT*/, sport, dport))
+ {
+ isakmp_rfc3948_print(ndo, cp, length, bp2, IP_V(ip), fragmented, ttl_hl);
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(7500 /*TCPDUMP_ISAKMP_PORT_USER1*/, sport, dport) || CHECK_IS_SRC_OR_DST_PORT(8500 /*TCPDUMP_ISAKMP_PORT_USER2*/, sport, dport))
+ {
isakmp_print(ndo, cp, length, bp2);
- else if (IS_SRC_OR_DST_PORT(SNMP_PORT) || IS_SRC_OR_DST_PORT(SNMPTRAP_PORT))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(161 /*TCPDUMP_SNMP_PORT*/, sport, dport) || CHECK_IS_SRC_OR_DST_PORT(162 /*TCPDUMP_SNMPTRAP_PORT*/, sport, dport))
+ {
snmp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(NTP_PORT))
+ return;
+ }
+ if (CHECK_IS_SRC_OR_DST_PORT(123 /*TCPDUMP_NTP_PORT*/, sport, dport))
+ {
ntp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(KERBEROS_PORT) || IS_SRC_OR_DST_PORT(KERBEROS_SEC_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(88 /*TCPDUMP_KERBEROS_PORT*/) || CHECK_IS_SRC_OR_DST_PORT(750 /*TCPDUMP_KERBEROS_SEC_PORT*/, sport, dport))
+ {
krb_print(ndo, (const u_char *)cp);
- else if (IS_SRC_OR_DST_PORT(L2TP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(1701 /*TCPDUMP_L2TP_PORT*/))
+ {
l2tp_print(ndo, cp, length);
+ return;
+ }
#ifdef ENABLE_SMB
- else if (IS_SRC_OR_DST_PORT(NETBIOS_NS_PORT))
+ if (IS_SRC_OR_DST_UDPPORT(137 /*TCPDUMP_NETBIOS_NS_PORT*/))
+ {
nbt_udp137_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(NETBIOS_DGRAM_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(138 /*TCPDUMP_NETBIOS_DGRAM_PORT*/))
+ {
nbt_udp138_print(ndo, cp, length);
+ return;
+ }
#endif
- else if (dport == VAT_PORT)
+
+ if (dport == 3456 /*TCPDUMP_VAT_PORT*/)
+ {
vat_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(ZEPHYR_SRV_PORT) || IS_SRC_OR_DST_PORT(ZEPHYR_CLT_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(2103 /*TCPDUMP_ZEPHYR_SRV_PORT*/) || IS_SRC_OR_DST_UDPPORT(2104 /*ZEPHYR_CLT_PORT*/))
+ {
zephyr_print(ndo, cp, length);
+ return;
+ }
/*
* Since there are 10 possible ports to check, I think
* a <> test would be more efficient
*/
- else if ((sport >= RX_PORT_LOW && sport <= RX_PORT_HIGH) ||
- (dport >= RX_PORT_LOW && dport <= RX_PORT_HIGH))
- rx_print(ndo, cp, length, sport, dport,
- (const u_char *) ip);
- else if (IS_SRC_OR_DST_PORT(RIPNG_PORT))
+ if ((sport >= 7000 /*TCPDUMP_RX_PORT_LOW*/ && sport <= 7009 /*TCPDUMP_RX_PORT_HIGH*/) ||
+ (dport >= 7000 /*TCPDUMP_RX_PORT_LOW*/ && dport <= 7009 /*TCPDUMP_RX_PORT_HIGH*/))
+ {
+ rx_print(ndo, cp, length, sport, dport, (const u_char *)ip);
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(521 /*TCPDUMP_RIPNG_PORT*/))
+ {
ripng_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(DHCP6_SERV_PORT) || IS_SRC_OR_DST_PORT(DHCP6_CLI_PORT))
+ return;
+ }
+
+ if (IS_SRC_OR_DST_UDPPORT(546 /*TCPDUMP_DHCP6_SERV_PORT*/) || IS_SRC_OR_DST_UDPPORT(547 /*TCPDUMP_DHCP6_CLI_PORT*/))
+ {
dhcp6_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(AHCP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(5359 /*TCPDUMP_AHCP_PORT*/))
+ {
ahcp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(BABEL_PORT) || IS_SRC_OR_DST_PORT(BABEL_PORT_OLD))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(6696 /*TCPDUMP_BABEL_PORT*/) || IS_SRC_OR_DST_UDPPORT(6697 /*TCPDUMP_BABEL_PORT_OLD*/))
+ {
babel_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(HNCP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(8231 /*TCPDUMP_HNCP_PORT*/))
+ {
hncp_print(ndo, cp, length);
+ return;
+ }
/*
* Kludge in test for whiteboard packets.
*/
- else if (dport == WB_PORT)
+ if (dport == 4567 /*TCPDUMP_WB_PORT*/)
+ {
wb_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(CISCO_AUTORP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(496 /*TCPDUMP_CISCO_AUTORP_PORT*/))
+ {
cisco_autorp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(RADIUS_PORT) ||
- IS_SRC_OR_DST_PORT(RADIUS_NEW_PORT) ||
- IS_SRC_OR_DST_PORT(RADIUS_ACCOUNTING_PORT) ||
- IS_SRC_OR_DST_PORT(RADIUS_NEW_ACCOUNTING_PORT) ||
- IS_SRC_OR_DST_PORT(RADIUS_CISCO_COA_PORT) ||
- IS_SRC_OR_DST_PORT(RADIUS_COA_PORT) )
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(1645 /*TCPDUMP_RADIUS_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(1812 /*TCPDUMP_RADIUS_NEW_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(1646 /*TCPDUMP_RADIUS_ACCOUNTING_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(1813 /*TCPDUMP_RADIUS_NEW_ACCOUNTING_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(1700 /*TCPDUMP_RADIUS_CISCO_COA_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(3799 /*TCPDUMP_RADIUS_COA_PORT*/))
+ {
radius_print(ndo, cp, length);
- else if (dport == HSRP_PORT)
+ return;
+ }
+ if (dport == 1985 /*TCPDUMP_HSRP_PORT*/)
+ {
hsrp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(LWRES_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(921 /*TCPDUMP_LWRES_PORT*/))
+ {
lwres_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(LDP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(646 /*TCPDUMP_LDP_PORT*/))
+ {
ldp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(OLSR_PORT))
- olsr_print(ndo, cp, length,
- (IP_V(ip) == 6) ? 1 : 0);
- else if (IS_SRC_OR_DST_PORT(MPLS_LSP_PING_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(698 /*TCPDUMP_OLSR_PORT*/))
+ {
+ olsr_print(ndo, cp, length, (IP_V(ip) == 6) ? 1 : 0);
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(3503 /*TCPDUMP_MPLS_LSP_PING_PORT*/))
+ {
lspping_print(ndo, cp, length);
- else if (sport == BCM_LI_PORT)
+ return;
+ }
+ if (sport == 49152 /*TCPDUMP_BCM_LI_PORT*/)
+ {
bcm_li_print(ndo, cp, length);
- else if (dport == BFD_CONTROL_PORT ||
- dport == BFD_MULTIHOP_PORT ||
- dport == BFD_LAG_PORT ||
- dport == BFD_ECHO_PORT )
+ return;
+ }
+
+ if (dport == 3784 /*TCPDUMP_BFD_CONTROL_PORT*/ ||
+ dport == 4784 /*TCPDUMP_BFD_MULTIHOP_PORT*/ ||
+ dport == 6784 /*TCPDUMP_BFD_LAG_PORT*/ ||
+ dport == 3785 /*TCPDUMP_BFD_ECHO_PORT*/)
+ {
bfd_print(ndo, cp, length, dport);
- else if (IS_SRC_OR_DST_PORT(LMP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(701 /*TCPDUMP_LMP_PORT*/))
+ {
lmp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(VQP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(1589 /*TCPDUMP_VQP_PORT*/))
+ {
vqp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(SFLOW_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(6343 /*TCPDUMP_SFLOW_PORT*/))
+ {
sflow_print(ndo, cp, length);
- else if (dport == LWAPP_CONTROL_PORT)
+ return;
+ }
+ if (dport == 12223 /*TCPDUMP_LWAPP_CONTROL_PORT*/)
+ {
lwapp_control_print(ndo, cp, length, 1);
- else if (sport == LWAPP_CONTROL_PORT)
+ return;
+ }
+ if (sport == 12223 /*TCPDUMP_LWAPP_CONTROL_PORT*/)
+ {
lwapp_control_print(ndo, cp, length, 0);
- else if (IS_SRC_OR_DST_PORT(LWAPP_DATA_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(12222 /*TCPDUMP_LWAPP_DATA_PORT*/))
+ {
lwapp_data_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(SIP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(5060 /*TCPDUMP_SIP_PORT*/))
+ {
sip_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(SYSLOG_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(514 /*TCPDUMP_SYSLOG_PORT*/))
+ {
syslog_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(OTV_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(8472 /*TCPDUMP_OTV_PORT*/))
+ {
otv_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(VXLAN_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(4789 /*TCPDUMP_VXLAN_PORT*/))
+ {
vxlan_print(ndo, cp, length);
- else if (dport == GENEVE_PORT)
+ return;
+ }
+ if (dport == 6081 /*TCPDUMP_GENEVE_PORT*/)
+ {
geneve_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(LISP_CONTROL_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(4342 /*TCPDUMP_LISP_CONTROL_PORT*/))
+ {
lisp_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(VXLAN_GPE_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(4790 /*TCPDUMP_VXLAN_GPE_PORT*/))
+ {
vxlan_gpe_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(ZEP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(17754 /*TCPDUMP_ZEP_PORT*/))
+ {
zep_print(ndo, cp, length);
- else if (IS_SRC_OR_DST_PORT(MPLS_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(6635 /*TCPDUMP_MPLS_PORT*/))
+ {
mpls_print(ndo, cp, length);
- else if (ND_TTEST_1(((const struct LAP *)cp)->type) &&
- GET_U_1(((const struct LAP *)cp)->type) == lapDDP &&
- (atalk_port(sport) || atalk_port(dport))) {
+ return;
+ }
+ if (ND_TTEST_1(((const struct LAP *)cp)->type) &&
+ GET_U_1(((const struct LAP *)cp)->type) == lapDDP &&
+ (atalk_port(sport) || atalk_port(dport)))
+ {
if (ndo->ndo_vflag)
ND_PRINT("kip ");
llap_print(ndo, cp, length);
- } else if (IS_SRC_OR_DST_PORT(PTP_EVENT_PORT) ||
- IS_SRC_OR_DST_PORT(PTP_GENERAL_PORT)) {
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(319 /*TCPDUMP_PTP_EVENT_PORT*/) ||
+ IS_SRC_OR_DST_UDPPORT(320 /*TCPDUMP_PTP_GENERAL_PORT*/))
+
+ {
ptp_print(ndo, cp, length);
- } else if (IS_SRC_OR_DST_PORT(SOMEIP_PORT))
+ return;
+ }
+ if (IS_SRC_OR_DST_UDPPORT(30490 /*TCPDUMP_SOMEIP_PORT*/))
someip_print(ndo, cp, length);
- else {
+ else
+ {
if (ulen > length && !fragmented)
ND_PRINT("UDP, bad length %u > %u",
- ulen, length);
+ ulen, length);
else
ND_PRINT("UDP, length %u", ulen);
}
- } else {
+ }
+
+ else
+ {
if (ulen > length && !fragmented)
ND_PRINT("UDP, bad length %u > %u",
- ulen, length);
+ ulen, length);
else
ND_PRINT("UDP, length %u", ulen);
}
diff -uNr tcpdump-tcpdump-4.99.4/print-udp.h tcpdump-for-stellar/print-udp.h
--- tcpdump-tcpdump-4.99.4/print-udp.h 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/print-udp.h 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 1982, 1986, 1993
+ * 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 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.
+ *
+ * @(#)udp.h 8.1 (Berkeley) 6/10/93
+ */
+
+#pragma once
+#include "netdissect.h"
+/*
+ * Udp protocol header.
+ * Per RFC 768, September, 1981.
+ */
+struct udphdr
+{
+ nd_uint16_t uh_sport; /* source port */
+ nd_uint16_t uh_dport; /* destination port */
+ nd_uint16_t uh_ulen; /* udp length */
+ nd_uint16_t uh_sum; /* udp checksum */
+};
+
+// #define TCPDUMP_NAMESERVER_PORT 53
+
+// #define TCPDUMP_BOOTPS_PORT 67 /* RFC951 */
+
+// #define TCPDUMP_BOOTPC_PORT 68 /* RFC951 */
+
+// #define TCPDUMP_TFTP_PORT 69 /*XXX*/
+
+// #define TCPDUMP_KERBEROS_PORT 88 /*XXX*/
+
+// #define TCPDUMP_SUNRPC_PORT 111 /*XXX*/
+
+// #define TCPDUMP_NTP_PORT 123 /*XXX*/
+
+// #define TCPDUMP_NETBIOS_NS_PORT 137 /* RFC 1001, RFC 1002 */
+
+// #define TCPDUMP_NETBIOS_DGRAM_PORT 138 /* RFC 1001, RFC 1002 */
+
+// #define TCPDUMP_SNMP_PORT 161 /*XXX*/
+
+// #define TCPDUMP_SNMPTRAP_PORT 162 /*XXX*/
+
+// #define TCPDUMP_PTP_EVENT_PORT 319 /* IANA */
+
+// #define TCPDUMP_PTP_GENERAL_PORT 320 /* IANA */
+
+// #define TCPDUMP_CISCO_AUTORP_PORT 496 /*XXX*/
+
+// #define TCPDUMP_ISAKMP_PORT 500 /*XXX*/
+
+// #define TCPDUMP_SYSLOG_PORT 514 /* rfc3164 */
+
+// #define TCPDUMP_RIP_PORT 520 /*XXX*/
+
+// #define TCPDUMP_RIPNG_PORT 521 /* RFC 2080 */
+
+// #define TCPDUMP_TIMED_PORT 525 /*XXX*/
+
+// #define TCPDUMP_DHCP6_SERV_PORT 546 /*XXX*/
+
+// #define TCPDUMP_DHCP6_CLI_PORT 547 /*XXX*/
+
+// #define TCPDUMP_LDP_PORT 646
+
+// #define TCPDUMP_AQDV_PORT 654 /*XXX*/
+
+// #define TCPDUMP_OLSR_PORT 698 /* rfc3626 */
+
+// #define TCPDUMP_LMP_PORT 701 /* rfc4204 */
+
+// #define TCPDUMP_KERBEROS_SEC_PORT 750 /*XXX - Kerberos v4 */
+
+// #define TCPDUMP_LWRES_PORT 921 /*XXX*/
+
+// #define TCPDUMP_VQP_PORT 1589 /*XXX*/
+
+// #define TCPDUMP_RADIUS_PORT 1645 /*XXX*/
+
+// #define TCPDUMP_RADIUS_ACCOUNTING_PORT 1646
+
+// #define TCPDUMP_RADIUS_CISCO_COA_PORT 1700
+
+// #define TCPDUMP_L2TP_PORT 1701 /*XXX*/
+
+// #define TCPDUMP_RADIUS_NEW_PORT 1812 /*XXX*/
+
+// #define TCPDUMP_RADIUS_NEW_ACCOUNTING_PORT 1813
+
+// #define TCPDUMP_HSRP_PORT 1985 /*XXX*/
+
+// #define TCPDUMP_ZEPHYR_SRV_PORT 2103 /*XXX*/
+
+// #define TCPDUMP_ZEPHYR_CLI_PORT 2104 /*XXX*/
+
+// #define TCPDUMP_VAT_PORT 3456 /*XXX*/
+
+// #define TCPDUMP_MPLS_LSP_PING_PORT 3503 /* draft-ietf-mpls-lsp-ping-02.txt */
+
+// #define TCPDUMP_BCM_LI_PORT 49152 /* SDK default */
+
+#define TCPDUMP_BFD_CONTROL_PORT 3784 /* RFC 5881 */
+
+#define TCPDUMP_BFD_ECHO_PORT 3785 /* RFC 5881 */
+
+// #define TCPDUMP_RADIUS_COA_PORT 3799 /* RFC 5176 */
+
+// #define TCPDUMP_LISP_CONTROL_PORT 4342 /* RFC 6830 */
+
+// #define TCPDUMP_ISAKMP_PORT_NATT 4500 /* rfc3948 */
+
+// #define TCPDUMP_WB_PORT 4567
+
+#define TCPDUMP_BFD_MULTIHOP_PORT 4784 /* RFC 5883 */
+
+// #define TCPDUMP_VXLAN_PORT 4789 /* RFC 7348 */
+
+// #define TCPDUMP_VXLAN_GPE_PORT 4790 /* draft-ietf-nvo3-vxlan-gpe-01 */
+
+// #define TCPDUMP_SIP_PORT 5060
+
+// #define TCPDUMP_MULTICASTDNS_PORT 5353 /* RFC 6762 */
+
+// #define TCPDUMP_AHCP_PORT 5359 /* draft-chroboczek-ahcp-00 */
+
+// #define TCPDUMP_GENEVE_PORT 6081 /* draft-gross-geneve-02 */
+
+// #define TCPDUMP_SFLOW_PORT 6343 /* https://sflow.org/developers/specifications.php */
+
+// #define TCPDUMP_MPLS_PORT 6635 /* RFC 7510 */
+
+// #define TCPDUMP_BABEL_PORT 6696 /* RFC 6126 errata */
+
+// #define TCPDUMP_BABEL_PORT_OLD 6697 /* RFC 6126 */
+
+#define TCPDUMP_BFD_LAG_PORT 6784 /* RFC 7310 */
+
+// #define TCPDUMP_RX_PORT_LOW 7000 /*XXX*/
+
+// #define TCPDUMP_RX_PORT_HIGH 7009 /*XXX*/
+
+// #define TCPDUMP_ISAKMP_PORT_USER1 7500 /*XXX - nonstandard*/
+
+// #define TCPDUMP_HNCP_PORT 8231 /* RFC 7788 */
+
+// #define TCPDUMP_OTV_PORT 8472 /* draft-hasmit-otv-04 */
+
+// #define TCPDUMP_ISAKMP_PORT_USER2 8500 /*XXX - nonstandard*/
+
+// #define TCPDUMP_LWAPP_DATA_PORT 12222 /* RFC 5412 */
+
+// #define TCPDUMP_LWAPP_CONTROL_PORT 12223 /* RFC 5412 */
+
+// #define TCPDUMP_ZEP_PORT 17754 /* XXX */
+
+// #define TCPDUMP_SOMEIP_PORT 30490 /* https://www.autosar.org/standards/foundation */
diff -uNr tcpdump-tcpdump-4.99.4/print-vrrp.c tcpdump-for-stellar/print-vrrp.c
--- tcpdump-tcpdump-4.99.4/print-vrrp.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/print-vrrp.c 2024-10-30 17:34:05.631498702 +0800
@@ -35,7 +35,7 @@
#include "extract.h"
#include "addrtoname.h"
-#include "ip.h"
+#include "tcpdump_ip.h"
#include "ipproto.h"
/*
* RFC 2338 (VRRP v2):
@@ -151,10 +151,10 @@
uint16_t cksum;
if (ver == 4)
- cksum = nextproto4_cksum(ndo, (const struct ip *)bp2, bp,
+ cksum = nextproto4_cksum(ndo, (const struct tcpdump_ip *)bp2, bp,
len, len, IPPROTO_VRRP);
else
- cksum = nextproto6_cksum(ndo, (const struct ip6_hdr *)bp2, bp,
+ cksum = nextproto6_cksum(ndo, (const struct tcpdump_ip6_hdr *)bp2, bp,
len, len, IPPROTO_VRRP);
if (cksum)
ND_PRINT(", (bad vrrp cksum %x)",
diff -uNr tcpdump-tcpdump-4.99.4/stellar_dump_ctrl_link.c tcpdump-for-stellar/stellar_dump_ctrl_link.c
--- tcpdump-tcpdump-4.99.4/stellar_dump_ctrl_link.c 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/stellar_dump_ctrl_link.c 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,266 @@
+#include "stellar_dump.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <pcap/pcap.h>
+#include <sys/types.h> /* See NOTES */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <event2/event.h>
+#include <event2/listener.h>
+#include <event2/bufferevent.h>
+#include <event2/buffer.h>
+#include <event2/thread.h>
+#include <event2/http.h>
+
+struct libevent_http_client
+{
+ struct event_base *base;
+ struct evhttp_connection *conn;
+ struct evhttp_request *req;
+ uint32_t response_code;
+ char *response_cstr;
+};
+
+static struct libevent_http_client *g_ctrllink_http_client = NULL;
+static pthread_t keepalive_thread_id;
+static volatile int keepalive_running = 0;
+
+static struct libevent_http_client *evhttp_client_new(const char *server_ip, unsigned short server_port_host)
+{
+ struct libevent_http_client *evh_client = (struct libevent_http_client *)calloc(1, sizeof(struct libevent_http_client));
+ evh_client->base = event_base_new();
+ evh_client->conn = evhttp_connection_base_new(evh_client->base, NULL, server_ip, server_port_host);
+ evhttp_connection_set_timeout(evh_client->conn, CTRLLINK_CONNECT_TIMEOUT);
+ return evh_client;
+}
+
+static void evhttp_response_cb(struct evhttp_request *req, void *arg)
+{
+ struct libevent_http_client *evh_client = (struct libevent_http_client *)arg;
+ if (req == NULL)
+ {
+ return;
+ }
+
+ struct evbuffer *input_buffer = evhttp_request_get_input_buffer(req);
+ size_t evbuf_len = evbuffer_get_length(input_buffer);
+ if (NULL == input_buffer || 0 == evbuf_len)
+ {
+ return;
+ }
+ evh_client->response_cstr = (char *)calloc(1, evbuf_len + 1);
+ evbuffer_remove(input_buffer, evh_client->response_cstr, evbuf_len);
+ evh_client->response_code = evhttp_request_get_response_code(req);
+ // terminate event_base_dispatch()
+ event_base_loopbreak(evh_client->base);
+}
+
+static void evhttp_request_error_cb(enum evhttp_request_error errnum, void *arg)
+{
+ (void)arg;
+ (void)errnum;
+ // fprintf(stderr, "ERR monitor connection error: %d\n", errnum);
+ exit(1);
+}
+
+static void evhttp_conn_close_cb(struct evhttp_connection *conn, void *arg)
+{
+ (void)conn;
+ event_base_loopexit((struct event_base *)arg, NULL);
+ static volatile int barrier = 0;
+ if (__sync_bool_compare_and_swap(&barrier, 0, 1))
+ {
+ fprintf(stderr, "monitor connection closed.\n");
+ exit(1);
+ }
+}
+
+static int evhttp_client_request_new(struct libevent_http_client *evh_client)
+{
+ evh_client->req = evhttp_request_new(evhttp_response_cb, evh_client);
+ evhttp_request_set_error_cb(evh_client->req, evhttp_request_error_cb);
+ evhttp_connection_set_closecb(evh_client->conn, evhttp_conn_close_cb, evh_client->base);
+ evh_client->response_cstr = NULL;
+ evh_client->response_code = 204;
+ return 0;
+}
+static void evhttp_client_add_header(struct libevent_http_client *evh_client,
+ const char *key, const char *value)
+{
+ struct evkeyvalq *output_headers = evhttp_request_get_output_headers(evh_client->req);
+ evhttp_add_header(output_headers, key, value);
+}
+
+static unsigned int evhttp_run_cmd(struct libevent_http_client *evh_client, const char *cmd_uri)
+{
+ evhttp_client_request_new(evh_client);
+ evhttp_client_add_header(evh_client, "Connection", "keep-alive");
+ evhttp_client_add_header(evh_client, "Content-Length", "0");
+ evhttp_make_request(evh_client->conn, evh_client->req, EVHTTP_REQ_GET, cmd_uri);
+
+ int ret = event_base_dispatch(evh_client->base);
+ if (ret < 0)
+ {
+ fprintf(stderr, "event_base_dispatch failed!\n");
+ exit(1);
+ }
+ // here we receive the response from monitor server.
+ return evh_client->response_code;
+}
+
+static void *stellar_dump_ctrllink_keepalive(void *arg)
+{
+ (void)arg;
+ struct libevent_http_client *evh_client = g_ctrllink_http_client;
+ char keepalive_cmd[256] = {0};
+ snprintf(keepalive_cmd, sizeof(keepalive_cmd), "%s%s", CTRLLINK_CMD_URI_PREFIX, "ping%20stellar-dump-keepalive");
+ int cmd_ret;
+ while (keepalive_running)
+ {
+ cmd_ret = evhttp_run_cmd(evh_client, keepalive_cmd);
+ if (cmd_ret != 200)
+ {
+ fprintf(stderr, "ERR connection failed!\n");
+ exit(1);
+ }
+ if (evh_client->response_cstr)
+ {
+ free(evh_client->response_cstr);
+ evh_client->response_cstr = NULL;
+ }
+ if (keepalive_running)
+ {
+ sleep(1);
+ }
+ }
+ return NULL;
+}
+
+static char *http_url_encode(const char *originalText)
+{
+ // allocate memory for the worst possible case (all characters need to be encoded)
+ char *encodedText = (char *)malloc(sizeof(char) * strlen(originalText) * 3 + 1);
+ const char *hex = "0123456789abcdef";
+ int pos = 0;
+ for (size_t i = 0; i < strlen(originalText); i++)
+ {
+ if (('a' <= originalText[i] && originalText[i] <= 'z') || ('A' <= originalText[i] && originalText[i] <= 'Z') || ('0' <= originalText[i] && originalText[i] <= '9'))
+ {
+ encodedText[pos++] = originalText[i];
+ }
+ else if (originalText[i] == ' ')
+ {
+ encodedText[pos++] = '%';
+ encodedText[pos++] = hex[originalText[i] >> 4];
+ encodedText[pos++] = hex[originalText[i] & 15];
+ }
+ else
+ {
+ encodedText[pos++] = originalText[i];
+ }
+ }
+ encodedText[pos] = '\0';
+ return encodedText;
+}
+
+int stellar_dump_ctrllink_init(const struct stellar_dump_args *st_dump_arg)
+{
+ g_ctrllink_http_client = evhttp_client_new(st_dump_arg->stellar_server_ip, st_dump_arg->stellar_server_port_host_order);
+ char probe_cmd[256] = {};
+ snprintf(probe_cmd, sizeof(probe_cmd), "%s%s", CTRLLINK_CMD_URI_PREFIX, "ping stellar-dump-start");
+ char *encoded_url = http_url_encode(probe_cmd);
+ evhttp_run_cmd(g_ctrllink_http_client, encoded_url);
+ free(encoded_url);
+ if (g_ctrllink_http_client->response_code != 200)
+ {
+ fprintf(stderr, "Could not connect to stellar monitor server %s:%u\n", st_dump_arg->stellar_server_ip, st_dump_arg->stellar_server_port_host_order);
+ exit(1);
+ }
+ if (g_ctrllink_http_client->response_cstr)
+ {
+ free(g_ctrllink_http_client->response_cstr);
+ g_ctrllink_http_client->response_cstr = NULL;
+ }
+ return 0;
+}
+
+void stellar_dump_ctrllink_free(void)
+{
+ if (g_ctrllink_http_client)
+ {
+ evhttp_connection_free(g_ctrllink_http_client->conn);
+ event_base_loopbreak(g_ctrllink_http_client->base);
+ event_base_free(g_ctrllink_http_client->base);
+ if (g_ctrllink_http_client->response_cstr)
+ {
+ free(g_ctrllink_http_client->response_cstr);
+ g_ctrllink_http_client->response_cstr = NULL;
+ }
+ free(g_ctrllink_http_client);
+ g_ctrllink_http_client = NULL;
+ }
+}
+
+int stellar_dump_start(const struct stellar_dump_args *st_dump_arg)
+{
+ char dump_cmd[4096] = {};
+ strcat(dump_cmd, CTRLLINK_CMD_URI_PREFIX);
+ strcat(dump_cmd, "tcpdump ");
+
+ /* necessary arg */
+ sprintf(dump_cmd, "%s%s%s%u ", CTRLLINK_CMD_URI_PREFIX, "tcpdump ", "datalinkport ", st_dump_arg->datalink_recv_port_host_order);
+
+ /* optional args */
+ if (st_dump_arg->greedy_seek)
+ {
+ strcat(dump_cmd, "greedy ");
+ }
+ if (st_dump_arg->thread_enable_expression)
+ {
+ strcat(dump_cmd, "threads ");
+ strcat(dump_cmd, st_dump_arg->thread_enable_expression);
+ strcat(dump_cmd, " ");
+ }
+ if (st_dump_arg->bpf)
+ {
+ strcat(dump_cmd, "bpf ");
+ strcat(dump_cmd, st_dump_arg->bpf);
+ strcat(dump_cmd, " ");
+ }
+ char *encoded_url = http_url_encode(dump_cmd);
+ evhttp_run_cmd(g_ctrllink_http_client, encoded_url);
+ free(encoded_url);
+ if (g_ctrllink_http_client->response_code != 200)
+ {
+ fprintf(stderr, "Starting packet dump from server %s:%u : %s\r\n",
+ st_dump_arg->stellar_server_ip, st_dump_arg->stellar_server_port_host_order, g_ctrllink_http_client->response_cstr);
+ exit(1);
+ }
+ if (g_ctrllink_http_client->response_cstr)
+ {
+ free(g_ctrllink_http_client->response_cstr);
+ g_ctrllink_http_client->response_cstr = NULL;
+ }
+ return 0;
+}
+
+int stellar_dump_ctrllink_keepalive_start(const struct stellar_dump_args *st_dump_arg)
+{
+ keepalive_running = 1;
+ pthread_create(&keepalive_thread_id, NULL, stellar_dump_ctrllink_keepalive, (void *)st_dump_arg);
+ return 0;
+}
+
+void stellar_dump_ctrllink_keepalive_stop(void)
+{
+ keepalive_running = 0;
+ if (keepalive_thread_id != 0)
+ {
+ pthread_cancel(keepalive_thread_id);
+ pthread_join(keepalive_thread_id, NULL);
+ keepalive_thread_id = 0;
+ }
+}
diff -uNr tcpdump-tcpdump-4.99.4/stellar_dump_data_link.c tcpdump-for-stellar/stellar_dump_data_link.c
--- tcpdump-tcpdump-4.99.4/stellar_dump_data_link.c 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/stellar_dump_data_link.c 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,69 @@
+#include "stellar_dump.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pcap/pcap.h>
+#include <sys/types.h> /* See NOTES */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <errno.h>
+static int sockfd;
+
+int stellar_dump_datalink_init(struct stellar_dump_args *out_arg)
+{
+ uint16_t port;
+ struct sockaddr_in datalink_addr = {};
+ datalink_addr.sin_family = AF_INET;
+ datalink_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+ sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sockfd < 0)
+ {
+ perror("socket");
+ return -1;
+ }
+ // int opt = 1;
+ // if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int)) == -1)
+ // {
+ // perror("setsockopt SO_REUSEADDR");
+ // return -1;
+ // }
+
+ struct timeval tv = {};
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
+ setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));
+
+ /* find an available port */
+ for (port = 60000; port < 65535; port++)
+ {
+ datalink_addr.sin_port = htons(port);
+ if (bind(sockfd, (struct sockaddr *)&datalink_addr, sizeof(datalink_addr)) != -1)
+ {
+ break;
+ }
+ }
+ if (port >= 65535)
+ {
+ fprintf(stderr, "no available data link port found\n");
+ return -1;
+ }
+ out_arg->datalink_recv_port_host_order = port;
+ return port;
+}
+
+ssize_t stellar_dump_datalink_recv(void *buf, size_t len, char **raw_pkt_start_ptr, struct pcap_pkthdr *phdr)
+{
+ ssize_t n;
+ n = recv(sockfd, buf, len, 0);
+ if (n < TZSP_HDR_LEN)
+ {
+ return -1;
+ }
+ gettimeofday(&phdr->ts, NULL);
+ phdr->caplen = n - TZSP_HDR_LEN;
+ phdr->len = n - TZSP_HDR_LEN;
+ *raw_pkt_start_ptr = (char *)buf + TZSP_HDR_LEN;
+ return n;
+}
\ No newline at end of file
diff -uNr tcpdump-tcpdump-4.99.4/stellar_dump.h tcpdump-for-stellar/stellar_dump.h
--- tcpdump-tcpdump-4.99.4/stellar_dump.h 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/stellar_dump.h 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,42 @@
+#pragma once
+#ifndef __FAVOR_BSD
+#define __FAVOR_BSD 1
+#endif
+#include <stdio.h>
+#include <stdint.h>
+#include <pcap/pcap.h>
+
+#define STELLAR_DUMP (1)
+#define PROGRAM_NAME "stellar_dump"
+
+#define CTRLLINK_DEFAULT_IP "127.0.0.1"
+#define CTRLLINK_DEFAULT_PORT 80
+
+#define TZSP_UDP_PORT 37008 /* default port of TZSP protocol: https://en.wikipedia.org/wiki/TZSP# */
+#define TZSP_HDR_LEN 5 /* length of TZSP header */
+
+#define CTRLLINK_CONNECT_TIMEOUT 3 /* seconds */
+
+#define DATALINK_RECV_BUF_SIZE 4096
+
+#define CTRLLINK_CMD_URI_PREFIX "/v1/stellar_monitor?raw_cmd="
+
+struct stellar_dump_args
+{
+ char *stellar_server_ip;
+ unsigned short stellar_server_port_host_order;
+ unsigned short datalink_recv_port_host_order;
+ int greedy_seek;
+ char *thread_enable_expression;
+ char *bpf;
+ int expect_packet_count; // arg -c
+};
+
+int stellar_dump_ctrllink_init(const struct stellar_dump_args *st_dump_arg);
+void stellar_dump_ctrllink_free(void);
+int stellar_dump_ctrllink_keepalive_start(const struct stellar_dump_args *st_dump_arg);
+void stellar_dump_ctrllink_keepalive_stop(void);
+
+int stellar_dump_datalink_init(struct stellar_dump_args *out_arg);
+int stellar_dump_start(const struct stellar_dump_args *st_dump_arg);
+ssize_t stellar_dump_datalink_recv(void *buf, size_t len, char **raw_pkt_start_ptr, struct pcap_pkthdr *phdr);
\ No newline at end of file
diff -uNr tcpdump-tcpdump-4.99.4/tcpdump.c tcpdump-for-stellar/tcpdump.c
--- tcpdump-tcpdump-4.99.4/tcpdump.c 2023-04-08 02:30:58.000000000 +0800
+++ tcpdump-for-stellar/tcpdump.c 2024-10-30 17:34:05.655498702 +0800
@@ -1,4 +1,4 @@
-/*
+/* PATCH FOR STELLAR-DUMP
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
* The Regents of the University of California. All rights reserved.
*
@@ -33,6 +33,24 @@
* combined efforts of Van, Steve McCanne and Craig Leres of LBL.
*/
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-function"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#pragma clang diagnostic ignored "-Wunused-macros"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-macros"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#include "stellar_dump.h"
+
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
@@ -57,7 +75,7 @@
*/
#ifndef lint
static const char copyright[] _U_ =
- "@(#) Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000\n\
+ "@(#) Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000\n\
The Regents of the University of California. All rights reserved.\n";
#endif
@@ -91,8 +109,8 @@
#include <libcasper.h>
#include <casper/cap_dns.h>
#include <sys/nv.h>
-#endif /* HAVE_CASPER */
-#endif /* HAVE_CAPSICUM */
+#endif /* HAVE_CASPER */
+#endif /* HAVE_CAPSICUM */
#ifdef HAVE_PCAP_OPEN
/*
* We found pcap_open() in the capture library, so we'll be using
@@ -116,6 +134,7 @@
#include <stdlib.h>
#include <string.h>
#include <limits.h>
+#include <ctype.h>
#ifdef _WIN32
#include <windows.h>
#else
@@ -131,9 +150,9 @@
* Use this in pathnames, but do *not* use it in URLs.
*/
#ifdef _WIN32
-#define PATH_SEPARATOR '\\'
+#define PATH_SEPARATOR '\\'
#else
-#define PATH_SEPARATOR '/'
+#define PATH_SEPARATOR '/'
#endif
/* capabilities convenience library */
@@ -182,19 +201,19 @@
#endif
#if defined(HAVE_PCAP_CREATE) || defined(_WIN32)
-static int Bflag; /* buffer size */
+static int Bflag; /* buffer size */
#endif
#ifdef HAVE_PCAP_DUMP_FTELL64
-static int64_t Cflag; /* rotate dump files after this many bytes */
+static int64_t Cflag; /* rotate dump files after this many bytes */
#else
-static long Cflag; /* rotate dump files after this many bytes */
+static long Cflag; /* rotate dump files after this many bytes */
#endif
-static int Cflag_count; /* Keep track of which file number we're writing */
+static int Cflag_count; /* Keep track of which file number we're writing */
#ifdef HAVE_PCAP_FINDALLDEVS
-static int Dflag; /* list available devices and exit */
+static int Dflag; /* list available devices and exit */
#endif
#ifdef HAVE_PCAP_FINDALLDEVS_EX
-static char *remote_interfaces_source; /* list available devices from this source and exit */
+static char *remote_interfaces_source; /* list available devices from this source and exit */
#endif
/*
@@ -210,28 +229,28 @@
* *export* a routine to set that flag.
*/
extern int dflag;
-int dflag; /* print filter code */
-static int Gflag; /* rotate dump files after this many seconds */
-static int Gflag_count; /* number of files created with Gflag rotation */
-static time_t Gflag_time; /* The last time_t the dump file was rotated. */
-static int Lflag; /* list available data link types and exit */
-static int Iflag; /* rfmon (monitor) mode */
+int dflag; /* print filter code */
+static int Gflag; /* rotate dump files after this many seconds */
+static int Gflag_count; /* number of files created with Gflag rotation */
+static time_t Gflag_time; /* The last time_t the dump file was rotated. */
+static int Lflag; /* list available data link types and exit */
+static int Iflag; /* rfmon (monitor) mode */
#ifdef HAVE_PCAP_SET_TSTAMP_TYPE
-static int Jflag; /* list available time stamp types */
-static int jflag = -1; /* packet time stamp source */
+static int Jflag; /* list available time stamp types */
+static int jflag = -1; /* packet time stamp source */
#endif
-static int lflag; /* line-buffered output */
-static int pflag; /* don't go promiscuous */
+static int lflag; /* line-buffered output */
+static int pflag; /* don't go promiscuous */
#ifdef HAVE_PCAP_SETDIRECTION
-static int Qflag = -1; /* restrict captured packet by send/receive direction */
+static int Qflag = -1; /* restrict captured packet by send/receive direction */
#endif
#ifdef HAVE_PCAP_DUMP_FLUSH
-static int Uflag; /* "unbuffered" output of dump files */
+static int Uflag; /* "unbuffered" output of dump files */
#endif
-static int Wflag; /* recycle output files after this number of files */
+static int Wflag; /* recycle output files after this number of files */
static int WflagChars;
-static char *zflag = NULL; /* compress each savefile using a specified command (like gzip or bzip2) */
-static int timeout = 1000; /* default timeout = 1000 ms = 1 s */
+static char *zflag = NULL; /* compress each savefile using a specified command (like gzip or bzip2) */
+static int timeout = 1000; /* default timeout = 1000 ms = 1 s */
#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
static int immediate_mode;
#endif
@@ -246,7 +265,7 @@
static NORETURN void error(FORMAT_STRING(const char *), ...) PRINTFLIKE(1, 2);
static void warning(FORMAT_STRING(const char *), ...) PRINTFLIKE(1, 2);
static NORETURN void exit_tcpdump(int);
-static void (*setsignal (int sig, void (*func)(int)))(int);
+static void (*setsignal(int sig, void (*func)(int)))(int);
static void cleanup(int);
static void child_cleanup(int);
static void print_version(FILE *);
@@ -262,9 +281,9 @@
static NORETURN void show_remote_devices_and_exit(void);
#endif
-static void print_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
+void print_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
static void dump_packet_and_trunc(u_char *, const struct pcap_pkthdr *, const u_char *);
-static void dump_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
+void dump_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
static void droproot(const char *, const char *);
#ifdef SIGNAL_REQ_INFO
@@ -276,10 +295,10 @@
#endif
#ifdef _WIN32
- static HANDLE timer_handle = INVALID_HANDLE_VALUE;
- static void CALLBACK verbose_stats_dump(PVOID param, BOOLEAN timer_fired);
-#else /* _WIN32 */
- static void verbose_stats_dump(int sig);
+static HANDLE timer_handle = INVALID_HANDLE_VALUE;
+static void CALLBACK verbose_stats_dump(PVOID param, BOOLEAN timer_fired);
+#else /* _WIN32 */
+static void verbose_stats_dump(int sig);
#endif /* _WIN32 */
static void info(int);
@@ -288,38 +307,82 @@
#ifdef HAVE_PCAP_FINDALLDEVS
static const struct tok status_flags[] = {
#ifdef PCAP_IF_UP
- { PCAP_IF_UP, "Up" },
+ {PCAP_IF_UP, "Up"},
#endif
#ifdef PCAP_IF_RUNNING
- { PCAP_IF_RUNNING, "Running" },
+ {PCAP_IF_RUNNING, "Running"},
#endif
- { PCAP_IF_LOOPBACK, "Loopback" },
+ {PCAP_IF_LOOPBACK, "Loopback"},
#ifdef PCAP_IF_WIRELESS
- { PCAP_IF_WIRELESS, "Wireless" },
+ {PCAP_IF_WIRELESS, "Wireless"},
#endif
- { 0, NULL }
-};
+ {0, NULL}};
#endif
static pcap_t *pd;
static pcap_dumper_t *pdd = NULL;
static int supports_monitor_mode;
-
extern int optind;
extern int opterr;
extern char *optarg;
-struct dump_info {
- char *WFileName;
- char *CurrentFileName;
- pcap_t *pd;
+static netdissect_options Ndo;
+static netdissect_options *ndo = &Ndo;
+u_char *pcap_userdata;
+static char *cp, *infile, *cmdbuf, *device, *RFileName, *VFileName, *WFileName;
+pcap_handler callback;
+static int print = 0;
+static FILE *VFile;
+static char VFileLine[PATH_MAX + 1];
+static char ebuf[PCAP_ERRBUF_SIZE];
+int dlt, i;
+static char *endp;
+static int cnt = -1, op;
+static bpf_u_int32 localnet = 0, netmask = 0;
+
+static int Oflag = 1; /* run filter code optimizer */
+static int yflag_dlt = -1;
+static const char *yflag_dlt_name = NULL;
+
+static const char *dlt_name;
+static struct bpf_program fcode;
+#ifndef _WIN32
+static void (*oldhandler)(int);
+#endif
+
+static const char *username = NULL;
+#ifndef _WIN32
+static const char *chroot_dir = NULL;
+#endif
+// static char *ret = NULL;
+static char *end;
+#ifdef HAVE_PCAP_FINDALLDEVS
+static pcap_if_t *devlist;
+static long devnum;
+#endif
+static int status;
+
+#ifdef HAVE_CAPSICUM
+static cap_rights_t rights;
+#endif /* HAVE_CAPSICUM */
+static int cansandbox;
+
+static int argc;
+static char **argv;
+
+struct dump_info
+{
+ char *WFileName;
+ char *CurrentFileName;
+ pcap_t *pd;
pcap_dumper_t *pdd;
netdissect_options *ndo;
#ifdef HAVE_CAPSICUM
- int dirfd;
+ int dirfd;
#endif
};
+static struct dump_info dumpinfo;
#if defined(HAVE_PCAP_SET_PARSER_DEBUG)
/*
@@ -330,10 +393,11 @@
*/
#ifdef _WIN32
__declspec(dllimport)
-#else /* _WIN32 */
+#else /* _WIN32 */
extern
#endif /* _WIN32 */
-void pcap_set_parser_debug(int);
+void
+pcap_set_parser_debug(int);
#elif defined(HAVE_PCAP_DEBUG) || defined(HAVE_YYDEBUG)
/*
* We don't have pcap_set_parser_debug() in libpcap, but we do have
@@ -347,7 +411,7 @@
extern int pcap_debug;
pcap_debug = value;
-#else /* HAVE_PCAP_DEBUG */
+#else /* HAVE_PCAP_DEBUG */
extern int yydebug;
yydebug = value;
@@ -366,10 +430,11 @@
*/
#ifdef _WIN32
__declspec(dllimport)
-#else /* _WIN32 */
+#else /* _WIN32 */
extern
#endif /* _WIN32 */
-void pcap_set_optimizer_debug(int);
+void
+pcap_set_optimizer_debug(int);
#endif
/* VARARGS */
@@ -382,7 +447,8 @@
va_start(ap, fmt);
(void)vfprintf(stderr, fmt, ap);
va_end(ap);
- if (*fmt) {
+ if (*fmt)
+ {
fmt += strlen(fmt);
if (fmt[-1] != '\n')
(void)fputc('\n', stderr);
@@ -401,15 +467,15 @@
va_start(ap, fmt);
(void)vfprintf(stderr, fmt, ap);
va_end(ap);
- if (*fmt) {
+ if (*fmt)
+ {
fmt += strlen(fmt);
if (fmt[-1] != '\n')
(void)fputc('\n', stderr);
}
}
-static void
-exit_tcpdump(int status)
+static void exit_tcpdump(int status)
{
nd_cleanup();
exit(status);
@@ -428,20 +494,25 @@
if (n_tstamp_types < 0)
error("%s", pcap_geterr(pc));
- if (n_tstamp_types == 0) {
+ if (n_tstamp_types == 0)
+ {
fprintf(stderr, "Time stamp type cannot be set for %s\n",
- device);
+ device);
exit_tcpdump(S_SUCCESS);
}
fprintf(stderr, "Time stamp types for %s (use option -j to set):\n",
- device);
- for (i = 0; i < n_tstamp_types; i++) {
+ device);
+ for (i = 0; i < n_tstamp_types; i++)
+ {
tstamp_type_name = pcap_tstamp_type_val_to_name(tstamp_types[i]);
- if (tstamp_type_name != NULL) {
- (void) fprintf(stderr, " %s (%s)\n", tstamp_type_name,
- pcap_tstamp_type_val_to_description(tstamp_types[i]));
- } else {
- (void) fprintf(stderr, " %d\n", tstamp_types[i]);
+ if (tstamp_type_name != NULL)
+ {
+ (void)fprintf(stderr, " %s (%s)\n", tstamp_type_name,
+ pcap_tstamp_type_val_to_description(tstamp_types[i]));
+ }
+ else
+ {
+ (void)fprintf(stderr, " %d\n", tstamp_types[i]);
}
}
pcap_free_tstamp_types(tstamp_types);
@@ -471,28 +542,32 @@
* not in monitor mode).
*/
if (supports_monitor_mode)
- (void) fprintf(stderr, "Data link types for %s %s (use option -y to set):\n",
- device,
- Iflag ? "when in monitor mode" : "when not in monitor mode");
+ (void)fprintf(stderr, "Data link types for %s %s (use option -y to set):\n",
+ device,
+ Iflag ? "when in monitor mode" : "when not in monitor mode");
else
- (void) fprintf(stderr, "Data link types for %s (use option -y to set):\n",
- device);
+ (void)fprintf(stderr, "Data link types for %s (use option -y to set):\n",
+ device);
- for (i = 0; i < n_dlts; i++) {
+ for (i = 0; i < n_dlts; i++)
+ {
dlt_name = pcap_datalink_val_to_name(dlts[i]);
- if (dlt_name != NULL) {
- (void) fprintf(stderr, " %s (%s)", dlt_name,
- pcap_datalink_val_to_description(dlts[i]));
+ if (dlt_name != NULL)
+ {
+ (void)fprintf(stderr, " %s (%s)", dlt_name,
+ pcap_datalink_val_to_description(dlts[i]));
/*
* OK, does tcpdump handle that type?
*/
if (!has_printer(dlts[i]))
- (void) fprintf(stderr, " (printing not supported)");
+ (void)fprintf(stderr, " (printing not supported)");
fprintf(stderr, "\n");
- } else {
- (void) fprintf(stderr, " DLT %d (printing not supported)\n",
- dlts[i]);
+ }
+ else
+ {
+ (void)fprintf(stderr, " DLT %d (printing not supported)\n",
+ dlts[i]);
}
}
#ifdef HAVE_PCAP_FREE_DATALINKS
@@ -511,16 +586,20 @@
if (pcap_findalldevs(&devlist, ebuf) < 0)
error("%s", ebuf);
- for (i = 0, dev = devlist; dev != NULL; i++, dev = dev->next) {
- printf("%d.%s", i+1, dev->name);
+ for (i = 0, dev = devlist; dev != NULL; i++, dev = dev->next)
+ {
+ printf("%d.%s", i + 1, dev->name);
if (dev->description != NULL)
printf(" (%s)", dev->description);
- if (dev->flags != 0) {
+ if (dev->flags != 0)
+ {
printf(" [");
printf("%s", bittok2str(status_flags, "none", dev->flags));
#ifdef PCAP_IF_WIRELESS
- if (dev->flags & PCAP_IF_WIRELESS) {
- switch (dev->flags & PCAP_IF_CONNECTION_STATUS) {
+ if (dev->flags & PCAP_IF_WIRELESS)
+ {
+ switch (dev->flags & PCAP_IF_CONNECTION_STATUS)
+ {
case PCAP_IF_CONNECTION_STATUS_UNKNOWN:
printf(", Association status unknown");
@@ -537,8 +616,11 @@
case PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE:
break;
}
- } else {
- switch (dev->flags & PCAP_IF_CONNECTION_STATUS) {
+ }
+ else
+ {
+ switch (dev->flags & PCAP_IF_CONNECTION_STATUS)
+ {
case PCAP_IF_CONNECTION_STATUS_UNKNOWN:
printf(", Connection status unknown");
@@ -575,10 +657,11 @@
int i;
if (pcap_findalldevs_ex(remote_interfaces_source, NULL, &devlist,
- ebuf) < 0)
+ ebuf) < 0)
error("%s", ebuf);
- for (i = 0, dev = devlist; dev != NULL; i++, dev = dev->next) {
- printf("%d.%s", i+1, dev->name);
+ for (i = 0, dev = devlist; dev != NULL; i++, dev = dev->next)
+ {
+ printf("%d.%s", i + 1, dev->name);
if (dev->description != NULL)
printf(" (%s)", dev->description);
if (dev->flags != 0)
@@ -625,29 +708,29 @@
* version of libpcap we're using.
*/
#if defined(HAVE_PCAP_CREATE) || defined(_WIN32)
-#define B_FLAG "B:"
-#define B_FLAG_USAGE " [ -B size ]"
+#define B_FLAG "B:"
+#define B_FLAG_USAGE " [ -B size ]"
#else /* defined(HAVE_PCAP_CREATE) || defined(_WIN32) */
#define B_FLAG
#define B_FLAG_USAGE
#endif /* defined(HAVE_PCAP_CREATE) || defined(_WIN32) */
#ifdef HAVE_PCAP_FINDALLDEVS
-#define D_FLAG "D"
+#define D_FLAG "D"
#else
#define D_FLAG
#endif
#ifdef HAVE_PCAP_CREATE
-#define I_FLAG "I"
+#define I_FLAG "I"
#else /* HAVE_PCAP_CREATE */
#define I_FLAG
#endif /* HAVE_PCAP_CREATE */
#ifdef HAVE_PCAP_SET_TSTAMP_TYPE
-#define j_FLAG "j:"
-#define j_FLAG_USAGE " [ -j tstamptype ]"
-#define J_FLAG "J"
+#define j_FLAG "j:"
+#define j_FLAG_USAGE " [ -j tstamptype ]"
+#define J_FLAG "J"
#else /* PCAP_ERROR_TSTAMP_TYPE_NOTSUP */
#define j_FLAG
#define j_FLAG_USAGE
@@ -667,12 +750,18 @@
#endif
#ifdef HAVE_PCAP_DUMP_FLUSH
-#define U_FLAG "U"
+#define U_FLAG "U"
#else
#define U_FLAG
#endif
+#if STELLAR_DUMP
+#define SHORTOPTS "aAb" B_FLAG "c:C:d" D_FLAG "eE:fF:G:hHi:" I_FLAG j_FLAG J_FLAG "KlLm:M:nNOpq" Q_FLAG "r:s:StT:u" U_FLAG "vV:w:W:xXy:Yz:Z:P:k:g#"
+static struct stellar_dump_args g_stellar_dump_arg = {};
+static volatile int g_stellar_dump_run = 1;
+#else
#define SHORTOPTS "aAb" B_FLAG "c:C:d" D_FLAG "eE:fF:G:hHi:" I_FLAG j_FLAG J_FLAG "KlLm:M:nNOpq" Q_FLAG "r:s:StT:u" U_FLAG "vV:w:W:xXy:Yz:Z:#"
+#endif
/*
* Long options.
@@ -694,65 +783,70 @@
* component of the entry for the long option, and have a case for that
* option in the switch statement.
*/
-#define OPTION_VERSION 128
-#define OPTION_TSTAMP_PRECISION 129
-#define OPTION_IMMEDIATE_MODE 130
-#define OPTION_PRINT 131
-#define OPTION_LIST_REMOTE_INTERFACES 132
-#define OPTION_TSTAMP_MICRO 133
-#define OPTION_TSTAMP_NANO 134
-#define OPTION_FP_TYPE 135
-#define OPTION_COUNT 136
+#define OPTION_VERSION 128
+#define OPTION_TSTAMP_PRECISION 129
+#define OPTION_IMMEDIATE_MODE 130
+#define OPTION_PRINT 131
+#define OPTION_LIST_REMOTE_INTERFACES 132
+#define OPTION_TSTAMP_MICRO 133
+#define OPTION_TSTAMP_NANO 134
+#define OPTION_FP_TYPE 135
+#define OPTION_COUNT 136
static const struct option longopts[] = {
#if defined(HAVE_PCAP_CREATE) || defined(_WIN32)
- { "buffer-size", required_argument, NULL, 'B' },
+ {"buffer-size", required_argument, NULL, 'B'},
#endif
- { "list-interfaces", no_argument, NULL, 'D' },
+ {"list-interfaces", no_argument, NULL, 'D'},
#ifdef HAVE_PCAP_FINDALLDEVS_EX
- { "list-remote-interfaces", required_argument, NULL, OPTION_LIST_REMOTE_INTERFACES },
+ {"list-remote-interfaces", required_argument, NULL, OPTION_LIST_REMOTE_INTERFACES},
#endif
- { "help", no_argument, NULL, 'h' },
- { "interface", required_argument, NULL, 'i' },
+ {"help", no_argument, NULL, 'h'},
+ {"serverip", required_argument, NULL, 'i'},
#ifdef HAVE_PCAP_CREATE
- { "monitor-mode", no_argument, NULL, 'I' },
+ {"monitor-mode", no_argument, NULL, 'I'},
#endif
#ifdef HAVE_PCAP_SET_TSTAMP_TYPE
- { "time-stamp-type", required_argument, NULL, 'j' },
- { "list-time-stamp-types", no_argument, NULL, 'J' },
+ {"time-stamp-type", required_argument, NULL, 'j'},
+ {"list-time-stamp-types", no_argument, NULL, 'J'},
#endif
#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
- { "micro", no_argument, NULL, OPTION_TSTAMP_MICRO},
- { "nano", no_argument, NULL, OPTION_TSTAMP_NANO},
- { "time-stamp-precision", required_argument, NULL, OPTION_TSTAMP_PRECISION},
-#endif
- { "dont-verify-checksums", no_argument, NULL, 'K' },
- { "list-data-link-types", no_argument, NULL, 'L' },
- { "no-optimize", no_argument, NULL, 'O' },
- { "no-promiscuous-mode", no_argument, NULL, 'p' },
+ {"micro", no_argument, NULL, OPTION_TSTAMP_MICRO},
+ {"nano", no_argument, NULL, OPTION_TSTAMP_NANO},
+ {"time-stamp-precision", required_argument, NULL, OPTION_TSTAMP_PRECISION},
+#endif
+ {"dont-verify-checksums", no_argument, NULL, 'K'},
+ {"list-data-link-types", no_argument, NULL, 'L'},
+ {"no-optimize", no_argument, NULL, 'O'},
+ {"no-promiscuous-mode", no_argument, NULL, 'p'},
#ifdef HAVE_PCAP_SETDIRECTION
- { "direction", required_argument, NULL, 'Q' },
+ {"direction", required_argument, NULL, 'Q'},
#endif
- { "snapshot-length", required_argument, NULL, 's' },
- { "absolute-tcp-sequence-numbers", no_argument, NULL, 'S' },
+ {"snapshot-length", required_argument, NULL, 's'},
+ {"absolute-tcp-sequence-numbers", no_argument, NULL, 'S'},
#ifdef HAVE_PCAP_DUMP_FLUSH
- { "packet-buffered", no_argument, NULL, 'U' },
+ {"packet-buffered", no_argument, NULL, 'U'},
#endif
- { "linktype", required_argument, NULL, 'y' },
+ {"linktype", required_argument, NULL, 'y'},
#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
- { "immediate-mode", no_argument, NULL, OPTION_IMMEDIATE_MODE },
+ {"immediate-mode", no_argument, NULL, OPTION_IMMEDIATE_MODE},
#endif
#ifdef HAVE_PCAP_SET_PARSER_DEBUG
- { "debug-filter-parser", no_argument, NULL, 'Y' },
+ {"debug-filter-parser", no_argument, NULL, 'Y'},
#endif
- { "relinquish-privileges", required_argument, NULL, 'Z' },
- { "count", no_argument, NULL, OPTION_COUNT },
- { "fp-type", no_argument, NULL, OPTION_FP_TYPE },
- { "number", no_argument, NULL, '#' },
- { "print", no_argument, NULL, OPTION_PRINT },
- { "version", no_argument, NULL, OPTION_VERSION },
- { NULL, 0, NULL, 0 }
-};
+ {"relinquish-privileges", required_argument, NULL, 'Z'},
+ {"count", no_argument, NULL, OPTION_COUNT},
+ {"fp-type", no_argument, NULL, OPTION_FP_TYPE},
+ {"number", no_argument, NULL, '#'},
+ {"print", no_argument, NULL, OPTION_PRINT},
+ {"version", no_argument, NULL, OPTION_VERSION},
+#if STELLAR_DUMP
+ {"greedy", no_argument, NULL, 'g'},
+ {"threads", required_argument, NULL, 'k'},
+ {"serverport", required_argument, NULL, 'P'},
+// {"classify", required_argument, NULL, 255},
+#endif
+ {NULL, 0, NULL, 0}};
#ifdef HAVE_PCAP_FINDALLDEVS_EX
#define LIST_REMOTE_INTERFACES_USAGE "[ --list-remote-interfaces remote-source ]"
@@ -777,11 +871,13 @@
error("Chroot without dropping root is insecure");
pw = getpwnam(username);
- if (pw) {
- if (chroot_dir) {
- if (chroot(chroot_dir) != 0 || chdir ("/") != 0)
+ if (pw)
+ {
+ if (chroot_dir)
+ {
+ if (chroot(chroot_dir) != 0 || chdir("/") != 0)
error("Couldn't chroot/chdir to '%.64s': %s",
- chroot_dir, pcap_strerror(errno));
+ chroot_dir, pcap_strerror(errno));
}
#ifdef HAVE_LIBCAP_NG
{
@@ -793,21 +889,23 @@
}
#else
if (initgroups(pw->pw_name, pw->pw_gid) != 0 ||
- setgid(pw->pw_gid) != 0 || setuid(pw->pw_uid) != 0)
+ setgid(pw->pw_gid) != 0 || setuid(pw->pw_uid) != 0)
error("Couldn't change to '%.32s' uid=%lu gid=%lu: %s",
- username,
- (unsigned long)pw->pw_uid,
- (unsigned long)pw->pw_gid,
- pcap_strerror(errno));
- else {
+ username,
+ (unsigned long)pw->pw_uid,
+ (unsigned long)pw->pw_gid,
+ pcap_strerror(errno));
+ else
+ {
fprintf(stderr, "dropped privs to %s\n", username);
}
#endif /* HAVE_LIBCAP_NG */
- } else
+ }
+ else
error("Couldn't find user '%.32s'", username);
#ifdef HAVE_LIBCAP_NG
/* We don't need CAP_SETUID, CAP_SETGID and CAP_SYS_CHROOT any more. */
-DIAG_OFF_ASSIGN_ENUM
+ DIAG_OFF_ASSIGN_ENUM
capng_updatev(
CAPNG_DROP,
CAPNG_EFFECTIVE | CAPNG_PERMITTED,
@@ -815,10 +913,9 @@
CAP_SETGID,
CAP_SYS_CHROOT,
-1);
-DIAG_ON_ASSIGN_ENUM
+ DIAG_ON_ASSIGN_ENUM
capng_apply(CAPNG_SELECT_BOTH);
#endif /* HAVE_LIBCAP_NG */
-
}
#endif /* _WIN32 */
@@ -828,7 +925,8 @@
int c = 0;
x -= 1;
- while (x > 0) {
+ while (x > 0)
+ {
c += 1;
x /= 10;
}
@@ -836,56 +934,61 @@
return c;
}
-
static void
MakeFilename(char *buffer, char *orig_name, int cnt, int max_chars)
{
- char *filename = malloc(PATH_MAX + 1);
- if (filename == NULL)
- error("%s: malloc", __func__);
- if (strlen(orig_name) == 0)
- error("an empty string is not a valid file name");
-
- /* Process with strftime if Gflag is set. */
- if (Gflag != 0) {
- struct tm *local_tm;
-
- /* Convert Gflag_time to a usable format */
- if ((local_tm = localtime(&Gflag_time)) == NULL) {
- error("%s: localtime", __func__);
- }
-
- /* There's no good way to detect an error in strftime since a return
- * value of 0 isn't necessarily failure; if orig_name is an empty
- * string, the formatted string will be empty.
- *
- * However, the C90 standard says that, if there *is* a
- * buffer overflow, the content of the buffer is undefined,
- * so we must check for a buffer overflow.
- *
- * So we check above for an empty orig_name, and only call
- * strftime() if it's non-empty, in which case the return
- * value will only be 0 if the formatted date doesn't fit
- * in the buffer.
- *
- * (We check above because, even if we don't use -G, we
- * want a better error message than "tcpdump: : No such
- * file or directory" for this case.)
- */
- if (strftime(filename, PATH_MAX, orig_name, local_tm) == 0) {
- error("%s: strftime", __func__);
- }
- } else {
- strncpy(filename, orig_name, PATH_MAX);
- }
+ char *filename = malloc(PATH_MAX + 1);
+ if (filename == NULL)
+ error("%s: malloc", __func__);
+ if (strlen(orig_name) == 0)
+ error("an empty string is not a valid file name");
+
+ /* Process with strftime if Gflag is set. */
+ if (Gflag != 0)
+ {
+ struct tm *local_tm;
+
+ /* Convert Gflag_time to a usable format */
+ if ((local_tm = localtime(&Gflag_time)) == NULL)
+ {
+ error("%s: localtime", __func__);
+ return;
+ }
+
+ /* There's no good way to detect an error in strftime since a return
+ * value of 0 isn't necessarily failure; if orig_name is an empty
+ * string, the formatted string will be empty.
+ *
+ * However, the C90 standard says that, if there *is* a
+ * buffer overflow, the content of the buffer is undefined,
+ * so we must check for a buffer overflow.
+ *
+ * So we check above for an empty orig_name, and only call
+ * strftime() if it's non-empty, in which case the return
+ * value will only be 0 if the formatted date doesn't fit
+ * in the buffer.
+ *
+ * (We check above because, even if we don't use -G, we
+ * want a better error message than "tcpdump: : No such
+ * file or directory" for this case.)
+ */
+ if (strftime(filename, PATH_MAX, orig_name, local_tm) == 0)
+ {
+ error("%s: strftime", __func__);
+ return;
+ }
+ }
+ else
+ {
+ strncpy(filename, orig_name, PATH_MAX);
+ }
if (cnt == 0 && max_chars == 0)
strncpy(buffer, filename, PATH_MAX + 1);
- else
- if (snprintf(buffer, PATH_MAX + 1, "%s%0*d", filename, max_chars, cnt) > PATH_MAX)
- /* Report an error if the filename is too large */
- error("too many output files or filename is too long (> %d)", PATH_MAX);
- free(filename);
+ else if (snprintf(buffer, PATH_MAX + 1, "%s%0*d", filename, max_chars, cnt) > PATH_MAX)
+ /* Report an error if the filename is too large */
+ error("too many output files or filename is too long (> %d)", PATH_MAX);
+ free(filename);
}
static char *
@@ -898,7 +1001,7 @@
if (!ret)
return NULL;
- len = strlen (ptr);
+ len = strlen(ptr);
if (len > 0 && ptr[len - 1] == '\n')
ptr[len - 1] = '\0';
@@ -932,7 +1035,7 @@
return (capdnsloc);
}
-#endif /* HAVE_CASPER */
+#endif /* HAVE_CASPER */
#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
static int
@@ -950,7 +1053,8 @@
static const char *
tstamp_precision_to_string(int precision)
{
- switch (precision) {
+ switch (precision)
+ {
case PCAP_TSTAMP_PRECISION_MICRO:
return "micro";
@@ -962,6 +1066,7 @@
return "unknown";
}
}
+
#endif
#ifdef HAVE_CAPSICUM
@@ -1025,10 +1130,12 @@
cap_rights_t rights;
cap_rights_init(&rights, CAP_SEEK, CAP_WRITE, CAP_FCNTL);
- if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS) {
+ if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS)
+ {
error("unable to limit dump descriptor");
}
- if (cap_fcntls_limit(fd, CAP_FCNTL_GETFL) < 0 && errno != ENOSYS) {
+ if (cap_fcntls_limit(fd, CAP_FCNTL_GETFL) < 0 && errno != ENOSYS)
+ {
error("unable to limit dump descriptor fcntls");
}
}
@@ -1037,8 +1144,7 @@
/*
* Copy arg vector into a new buffer, concatenating arguments with spaces.
*/
-static char *
-copy_argv(char **argv)
+static char *copy_argv(char **argv)
{
char **p;
size_t len = 0;
@@ -1058,7 +1164,8 @@
p = argv;
dst = buf;
- while ((src = *p++) != NULL) {
+ while ((src = *p++) != NULL)
+ {
while ((*dst++ = *src++) != '\0')
;
dst[-1] = ' ';
@@ -1075,7 +1182,7 @@
* we define it as 0 if it's not defined, so it does nothing.
*/
#ifndef O_BINARY
-#define O_BINARY 0
+#define O_BINARY 0
#endif
static char *
@@ -1086,7 +1193,7 @@
char *cp;
our_statb buf;
- fd = open(fname, O_RDONLY|O_BINARY);
+ fd = open(fname, O_RDONLY | O_BINARY);
if (fd < 0)
error("can't open %s: %s", fname, pcap_strerror(errno));
@@ -1103,17 +1210,18 @@
cp = malloc((u_int)buf.st_size + 1);
if (cp == NULL)
error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
- fname, pcap_strerror(errno));
+ fname, pcap_strerror(errno));
cc = read(fd, cp, (u_int)buf.st_size);
if (cc < 0)
error("read %s: %s", fname, pcap_strerror(errno));
if (cc != buf.st_size)
- error("short read %s (%d != %d)", fname, (int) cc,
- (int)buf.st_size);
+ error("short read %s (%d != %d)", fname, (int)cc,
+ (int)buf.st_size);
close(fd);
/* replace "# comment" with spaces */
- for (i = 0; i < cc; i++) {
+ for (i = 0; i < cc; i++)
+ {
if (cp[i] == '#')
while (i < cc && cp[i] != '\n')
cp[i++] = ' ';
@@ -1135,19 +1243,22 @@
* of the device.
*/
p = strchr(device, ':');
- if (p != NULL) {
+ if (p != NULL)
+ {
/*
* We found it. Is it followed by "//"?
*/
- p++; /* skip the : */
- if (strncmp(p, "//", 2) == 0) {
+ p++; /* skip the : */
+ if (strncmp(p, "//", 2) == 0)
+ {
/*
* Yes. Search for the next /, at the end of the
* authority part of the URL.
*/
- p += 2; /* skip the // */
+ p += 2; /* skip the // */
p = strchr(p, '/');
- if (p != NULL) {
+ if (p != NULL)
+ {
/*
* OK, past the / is the path.
*/
@@ -1156,18 +1267,22 @@
}
}
devnum = strtol(device, &end, 10);
- if (device != end && *end == '\0') {
+ if (device != end && *end == '\0')
+ {
/*
* It's all-numeric, but is it a valid number?
*/
- if (devnum <= 0) {
+ if (devnum <= 0)
+ {
/*
* No, it's not an ordinal.
*/
error("Invalid adapter index");
}
return (devnum);
- } else {
+ }
+ else
+ {
/*
* It's not all-numeric; return -1, so our caller
* knows that.
@@ -1175,13 +1290,15 @@
return (-1);
}
}
+#endif
static char *
find_interface_by_number(const char *url
#ifndef HAVE_PCAP_FINDALLDEVS_EX
-_U_
+ _U_
#endif
-, long devnum)
+ ,
+ long devnum)
{
pcap_if_t *dev, *devlist;
long i;
@@ -1199,27 +1316,31 @@
* of the URL.
*/
endp = strchr(url, ':');
- if (endp != NULL) {
+ if (endp != NULL)
+ {
/*
* We found it. Is it followed by "//"?
*/
- endp++; /* skip the : */
- if (strncmp(endp, "//", 2) == 0) {
+ endp++; /* skip the : */
+ if (strncmp(endp, "//", 2) == 0)
+ {
/*
* Yes. Search for the next /, at the end of the
* authority part of the URL.
*/
- endp += 2; /* skip the // */
+ endp += 2; /* skip the // */
endp = strchr(endp, '/');
- } else
+ }
+ else
endp = NULL;
}
- if (endp != NULL) {
+ if (endp != NULL)
+ {
/*
* OK, everything from device to endp is a URL to hand
* to pcap_findalldevs_ex().
*/
- endp++; /* Include the trailing / in the URL; pcap_findalldevs_ex() requires it */
+ endp++; /* Include the trailing / in the URL; pcap_findalldevs_ex() requires it */
host_url = malloc(endp - url + 1);
if (host_url == NULL && (endp - url + 1) > 0)
error("Invalid allocation for host");
@@ -1228,24 +1349,30 @@
host_url[endp - url] = '\0';
status = pcap_findalldevs_ex(host_url, NULL, &devlist, ebuf);
free(host_url);
- } else
+ }
+ else
#endif
- status = pcap_findalldevs(&devlist, ebuf);
+ status = pcap_findalldevs(&devlist, ebuf);
if (status < 0)
+ {
error("%s", ebuf);
+ return NULL;
+ }
/*
* Look for the devnum-th entry in the list of devices (1-based).
*/
- for (i = 0, dev = devlist; i < devnum-1 && dev != NULL;
- i++, dev = dev->next)
+ for (i = 0, dev = devlist; i < devnum - 1 && dev != NULL;
+ i++, dev = dev->next)
;
if (dev == NULL)
+ {
error("Invalid adapter index");
+ return NULL;
+ }
device = strdup(dev->name);
pcap_freealldevs(devlist);
return (device);
}
-#endif
#ifdef HAVE_PCAP_OPEN
/*
@@ -1269,15 +1396,17 @@
* Is this an rpcap URL?
*/
if (strncmp(device, rpcap_prefix, sizeof(rpcap_prefix) - 1) == 0 ||
- strncmp(device, rpcap_ssl_prefix, sizeof(rpcap_ssl_prefix) - 1) == 0) {
+ strncmp(device, rpcap_ssl_prefix, sizeof(rpcap_ssl_prefix) - 1) == 0)
+ {
/*
* Yes. Open it with pcap_open().
*/
*ebuf = '\0';
pc = pcap_open(device, ndo->ndo_snaplen,
- pflag ? 0 : PCAP_OPENFLAG_PROMISCUOUS, timeout, NULL,
- ebuf);
- if (pc == NULL) {
+ pflag ? 0 : PCAP_OPENFLAG_PROMISCUOUS, timeout, NULL,
+ ebuf);
+ if (pc == NULL)
+ {
/*
* If this failed with "No such device" or "The system
* cannot find the device specified", that means
@@ -1286,7 +1415,7 @@
* actually an interface index.
*/
if (strstr(ebuf, "No such device") != NULL ||
- strstr(ebuf, "The system cannot find the device specified") != NULL)
+ strstr(ebuf, "The system cannot find the device specified") != NULL)
return (NULL);
error("%s", ebuf);
}
@@ -1298,7 +1427,8 @@
#ifdef HAVE_PCAP_CREATE
pc = pcap_create(device, ebuf);
- if (pc == NULL) {
+ if (pc == NULL)
+ {
/*
* If this failed with "No such device", that means
* the interface doesn't exist; return NULL, so that
@@ -1317,17 +1447,18 @@
status = pcap_set_tstamp_precision(pc, ndo->ndo_tstamp_precision);
if (status != 0)
error("%s: Can't set %ssecond time stamp precision: %s",
- device,
- tstamp_precision_to_string(ndo->ndo_tstamp_precision),
- pcap_statustostr(status));
+ device,
+ tstamp_precision_to_string(ndo->ndo_tstamp_precision),
+ pcap_statustostr(status));
#endif
#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
- if (immediate_mode) {
+ if (immediate_mode)
+ {
status = pcap_set_immediate_mode(pc, 1);
if (status != 0)
error("%s: Can't set immediate mode: %s",
- device, pcap_statustostr(status));
+ device, pcap_statustostr(status));
}
#endif
/*
@@ -1337,7 +1468,8 @@
supports_monitor_mode = 1;
else
supports_monitor_mode = 0;
- if (ndo->ndo_snaplen != 0) {
+ if (ndo->ndo_snaplen != 0)
+ {
/*
* A snapshot length was explicitly specified;
* use it.
@@ -1345,66 +1477,73 @@
status = pcap_set_snaplen(pc, ndo->ndo_snaplen);
if (status != 0)
error("%s: Can't set snapshot length: %s",
- device, pcap_statustostr(status));
+ device, pcap_statustostr(status));
}
status = pcap_set_promisc(pc, !pflag);
if (status != 0)
error("%s: Can't set promiscuous mode: %s",
- device, pcap_statustostr(status));
- if (Iflag) {
+ device, pcap_statustostr(status));
+ if (Iflag)
+ {
status = pcap_set_rfmon(pc, 1);
if (status != 0)
error("%s: Can't set monitor mode: %s",
- device, pcap_statustostr(status));
+ device, pcap_statustostr(status));
}
status = pcap_set_timeout(pc, timeout);
if (status != 0)
error("%s: pcap_set_timeout failed: %s",
- device, pcap_statustostr(status));
- if (Bflag != 0) {
+ device, pcap_statustostr(status));
+ if (Bflag != 0)
+ {
status = pcap_set_buffer_size(pc, Bflag);
if (status != 0)
error("%s: Can't set buffer size: %s",
- device, pcap_statustostr(status));
+ device, pcap_statustostr(status));
}
#ifdef HAVE_PCAP_SET_TSTAMP_TYPE
- if (jflag != -1) {
+ if (jflag != -1)
+ {
status = pcap_set_tstamp_type(pc, jflag);
if (status < 0)
error("%s: Can't set time stamp type: %s",
- device, pcap_statustostr(status));
+ device, pcap_statustostr(status));
else if (status > 0)
warning("When trying to set timestamp type '%s' on %s: %s",
- pcap_tstamp_type_val_to_name(jflag), device,
- pcap_statustostr(status));
+ pcap_tstamp_type_val_to_name(jflag), device,
+ pcap_statustostr(status));
}
#endif
status = pcap_activate(pc);
- if (status < 0) {
+ if (status < 0)
+ {
/*
* pcap_activate() failed.
*/
cp = pcap_geterr(pc);
if (status == PCAP_ERROR)
error("%s", cp);
- else if (status == PCAP_ERROR_NO_SUCH_DEVICE) {
+ else if (status == PCAP_ERROR_NO_SUCH_DEVICE)
+ {
/*
* Return an error for our caller to handle.
*/
snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s: %s\n(%s)",
- device, pcap_statustostr(status), cp);
- } else if (status == PCAP_ERROR_PERM_DENIED && *cp != '\0')
+ device, pcap_statustostr(status), cp);
+ }
+ else if (status == PCAP_ERROR_PERM_DENIED && *cp != '\0')
error("%s: %s\n(%s)", device,
- pcap_statustostr(status), cp);
+ pcap_statustostr(status), cp);
#ifdef __FreeBSD__
else if (status == PCAP_ERROR_RFMON_NOTSUP &&
- strncmp(device, "wlan", 4) == 0) {
+ strncmp(device, "wlan", 4) == 0)
+ {
char parent[8], newdev[8];
char sysctl[32];
size_t s = sizeof(parent);
snprintf(sysctl, sizeof(sysctl),
- "net.wlan.%d.%%parent", atoi(device + 4));
+ "net.wlan.%d.%%parent", atoi(device + 4));
sysctlbyname(sysctl, parent, &s, NULL, 0);
strlcpy(newdev, device, sizeof(newdev));
/* Suggest a new wlan device. */
@@ -1412,20 +1551,22 @@
* when the index is 9 or greater but the only consequence in this
* specific case would be an error message that looks a bit odd.
*/
- newdev[strlen(newdev)-1]++;
+ newdev[strlen(newdev) - 1]++;
error("%s is not a monitor mode VAP\n"
- "To create a new monitor mode VAP use:\n"
- " ifconfig %s create wlandev %s wlanmode monitor\n"
- "and use %s as the tcpdump interface",
- device, newdev, parent, newdev);
+ "To create a new monitor mode VAP use:\n"
+ " ifconfig %s create wlandev %s wlanmode monitor\n"
+ "and use %s as the tcpdump interface",
+ device, newdev, parent, newdev);
}
#endif
else
error("%s: %s", device,
- pcap_statustostr(status));
+ pcap_statustostr(status));
pcap_close(pc);
return (NULL);
- } else if (status > 0) {
+ }
+ else if (status > 0)
+ {
/*
* pcap_activate() succeeded, but it's warning us
* of a problem it had.
@@ -1434,22 +1575,23 @@
if (status == PCAP_WARNING)
warning("%s", cp);
else if (status == PCAP_WARNING_PROMISC_NOTSUP &&
- *cp != '\0')
+ *cp != '\0')
warning("%s: %s\n(%s)", device,
- pcap_statustostr(status), cp);
+ pcap_statustostr(status), cp);
else
warning("%s: %s", device,
- pcap_statustostr(status));
+ pcap_statustostr(status));
}
#ifdef HAVE_PCAP_SETDIRECTION
- if (Qflag != -1) {
+ if (Qflag != -1)
+ {
status = pcap_setdirection(pc, Qflag);
if (status != 0)
error("%s: pcap_setdirection() failed: %s",
- device, pcap_geterr(pc));
- }
+ device, pcap_geterr(pc));
+ }
#endif /* HAVE_PCAP_SETDIRECTION */
-#else /* HAVE_PCAP_CREATE */
+#else /* HAVE_PCAP_CREATE */
*ebuf = '\0';
/*
* If no snapshot length was specified, or a length of 0 was
@@ -1458,7 +1600,8 @@
if (ndo->ndo_snaplen == 0)
ndo->ndo_snaplen = MAXIMUM_SNAPLEN;
pc = pcap_open_live(device, ndo->ndo_snaplen, !pflag, timeout, ebuf);
- if (pc == NULL) {
+ if (pc == NULL)
+ {
/*
* If this failed with "No such device", that means
* the interface doesn't exist; return NULL, so that
@@ -1476,48 +1619,743 @@
return (pc);
}
-int
-main(int argc, char **argv)
+/*
+ * Catch a signal.
+ */
+static void (*setsignal(int sig, void (*func)(int)))(int)
{
- int cnt, op, i;
- bpf_u_int32 localnet = 0, netmask = 0;
- char *cp, *infile, *cmdbuf, *device, *RFileName, *VFileName, *WFileName;
- char *endp;
- pcap_handler callback;
- int dlt;
- const char *dlt_name;
- struct bpf_program fcode;
-#ifndef _WIN32
- void (*oldhandler)(int);
+#ifdef _WIN32
+ return (signal(sig, func));
+#else
+ struct sigaction old, new;
+
+ memset(&new, 0, sizeof(new));
+ new.sa_handler = func;
+ if ((sig == SIGCHLD)
+#ifdef SIGNAL_REQ_INFO
+ || (sig == SIGNAL_REQ_INFO)
#endif
- struct dump_info dumpinfo;
- u_char *pcap_userdata;
- char ebuf[PCAP_ERRBUF_SIZE];
- char VFileLine[PATH_MAX + 1];
- const char *username = NULL;
-#ifndef _WIN32
- const char *chroot_dir = NULL;
+#ifdef SIGNAL_FLUSH_PCAP
+ || (sig == SIGNAL_FLUSH_PCAP)
#endif
- char *ret = NULL;
- char *end;
-#ifdef HAVE_PCAP_FINDALLDEVS
- pcap_if_t *devlist;
- long devnum;
+ )
+ new.sa_flags = SA_RESTART;
+ if (sigaction(sig, &new, &old) < 0)
+ return (SIG_ERR);
+ return (old.sa_handler);
#endif
- int status;
- FILE *VFile;
+}
+
+/* make a clean exit on interrupts */
+static void cleanup(int signo _U_)
+{
+#ifdef _WIN32
+ if (timer_handle != INVALID_HANDLE_VALUE)
+ {
+ DeleteTimerQueueTimer(NULL, timer_handle, NULL);
+ CloseHandle(timer_handle);
+ timer_handle = INVALID_HANDLE_VALUE;
+ }
+#else /* _WIN32 */
+ struct itimerval timer;
+
+ timer.it_interval.tv_sec = 0;
+ timer.it_interval.tv_usec = 0;
+ timer.it_value.tv_sec = 0;
+ timer.it_value.tv_usec = 0;
+ setitimer(ITIMER_REAL, &timer, NULL);
+#endif /* _WIN32 */
+
+#ifdef HAVE_PCAP_BREAKLOOP
+ /*
+ * We have "pcap_breakloop()"; use it, so that we do as little
+ * as possible in the signal handler (it's probably not safe
+ * to do anything with standard I/O streams in a signal handler -
+ * the ANSI C standard doesn't say it is).
+ */
+ if (pd)
+ {
+ pcap_breakloop(pd);
+ pcap_close(pd);
+#ifdef HAVE_PCAP_DUMP_FLUSH
+ if (WFileName != NULL)
+ {
+ pcap_dump_flush(dumpinfo.pdd);
+ }
+#endif
+ pd = NULL;
+ }
+#else
+ /*
+ * We don't have "pcap_breakloop()"; this isn't safe, but
+ * it's the best we can do. Print the summary if we're
+ * not reading from a savefile - i.e., if we're doing a
+ * live capture - and exit.
+ */
+ if (pd != NULL && pcap_file(pd) == NULL)
+ {
+ /*
+ * We got interrupted, so perhaps we didn't
+ * manage to finish a line we were printing.
+ * Print an extra newline, just in case.
+ */
+ putchar('\n');
+ (void)fflush(stdout);
+ info(1);
+ }
+ exit_tcpdump(S_SUCCESS);
+#endif
+
+#if STELLAR_DUMP
+ if (fcode.bf_len != 0)
+ {
+ pcap_freecode(&fcode);
+ memset(&fcode, 0, sizeof(fcode));
+ }
+ g_stellar_dump_run = 0;
+ if (device != NULL) // for memleak check
+ {
+ free(device);
+ device = NULL;
+ }
+ if (RFileName == NULL && VFileName == NULL)
+ {
+ stellar_dump_ctrllink_keepalive_stop();
+ stellar_dump_ctrllink_free();
+ }
+ exit_tcpdump(S_SUCCESS);
+#endif
+}
+
+/*
+ On windows, we do not use a fork, so we do not care less about
+ waiting a child processes to die
+ */
+#if defined(HAVE_FORK) || defined(HAVE_VFORK)
+static void
+child_cleanup(int signo _U_)
+{
+ wait(NULL);
+}
+#endif /* HAVE_FORK && HAVE_VFORK */
+
+static void
+info(int verbose)
+{
+ struct pcap_stat stats;
+
+ /*
+ * Older versions of libpcap didn't set ps_ifdrop on some
+ * platforms; initialize it to 0 to handle that.
+ */
+ stats.ps_ifdrop = 0;
+ if (pcap_stats(pd, &stats) < 0)
+ {
+ (void)fprintf(stderr, "pcap_stats: %s\n", pcap_geterr(pd));
+ infoprint = 0;
+ return;
+ }
+
+ if (!verbose)
+ fprintf(stderr, "%s: ", program_name);
+
+ (void)fprintf(stderr, "%u packet%s captured", packets_captured,
+ PLURAL_SUFFIX(packets_captured));
+ if (!verbose)
+ fputs(", ", stderr);
+ else
+ putc('\n', stderr);
+ (void)fprintf(stderr, "%u packet%s received by filter", stats.ps_recv,
+ PLURAL_SUFFIX(stats.ps_recv));
+ if (!verbose)
+ fputs(", ", stderr);
+ else
+ putc('\n', stderr);
+ (void)fprintf(stderr, "%u packet%s dropped by kernel", stats.ps_drop,
+ PLURAL_SUFFIX(stats.ps_drop));
+ if (stats.ps_ifdrop != 0)
+ {
+ if (!verbose)
+ fputs(", ", stderr);
+ else
+ putc('\n', stderr);
+ (void)fprintf(stderr, "%u packet%s dropped by interface\n",
+ stats.ps_ifdrop, PLURAL_SUFFIX(stats.ps_ifdrop));
+ }
+ else
+ putc('\n', stderr);
+ infoprint = 0;
+}
+
+#if defined(HAVE_FORK) || defined(HAVE_VFORK)
+#ifdef HAVE_FORK
+#define fork_subprocess() fork()
+#else
+#define fork_subprocess() vfork()
+#endif
+static void
+compress_savefile(const char *filename)
+{
+ pid_t child;
+
+ child = fork_subprocess();
+ if (child == -1)
+ {
+ fprintf(stderr,
+ "compress_savefile: fork failed: %s\n",
+ pcap_strerror(errno));
+ return;
+ }
+ if (child != 0)
+ {
+ /* Parent process. */
+ return;
+ }
+
+ /*
+ * Child process.
+ * Set to lowest priority so that this doesn't disturb the capture.
+ */
+#ifdef NZERO
+ setpriority(PRIO_PROCESS, 0, NZERO - 1);
+#else
+ setpriority(PRIO_PROCESS, 0, 19);
+#endif
+ if (execlp(zflag, zflag, filename, (char *)NULL) == -1)
+ fprintf(stderr,
+ "compress_savefile: execlp(%s, %s) failed: %s\n",
+ zflag,
+ filename,
+ pcap_strerror(errno));
+#ifdef HAVE_FORK
+ exit(S_ERR_HOST_PROGRAM);
+#else
+ _exit(S_ERR_HOST_PROGRAM);
+#endif
+}
+#else /* HAVE_FORK && HAVE_VFORK */
+static void
+compress_savefile(const char *filename)
+{
+ fprintf(stderr,
+ "compress_savefile failed. Functionality not implemented under your system\n");
+}
+#endif /* HAVE_FORK && HAVE_VFORK */
+
+static void
+dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
+{
+ struct dump_info *dump_info;
+
+ ++packets_captured;
+
+ ++infodelay;
+
+ dump_info = (struct dump_info *)user;
+
+ /*
+ * XXX - this won't force the file to rotate on the specified time
+ * boundary, but it will rotate on the first packet received after the
+ * specified Gflag number of seconds. Note: if a Gflag time boundary
+ * and a Cflag size boundary coincide, the time rotation will occur
+ * first thereby cancelling the Cflag boundary (since the file should
+ * be 0).
+ */
+ if (Gflag != 0)
+ {
+ /* Check if it is time to rotate */
+ time_t t;
+
+ /* Get the current time */
+ if ((t = time(NULL)) == (time_t)-1)
+ {
+ error("%s: can't get current_time: %s",
+ __func__, pcap_strerror(errno));
+ }
+
+ /* If the time is greater than the specified window, rotate */
+ if (t - Gflag_time >= Gflag)
+ {
#ifdef HAVE_CAPSICUM
- cap_rights_t rights;
- int cansandbox;
-#endif /* HAVE_CAPSICUM */
- int Oflag = 1; /* run filter code optimizer */
- int yflag_dlt = -1;
- const char *yflag_dlt_name = NULL;
- int print = 0;
+ FILE *fp;
+ int fd;
+#endif
+
+ /* Update the Gflag_time */
+ Gflag_time = t;
+ /* Update Gflag_count */
+ Gflag_count++;
+ /*
+ * Close the current file and open a new one.
+ */
+ pcap_dump_close(dump_info->pdd);
+
+ /*
+ * Compress the file we just closed, if the user asked for it
+ */
+ if (zflag != NULL)
+ compress_savefile(dump_info->CurrentFileName);
+
+ /*
+ * Check to see if we've exceeded the Wflag (when
+ * not using Cflag).
+ */
+ if (Cflag == 0 && Wflag > 0 && Gflag_count >= Wflag)
+ {
+ (void)fprintf(stderr, "Maximum file limit reached: %d\n",
+ Wflag);
+ info(1);
+ exit_tcpdump(S_SUCCESS);
+ /* NOTREACHED */
+ }
+ if (dump_info->CurrentFileName != NULL)
+ free(dump_info->CurrentFileName);
+ /* Allocate space for max filename + \0. */
+ dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
+ if (dump_info->CurrentFileName == NULL)
+ error("dump_packet_and_trunc: malloc");
+ /*
+ * Gflag was set otherwise we wouldn't be here. Reset the count
+ * so multiple files would end with 1,2,3 in the filename.
+ * The counting is handled with the -C flow after this.
+ */
+ Cflag_count = 0;
+
+ /*
+ * This is always the first file in the Cflag
+ * rotation: e.g. 0
+ * We also don't need numbering if Cflag is not set.
+ */
+ if (Cflag != 0)
+ MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0,
+ WflagChars);
+ else
+ MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0, 0);
+
+#ifdef HAVE_LIBCAP_NG
+ capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+ capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+#ifdef HAVE_CAPSICUM
+ fd = openat(dump_info->dirfd,
+ dump_info->CurrentFileName,
+ O_CREAT | O_WRONLY | O_TRUNC, 0644);
+ if (fd < 0)
+ {
+ error("unable to open file %s",
+ dump_info->CurrentFileName);
+ }
+ fp = fdopen(fd, "w");
+ if (fp == NULL)
+ {
+ error("unable to fdopen file %s",
+ dump_info->CurrentFileName);
+ }
+ dump_info->pdd = pcap_dump_fopen(dump_info->pd, fp);
+#else /* !HAVE_CAPSICUM */
+ dump_info->pdd = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
+#endif
+#ifdef HAVE_LIBCAP_NG
+ capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+ capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+ if (dump_info->pdd == NULL)
+ error("%s", pcap_geterr(pd));
+#ifdef HAVE_CAPSICUM
+ set_dumper_capsicum_rights(dump_info->pdd);
+#endif
+ }
+ }
+
+ /*
+ * XXX - this won't prevent capture files from getting
+ * larger than Cflag - the last packet written to the
+ * file could put it over Cflag.
+ */
+ if (Cflag != 0)
+ {
+#ifdef HAVE_PCAP_DUMP_FTELL64
+ int64_t size = pcap_dump_ftell64(dump_info->pdd);
+#else
+ /*
+ * XXX - this only handles a Cflag value > 2^31-1 on
+ * LP64 platforms; to handle ILP32 (32-bit UN*X and
+ * Windows) or LLP64 (64-bit Windows) would require
+ * a version of libpcap with pcap_dump_ftell64().
+ */
+ long size = pcap_dump_ftell(dump_info->pdd);
+#endif
+
+ if (size == -1)
+ error("ftell fails on output file");
+ if (size > Cflag)
+ {
+#ifdef HAVE_CAPSICUM
+ FILE *fp;
+ int fd;
+#endif
+
+ /*
+ * Close the current file and open a new one.
+ */
+ pcap_dump_close(dump_info->pdd);
+
+ /*
+ * Compress the file we just closed, if the user
+ * asked for it.
+ */
+ if (zflag != NULL)
+ compress_savefile(dump_info->CurrentFileName);
+
+ Cflag_count++;
+ if (Wflag > 0)
+ {
+ if (Cflag_count >= Wflag)
+ Cflag_count = 0;
+ }
+ if (dump_info->CurrentFileName != NULL)
+ free(dump_info->CurrentFileName);
+ dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
+ if (dump_info->CurrentFileName == NULL)
+ error("%s: malloc", __func__);
+ MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, Cflag_count, WflagChars);
+#ifdef HAVE_LIBCAP_NG
+ capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+ capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+#ifdef HAVE_CAPSICUM
+ fd = openat(dump_info->dirfd, dump_info->CurrentFileName,
+ O_CREAT | O_WRONLY | O_TRUNC, 0644);
+ if (fd < 0)
+ {
+ error("unable to open file %s",
+ dump_info->CurrentFileName);
+ }
+ fp = fdopen(fd, "w");
+ if (fp == NULL)
+ {
+ error("unable to fdopen file %s",
+ dump_info->CurrentFileName);
+ }
+ dump_info->pdd = pcap_dump_fopen(dump_info->pd, fp);
+#else /* !HAVE_CAPSICUM */
+ dump_info->pdd = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
+#endif
+#ifdef HAVE_LIBCAP_NG
+ capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+ capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+ if (dump_info->pdd == NULL)
+ error("%s", pcap_geterr(pd));
+#ifdef HAVE_CAPSICUM
+ set_dumper_capsicum_rights(dump_info->pdd);
+#endif
+ }
+ }
+
+ pcap_dump((u_char *)dump_info->pdd, h, sp);
+#ifdef HAVE_PCAP_DUMP_FLUSH
+ if (Uflag)
+ pcap_dump_flush(dump_info->pdd);
+#endif
+
+ if (dump_info->ndo != NULL)
+ pretty_print_packet(dump_info->ndo, h, sp, packets_captured);
+
+ --infodelay;
+ if (infoprint)
+ info(0);
+}
+
+//#include "stellar/packet_manager.h"
+#include "packet_manager/packet_internal.h"
+#include "packet_manager/packet_parser.h"
+#include "stellar/log.h"
+#include "stellar/exdata.h"
+
+// fake variable and function
+__thread struct logger *__thread_local_logger = NULL;
+int exdata_set(struct exdata_runtime *rt, int idx, void *ex_ptr)
+{
+ return 0;
+}
+void *exdata_get(struct exdata_runtime *rt, int idx)
+{
+ return NULL;
+}
+int log_check_level(struct logger *logger, enum log_level level)
+{
+ return 0;
+}
+void log_print(struct logger *logger, enum log_level level, const char *module, const char *fmt, ...)
+{
+ return;
+}
+/*
+ * 0: not match
+ * not 0: match
+ */
+static int packet_filter_greedy(const struct pcap_pkthdr *h, const u_char *sp)
+{
+ if (NULL == cmdbuf || fcode.bf_len == 0)
+ {
+ return 1;
+ }
+
+ struct packet _pkt = {};
+ if (NULL == packet_parse(&_pkt, (char *)sp, h->caplen))
+ {
+ return 0;
+ }
+ struct packet *pkt = &_pkt;
+ const char *raw_pkt_hdr = packet_get_raw_data(pkt);
+ int raw_pkt_len = (int)packet_get_raw_len(pkt);
+ int pkt_layer = packet_get_layer_count(pkt);
+ int match = 0;
+ for (int i = 0; i < pkt_layer; i++)
+ {
+ const struct layer *layer = packet_get_layer_by_idx(pkt, i);
+ if (layer->proto == LAYER_PROTO_IPV4 || layer->proto == LAYER_PROTO_IPV6)
+ {
+ int remain_len = raw_pkt_len - (layer->hdr.raw - raw_pkt_hdr);
+ if (remain_len <= 0)
+ {
+ continue;
+ }
+ match = bpf_filter(fcode.bf_insns, (unsigned char *)layer->hdr.raw, remain_len, remain_len);
+ if (match)
+ {
+ break;
+ }
+ }
+ }
+ return match;
+}
+
+void dump_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
+{
+ struct dump_info *dump_info;
+ if ((g_stellar_dump_arg.greedy_seek != 0) && packet_filter_greedy(h, sp) == 0)
+ {
+ return;
+ }
+
+ ++packets_captured;
+
+ ++infodelay;
+
+ dump_info = (struct dump_info *)user;
+
+ pcap_dump((u_char *)dump_info->pdd, h, sp);
+#ifdef HAVE_PCAP_DUMP_FLUSH
+ if (Uflag)
+ pcap_dump_flush(dump_info->pdd);
+#endif
+
+ if (dump_info->ndo != NULL)
+ pretty_print_packet(dump_info->ndo, h, sp, packets_captured);
+
+ --infodelay;
+ if (infoprint)
+ info(0);
+}
+
+void print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
+{
+ if ((g_stellar_dump_arg.greedy_seek != 0) && packet_filter_greedy(h, sp) == 0)
+ {
+ return;
+ }
+ ++packets_captured;
+
+ ++infodelay;
+
+ if (!count_mode)
+ pretty_print_packet((netdissect_options *)user, h, sp, packets_captured);
+
+ --infodelay;
+ if (infoprint)
+ info(0);
+}
+
+#ifdef SIGNAL_REQ_INFO
+static void
+requestinfo(int signo _U_)
+{
+ if (infodelay)
+ ++infoprint;
+ else
+ info(0);
+}
+#endif
+
+#ifdef SIGNAL_FLUSH_PCAP
+static void
+flushpcap(int signo _U_)
+{
+ if (pdd != NULL)
+ pcap_dump_flush(pdd);
+}
+#endif
+
+static void
+print_packets_captured(void)
+{
+ static u_int prev_packets_captured, first = 1;
+
+ if (infodelay == 0 && (first || packets_captured != prev_packets_captured))
+ {
+ fprintf(stderr, "Got %u\r", packets_captured);
+ first = 0;
+ prev_packets_captured = packets_captured;
+ }
+}
+
+/*
+ * Called once each second in verbose mode while dumping to file
+ */
+#ifdef _WIN32
+static void CALLBACK verbose_stats_dump(PVOID param _U_,
+ BOOLEAN timer_fired _U_)
+{
+ print_packets_captured();
+}
+#else /* _WIN32 */
+static void verbose_stats_dump(int sig _U_)
+{
+ print_packets_captured();
+}
+#endif /* _WIN32 */
+
+DIAG_OFF_DEPRECATION
+static void
+print_version(FILE *f)
+{
+#ifndef HAVE_PCAP_LIB_VERSION
+#ifdef HAVE_PCAP_VERSION
+ extern char pcap_version[];
+#else /* HAVE_PCAP_VERSION */
+ static char pcap_version[] = "unknown";
+#endif /* HAVE_PCAP_VERSION */
+#endif /* HAVE_PCAP_LIB_VERSION */
+ const char *smi_version_string;
+
+ (void)fprintf(f, "%s version " PACKAGE_VERSION "\n", program_name);
+#ifdef HAVE_PCAP_LIB_VERSION
+ (void)fprintf(f, "%s\n", pcap_lib_version());
+#else /* HAVE_PCAP_LIB_VERSION */
+ (void)fprintf(f, "libpcap version %s\n", pcap_version);
+#endif /* HAVE_PCAP_LIB_VERSION */
+
+#if defined(HAVE_LIBCRYPTO) && defined(SSLEAY_VERSION)
+ (void)fprintf(f, "%s\n", SSLeay_version(SSLEAY_VERSION));
+#endif
+
+ smi_version_string = nd_smi_version_string();
+ if (smi_version_string != NULL)
+ (void)fprintf(f, "SMI-library: %s\n", smi_version_string);
+
+#if defined(__SANITIZE_ADDRESS__)
+ (void)fprintf(f, "Compiled with AddressSanitizer/GCC.\n");
+#elif defined(__has_feature)
+#if __has_feature(address_sanitizer)
+ (void)fprintf(f, "Compiled with AddressSanitizer/Clang.\n");
+#elif __has_feature(memory_sanitizer)
+ (void)fprintf(f, "Compiled with MemorySanitizer/Clang.\n");
+#endif
+#endif /* __SANITIZE_ADDRESS__ or __has_feature */
+}
+DIAG_ON_DEPRECATION
+
+static void
+print_usage(FILE *f)
+{
+ print_version(f);
+ (void)fprintf(f,
+ "Usage: %s [-Abd" D_FLAG "efhH" I_FLAG J_FLAG "KlLnNOpqStu" U_FLAG "vxX#]" B_FLAG_USAGE " [ -c count ] [--count]\n", program_name);
+ (void)fprintf(f,
+ "\t\t[ -C file_size ] [ -E algo:secret ] [ -F file ] [ -G seconds ]\n");
+#if STELLAR_DUMP == 0
+ (void)fprintf(f, "\t\t[ -i interface ]" IMMEDIATE_MODE_USAGE j_FLAG_USAGE "\n");
+#endif
+#ifdef HAVE_PCAP_FINDALLDEVS_EX
+ (void)fprintf(f,
+ "\t\t" LIST_REMOTE_INTERFACES_USAGE "\n");
+#endif
+#ifdef USE_LIBSMI
+ (void)fprintf(f,
+ "\t\t" m_FLAG_USAGE "\n");
+#endif
+
+ (void)fprintf(f, "\t\t[ -M secret ] [ --number ] [ --print ]" Q_FLAG_USAGE "\n");
+ (void)fprintf(f,
+ "\t\t[ -r file ] [ -s snaplen ] [ -T type ] [ --version ]\n");
+ (void)fprintf(f,
+ "\t\t[ -V file ] [ -w file ] [ -W filecount ] [ -y datalinktype ]\n");
+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+ (void)fprintf(f,
+ "\t\t[ --time-stamp-precision precision ] [ --micro ] [ --nano ]\n");
+#endif
+ (void)fprintf(f,
+ "\t\t[ -z postrotate-command ] [ -Z user ] [ expression ]\n");
+#if STELLAR_DUMP
+ (void)fprintf(f, "\n --- \033[1m%s %s ---\033[0m\n", "The following options are customized for", PROGRAM_NAME);
+ (void)fprintf(f, "\t\t[ -i ] not interface, is stellar monitor ip (default: 127.0.0.1)\n");
+ (void)fprintf(f, "\t\t[ -P ] stellar monitor port (default: 80)\n");
+ (void)fprintf(f, "\t\t[ -g ] enable greedy seek to most inner IP layer for tunnel protocol (default: disable)\n");
+ (void)fprintf(f, "\t\t[ -k ] which threads enable packet dump, support comma-separated values, for example: 1,3,5 (default: all threads)\n");
+#endif
+}
- netdissect_options Ndo;
- netdissect_options *ndo = &Ndo;
+// static netdissect_options Ndo;
+// static netdissect_options *ndo = &Ndo;
+// static struct dump_info dumpinfo;
+// u_char *pcap_userdata;
+// static char *cp, *infile, *cmdbuf, *device, *RFileName, *VFileName, *WFileName;
+// pcap_handler callback;
+// static int print = 0;
+// static FILE *VFile;
+// static char VFileLine[PATH_MAX + 1];
+// static char ebuf[PCAP_ERRBUF_SIZE];
+// int dlt, i;
+// static char *endp;
+// static int cnt, op;
+// static bpf_u_int32 localnet = 0, netmask = 0;
+
+// static int Oflag = 1; /* run filter code optimizer */
+// static int yflag_dlt = -1;
+// static const char *yflag_dlt_name = NULL;
+
+// static const char *dlt_name;
+// static struct bpf_program fcode;
+// #ifndef _WIN32
+// static void (*oldhandler)(int);
+// #endif
+
+// static const char *username = NULL;
+// #ifndef _WIN32
+// static const char *chroot_dir = NULL;
+// #endif
+// static char *ret = NULL;
+// static char *end;
+// #ifdef HAVE_PCAP_FINDALLDEVS
+// static pcap_if_t *devlist;
+// static long devnum;
+// #endif
+// static int status;
+
+// #ifdef HAVE_CAPSICUM
+// static cap_rights_t rights;
+// static int cansandbox;
+// #endif /* HAVE_CAPSICUM */
+// static int argc;
+// static char **argv;
+
+int tcpdump_parse_args(int f_argc, char **f_argv)
+{
+ argc = f_argc;
+ argv = f_argv;
/*
* Initialize the netdissect code.
*/
@@ -1558,9 +2396,9 @@
if (abort_on_misalignment(ebuf, sizeof(ebuf)) < 0)
error("%s", ebuf);
- while (
- (op = getopt_long(argc, argv, SHORTOPTS, longopts, NULL)) != -1)
- switch (op) {
+ while ((op = getopt_long(argc, argv, SHORTOPTS, longopts, NULL)) != -1)
+ switch (op)
+ {
case 'a':
/* compatibility for old -a */
@@ -1576,7 +2414,7 @@
#if defined(HAVE_PCAP_CREATE) || defined(_WIN32)
case 'B':
- Bflag = atoi(optarg)*1024;
+ Bflag = atoi(optarg) * 1024;
if (Bflag <= 0)
error("invalid packet buffer size %s", optarg);
break;
@@ -1586,6 +2424,7 @@
cnt = atoi(optarg);
if (cnt <= 0)
error("invalid packet count %s", optarg);
+ g_stellar_dump_arg.expect_packet_count = cnt;
break;
case 'C':
@@ -1595,12 +2434,11 @@
#else
Cflag = strtol(optarg, &endp, 10);
#endif
- if (endp == optarg || *endp != '\0' || errno != 0
- || Cflag <= 0)
+ if (endp == optarg || *endp != '\0' || errno != 0 || Cflag <= 0)
error("invalid file size %s", optarg);
- /*
- * Will multiplying it by 1000000 overflow?
- */
+ /*
+ * Will multiplying it by 1000000 overflow?
+ */
#ifdef HAVE_PCAP_DUMP_FTELL64
if (Cflag > INT64_T_CONSTANT(0x7fffffffffffffff) / 1000000)
#else
@@ -1649,18 +2487,24 @@
infile = optarg;
break;
+#if STELLAR_DUMP
+ case 'g':
+ g_stellar_dump_arg.greedy_seek = 1;
+ break;
+#endif
case 'G':
Gflag = atoi(optarg);
if (Gflag < 0)
error("invalid number of seconds %s", optarg);
- /* We will create one file initially. */
- Gflag_count = 0;
+ /* We will create one file initially. */
+ Gflag_count = 0;
/* Grab the current time for rotation use. */
- if ((Gflag_time = time(NULL)) == (time_t)-1) {
+ if ((Gflag_time = time(NULL)) == (time_t)-1)
+ {
error("%s: can't get current time: %s",
- __func__, pcap_strerror(errno));
+ __func__, pcap_strerror(errno));
}
break;
@@ -1674,8 +2518,20 @@
break;
case 'i':
+ {
+#if STELLAR_DUMP
+ uint32_t tmp_ip;
+ g_stellar_dump_arg.stellar_server_ip = optarg;
+ if (inet_pton(AF_INET, g_stellar_dump_arg.stellar_server_ip, &tmp_ip) != 1)
+ {
+ printf("invalid ip address %s\n", g_stellar_dump_arg.stellar_server_ip);
+ exit(1);
+ }
+#else
device = optarg;
- break;
+#endif
+ }
+ break;
#ifdef HAVE_PCAP_CREATE
case 'I':
@@ -1717,17 +2573,38 @@
lflag = 1;
break;
+#if STELLAR_DUMP
+ case 'k':
+ {
+ const char *ptr = optarg;
+ size_t len = strlen(optarg);
+ for (i = 0; i < (int)len; i++)
+ {
+ if (isxdigit(ptr[i]) == 0 && ptr[i] != ',')
+ {
+ printf("invalid threads expression: %s\n", optarg);
+ exit(1);
+ }
+ }
+ g_stellar_dump_arg.thread_enable_expression = optarg;
+ }
+ break;
+#endif
+
case 'K':
++ndo->ndo_Kflag;
break;
case 'm':
- if (nd_have_smi_support()) {
+ if (nd_have_smi_support())
+ {
if (nd_load_smi_module(optarg, ebuf, sizeof(ebuf)) == -1)
error("%s", ebuf);
- } else {
+ }
+ else
+ {
(void)fprintf(stderr, "%s: ignoring option `-m %s' ",
- program_name, optarg);
+ program_name, optarg);
(void)fprintf(stderr, "(no libsmi support)\n");
}
break;
@@ -1756,6 +2633,19 @@
++pflag;
break;
+#if STELLAR_DUMP
+ case 'P':
+ {
+ int tmp_port = atoi(optarg);
+ if (tmp_port <= 0 || tmp_port > 65535)
+ {
+ printf("invalid port %s\n", optarg);
+ exit(1);
+ }
+ g_stellar_dump_arg.stellar_server_port_host_order = (unsigned short)tmp_port;
+ }
+ break;
+#endif
case 'q':
++ndo->ndo_qflag;
++ndo->ndo_suppress_default_print;
@@ -1763,6 +2653,7 @@
#ifdef HAVE_PCAP_SETDIRECTION
case 'Q':
+#if STELLAR_DUMP == 0
if (ascii_strcasecmp(optarg, "in") == 0)
Qflag = PCAP_D_IN;
else if (ascii_strcasecmp(optarg, "out") == 0)
@@ -1771,6 +2662,10 @@
Qflag = PCAP_D_INOUT;
else
error("unknown capture direction `%s'", optarg);
+#else
+ fprintf(stderr, "unsupport '-Q' option for %s\n", PROGRAM_NAME);
+ return -1;
+#endif
break;
#endif /* HAVE_PCAP_SETDIRECTION */
@@ -1780,10 +2675,9 @@
case 's':
ndo->ndo_snaplen = (int)strtol(optarg, &end, 0);
- if (optarg == end || *end != '\0'
- || ndo->ndo_snaplen < 0 || ndo->ndo_snaplen > MAXIMUM_SNAPLEN)
+ if (optarg == end || *end != '\0' || ndo->ndo_snaplen < 0 || ndo->ndo_snaplen > MAXIMUM_SNAPLEN)
error("invalid snaplen %s (must be >= 0 and <= %d)",
- optarg, MAXIMUM_SNAPLEN);
+ optarg, MAXIMUM_SNAPLEN);
break;
case 'S':
@@ -1888,11 +2782,11 @@
#ifdef HAVE_PCAP_SET_PARSER_DEBUG
case 'Y':
- {
+ {
/* Undocumented flag */
pcap_set_parser_debug(1);
- }
- break;
+ }
+ break;
#endif
case 'z':
zflag = optarg;
@@ -1970,15 +2864,31 @@
#endif
#if defined(DLT_LINUX_SLL2) && defined(HAVE_PCAP_SET_DATALINK)
-/* Set default linktype DLT_LINUX_SLL2 when capturing on the "any" device */
- if (device != NULL &&
- strncmp (device, "any", strlen("any")) == 0
- && yflag_dlt == -1)
- yflag_dlt = DLT_LINUX_SLL2;
+ /* Set default linktype DLT_LINUX_SLL2 when capturing on the "any" device */
+ if (device != NULL &&
+ strncmp(device, "any", strlen("any")) == 0 && yflag_dlt == -1)
+ yflag_dlt = DLT_LINUX_SLL2;
#endif
- switch (ndo->ndo_tflag) {
+#if STELLAR_DUMP
+ /* set default value */
+ if (g_stellar_dump_arg.stellar_server_ip == NULL)
+ {
+ g_stellar_dump_arg.stellar_server_ip = CTRLLINK_DEFAULT_IP;
+ }
+ if (g_stellar_dump_arg.stellar_server_port_host_order == 0)
+ {
+ g_stellar_dump_arg.stellar_server_port_host_order = CTRLLINK_DEFAULT_PORT;
+ }
+#endif
+ return 0;
+}
+int tcpdump_prepare(void)
+{
+ char *ret;
+ switch (ndo->ndo_tflag)
+ {
case 0: /* Default */
case 1: /* No time stamp */
case 2: /* Unix timeval style */
@@ -2013,7 +2923,8 @@
#ifdef WITH_CHROOT
/* if run as root, prepare for chrooting */
- if (getuid() == 0 || geteuid() == 0) {
+ if (getuid() == 0 || geteuid() == 0)
+ {
/* future extensibility for cmd-line arguments */
if (!chroot_dir)
chroot_dir = WITH_CHROOT;
@@ -2022,14 +2933,16 @@
#ifdef WITH_USER
/* if run as root, prepare for dropping root privileges */
- if (getuid() == 0 || geteuid() == 0) {
+ if (getuid() == 0 || geteuid() == 0)
+ {
/* Run with '-Z root' to restore old behaviour */
if (!username)
username = WITH_USER;
}
#endif
- if (RFileName != NULL || VFileName != NULL) {
+ if (RFileName != NULL || VFileName != NULL)
+ {
/*
* If RFileName is non-null, it's the pathname of a
* savefile to read. If VFileName is non-null, it's
@@ -2049,10 +2962,11 @@
* people's trace files (especially if we're set-UID
* root).
*/
- if (setgid(getgid()) != 0 || setuid(getuid()) != 0 )
+ if (setgid(getgid()) != 0 || setuid(getuid()) != 0)
fprintf(stderr, "Warning: setgid/setuid failed !\n");
#endif /* _WIN32 */
- if (VFileName != NULL) {
+ if (VFileName != NULL)
+ {
if (VFileName[0] == '-' && VFileName[1] == '\0')
VFile = stdin;
else
@@ -2069,7 +2983,7 @@
#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
pd = pcap_open_offline_with_tstamp_precision(RFileName,
- ndo->ndo_tstamp_precision, ebuf);
+ ndo->ndo_tstamp_precision, ebuf);
#else
pd = pcap_open_offline(RFileName, ebuf);
#endif
@@ -2079,25 +2993,31 @@
#ifdef HAVE_CAPSICUM
cap_rights_init(&rights, CAP_READ);
if (cap_rights_limit(fileno(pcap_file(pd)), &rights) < 0 &&
- errno != ENOSYS) {
+ errno != ENOSYS)
+ {
error("unable to limit pcap descriptor");
}
#endif
dlt = pcap_datalink(pd);
dlt_name = pcap_datalink_val_to_name(dlt);
fprintf(stderr, "reading from file %s", RFileName);
- if (dlt_name == NULL) {
- fprintf(stderr, ", link-type %u", dlt);
- } else {
+ if (dlt_name == NULL)
+ {
+ fprintf(stderr, ", link-type %d", dlt);
+ }
+ else
+ {
fprintf(stderr, ", link-type %s (%s)", dlt_name,
- pcap_datalink_val_to_description(dlt));
+ pcap_datalink_val_to_description(dlt));
}
fprintf(stderr, ", snapshot length %d\n", pcap_snapshot(pd));
#ifdef DLT_LINUX_SLL2
if (dlt == DLT_LINUX_SLL2)
fprintf(stderr, "Warning: interface names might be incorrect\n");
#endif
- } else if (dflag && !device) {
+ }
+ else if (dflag && !device)
+ {
int dump_dlt = DLT_EN10MB;
/*
* We're dumping the compiled code without an explicit
@@ -2119,12 +3039,16 @@
dump_dlt = yflag_dlt;
else
fprintf(stderr, "Warning: assuming Ethernet\n");
- pd = pcap_open_dead(dump_dlt, ndo->ndo_snaplen);
- } else {
+ pd = pcap_open_dead(dump_dlt, ndo->ndo_snaplen);
+ }
+ else
+ {
/*
* We're doing a live capture.
*/
- if (device == NULL) {
+ if (device == NULL)
+ {
+#if STELLAR_DUMP == 0
/*
* No interface was specified. Pick one.
*/
@@ -2148,13 +3072,21 @@
if (device == NULL)
error("%s", ebuf);
#endif
+#else
+ device = strdup("lo");
+#endif
}
/*
* Try to open the interface with the specified name.
*/
+#if STELLAR_DUMP == 0
pd = open_interface(device, ndo, ebuf);
- if (pd == NULL) {
+#else
+ pd = pcap_open_dead(DLT_EN10MB, 65535);
+#endif
+ if (pd == NULL)
+ {
/*
* That failed. If we can get a list of
* interfaces, and the interface name
@@ -2164,7 +3096,8 @@
*/
#ifdef HAVE_PCAP_FINDALLDEVS
devnum = parse_interface_number(device);
- if (devnum == -1) {
+ if (devnum == -1)
+ {
/*
* It's not a number; just report
* the open error and fail.
@@ -2184,7 +3117,7 @@
pd = open_interface(device, ndo, ebuf);
if (pd == NULL)
error("%s", ebuf);
-#else /* HAVE_PCAP_FINDALLDEVS */
+#else /* HAVE_PCAP_FINDALLDEVS */
/*
* We can't get a list of interfaces; just
* fail.
@@ -2202,14 +3135,16 @@
fprintf(stderr, "Warning: setgid/setuid failed !\n");
#endif /* _WIN32 */
#if !defined(HAVE_PCAP_CREATE) && defined(_WIN32)
- if(Bflag != 0)
- if(pcap_setbuff(pd, Bflag)==-1){
+ if (Bflag != 0)
+ if (pcap_setbuff(pd, Bflag) == -1)
+ {
error("%s", pcap_geterr(pd));
}
#endif /* !defined(HAVE_PCAP_CREATE) && defined(_WIN32) */
if (Lflag)
show_dlts_and_exit(pd, device);
- if (yflag_dlt >= 0) {
+ if (yflag_dlt >= 0)
+ {
#ifdef HAVE_PCAP_SET_DATALINK
if (pcap_set_datalink(pd, yflag_dlt) < 0)
error("%s", pcap_geterr(pd));
@@ -2219,31 +3154,36 @@
* data link type, so we only let them
* set it to what it already is.
*/
- if (yflag_dlt != pcap_datalink(pd)) {
+ if (yflag_dlt != pcap_datalink(pd))
+ {
error("%s is not one of the DLTs supported by this device\n",
- yflag_dlt_name);
+ yflag_dlt_name);
}
#endif
(void)fprintf(stderr, "%s: data link type %s\n",
- program_name,
- pcap_datalink_val_to_name(yflag_dlt));
+ program_name,
+ pcap_datalink_val_to_name(yflag_dlt));
(void)fflush(stderr);
}
i = pcap_snapshot(pd);
- if (ndo->ndo_snaplen < i) {
+ if (ndo->ndo_snaplen < i)
+ {
if (ndo->ndo_snaplen != 0)
warning("snaplen raised from %d to %d", ndo->ndo_snaplen, i);
ndo->ndo_snaplen = i;
- } else if (ndo->ndo_snaplen > i) {
+ }
+ else if (ndo->ndo_snaplen > i)
+ {
warning("snaplen lowered from %d to %d", ndo->ndo_snaplen, i);
ndo->ndo_snaplen = i;
}
- if(ndo->ndo_fflag != 0) {
- if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {
- warning("foreign (-f) flag used but: %s", ebuf);
- }
- }
-
+ if (ndo->ndo_fflag != 0)
+ {
+ if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0)
+ {
+ warning("foreign (-f) flag used but: %s", ebuf);
+ }
+ }
}
if (infile)
cmdbuf = read_infile(infile);
@@ -2253,9 +3193,32 @@
#ifdef HAVE_PCAP_SET_OPTIMIZER_DEBUG
pcap_set_optimizer_debug(dflag);
#endif
- if (pcap_compile(pd, &fcode, cmdbuf, Oflag, netmask) < 0)
- error("%s", pcap_geterr(pd));
- if (dflag) {
+
+ if (cmdbuf != NULL)
+ {
+ int compile_ret;
+ if (RFileName != NULL)
+ {
+ if (g_stellar_dump_arg.greedy_seek == 0)
+ {
+ compile_ret = pcap_compile(pd, &fcode, cmdbuf, Oflag, netmask);
+ }
+ else
+ {
+ compile_ret = pcap_compile_nopcap(65535, DLT_RAW, &fcode, cmdbuf, Oflag, netmask);
+ }
+ }
+ else
+ {
+ compile_ret = pcap_compile_nopcap(65535, DLT_RAW, &fcode, cmdbuf, Oflag, netmask);
+ }
+ if (compile_ret < 0)
+ {
+ error("pcap_compile: %s", pcap_geterr(pd));
+ }
+ }
+ if (dflag)
+ {
bpf_dump(&fcode, dflag);
pcap_close(pd);
free(cmdbuf);
@@ -2263,10 +3226,14 @@
exit_tcpdump(S_SUCCESS);
}
+#if STELLAR_DUMP
+ g_stellar_dump_arg.bpf = cmdbuf;
+#endif
+
#ifdef HAVE_CASPER
if (!ndo->ndo_nflag)
capdns = capdns_setup();
-#endif /* HAVE_CASPER */
+#endif /* HAVE_CASPER */
init_print(ndo, localnet, netmask);
@@ -2303,52 +3270,60 @@
* savefile doesn't handle the general case.
*/
- if (getuid() == 0 || geteuid() == 0) {
+ if (getuid() == 0 || geteuid() == 0)
+ {
#ifdef HAVE_LIBCAP_NG
/* Initialize capng */
capng_clear(CAPNG_SELECT_BOTH);
- if (username) {
-DIAG_OFF_ASSIGN_ENUM
+ if (username)
+ {
+ DIAG_OFF_ASSIGN_ENUM
capng_updatev(
CAPNG_ADD,
CAPNG_PERMITTED | CAPNG_EFFECTIVE,
CAP_SETUID,
CAP_SETGID,
-1);
-DIAG_ON_ASSIGN_ENUM
+ DIAG_ON_ASSIGN_ENUM
}
- if (chroot_dir) {
-DIAG_OFF_ASSIGN_ENUM
+ if (chroot_dir)
+ {
+ DIAG_OFF_ASSIGN_ENUM
capng_update(
CAPNG_ADD,
CAPNG_PERMITTED | CAPNG_EFFECTIVE,
- CAP_SYS_CHROOT
- );
-DIAG_ON_ASSIGN_ENUM
+ CAP_SYS_CHROOT);
+ DIAG_ON_ASSIGN_ENUM
}
- if (WFileName) {
-DIAG_OFF_ASSIGN_ENUM
+ if (WFileName)
+ {
+ DIAG_OFF_ASSIGN_ENUM
capng_update(
CAPNG_ADD,
CAPNG_PERMITTED | CAPNG_EFFECTIVE,
- CAP_DAC_OVERRIDE
- );
-DIAG_ON_ASSIGN_ENUM
+ CAP_DAC_OVERRIDE);
+ DIAG_ON_ASSIGN_ENUM
}
capng_apply(CAPNG_SELECT_BOTH);
#endif /* HAVE_LIBCAP_NG */
if (username || chroot_dir)
droproot(username, chroot_dir);
-
}
#endif /* _WIN32 */
- if (pcap_setfilter(pd, &fcode) < 0)
- error("%s", pcap_geterr(pd));
+ if (RFileName)
+ {
+ if ((pd != NULL) && (cmdbuf != NULL) && (0 == g_stellar_dump_arg.greedy_seek) && pcap_setfilter(pd, &fcode) < 0)
+ {
+ error("%s", pcap_geterr(pd));
+ return -1;
+ }
+ }
#ifdef HAVE_CAPSICUM
- if (RFileName == NULL && VFileName == NULL && pcap_fileno(pd) != -1) {
- static const unsigned long cmds[] = { BIOCGSTATS, BIOCROTZBUF };
+ if (RFileName == NULL && VFileName == NULL && pcap_fileno(pd) != -1)
+ {
+ static const unsigned long cmds[] = {BIOCGSTATS, BIOCROTZBUF};
/*
* The various libpcap devices use a combination of
@@ -2357,16 +3332,20 @@
*/
cap_rights_init(&rights, CAP_IOCTL, CAP_READ, CAP_EVENT);
if (cap_rights_limit(pcap_fileno(pd), &rights) < 0 &&
- errno != ENOSYS) {
+ errno != ENOSYS)
+ {
error("unable to limit pcap descriptor");
}
if (cap_ioctls_limit(pcap_fileno(pd), cmds,
- sizeof(cmds) / sizeof(cmds[0])) < 0 && errno != ENOSYS) {
+ sizeof(cmds) / sizeof(cmds[0])) < 0 &&
+ errno != ENOSYS)
+ {
error("unable to limit ioctls on pcap descriptor");
}
}
#endif
- if (WFileName) {
+ if (WFileName)
+ {
/* Do not exceed the default PATH_MAX for files. */
dumpinfo.CurrentFileName = (char *)malloc(PATH_MAX + 1);
@@ -2375,9 +3354,9 @@
/* We do not need numbering for dumpfiles if Cflag isn't set. */
if (Cflag != 0)
- MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, WflagChars);
+ MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, WflagChars);
else
- MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, 0);
+ MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, 0);
pdd = pcap_dump_open(pd, dumpinfo.CurrentFileName);
#ifdef HAVE_LIBCAP_NG
@@ -2387,10 +3366,8 @@
*/
capng_update(
CAPNG_DROP,
- (Cflag || Gflag ? 0 : CAPNG_PERMITTED)
- | CAPNG_EFFECTIVE,
- CAP_DAC_OVERRIDE
- );
+ (Cflag || Gflag ? 0 : CAPNG_PERMITTED) | CAPNG_EFFECTIVE,
+ CAP_DAC_OVERRIDE);
capng_apply(CAPNG_SELECT_BOTH);
#endif /* HAVE_LIBCAP_NG */
if (pdd == NULL)
@@ -2398,7 +3375,8 @@
#ifdef HAVE_CAPSICUM
set_dumper_capsicum_rights(pdd);
#endif
- if (Cflag != 0 || Gflag != 0) {
+ if (Cflag != 0 || Gflag != 0)
+ {
#ifdef HAVE_CAPSICUM
/*
* basename() and dirname() may modify their input buffer
@@ -2409,71 +3387,83 @@
*/
char *WFileName_copy;
- if ((WFileName_copy = strdup(WFileName)) == NULL) {
+ if ((WFileName_copy = strdup(WFileName)) == NULL)
+ {
error("Unable to allocate memory for file %s",
- WFileName);
+ WFileName);
}
DIAG_OFF_C11_EXTENSIONS
dumpinfo.WFileName = strdup(basename(WFileName_copy));
DIAG_ON_C11_EXTENSIONS
- if (dumpinfo.WFileName == NULL) {
+ if (dumpinfo.WFileName == NULL)
+ {
error("Unable to allocate memory for file %s",
- WFileName);
+ WFileName);
}
free(WFileName_copy);
- if ((WFileName_copy = strdup(WFileName)) == NULL) {
+ if ((WFileName_copy = strdup(WFileName)) == NULL)
+ {
error("Unable to allocate memory for file %s",
- WFileName);
+ WFileName);
}
DIAG_OFF_C11_EXTENSIONS
char *WFileName_dirname = dirname(WFileName_copy);
DIAG_ON_C11_EXTENSIONS
dumpinfo.dirfd = open(WFileName_dirname,
- O_DIRECTORY | O_RDONLY);
- if (dumpinfo.dirfd < 0) {
+ O_DIRECTORY | O_RDONLY);
+ if (dumpinfo.dirfd < 0)
+ {
error("unable to open directory %s",
- WFileName_dirname);
+ WFileName_dirname);
}
free(WFileName_dirname);
free(WFileName_copy);
cap_rights_init(&rights, CAP_CREATE, CAP_FCNTL,
- CAP_FTRUNCATE, CAP_LOOKUP, CAP_SEEK, CAP_WRITE);
+ CAP_FTRUNCATE, CAP_LOOKUP, CAP_SEEK, CAP_WRITE);
if (cap_rights_limit(dumpinfo.dirfd, &rights) < 0 &&
- errno != ENOSYS) {
+ errno != ENOSYS)
+ {
error("unable to limit directory rights");
}
if (cap_fcntls_limit(dumpinfo.dirfd, CAP_FCNTL_GETFL) < 0 &&
- errno != ENOSYS) {
+ errno != ENOSYS)
+ {
error("unable to limit dump descriptor fcntls");
}
-#else /* !HAVE_CAPSICUM */
+#else /* !HAVE_CAPSICUM */
dumpinfo.WFileName = WFileName;
#endif
callback = dump_packet_and_trunc;
dumpinfo.pd = pd;
dumpinfo.pdd = pdd;
pcap_userdata = (u_char *)&dumpinfo;
- } else {
+ }
+ else
+ {
callback = dump_packet;
dumpinfo.WFileName = WFileName;
dumpinfo.pd = pd;
dumpinfo.pdd = pdd;
pcap_userdata = (u_char *)&dumpinfo;
}
- if (print) {
+ if (print)
+ {
dlt = pcap_datalink(pd);
ndo->ndo_if_printer = get_if_printer(dlt);
dumpinfo.ndo = ndo;
- } else
+ }
+ else
dumpinfo.ndo = NULL;
#ifdef HAVE_PCAP_DUMP_FLUSH
if (Uflag)
pcap_dump_flush(pdd);
#endif
- } else {
+ }
+ else
+ {
dlt = pcap_datalink(pd);
ndo->ndo_if_printer = get_if_printer(dlt);
callback = print_packet;
@@ -2492,7 +3482,8 @@
(void)setsignal(SIGNAL_FLUSH_PCAP, flushpcap);
#endif
- if (ndo->ndo_vflag > 0 && WFileName && RFileName == NULL && !print) {
+ if (ndo->ndo_vflag > 0 && WFileName && RFileName == NULL && !print)
+ {
/*
* When capturing to a file, if "--print" wasn't specified,
*"-v" means tcpdump should, once per second,
@@ -2511,10 +3502,10 @@
* that printing the stats could be a "long wait".
*/
CreateTimerQueueTimer(&timer_handle, NULL,
- verbose_stats_dump, NULL, 1000, 1000,
- WT_EXECUTEDEFAULT|WT_EXECUTELONGFUNCTION);
+ verbose_stats_dump, NULL, 1000, 1000,
+ WT_EXECUTEDEFAULT | WT_EXECUTELONGFUNCTION);
setvbuf(stderr, NULL, _IONBF, 0);
-#else /* _WIN32 */
+#else /* _WIN32 */
/*
* Assume this is UN*X, and that it has setitimer(); that
* dates back to UNIX 95.
@@ -2529,30 +3520,38 @@
#endif /* _WIN32 */
}
- if (RFileName == NULL) {
+#if 0 == STELLAR_DUMP
+ if (RFileName == NULL)
+ {
/*
* Live capture (if -V was specified, we set RFileName
* to a file from the -V file). Print a message to
* the standard error on UN*X.
*/
- if (!ndo->ndo_vflag && !WFileName) {
+ if (!ndo->ndo_vflag && !WFileName)
+ {
(void)fprintf(stderr,
- "%s: verbose output suppressed, use -v[v]... for full protocol decode\n",
- program_name);
- } else
+ "%s: verbose output suppressed, use -v[v]... for full protocol decode\n",
+ program_name);
+ }
+ else
(void)fprintf(stderr, "%s: ", program_name);
dlt = pcap_datalink(pd);
dlt_name = pcap_datalink_val_to_name(dlt);
(void)fprintf(stderr, "listening on %s", device);
- if (dlt_name == NULL) {
+ if (dlt_name == NULL)
+ {
(void)fprintf(stderr, ", link-type %u", dlt);
- } else {
+ }
+ else
+ {
(void)fprintf(stderr, ", link-type %s (%s)", dlt_name,
- pcap_datalink_val_to_description(dlt));
+ pcap_datalink_val_to_description(dlt));
}
(void)fprintf(stderr, ", snapshot length %d bytes\n", ndo->ndo_snaplen);
(void)fflush(stderr);
}
+#endif
#ifdef HAVE_CAPSICUM
cansandbox = (VFileName == NULL && zflag == NULL);
@@ -2563,16 +3562,24 @@
#endif /* HAVE_CASPER */
if (cansandbox && cap_enter() < 0 && errno != ENOSYS)
error("unable to enter the capability mode");
-#endif /* HAVE_CAPSICUM */
+#endif /* HAVE_CAPSICUM */
+ return 0;
+}
- do {
+void tcpdump_run(void)
+{
+ char *ret = NULL;
+ do
+ {
status = pcap_loop(pd, cnt, callback, pcap_userdata);
- if (WFileName == NULL) {
+ if (WFileName == NULL)
+ {
/*
* We're printing packets. Flush the printed output,
* so it doesn't get intermingled with error output.
*/
- if (status == -2) {
+ if (status == -2)
+ {
/*
* We got interrupted, so perhaps we didn't
* manage to finish a line we were printing.
@@ -2582,7 +3589,8 @@
}
(void)fflush(stdout);
}
- if (status == -2) {
+ if (status == -2)
+ {
/*
* We got interrupted. If we are reading multiple
* files (via -V) set these so that we stop.
@@ -2590,24 +3598,32 @@
VFileName = NULL;
ret = NULL;
}
- if (status == -1) {
+ if (status == -1)
+ {
/*
* Error. Report it.
*/
(void)fprintf(stderr, "%s: pcap_loop: %s\n",
- program_name, pcap_geterr(pd));
+ program_name, pcap_geterr(pd));
}
- if (RFileName == NULL) {
+ if (RFileName == NULL)
+ {
/*
* We're doing a live capture. Report the capture
* statistics.
*/
info(1);
}
- pcap_close(pd);
- if (VFileName != NULL) {
+ if (pd)
+ {
+ pcap_close(pd);
+ pd = NULL;
+ }
+ if (VFileName != NULL)
+ {
ret = get_next_file(VFile, VFileLine);
- if (ret) {
+ if (ret)
+ {
int new_dlt;
RFileName = VFileLine;
@@ -2617,18 +3633,22 @@
#ifdef HAVE_CAPSICUM
cap_rights_init(&rights, CAP_READ);
if (cap_rights_limit(fileno(pcap_file(pd)),
- &rights) < 0 && errno != ENOSYS) {
+ &rights) < 0 &&
+ errno != ENOSYS)
+ {
error("unable to limit pcap descriptor");
}
#endif
new_dlt = pcap_datalink(pd);
- if (new_dlt != dlt) {
+ if (new_dlt != dlt)
+ {
/*
* The new file has a different
* link-layer header type from the
* previous one.
*/
- if (WFileName != NULL) {
+ if (WFileName != NULL)
+ {
/*
* We're writing raw packets
* that match the filter to
@@ -2667,586 +3687,86 @@
*/
dlt_name = pcap_datalink_val_to_name(dlt);
fprintf(stderr, "reading from file %s", RFileName);
- if (dlt_name == NULL) {
- fprintf(stderr, ", link-type %u", dlt);
- } else {
+ if (dlt_name == NULL)
+ {
+ fprintf(stderr, ", link-type %d", dlt);
+ }
+ else
+ {
fprintf(stderr, ", link-type %s (%s)",
- dlt_name,
- pcap_datalink_val_to_description(dlt));
+ dlt_name,
+ pcap_datalink_val_to_description(dlt));
}
fprintf(stderr, ", snapshot length %d\n", pcap_snapshot(pd));
}
}
- }
- while (ret != NULL);
+ } while (ret != NULL);
if (count_mode && RFileName != NULL)
fprintf(stdout, "%u packet%s\n", packets_captured,
- PLURAL_SUFFIX(packets_captured));
+ PLURAL_SUFFIX(packets_captured));
free(cmdbuf);
pcap_freecode(&fcode);
exit_tcpdump(status == -1 ? S_ERR_HOST_PROGRAM : S_SUCCESS);
}
-/*
- * Catch a signal.
- */
-static void
-(*setsignal (int sig, void (*func)(int)))(int)
-{
-#ifdef _WIN32
- return (signal(sig, func));
-#else
- struct sigaction old, new;
-
- memset(&new, 0, sizeof(new));
- new.sa_handler = func;
- if ((sig == SIGCHLD)
-# ifdef SIGNAL_REQ_INFO
- || (sig == SIGNAL_REQ_INFO)
-# endif
-# ifdef SIGNAL_FLUSH_PCAP
- || (sig == SIGNAL_FLUSH_PCAP)
-# endif
- )
- new.sa_flags = SA_RESTART;
- if (sigaction(sig, &new, &old) < 0)
- return (SIG_ERR);
- return (old.sa_handler);
-#endif
-}
-
-/* make a clean exit on interrupts */
-static void
-cleanup(int signo _U_)
+static void stellar_dump_run(void)
{
-#ifdef _WIN32
- if (timer_handle != INVALID_HANDLE_VALUE) {
- DeleteTimerQueueTimer(NULL, timer_handle, NULL);
- CloseHandle(timer_handle);
- timer_handle = INVALID_HANDLE_VALUE;
- }
-#else /* _WIN32 */
- struct itimerval timer;
-
- timer.it_interval.tv_sec = 0;
- timer.it_interval.tv_usec = 0;
- timer.it_value.tv_sec = 0;
- timer.it_value.tv_usec = 0;
- setitimer(ITIMER_REAL, &timer, NULL);
-#endif /* _WIN32 */
-
-#ifdef HAVE_PCAP_BREAKLOOP
- /*
- * We have "pcap_breakloop()"; use it, so that we do as little
- * as possible in the signal handler (it's probably not safe
- * to do anything with standard I/O streams in a signal handler -
- * the ANSI C standard doesn't say it is).
- */
- pcap_breakloop(pd);
-#else
- /*
- * We don't have "pcap_breakloop()"; this isn't safe, but
- * it's the best we can do. Print the summary if we're
- * not reading from a savefile - i.e., if we're doing a
- * live capture - and exit.
- */
- if (pd != NULL && pcap_file(pd) == NULL) {
+ if (stellar_dump_datalink_init(&g_stellar_dump_arg) < 0)
+ {
+ exit(1);
+ }
+ if (stellar_dump_ctrllink_init(&g_stellar_dump_arg) < 0)
+ {
+ exit(1);
+ }
+ if (stellar_dump_start(&g_stellar_dump_arg) < 0)
+ {
+ exit(1);
+ }
+ stellar_dump_ctrllink_keepalive_start(&g_stellar_dump_arg);
+ char recv_buf[DATALINK_RECV_BUF_SIZE];
+ struct pcap_pkthdr pcaphdr = {};
+ char *pkt_ptr;
+ int total_recv_pkt_num = 0;
+ while (g_stellar_dump_run)
+ {
+ if (stellar_dump_datalink_recv(recv_buf, DATALINK_RECV_BUF_SIZE, &pkt_ptr, &pcaphdr) < 0)
+ {
+ continue;
+ }
/*
- * We got interrupted, so perhaps we didn't
- * manage to finish a line we were printing.
- * Print an extra newline, just in case.
- */
- putchar('\n');
- (void)fflush(stdout);
- info(1);
- }
- exit_tcpdump(S_SUCCESS);
-#endif
-}
-
-/*
- On windows, we do not use a fork, so we do not care less about
- waiting a child processes to die
- */
-#if defined(HAVE_FORK) || defined(HAVE_VFORK)
-static void
-child_cleanup(int signo _U_)
-{
- wait(NULL);
-}
-#endif /* HAVE_FORK && HAVE_VFORK */
-
-static void
-info(int verbose)
-{
- struct pcap_stat stats;
-
- /*
- * Older versions of libpcap didn't set ps_ifdrop on some
- * platforms; initialize it to 0 to handle that.
- */
- stats.ps_ifdrop = 0;
- if (pcap_stats(pd, &stats) < 0) {
- (void)fprintf(stderr, "pcap_stats: %s\n", pcap_geterr(pd));
- infoprint = 0;
- return;
+ dump_packet: if set -w option, write packet to file
+ print_packet: print packet to stdout
+ */
+ callback(pcap_userdata, &pcaphdr, (u_char *)pkt_ptr);
+ if (g_stellar_dump_arg.expect_packet_count > 0 && ++total_recv_pkt_num >= g_stellar_dump_arg.expect_packet_count)
+ {
+ break;
+ }
}
-
- if (!verbose)
- fprintf(stderr, "%s: ", program_name);
-
- (void)fprintf(stderr, "%u packet%s captured", packets_captured,
- PLURAL_SUFFIX(packets_captured));
- if (!verbose)
- fputs(", ", stderr);
- else
- putc('\n', stderr);
- (void)fprintf(stderr, "%u packet%s received by filter", stats.ps_recv,
- PLURAL_SUFFIX(stats.ps_recv));
- if (!verbose)
- fputs(", ", stderr);
- else
- putc('\n', stderr);
- (void)fprintf(stderr, "%u packet%s dropped by kernel", stats.ps_drop,
- PLURAL_SUFFIX(stats.ps_drop));
- if (stats.ps_ifdrop != 0) {
- if (!verbose)
- fputs(", ", stderr);
- else
- putc('\n', stderr);
- (void)fprintf(stderr, "%u packet%s dropped by interface\n",
- stats.ps_ifdrop, PLURAL_SUFFIX(stats.ps_ifdrop));
- } else
- putc('\n', stderr);
- infoprint = 0;
+ exit(0);
}
-#if defined(HAVE_FORK) || defined(HAVE_VFORK)
-#ifdef HAVE_FORK
-#define fork_subprocess() fork()
-#else
-#define fork_subprocess() vfork()
-#endif
-static void
-compress_savefile(const char *filename)
+int stellar_dump(int argc, char **argv)
{
- pid_t child;
-
- child = fork_subprocess();
- if (child == -1) {
- fprintf(stderr,
- "compress_savefile: fork failed: %s\n",
- pcap_strerror(errno));
- return;
+ atexit((void (*)(void))cleanup);
+ if (tcpdump_parse_args(argc, argv) < 0)
+ {
+ return -1;
}
- if (child != 0) {
- /* Parent process. */
- return;
- }
-
- /*
- * Child process.
- * Set to lowest priority so that this doesn't disturb the capture.
- */
-#ifdef NZERO
- setpriority(PRIO_PROCESS, 0, NZERO - 1);
-#else
- setpriority(PRIO_PROCESS, 0, 19);
-#endif
- if (execlp(zflag, zflag, filename, (char *)NULL) == -1)
- fprintf(stderr,
- "compress_savefile: execlp(%s, %s) failed: %s\n",
- zflag,
- filename,
- pcap_strerror(errno));
-#ifdef HAVE_FORK
- exit(S_ERR_HOST_PROGRAM);
-#else
- _exit(S_ERR_HOST_PROGRAM);
-#endif
-}
-#else /* HAVE_FORK && HAVE_VFORK */
-static void
-compress_savefile(const char *filename)
-{
- fprintf(stderr,
- "compress_savefile failed. Functionality not implemented under your system\n");
-}
-#endif /* HAVE_FORK && HAVE_VFORK */
-
-static void
-dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
-{
- struct dump_info *dump_info;
-
- ++packets_captured;
-
- ++infodelay;
-
- dump_info = (struct dump_info *)user;
-
- /*
- * XXX - this won't force the file to rotate on the specified time
- * boundary, but it will rotate on the first packet received after the
- * specified Gflag number of seconds. Note: if a Gflag time boundary
- * and a Cflag size boundary coincide, the time rotation will occur
- * first thereby cancelling the Cflag boundary (since the file should
- * be 0).
- */
- if (Gflag != 0) {
- /* Check if it is time to rotate */
- time_t t;
-
- /* Get the current time */
- if ((t = time(NULL)) == (time_t)-1) {
- error("%s: can't get current_time: %s",
- __func__, pcap_strerror(errno));
- }
-
-
- /* If the time is greater than the specified window, rotate */
- if (t - Gflag_time >= Gflag) {
-#ifdef HAVE_CAPSICUM
- FILE *fp;
- int fd;
-#endif
-
- /* Update the Gflag_time */
- Gflag_time = t;
- /* Update Gflag_count */
- Gflag_count++;
- /*
- * Close the current file and open a new one.
- */
- pcap_dump_close(dump_info->pdd);
-
- /*
- * Compress the file we just closed, if the user asked for it
- */
- if (zflag != NULL)
- compress_savefile(dump_info->CurrentFileName);
-
- /*
- * Check to see if we've exceeded the Wflag (when
- * not using Cflag).
- */
- if (Cflag == 0 && Wflag > 0 && Gflag_count >= Wflag) {
- (void)fprintf(stderr, "Maximum file limit reached: %d\n",
- Wflag);
- info(1);
- exit_tcpdump(S_SUCCESS);
- /* NOTREACHED */
- }
- if (dump_info->CurrentFileName != NULL)
- free(dump_info->CurrentFileName);
- /* Allocate space for max filename + \0. */
- dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
- if (dump_info->CurrentFileName == NULL)
- error("dump_packet_and_trunc: malloc");
- /*
- * Gflag was set otherwise we wouldn't be here. Reset the count
- * so multiple files would end with 1,2,3 in the filename.
- * The counting is handled with the -C flow after this.
- */
- Cflag_count = 0;
-
- /*
- * This is always the first file in the Cflag
- * rotation: e.g. 0
- * We also don't need numbering if Cflag is not set.
- */
- if (Cflag != 0)
- MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0,
- WflagChars);
- else
- MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0, 0);
-
-#ifdef HAVE_LIBCAP_NG
- capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
- capng_apply(CAPNG_SELECT_BOTH);
-#endif /* HAVE_LIBCAP_NG */
-#ifdef HAVE_CAPSICUM
- fd = openat(dump_info->dirfd,
- dump_info->CurrentFileName,
- O_CREAT | O_WRONLY | O_TRUNC, 0644);
- if (fd < 0) {
- error("unable to open file %s",
- dump_info->CurrentFileName);
- }
- fp = fdopen(fd, "w");
- if (fp == NULL) {
- error("unable to fdopen file %s",
- dump_info->CurrentFileName);
- }
- dump_info->pdd = pcap_dump_fopen(dump_info->pd, fp);
-#else /* !HAVE_CAPSICUM */
- dump_info->pdd = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
-#endif
-#ifdef HAVE_LIBCAP_NG
- capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
- capng_apply(CAPNG_SELECT_BOTH);
-#endif /* HAVE_LIBCAP_NG */
- if (dump_info->pdd == NULL)
- error("%s", pcap_geterr(pd));
-#ifdef HAVE_CAPSICUM
- set_dumper_capsicum_rights(dump_info->pdd);
-#endif
- }
+ if (tcpdump_prepare() < 0)
+ {
+ return -1;
}
-
- /*
- * XXX - this won't prevent capture files from getting
- * larger than Cflag - the last packet written to the
- * file could put it over Cflag.
- */
- if (Cflag != 0) {
-#ifdef HAVE_PCAP_DUMP_FTELL64
- int64_t size = pcap_dump_ftell64(dump_info->pdd);
-#else
- /*
- * XXX - this only handles a Cflag value > 2^31-1 on
- * LP64 platforms; to handle ILP32 (32-bit UN*X and
- * Windows) or LLP64 (64-bit Windows) would require
- * a version of libpcap with pcap_dump_ftell64().
- */
- long size = pcap_dump_ftell(dump_info->pdd);
-#endif
-
- if (size == -1)
- error("ftell fails on output file");
- if (size > Cflag) {
-#ifdef HAVE_CAPSICUM
- FILE *fp;
- int fd;
-#endif
-
- /*
- * Close the current file and open a new one.
- */
- pcap_dump_close(dump_info->pdd);
-
- /*
- * Compress the file we just closed, if the user
- * asked for it.
- */
- if (zflag != NULL)
- compress_savefile(dump_info->CurrentFileName);
-
- Cflag_count++;
- if (Wflag > 0) {
- if (Cflag_count >= Wflag)
- Cflag_count = 0;
- }
- if (dump_info->CurrentFileName != NULL)
- free(dump_info->CurrentFileName);
- dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
- if (dump_info->CurrentFileName == NULL)
- error("%s: malloc", __func__);
- MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, Cflag_count, WflagChars);
-#ifdef HAVE_LIBCAP_NG
- capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
- capng_apply(CAPNG_SELECT_BOTH);
-#endif /* HAVE_LIBCAP_NG */
-#ifdef HAVE_CAPSICUM
- fd = openat(dump_info->dirfd, dump_info->CurrentFileName,
- O_CREAT | O_WRONLY | O_TRUNC, 0644);
- if (fd < 0) {
- error("unable to open file %s",
- dump_info->CurrentFileName);
- }
- fp = fdopen(fd, "w");
- if (fp == NULL) {
- error("unable to fdopen file %s",
- dump_info->CurrentFileName);
- }
- dump_info->pdd = pcap_dump_fopen(dump_info->pd, fp);
-#else /* !HAVE_CAPSICUM */
- dump_info->pdd = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
-#endif
-#ifdef HAVE_LIBCAP_NG
- capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
- capng_apply(CAPNG_SELECT_BOTH);
-#endif /* HAVE_LIBCAP_NG */
- if (dump_info->pdd == NULL)
- error("%s", pcap_geterr(pd));
-#ifdef HAVE_CAPSICUM
- set_dumper_capsicum_rights(dump_info->pdd);
-#endif
- }
+ if (RFileName != NULL || VFileName != NULL)
+ {
+ tcpdump_run();
}
-
- pcap_dump((u_char *)dump_info->pdd, h, sp);
-#ifdef HAVE_PCAP_DUMP_FLUSH
- if (Uflag)
- pcap_dump_flush(dump_info->pdd);
-#endif
-
- if (dump_info->ndo != NULL)
- pretty_print_packet(dump_info->ndo, h, sp, packets_captured);
-
- --infodelay;
- if (infoprint)
- info(0);
-}
-
-static void
-dump_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
-{
- struct dump_info *dump_info;
-
- ++packets_captured;
-
- ++infodelay;
-
- dump_info = (struct dump_info *)user;
-
- pcap_dump((u_char *)dump_info->pdd, h, sp);
-#ifdef HAVE_PCAP_DUMP_FLUSH
- if (Uflag)
- pcap_dump_flush(dump_info->pdd);
-#endif
-
- if (dump_info->ndo != NULL)
- pretty_print_packet(dump_info->ndo, h, sp, packets_captured);
-
- --infodelay;
- if (infoprint)
- info(0);
-}
-
-static void
-print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
-{
- ++packets_captured;
-
- ++infodelay;
-
- if (!count_mode)
- pretty_print_packet((netdissect_options *)user, h, sp, packets_captured);
-
- --infodelay;
- if (infoprint)
- info(0);
-}
-
-#ifdef SIGNAL_REQ_INFO
-static void
-requestinfo(int signo _U_)
-{
- if (infodelay)
- ++infoprint;
else
- info(0);
-}
-#endif
-
-#ifdef SIGNAL_FLUSH_PCAP
-static void
-flushpcap(int signo _U_)
-{
- if (pdd != NULL)
- pcap_dump_flush(pdd);
-}
-#endif
-
-static void
-print_packets_captured (void)
-{
- static u_int prev_packets_captured, first = 1;
-
- if (infodelay == 0 && (first || packets_captured != prev_packets_captured)) {
- fprintf(stderr, "Got %u\r", packets_captured);
- first = 0;
- prev_packets_captured = packets_captured;
+ {
+ stellar_dump_run();
}
-}
-
-/*
- * Called once each second in verbose mode while dumping to file
- */
-#ifdef _WIN32
-static void CALLBACK verbose_stats_dump(PVOID param _U_,
- BOOLEAN timer_fired _U_)
-{
- print_packets_captured();
-}
-#else /* _WIN32 */
-static void verbose_stats_dump(int sig _U_)
-{
- print_packets_captured();
-}
-#endif /* _WIN32 */
-
-DIAG_OFF_DEPRECATION
-static void
-print_version(FILE *f)
-{
-#ifndef HAVE_PCAP_LIB_VERSION
- #ifdef HAVE_PCAP_VERSION
- extern char pcap_version[];
- #else /* HAVE_PCAP_VERSION */
- static char pcap_version[] = "unknown";
- #endif /* HAVE_PCAP_VERSION */
-#endif /* HAVE_PCAP_LIB_VERSION */
- const char *smi_version_string;
-
- (void)fprintf(f, "%s version " PACKAGE_VERSION "\n", program_name);
-#ifdef HAVE_PCAP_LIB_VERSION
- (void)fprintf(f, "%s\n", pcap_lib_version());
-#else /* HAVE_PCAP_LIB_VERSION */
- (void)fprintf(f, "libpcap version %s\n", pcap_version);
-#endif /* HAVE_PCAP_LIB_VERSION */
-
-#if defined(HAVE_LIBCRYPTO) && defined(SSLEAY_VERSION)
- (void)fprintf (f, "%s\n", SSLeay_version(SSLEAY_VERSION));
-#endif
-
- smi_version_string = nd_smi_version_string();
- if (smi_version_string != NULL)
- (void)fprintf (f, "SMI-library: %s\n", smi_version_string);
-
-#if defined(__SANITIZE_ADDRESS__)
- (void)fprintf (f, "Compiled with AddressSanitizer/GCC.\n");
-#elif defined(__has_feature)
-# if __has_feature(address_sanitizer)
- (void)fprintf (f, "Compiled with AddressSanitizer/Clang.\n");
-# elif __has_feature(memory_sanitizer)
- (void)fprintf (f, "Compiled with MemorySanitizer/Clang.\n");
-# endif
-#endif /* __SANITIZE_ADDRESS__ or __has_feature */
-}
-DIAG_ON_DEPRECATION
-
-static void
-print_usage(FILE *f)
-{
- print_version(f);
- (void)fprintf(f,
-"Usage: %s [-Abd" D_FLAG "efhH" I_FLAG J_FLAG "KlLnNOpqStu" U_FLAG "vxX#]" B_FLAG_USAGE " [ -c count ] [--count]\n", program_name);
- (void)fprintf(f,
-"\t\t[ -C file_size ] [ -E algo:secret ] [ -F file ] [ -G seconds ]\n");
- (void)fprintf(f,
-"\t\t[ -i interface ]" IMMEDIATE_MODE_USAGE j_FLAG_USAGE "\n");
-#ifdef HAVE_PCAP_FINDALLDEVS_EX
- (void)fprintf(f,
-"\t\t" LIST_REMOTE_INTERFACES_USAGE "\n");
-#endif
-#ifdef USE_LIBSMI
- (void)fprintf(f,
-"\t\t" m_FLAG_USAGE "\n");
-#endif
- (void)fprintf(f,
-"\t\t[ -M secret ] [ --number ] [ --print ]" Q_FLAG_USAGE "\n");
- (void)fprintf(f,
-"\t\t[ -r file ] [ -s snaplen ] [ -T type ] [ --version ]\n");
- (void)fprintf(f,
-"\t\t[ -V file ] [ -w file ] [ -W filecount ] [ -y datalinktype ]\n");
-#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
- (void)fprintf(f,
-"\t\t[ --time-stamp-precision precision ] [ --micro ] [ --nano ]\n");
-#endif
- (void)fprintf(f,
-"\t\t[ -z postrotate-command ] [ -Z user ] [ expression ]\n");
+ return 0;
}
diff -uNr tcpdump-tcpdump-4.99.4/tcpdump_ip6.h tcpdump-for-stellar/tcpdump_ip6.h
--- tcpdump-tcpdump-4.99.4/tcpdump_ip6.h 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/tcpdump_ip6.h 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,231 @@
+/* NetBSD: ip6.h,v 1.9 2000/07/13 05:34:21 itojun Exp */
+/* $KAME: ip6.h,v 1.9 2000/07/02 21:01:32 itojun Exp $ */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * 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. Neither the name of the project 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 PROJECT 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 PROJECT 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.
+ */
+
+/*
+ * Copyright (c) 1982, 1986, 1993
+ * 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 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.
+ *
+ * @(#)ip.h 8.1 (Berkeley) 6/10/93
+ */
+
+#ifndef ND_IP6_H_
+#define ND_IP6_H_
+
+/*
+ * Definition for internet protocol version 6.
+ * RFC 2460
+ */
+
+// struct ip6_hdr
+struct tcpdump_ip6_hdr
+{
+ union
+ {
+ // struct ip6_hdrctl
+ struct tcpdump_ip6_hdrctl
+ {
+ nd_uint32_t ip6_un1_flow; /* 20 bits of flow-ID */
+ nd_uint16_t ip6_un1_plen; /* payload length */
+ nd_uint8_t ip6_un1_nxt; /* next header */
+ nd_uint8_t ip6_un1_hlim; /* hop limit */
+ } ip6_un1;
+ nd_uint8_t ip6_un2_vfc; /* 4 bits version, top 4 bits class */
+ } ip6_ctlun;
+ nd_ipv6 ip6_src; /* source address */
+ nd_ipv6 ip6_dst; /* destination address */
+};
+
+#define ip6_vfc ip6_ctlun.ip6_un2_vfc
+#define IP6_VERSION(ip6_hdr) ((GET_U_1((ip6_hdr)->ip6_vfc) & 0xf0) >> 4)
+#define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow
+#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen
+#define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt
+#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim
+#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim
+
+/* in network endian */
+#define IPV6_FLOWINFO_MASK ((uint32_t)htonl(0x0fffffff)) /* flow info (28 bits) */
+#define IPV6_FLOWLABEL_MASK ((uint32_t)htonl(0x000fffff)) /* flow label (20 bits) */
+
+/*
+ * Extension Headers
+ */
+
+// struct ip6_ext
+struct tcpdump_ip6_ext
+{
+ nd_uint8_t ip6e_nxt;
+ nd_uint8_t ip6e_len;
+};
+
+/* Hop-by-Hop options header */
+// struct ip6_hbh
+struct tcpdump_ip6_hbh
+{
+ nd_uint8_t ip6h_nxt; /* next header */
+ nd_uint8_t ip6h_len; /* length in units of 8 octets */
+ /* followed by options */
+};
+
+/* Destination options header */
+// struct ip6_dest
+struct tcpdump_ip6_dest
+{
+ nd_uint8_t ip6d_nxt; /* next header */
+ nd_uint8_t ip6d_len; /* length in units of 8 octets */
+ /* followed by options */
+};
+
+/* https://www.iana.org/assignments/ipv6-parameters/ipv6-parameters.xhtml */
+
+/* Option types and related macros */
+#define IP6OPT_PAD1 0x00 /* 00 0 00000 */
+#define IP6OPT_PADN 0x01 /* 00 0 00001 */
+#define IP6OPT_JUMBO 0xC2 /* 11 0 00010 = 194 */
+#define IP6OPT_JUMBO_LEN 6
+#define IP6OPT_RPL 0x63 /* 01 1 00011 */
+#define IP6OPT_TUN_ENC_LIMIT 0x04 /* 00 0 00100 */
+#define IP6OPT_ROUTER_ALERT 0x05 /* 00 0 00101 */
+
+#define IP6OPT_RTALERT_LEN 4
+#define IP6OPT_RTALERT_MLD 0 /* Datagram contains an MLD message */
+#define IP6OPT_RTALERT_RSVP 1 /* Datagram contains an RSVP message */
+#define IP6OPT_RTALERT_ACTNET 2 /* contains an Active Networks msg */
+#define IP6OPT_MINLEN 2
+
+#define IP6OPT_QUICK_START 0x26 /* 00 1 00110 */
+#define IP6OPT_CALIPSO 0x07 /* 00 0 00111 */
+#define IP6OPT_SMF_DPD 0x08 /* 00 0 01000 */
+#define IP6OPT_HOME_ADDRESS 0xc9 /* 11 0 01001 */
+#define IP6OPT_HOMEADDR_MINLEN 18
+#define IP6OPT_EID 0x8a /* 10 0 01010 */
+#define IP6OPT_ILNP_NOTICE 0x8b /* 10 0 01011 */
+#define IP6OPT_LINE_ID 0x8c /* 10 0 01100 */
+#define IP6OPT_MPL 0x6d /* 01 1 01101 */
+#define IP6OPT_IP_DFF 0xee /* 11 1 01110 */
+
+#define IP6OPT_TYPE(o) ((o) & 0xC0)
+#define IP6OPT_TYPE_SKIP 0x00
+#define IP6OPT_TYPE_DISCARD 0x40
+#define IP6OPT_TYPE_FORCEICMP 0x80
+#define IP6OPT_TYPE_ICMP 0xC0
+
+#define IP6OPT_MUTABLE 0x20
+
+/* Routing header */
+// struct ip6_rthdr
+struct tcpdump_ip6_rthdr
+{
+ nd_uint8_t ip6r_nxt; /* next header */
+ nd_uint8_t ip6r_len; /* length in units of 8 octets */
+ nd_uint8_t ip6r_type; /* routing type */
+ nd_uint8_t ip6r_segleft; /* segments left */
+ /* followed by routing type specific data */
+};
+
+#define IPV6_RTHDR_TYPE_0 0
+#define IPV6_RTHDR_TYPE_2 2
+#define IPV6_RTHDR_TYPE_4 4
+
+/* Type 0 Routing header */
+/* Also used for Type 2 */
+// struct ip6_rthdr0
+struct tcpdump_ip6_rthdr0
+{
+ nd_uint8_t ip6r0_nxt; /* next header */
+ nd_uint8_t ip6r0_len; /* length in units of 8 octets */
+ nd_uint8_t ip6r0_type; /* always zero */
+ nd_uint8_t ip6r0_segleft; /* segments left */
+ nd_uint32_t ip6r0_reserved; /* reserved field */
+ nd_ipv6 ip6r0_addr[1]; /* up to 23 addresses */
+};
+
+/**
+ * Type 4 Routing header
+ * known as Segment Routing Header 'SRH'
+ */
+// struct ip6_srh
+struct tcpdump_ip6_srh
+{
+ nd_uint8_t srh_nxt; /* next header */
+ nd_uint8_t srh_len; /* length in units of 8 octets */
+ nd_uint8_t srh_type; /* Routing Type 4 */
+ nd_uint8_t srh_segleft; /* segments left */
+ nd_uint8_t srh_last_ent; /* Last Entry*/
+ nd_uint8_t srh_flags; /* Flags */
+ nd_uint16_t srh_tag; /* Tag */
+ nd_ipv6 srh_segments[1]; /* SRH segments list*/
+};
+
+/* Fragment header */
+// struct ip6_frag
+struct tcpdump_ip6_frag
+{
+ nd_uint8_t ip6f_nxt; /* next header */
+ nd_uint8_t ip6f_reserved; /* reserved field */
+ nd_uint16_t ip6f_offlg; /* offset, reserved, and flag */
+ nd_uint32_t ip6f_ident; /* identification */
+};
+
+#define IP6F_OFF_MASK 0xfff8 /* mask out offset from ip6f_offlg */
+#define IP6F_RESERVED_MASK 0x0006 /* reserved bits in ip6f_offlg */
+#define IP6F_MORE_FRAG 0x0001 /* more-fragments flag */
+
+#endif /* not ND_IP6_H_ */
diff -uNr tcpdump-tcpdump-4.99.4/tcpdump_ip.h tcpdump-for-stellar/tcpdump_ip.h
--- tcpdump-tcpdump-4.99.4/tcpdump_ip.h 1970-01-01 08:00:00.000000000 +0800
+++ tcpdump-for-stellar/tcpdump_ip.h 2024-10-30 17:34:06.265498697 +0800
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1982, 1986, 1993
+ * 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 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.
+ *
+ * @(#)ip.h 8.2 (Berkeley) 6/1/94
+ */
+
+#ifndef netdissect_ip_h
+#define netdissect_ip_h
+/*
+ * Definitions for internet protocol version 4.
+ * Per RFC 791, September 1981.
+ */
+#define IPVERSION 4
+
+/*
+ * Structure of an internet header, naked of options.
+ *
+ * We declare ip_len and ip_off to be short, rather than u_short
+ * pragmatically since otherwise unsigned comparisons can result
+ * against negative integers quite easily, and fail in subtle ways.
+ */
+// struct ip
+struct tcpdump_ip
+{
+ nd_uint8_t ip_vhl; /* header length, version */
+#define IP_V(ip) ((GET_U_1((ip)->ip_vhl) & 0xf0) >> 4)
+#define IP_HL(ip) (GET_U_1((ip)->ip_vhl) & 0x0f)
+ nd_uint8_t ip_tos; /* type of service */
+ nd_uint16_t ip_len; /* total length */
+ nd_uint16_t ip_id; /* identification */
+ nd_uint16_t ip_off; /* fragment offset field */
+#define IP_DF 0x4000 /* don't fragment flag */
+#define IP_MF 0x2000 /* more fragments flag */
+#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
+ nd_uint8_t ip_ttl; /* time to live */
+ nd_uint8_t ip_p; /* protocol */
+ nd_uint16_t ip_sum; /* checksum */
+ nd_ipv4 ip_src, ip_dst; /* source and dest address */
+};
+
+#define IP_MAXPACKET 65535 /* maximum packet size */
+
+/*
+ * Definitions for IP type of service (ip_tos)
+ */
+#define IPTOS_LOWDELAY 0x10
+#define IPTOS_THROUGHPUT 0x08
+#define IPTOS_RELIABILITY 0x04
+
+/*
+ * Definitions for IP precedence (also in ip_tos) (hopefully unused)
+ */
+#define IPTOS_PREC_NETCONTROL 0xe0
+#define IPTOS_PREC_INTERNETCONTROL 0xc0
+#define IPTOS_PREC_CRITIC_ECP 0xa0
+#define IPTOS_PREC_FLASHOVERRIDE 0x80
+#define IPTOS_PREC_FLASH 0x60
+#define IPTOS_PREC_IMMEDIATE 0x40
+#define IPTOS_PREC_PRIORITY 0x20
+#define IPTOS_PREC_ROUTINE 0x00
+
+/*
+ * Definitions for options.
+ */
+#define IPOPT_COPIED(o) ((o) & 0x80)
+#define IPOPT_CLASS(o) ((o) & 0x60)
+#define IPOPT_NUMBER(o) ((o) & 0x1f)
+
+#define IPOPT_CONTROL 0x00
+#define IPOPT_RESERVED1 0x20
+#define IPOPT_DEBMEAS 0x40
+#define IPOPT_RESERVED2 0x60
+
+#define IPOPT_EOL 0 /* end of option list */
+#define IPOPT_NOP 1 /* no operation */
+
+#define IPOPT_RR 7 /* record packet route */
+#define IPOPT_TS 68 /* timestamp */
+#define IPOPT_RFC1393 82 /* traceroute RFC 1393 */
+#define IPOPT_SECURITY 130 /* provide s,c,h,tcc */
+#define IPOPT_LSRR 131 /* loose source route */
+#define IPOPT_SATID 136 /* satnet id */
+#define IPOPT_SSRR 137 /* strict source route */
+#define IPOPT_RA 148 /* router-alert, rfc2113 */
+
+/*
+ * Offsets to fields in options other than EOL and NOP.
+ */
+#define IPOPT_OPTVAL 0 /* option ID */
+#define IPOPT_OLEN 1 /* option length */
+#define IPOPT_OFFSET 2 /* offset within option */
+#define IPOPT_MINOFF 4 /* min value of above */
+
+/*
+ * Time stamp option structure.
+ */
+// struct ip_timestamp
+struct tcpdump_ip_timestamp
+{
+ nd_uint8_t ipt_code; /* IPOPT_TS */
+ nd_uint8_t ipt_len; /* size of structure (variable) */
+ nd_uint8_t ipt_ptr; /* index of current entry */
+ nd_uint8_t ipt_oflwflg; /* flags, overflow counter */
+#define IPTS_OFLW(ip) (((ipt)->ipt_oflwflg & 0xf0) >> 4)
+#define IPTS_FLG(ip) ((ipt)->ipt_oflwflg & 0x0f)
+ union ipt_timestamp
+ {
+ nd_uint32_t ipt_time[1];
+ struct ipt_ta
+ {
+ nd_ipv4 ipt_addr;
+ nd_uint32_t ipt_time;
+ } ipt_ta[1];
+ } ipt_timestamp;
+};
+
+/* flag bits for ipt_flg */
+#define IPOPT_TS_TSONLY 0 /* timestamps only */
+#define IPOPT_TS_TSANDADDR 1 /* timestamps and addresses */
+#define IPOPT_TS_PRESPEC 3 /* specified modules only */
+
+/* bits for security (not byte swapped) */
+#define IPOPT_SECUR_UNCLASS 0x0000
+#define IPOPT_SECUR_CONFID 0xf135
+#define IPOPT_SECUR_EFTO 0x789a
+#define IPOPT_SECUR_MMMM 0xbc4d
+#define IPOPT_SECUR_RESTR 0xaf13
+#define IPOPT_SECUR_SECRET 0xd788
+#define IPOPT_SECUR_TOPSECRET 0x6bc5
+
+/*
+ * Internet implementation parameters.
+ */
+#define MAXTTL 255 /* maximum time to live (seconds) */
+#define IPDEFTTL 64 /* default ttl, from RFC 1340 */
+#define IPFRAGTTL 60 /* time to live for frags, slowhz */
+#define IPTTLDEC 1 /* subtracted when forwarding */
+
+#define IP_MSS 576 /* default maximum segment size */
+#endif /* netdissect_ip_h */
\ No newline at end of file
Reference in New Issue View Git Blame Copy Permalink