void
test_HandleKodDemobilize(void)
{
static const char * HOSTNAME = "192.0.2.1";
static const char * REASON = "DENY";
struct pkt rpkt;
sockaddr_u host;
int rpktl;
struct kod_entry * entry;
rpktl = KOD_DEMOBILIZE;
ZERO(rpkt);
memcpy(&rpkt.refid, REASON, 4);
ZERO(host);
host.sa4.sin_family = AF_INET;
host.sa4.sin_addr.s_addr = inet_addr(HOSTNAME);
/* Test that the KOD-entry is added to the database. */
kod_init_kod_db("/dev/null", TRUE);
TEST_ASSERT_EQUAL(1, handle_pkt(rpktl, &rpkt, &host, HOSTNAME));
TEST_ASSERT_EQUAL(1, search_entry(HOSTNAME, &entry));
TEST_ASSERT_EQUAL_MEMORY(REASON, entry->type, 4);
}
TEST_F(kodFileTest, ReadCorrectFile) {
kod_init_kod_db(CreatePath("kod-test-correct", INPUT_DIR).c_str(), TRUE);
EXPECT_EQ(2, kod_db_cnt);
kod_entry* res;
ASSERT_EQ(1, search_entry("192.0.2.5", &res));
EXPECT_STREQ("DENY", res->type);
EXPECT_STREQ("192.0.2.5", res->hostname);
EXPECT_EQ(0x12345678, res->timestamp);
ASSERT_EQ(1, search_entry("192.0.2.100", &res));
EXPECT_STREQ("RSTR", res->type);
EXPECT_STREQ("192.0.2.100", res->hostname);
EXPECT_EQ(0xfff, res->timestamp);
}
void
test_ReadCorrectFile(void) {
kod_init_kod_db(CreatePath("kod-test-correct", INPUT_DIR), TRUE);
TEST_ASSERT_EQUAL(2, kod_db_cnt);
struct kod_entry* res;
TEST_ASSERT_EQUAL(1, search_entry("192.0.2.5", &res));
TEST_ASSERT_EQUAL_STRING("DENY", res->type);
TEST_ASSERT_EQUAL_STRING("192.0.2.5", res->hostname);
TEST_ASSERT_EQUAL(0x12345678, res->timestamp);
TEST_ASSERT_EQUAL(1, search_entry("192.0.2.100", &res));
TEST_ASSERT_EQUAL_STRING("RSTR", res->type);
TEST_ASSERT_EQUAL_STRING("192.0.2.100", res->hostname);
TEST_ASSERT_EQUAL(0xfff, res->timestamp);
}
TEST_F(kodFileTest, ReadFileWithBlankLines) {
kod_init_kod_db(CreatePath("kod-test-blanks", INPUT_DIR).c_str(), TRUE);
EXPECT_EQ(3, kod_db_cnt);
kod_entry* res;
ASSERT_EQ(1, search_entry("192.0.2.5", &res));
EXPECT_STREQ("DENY", res->type);
EXPECT_STREQ("192.0.2.5", res->hostname);
EXPECT_EQ(0x12345678, res->timestamp);
ASSERT_EQ(1, search_entry("192.0.2.100", &res));
EXPECT_STREQ("RSTR", res->type);
EXPECT_STREQ("192.0.2.100", res->hostname);
EXPECT_EQ(0xfff, res->timestamp);
ASSERT_EQ(1, search_entry("example.com", &res));
EXPECT_STREQ("DENY", res->type);
EXPECT_STREQ("example.com", res->hostname);
EXPECT_EQ(0xabcd, res->timestamp);
}
void
test_ReadFileWithBlankLines(void) {
kod_init_kod_db(CreatePath("kod-test-blanks", INPUT_DIR), TRUE);
TEST_ASSERT_EQUAL(3, kod_db_cnt);
struct kod_entry* res;
TEST_ASSERT_EQUAL(1, search_entry("192.0.2.5", &res));
TEST_ASSERT_EQUAL_STRING("DENY", res->type);
TEST_ASSERT_EQUAL_STRING("192.0.2.5", res->hostname);
TEST_ASSERT_EQUAL(0x12345678, res->timestamp);
TEST_ASSERT_EQUAL(1, search_entry("192.0.2.100", &res));
TEST_ASSERT_EQUAL_STRING("RSTR", res->type);
TEST_ASSERT_EQUAL_STRING("192.0.2.100", res->hostname);
TEST_ASSERT_EQUAL(0xfff, res->timestamp);
TEST_ASSERT_EQUAL(1, search_entry("example.com", &res));
TEST_ASSERT_EQUAL_STRING("DENY", res->type);
TEST_ASSERT_EQUAL_STRING("example.com", res->hostname);
TEST_ASSERT_EQUAL(0xabcd, res->timestamp);
}
TEST_F(mainTest, HandleKodDemobilize) {
const char * HOSTNAME = "192.0.2.1";
const char * REASON = "DENY";
pkt rpkt;
sockaddr_u host;
int rpktl;
kod_entry * entry;
rpktl = KOD_DEMOBILIZE;
ZERO(rpkt);
memcpy(&rpkt.refid, REASON, 4);
ZERO(host);
host.sa4.sin_family = AF_INET;
host.sa4.sin_addr.s_addr = inet_addr(HOSTNAME);
// Test that the KOD-entry is added to the database.
kod_init_kod_db("/dev/null", TRUE);
EXPECT_EQ(1, handle_pkt(rpktl, &rpkt, &host, HOSTNAME));
ASSERT_EQ(1, search_entry(HOSTNAME, &entry));
EXPECT_TRUE(memcmp(REASON, entry->type, 4) == 0);
}
void setUp(void)
{
kod_init_kod_db("/dev/null", TRUE);
}
/*
* The actual main function.
*/
int
sntp_main (
int argc,
char **argv
)
{
register int c;
struct kod_entry *reason = NULL;
int optct;
/* boolean, u_int quiets gcc4 signed overflow warning */
u_int sync_data_suc;
struct addrinfo **bcastaddr = NULL;
struct addrinfo **resh = NULL;
struct addrinfo *ai;
int resc;
int kodc;
int ow_ret;
int bcast = 0;
char *hostname;
optct = optionProcess(&sntpOptions, argc, argv);
argc -= optct;
argv += optct;
/* Initialize logging system */
init_logging();
if (HAVE_OPT(LOGFILE))
open_logfile(OPT_ARG(LOGFILE));
msyslog(LOG_NOTICE, "Started sntp");
/* IPv6 available? */
if (isc_net_probeipv6() != ISC_R_SUCCESS) {
ai_fam_pref = AF_INET;
#ifdef DEBUG
printf("No ipv6 support available, forcing ipv4\n");
#endif
} else {
/* Check for options -4 and -6 */
if (HAVE_OPT(IPV4))
ai_fam_pref = AF_INET;
else if (HAVE_OPT(IPV6))
ai_fam_pref = AF_INET6;
}
/* Parse config file if declared TODO */
/*
* If there's a specified KOD file init KOD system. If not use
* default file. For embedded systems with no writable
* filesystem, -K /dev/null can be used to disable KoD storage.
*/
if (HAVE_OPT(KOD))
kod_init_kod_db(OPT_ARG(KOD));
else
kod_init_kod_db("/var/db/ntp-kod");
if (HAVE_OPT(KEYFILE))
auth_init(OPT_ARG(KEYFILE), &keys);
#ifdef EXERCISE_KOD_DB
add_entry("192.168.169.170", "DENY");
add_entry("192.168.169.171", "DENY");
add_entry("192.168.169.172", "DENY");
add_entry("192.168.169.173", "DENY");
add_entry("192.168.169.174", "DENY");
delete_entry("192.168.169.174", "DENY");
delete_entry("192.168.169.172", "DENY");
delete_entry("192.168.169.170", "DENY");
if ((kodc = search_entry("192.168.169.173", &reason)) == 0)
printf("entry for 192.168.169.173 not found but should have been!\n");
else
free(reason);
#endif
/* Considering employing a variable that prevents functions of doing anything until
* everything is initialized properly
*/
resc = resolve_hosts((void *)argv, argc, &resh, ai_fam_pref);
if (resc < 1) {
printf("Unable to resolve hostname(s)\n");
return -1;
}
bcast = ENABLED_OPT(BROADCAST);
if (bcast) {
const char * myargv[2];
myargv[0] = OPT_ARG(BROADCAST);
myargv[1] = NULL;
bcast = resolve_hosts(myargv, 1, &bcastaddr, ai_fam_pref);
}
/* Select a certain ntp server according to simple criteria? For now
* let's just pay attention to previous KoDs.
*/
sync_data_suc = FALSE;
for (c = 0; c < resc && !sync_data_suc; c++) {
ai = resh[c];
do {
hostname = addrinfo_to_str(ai);
if ((kodc = search_entry(hostname, &reason)) == 0) {
if (is_reachable(ai)) {
ow_ret = on_wire(ai, bcast ? bcastaddr[0] : NULL);
if (0 == ow_ret)
sync_data_suc = TRUE;
}
} else {
printf("%d prior KoD%s for %s, skipping.\n",
kodc, (kodc > 1) ? "s" : "", hostname);
free(reason);
}
free(hostname);
ai = ai->ai_next;
} while (NULL != ai);
freeaddrinfo(resh[c]);
}
free(resh);
if (!sync_data_suc)
return 1;
return 0;
}
TEST_F(kodFileTest, ReadEmptyFile) {
kod_init_kod_db(CreatePath("kod-test-empty", INPUT_DIR).c_str(), TRUE);
EXPECT_EQ(0, kod_db_cnt);
}
/*
* The actual main function.
*/
int
sntp_main (
int argc,
char **argv,
const char *sntpVersion
)
{
int i;
int exitcode;
int optct;
struct event_config * evcfg;
/* Initialize logging system - sets up progname */
sntp_init_logging(argv[0]);
if (!libevent_version_ok())
exit(EX_SOFTWARE);
init_lib();
init_auth();
optct = ntpOptionProcess(&sntpOptions, argc, argv);
argc -= optct;
argv += optct;
debug = OPT_VALUE_SET_DEBUG_LEVEL;
TRACE(2, ("init_lib() done, %s%s\n",
(ipv4_works)
? "ipv4_works "
: "",
(ipv6_works)
? "ipv6_works "
: ""));
ntpver = OPT_VALUE_NTPVERSION;
steplimit = OPT_VALUE_STEPLIMIT / 1e3;
gap.tv_usec = max(0, OPT_VALUE_GAP * 1000);
gap.tv_usec = min(gap.tv_usec, 999999);
if (HAVE_OPT(LOGFILE))
open_logfile(OPT_ARG(LOGFILE));
msyslog(LOG_INFO, "%s", sntpVersion);
if (0 == argc && !HAVE_OPT(BROADCAST) && !HAVE_OPT(CONCURRENT)) {
printf("%s: Must supply at least one of -b hostname, -c hostname, or hostname.\n",
progname);
exit(EX_USAGE);
}
/*
** Eventually, we probably want:
** - separate bcst and ucst timeouts (why?)
** - multiple --timeout values in the commandline
*/
response_timeout = OPT_VALUE_TIMEOUT;
response_tv.tv_sec = response_timeout;
response_tv.tv_usec = 0;
/* IPv6 available? */
if (isc_net_probeipv6() != ISC_R_SUCCESS) {
ai_fam_pref = AF_INET;
TRACE(1, ("No ipv6 support available, forcing ipv4\n"));
} else {
/* Check for options -4 and -6 */
if (HAVE_OPT(IPV4))
ai_fam_pref = AF_INET;
else if (HAVE_OPT(IPV6))
ai_fam_pref = AF_INET6;
}
/* TODO: Parse config file if declared */
/*
** Init the KOD system.
** For embedded systems with no writable filesystem,
** -K /dev/null can be used to disable KoD storage.
*/
kod_init_kod_db(OPT_ARG(KOD), FALSE);
// HMS: Should we use arg-defalt for this too?
if (HAVE_OPT(KEYFILE))
auth_init(OPT_ARG(KEYFILE), &keys);
/*
** Considering employing a variable that prevents functions of doing
** anything until everything is initialized properly
**
** HMS: What exactly does the above mean?
*/
event_set_log_callback(&sntp_libevent_log_cb);
if (debug > 0)
event_enable_debug_mode();
#ifdef WORK_THREAD
evthread_use_pthreads();
/* we use libevent from main thread only, locks should be academic */
if (debug > 0)
evthread_enable_lock_debuging();
#endif
evcfg = event_config_new();
if (NULL == evcfg) {
printf("%s: event_config_new() failed!\n", progname);
return -1;
}
#ifndef HAVE_SOCKETPAIR
event_config_require_features(evcfg, EV_FEATURE_FDS);
#endif
/* all libevent calls are from main thread */
/* event_config_set_flag(evcfg, EVENT_BASE_FLAG_NOLOCK); */
base = event_base_new_with_config(evcfg);
event_config_free(evcfg);
if (NULL == base) {
printf("%s: event_base_new() failed!\n", progname);
return -1;
}
/* wire into intres resolver */
worker_per_query = TRUE;
addremove_io_fd = &sntp_addremove_fd;
open_sockets();
if (HAVE_OPT(BROADCAST)) {
int cn = STACKCT_OPT( BROADCAST );
const char ** cp = STACKLST_OPT( BROADCAST );
while (cn-- > 0) {
handle_lookup(*cp, CTX_BCST);
cp++;
}
}
if (HAVE_OPT(CONCURRENT)) {
int cn = STACKCT_OPT( CONCURRENT );
const char ** cp = STACKLST_OPT( CONCURRENT );
while (cn-- > 0) {
handle_lookup(*cp, CTX_UCST | CTX_CONC);
cp++;
}
}
for (i = 0; i < argc; ++i)
handle_lookup(argv[i], CTX_UCST);
gettimeofday_cached(base, &start_tv);
event_base_dispatch(base);
event_base_free(base);
if (!time_adjusted &&
(ENABLED_OPT(STEP) || ENABLED_OPT(SLEW)))
exitcode = 1;
else
exitcode = 0;
return exitcode;
}
void
test_ReadEmptyFile(void) {
kod_init_kod_db(CreatePath("kod-test-empty", INPUT_DIR), TRUE);
TEST_ASSERT_EQUAL(0, kod_db_cnt);
}
