fuzz_common.h File Reference

#include "lwip/opt.h"
#include "lwip/arch.h"

Include dependency graph for fuzz_common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	LWIP_FUZZ_DEFAULT   0x01
#define	LWIP_FUZZ_STATICARP   0x02
#define	LWIP_FUZZ_TCP_SERVER   0x04
#define	LWIP_FUZZ_TCP_CLIENT   0x08
#define	LWIP_FUZZ_UDP_SERVER   0x10
#define	LWIP_FUZZ_UDP_CLIENT   0x20

Enumerations
enum	lwip_fuzz_type { LWIP_FUZZ_SINGLE = 0 , LWIP_FUZZ_MULTIPACKET = 1 , LWIP_FUZZ_MULTIPACKET_TIME = 2 }

Functions
int	lwip_fuzztest (int argc, char **argv, enum lwip_fuzz_type type, u32_t test_apps)

Macro Definition Documentation

LWIP_FUZZ_DEFAULT

#define LWIP_FUZZ_DEFAULT   0x01

Definition at line 49 of file fuzz_common.h.

LWIP_FUZZ_STATICARP

#define LWIP_FUZZ_STATICARP   0x02

Definition at line 50 of file fuzz_common.h.

LWIP_FUZZ_TCP_CLIENT

#define LWIP_FUZZ_TCP_CLIENT   0x08

Definition at line 52 of file fuzz_common.h.

LWIP_FUZZ_TCP_SERVER

#define LWIP_FUZZ_TCP_SERVER   0x04

Definition at line 51 of file fuzz_common.h.

LWIP_FUZZ_UDP_CLIENT

#define LWIP_FUZZ_UDP_CLIENT   0x20

Definition at line 54 of file fuzz_common.h.

LWIP_FUZZ_UDP_SERVER

#define LWIP_FUZZ_UDP_SERVER   0x10

Definition at line 53 of file fuzz_common.h.

Enumeration Type Documentation

lwip_fuzz_type

enum lwip_fuzz_type

Enumerator
LWIP_FUZZ_SINGLE
LWIP_FUZZ_MULTIPACKET
LWIP_FUZZ_MULTIPACKET_TIME

Definition at line 42 of file fuzz_common.h.

                    {
  LWIP_FUZZ_SINGLE = 0,
  LWIP_FUZZ_MULTIPACKET = 1,
  LWIP_FUZZ_MULTIPACKET_TIME = 2
};

Function Documentation

lwip_fuzztest()

int lwip_fuzztest	(	int	argc,
		char **	argv,
		enum lwip_fuzz_type	type,
		u32_t	test_apps
	)

Definition at line 576 of file fuzz_common.c.

{
  struct netif net_test;
  ip4_addr_t addr;
  ip4_addr_t netmask;
  ip4_addr_t gw;
  size_t len;
  err_t err;
  ip_addr_t remote_addr;      /* a IPv4 addr of the destination */
  struct eth_addr remote_mac = ETH_ADDR(0x28, 0x00, 0x00, 0x22, 0x2b, 0x38); /* a MAC addr of the destination */
 
  pcap_dump_init();
  lwip_init();
 
  IP4_ADDR(&addr, 172, 30, 115, 84);
  IP4_ADDR(&netmask, 255, 255, 255, 0);
  IP4_ADDR(&gw, 172, 30, 115, 1);
 
  netif_add(&net_test, &addr, &netmask, &gw, &net_test, testif_init, ethernet_input);
  netif_set_up(&net_test);
  netif_set_link_up(&net_test);
 
  if (test_apps & LWIP_FUZZ_STATICARP) {
    /* Add the ARP entry */
    IP_ADDR4(&remote_addr, 172, 30, 115, 37);
    etharp_add_static_entry(&(remote_addr.u_addr.ip4), &remote_mac);
  }
 
#if LWIP_IPV6
  nd6_tmr(); /* tick nd to join multicast groups */
#endif
  dns_setserver(0, &net_test.gw);
 
  if (test_apps & LWIP_FUZZ_DEFAULT) {
    /* initialize apps */
    httpd_init();
    lwiperf_start_tcp_server_default(NULL, NULL);
    mdns_resp_init();
    mdns_resp_add_netif(&net_test, "hostname");
    snmp_init();
  }
  if (test_apps & LWIP_FUZZ_TCP_CLIENT) {
    tcp_client_pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY);
    LWIP_ASSERT("Error: altcp_new() failed", tcp_client_pcb != NULL);
    tcp_remote_port = 80;
    err = altcp_connect(tcp_client_pcb, &remote_addr, tcp_remote_port, tcp_client_connected);
    LWIP_ASSERT("Error: altcp_connect() failed", err == ERR_OK);
    altcp_recv(tcp_client_pcb, tcp_client_recv);
    altcp_err(tcp_client_pcb, tcp_client_err);
    altcp_poll(tcp_client_pcb, tcp_client_poll, 10);
    altcp_sent(tcp_client_pcb, tcp_client_sent);
  }
  if (test_apps & LWIP_FUZZ_TCP_SERVER) {
    tcp_server_pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY);
    LWIP_ASSERT("Error: altcp_new() failed", tcp_server_pcb != NULL);
    altcp_setprio(tcp_server_pcb, TCP_PRIO_MIN);
    tcp_local_port = 80;
    err = altcp_bind(tcp_server_pcb, IP_ANY_TYPE, tcp_local_port);
    LWIP_ASSERT("Error: altcp_bind() failed", err == ERR_OK);
    tcp_server_pcb = altcp_listen(tcp_server_pcb);
    LWIP_ASSERT("Error: altcp_listen() failed", err == ERR_OK);
    altcp_accept(tcp_server_pcb, tcp_server_accept);
  }
  if (test_apps & LWIP_FUZZ_UDP_CLIENT) {
    udp_client_pcb = udp_new();
    udp_new_ip_type(IPADDR_TYPE_ANY);
    udp_recv(udp_client_pcb, udp_client_recv, NULL);
    udp_remote_port = 161;
    udp_connect(udp_client_pcb, &remote_addr, udp_remote_port);
  }
  if (test_apps & LWIP_FUZZ_UDP_SERVER) {
    udp_server_pcb = udp_new();
    udp_new_ip_type(IPADDR_TYPE_ANY);
    udp_local_port = 161;
    udp_bind(udp_server_pcb, IP_ANY_TYPE, udp_local_port);
    udp_recv(udp_server_pcb, udp_server_recv, NULL);
  }
 
  if(argc > 1) {
    FILE* f;
    const char* filename;
    printf("reading input from file... ");
    fflush(stdout);
    filename = argv[1];
    LWIP_ASSERT("invalid filename", filename != NULL);
    f = fopen(filename, "rb");
    LWIP_ASSERT("open failed", f != NULL);
    len = fread(pktbuf, 1, sizeof(pktbuf), f);
    fclose(f);
    printf("testing file: \"%s\"...\r\n", filename);
  } else {
    len = fread(pktbuf, 1, sizeof(pktbuf), stdin);
  }
  input_pkts(type, &net_test, pktbuf, len);
 
  pcap_dump_stop();
  return 0;
}

Referenced by main().