alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

pcap: refactor and move to common components

Browse Source
This commit is contained in:
morris 2021-08-25 20:25:38 +08:00 committed by bot
parent 03a89f1c39
commit f04f078825
8 changed files with 359 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/common_components/pcap/CMakeLists.txt Normal file
View File

@ -0,0 +1,2 @@
idf_component_register(SRCS "src/pcap.c"
INCLUDE_DIRS "include")

5
examples/common_components/pcap/component.mk Normal file
View File

@ -0,0 +1,5 @@
#
# Component Makefile
#
COMPONENT_ADD_INCLUDEDIRS := include
COMPONENT_SRCDIRS := src

128
examples/common_components/pcap/include/pcap.h Normal file
View File

@ -0,0 +1,128 @@
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <stdio.h>
#include "esp_err.h"
#ifdef __cplusplus
extern "C" {
#endif
#define PCAP_DEFAULT_VERSION_MAJOR 0x02 /*!< Major Version */
#define PCAP_DEFAULT_VERSION_MINOR 0x04 /*!< Minor Version */
#define PCAP_DEFAULT_TIME_ZONE_GMT 0x00 /*!< Time Zone */
/**
* @brief Type of pcap file handle
*
*/
typedef struct pcap_file_t *pcap_file_handle_t;
/**
* @brief Link layer Type Definition, used for Pcap reader to decode payload
*
*/
typedef enum {
PCAP_LINK_TYPE_LOOPBACK = 0, /*!< Loopback devices, except for later OpenBSD */
PCAP_LINK_TYPE_ETHERNET = 1, /*!< Ethernet, and Linux loopback devices */
PCAP_LINK_TYPE_TOKEN_RING = 6, /*!< 802.5 Token Ring */
PCAP_LINK_TYPE_ARCNET = 7, /*!< ARCnet */
PCAP_LINK_TYPE_SLIP = 8, /*!< SLIP */
PCAP_LINK_TYPE_PPP = 9, /*!< PPP */
PCAP_LINK_TYPE_FDDI = 10, /*!< FDDI */
PCAP_LINK_TYPE_ATM = 100, /*!< LLC/SNAP encapsulated ATM */
PCAP_LINK_TYPE_RAW_IP = 101, /*!< Raw IP, without link */
PCAP_LINK_TYPE_BSD_SLIP = 102, /*!< BSD/OS SLIP */
PCAP_LINK_TYPE_BSD_PPP = 103, /*!< BSD/OS PPP */
PCAP_LINK_TYPE_CISCO_HDLC = 104, /*!< Cisco HDLC */
PCAP_LINK_TYPE_802_11 = 105, /*!< 802.11 */
PCAP_LINK_TYPE_BSD_LOOPBACK = 108, /*!< OpenBSD loopback devices(with AF_value in network byte order) */
PCAP_LINK_TYPE_LOCAL_TALK = 114 /*!< LocalTalk */
} pcap_link_type_t;
/**
* @brief Pcap configuration Type Definition
*
*/
typedef struct {
FILE *fp; /*!< Pointer to a standard file handle */
unsigned int major_version; /*!< Pcap version: major */
unsigned int minor_version; /*!< Pcap version: minor */
unsigned int time_zone; /*!< Pcap timezone code */
struct {
unsigned int little_endian: 1; /*!< Whether the pcap file is recored in little endian format */
} flags;
} pcap_config_t;
/**
* @brief Create a new pcap session, and returns pcap file handle
*
* @note This function won't create the low level FILE* object, the user should take care of the creation of the File Stream.
*
* @param[in] config pcap file configuration
* @param[out] ret_pcap Returned pcap file handle
* @return
* - ESP_OK: Create pcap file successfully
* - ESP_ERR_INVALID_ARG: Create pcap file failed because of invalid argument
* - ESP_ERR_NO_MEM: Create pcap file failed because out of memory
* - ESP_FAIL: Create pcap file failed
*/
esp_err_t pcap_new_session(const pcap_config_t *config, pcap_file_handle_t *ret_pcap);
/**
* @brief Delete the pcap session, and close the File Stream
*
* @param[in] pcap pcap file handle created by `pcap_new_session()`
* @return
* - ESP_OK: Delete pcap session successfully
* - ESP_ERR_INVALID_ARG: Delete pcap session failed because of invalid argument
* - ESP_FAIL: Delete pcap session failed
*/
esp_err_t pcap_del_session(pcap_file_handle_t pcap);
/**
* @brief Write pcap file header
*
* @param[in] pcap pcap file handle created by `pcap_new_session()`
* @param[in] link_type Network link layer type
* @return
* - ESP_OK: Write pcap file header successfully
* - ESP_ERR_INVALID_ARG: Write pcap file header failed because of invalid argument
* - ESP_FAIL: Write pcap file header failed
*/
esp_err_t pcap_write_header(pcap_file_handle_t pcap, pcap_link_type_t link_type);
/**
* @brief Capture one packet into pcap file
*
* @param[in] pcap pcap file handle created by `pcap_new_session()`
* @param[in] payload pointer of the captured data buffer
* @param[in] length length of captured data buffer
* @param[in] seconds second of capture time
* @param[in] microseconds microsecond of capture time
* @return
* - ESP_OK: Write network packet into pcap file successfully
* - ESP_ERR_INVALID_ARG: Write network packet into pcap file failed because of invalid argument
* - ESP_FAIL: Write network packet into pcap file failed
*/
esp_err_t pcap_capture_packet(pcap_file_handle_t pcap, void *payload, uint32_t length, uint32_t seconds, uint32_t microseconds);
/**
* @brief Print the summary of pcap file into stream
*
* @param[in] pcap pcap file handle created by `pcap_new_session()`
* @param[in] print_file the file stream to save the summary
* @return
* - ESP_OK: Print pcap file summary successfully
* - ESP_ERR_INVALID_ARG: Print pcap file summary failed because of invalid argument
* - ESP_FAIL: Print pcap file summary failed
*/
esp_err_t pcap_print_summary(pcap_file_handle_t pcap, FILE *print_file);
#ifdef __cplusplus
}
#endif

