int main()
{
FBDEV fbdev;
memset(&fbdev,0,sizeof(FBDEV));
strcpy(fbdev.dev,"/dev/fb0");
if(0 == fb_open(&fbdev)){
printf("Open fail!!\n");
return -1;
}
//打印frame buffer 所占内存的开始地址
pmem_start(&fbdev);
//打印FB_TYPE
p_type(&fbdev);
//打印可见清晰度
p_visible_res(&fbdev);
//打印虚拟分辨率
p_virt_res(&fbdev);
//打印虚拟到可见的偏移量
p_offset(&fbdev);
//打印每个像素的位数
p_bpp(&fbdev);
//打印R,G,B和透明度
p_rgbt(&fbdev);
//打印在内存中的高度和宽度
p_hw(&fbdev);
fb_close(&fbdev);
return 0;
}
static void
nslookupComplain(const char *sysloginfo,
const char *net_queryname,
const char *complaint,
const char *net_dname,
const struct databuf *a_rr,
const struct databuf *nsdp)
{
char queryname[INSZ+1], dname[INSZ+1];
const char *a, *ns;
const char *a_type;
int print_a;
strncpy(queryname, net_queryname, sizeof queryname);
queryname[(sizeof queryname) - 1] = EOS;
strncpy(dname, net_dname, sizeof dname);
dname[(sizeof dname) - 1] = EOS;
if (sysloginfo && queryname && !haveComplained(queryname, complaint)) {
char buf[BUFSZ];
a = ns = (char *)NULL;
print_a = (a_rr->d_type == T_A);
a_type = p_type(a_rr->d_type);
/* OK */
r_strncpy (buf, sysloginfo, BUFSZ);
}
}
static void
do_section(ns_msg *handle, ns_sect section, int pflag, FILE *file) {
int n, sflag, rrnum;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (int)(_res.pfcode & pflag);
if (_res.pfcode && !sflag)
return;
opcode = ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(_res.pfcode & RES_PRF_HEAD1))
putc('\n', file);
return;
}
if (rrnum == 0 && sflag != 0 && (_res.pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else {
char *buf;
buf = (char*)malloc(2024);
if (buf) {
n = ns_sprintrr(handle, &rr, NULL, NULL,
buf, sizeof buf);
if (n < 0) {
fprintf(file, ";; ns_sprintrr: %s\n",
strerror(errno));
free(buf);
return;
}
fputs(buf, file);
fputc('\n', file);
free(buf);
}
}
rrnum++;
}
}
/**
==================== Decl =============================================
Grammar:
decl : type id ';'
*/
static TreeDecl p_decl(void) {
TreeDecl decl = 0; // set null by default
TokenCode code = curr()->code;
// body
TreeType l0type = p_type();
TreeId l1id = p_id();
eat(';');
decl = t_decl_type(l0type, l1id);
return decl;
}
static void
do_section(const res_state statp,
ns_msg *handle, ns_sect section,
int pflag, FILE *file)
{
int n, sflag, rrnum;
int buflen = 2048;
char *buf;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (statp->pfcode & pflag);
if (statp->pfcode && !sflag)
return;
buf = malloc((size_t)buflen);
if (buf == NULL) {
fprintf(file, ";; memory allocation failure\n");
return;
}
opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(statp->pfcode & RES_PRF_HEAD1))
putc('\n', file);
goto cleanup;
}
if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else if (section == ns_s_ar && ns_rr_type(rr) == ns_t_opt) {
u_int32_t ttl = ns_rr_ttl(rr);
fprintf(file,
"; EDNS: version: %u, udp=%u, flags=%04x\n",
(ttl>>16)&0xff, ns_rr_class(rr), ttl&0xffff);
} else {
void
val_log_val_rrset_pfx(const val_context_t * ctx, int level,
const char *pfx, struct val_rrset_rec *val_rrset_rec)
{
char buf1[2049], buf2[2049];
if (!val_rrset_rec)
return;
val_log(ctx, level, "%srrs->val_rrset_name=%s rrs->val_rrset_type=%s "
"rrs->val_rrset_class=%s rrs->val_rrset_ttl=%d "
"rrs->val_rrset_section=%s\nrrs->val_rrset_data=%s\n"
"rrs->val_rrset_sig=%s", pfx ? pfx : "",
val_rrset_rec->val_rrset_name,
p_type(val_rrset_rec->val_rrset_type),
p_class(val_rrset_rec->val_rrset_class),
val_rrset_rec->val_rrset_ttl,
p_section(val_rrset_rec->val_rrset_section - 1, !ns_o_update),
get_rr_string(val_rrset_rec->val_rrset_data, buf1, 2048),
get_rr_string(val_rrset_rec->val_rrset_sig, buf2, 2048));
}
void TestArchivingOfCell() throw(Exception)
{
OutputFileHandler handler("archive", false);
handler.SetArchiveDirectory();
std::string archive_filename = handler.GetOutputDirectoryFullPath() + "cell.arch";
// Archive a cell
{
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(2.0, 4);
// Create mutation state
boost::shared_ptr<AbstractCellProperty> p_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
boost::shared_ptr<AbstractCellProperty> p_type(CellPropertyRegistry::Instance()->Get<StemCellProliferativeType>());
// Create cell-cycle model
FixedDurationGenerationBasedCellCycleModel* p_cell_model = new FixedDurationGenerationBasedCellCycleModel();
// Create SRN
Goldbeter1991SrnModel* p_srn_model = new Goldbeter1991SrnModel();
// Create cell property collection
CellPropertyCollection collection;
MAKE_PTR(CellLabel, p_label);
collection.AddProperty(p_label);
// Create cell
CellPtr p_cell(new Cell(p_healthy_state, p_cell_model, p_srn_model, false, collection));
p_cell->SetCellProliferativeType(p_type);
p_cell->InitialiseCellCycleModel();
p_cell->InitialiseSrnModel();
p_simulation_time->IncrementTimeOneStep();
TS_ASSERT_EQUALS(p_cell->GetAge(), 0.5);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), UNSIGNED_UNSET);
// Set ancestor
MAKE_PTR_ARGS(CellAncestor, p_cell_ancestor, (2u));
p_cell->SetAncestor(p_cell_ancestor);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
// Set CellVecData with some actual content
boost::shared_ptr<AbstractCellProperty> p_vec_data(CellPropertyRegistry::Instance()->Get<CellVecData>());
p_cell->AddCellProperty(p_vec_data);
Vec item_1 = PetscTools::CreateAndSetVec(2, -17.3); // <-17.3, -17.3>
p_cell->GetCellVecData()->SetItem("item 1", item_1);
// Check properties set correctly
CellPropertyCollection& final_collection = p_cell->rGetCellPropertyCollection();
TS_ASSERT_EQUALS(final_collection.GetSize(), 7u);
TS_ASSERT_EQUALS(final_collection.HasProperty<WildTypeCellMutationState>(), true);
TS_ASSERT_EQUALS(final_collection.HasProperty<ApcOneHitCellMutationState>(), false);
TS_ASSERT_EQUALS(final_collection.HasProperty<ApcTwoHitCellMutationState>(), false);
TS_ASSERT_EQUALS(final_collection.HasProperty<CellLabel>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<AbstractCellMutationState>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<CellAncestor>(), true);
TS_ASSERT_EQUALS(final_collection.HasPropertyType<CellId>(), true);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
for (CellPropertyCollection::Iterator it = final_collection.Begin(); it != final_collection.End(); ++it)
{
TS_ASSERT_EQUALS(final_collection.HasProperty(*it), true);
bool is_wildtype = (*it)->IsType<WildTypeCellMutationState>();
bool is_label = (*it)->IsType<CellLabel>();
bool is_ancestor = (*it)->IsType<CellAncestor>();
bool is_cellid = (*it)->IsType<CellId>();
bool is_data = (*it)->IsType<CellData>();
bool is_vec_data = (*it)->IsType<CellVecData>();
bool is_stem = (*it)->IsType<StemCellProliferativeType>();
bool is_any_of_above = is_wildtype || is_label || is_ancestor || is_cellid || is_data || is_vec_data || is_stem;
TS_ASSERT_EQUALS(is_any_of_above, true);
}
// Create another cell
boost::shared_ptr<AbstractCellProperty> p_another_healthy_state(CellPropertyRegistry::Instance()->Get<WildTypeCellMutationState>());
FixedDurationGenerationBasedCellCycleModel* p_another_cell_model = new FixedDurationGenerationBasedCellCycleModel();
Goldbeter1991SrnModel* p_another_srn_model = new Goldbeter1991SrnModel();
CellPtr p_another_cell(new Cell(p_another_healthy_state, p_another_cell_model, p_another_srn_model, false, collection));
boost::shared_ptr<AbstractCellProperty> p_another_vec_data(new CellVecData);
p_another_cell->AddCellProperty(p_another_vec_data);
TS_ASSERT_EQUALS(p_cell->GetCellVecData()->GetNumItems(), 1u);
TS_ASSERT_EQUALS(p_another_cell->GetCellVecData()->GetNumItems(), 0u);
Vec another_item_1 = PetscTools::CreateAndSetVec(2, 42.0); // <42, 42>
p_another_cell->GetCellVecData()->SetItem("item 1", another_item_1);
// Create an output archive
std::ofstream ofs(archive_filename.c_str());
boost::archive::text_oarchive output_arch(ofs);
CellPtr const p_const_cell = p_cell;
// Write the cell to the archive
output_arch << static_cast<const SimulationTime&> (*p_simulation_time);
output_arch << p_const_cell;
// Write the second cell also
CellPtr const p_another_const_cell = p_another_cell;
output_arch << p_another_const_cell;
// Tidy up
SimulationTime::Destroy();
PetscTools::Destroy(item_1);
PetscTools::Destroy(another_item_1);
}
// Restore CellPtr
{
// Need to set up time to initialize a cell
SimulationTime* p_simulation_time = SimulationTime::Instance();
p_simulation_time->SetStartTime(1.0);
p_simulation_time->SetEndTimeAndNumberOfTimeSteps(2.0, 1); // will be restored
// Initialize a cell
CellPtr p_cell;
// Restore the cell
std::ifstream ifs(archive_filename.c_str(), std::ios::binary);
boost::archive::text_iarchive input_arch(ifs);
input_arch >> *p_simulation_time;
input_arch >> p_cell;
// Check the simulation time has been restored (through the cell)
TS_ASSERT_EQUALS(p_simulation_time->GetTime(), 0.5);
TS_ASSERT_EQUALS(p_simulation_time->GetTimeStep(), 0.5);
TS_ASSERT_EQUALS(p_cell->GetAge(), 0.5);
TS_ASSERT_EQUALS(static_cast<FixedDurationGenerationBasedCellCycleModel*>(p_cell->GetCellCycleModel())->GetGeneration(), 0u);
TS_ASSERT(dynamic_cast<Goldbeter1991SrnModel*>(p_cell->GetSrnModel()));
TS_ASSERT_EQUALS(p_cell->GetCellProliferativeType()->IsType<StemCellProliferativeType>(), true);
AbstractCellCycleModel* p_cc_model = p_cell->GetCellCycleModel();
TS_ASSERT_EQUALS(p_cc_model->GetCell(), p_cell);
AbstractSrnModel* p_srn_model = p_cell->GetSrnModel();
TS_ASSERT_EQUALS(p_srn_model->GetCell(), p_cell);
CellPropertyCollection& collection = p_cell->rGetCellPropertyCollection();
TS_ASSERT_EQUALS(collection.GetSize(), 7u);
TS_ASSERT_EQUALS(collection.HasProperty<WildTypeCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasProperty<ApcOneHitCellMutationState>(), false);
TS_ASSERT_EQUALS(collection.HasProperty<ApcTwoHitCellMutationState>(), false);
TS_ASSERT_EQUALS(collection.HasProperty<CellLabel>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellProperty>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<AbstractCellMutationState>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<CellAncestor>(), true);
TS_ASSERT_EQUALS(collection.HasPropertyType<CellId>(), true);
TS_ASSERT_EQUALS(p_cell->GetAncestor(), 2u);
// Check explicitly for CellVecData as it is not available by default as CellData
TS_ASSERT_EQUALS(collection.HasPropertyType<CellVecData>(), true);
// Check that the Vec stored in CellVecData was unarchived correctly
boost::shared_ptr<CellVecData> p_cell_vec_data = boost::static_pointer_cast<CellVecData>(collection.GetPropertiesType<CellVecData>().GetProperty());
PetscInt vec_size;
VecGetSize(p_cell_vec_data->GetItem("item 1"), &vec_size);
TS_ASSERT_EQUALS(vec_size, 2);
ReplicatableVector rep_item_1(p_cell_vec_data->GetItem("item 1"));
TS_ASSERT_DELTA(rep_item_1[0], -17.3, 2e-14);
for (CellPropertyCollection::Iterator it = collection.Begin(); it != collection.End(); ++it)
{
TS_ASSERT_EQUALS(collection.HasProperty(*it), true);
bool is_wildtype = (*it)->IsType<WildTypeCellMutationState>();
bool is_label = (*it)->IsType<CellLabel>();
bool is_ancestor = (*it)->IsType<CellAncestor>();
bool is_cellid = (*it)->IsType<CellId>();
bool is_data = (*it)->IsType<CellData>();
bool is_vec_data = (*it)->IsType<CellVecData>();
bool is_stem = (*it)->IsType<StemCellProliferativeType>();
bool is_any_of_above = is_wildtype || is_label || is_ancestor || is_cellid || is_data || is_vec_data || is_stem;
TS_ASSERT_EQUALS(is_any_of_above, true);
}
// Try another cell
CellPtr p_another_cell;
input_arch >> p_another_cell;
ReplicatableVector rep_another_item_1(p_another_cell->GetCellVecData()->GetItem("item 1"));
TS_ASSERT_DELTA(rep_another_item_1[0], 42.0, 2e-14);
}
}
void
val_log_authentication_chain(const val_context_t * ctx, int level,
const char * name_p, int class_h,
int type_h,
struct val_result_chain *results)
{
struct val_result_chain *next_result;
int real_type_h;
int real_class_h;
if (results == NULL) {
return;
}
for (next_result = results; next_result;
next_result = next_result->val_rc_next) {
struct val_authentication_chain *next_as;
int i;
/* Display the correct owner name, class,type for the record */
if (next_result->val_rc_rrset) {
real_type_h = next_result->val_rc_rrset->val_rrset_type;
real_class_h = next_result->val_rc_rrset->val_rrset_class;
} else {
real_type_h = type_h;
real_class_h = class_h;
}
if (val_isvalidated(next_result->val_rc_status)) {
val_log(ctx, level, "Validation result for {%s, %s(%d), %s(%d)}: %s:%d (Validated)",
name_p, p_class(real_class_h), real_class_h,
p_type(real_type_h), real_type_h,
p_val_status(next_result->val_rc_status),
next_result->val_rc_status);
} else if (val_istrusted(next_result->val_rc_status)) {
val_log(ctx, level, "Validation result for {%s, %s(%d), %s(%d)}: %s:%d (Trusted but not Validated)",
name_p, p_class(real_class_h), real_class_h,
p_type(real_type_h), real_type_h,
p_val_status(next_result->val_rc_status),
next_result->val_rc_status);
} else {
val_log(ctx, level, "Validation result for {%s, %s(%d), %s(%d)}: %s:%d (Untrusted)",
name_p, p_class(real_class_h), real_class_h,
p_type(real_type_h), real_type_h,
p_val_status(next_result->val_rc_status),
next_result->val_rc_status);
}
for (next_as = next_result->val_rc_answer; next_as;
next_as = next_as->val_ac_trust) {
if (next_as->val_ac_rrset == NULL) {
val_log(ctx, level, " Assertion status = %s:%d",
p_ac_status(next_as->val_ac_status),
next_as->val_ac_status);
} else {
const char *t_name;
t_name = next_as->val_ac_rrset->val_rrset_name;
if (t_name == NULL)
t_name = (const char *) "NULL_DATA";
val_log_assertion_pfx(ctx, level, " ", t_name,
next_as);
// val_log_val_rrset_pfx(ctx, level, " ",
// next_as->val_ac_rrset);
}
}
for (i = 0; i < next_result->val_rc_proof_count; i++) {
val_log(ctx, level, " Proof of non-existence [%d of %d]",
i+1, next_result->val_rc_proof_count);
for (next_as = next_result->val_rc_proofs[i]; next_as;
next_as = next_as->val_ac_trust) {
if (next_as->val_ac_rrset == NULL) {
val_log(ctx, level, " Assertion status = %s:%d",
p_ac_status(next_as->val_ac_status),
next_as->val_ac_status);
} else {
const char *t_name;
t_name = next_as->val_ac_rrset->val_rrset_name;
if (t_name == NULL)
t_name = (const char *) "NULL_DATA";
val_log_assertion_pfx(ctx, level, " ", t_name,
next_as);
}
}
}
}
}
static void
do_section (int pfcode, ns_msg *handle, ns_sect section, int pflag, FILE *file)
{
int n, sflag, rrnum;
static int buflen = 2048;
char *buf;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (pfcode & pflag);
if (pfcode && !sflag)
return;
buf = malloc(buflen);
if (buf == NULL) {
fprintf(file, ";; memory allocation failure\n");
return;
}
opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(pfcode & RES_PRF_HEAD1))
putc('\n', file);
goto cleanup;
}
if (rrnum == 0 && sflag != 0 && (pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else {
n = ns_sprintrr(handle, &rr, NULL, NULL,
buf, buflen);
if (n < 0) {
if (errno == ENOSPC) {
free(buf);
buf = NULL;
if (buflen < 131072)
buf = malloc(buflen += 1024);
if (buf == NULL) {
fprintf(file,
";; memory allocation failure\n");
return;
}
continue;
}
fprintf(file, ";; ns_sprintrr: %s\n",
strerror(errno));
goto cleanup;
}
fputs(buf, file);
fputc('\n', file);
}
rrnum++;
}
cleanup:
free(buf);
}
void
val_log_assertion_pfx(const val_context_t * ctx, int level,
const char *prefix, const char * name_pr,
struct val_authentication_chain *next_as)
{
char name_buf[INET6_ADDRSTRLEN + 1];
const char *serv_pr;
int tag = 0;
int class_h;
int type_h;
struct val_rr_rec *data;
struct sockaddr *serv;
val_astatus_t status;
struct val_rr_rec *curkey;
#undef VAL_LOG_SIG
#ifdef VAL_LOG_SIG
struct val_rr_rec *sig;
struct val_rr_rec *cursig;
#endif
if (next_as == NULL)
return;
class_h = next_as->val_ac_rrset->val_rrset_class;
type_h = next_as->val_ac_rrset->val_rrset_type;
data = next_as->val_ac_rrset->val_rrset_data;
#ifdef VAL_LOG_SIG
sig = next_as->val_ac_rrset->val_rrset_sig;
#endif
serv = next_as->val_ac_rrset->val_rrset_server;
status = next_as->val_ac_status;
if (NULL == prefix)
prefix = "";
if (serv)
serv_pr =
((serv_pr =
val_get_ns_string(serv, name_buf, sizeof(name_buf))) == NULL) ? "VAL_CACHE" : serv_pr;
else
serv_pr = "NULL";
if (type_h == ns_t_dnskey) {
for (curkey = data; curkey; curkey = curkey->rr_next) {
if ((curkey->rr_status == VAL_AC_VERIFIED_LINK) ||
(curkey->rr_status == VAL_AC_TRUST_POINT) ||
(curkey->rr_status == VAL_AC_UNKNOWN_ALGORITHM_LINK)) {
/*
* Extract the key tag
*/
val_dnskey_rdata_t dnskey;
if (VAL_NO_ERROR != val_parse_dnskey_rdata(curkey->rr_rdata,
curkey->rr_rdata_length, &dnskey)) {
val_log(ctx, LOG_INFO, "val_log_assertion_pfx(): Cannot parse DNSKEY data");
} else {
tag = dnskey.key_tag;
if (dnskey.public_key)
FREE(dnskey.public_key);
}
break;
}
}
}
if (tag != 0) {
val_log(ctx, level,
"%sname=%s class=%s type=%s[tag=%d] from-server=%s "
"status=%s:%d", prefix, name_pr, p_class(class_h),
p_type(type_h), tag, serv_pr, p_ac_status(status), status);
} else {
val_log(ctx, level,
"%sname=%s class=%s type=%s from-server=%s status=%s:%d",
prefix, name_pr, p_class(class_h), p_type(type_h), serv_pr,
p_ac_status(status), status);
}
#ifdef VAL_LOG_SIG
for (cursig = sig; cursig; cursig = cursig->rr_next) {
char incpTime[1028];
char exprTime[1028];
struct timeval tv_sig;
val_rrsig_rdata_t rrsig;
val_parse_rrsig_rdata(cursig->rr_rdata, cursig->rr_rdata_length, &rrsig);
memset(&tv_sig, 0, sizeof(tv_sig));
tv_sig.tv_sec = rrsig.sig_incp;
GET_TIME_BUF((const time_t *)(&tv_sig.tv_sec), incpTime);
memset(&tv_sig, 0, sizeof(tv_sig));
tv_sig.tv_sec = rrsig.sig_expr;
GET_TIME_BUF((const time_t *)(&tv_sig.tv_sec), exprTime);
val_log(ctx, level,
"%s ->tag=%d status=%s sig-incep=%s sig-expr=%s",
prefix, rrsig.key_tag,
p_ac_status(cursig->rr_status),
incpTime, exprTime);
}
#endif
#ifdef VAL_LOG_SIG
struct val_rr_rec *rr;
struct val_rr_rec *sig = next_as->val_ac_rrset->val_rrset_sig;
for (rr = data; rr; rr = rr->rr_next) {
val_log(ctx, level, " data_status=%s:%d",
p_ac_status(rr->rr_status), rr->rr_status);
}
for (rr = sig; rr; rr = rr->rr_next) {
val_log(ctx, level, " sig_status=%s:%d",
p_ac_status(rr->rr_status), rr->rr_status);
}
#endif
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "usage: %s /path/to/elf64_file\n", argv[0]);
return 1;
}
int fd;
struct stat buf;
u8 *f;
fd = open(argv[1], O_RDONLY);
if (fd == -1) {
perror("open");
return 1;
}
if (fstat(fd, &buf) == -1) {
perror("fstat");
return 1;
}
f = mmap(NULL, buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (f == MAP_FAILED) {
perror("mmap");
return 1;
}
Elf64_Ehdr *elf_header = (Elf64_Ehdr *)f;
printf("ELF header:\n");
printf(" header size = %#x\n", elf_header->e_ehsize);
printf(" program header table at = %#lx, entry count = %d, entry size = %#x\n",
elf_header->e_phoff,
elf_header->e_phnum,
elf_header->e_phentsize);
printf(" section header table at = %#lx, entry count = %d, entry size = %#x\n",
elf_header->e_shoff,
elf_header->e_shnum,
elf_header->e_shentsize);
printf(" e_entry = %#lx\n", elf_header->e_entry);
printf(" e_type = %#x (ET_EXEC = %#x, ET_DYN = %#x, ET_CORE = %#x)\n",
elf_header->e_type,
ET_EXEC,
ET_DYN,
ET_CORE);
printf(" e_machine = %#x (ET_X86_64 = %#x)\n", elf_header->e_machine, EM_X86_64);
printf(" e_shstrndx = %d\n", elf_header->e_shstrndx);
printf("\nProgram header table:\n");
Elf64_Phdr *program_header_table = (Elf64_Phdr *)(f + elf_header->e_phoff);
int i;
Elf64_Phdr *ph;
u8 *pt_note;
int pt_note_count, pt_note_namesize, pt_note_descsize;
Elf64_Dyn *dyn;
for (i = 0; i < elf_header->e_phnum; i++) {
ph = program_header_table + i;
printf(" %4d: ", i);
printf("type = %-16s", p_type(ph->p_type));
if (ph->p_flags & PF_R) {
printf("R");
}
if (ph->p_flags & PF_W) {
printf("W");
}
if (ph->p_flags & PF_X) {
printf("X");
}
printf("\t");
printf("offset = %#lx size = %ld ", ph->p_offset, ph->p_filesz);
if (ph->p_type == PT_LOAD) {
printf("p_vaddr = %#lx p_memsz = %#lx ", ph->p_vaddr, ph->p_memsz);
}
printf("\n");
if (ph->p_type == PT_INTERP) {
printf("\t\t%s\n", (char *)(f + ph->p_offset));
}
if (ph->p_type == PT_NOTE) {
pt_note = (u8 *)(f + ph->p_offset);
while (pt_note_count < ph->p_filesz) {
printf("\t\t");
pt_note_namesize = (u32)(*pt_note);
printf("name size = %d, ", pt_note_namesize);
pt_note += 4;
pt_note_count += 4;
pt_note_descsize = (u32)(*pt_note);
printf("desc size = %d, ", pt_note_descsize);
pt_note += 4;
pt_note_count += 4;
printf("type = %d\n", (u32)(*pt_note));
pt_note += 4;
pt_note_count += 4;
printf("\t\tname: ");
while (pt_note_namesize--) {
printf("%#x ", *pt_note);
if (*pt_note) {
printf("(%c) ", *pt_note);
}
pt_note++;
pt_note_count++;
}
printf("\n");
printf("\t\tdesc: ");
while (pt_note_descsize--) {
printf("%#x ", *pt_note);
pt_note++;
pt_note_count++;
}
printf("\n");
}
} else if (ph->p_type == PT_DYNAMIC) {
dyn = (Elf64_Dyn *)(f + ph->p_offset);
while (dyn->d_tag != DT_NULL) {
printf("\t\td_tag = %-20s d_un = %#lx\n", d_tag(dyn->d_tag), dyn->d_un.d_val);
dyn = dyn + 1;
}
}
}
Elf64_Shdr *section_header_table = (Elf64_Shdr *)(f + elf_header->e_shoff);
Elf64_Shdr *name_sh = NULL;
printf("\nFind section name string table:\n");
if (elf_header->e_shstrndx != SHN_UNDEF) {
name_sh = section_header_table + elf_header->e_shstrndx;
printf(" offset = %#lx, size = %ld\n", name_sh->sh_offset, name_sh->sh_size);
}
printf("\nSection header table:\n");
Elf64_Shdr *sh;
Elf64_Shdr *symtab_sh = NULL, *dynsym_sh = NULL,
*strtab_sh = NULL, *dynstr_sh = NULL,
*got_sh = NULL, *gotplt_sh = NULL;
char *name;
Elf64_Rela *rela_sh;
int rela_count, rela_idx;
for (i = 0; i < elf_header->e_shnum; i++) {
sh = section_header_table + i;
printf(" %4d: ", i);
if (name_sh) {
name = (char *)(f + name_sh->sh_offset + sh->sh_name);
printf("name = %-20s ", name);
if (sh->sh_type == SHT_STRTAB) {
if (strcmp(name, ".strtab") == 0) {
strtab_sh = sh;
} else if (strcmp(name, ".dynstr") == 0) {
dynstr_sh = sh;
}
}
if (strcmp(name, ".got") == 0) {
got_sh = sh;
}
if (strcmp(name, ".got.plt") == 0) {
gotplt_sh = sh;
}
}
printf("type = %-16s ", sh_type(sh->sh_type));
printf("offset = %#lx ", sh->sh_offset);
printf("size = %ld ", sh->sh_size);
printf("\n");
if (sh->sh_type == SHT_SYMTAB) {
symtab_sh = sh;
} else if (sh->sh_type == SHT_DYNSYM) {
dynsym_sh = sh;
} else if (sh->sh_type == SHT_RELA) {
printf("\t\tsh_link = %s, sh_info = %s\n",
(f + name_sh->sh_offset + (section_header_table + sh->sh_link)->sh_name),
(f + name_sh->sh_offset + (section_header_table + sh->sh_info)->sh_name));
rela_sh = (Elf64_Rela *)(f + sh->sh_offset);
rela_count = sh->sh_size / sizeof(Elf64_Rela);
rela_idx = 0;
while (rela_idx < rela_count - 1) {
rela_sh = rela_sh + 1;
printf("\t\tr_offset = %#lx, r_info = (SYM = %lu, TYPE = %#lx), r_addend = %#lx\n",
rela_sh->r_offset,
ELF64_R_SYM(rela_sh->r_info),
ELF64_R_TYPE(rela_sh->r_info),
rela_sh->r_addend);
rela_idx++;
}
}
}
if (symtab_sh && strtab_sh) {
printf("\nFound symbol table:\n");
Elf64_Sym *symtab = (Elf64_Sym *)(f + symtab_sh->sh_offset);
int count = symtab_sh->sh_size / symtab_sh->sh_entsize;
Elf64_Sym *sym;
for (i = 0; i < count; i++) {
sym = symtab + i;
printf(" %d: ", i);
printf("name = %-30s ", f + strtab_sh->sh_offset + sym->st_name);
printf("value = %#-8lx ", sym->st_value);
printf("size = %#-8lx ", sym->st_size);
printf("type = %-16s ", symbol_type(sym->st_info));
printf("binding = %-16s ", symbol_binding(sym->st_info));
printf("defined section index = ");
if (sym->st_shndx > 0 && sym->st_shndx < elf_header->e_shnum - 1) {
printf("%s", f + name_sh->sh_offset + (section_header_table + sym->st_shndx)->sh_name);
} else {
printf("%s", special_seciton_name(sym->st_shndx));
}
printf("\n");
}
}
if (dynsym_sh && dynstr_sh) {
printf("\nFound dynamic linking symbol table:\n");
Elf64_Sym *symtab = (Elf64_Sym *)(f + dynsym_sh->sh_offset);
int count = dynsym_sh->sh_size / dynsym_sh->sh_entsize;
Elf64_Sym *sym;
for (i = 0; i < count; i++) {
sym = symtab + i;
printf(" %d: ", i);
printf("name = %-30s ", f + dynstr_sh->sh_offset + sym->st_name);
printf("value = %#-8lx ", sym->st_value);
printf("size = %#-8lx ", sym->st_size);
printf("type = %-16s ", symbol_type(sym->st_info));
printf("binding = %-16s ", symbol_binding(sym->st_info));
printf("defined section index = ");
if (sym->st_shndx > 0 && sym->st_shndx < elf_header->e_shnum - 1) {
printf("%s", f + name_sh->sh_offset + (section_header_table + sym->st_shndx)->sh_name);
} else {
printf("%s", special_seciton_name(sym->st_shndx));
}
printf("\n");
}
}
if (got_sh) {
printf("\nGOT:\n");
int count = got_sh->sh_size / 8;
uint64_t *got = (uint64_t *)(f + got_sh->sh_offset);
for (i = 0; i < count; i++) {
printf("%d: %#lx\n", i, *got);
got++;
}
}
if (gotplt_sh) {
printf("\nGOT.PLT:\n");
int count = gotplt_sh->sh_size / 8;
uint64_t *gotplt = (uint64_t *)(f + gotplt_sh->sh_offset);
for (i = 0; i < count; i++) {
printf("%d: %#lx\n", i, *gotplt);
gotplt++;
}
}
munmap(f, buf.st_size);
close(fd);
return 0;
}
void txtout_output(const char* descr, iaddr from, iaddr to, uint8_t proto, unsigned flags,
unsigned sport, unsigned dport, my_bpftimeval ts,
const u_char* pkt_copy, unsigned olen,
const u_char* payload, unsigned payloadlen)
{
/*
* Short output, only print QTYPE and QNAME for IN records
*/
if (opt_s) {
if (flags & DNSCAP_OUTPUT_ISDNS) {
ns_msg msg;
int qdcount, err = 0;
ns_rr rr;
if (ns_initparse(payload, payloadlen, &msg) < 0) {
if (tcpstate_getcurr && tcpstate_reset)
tcpstate_reset(tcpstate_getcurr(), "");
return;
}
qdcount = ns_msg_count(msg, ns_s_qd);
if (qdcount > 0 && 0 == (err = ns_parserr(&msg, ns_s_qd, 0, &rr)) && ns_rr_class(rr) == 1) {
fprintf(out, "%s %s\n",
p_type(ns_rr_type(rr)),
ns_rr_name(rr));
}
if (err < 0) {
if (tcpstate_getcurr && tcpstate_reset)
tcpstate_reset(tcpstate_getcurr(), "");
}
}
return;
}
/*
* IP Stuff
*/
fprintf(out, "%10ld.%06ld", (long)ts.tv_sec, (long)ts.tv_usec);
fprintf(out, " %s %u", ia_str(from), sport);
fprintf(out, " %s %u", ia_str(to), dport);
fprintf(out, " %hhu", proto);
if (flags & DNSCAP_OUTPUT_ISDNS) {
ns_msg msg;
int qdcount, err = 0;
ns_rr rr;
if (ns_initparse(payload, payloadlen, &msg) < 0) {
if (tcpstate_getcurr && tcpstate_reset)
tcpstate_reset(tcpstate_getcurr(), "");
fprintf(out, "\n");
return;
}
/*
* DNS Header
*/
fprintf(out, " %u", ns_msg_id(msg));
fprintf(out, " %u", ns_msg_getflag(msg, ns_f_opcode));
fprintf(out, " %u", ns_msg_getflag(msg, ns_f_rcode));
fprintf(out, " |");
if (ns_msg_getflag(msg, ns_f_qr))
fprintf(out, "QR|");
if (ns_msg_getflag(msg, ns_f_aa))
fprintf(out, "AA|");
if (ns_msg_getflag(msg, ns_f_tc))
fprintf(out, "TC|");
if (ns_msg_getflag(msg, ns_f_rd))
fprintf(out, "RD|");
if (ns_msg_getflag(msg, ns_f_ra))
fprintf(out, "RA|");
if (ns_msg_getflag(msg, ns_f_ad))
fprintf(out, "AD|");
if (ns_msg_getflag(msg, ns_f_cd))
fprintf(out, "CD|");
qdcount = ns_msg_count(msg, ns_s_qd);
if (qdcount > 0 && 0 == (err = ns_parserr(&msg, ns_s_qd, 0, &rr))) {
fprintf(out, " %s %s %s",
p_class(ns_rr_class(rr)),
p_type(ns_rr_type(rr)),
ns_rr_name(rr));
}
if (err < 0) {
if (tcpstate_getcurr && tcpstate_reset)
tcpstate_reset(tcpstate_getcurr(), "");
}
}
/*
* Done
*/
fprintf(out, "\n");
}
/*
* Print resource record fields in human readable form.
*/
char *
p_rr(char *cp, char *msg, FILE *file)
{
int type, class, dlen, n, c;
struct in_addr inaddr;
char *cp1, *cp2;
if ((cp = p_cdname(cp, msg, file)) == NULL)
return (NULL); /* compression error */
fprintf(file,"\n\ttype = %s", p_type(type = _getshort(cp)));
cp += sizeof(u_short);
fprintf(file,", class = %s", p_class(class = _getshort(cp)));
cp += sizeof(u_short);
fprintf(file,", ttl = %s", p_time(_getlong(cp)));
cp += sizeof(u_long);
fprintf(file,", dlen = %d\n", dlen = _getshort(cp));
cp += sizeof(u_short);
cp1 = cp;
/*
* Print type specific data, if appropriate
*/
switch (type) {
case T_A:
switch (class) {
case C_IN:
case C_HS:
bcopy(cp, (char *)&inaddr, sizeof(inaddr));
if (dlen == 4) {
fprintf(file,"\tinternet address = %s\n",
inet_ntoa(inaddr));
cp += dlen;
} else if (dlen == 7) {
fprintf(file,"\tinternet address = %s",
inet_ntoa(inaddr));
fprintf(file,", protocol = %d", cp[4]);
fprintf(file,", port = %d\n",
(cp[5] << 8) + cp[6]);
cp += dlen;
}
break;
default:
cp += dlen;
}
break;
case T_CNAME:
case T_MB:
case T_MG:
case T_MR:
case T_NS:
case T_PTR:
fprintf(file,"\tdomain name = ");
cp = p_cdname(cp, msg, file);
fprintf(file,"\n");
break;
case T_HINFO:
if (n = *cp++) {
fprintf(file,"\tCPU=%.*s\n", n, cp);
cp += n;
}
if (n = *cp++) {
fprintf(file,"\tOS=%.*s\n", n, cp);
cp += n;
}
break;
case T_SOA:
fprintf(file,"\torigin = ");
cp = p_cdname(cp, msg, file);
fprintf(file,"\n\tmail addr = ");
cp = p_cdname(cp, msg, file);
fprintf(file,"\n\tserial = %ld", _getlong(cp));
cp += sizeof(u_long);
fprintf(file,"\n\trefresh = %s", p_time(_getlong(cp)));
cp += sizeof(u_long);
fprintf(file,"\n\tretry = %s", p_time(_getlong(cp)));
cp += sizeof(u_long);
fprintf(file,"\n\texpire = %s", p_time(_getlong(cp)));
cp += sizeof(u_long);
fprintf(file,"\n\tmin = %s\n", p_time(_getlong(cp)));
cp += sizeof(u_long);
break;
case T_MX:
fprintf(file,"\tpreference = %ld,",_getshort(cp));
cp += sizeof(u_short);
fprintf(file," name = ");
cp = p_cdname(cp, msg, file);
break;
case T_TXT:
(void) fputs("\t\"", file);
cp2 = cp1 + dlen;
while (cp < cp2) {
if (n = (unsigned char) *cp++) {
for (c = n; c > 0 && cp < cp2; c--)
if (*cp == '\n') {
(void) putc('\\', file);
(void) putc(*cp++, file);
} else
(void) putc(*cp++, file);
}
}
(void) fputs("\"\n", file);
break;
case T_MINFO:
fprintf(file,"\trequests = ");
cp = p_cdname(cp, msg, file);
fprintf(file,"\n\terrors = ");
cp = p_cdname(cp, msg, file);
break;
case T_UINFO:
fprintf(file,"\t%s\n", cp);
cp += dlen;
break;
case T_UID:
case T_GID:
if (dlen == 4) {
fprintf(file,"\t%ld\n", _getlong(cp));
cp += sizeof(int);
}
break;
case T_WKS:
if (dlen < sizeof(u_long) + 1)
break;
bcopy(cp, (char *)&inaddr, sizeof(inaddr));
cp += sizeof(u_long);
fprintf(file,"\tinternet address = %s, protocol = %d\n\t",
inet_ntoa(inaddr), *cp++);
n = 0;
while (cp < cp1 + dlen) {
c = *cp++;
do {
if (c & 0200)
fprintf(file," %d", n);
c <<= 1;
} while (++n & 07);
}
putc('\n',file);
break;
#ifdef ALLOW_T_UNSPEC
case T_UNSPEC:
{
int NumBytes = 8;
char *DataPtr;
int i;
if (dlen < NumBytes) NumBytes = dlen;
fprintf(file, "\tFirst %d bytes of hex data:",
NumBytes);
for (i = 0, DataPtr = cp; i < NumBytes; i++, DataPtr++)
fprintf(file, " %x", *DataPtr);
fputs("\n", file);
cp += dlen;
}
break;
#endif /* ALLOW_T_UNSPEC */
default:
fprintf(file,"\t???\n");
cp += dlen;
}
if (cp != cp1 + dlen) {
fprintf(file,"packet size error (%#x != %#x)\n", cp, cp1+dlen);
cp = NULL;
}
fprintf(file,"\n");
return (cp);
}
void
verify_next_assertion(val_context_t * ctx,
struct val_digested_auth_chain *as,
struct val_digested_auth_chain *the_trust,
u_int32_t flags)
{
struct rrset_rec *the_set;
struct rrset_rr *the_sig;
u_char *signby_name_n;
u_int16_t signby_footprint_n;
val_dnskey_rdata_t dnskey;
int is_a_wildcard;
struct rrset_rr *nextrr;
struct rrset_rr *keyrr;
u_int16_t tag_h;
char name_p[NS_MAXDNAME];
if ((as == NULL) || (as->val_ac_rrset.ac_data == NULL) || (the_trust == NULL)) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): Cannot verify assertion - no data");
return;
}
the_set = as->val_ac_rrset.ac_data;
dnskey.public_key = NULL;
if (-1 == ns_name_ntop(the_set->rrs_name_n, name_p, sizeof(name_p)))
snprintf(name_p, sizeof(name_p), "unknown/error");
if (the_set->rrs_sig == NULL) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): RRSIG is missing");
as->val_ac_status = VAL_AC_RRSIG_MISSING;
return;
}
if (the_set->rrs_type_h != ns_t_dnskey) {
/*
* trust path contains the key
*/
if (the_trust->val_ac_rrset.ac_data == NULL) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): Key is empty");
as->val_ac_status = VAL_AC_DNSKEY_MISSING;
return;
}
keyrr = the_trust->val_ac_rrset.ac_data->rrs_data;
} else {
/*
* data itself contains the key
*/
if (the_set->rrs_data == NULL) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): Key is empty");
as->val_ac_status = VAL_AC_DNSKEY_MISSING;
return;
}
keyrr = the_set->rrs_data;
}
for (the_sig = the_set->rrs_sig;
the_sig; the_sig = the_sig->rr_next) {
/*
* do wildcard processing
*/
if (!check_label_count(the_set, the_sig, &is_a_wildcard)) {
SET_STATUS(as->val_ac_status, the_sig,
VAL_AC_WRONG_LABEL_COUNT);
val_log(ctx, LOG_INFO, "verify_next_assertion(): Incorrect RRSIG label count");
continue;
}
/*
* for each sig, identify key,
*/
if (VAL_NO_ERROR != identify_key_from_sig(the_sig, &signby_name_n,
&signby_footprint_n)) {
SET_STATUS(as->val_ac_status, the_sig,
VAL_AC_INVALID_RRSIG);
val_log(ctx, LOG_INFO, "verify_next_assertion(): Cannot extract key footprint from RRSIG");
continue;
}
tag_h = ntohs(signby_footprint_n);
for (nextrr = keyrr; nextrr; nextrr = nextrr->rr_next) {
int is_verified = 0;
if (VAL_NO_ERROR != val_parse_dnskey_rdata(nextrr->rr_rdata,
nextrr->rr_rdata_length,
&dnskey)) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): Cannot parse DNSKEY data");
nextrr->rr_status = VAL_AC_INVALID_KEY;
continue;
}
dnskey.next = NULL;
if (dnskey.key_tag != tag_h) {
if (dnskey.public_key != NULL) {
FREE(dnskey.public_key);
dnskey.public_key = NULL;
}
continue;
}
val_log(ctx, LOG_DEBUG, "verify_next_assertion(): Found potential matching DNSKEY for RRSIG");
/*
* check the signature
*/
is_verified = do_verify(ctx, signby_name_n,
&nextrr->rr_status,
&the_sig->rr_status,
the_set, the_sig, &dnskey, is_a_wildcard, flags);
/*
* There might be multiple keys with the same key tag; set this as
* the signing key only if we dont have other status for this key
*/
SET_STATUS(as->val_ac_status, the_sig, the_sig->rr_status);
if (nextrr->rr_status == VAL_AC_UNSET) {
nextrr->rr_status = VAL_AC_SIGNING_KEY;
}
if (is_verified) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): Verified a RRSIG for %s (%s) using a DNSKEY (%d)",
name_p, p_type(the_set->rrs_type_h),
dnskey.key_tag);
if ( as->val_ac_status == VAL_AC_TRUST ||
nextrr->rr_status == VAL_AC_TRUST_POINT) {
/* we've verified a trust anchor */
as->val_ac_status = VAL_AC_TRUST;
val_log(ctx, LOG_INFO, "verify_next_assertion(): verification traces back to trust anchor");
if (dnskey.public_key != NULL) {
FREE(dnskey.public_key);
dnskey.public_key = NULL;
}
return;
}
/* Check if we're trying to verify some key in the authentication chain */
if ( the_set->rrs_type_h == ns_t_dnskey &&
as != the_trust) {
/* Check if we have reached our trust key */
/*
* If this record contains a DNSKEY, check if the DS record contains this key
* DNSKEYs cannot be wildcard expanded, so VAL_AC_WCARD_VERIFIED does not
* count as a good sig
* Create the link even if the DNSKEY algorithm is unknown since this
* may be the provably insecure case
*/
/*
* follow the trust path
*/
struct rrset_rr *dsrec =
the_trust->val_ac_rrset.ac_data->rrs_data;
while (dsrec) {
val_ds_rdata_t ds;
ds.d_hash = NULL;
int retval = val_parse_ds_rdata(dsrec->rr_rdata,
dsrec->rr_rdata_length, &ds);
if(retval == VAL_NOT_IMPLEMENTED) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): DS hash not supported");
dsrec->rr_status = VAL_AC_ALGORITHM_NOT_SUPPORTED;
} else if (retval != VAL_NO_ERROR) {
val_log(ctx, LOG_INFO, "verify_next_assertion(): DS parse error");
dsrec->rr_status = VAL_AC_INVALID_DS;
} else if (DNSKEY_MATCHES_DS(ctx, &dnskey, &ds,
the_set->rrs_name_n, nextrr,
&dsrec->rr_status)) {
val_log(ctx, LOG_DEBUG,
"verify_next_assertion(): DNSKEY tag (%d) matches DS tag (%d)",
(&dnskey)->key_tag,
(&ds)->d_keytag);
/*
* the first match is enough
*/
nextrr->rr_status = VAL_AC_VERIFIED_LINK;
FREE(ds.d_hash);
ds.d_hash = NULL;
if (dnskey.public_key) {
FREE(dnskey.public_key);
dnskey.public_key = NULL;
}
val_log(ctx, LOG_INFO, "verify_next_assertion(): Key links upward");
return;
} else {
/*
* Didn't find a valid entry in the DS record set
* Not necessarily a problem, since there is no requirement that a DS be present
* If none match, then we set the status accordingly. See below.
*/
nextrr->rr_status = VAL_AC_DS_NOMATCH;
}
if (ds.d_hash != NULL)
FREE(ds.d_hash);
dsrec = dsrec->rr_next;
}
}
}
if (dnskey.public_key != NULL) {
FREE(dnskey.public_key);
}
dnskey.public_key = NULL;
}
val_log(ctx, LOG_INFO, "verify_next_assertion(): Could not link this RRSIG to a DNSKEY");
SET_STATUS(as->val_ac_status, the_sig, VAL_AC_DNSKEY_NOMATCH);
}
/*
* If we reach here and we're a keyset, we either didn't verify the keyset or
* didn't verify the link from the key to the DS
*/
if (the_set->rrs_type_h == ns_t_dnskey){
as->val_ac_status = VAL_AC_NO_LINK;
}
}
static void
do_section(const res_state statp,
ns_msg *handle, ns_sect section,
int pflag, FILE *file)
{
int n, sflag, rrnum;
static int buflen = 2048;
char *buf;
ns_opcode opcode;
ns_rr rr;
/*
* Print answer records.
*/
sflag = (statp->pfcode & pflag);
if (statp->pfcode && !sflag)
return;
buf = malloc(buflen);
if (buf == NULL) {
fprintf(file, ";; memory allocation failure\n");
return;
}
opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
rrnum = 0;
for (;;) {
if (ns_parserr(handle, section, rrnum, &rr)) {
if (errno != ENODEV)
fprintf(file, ";; ns_parserr: %s\n",
strerror(errno));
else if (rrnum > 0 && sflag != 0 &&
(statp->pfcode & RES_PRF_HEAD1))
putc('\n', file);
goto cleanup;
}
if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
fprintf(file, ";; %s SECTION:\n",
p_section(section, opcode));
if (section == ns_s_qd)
fprintf(file, ";;\t%s, type = %s, class = %s\n",
ns_rr_name(rr),
p_type(ns_rr_type(rr)),
p_class(ns_rr_class(rr)));
else if (section == ns_s_ar && ns_rr_type(rr) == ns_t_opt) {
u_int16_t optcode, optlen, rdatalen = ns_rr_rdlen(rr);
u_int32_t ttl = ns_rr_ttl(rr);
fprintf(file,
"; EDNS: version: %u, udp=%u, flags=%04x\n",
(ttl>>16)&0xff, ns_rr_class(rr), ttl&0xffff);
while (rdatalen >= 4) {
const u_char *cp = ns_rr_rdata(rr);
int i;
GETSHORT(optcode, cp);
GETSHORT(optlen, cp);
if (optcode == NS_OPT_NSID) {
fputs("; NSID: ", file);
if (optlen == 0) {
fputs("; NSID\n", file);
} else {
fputs("; NSID: ", file);
for (i = 0; i < optlen; i++)
fprintf(file, "%02x ",
cp[i]);
fputs(" (",file);
for (i = 0; i < optlen; i++)
fprintf(file, "%c",
isprint(cp[i])?
cp[i] : '.');
fputs(")\n", file);
}
} else {
if (optlen == 0) {
fprintf(file, "; OPT=%u\n",
optcode);
} else {
fprintf(file, "; OPT=%u: ",
optcode);
for (i = 0; i < optlen; i++)
fprintf(file, "%02x ",
cp[i]);
fputs(" (",file);
for (i = 0; i < optlen; i++)
fprintf(file, "%c",
isprint(cp[i]) ?
cp[i] : '.');
fputs(")\n", file);
}
}
rdatalen -= 4 + optlen;
}
} else {
static int
printZone(ns_type xfr, const char *zone, const struct sockaddr_in *sin,
ns_tsig_key *key)
{
static u_char *answer = NULL;
static int answerLen = 0;
querybuf buf;
int msglen, amtToRead, numRead, result, sockFD, len;
int count, type, rlen, done, n;
int numAnswers, numRecords, soacnt;
u_char *cp, tmp[NS_INT16SZ];
char dname[2][NS_MAXDNAME];
enum { NO_ERRORS, ERR_READING_LEN, ERR_READING_MSG, ERR_PRINTING }
error;
pid_t zpid = -1;
u_char *newmsg;
int newmsglen;
ns_tcp_tsig_state tsig_state;
int tsig_ret, tsig_required, tsig_present;
switch (xfr) {
case ns_t_axfr:
case ns_t_zxfr:
break;
default:
fprintf(stderr, ";; %s - transfer type not supported\n",
p_type(xfr));
return (ERROR);
}
/*
* Create a query packet for the requested zone name.
*/
msglen = res_nmkquery(&res, ns_o_query, zone,
queryClass, ns_t_axfr, NULL,
0, 0, buf.qb2, sizeof buf);
if (msglen < 0) {
if (res.options & RES_DEBUG)
fprintf(stderr, ";; res_nmkquery failed\n");
return (ERROR);
}
/*
* Sign the message if a key was sent
*/
if (key == NULL) {
newmsg = (u_char *)&buf;
newmsglen = msglen;
} else {
DST_KEY *dstkey;
int bufsize, siglen;
u_char sig[64];
int ret;
/* ns_sign() also calls dst_init(), but there is no harm
* doing it twice
*/
dst_init();
bufsize = msglen + 1024;
newmsg = (u_char *) malloc(bufsize);
if (newmsg == NULL) {
errno = ENOMEM;
return (-1);
}
memcpy(newmsg, (u_char *)&buf, msglen);
newmsglen = msglen;
if (strcmp(key->alg, NS_TSIG_ALG_HMAC_MD5) != 0)
dstkey = NULL;
else
dstkey = dst_buffer_to_key(key->name, KEY_HMAC_MD5,
NS_KEY_TYPE_AUTH_ONLY,
NS_KEY_PROT_ANY,
key->data, key->len);
if (dstkey == NULL) {
errno = EINVAL;
if (key)
free(newmsg);
return (-1);
}
siglen = sizeof(sig);
/* newmsglen++; */
ret = ns_sign(newmsg, &newmsglen, bufsize, NOERROR, dstkey, NULL, 0,
sig, &siglen, 0);
if (ret < 0) {
if (key)
free (newmsg);
if (ret == NS_TSIG_ERROR_NO_SPACE)
errno = EMSGSIZE;
else if (ret == -1)
errno = EINVAL;
return (ret);
}
ns_verify_tcp_init(dstkey, sig, siglen, &tsig_state);
}
/*
* Set up a virtual circuit to the server.
*/
if ((sockFD = socket(sin->sin_family, SOCK_STREAM, 0)) < 0) {
int e = errno;
perror(";; socket");
return (e);
}
switch (sin->sin_family) {
case AF_INET:
if (bind(sockFD, (struct sockaddr *)&myaddress,
sizeof myaddress) < 0){
int e = errno;
fprintf(stderr, ";; bind(%s port %u): %s\n",
inet_ntoa(myaddress.sin_addr),
ntohs(myaddress.sin_port),
strerror(e));
(void) close(sockFD);
sockFD = -1;
return (e);
}
if (connect(sockFD, (const struct sockaddr *)sin,
sizeof *sin) < 0) {
int e = errno;
perror(";; connect");
(void) close(sockFD);
sockFD = -1;
return (e);
}
break;
case AF_INET6:
if (bind(sockFD, (struct sockaddr *)&myaddress6,
sizeof myaddress6) < 0){
int e = errno;
char buf[80];
fprintf(stderr, ";; bind(%s port %u): %s\n",
inet_ntop(AF_INET6, &myaddress6.sin6_addr,
buf, sizeof(buf)),
ntohs(myaddress6.sin6_port),
strerror(e));
(void) close(sockFD);
sockFD = -1;
return (e);
}
if (connect(sockFD, (const struct sockaddr *)sin,
sizeof(struct sockaddr_in6)) < 0) {
int e = errno;
perror(";; connect");
(void) close(sockFD);
sockFD = -1;
return (e);
}
break;
}
/*
* Send length & message for zone transfer
*/
ns_put16(newmsglen, tmp);
if (write(sockFD, (char *)tmp, NS_INT16SZ) != NS_INT16SZ ||
write(sockFD, (char *)newmsg, newmsglen) != newmsglen) {
int e = errno;
if (key)
free (newmsg);
perror(";; write");
(void) close(sockFD);
sockFD = -1;
return (e);
} else if (key)
free (newmsg);
/*
* If we're compressing, push a gzip into the pipeline.
*/
if (xfr == ns_t_zxfr) {
enum { rd = 0, wr = 1 };
int z[2];
if (pipe(z) < 0) {
int e = errno;
perror(";; pipe");
(void) close(sockFD);
sockFD = -1;
return (e);
}
zpid = vfork();
if (zpid < 0) {
int e = errno;
perror(";; fork");
(void) close(sockFD);
sockFD = -1;
return (e);
} else if (zpid == 0) {
/* Child. */
(void) close(z[rd]);
(void) dup2(sockFD, STDIN_FILENO);
(void) close(sockFD);
(void) dup2(z[wr], STDOUT_FILENO);
(void) close(z[wr]);
execlp("gzip", "gzip", "-d", "-v", NULL);
perror(";; child: execlp(gunzip)");
_exit(1);
}
/* Parent. */
(void) close(z[wr]);
(void) dup2(z[rd], sockFD);
(void) close(z[rd]);
}
result = 0;
numAnswers = 0;
numRecords = 0;
soacnt = 0;
error = NO_ERRORS;
numRead = 0;
dname[0][0] = '\0';
for (done = 0; !done; (void)NULL) {
/*
* Read the length of the response.
*/
cp = tmp;
amtToRead = INT16SZ;
while (amtToRead > 0 &&
(numRead = read(sockFD, cp, amtToRead)) > 0) {
cp += numRead;
amtToRead -= numRead;
}
if (numRead <= 0) {
error = ERR_READING_LEN;
break;
}
len = ns_get16(tmp);
if (len == 0)
break; /* nothing left to read */
/*
* The server sent too much data to fit the existing buffer --
* allocate a new one.
*/
if (len > answerLen) {
if (answerLen != 0)
free(answer);
answerLen = len;
answer = (u_char *)malloc(answerLen);
}
/*
* Read the response.
*/
amtToRead = len;
cp = answer;
while (amtToRead > 0 &&
(numRead = read(sockFD, cp, amtToRead)) > 0) {
cp += numRead;
amtToRead -= numRead;
}
if (numRead <= 0) {
error = ERR_READING_MSG;
break;
}
result = print_axfr(stdout, answer, len);
if (result != 0) {
error = ERR_PRINTING;
break;
}
numRecords += htons(((HEADER *)answer)->ancount);
numAnswers++;
/* Header. */
cp = answer + HFIXEDSZ;
/* Question. */
for (count = ntohs(((HEADER *)answer)->qdcount);
count > 0;
count--) {
n = dn_skipname(cp, answer + len);
if (n < 0) {
error = ERR_PRINTING;
done++;
break;
}
cp += n + QFIXEDSZ;
if (cp > answer + len) {
error = ERR_PRINTING;
done++;
break;
}
}
/* Answer. */
for (count = ntohs(((HEADER *)answer)->ancount);
count > 0 && !done;
count--) {
n = dn_expand(answer, answer + len, cp,
dname[soacnt], sizeof dname[0]);
if (n < 0) {
error = ERR_PRINTING;
done++;
break;
}
cp += n;
if (cp + 3 * INT16SZ + INT32SZ > answer + len) {
error = ERR_PRINTING;
done++;
break;
}
GETSHORT(type, cp);
cp += INT16SZ;
cp += INT32SZ; /* ttl */
GETSHORT(rlen, cp);
cp += rlen;
if (cp > answer + len) {
error = ERR_PRINTING;
done++;
break;
}
if (type == T_SOA && soacnt++ &&
ns_samename(dname[0], dname[1]) == 1) {
done++;
break;
}
}
/*
* Verify the TSIG
*/
if (key) {
if (ns_find_tsig(answer, answer + len) != NULL)
tsig_present = 1;
else
tsig_present = 0;
if (numAnswers == 1 || soacnt > 1)
tsig_required = 1;
else
tsig_required = 0;
tsig_ret = ns_verify_tcp(answer, &len, &tsig_state,
tsig_required);
if (tsig_ret == 0) {
if (tsig_present)
printf("; TSIG ok\n");
}
else
printf("; TSIG invalid\n");
}
}
printf(";; Received %d answer%s (%d record%s).\n",
numAnswers, (numAnswers != 1) ? "s" : "",
numRecords, (numRecords != 1) ? "s" : "");
(void) close(sockFD);
sockFD = -1;
/*
* If we were uncompressing, reap the uncompressor.
*/
if (xfr == ns_t_zxfr) {
pid_t pid;
int status = 0;
pid = wait(&status);
if (pid < 0) {
int e = errno;
perror(";; wait");
return (e);
}
if (pid != zpid) {
fprintf(stderr, ";; wrong pid (%lu != %lu)\n",
(u_long)pid, (u_long)zpid);
return (ERROR);
}
printf(";; pid %lu: exit %d, signal %d, core %c\n",
(u_long)pid, WEXITSTATUS(status),
WIFSIGNALED(status) ? WTERMSIG(status) : 0,
WCOREDUMP(status) ? 't' : 'f');
}
switch (error) {
case NO_ERRORS:
return (0);
case ERR_READING_LEN:
return (EMSGSIZE);
case ERR_PRINTING:
return (result);
case ERR_READING_MSG:
return (EMSGSIZE);
default:
return (EFAULT);
}
}
/*
* Print the contents of a query.
* This is intended to be primarily a debugging routine.
*/
void
fp_query(char *msg, FILE *file)
{
register char *cp;
register HEADER *hp;
register int n;
/*
* Print header fields.
*/
hp = (HEADER *)msg;
cp = msg + sizeof(HEADER);
fprintf(file,"HEADER:\n");
fprintf(file,"\topcode = %s", _res_opcodes[hp->opcode]);
fprintf(file,", id = %d", ntohs(hp->id));
fprintf(file,", rcode = %s\n", _res_resultcodes[hp->rcode]);
fprintf(file,"\theader flags: ");
if (hp->qr)
fprintf(file," qr");
if (hp->aa)
fprintf(file," aa");
if (hp->tc)
fprintf(file," tc");
if (hp->rd)
fprintf(file," rd");
if (hp->ra)
fprintf(file," ra");
if (hp->pr)
fprintf(file," pr");
fprintf(file,"\n\tqdcount = %d", ntohs(hp->qdcount));
fprintf(file,", ancount = %d", ntohs(hp->ancount));
fprintf(file,", nscount = %d", ntohs(hp->nscount));
fprintf(file,", arcount = %d\n\n", ntohs(hp->arcount));
/*
* Print question records.
*/
if (n = ntohs(hp->qdcount)) {
fprintf(file,"QUESTIONS:\n");
while (--n >= 0) {
fprintf(file,"\t");
cp = p_cdname(cp, msg, file);
if (cp == NULL)
return;
fprintf(file,", type = %s", p_type(_getshort(cp)));
cp += sizeof(u_short);
fprintf(file,", class = %s\n\n", p_class(_getshort(cp)));
cp += sizeof(u_short);
}
}
/*
* Print authoritative answer records
*/
if (n = ntohs(hp->ancount)) {
fprintf(file,"ANSWERS:\n");
while (--n >= 0) {
fprintf(file,"\t");
cp = p_rr(cp, msg, file);
if (cp == NULL)
return;
}
}
/*
* print name server records
*/
if (n = ntohs(hp->nscount)) {
fprintf(file,"NAME SERVERS:\n");
while (--n >= 0) {
fprintf(file,"\t");
cp = p_rr(cp, msg, file);
if (cp == NULL)
return;
}
}
/*
* print additional records
*/
if (n = ntohs(hp->arcount)) {
fprintf(file,"ADDITIONAL RECORDS:\n");
while (--n >= 0) {
fprintf(file,"\t");
cp = p_rr(cp, msg, file);
if (cp == NULL)
return;
}
}
}
