static void
tx_sde(isc_task_t *task, isc_event_t *event) {
isc_result_t isc_result;
UNUSED(task);
UNUSED(event);
/*
* Signal shutdown processing complete.
*/
isc_result = isc_mutex_lock(&Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
isc_result = isc_condition_signal(&Tx_cv);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_signal failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
isc_result = isc_mutex_unlock(&Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
isc_event_free(&event);
}
static void
t5_start_event(isc_task_t *task, isc_event_t *event) {
isc_result_t isc_result;
UNUSED(task);
t_info("t5_start_event\n");
isc_result = isc_mutex_lock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
while (! T5_startflag) {
(void) isc_condition_wait(&T5_cv, &T5_mx);
}
isc_result = isc_mutex_unlock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
isc_event_free(&event);
}
static void
test_dns_resolver_settimeout_to_default(void) {
dns_resolver_t *resolver = NULL;
int test_result;
unsigned int default_timeout, timeout;
t_assert("test_dns_resolver_settimeout_to_default", 1, T_REQUIRED, "%s",
"_settimeout() can change the timeout back to a default value"
" by specifying 0 as the timeout.");
setup();
CHECK(make_resolver(&resolver));
default_timeout = dns_resolver_gettimeout(resolver);
t_info("The default timeout is %d second%s\n", default_timeout,
(default_timeout == 1 ? "" : "s"));
dns_resolver_settimeout(resolver, default_timeout - 1);
timeout = dns_resolver_gettimeout(resolver);
t_info("The new timeout is %d second%s\n", timeout,
(timeout == 1 ? "" : "s"));
dns_resolver_settimeout(resolver, 0);
timeout = dns_resolver_gettimeout(resolver);
test_result = (timeout == default_timeout) ? T_PASS : T_FAIL;
destroy_resolver(&resolver);
teardown();
t_result(test_result);
}
static void
t5_tick_event(isc_task_t *task, isc_event_t *event) {
isc_result_t isc_result;
isc_time_t expires;
isc_interval_t interval;
UNUSED(task);
++T5_eventcnt;
t_info("t5_tick_event %d\n", T5_eventcnt);
/*
* On the first tick, purge all remaining tick events
* and then shut down the task.
*/
if (T5_eventcnt == 1) {
isc_time_settoepoch(&expires);
isc_interval_set(&interval, T5_SECONDS, 0);
isc_result = isc_timer_reset(T5_tickertimer,
isc_timertype_ticker, &expires,
&interval, ISC_TRUE);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_timer_reset failed %s\n",
isc_result_totext(isc_result));
++T5_nfails;
}
isc_task_shutdown(task);
}
isc_event_free(&event);
}
/*
* Adapted from the original rbt_test.c.
*/
static int
t1_add(char *name, dns_rbt_t *rbt, isc_mem_t *mctx, isc_result_t *dns_result) {
int nprobs;
dns_name_t *dns_name;
nprobs = 0;
if (name && dns_result) {
if (create_name(name, mctx, &dns_name) == 0) {
if (T_debug)
t_info("dns_rbt_addname succeeded\n");
*dns_result = dns_rbt_addname(rbt, dns_name, dns_name);
if (*dns_result != ISC_R_SUCCESS) {
delete_name(dns_name, mctx);
t_info("dns_rbt_addname failed %s\n",
dns_result_totext(*dns_result));
++nprobs;
}
} else {
++nprobs;
}
} else {
++nprobs;
}
return(nprobs);
}
//data should be allocated
bool Tdcmtk::getPixelsToFlt(float* data)
{
if (!m_dataSet)
{
t_info("fails to open the file");
return false;
}
if (m_nBits == 16 && m_bSined)
{
const Sint16 *v = 0;
getPixels_SInt16(v);
for (int i = 0, s = m_W * m_H; i < s; ++i) data[i] = v[i];
delete[] v;
}
else if (m_nBits == 16 && !m_bSined)
{
const Uint16 *v = 0;
getPixels_UInt16(v);
for (int i = 0, s = m_W * m_H; i < s; ++i) data[i] = v[i];
delete[] v;
}
else
{
t_info("this file type is not implemeted yet\n");
return false;
}
return true;
}
static int
t_namechk(isc_result_t dns_result, dns_fixedname_t *dns_name, char *exp_name,
dns_fixedname_t *dns_origin, char *exp_origin,
isc_result_t exp_result)
{
int nfails;
nfails = 0;
if (fixedname_cmp(dns_name, exp_name)) {
t_info("\texpected name of %s, got %s\n",
exp_name, fixedname_totext(dns_name));
++nfails;
}
if (exp_origin != NULL) {
t_info("checking for DNS_R_NEWORIGIN\n");
if (dns_result == exp_result) {
if (fixedname_cmp(dns_origin, exp_origin)) {
t_info("\torigin %s, expected %s\n",
fixedname_totext(dns_origin),
exp_origin);
++nfails;
}
} else {
t_info("\tgot %s\n", dns_result_totext(dns_result));
++nfails;
}
}
return(nfails);
}
/*
* Compare binary digest or HMAC to string of hex digits from an RFC
*/
static void
ck(const char *name, const IN_ *in, const OUT_ *out)
{
char buf[sizeof(dbuf)*2+1];
const char *str_name;
unsigned int l;
d2str(buf, sizeof(buf), dbuf.b, out->digest_len);
str_name = in->name != NULL ? in->name : (const char *)in->str;
if (T_debug != 0)
t_info("%s(%s) = %s\n", name, str_name, buf);
if (strcasecmp(buf, out->str)) {
t_info("%s(%s)\n%9s %s\n%9s %s\n",
name, str_name,
"is", buf,
"should be", out->str);
++nprobs;
return;
}
/*
* check that the hash or HMAC is no longer than we think it is
*/
for (l = out->digest_len; l < sizeof(dbuf); ++l) {
if (dbuf.b[l] != DIGEST_FILL) {
t_info("byte #%d after end of %s(%s) changed to %02x\n",
l-out->digest_len, name, str_name, dbuf.b[l]);
++nprobs;
break;
}
}
}
static int
create_name(char *s, isc_mem_t *mctx, dns_name_t **dns_name) {
int nfails;
int length;
isc_result_t result;
isc_buffer_t source;
isc_buffer_t target;
dns_name_t *name;
nfails = 0;
if (s && *s) {
length = strlen(s);
isc_buffer_init(&source, s, length);
isc_buffer_add(&source, length);
/*
* The buffer for the actual name will immediately follow the
* name structure.
*/
name = isc_mem_get(mctx, sizeof(*name) + DNSNAMELEN);
if (name == NULL) {
t_info("isc_mem_get failed\n");
++nfails;
} else {
dns_name_init(name, NULL);
isc_buffer_init(&target, name + 1, DNSNAMELEN);
result = dns_name_fromtext(name, &source, dns_rootname,
0, &target);
if (result != ISC_R_SUCCESS) {
++nfails;
t_info("dns_name_fromtext(%s) failed %s\n",
s, dns_result_totext(result));
isc_mem_put(mctx, name,
sizeof(*name) + DNSNAMELEN);
} else
*dns_name = name;
}
} else {
++nfails;
t_info("create_name: empty name\n");
}
return(nfails);
}
/*
* Initialize a database from filename.
*/
static int
rbt_init(char *filename, dns_rbt_t **rbt, isc_mem_t *mctx) {
int rval;
isc_result_t dns_result;
char *p;
FILE *fp;
fp = fopen(filename, "r");
if (fp == NULL) {
t_info("No such file %s\n", filename);
return(1);
}
dns_result = dns_rbt_create(mctx, delete_name, mctx, rbt);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_rbt_create failed %s\n",
dns_result_totext(dns_result));
fclose(fp);
return(1);
}
while ((p = t_fgetbs(fp)) != NULL) {
/*
* Skip any comment lines.
*/
if ((*p == '#') || (*p == '\0') || (*p == ' ')) {
(void)free(p);
continue;
}
if (T_debug)
t_info("adding name %s to the rbt\n", p);
rval = t1_add(p, *rbt, mctx, &dns_result);
if ((rval != 0) || (dns_result != ISC_R_SUCCESS)) {
t_info("add of %s failed\n", p);
dns_rbt_destroy(rbt);
fclose(fp);
return(1);
}
(void) free(p);
}
fclose(fp);
return(0);
}
static int
test_master_x(const char *filename) {
FILE *fp;
char *p;
int line;
int cnt;
int result;
result = T_UNRESOLVED;
fp = fopen(filename, "r");
if (fp != NULL) {
line = 0;
while ((p = t_fgetbs(fp)) != NULL) {
++line;
/*
* Skip comment lines.
*/
if ((isspace(*p & 0xff)) || (*p == '#')) {
(void)free(p);
continue;
}
/*
* Name of data file, origin, zclass, expected result.
*/
cnt = t_bustline(p, Tokens);
if (cnt == 4) {
result = test_master(Tokens[0], Tokens[1],
Tokens[2],
t_dns_result_fromtext(Tokens[3]));
} else {
t_info("bad format in %s at line %d\n",
filename, line);
}
(void)free(p);
}
(void)fclose(fp);
} else {
t_info("Missing datafile %s\n", filename);
}
return(result);
}
bool Tdcmtk::getPixels_UInt16(const Uint16* &data)
{
if (!m_dataSet)
{
t_info("fails to open the file");
return false;
}
if (m_nBits != 16 || m_bSined) {
t_info("wrong format\n");
return false;
}
// Load pixel data into memory
unsigned long psize = 0;
if (m_dataSet->findAndGetUint16Array(DCM_PixelData, (const Uint16*&)data, &psize, false).bad()) return false;
//if ( m_dataSet->findAndGetSint16Array( DCM_PixelData, data, &psize,false ).bad() ) return false;
return true;
}
static void
t5_once_event(isc_task_t *task, isc_event_t *event) {
isc_result_t isc_result;
t_info("t5_once_event\n");
/*
* Allow task1 to start processing events.
*/
isc_result = isc_mutex_lock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
T5_startflag = 1;
isc_result = isc_condition_broadcast(&T5_cv);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_broadcast failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
isc_result = isc_mutex_unlock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
isc_event_free(&event);
isc_task_shutdown(task);
}
static isc_result_t
print_data(void *data) {
isc_result_t dns_result;
isc_buffer_t target;
char *buffer[DNSNAMELEN];
isc_buffer_init(&target, buffer, sizeof(buffer));
dns_result = dns_name_totext(data, ISC_FALSE, &target);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_name_totext failed %s\n",
dns_result_totext(dns_result));
}
return(dns_result);
}
static isc_result_t
t1_add_callback(void *arg, dns_name_t *owner, dns_rdataset_t *dataset) {
char buf[BIGBUFLEN];
isc_buffer_t target;
isc_result_t result;
UNUSED(arg);
isc_buffer_init(&target, buf, BIGBUFLEN);
result = dns_rdataset_totext(dataset, owner, ISC_FALSE, ISC_FALSE,
&target);
if (result != ISC_R_SUCCESS)
t_info("dns_rdataset_totext: %s\n", dns_result_totext(result));
return(result);
}
Tdcmtk::Tdcmtk( const char *fname )
{
m_FileFormat = new DcmFileFormat;
OFCondition status = m_FileFormat->loadFile(fname);
if ( status.bad() )
{
t_info( "cannot open the file!!!");
if ( m_FileFormat )
{
delete m_FileFormat;
m_FileFormat = 0;
}
return;
}
m_dataSet = m_FileFormat->getDataset();
m_W = m_H = m_fNum = 0;
m_nBits = m_bSined = m_bChNum = m_bChArrange = 0;
//size
t_getTagValInt(m_dataSet, DCM_Columns , m_W );
t_getTagValInt(m_dataSet, DCM_Rows , m_H );
t_getTagValInt(m_dataSet, DCM_NumberOfFrames , m_fNum );
//pixel configureation
int bs, ba, hb, spp, plc, pr;
t_getTagValInt(m_dataSet, DCM_BitsStored , bs ); // bits for 1 pixel (actually used)
t_getTagValInt(m_dataSet, DCM_BitsAllocated , ba ); // bits for 1 pixel (allocated)
t_getTagValInt(m_dataSet, DCM_HighBit , hb );
t_getTagValInt(m_dataSet, DCM_SamplesPerPixel , spp ); // 1:gray, 3:rgb
t_getTagValInt(m_dataSet, DCM_PlanarConfiguration, plc );
t_getTagValInt(m_dataSet, DCM_PixelRepresentation, pr ); //unsigned (0) or signed (1)
m_nBits = ba ;
m_bSined = pr ;
m_bChNum = spp;
m_bChArrange = plc;
t_getPitchInfo( m_FileFormat, m_pitch, m_pos );
}
static void
test_dns_resolver_gettimeout(void) {
dns_resolver_t *resolver = NULL;
int test_result;
unsigned int timeout;
t_assert("test_dns_resolver_gettimeout", 1, T_REQUIRED, "%s",
"The default timeout is returned from _gettimeout()");
setup();
CHECK(make_resolver(&resolver));
timeout = dns_resolver_gettimeout(resolver);
t_info("The default timeout is %d second%s\n", timeout, (timeout == 1 ? "" : "s"));
test_result = (timeout > 0) ? T_PASS : T_FAIL;
destroy_resolver(&resolver);
teardown();
t_result(test_result);
}
static void
t3(void) {
int result;
int isc_result;
isc_time_t expires;
isc_interval_t interval;
t_assert("isc_timer_create", 3, T_REQUIRED, "%s", a3);
if (threaded) {
Tx_nfails = 0;
Tx_nprobs = 0;
Tx_nevents = 1;
Tx_seconds = T3_SECONDS;
Tx_nanoseconds = T3_NANOSECONDS;
isc_interval_set(&interval, Tx_seconds + 1, Tx_nanoseconds);
isc_result = isc_time_nowplusinterval(&expires, &interval);
if (isc_result == ISC_R_SUCCESS) {
isc_interval_set(&interval, Tx_seconds,
Tx_nanoseconds);
t_timers_x(isc_timertype_once, &expires, &interval,
t3_te);
} else {
t_info("isc_time_nowplusinterval failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
result = T_UNRESOLVED;
if ((Tx_nfails == 0) && (Tx_nprobs == 0))
result = T_PASS;
else if (Tx_nfails)
result = T_FAIL;
t_result(result);
} else
require_threads();
}
static void
test_dns_resolver_settimeout_over_maximum(void) {
dns_resolver_t *resolver = NULL;
int test_result;
unsigned int timeout;
t_assert("test_dns_resolver_settimeout_over_maximum", 1, T_REQUIRED, "%s",
"_settimeout() cannot set the value larger than the maximum.");
setup();
CHECK(make_resolver(&resolver));
dns_resolver_settimeout(resolver, 4000000);
timeout = dns_resolver_gettimeout(resolver);
t_info("The new timeout is %d second%s\n", timeout,
(timeout == 1 ? "" : "s"));
test_result = (timeout < 4000000 && timeout > 0) ? T_PASS : T_FAIL;
destroy_resolver(&resolver);
teardown();
t_result(test_result);
}
bool t_getTagValInt(DcmDataset *DataSet, DcmTagKey tagKey, int &value)
{
DcmElement *elem = NULL;
DcmTag tag(tagKey);
if ( DataSet->findAndGetElement(tag, elem).bad() || elem->getLength() == 0) return false;
Sint16 rvS16;
Sint32 rvS32;
Uint8 rvU8 ;
Uint16 rvU16;
Uint32 rvU32;
if ( elem->getSint16( rvS16 ).good() ) { value = (int)rvS16; }
else if ( elem->getSint32( rvS32 ).good() ) { value = (int)rvS32; }
else if ( elem->getUint8 ( rvU8 ).good() ) { value = (int)rvU8 ; }
else if ( elem->getUint16( rvU16 ).good() ) { value = (int)rvU16; }
else if ( elem->getUint32( rvU32 ).good() ) { value = (int)rvU32; }
else {
t_info("%s is not integer value", tag.getTagName());
return false;
}
return true;
}
static void
test_atomic_xaddq() {
int test_result;
isc_task_t *tasks[TASKS];
isc_event_t *event;
int i;
t_assert("test_atomic_xaddq", 1, T_REQUIRED, "%s",
"ensure that isc_atomic_xaddq() works.");
setup();
memset(counters, 0, sizeof(counters));
counter_64 = 0;
/*
* Create our tasks, and allocate an event to get the counters going.
*/
for (i = 0 ; i < TASKS ; i++) {
tasks[i] = NULL;
CHECK(isc_task_create(task_manager, 0, &tasks[i]));
event = isc_event_allocate(mctx, NULL, 1000, do_xaddq,
&counters[i], sizeof(struct isc_event));
isc_task_sendanddetach(&tasks[i], &event);
}
teardown();
test_result = T_PASS;
t_info("64-bit counter %"ISC_PRINT_QUADFORMAT"d, expected %"ISC_PRINT_QUADFORMAT"d\n",
counter_64, EXPECTED_COUNT_64);
if (counter_64 != EXPECTED_COUNT_64)
test_result = T_FAIL;
t_result(test_result);
counter_64 = 0;
}
static int
test_dns_rbtnodechain_init(const char *filename) {
FILE *fp;
char *p;
int line;
int cnt;
int result;
int nfails;
int nprobs;
nfails = 0;
nprobs = 0;
fp = fopen(filename, "r");
if (fp != NULL) {
line = 0;
while ((p = t_fgetbs(fp)) != NULL) {
++line;
/*
* Skip comment lines.
*/
if ((isspace((unsigned char)*p)) || (*p == '#')) {
(void)free(p);
continue;
}
cnt = t_bustline(p, Tokens);
if (cnt == 10) {
result = t_dns_rbtnodechain_init(
Tokens[0], /* dbfile */
Tokens[1], /* startname */
Tokens[2], /* nextname */
Tokens[3], /* nextorigin */
Tokens[4], /* prevname */
Tokens[5], /* prevorigin */
Tokens[6], /* firstname */
Tokens[7], /* firstorigin */
Tokens[8], /* lastname */
Tokens[9]); /* lastorigin */
if (result != T_PASS) {
if (result == T_FAIL)
++nfails;
else
++nprobs;
}
} else {
t_info("bad format in %s at line %d\n",
filename, line);
++nprobs;
}
(void)free(p);
}
(void)fclose(fp);
} else {
t_info("Missing datafile %s\n", filename);
++nprobs;
}
result = T_UNRESOLVED;
if ((nfails == 0) && (nprobs == 0))
result = T_PASS;
else if (nfails)
result = T_FAIL;
return(result);
}
static int
t_dns_rbtnodechain_init(char *dbfile, char *findname,
char *nextname, char *nextorigin,
char *prevname, char *prevorigin,
char *firstname, char *firstorigin,
char *lastname, char *lastorigin)
{
int result;
int len;
int nfails;
dns_rbt_t *rbt;
dns_rbtnode_t *node;
dns_rbtnodechain_t chain;
isc_mem_t *mctx;
isc_entropy_t *ectx;
isc_result_t isc_result;
isc_result_t dns_result;
dns_fixedname_t dns_findname;
dns_fixedname_t dns_foundname;
dns_fixedname_t dns_firstname;
dns_fixedname_t dns_lastname;
dns_fixedname_t dns_prevname;
dns_fixedname_t dns_nextname;
dns_fixedname_t dns_origin;
isc_buffer_t isc_buffer;
result = T_UNRESOLVED;
nfails = 0;
mctx = NULL;
ectx = NULL;
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create failed %s\n",
isc_result_totext(isc_result));
return(result);
}
isc_result = isc_entropy_create(mctx, &ectx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_entropy_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_hash_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
dns_rbtnodechain_init(&chain, mctx);
rbt = NULL;
if (rbt_init(dbfile, &rbt, mctx)) {
t_info("rbt_init %s failed\n", dbfile);
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
len = strlen(findname);
isc_buffer_init(&isc_buffer, findname, len);
isc_buffer_add(&isc_buffer, len);
dns_fixedname_init(&dns_foundname);
dns_fixedname_init(&dns_findname);
dns_fixedname_init(&dns_firstname);
dns_fixedname_init(&dns_origin);
dns_fixedname_init(&dns_lastname);
dns_fixedname_init(&dns_prevname);
dns_fixedname_init(&dns_nextname);
dns_result = dns_name_fromtext(dns_fixedname_name(&dns_findname),
&isc_buffer, NULL, 0, NULL);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_name_fromtext failed %s\n",
dns_result_totext(dns_result));
return(result);
}
/*
* Set the starting node.
*/
node = NULL;
dns_result = dns_rbt_findnode(rbt, dns_fixedname_name(&dns_findname),
dns_fixedname_name(&dns_foundname),
&node, &chain, DNS_RBTFIND_EMPTYDATA,
NULL, NULL);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_rbt_findnode failed %s\n",
dns_result_totext(dns_result));
return(result);
}
/*
* Check next.
*/
t_info("checking for next name of %s and new origin of %s\n",
nextname, nextorigin);
dns_result = dns_rbtnodechain_next(&chain,
dns_fixedname_name(&dns_nextname),
dns_fixedname_name(&dns_origin));
if ((dns_result != ISC_R_SUCCESS) &&
(dns_result != DNS_R_NEWORIGIN)) {
t_info("dns_rbtnodechain_next unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
nfails += t_namechk(dns_result, &dns_nextname, nextname, &dns_origin,
nextorigin, DNS_R_NEWORIGIN);
/*
* Set the starting node again.
*/
node = NULL;
dns_fixedname_init(&dns_foundname);
dns_result = dns_rbt_findnode(rbt, dns_fixedname_name(&dns_findname),
dns_fixedname_name(&dns_foundname),
&node, &chain, DNS_RBTFIND_EMPTYDATA,
NULL, NULL);
if (dns_result != ISC_R_SUCCESS) {
t_info("\tdns_rbt_findnode failed %s\n",
dns_result_totext(dns_result));
return(result);
}
/*
* Check previous.
*/
t_info("checking for previous name of %s and new origin of %s\n",
prevname, prevorigin);
dns_fixedname_init(&dns_origin);
dns_result = dns_rbtnodechain_prev(&chain,
dns_fixedname_name(&dns_prevname),
dns_fixedname_name(&dns_origin));
if ((dns_result != ISC_R_SUCCESS) &&
(dns_result != DNS_R_NEWORIGIN)) {
t_info("dns_rbtnodechain_prev unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
nfails += t_namechk(dns_result, &dns_prevname, prevname, &dns_origin,
prevorigin, DNS_R_NEWORIGIN);
/*
* Check first.
*/
t_info("checking for first name of %s and new origin of %s\n",
firstname, firstorigin);
dns_result = dns_rbtnodechain_first(&chain, rbt,
dns_fixedname_name(&dns_firstname),
dns_fixedname_name(&dns_origin));
if (dns_result != DNS_R_NEWORIGIN) {
t_info("dns_rbtnodechain_first unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
nfails += t_namechk(dns_result, &dns_firstname, firstname,
&dns_origin, firstorigin, DNS_R_NEWORIGIN);
/*
* Check last.
*/
t_info("checking for last name of %s\n", lastname);
dns_result = dns_rbtnodechain_last(&chain, rbt,
dns_fixedname_name(&dns_lastname),
dns_fixedname_name(&dns_origin));
if (dns_result != DNS_R_NEWORIGIN) {
t_info("dns_rbtnodechain_last unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
nfails += t_namechk(dns_result, &dns_lastname, lastname, &dns_origin,
lastorigin, DNS_R_NEWORIGIN);
/*
* Check node ordering.
*/
t_info("checking node ordering\n");
nfails += t9_walkchain(&chain, rbt);
if (nfails)
result = T_FAIL;
else
result = T_PASS;
dns_rbtnodechain_invalidate(&chain);
dns_rbt_destroy(&rbt);
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
static int
test_dns_rbt_x(const char *filename) {
FILE *fp;
char *p;
int line;
int cnt;
int result;
int nfails;
int nprobs;
nfails = 0;
nprobs = 0;
fp = fopen(filename, "r");
if (fp != NULL) {
line = 0;
while ((p = t_fgetbs(fp)) != NULL) {
++line;
/*
* Skip comment lines.
*/
if ((isspace((unsigned char)*p)) || (*p == '#')) {
(void)free(p);
continue;
}
/*
* Name of db file, command, testname,
* expected result.
*/
cnt = t_bustline(p, Tokens);
if (cnt == 4) {
result = test_rbt_gen(Tokens[0], Tokens[1],
Tokens[2],
t_dns_result_fromtext(Tokens[3]));
if (result != T_PASS)
++nfails;
} else {
t_info("bad format in %s at line %d\n",
filename, line);
++nprobs;
}
(void)free(p);
}
(void)fclose(fp);
} else {
t_info("Missing datafile %s\n", filename);
++nprobs;
}
result = T_UNRESOLVED;
if ((nfails == 0) && (nprobs == 0))
result = T_PASS;
else if (nfails)
result = T_FAIL;
return(result);
}
static int
t9_walkchain(dns_rbtnodechain_t *chain, dns_rbt_t *rbt) {
int cnt;
int order;
unsigned int nlabels;
int nprobs;
isc_result_t dns_result;
dns_fixedname_t name;
dns_fixedname_t origin;
dns_fixedname_t fullname1;
dns_fixedname_t fullname2;
cnt = 0;
nprobs = 0;
do {
if (cnt == 0) {
dns_fixedname_init(&name);
dns_fixedname_init(&origin);
dns_result = dns_rbtnodechain_first(chain, rbt,
dns_fixedname_name(&name),
dns_fixedname_name(&origin));
if (dns_result != DNS_R_NEWORIGIN) {
t_info("dns_rbtnodechain_first returned %s, "
"expecting DNS_R_NEWORIGIN\n",
dns_result_totext(dns_result));
++nprobs;
break;
}
t_info("first name:\t<%s>\n", fixedname_totext(&name));
t_info("first origin:\t<%s>\n",
fixedname_totext(&origin));
} else {
dns_fixedname_init(&fullname1);
dns_result = dns_name_concatenate(
dns_fixedname_name(&name),
dns_name_isabsolute(dns_fixedname_name(&name)) ?
NULL : dns_fixedname_name(&origin),
dns_fixedname_name(&fullname1), NULL);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_name_concatenate failed %s\n",
dns_result_totext(dns_result));
++nprobs;
break;
}
/*
* Expecting origin not to get touched if next
* doesn't return NEWORIGIN.
*/
dns_fixedname_init(&name);
dns_result = dns_rbtnodechain_next(chain,
dns_fixedname_name(&name),
dns_fixedname_name(&origin));
if ((dns_result != ISC_R_SUCCESS) &&
(dns_result != DNS_R_NEWORIGIN)) {
if (dns_result != ISC_R_NOMORE) {
t_info("dns_rbtnodechain_next "
"failed %s\n",
dns_result_totext(dns_result));
++nprobs;
}
break;
}
t_info("next name:\t<%s>\n", fixedname_totext(&name));
t_info("next origin:\t<%s>\n",
fixedname_totext(&origin));
dns_fixedname_init(&fullname2);
dns_result = dns_name_concatenate(
dns_fixedname_name(&name),
dns_name_isabsolute(dns_fixedname_name(&name)) ?
NULL : dns_fixedname_name(&origin),
dns_fixedname_name(&fullname2), NULL);
if (dns_result != ISC_R_SUCCESS) {
t_info("dns_name_concatenate failed %s\n",
dns_result_totext(dns_result));
++nprobs;
break;
}
t_info("comparing\t<%s>\n",
fixedname_totext(&fullname1));
t_info("\twith\t<%s>\n", fixedname_totext(&fullname2));
(void)dns_name_fullcompare(
dns_fixedname_name(&fullname1),
dns_fixedname_name(&fullname2),
&order, &nlabels);
if (order >= 0) {
t_info("unexpected order %s %s %s\n",
dnsname_totext(dns_fixedname_name(&fullname1)),
order == -1 ? "<" : (order == 0 ? "==" : ">"),
dnsname_totext(dns_fixedname_name(&fullname2)));
++nprobs;
}
}
++cnt;
} while (1);
return (nprobs);
}
static int
test_rbt_gen(char *filename, char *command, char *testname,
isc_result_t exp_result)
{
int rval;
int result;
dns_rbt_t *rbt;
isc_result_t isc_result;
isc_result_t dns_result;
isc_mem_t *mctx;
isc_entropy_t *ectx;
dns_name_t *dns_name;
result = T_UNRESOLVED;
if (strcmp(command, "create") != 0)
t_info("testing using name %s\n", testname);
mctx = NULL;
ectx = NULL;
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create: %s: exiting\n",
dns_result_totext(isc_result));
return(T_UNRESOLVED);
}
isc_result = isc_entropy_create(mctx, &ectx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_entropy_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_hash_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
rbt = NULL;
if (rbt_init(filename, &rbt, mctx) != 0) {
if (strcmp(command, "create") == 0)
result = T_FAIL;
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
/*
* Now try the database command.
*/
if (strcmp(command, "create") == 0) {
result = T_PASS;
} else if (strcmp(command, "add") == 0) {
if (create_name(testname, mctx, &dns_name) == 0) {
dns_result = dns_rbt_addname(rbt, dns_name, dns_name);
if (dns_result != ISC_R_SUCCESS)
delete_name(dns_name, mctx);
if (dns_result == exp_result) {
if (dns_result == ISC_R_SUCCESS) {
rval = t1_search(testname, rbt, mctx,
&dns_result);
if (rval == 0) {
if (dns_result == ISC_R_SUCCESS) {
result = T_PASS;
} else {
result = T_FAIL;
}
} else {
t_info("t1_search failed\n");
result = T_UNRESOLVED;
}
} else {
result = T_PASS;
}
} else {
t_info("dns_rbt_addname returned %s, "
"expected %s\n",
dns_result_totext(dns_result),
dns_result_totext(exp_result));
result = T_FAIL;
}
} else {
t_info("create_name failed\n");
result = T_UNRESOLVED;
}
} else if ((strcmp(command, "delete") == 0) ||
(strcmp(command, "nuke") == 0)) {
rval = t1_delete(testname, rbt, mctx, &dns_result);
if (rval == 0) {
if (dns_result == exp_result) {
rval = t1_search(testname, rbt, mctx,
&dns_result);
if (rval == 0) {
if (dns_result == ISC_R_SUCCESS) {
t_info("dns_rbt_deletename "
"didn't delete "
"the name");
result = T_FAIL;
} else {
result = T_PASS;
}
}
} else {
t_info("delete returned %s, expected %s\n",
dns_result_totext(dns_result),
dns_result_totext(exp_result));
result = T_FAIL;
}
}
} else if (strcmp(command, "search") == 0) {
rval = t1_search(testname, rbt, mctx, &dns_result);
if (rval == 0) {
if (dns_result == exp_result) {
result = T_PASS;
} else {
t_info("find returned %s, expected %s\n",
dns_result_totext(dns_result),
dns_result_totext(exp_result));
result = T_FAIL;
}
}
}
dns_rbt_destroy(&rbt);
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
static int
t_timers5(void) {
char *p;
int result;
isc_mem_t *mctx;
isc_taskmgr_t *tmgr;
unsigned int workers;
isc_result_t isc_result;
isc_timermgr_t *timermgr;
isc_event_t *event;
isc_time_t expires;
isc_interval_t interval;
T5_startflag = 0;
T5_shutdownflag = 0;
T5_eventcnt = 0;
workers = 2;
p = t_getenv("ISC_TASK_WORKERS");
if (p != NULL)
workers = atoi(p);
mctx = NULL;
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create failed %s\n",
isc_result_totext(isc_result));
return(T_UNRESOLVED);
}
isc_result = isc_mutex_init(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_init failed %s\n",
isc_result_totext(isc_result));
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_condition_init(&T5_cv);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_init failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&T5_mx);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
tmgr = NULL;
isc_result = isc_taskmgr_create(mctx, workers, 0, &tmgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_taskmgr_create failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
timermgr = NULL;
isc_result = isc_timermgr_create(mctx, &timermgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_timermgr_create failed %s\n",
isc_result_totext(isc_result));
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_task1 = NULL;
isc_result = isc_task_create(tmgr, 0, &T5_task1);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_create failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_task_onshutdown(T5_task1, t5_shutdown_event, NULL);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_onshutdown failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_task2 = NULL;
isc_result = isc_task_create(tmgr, 0, &T5_task2);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_create failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_mutex_lock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
event = isc_event_allocate(mctx, (void *)1 , (isc_eventtype_t)1,
t5_start_event, NULL, sizeof(*event));
isc_task_send(T5_task1, &event);
isc_time_settoepoch(&expires);
isc_interval_set(&interval, T5_SECONDS, 0);
T5_tickertimer = NULL;
isc_result = isc_timer_create(timermgr, isc_timertype_ticker,
&expires, &interval, T5_task1,
t5_tick_event, NULL, &T5_tickertimer);
if (isc_result != ISC_R_SUCCESS) {
isc_timermgr_destroy(&timermgr);
(void) isc_condition_signal(&T5_cv);
(void) isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_oncetimer = NULL;
isc_interval_set(&interval, (T5_SECONDS * T5_NTICKS) + 2, 0);
isc_result = isc_time_nowplusinterval(&expires, &interval);
if (isc_result != ISC_R_SUCCESS) {
isc_timer_detach(&T5_tickertimer);
isc_timermgr_destroy(&timermgr);
(void)isc_condition_signal(&T5_cv);
(void)isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_interval_set(&interval, 0, 0);
isc_result = isc_timer_create(timermgr, isc_timertype_once,
&expires, &interval, T5_task2,
t5_once_event, NULL, &T5_oncetimer);
if (isc_result != ISC_R_SUCCESS) {
isc_timer_detach(&T5_tickertimer);
isc_timermgr_destroy(&timermgr);
(void) isc_condition_signal(&T5_cv);
(void) isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
++T5_nprobs;
return(T_UNRESOLVED);
}
/*
* Wait for shutdown processing to complete.
*/
while (! T5_shutdownflag) {
isc_result = isc_condition_wait(&T5_cv, &T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_waituntil failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
}
isc_result = isc_mutex_unlock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
if (T5_eventcnt != 1) {
t_info("processed %d events\n", T5_eventcnt);
++T5_nfails;
}
isc_timer_detach(&T5_tickertimer);
isc_timer_detach(&T5_oncetimer);
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
result = T_UNRESOLVED;
if ((T5_nfails == 0) && (T5_nprobs == 0))
result = T_PASS;
else if (T5_nfails)
result = T_FAIL;
return (result);
}
static void
tx_te(isc_task_t *task, isc_event_t *event) {
isc_result_t isc_result;
isc_time_t now;
isc_time_t base;
isc_time_t ulim;
isc_time_t llim;
isc_interval_t interval;
isc_eventtype_t expected_event_type;
++Tx_eventcnt;
t_info("tick %d\n", Tx_eventcnt);
expected_event_type = ISC_TIMEREVENT_LIFE;
if ((isc_timertype_t) event->ev_arg == isc_timertype_ticker)
expected_event_type = ISC_TIMEREVENT_TICK;
if (event->ev_type != expected_event_type) {
t_info("expected event type %d, got %d\n",
expected_event_type, (int) event->ev_type);
++Tx_nfails;
}
isc_result = isc_time_now(&now);
if (isc_result == ISC_R_SUCCESS) {
interval.seconds = Tx_seconds;
interval.nanoseconds = Tx_nanoseconds;
isc_result = isc_time_add(&Tx_lasttime, &interval, &base);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_time_add failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
} else {
t_info("isc_time_now failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
if (isc_result == ISC_R_SUCCESS) {
interval.seconds = Tx_FUDGE_SECONDS;
interval.nanoseconds = Tx_FUDGE_NANOSECONDS;
isc_result = isc_time_add(&base, &interval, &ulim);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_time_add failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
}
if (isc_result == ISC_R_SUCCESS) {
isc_result = isc_time_subtract(&base, &interval, &llim);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_time_subtract failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
}
if (isc_result == ISC_R_SUCCESS) {
if (isc_time_compare(&llim, &now) > 0) {
t_info("timer range error: early by "
"%lu microseconds\n",
(unsigned long)isc_time_microdiff(&base, &now));
++Tx_nfails;
} else if (isc_time_compare(&ulim, &now) < 0) {
t_info("timer range error: late by "
"%lu microseconds\n",
(unsigned long)isc_time_microdiff(&now, &base));
++Tx_nfails;
}
Tx_lasttime = now;
}
if (Tx_eventcnt == Tx_nevents) {
isc_result = isc_time_now(&Tx_endtime);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_time_now failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
isc_timer_detach(&Tx_timer);
isc_task_shutdown(task);
}
isc_event_free(&event);
}
int
main(int argc, char **argv) {
int c;
int tnum;
int subprocs;
pid_t deadpid;
int status;
int len;
isc_boolean_t first;
testspec_t *pts;
struct sigaction sa;
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
first = ISC_TRUE;
subprocs = 1;
T_timeout = T_TCTOUT;
/*
* -a option is now default.
*/
memset(T_tvec, 0xff, sizeof(T_tvec));
/*
* Parse args.
*/
while ((c = isc_commandline_parse(argc, argv, ":at:c:d:n:huxq:b:"))
!= -1) {
if (c == 'a') {
/*
* Flag all tests to be run.
*/
memset(T_tvec, 0xff, sizeof(T_tvec));
}
else if (c == 'b') {
T_dir = isc_commandline_argument;
}
else if (c == 't') {
tnum = atoi(isc_commandline_argument);
if ((tnum > 0) && (tnum < T_MAXTESTS)) {
if (first) {
/*
* Turn off effect of -a default
* and allow multiple -t and -n
* options.
*/
memset(T_tvec, 0, sizeof(T_tvec));
first = ISC_FALSE;
}
/*
* Flag test tnum to be run.
*/
tnum -= 1;
T_tvec[tnum / 8] |= (0x01 << (tnum % 8));
}
}
else if (c == 'c') {
T_config = isc_commandline_argument;
}
else if (c == 'd') {
T_debug = atoi(isc_commandline_argument);
}
else if (c == 'n') {
pts = &T_testlist[0];
tnum = 0;
while (pts->pfv != NULL) {
if (! strcmp(pts->func_name,
isc_commandline_argument)) {
if (first) {
memset(T_tvec, 0,
sizeof(T_tvec));
first = ISC_FALSE;
}
T_tvec[tnum/8] |= (0x01 << (tnum%8));
break;
}
++pts;
++tnum;
}
if (pts->pfv == NULL) {
fprintf(stderr, "no such test %s\n",
isc_commandline_argument);
exit(1);
}
}
else if (c == 'h') {
printhelp();
exit(0);
}
else if (c == 'u') {
printusage();
exit(0);
}
else if (c == 'x') {
subprocs = 0;
}
else if (c == 'q') {
T_timeout = atoi(isc_commandline_argument);
}
else if (c == ':') {
fprintf(stderr, "Option -%c requires an argument\n",
isc_commandline_option);
exit(1);
}
else if (c == '?') {
fprintf(stderr, "Unrecognized option -%c\n",
isc_commandline_option);
exit(1);
}
}
/*
* Set cwd.
*/
if (T_dir != NULL && chdir(T_dir) != 0) {
fprintf(stderr, "chdir %s failed\n", T_dir);
exit(1);
}
/*
* We don't want buffered output.
*/
(void)setbuf(stdout, NULL);
(void)setbuf(stderr, NULL);
/*
* Setup signals.
*/
sa.sa_flags = 0;
sigfillset(&sa.sa_mask);
sa.sa_handler = t_sighandler;
(void)sigaction(SIGINT, &sa, NULL);
(void)sigaction(SIGALRM, &sa, NULL);
/*
* Output start stanza to journal.
*/
snprintf(T_buf, sizeof(T_buf), "%s:", argv[0]);
len = strlen(T_buf);
(void) t_getdate(T_buf + len, T_BIGBUF - len);
t_putinfo("S", T_buf);
/*
* Setup the test environment using the config file.
*/
if (T_config == NULL)
T_config = T_DEFAULT_CONFIG;
t_initconf(T_config);
if (T_debug)
t_dumpconf(T_config);
/*
* Now invoke all the test cases.
*/
tnum = 0;
pts = &T_testlist[0];
while (*pts->pfv != NULL) {
if (T_tvec[tnum / 8] & (0x01 << (tnum % 8))) {
if (subprocs) {
T_pid = fork();
if (T_pid == 0) {
(*pts->pfv)();
exit(0);
} else if (T_pid > 0) {
T_int = 0;
sa.sa_handler = t_sighandler;
(void)sigaction(SIGALRM, &sa, NULL);
alarm(T_timeout);
deadpid = (pid_t) -1;
while (deadpid != T_pid) {
deadpid =
waitpid(T_pid, &status, 0);
if (deadpid == T_pid) {
if (WIFSIGNALED(status)) {
if (WTERMSIG(status) ==
SIGTERM)
t_info(
"the test case timed out\n");
else
t_info(
"the test case caused exception %d\n",
WTERMSIG(status));
t_result(T_UNRESOLVED);
}
} else if ((deadpid == -1) &&
(errno == EINTR) &&
T_int) {
kill(T_pid, SIGTERM);
T_int = 0;
}
else if ((deadpid == -1) &&
((errno == ECHILD) ||
(errno == ESRCH)))
break;
}
alarm(0);
sa.sa_handler = SIG_IGN;
(void)sigaction(SIGALRM, &sa, NULL);
} else {
t_info("fork failed, errno == %d\n",
errno);
t_result(T_UNRESOLVED);
}
}
else {
(*pts->pfv)();
}
}
++pts;
++tnum;
}
snprintf(T_buf, sizeof(T_buf), "%s:", argv[0]);
len = strlen(T_buf);
(void) t_getdate(T_buf + len, T_BIGBUF - len);
t_putinfo("E", T_buf);
return(0);
}
static int
t_dns_rbtnodechain_last(char *dbfile, char *expected_lastname,
char *expected_lastorigin,
char *expected_prevname,
char *expected_prevorigin)
{
int result;
int nfails;
dns_rbt_t *rbt;
dns_rbtnodechain_t chain;
isc_mem_t *mctx;
isc_entropy_t *ectx;
isc_result_t isc_result;
isc_result_t dns_result;
dns_fixedname_t dns_name;
dns_fixedname_t dns_origin;
isc_result_t expected_result;
result = T_UNRESOLVED;
nfails = 0;
mctx = NULL;
ectx = NULL;
dns_fixedname_init(&dns_name);
dns_fixedname_init(&dns_origin);
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create failed %s\n",
isc_result_totext(isc_result));
return(result);
}
isc_result = isc_entropy_create(mctx, &ectx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_entropy_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_hash_create: %s: exiting\n",
dns_result_totext(isc_result));
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
dns_rbtnodechain_init(&chain, mctx);
rbt = NULL;
if (rbt_init(dbfile, &rbt, mctx)) {
t_info("rbt_init %s failed\n", dbfile);
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
t_info("testing for last name of %s, origin of %s\n",
expected_lastname, expected_lastorigin);
dns_result = dns_rbtnodechain_last(&chain, rbt,
dns_fixedname_name(&dns_name),
dns_fixedname_name(&dns_origin));
if (dns_result != DNS_R_NEWORIGIN) {
t_info("dns_rbtnodechain_last unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
nfails += t_namechk(dns_result, &dns_name, expected_lastname,
&dns_origin, expected_lastorigin, DNS_R_NEWORIGIN);
t_info("testing for previous name of %s, origin of %s\n",
expected_prevname, expected_prevorigin);
dns_fixedname_init(&dns_name);
dns_result = dns_rbtnodechain_prev(&chain,
dns_fixedname_name(&dns_name),
dns_fixedname_name(&dns_origin));
if ((dns_result != ISC_R_SUCCESS) &&
(dns_result != DNS_R_NEWORIGIN)) {
t_info("dns_rbtnodechain_prev unexpectedly returned %s\n",
dns_result_totext(dns_result));
}
if (strcasecmp(expected_lastorigin, expected_prevorigin) == 0)
expected_result = ISC_R_SUCCESS;
else
expected_result = DNS_R_NEWORIGIN;
nfails += t_namechk(dns_result, &dns_name, expected_prevname,
&dns_origin, expected_prevorigin, expected_result);
if (nfails)
result = T_FAIL;
else
result = T_PASS;
dns_rbtnodechain_invalidate(&chain);
dns_rbt_destroy(&rbt);
isc_hash_destroy();
isc_entropy_detach(&ectx);
isc_mem_destroy(&mctx);
return(result);
}
