wt/mongoose
1
0
Fork 0
mirror of https://github.com/cesanta/mongoose.git synced 2026-10-11 17:04:33 +07:00
Code Issues Packages Projects Releases Wiki Activity

simplify eth and ppp tests, add IPV6 testing for VC targets

Browse Source
This commit is contained in:
Sergio R. Caprile
2026-07-01 16:19:38 -03:00
parent 8bb65c6492
commit dfbbe5fa8b
3 changed files with 449 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/Makefile
+2 -2
View File
@@ -1,6 +1,6 @@
SRCS = mongoose.c unit_test.c packed_fs.c
HDRS = $(wildcard ../src/*.h) $(wildcard ../src/drivers/*.h)
DEFS ?= -DMG_MAX_HTTP_HEADERS=7 -DMG_ENABLE_LINES -DMG_ENABLE_SSI=1 -DMG_ENABLE_ASSERT=1
DEFS ?= -DMG_MAX_HTTP_HEADERS=7 -DMG_ENABLE_LINES -DMG_ENABLE_SSI=1 -DMG_ENABLE_ASSERT=1 -DMG_ENABLE_IPV6=$(IPV6)
WARN ?= -pedantic -W -Wall -Werror -Wshadow -Wdouble-promotion -fno-common -Wconversion -Wundef
OPTS ?= -O3 -g3
INCS ?= -Isrc -I.
@@ -25,7 +25,7 @@ PREFIX ?= /usr/local
LIBDIR ?= $(PREFIX)/lib
INCLUDEDIR ?= $(PREFIX)/include
VERSION ?= $(shell cut -d'"' -f2 ../src/version.h)
COMMON_CFLAGS ?= $(C_WARN) $(WARN) $(INCS) $(DEFS) -DMG_ENABLE_IPV6=$(IPV6) $(TFLAGS) -pthread
COMMON_CFLAGS ?= $(C_WARN) $(WARN) $(INCS) $(DEFS) $(TFLAGS) -pthread
CFLAGS ?= $(OPTS) $(ASAN) $(COMMON_CFLAGS)
VALGRIND_CFLAGS ?= $(OPTS) $(COMMON_CFLAGS)
VALGRIND_RUN ?= valgrind --tool=memcheck --gen-suppressions=all --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --error-exitcode=1 --exit-on-first-error=yes --fair-sched=yes
test/eth_test.c
+180 -183
View File
@@ -67,203 +67,200 @@ static size_t add_fcs(uint8_t *buf, size_t len) {
return len + sizeof(crc);
}
static void test_plain_accept(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
mg_l2_init(&ifp);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
len = mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_plain_discard(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
char sentinel[] = "discard";
struct mg_tcpip_if ifp;
struct mg_str raw, pay = mg_str_n(sentinel, sizeof(sentinel));
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
mg_l2_init(&ifp);
len = mk_eth(frame, s_mac, 0x1234, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
}
static void test_mac_check_accept(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.enable_mac_check = true;
mg_l2_init(&ifp);
len = mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_mac_check_discard(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4}, dst[6] = {1, 1, 1, 1, 1, 1};
char sentinel[] = "discard";
struct mg_tcpip_if ifp;
struct mg_str raw, pay = mg_str_n(sentinel, sizeof(sentinel));
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.enable_mac_check = true;
mg_l2_init(&ifp);
len = mk_eth(frame, dst, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
static void test_fcs_check_accept(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.enable_fcs_check = true;
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload)));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_fcs_check_discard(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
char sentinel[] = "discard";
struct mg_tcpip_if ifp;
struct mg_str raw, pay = mg_str_n(sentinel, sizeof(sentinel));
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.enable_fcs_check = true;
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload)));
frame[len - 1] ^= 1;
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
static void test_fcs_check_disabled(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload)));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload) + sizeof(uint32_t));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_vlan_accept(void) {
uint8_t frame[64], payload[] = {5, 6, 7, 8};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.l2data.eth.vlan_id = 123;
mg_l2_init(&ifp);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
len = mk_vlan(frame, s_mac, 123, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV6);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_vlan_discard(void) {
uint8_t frame[64], payload[] = {5, 6, 7, 8};
char sentinel[] = "discard";
struct mg_tcpip_if ifp;
struct mg_str raw, pay = mg_str_n(sentinel, sizeof(sentinel));
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
ifp.l2data.eth.vlan_id = 123;
mg_l2_init(&ifp);
len = mk_vlan(frame, s_mac, 124, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
static void test_tagged_without_vlan_discard(void) {
uint8_t frame[64], payload[] = {5, 6, 7, 8};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
size_t len;
reset_if(&ifp);
mg_l2_init(&ifp);
len = mk_vlan(frame, s_mac, 123, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
}
#define DASHBOARD(x) \
printf("HEALTH_DASHBOARD\t\"%s\": %s,\n", x, s_error ? "false" : "true")
static void test_eth(void) {
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto;
size_t len;
uint8_t frame[64];
{ // Plain Ethernet frame is accepted
uint8_t payload[] = {1, 2, 3, 4};
reset_if(&ifp);
mg_l2_init(&ifp);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
len = mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // Unknown Ethernet type is discarded
uint8_t payload[] = {1, 2, 3, 4};
char sentinel[] = "discard";
reset_if(&ifp);
mg_l2_init(&ifp);
len = mk_eth(frame, s_mac, 0x1234, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
pay = mg_str_n(sentinel, sizeof(sentinel));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
}
}
static void test_mac(void) {
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto;
size_t len;
uint8_t frame[64];
{ // MAC check accepts frames addressed to us
uint8_t payload[] = {1, 2, 3, 4};
reset_if(&ifp);
ifp.enable_mac_check = true;
mg_l2_init(&ifp);
len = mk_eth(frame, s_mac, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // MAC check discards alien unicast frames
uint8_t payload[] = {1, 2, 3, 4}, dst[6] = {1, 1, 1, 1, 1, 1};
char sentinel[] = "discard";
reset_if(&ifp);
ifp.enable_mac_check = true;
mg_l2_init(&ifp);
len = mk_eth(frame, dst, 0x0800, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
pay = mg_str_n(sentinel, sizeof(sentinel));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
}
static void test_fcs(void) {
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto;
size_t len;
uint8_t frame[64];
{ // FCS check strips a valid CRC
uint8_t payload[] = {1, 2, 3, 4};
reset_if(&ifp);
ifp.enable_fcs_check = true;
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload,
sizeof(payload)));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // FCS check rejects a bad CRC
uint8_t payload[] = {1, 2, 3, 4};
char sentinel[] = "discard";
reset_if(&ifp);
ifp.enable_fcs_check = true;
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload,
sizeof(payload)));
frame[len - 1] ^= 1;
raw = mg_str_n((char *) frame, len);
pay = mg_str_n(sentinel, sizeof(sentinel));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
{ // Disabled FCS check leaves the CRC in payload
uint8_t payload[] = {1, 2, 3, 4};
reset_if(&ifp);
mg_l2_init(&ifp);
len = add_fcs(frame, mk_eth(frame, s_mac, 0x0800, payload,
sizeof(payload)));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload) + sizeof(uint32_t));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
}
static void test_vlan(void) {
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto;
size_t len;
uint8_t frame[64];
{ // Configured VLAN accepts matching tagged frames
uint8_t payload[] = {5, 6, 7, 8};
reset_if(&ifp);
ifp.l2data.eth.vlan_id = 123;
mg_l2_init(&ifp);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
len = mk_vlan(frame, s_mac, 123, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV6);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // Configured VLAN rejects non-matching tags
uint8_t payload[] = {5, 6, 7, 8};
char sentinel[] = "discard";
reset_if(&ifp);
ifp.l2data.eth.vlan_id = 123;
mg_l2_init(&ifp);
len = mk_vlan(frame, s_mac, 124, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
pay = mg_str_n(sentinel, sizeof(sentinel));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
ASSERT(pay.buf == sentinel);
ASSERT(pay.len == sizeof(sentinel));
}
{ // Tagged frames are rejected when no VLAN is configured
uint8_t payload[] = {5, 6, 7, 8};
reset_if(&ifp);
mg_l2_init(&ifp);
len = mk_vlan(frame, s_mac, 123, 0x86dd, payload, sizeof(payload));
raw = mg_str_n((char *) frame, len);
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(proto == MG_TCPIP_L2PROTO_ARP);
}
}
int main(void) {
s_error = false;
test_plain_accept();
test_plain_discard();
test_eth();
DASHBOARD("eth");
s_error = false;
test_mac_check_accept();
test_mac_check_discard();
test_mac();
DASHBOARD("mac");
s_error = false;
test_fcs_check_accept();
test_fcs_check_discard();
test_fcs_check_disabled();
test_fcs();
DASHBOARD("fcs");
s_error = false;
test_vlan_accept();
test_vlan_discard();
test_tagged_without_vlan_discard();
test_vlan();
printf("HEALTH_DASHBOARD\t\"vlan\": %s\n", s_error ? "false" : "true");
#ifdef NO_ABORT
test/ppp_test.c
+267 -306
View File
@@ -93,314 +93,292 @@ static size_t mk_pppoe_sess(uint8_t *buf, uint16_t id, uint16_t proto,
return sizeof(*eth) + sizeof(*pppoe) + sizeof(*ppp) + len;
}
static void test_ppp_lcp_accept(void) {
static void test_lcp(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct lcp lcp = {MG_PPP_LCP_CFG_ACK, 1, mg_htons(sizeof(lcp))};
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_LCP, &lcp, sizeof(lcp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_lcpup == true);
enum mg_l2proto proto;
{ // LCP ACK brings PPP link up
struct lcp lcp = {MG_PPP_LCP_CFG_ACK, 1, mg_htons(sizeof(lcp))};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_LCP, &lcp, sizeof(lcp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_lcpup == true);
}
{ // Short LCP frame is discarded
uint8_t lcp[] = {MG_PPP_LCP_CFG_ACK, 1};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_LCP, lcp, sizeof(lcp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_lcpup == false);
}
}
static void test_ppp_lcp_discard(void) {
uint8_t frame[64], lcp[] = {MG_PPP_LCP_CFG_ACK, 1};
static void test_ipcp(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_LCP, lcp, sizeof(lcp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_lcpup == false);
}
enum mg_l2proto proto;
static void test_ppp_ip_accept(void) {
uint8_t frame[64], payload[sizeof(struct ip)];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IP, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_ppp_ip_discard(void) {
uint8_t frame[64], payload[sizeof(struct ip)];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IP, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
}
static void test_ppp_ipcp_accept(void) {
uint8_t frame[64], ipcp[] = {MG_PPP_IPCP_CFG_REQ, 1, 0, 10,
MG_PPP_IPCP_OPT_IPADDR, 6, 192, 0, 2, 1};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
uint32_t peer;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
memcpy(&peer, ipcp + 6, sizeof(peer));
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPCP, ipcp, sizeof(ipcp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.gw == peer);
ASSERT(((struct ipcp *) ppp_payload(frame))->code == MG_PPP_IPCP_CFG_ACK);
ASSERT(ifp.nsent == 2);
}
static void test_ppp_ipcp_reject(void) {
uint8_t frame[64], ipcp[] = {MG_PPP_IPCP_CFG_REQ, 1, 0, 4};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPCP, ipcp, sizeof(ipcp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.gw == 0);
ASSERT(((struct ipcp *) ppp_payload(frame))->code == MG_PPP_IPCP_CFG_REJECT);
ASSERT(ifp.nsent == 3);
{ // IPCP request with peer IP address is ACKed
uint8_t ipcp[] = {MG_PPP_IPCP_CFG_REQ, 1, 0, 10,
MG_PPP_IPCP_OPT_IPADDR, 6, 192, 0, 2, 1};
uint32_t peer;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
memcpy(&peer, ipcp + 6, sizeof(peer));
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPCP, ipcp, sizeof(ipcp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.gw == peer);
ASSERT(((struct ipcp *) ppp_payload(frame))->code == MG_PPP_IPCP_CFG_ACK);
ASSERT(ifp.nsent == 2);
}
{ // IPCP request without peer IP address is rejected
uint8_t ipcp[] = {MG_PPP_IPCP_CFG_REQ, 1, 0, 4};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPCP, ipcp, sizeof(ipcp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.gw == 0);
ASSERT(((struct ipcp *) ppp_payload(frame))->code ==
MG_PPP_IPCP_CFG_REJECT);
ASSERT(ifp.nsent == 3);
}
}
#if MG_ENABLE_IPV6
static void test_ppp_ipv6_accept(void) {
uint8_t frame[96], payload[sizeof(struct ip6)];
static void test_ipv6cp(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV6);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
enum mg_l2proto proto;
static void test_ppp_ipv6_discard(void) {
uint8_t frame[96], payload[sizeof(struct ip6)];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
}
static void test_ppp_ipv6cp_accept(void) {
uint8_t frame[64], ipv6cp[] = {MG_PPP_IPV6CP_CFG_REQ, 1, 0, 14,
MG_PPP_IPV6CP_OPT_IFCID, 10,
2, 3, 4, 5, 6, 7, 8, 9};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6CP, ipv6cp, sizeof(ipv6cp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(memcmp(&((struct mg_l2addr *) ifp.gwmac)->addr.ieee64, ipv6cp + 6,
8) == 0);
ASSERT(((struct ipv6cp *) ppp_payload(frame))->code ==
MG_PPP_IPV6CP_CFG_ACK);
ASSERT(ifp.nsent == 2);
}
static void test_ppp_ipv6cp_reject(void) {
uint8_t frame[64], ipv6cp[] = {MG_PPP_IPV6CP_CFG_REQ, 1, 0, 14,
MG_PPP_IPV6CP_OPT_IFCID, 10,
0, 0, 0, 0, 0, 0, 0, 0};
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6CP, ipv6cp, sizeof(ipv6cp)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(((struct ipv6cp *) ppp_payload(frame))->code ==
MG_PPP_IPV6CP_CFG_REJECT);
ASSERT(ifp.nsent == 1);
{ // IPv6CP request with interface ID is ACKed
uint8_t ipv6cp[] = {MG_PPP_IPV6CP_CFG_REQ, 1, 0, 14,
MG_PPP_IPV6CP_OPT_IFCID, 10, 2, 3, 4, 5, 6, 7, 8, 9};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6CP, ipv6cp,
sizeof(ipv6cp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(memcmp(&((struct mg_l2addr *) ifp.gwmac)->addr.ieee64, ipv6cp + 6,
8) == 0);
ASSERT(((struct ipv6cp *) ppp_payload(frame))->code ==
MG_PPP_IPV6CP_CFG_ACK);
ASSERT(ifp.nsent == 2);
}
{ // IPv6CP request with zero interface ID is rejected
uint8_t ipv6cp[] = {MG_PPP_IPV6CP_CFG_REQ, 1, 0, 14,
MG_PPP_IPV6CP_OPT_IFCID, 10, 0, 0, 0, 0, 0, 0, 0, 0};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6CP, ipv6cp,
sizeof(ipv6cp)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(((struct ipv6cp *) ppp_payload(frame))->code ==
MG_PPP_IPV6CP_CFG_REJECT);
ASSERT(ifp.nsent == 1);
}
}
#endif
static void test_ppp_unknown_reject(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
static void test_ppp(void) {
uint8_t frame[96];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, 0x1234, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.nsent == 1);
enum mg_l2proto proto;
{ // IPv4 packet is accepted after LCP is up
uint8_t payload[sizeof(struct ip)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IP, payload, sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // IPv4 packet is discarded while LCP is down
uint8_t payload[sizeof(struct ip)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IP, payload, sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
}
#if MG_ENABLE_IPV6
{ // IPv6 packet is accepted after LCP is up
uint8_t payload[sizeof(struct ip6)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6, payload,
sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV6);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // IPv6 packet is discarded while LCP is down
uint8_t payload[sizeof(struct ip6)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, MG_PPP_PROTO_IPV6, payload,
sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
}
#endif
{ // Unknown protocol is rejected after LCP is up
uint8_t payload[] = {1, 2, 3, 4};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_ppp(frame, 0x1234, payload, sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.nsent == 1);
}
{ // Unknown protocol is discarded while LCP is down
uint8_t payload[] = {1, 2, 3, 4};
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, 0x1234, payload, sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.nsent == 0);
}
}
static void test_ppp_unknown_discard(void) {
uint8_t frame[64], payload[] = {1, 2, 3, 4};
static void test_pppoe(void) {
uint8_t frame[96];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPP);
s_lcpup = false;
raw = mg_str_n((char *) frame,
mk_ppp(frame, 0x1234, payload, sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(ifp.nsent == 0);
}
enum mg_l2proto proto;
static void test_pppoe_pado_accept(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
s_state = MG_PPPoE_ST_DISC;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADO, 0, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_REQ);
ASSERT(ifp.nsent == 1);
}
static void test_pppoe_pado_discard(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADO, 0, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_REQ);
ASSERT(ifp.nsent == 0);
}
static void test_pppoe_pads_accept(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADS, 0x1234, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_SESS);
ASSERT(s_id == mg_htons(0x1234));
}
static void test_pppoe_pads_discard(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_DISC;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADS, 0x1234, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_DISC);
}
static void test_pppoe_padt_accept(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_id = mg_htons(0x1234);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADT, 0x1234, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_DISC);
ASSERT(s_id == 0);
ASSERT(s_lcpup == false);
}
static void test_pppoe_padt_discard(void) {
uint8_t frame[64];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_id = mg_htons(0x4321);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADT, 0x1234, NULL, 0));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_SESS);
ASSERT(s_id == mg_htons(0x4321));
ASSERT(s_lcpup == true);
}
static void test_pppoe_session_accept(void) {
uint8_t frame[96], payload[sizeof(struct ip)];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_sess(frame, 0x1234, MG_PPP_PROTO_IP, payload,
sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
static void test_pppoe_session_discard(void) {
uint8_t frame[96], payload[sizeof(struct ip)];
struct mg_tcpip_if ifp;
struct mg_str raw, pay;
enum mg_l2proto proto = MG_TCPIP_L2PROTO_ARP;
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_sess(frame, 0x1234, MG_PPP_PROTO_IP, payload,
sizeof(payload)));
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
{ // PADO moves discovery to request state
init_if(&ifp, MG_TCPIP_L2_PPPoE);
MG_DEBUG(("MTU: %u, frame size: %u", ifp.l2mtu, ifp.framesize));
ASSERT(ifp.l2mtu != 0);
ASSERT(ifp.framesize != 0);
s_state = MG_PPPoE_ST_DISC;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADO, 0, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_REQ);
ASSERT(ifp.nsent == 1);
}
{ // PADO is ignored outside discovery state
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADO, 0, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_REQ);
ASSERT(ifp.nsent == 0);
}
{ // PADS establishes the session
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADS, 0x1234, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_SESS);
ASSERT(s_id == mg_htons(0x1234));
}
{ // PADS is ignored outside request state
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_DISC;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADS, 0x1234, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_DISC);
}
{ // PADT matching the session tears it down
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_id = mg_htons(0x1234);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADT, 0x1234, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_DISC);
ASSERT(s_id == 0);
ASSERT(s_lcpup == false);
}
{ // PADT for a different session is ignored
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_id = mg_htons(0x4321);
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_disc(frame, MG_PPPoE_PADT, 0x1234, NULL, 0));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
ASSERT(s_state == MG_PPPoE_ST_SESS);
ASSERT(s_id == mg_htons(0x4321));
ASSERT(s_lcpup == true);
}
{ // PPPoE session packet is accepted in session state
uint8_t payload[sizeof(struct ip)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_SESS;
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_sess(frame, 0x1234, MG_PPP_PROTO_IP, payload,
sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == true);
ASSERT(proto == MG_TCPIP_L2PROTO_IPV4);
ASSERT(pay.len == sizeof(payload));
ASSERT(memcmp(pay.buf, payload, sizeof(payload)) == 0);
}
{ // PPPoE session packet is discarded outside session state
uint8_t payload[sizeof(struct ip)];
memset(payload, 0, sizeof(payload));
init_if(&ifp, MG_TCPIP_L2_PPPoE);
s_state = MG_PPPoE_ST_REQ;
s_lcpup = true;
raw = mg_str_n((char *) frame,
mk_pppoe_sess(frame, 0x1234, MG_PPP_PROTO_IP, payload,
sizeof(payload)));
proto = MG_TCPIP_L2PROTO_ARP;
ASSERT(mg_l2_rx(&ifp, &proto, &pay, &raw) == false);
}
}
#define DASHBOARD(x) \
@@ -408,42 +386,25 @@ static void test_pppoe_session_discard(void) {
int main(void) {
s_error = false;
test_ppp_lcp_accept();
test_ppp_lcp_discard();
test_lcp();
DASHBOARD("lcp");
s_error = false;
test_ppp_ipcp_accept();
test_ppp_ipcp_reject();
test_ipcp();
DASHBOARD("ipcp");
#if MG_ENABLE_IPV6
s_error = false;
test_ppp_ipv6cp_accept();
test_ppp_ipv6cp_reject();
test_ipv6cp();
DASHBOARD("ipv6cp");
#endif
s_error = false;
test_ppp_ip_accept();
test_ppp_ip_discard();
#if MG_ENABLE_IPV6
test_ppp_ipv6_accept();
test_ppp_ipv6_discard();
#endif
test_ppp_unknown_reject();
test_ppp_unknown_discard();
test_ppp();
DASHBOARD("ppp");
s_error = false;
test_pppoe_pado_accept();
test_pppoe_pado_discard();
test_pppoe_pads_accept();
test_pppoe_pads_discard();
test_pppoe_padt_accept();
test_pppoe_padt_discard();
test_pppoe_session_accept();
test_pppoe_session_discard();
test_pppoe();
printf("HEALTH_DASHBOARD\t\"pppoe\": %s\n", s_error ? "false" : "true");
#ifdef NO_ABORT