tests/netgraph: Inital framework for testing libnetgraph

Provide a framework of functions to test various netgraph modules.
Tests contain:
 - creating, renaming, and destroying nodes
 - connecting and removing hooks
 - sending and receiving data
 - sending ASCII messages
 - errors can be passed for indiviual inspection or fail the test

Reviewed by:	kp
MFC after:	1 week
Differential Revision: https://reviews.freebsd.org/D30629
This commit is contained in:
Lutz Donnerhacke 2021-06-03 00:29:46 +02:00
parent c8250c5ada
commit 24ea1dbf25
4 changed files with 486 additions and 1 deletions

View File

@ -10,6 +10,10 @@ TAP_TESTS_SH+= ng_macfilter_test
TEST_METADATA.ng_macfilter_test+= required_user="root"
TEST_METADATA.ng_macfilter_test+= required_programs="perl"
MAN=
ATF_TESTS_C+= basic \
SRCS.basic= basic.c util.c
LIBADD+= netgraph
.include <bsd.test.mk>

191
tests/sys/netgraph/basic.c Normal file
View File

@ -0,0 +1,191 @@
/*
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright 2021 Lutz Donnerhacke
*
* 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 copyright holder 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#include <atf-c.h>
#include <errno.h>
#include <stdio.h>
#include "util.h"
static void get_data(void *data, size_t len, void *ctx);
ATF_TC(send_recv);
ATF_TC_HEAD(send_recv, conf)
{
atf_tc_set_md_var(conf, "require.user", "root");
}
ATF_TC_BODY(send_recv, dummy)
{
char msg[] = "test";
int received;
ng_init();
ng_connect(".", "a", ".", "b");
ng_register_data("b", get_data);
ng_send_data("a", msg, sizeof(msg));
received = 0;
ng_handle_events(50, &received);
ATF_CHECK(received == 1);
}
ATF_TC(node);
ATF_TC_HEAD(node, conf)
{
atf_tc_set_md_var(conf, "require.user", "root");
}
ATF_TC_BODY(node, dummy)
{
char msg[] = "test";
int received;
ng_init();
ng_mkpeer(".", "a", "hub", "a");
ng_name("a", "test hub");
ng_connect(".", "b", "test hub:", "b");
ng_connect(".", "c", "test hub:", "c");
ng_register_data("a", get_data);
ng_register_data("b", get_data);
ng_register_data("c", get_data);
received = 0;
ng_send_data("a", msg, sizeof(msg));
ng_handle_events(50, &received);
ATF_CHECK(received == 2);
ng_rmhook(".", "b");
received = 0;
ng_send_data("a", msg, sizeof(msg));
ng_handle_events(50, &received);
ATF_CHECK(received == 1);
ng_shutdown("test hub:");
}
ATF_TC(message);
ATF_TC_HEAD(message, conf)
{
atf_tc_set_md_var(conf, "require.user", "root");
}
ATF_TC_BODY(message, dummy)
{
ng_init();
ng_mkpeer(".", "a", "hub", "a");
ng_name("a", "test hub");
ng_send_msg("test hub:", "setpersistent");
ng_rmhook(".", "a");
ng_shutdown("test hub:");
}
ATF_TC(same_name);
ATF_TC_HEAD(same_name, conf)
{
atf_tc_set_md_var(conf, "require.user", "root");
}
ATF_TC_BODY(same_name, dummy)
{
ng_init();
ng_mkpeer(".", "a", "hub", "a");
ng_name("a", "test");
ng_errors(PASS);
ng_connect(".", "a", ".", "b");
ATF_CHECK_ERRNO(EEXIST, 1);
ng_connect(".", "b", ".", "b");
ATF_CHECK_ERRNO(EEXIST, 1);
ng_name(".", "test");
ATF_CHECK_ERRNO(EADDRINUSE, 1);
ng_errors(FAIL);
ng_shutdown("test:");
}
ATF_TC(queuelimit);
ATF_TC_HEAD(queuelimit, conf)
{
atf_tc_set_md_var(conf, "require.user", "root");
}
ATF_TC_BODY(queuelimit, dummy)
{
int received, i;
char msg[] = "test";
const int MAX = 1000;
ng_init();
ng_connect(".", "a", ".", "b");
ng_register_data("b", get_data);
ng_errors(PASS);
for (i = 0; i < MAX; i++) {
ng_send_data("a", msg, sizeof(msg));
if (errno != 0)
break;
/* no ng_handle_events -> messages stall */
}
ng_errors(FAIL);
printf("queued %d\n", i);
sleep(3);
received = 0;
ng_handle_events(50, &received);
ATF_CHECK(received > 100);
ATF_CHECK(received == i);
atf_tc_expect_fail("Queue full (%d)", i);
ATF_CHECK(received == MAX);
atf_tc_expect_pass();
}
ATF_TP_ADD_TCS(basic)
{
ATF_TP_ADD_TC(basic, send_recv);
ATF_TP_ADD_TC(basic, node);
ATF_TP_ADD_TC(basic, message);
ATF_TP_ADD_TC(basic, same_name);
ATF_TP_ADD_TC(basic, queuelimit);
return atf_no_error();
}
static void
get_data(void *data, size_t len, void *ctx)
{
int *cnt = ctx;
(void)data;
printf("Got %zu bytes of data.\n", len);
(*cnt)++;
}

233
tests/sys/netgraph/util.c Normal file
View File