224
examples/common_components/pcap/src/pcap.c Normal file
View File

@ -0,0 +1,224 @@
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "esp_log.h"
#include "esp_check.h"
#include "pcap.h"
static const char *TAG = "pcap";
#define PCAP_MAGIC_BIG_ENDIAN 0xA1B2C3D4 /*!< Big-Endian */
#define PCAP_MAGIC_LITTLE_ENDIAN 0xD4C3B2A1 /*!< Little-Endian */
typedef struct pcap_file_t pcap_file_t;
/**
* @brief Pcap File Header
*
*/
typedef struct {
uint32_t magic; /*!< Magic Number */
uint16_t major; /*!< Major Version */
uint16_t minor; /*!< Minor Version */
uint32_t zone; /*!< Time Zone Offset */
uint32_t sigfigs; /*!< Timestamp Accuracy */
uint32_t snaplen; /*!< Max Length to Capture */
uint32_t link_type; /*!< Link Layer Type */
} pcap_file_header_t;
/**
* @brief Pcap Packet Header
*
*/
typedef struct {
uint32_t seconds; /*!< Number of seconds since January 1st, 1970, 00:00:00 GMT */
uint32_t microseconds; /*!< Number of microseconds when the packet was captured (offset from seconds) */
uint32_t capture_length; /*!< Number of bytes of captured data, no longer than packet_length */
uint32_t packet_length; /*!< Actual length of current packet */
} pcap_packet_header_t;
/**
* @brief Pcap Runtime Handle
*
*/
struct pcap_file_t {
FILE *file; /*!< File handle */
pcap_link_type_t link_type; /*!< Pcap Link Type */
unsigned int major_version; /*!< Pcap version: major */
unsigned int minor_version; /*!< Pcap version: minor */
unsigned int time_zone; /*!< Pcap timezone code */
uint32_t endian_magic; /*!< Magic value related to endian format */
};
esp_err_t pcap_new_session(const pcap_config_t *config, pcap_file_handle_t *ret_pcap)
{
esp_err_t ret = ESP_OK;
pcap_file_t *pcap = NULL;
ESP_GOTO_ON_FALSE(config && ret_pcap, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(config->fp, ESP_ERR_INVALID_ARG, err, TAG, "pcap file handle can't be NULL");
pcap = calloc(1, sizeof(pcap_file_t));
ESP_GOTO_ON_FALSE(pcap, ESP_ERR_NO_MEM, err, TAG, "no mem for pcap file object");
pcap->file = config->fp;
pcap->major_version = config->major_version;
pcap->minor_version = config->minor_version;
pcap->endian_magic = config->flags.little_endian ? PCAP_MAGIC_LITTLE_ENDIAN : PCAP_MAGIC_BIG_ENDIAN;
pcap->time_zone = config->time_zone;
*ret_pcap = pcap;
return ret;
err:
if (pcap) {
free(pcap);
}
return ret;
}
esp_err_t pcap_del_session(pcap_file_handle_t pcap)
{
ESP_RETURN_ON_FALSE(pcap, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
if (pcap->file) {
fclose(pcap->file);
pcap->file = NULL;
}
free(pcap);
return ESP_OK;
}
esp_err_t pcap_write_header(pcap_file_handle_t pcap, pcap_link_type_t link_type)
{
ESP_RETURN_ON_FALSE(pcap, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
/* Write Pcap File header */
pcap_file_header_t header = {
.magic = pcap->endian_magic,
.major = pcap->major_version,
.minor = pcap->minor_version,
.zone = pcap->time_zone,
.sigfigs = 0,
.snaplen = 0x40000,
.link_type = link_type,
};
size_t real_write = fwrite(&header, sizeof(header), 1, pcap->file);
ESP_RETURN_ON_FALSE(real_write == 1, ESP_FAIL, TAG, "write pcap file header failed");
/* Save the link type to pcap file object */
pcap->link_type = link_type;
/* Flush content in the buffer into device */
fflush(pcap->file);
return ESP_OK;
}
esp_err_t pcap_capture_packet(pcap_file_handle_t pcap, void *payload, uint32_t length, uint32_t seconds, uint32_t microseconds)
{
ESP_RETURN_ON_FALSE(pcap && payload, ESP_ERR_INVALID_ARG, TAG, "invalid argumnet");
size_t real_write = 0;
pcap_packet_header_t header = {
.seconds = seconds,
.microseconds = microseconds,
.capture_length = length,
.packet_length = length
};
real_write = fwrite(&header, sizeof(header), 1, pcap->file);
ESP_RETURN_ON_FALSE(real_write == 1, ESP_FAIL, TAG, "write packet header failed");
real_write = fwrite(payload, sizeof(uint8_t), length, pcap->file);
ESP_RETURN_ON_FALSE(real_write == length, ESP_FAIL, TAG, "write packet payload failed");
/* Flush content in the buffer into device */
fflush(pcap->file);
return ESP_OK;
}
esp_err_t pcap_print_summary(pcap_file_handle_t pcap, FILE *print_file)
{
esp_err_t ret = ESP_OK;
long size = 0;
char *packet_payload = NULL;
ESP_RETURN_ON_FALSE(pcap && print_file, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
// get file size
fseek(pcap->file, 0L, SEEK_END);
size = ftell(pcap->file);
fseek(pcap->file, 0L, SEEK_SET);
// file empty is allowed, so return ESP_OK
ESP_RETURN_ON_FALSE(size, ESP_OK, TAG, "pcap file is empty");
// packet index (by bytes)
uint32_t index = 0;
pcap_file_header_t file_header;
size_t real_read = fread(&file_header, sizeof(pcap_file_header_t), 1, pcap->file);
ESP_RETURN_ON_FALSE(real_read == 1, ESP_FAIL, TAG, "read pcap file header failed");
index += sizeof(pcap_file_header_t);
//print pcap header information
fprintf(print_file, "------------------------------------------------------------------------\n");
fprintf(print_file, "Pcap packet Head:\n");
fprintf(print_file, "------------------------------------------------------------------------\n");
fprintf(print_file, "Magic Number: %x\n", file_header.magic);
fprintf(print_file, "Major Version: %d\n", file_header.major);
fprintf(print_file, "Minor Version: %d\n", file_header.minor);
fprintf(print_file, "SnapLen: %d\n", file_header.snaplen);
fprintf(print_file, "LinkType: %d\n", file_header.link_type);
fprintf(print_file, "------------------------------------------------------------------------\n");
uint32_t packet_num = 0;
pcap_packet_header_t packet_header;
while (index < size) {
real_read = fread(&packet_header, sizeof(pcap_packet_header_t), 1, pcap->file);
ESP_GOTO_ON_FALSE(real_read == 1, ESP_FAIL, err, TAG, "read pcap packet header failed");
// print packet header information
fprintf(print_file, "Packet %d:\n", packet_num);
fprintf(print_file, "Timestamp (Seconds): %d\n", packet_header.seconds);
fprintf(print_file, "Timestamp (Microseconds): %d\n", packet_header.microseconds);
fprintf(print_file, "Capture Length: %d\n", packet_header.capture_length);
fprintf(print_file, "Packet Length: %d\n", packet_header.packet_length);
size_t payload_length = packet_header.capture_length;
packet_payload = malloc(payload_length);
ESP_GOTO_ON_FALSE(packet_payload, ESP_ERR_NO_MEM, err, TAG, "no mem to save packet payload");
real_read = fread(packet_payload, payload_length, 1, pcap->file);
ESP_GOTO_ON_FALSE(real_read == 1, ESP_FAIL, err, TAG, "read payload error");
// print packet information
// currently only print info for 802.11
if (file_header.link_type == PCAP_LINK_TYPE_802_11) {
fprintf(print_file, "Packet Type: %2x\n", (packet_payload[0] >> 4) & 0x03);
fprintf(print_file, "Packet Subtype: %2x\n", packet_payload[0] & 0x0F);
fprintf(print_file, "Destination: ");
for (int j = 0; j < 5; j++) {
fprintf(print_file, "%2x ", packet_payload[4 + j]);
}
fprintf(print_file, "%2x\n", packet_payload[9]);
fprintf(print_file, "Source: ");
for (int j = 0; j < 5; j++) {
fprintf(print_file, "%2x ", packet_payload[10 + j]);
}
fprintf(print_file, "%2x\n", packet_payload[15]);
fprintf(print_file, "------------------------------------------------------------------------\n");
} else if (file_header.link_type == PCAP_LINK_TYPE_ETHERNET){
fprintf(print_file, "Destination: ");
for (int j = 0; j < 5; j++) {
fprintf(print_file, "%2x ", packet_payload[j]);
}
fprintf(print_file, "%2x\n", packet_payload[5]);
fprintf(print_file, "Source: ");
for (int j = 0; j < 5; j++) {
fprintf(print_file, "%2x ", packet_payload[6 + j]);
}
fprintf(print_file, "%2x\n", packet_payload[11]);
fprintf(print_file, "Type: 0x%x\n", packet_payload[13] | (packet_payload[12] << 8));
fprintf(print_file, "------------------------------------------------------------------------\n");
}
else {
fprintf(print_file, "Unknown link type:%d\n", file_header.link_type);
fprintf(print_file, "------------------------------------------------------------------------\n");
}
free(packet_payload);
packet_payload = NULL;
index += packet_header.capture_length + sizeof(pcap_packet_header_t);
packet_num ++;
}
fprintf(print_file, "Pcap packet Number: %d\n", packet_num);
fprintf(print_file, "------------------------------------------------------------------------\n");
return ret;
err:
if (packet_payload) {
free(packet_payload);
}
return ret;
}

2
examples/network/simple_sniffer/components/pcap/CMakeLists.txt
View File

@ -1,2 +0,0 @@
idf_component_register(SRCS "pcap.c"
INCLUDE_DIRS .)

11
examples/network/simple_sniffer/components/pcap/component.mk
View File

@ -1,11 +0,0 @@
#
# Component Makefile
#
# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
#include $(IDF_PATH)/make/component_common.mk
COMPONENT_ADD_INCLUDEDIRS := .

141
examples/network/simple_sniffer/components/pcap/pcap.c
View File

@ -1,141 +0,0 @@
// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/fcntl.h>
#include "esp_types.h"
#include "esp_err.h"
#include "esp_log.h"
#include "pcap.h"
static const char *PCAP_TAG = "pcap";
#define PCAP_CHECK(a, str, goto_tag, ...) \
do \
{ \
if (!(a)) \
{ \
ESP_LOGE(PCAP_TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
goto goto_tag; \
} \
} while (0)
/**
* @brief Pcap File Header
*
*/
typedef struct {
uint32_t magic; /*!< Magic Number */
uint16_t major; /*!< Major Version */
uint16_t minor; /*!< Minor Version */
uint32_t zone; /*!< Time Zone Offset */
uint32_t sigfigs; /*!< Timestamp Accuracy */
uint32_t snaplen; /*!< Max Length to Capture */
uint32_t link_type; /*!< Link Layer Type */
} pcap_file_header_t;
/**
* @brief Pcap Packet Header
*
*/
typedef struct {
uint32_t seconds; /*!< Number of seconds since January 1st, 1970, 00:00:00 GMT */
uint32_t microseconds; /*!< Number of microseconds when the packet was captured (offset from seconds) */
uint32_t capture_length; /*!< Number of bytes of captured data, no longer than packet_length */
uint32_t packet_length; /*!< Actual length of current packet */
} pcap_packet_header_t;
/**
* @brief Pcap Runtime Handle
*
*/
typedef struct {
FILE *file; /*!< File handle */
} pcap_runtime_t;
esp_err_t pcap_capture_packet(pcap_handle_t handle, void *payload, uint32_t length, uint32_t seconds, uint32_t microseconds)
{
PCAP_CHECK(handle, "pcap handle is NULL", err);
pcap_runtime_t *pcap_rt = (pcap_runtime_t *)handle;
PCAP_CHECK(pcap_rt->file, "pcap file is NULL", err);
size_t real_write = 0;
pcap_packet_header_t header = {
.seconds = seconds,
.microseconds = microseconds,
.capture_length = length,
.packet_length = length
};
real_write = fwrite(&header, sizeof(header), 1, pcap_rt->file);
PCAP_CHECK(real_write == 1, "write packet header error", err);
real_write = fwrite(payload, sizeof(uint8_t), length, pcap_rt->file);
PCAP_CHECK(real_write == length, "write packet payload error", err);
/* Flush content in the buffer into device */
fflush(pcap_rt->file);
return ESP_OK;
err:
return ESP_FAIL;
}
esp_err_t pcap_deinit(pcap_handle_t handle)
{
PCAP_CHECK(handle, "pcap handle is NULL", err);
pcap_runtime_t *pcap_rt = (pcap_runtime_t *)handle;
if (pcap_rt->file != NULL) {
fclose(pcap_rt->file);
pcap_rt->file = NULL;
}
free(pcap_rt);
ESP_LOGD(PCAP_TAG, "pcap deinit OK");
return ESP_OK;
err:
ESP_LOGW(PCAP_TAG, "pcap deinit failed");
return ESP_FAIL;
}
esp_err_t pcap_init(pcap_config_t *config, pcap_handle_t *handle)
{
PCAP_CHECK(config, "config is NULL", err);
PCAP_CHECK(handle, "pcap handle is NULL", err);
pcap_runtime_t *pcap_rt = calloc(1, sizeof(pcap_runtime_t));
PCAP_CHECK(pcap_rt, "calloc pcap runtime failed", err);
pcap_rt->file = config->fp;
/* Write Pcap File header */
pcap_file_header_t header = {
.magic = PCAP_MAGIC_BIG_ENDIAN,
.major = PCAP_VERSION_MAJOR,
.minor = PCAP_VERSION_MINOR,
.zone = PCAP_TIME_ZONE_GMT,
.sigfigs = 0,
.snaplen = 0x40000,
.link_type = config->link_type
};
size_t real_write = fwrite(&header, sizeof(header), 1, pcap_rt->file);
PCAP_CHECK(real_write == 1, "write pcap file header failed", err_write);
/* Flush content in the buffer into device */
fflush(pcap_rt->file);
*handle = (pcap_handle_t)pcap_rt;
ESP_LOGD(PCAP_TAG, "pcap init OK");
return ESP_OK;
/* Error Handling */
err_write:
fclose(pcap_rt->file);
pcap_rt->file = NULL;
free(pcap_rt);
err:
ESP_LOGW(PCAP_TAG, "pcap init failed");
return ESP_FAIL;
}

105
examples/network/simple_sniffer/components/pcap/pcap.h
View File

@ -1,105 +0,0 @@
// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include "esp_err.h"
#define PCAP_MAGIC_BIG_ENDIAN 0xA1B2C3D4 /*!< Big-Endian */
#define PCAP_MAGIC_LITTLE_ENDIAN 0xD4C3B2A1 /*!< Little-Endian */
#define PCAP_VERSION_MAJOR 0x02 /*!< Major Version */
#define PCAP_VERSION_MINOR 0x04 /*!< Minor Version */
#define PCAP_TIME_ZONE_GMT 0x00 /*!< Time Zone */
/**
* @brief Link layer Type Definition, used for Pcap reader to decode payload
*
*/
typedef enum {
PCAP_LINK_TYPE_LOOPBACK = 0, /*!< Loopback devices, except for later OpenBSD */
PCAP_LINK_TYPE_ETHERNET = 1, /*!< Ethernet, and Linux loopback devices */
PCAP_LINK_TYPE_TOKEN_RING = 6, /*!< 802.5 Token Ring */
PCAP_LINK_TYPE_ARCNET = 7, /*!< ARCnet */
PCAP_LINK_TYPE_SLIP = 8, /*!< SLIP */
PCAP_LINK_TYPE_PPP = 9, /*!< PPP */
PCAP_LINK_TYPE_FDDI = 10, /*!< FDDI */
PCAP_LINK_TYPE_ATM = 100, /*!< LLC/SNAP encapsulated ATM */
PCAP_LINK_TYPE_RAW_IP = 101, /*!< Raw IP, without link */
PCAP_LINK_TYPE_BSD_SLIP = 102, /*!< BSD/OS SLIP */
PCAP_LINK_TYPE_BSD_PPP = 103, /*!< BSD/OS PPP */
PCAP_LINK_TYPE_CISCO_HDLC = 104, /*!< Cisco HDLC */
PCAP_LINK_TYPE_802_11 = 105, /*!< 802.11 */
PCAP_LINK_TYPE_BSD_LOOPBACK = 108, /*!< OpenBSD loopback devices(with AF_value in network byte order) */
PCAP_LINK_TYPE_LOCAL_TALK = 114 /*!< LocalTalk */
} pcap_link_type_t;
/**
* @brief Pcap configuration Type Definition
*
*/
typedef struct {
FILE *fp; /* Pointer to a standard file handle */
pcap_link_type_t link_type; /* Pcap Link Type */
} pcap_config_t;
/**
* @brief Pcap Handle Type Definition
*
*/
typedef void *pcap_handle_t;
/**
* @brief Initialize a pcap session
*
* @param config configuration of creating pcap object
* @param handle pcap handle
* @return esp_err_t
* - ESP_OK on success
* - ESP_FAIL on error
*/
esp_err_t pcap_init(pcap_config_t *config, pcap_handle_t *handle);
/**
* @brief De-initialize a pcap session
*
* @param handle pcap handle
* @return esp_err_t
* - ESP_OK on success
* - ESP_FAIL on error
*/
esp_err_t pcap_deinit(pcap_handle_t handle);
/**
* @brief Capture one packet into pcap file
*
* @param handle pcap handle
* @param payload pointer of the captured data
* @param length length of captured data
* @param seconds second of capture time
* @param microseconds microsecond of capture time
* @return esp_err_t
* - ESP_OK on success
* - ESP_FAIL on error
*/
esp_err_t pcap_capture_packet(pcap_handle_t handle, void *payload, uint32_t length, uint32_t seconds, uint32_t microseconds);
#ifdef __cplusplus
}
#endif