mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
312 lines
7.4 KiB
C
312 lines
7.4 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#ifndef NOT_MOCK_DNS
|
|
#include "lwip/dns.h"
|
|
#endif
|
|
#include "lwip/etharp.h"
|
|
#include "lwip/mem.h"
|
|
#include "lwip/netif.h"
|
|
#include "lwip/opt.h"
|
|
#include "lwip/pbuf.h"
|
|
#include "lwip/timeouts.h"
|
|
#include "lwip/udp.h"
|
|
#include "lwip/timeouts.h"
|
|
#include "esp32_mock.h"
|
|
#include "no_warn_host.h"
|
|
|
|
#define ESP_OK 0
|
|
|
|
/* ---------------------------------------------------- Variables ------------------------------------------------------
|
|
*
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// -------------------- LWIP Globals -----------------------
|
|
|
|
// ip_addr.h
|
|
const ip_addr_t ip_addr_any;
|
|
const ip_addr_t ip_addr_broadcast;
|
|
const ip_addr_t ip_addr_any_type;
|
|
// ip.h
|
|
struct ip_globals ip_data;
|
|
// netif.h
|
|
struct netif *netif_list;
|
|
|
|
// ---------------- AFL Host Test Globals ------------------
|
|
|
|
// dns_di.h
|
|
uint32_t g_random_numbers[8] = {0};
|
|
uint32_t g_random_numbers_cnt = 0;
|
|
|
|
// ----------------------- Locals --------------------------
|
|
|
|
struct udp_pcb mock_pcb;
|
|
|
|
/* ---------------------------------------------------- LWIP Mock ------------------------------------------------------
|
|
*
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- lwip/dns.h ------------------------
|
|
|
|
#ifndef NOT_MOCK_DNS
|
|
void dns_setserver(u8_t numdns, const ip_addr_t *dnsserver)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
// -------------------- lwip/etharp.h ----------------------
|
|
|
|
err_t etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
// --------------------- lwip/mem.h ------------------------
|
|
|
|
void * mem_malloc(mem_size_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
void * mem_calloc(size_t nr, mem_size_t size)
|
|
{
|
|
return calloc(nr, size);
|
|
}
|
|
|
|
void mem_free(void *rmem)
|
|
{
|
|
free(rmem);
|
|
}
|
|
|
|
// -------------------- lwip/netif.h -----------------------
|
|
|
|
void netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask,
|
|
const ip4_addr_t *gw)
|
|
{
|
|
}
|
|
|
|
// --------------------- lwip/pbuf.h -----------------------
|
|
|
|
struct pbuf * pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type)
|
|
{
|
|
struct pbuf * p;
|
|
p = (struct pbuf *)malloc(MEMP_PBUF_POOL);
|
|
p->tot_len = length;
|
|
p->next = NULL;
|
|
p->type_internal = PBUF_POOL;
|
|
p->len = length;
|
|
p->payload = malloc(length);
|
|
return p;
|
|
}
|
|
|
|
void pbuf_realloc(struct pbuf *p, u16_t size)
|
|
{
|
|
if (p != NULL)
|
|
{
|
|
uint8_t *buf = malloc(size);
|
|
free(p->payload);
|
|
p->payload = buf;
|
|
p->len = size;
|
|
p->tot_len = size;
|
|
}
|
|
}
|
|
|
|
u8_t pbuf_free(struct pbuf *p)
|
|
{
|
|
if (p) {
|
|
if (p->payload) {
|
|
free(p->payload);
|
|
p->payload = NULL;
|
|
}
|
|
free (p);
|
|
p = NULL;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
u16_t pbuf_copy_partial(const struct pbuf *buf, void *dataptr, u16_t len, u16_t offset)
|
|
{
|
|
struct pbuf *p;
|
|
u16_t left;
|
|
u16_t buf_copy_len;
|
|
u16_t copied_total = 0;
|
|
|
|
LWIP_ERROR("pbuf_copy_partial: invalid buf", (buf != NULL), return 0;);
|
|
LWIP_ERROR("pbuf_copy_partial: invalid dataptr", (dataptr != NULL), return 0;);
|
|
|
|
left = 0;
|
|
|
|
if ((buf == NULL) || (dataptr == NULL)) {
|
|
return 0;
|
|
}
|
|
|
|
/* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */
|
|
for (p = buf; len != 0 && p != NULL; p = p->next) {
|
|
if ((offset != 0) && (offset >= p->len)) {
|
|
/* don't copy from this buffer -> on to the next */
|
|
offset -= p->len;
|
|
} else {
|
|
/* copy from this buffer. maybe only partially. */
|
|
buf_copy_len = p->len - offset;
|
|
if (buf_copy_len > len)
|
|
buf_copy_len = len;
|
|
/* copy the necessary parts of the buffer */
|
|
MEMCPY(&((char*)dataptr)[left], &((char*)p->payload)[offset], buf_copy_len);
|
|
copied_total += buf_copy_len;
|
|
left += buf_copy_len;
|
|
len -= buf_copy_len;
|
|
offset = 0;
|
|
}
|
|
}
|
|
return copied_total;
|
|
}
|
|
|
|
err_t pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len)
|
|
{
|
|
return ERR_OK;
|
|
}
|
|
|
|
err_t pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset)
|
|
{
|
|
return ERR_OK;
|
|
}
|
|
|
|
struct pbuf* pbuf_skip(struct pbuf* in, u16_t in_offset, u16_t* out_offset)
|
|
{
|
|
u16_t offset_left = in_offset;
|
|
struct pbuf* q = in;
|
|
|
|
/* get the correct pbuf */
|
|
while ((q != NULL) && (q->len <= offset_left)) {
|
|
offset_left -= q->len;
|
|
q = q->next;
|
|
}
|
|
if (out_offset != NULL) {
|
|
*out_offset = offset_left;
|
|
}
|
|
return q;
|
|
}
|
|
|
|
u8_t pbuf_get_at(const struct pbuf* p, u16_t offset)
|
|
{
|
|
u16_t q_idx;
|
|
struct pbuf* q = pbuf_skip(p, offset, &q_idx);
|
|
|
|
/* return requested data if pbuf is OK */
|
|
if ((q != NULL) && (q->len > q_idx)) {
|
|
return ((u8_t*)q->payload)[q_idx];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int pbuf_try_get_at(const struct pbuf* p, u16_t offset)
|
|
{
|
|
u16_t q_idx;
|
|
struct pbuf* q = pbuf_skip(p, offset, &q_idx);
|
|
|
|
/* return requested data if pbuf is OK */
|
|
if ((q != NULL) && (q->len > q_idx)) {
|
|
return ((u8_t*)q->payload)[q_idx];
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void pbuf_put_at(struct pbuf* p, u16_t offset, u8_t data)
|
|
{
|
|
u16_t q_idx;
|
|
struct pbuf* q = pbuf_skip(p, offset, &q_idx);
|
|
|
|
/* write requested data if pbuf is OK */
|
|
if ((q != NULL) && (q->len > q_idx)) {
|
|
((u8_t*)q->payload)[q_idx] = data;
|
|
}
|
|
}
|
|
|
|
// ------------------- lwip/timeouts.h ---------------------
|
|
|
|
void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg)
|
|
{
|
|
}
|
|
|
|
void sys_untimeout(sys_timeout_handler handler, void *arg)
|
|
{
|
|
}
|
|
|
|
// --------------------- lwip/udp.h ------------------------
|
|
|
|
struct udp_pcb *udp_new(void)
|
|
{
|
|
return malloc(sizeof(struct udp_pcb));
|
|
}
|
|
|
|
struct udp_pcb * udp_new_ip_type(u8_t type)
|
|
{
|
|
return &mock_pcb;
|
|
}
|
|
|
|
void udp_remove(struct udp_pcb *pcb)
|
|
{
|
|
if (pcb == NULL)
|
|
{
|
|
free(pcb);
|
|
}
|
|
}
|
|
|
|
err_t udp_bind(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
err_t udp_connect(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
err_t udp_sendto(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, u16_t dst_port)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
void udp_disconnect(struct udp_pcb *pcb)
|
|
{
|
|
}
|
|
|
|
void udp_recv(struct udp_pcb *pcb, udp_recv_fn recv, void *recv_arg)
|
|
{
|
|
}
|
|
|
|
err_t udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
err_t udp_sendto_if_src(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif, const ip_addr_t *src_ip)
|
|
{
|
|
return ESP_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------- ESP32 Port Mock ---------------------------------------------------
|
|
*
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- lwipopts.h ------------------------
|
|
|
|
uint32_t esp_random(void)
|
|
{
|
|
// Preparation for injecting favorable random numbers
|
|
return g_random_numbers[g_random_numbers_cnt++ % 8];
|
|
}
|
|
|
|
void dhcp_parse_extra_opts(struct dhcp *dhcp, uint8_t state, uint8_t option, uint8_t len, struct pbuf* p, uint16_t offset)
|
|
{
|
|
}
|
|
|
|
void dhcp_append_extra_opts(struct netif *netif, uint8_t state, struct dhcp_msg *msg_out, uint16_t *options_out_len)
|
|
{
|
|
}
|