@ -0,0 +1,233 @@
/*
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright 2021 Lutz Donnerhacke
*
* 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 copyright holder 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#include <atf-c.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <sys/queue.h>
#include "util.h"
static int cs = -1, ds = -1;
static ng_error_t error_handling = FAIL;
#define CHECK(r, x) do { \
if (error_handling == FAIL) \
ATF_REQUIRE(x); \
else if(!(x)) \
return r; \
} while(0)
struct data_handler {
char const *hook;
ng_data_handler_t handler;
SLIST_ENTRY(data_handler) next;
};
static SLIST_HEAD(, data_handler) data_head = SLIST_HEAD_INITIALIZER(data_head);
static void handle_data(void *ctx);
static void handle_msg(void);
void
ng_connect(char const *path1, char const *hook1,
char const *path2, char const *hook2)
{
struct ngm_connect c;
strncpy(c.ourhook, hook1, sizeof(c.ourhook));
strncpy(c.peerhook, hook2, sizeof(c.peerhook));
strncpy(c.path, path2, sizeof(c.path));
CHECK(, -1 != NgSendMsg(cs, path1,
NGM_GENERIC_COOKIE, NGM_CONNECT,
&c, sizeof(c)));
}
void
ng_mkpeer(char const *path1, char const *hook1,
char const *type, char const *hook2)
{
struct ngm_mkpeer p;
strncpy(p.ourhook, hook1, sizeof(p.ourhook));
strncpy(p.peerhook, hook2, sizeof(p.peerhook));
strncpy(p.type, type, sizeof(p.type));
CHECK(, -1 != NgSendMsg(cs, path1,
NGM_GENERIC_COOKIE, NGM_MKPEER,
&p, sizeof(p)));
}
void
ng_rmhook(char const *path, char const *hook)
{
struct ngm_rmhook h;
strncpy(h.ourhook, hook, sizeof(h.ourhook));
CHECK(, -1 != NgSendMsg(cs, path,
NGM_GENERIC_COOKIE, NGM_RMHOOK,
&h, sizeof(h)));
}
void
ng_name(char const *path, char const *name)
{
struct ngm_name n;
strncpy(n.name, name, sizeof(n.name));
CHECK(, -1 != NgSendMsg(cs, path,
NGM_GENERIC_COOKIE, NGM_NAME,
&n, sizeof(n)));
}
void
ng_shutdown(char const *path)
{
CHECK(, -1 != NgSendMsg(cs, path,
NGM_GENERIC_COOKIE, NGM_SHUTDOWN,
NULL, 0));
}
void
ng_register_data(char const *hook, ng_data_handler_t proc)
{
struct data_handler *p;
ATF_REQUIRE(NULL != (p = calloc(1, sizeof(struct data_handler))));
ATF_REQUIRE(NULL != (p->hook = strdup(hook)));
ATF_REQUIRE(NULL != (p->handler = proc));
SLIST_INSERT_HEAD(&data_head, p, next);
}
void
ng_send_data(char const *hook,
void const *data, size_t len)
{
CHECK(, -1 != NgSendData(ds, hook, data, len));
}
static void
handle_msg(void) {
struct ng_mesg *m;
char path[NG_PATHSIZ];
ATF_REQUIRE(-1 != NgAllocRecvMsg(cs, &m, path));
printf("Got message from %s\n", path);
free(m);
}
static void
handle_data(void *ctx) {
char hook[NG_HOOKSIZ];
struct data_handler *hnd;
u_char *data;
int len;
ATF_REQUIRE(0 < (len = NgAllocRecvData(ds, &data, hook)));
SLIST_FOREACH(hnd, &data_head, next)
if (0 == strcmp(hnd->hook, hook))
break;
if (hnd != NULL)
(*(hnd->handler))(data, len, ctx);
free(data);
}
int
ng_handle_event(unsigned int ms, void *context)
{
fd_set fds;
int maxfd = (ds < cs) ? cs : ds;
struct timeval timeout = { 0, ms * 1000lu };
FD_ZERO(&fds);
FD_SET(cs, &fds);
FD_SET(ds, &fds);
retry:
switch (select(maxfd+1, &fds, NULL, NULL, &timeout)) {
case -1:
ATF_REQUIRE_ERRNO(EINTR, 1);
goto retry;
case 0: /* timeout */
return 0;
default: /* something to do */
if (FD_ISSET(cs, &fds))
handle_msg();
if (FD_ISSET(ds, &fds))
handle_data(context);
return 1;
}
}
void
ng_handle_events(unsigned int ms, void *context)
{
while(ng_handle_event(ms, context))
;
}
int
ng_send_msg(char const *path, char const *msg)
{
int res;
CHECK(-1, -1 != (res = NgSendAsciiMsg(cs, path, "%s", msg)));
return (res);
}
ng_error_t
ng_errors(ng_error_t n)
{
ng_error_t o = error_handling;
error_handling = n;
return (o);
}
void
ng_init(void) {
if (cs >= 0) /* prevent reinit */
return;
ATF_REQUIRE(0 == NgMkSockNode(NULL, &cs, &ds));
NgSetDebug(3);
}

57
tests/sys/netgraph/util.h Normal file
View File

@ -0,0 +1,57 @@
/*
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright 2021 Lutz Donnerhacke
*
* 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 copyright holder 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#include <netgraph.h>
void ng_connect (char const *path1, char const *hook1,
char const *path2, char const *hook2);
void ng_mkpeer (char const *path1, char const *hook1,
char const *type, char const *hook2);
void ng_shutdown(char const *path);
void ng_rmhook (char const *path, char const *hook);
void ng_name (char const *path, char const *name);
typedef void (*ng_data_handler_t)(void *, size_t, void *ctx);
void ng_register_data(char const *hook, ng_data_handler_t proc);
void ng_send_data(char const *hook, void const *, size_t);
int ng_send_msg(char const *path, char const *msg);
int ng_handle_event (unsigned int ms, void *ctx);
void ng_handle_events(unsigned int ms, void *ctx);
typedef enum { FAIL, PASS } ng_error_t;
ng_error_t ng_errors(ng_error_t);
void ng_init(void);