INLINE void ldns_dnssec_name_free_internal(ldns_dnssec_name *name, int deep) { if (name) { if (name->name_alloced) { ldns_rdf_deep_free(name->name); } if (name->rrsets) { ldns_dnssec_rrsets_free_internal(name->rrsets, deep); } if (name->nsec && deep) { ldns_rr_free(name->nsec); } if (name->nsec_signatures) { ldns_dnssec_rrs_free_internal(name->nsec_signatures, deep); } if (name->hashed_name) { if (deep) { ldns_rdf_deep_free(name->hashed_name); } } LDNS_FREE(name); } }
static ldns_rbnode_t * ldns_dnssec_zone_find_nsec3_original(ldns_dnssec_zone *zone, ldns_rr *rr) { ldns_rbnode_t *current_node = ldns_rbtree_first(zone->names); ldns_dnssec_name *current_name; ldns_rdf *hashed_name; hashed_name = ldns_dname_label(ldns_rr_owner(rr), 0); while (current_node != LDNS_RBTREE_NULL) { current_name = (ldns_dnssec_name *) current_node->data; if (!current_name->hashed_name) { current_name->hashed_name = ldns_nsec3_hash_name_frm_nsec3(rr, current_name->name); } if (ldns_dname_compare(hashed_name, current_name->hashed_name) == 0) { ldns_rdf_deep_free(hashed_name); return current_node; } current_node = ldns_rbtree_next(current_node); } ldns_rdf_deep_free(hashed_name); return NULL; }
/* reads the canned reply file and returns a list of structs */ struct entry* read_datafile(const char* name) { struct entry* list = NULL; struct entry* last = NULL; struct entry* current = NULL; FILE *in; int lineno = 0; uint32_t default_ttl = 0; ldns_rdf* origin = NULL; ldns_rdf* prev_rr = NULL; int entry_num = 0; if((in=fopen(name, "r")) == NULL) { error("could not open file %s: %s", name, strerror(errno)); } while((current = read_entry(in, name, &lineno, &default_ttl, &origin, &prev_rr))) { if(last) last->next = current; else list = current; last = current; entry_num ++; } verbose(1, "%s: Read %d entries\n", prog_name, entry_num); fclose(in); ldns_rdf_deep_free(origin); ldns_rdf_deep_free(prev_rr); return list; }
struct zversion_t* zversion_read(struct zone_entry_t* entry, uint32_t serial) { const char* fn = zinfo_ixfr_name(entry, serial); struct zversion_t* v; FILE* in = fopen(fn, "ra"); ldns_status status; ldns_rr* rr = 0; uint32_t dttl = 3600; ldns_rdf* origin = 0, *prev = 0; int line_nr = 1; if(!in) { perror(fn); return NULL; } v = (struct zversion_t*)calloc(1, sizeof(*v)); if(!v) { fclose(in); printf("out of memory\n"); return NULL; } v->serial = serial; v->ixfr = ldns_rr_list_new(); while(!feof(in)) { status = ldns_rr_new_frm_fp_l(&rr, in, &dttl, &origin, &prev, &line_nr); if(status == LDNS_STATUS_SYNTAX_TTL || status == LDNS_STATUS_SYNTAX_ORIGIN || status == LDNS_STATUS_SYNTAX_EMPTY) continue; if(status != LDNS_STATUS_OK) { printf("error %s:%d: %s\n", fn, line_nr, ldns_get_errorstr_by_id(status)); fclose(in); ldns_rdf_deep_free(origin); ldns_rdf_deep_free(prev); ldns_rr_list_deep_free(v->ixfr); free(v); return NULL; } ldns_rr_list_push_rr(v->ixfr, rr); } ldns_rdf_deep_free(origin); ldns_rdf_deep_free(prev); fclose(in); if(ldns_rr_list_rr_count(v->ixfr) < 1 || ldns_rr_get_type(ldns_rr_list_rr(v->ixfr, 0)) != LDNS_RR_TYPE_SOA) { printf("invalid IXFR format in %s\n", fn); ldns_rr_list_deep_free(v->ixfr); free(v); return NULL; } v->next_serial = ldns_rdf2native_int32(ldns_rr_rdf( ldns_rr_list_rr(v->ixfr, 0), 2)); return v; }
void zdomain_delete(struct zdomain_t* d) { if(!d) return; ldns_traverse_postorder(&d->rrsets, del_rrset, NULL); ldns_rdf_deep_free(d->name); free(d); }
/** dump message to rrset reference */ static int dump_msg_ref(SSL* ssl, struct ub_packed_rrset_key* k) { ldns_rdf* rdf; ldns_status status; size_t pos; char* nm, *tp, *cl; pos = 0; status = ldns_wire2dname(&rdf, k->rk.dname, k->rk.dname_len, &pos); if(status != LDNS_STATUS_OK) { return ssl_printf(ssl, "BADREF\n"); } nm = ldns_rdf2str(rdf); ldns_rdf_deep_free(rdf); tp = ldns_rr_type2str(ntohs(k->rk.type)); cl = ldns_rr_class2str(ntohs(k->rk.rrset_class)); if(!nm || !cl || !tp) { free(nm); free(tp); free(cl); return ssl_printf(ssl, "BADREF\n"); } if(!ssl_printf(ssl, "%s %s %s %d\n", nm, cl, tp, (int)k->rk.flags)) { free(nm); free(tp); free(cl); return 0; } free(nm); free(tp); free(cl); return 1; }
/* special case were there was a wildcard expansion match, the exact match must be disproven */ ldns_status ldns_verify_denial_wildcard(ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type, ldns_rr_list **nsec_rrs, ldns_rr_list **nsec_rr_sigs) { ldns_rdf *nsec3_ce = NULL; ldns_rr *nsec3_ex = NULL; ldns_rdf *wildcard_name = NULL; ldns_rdf *nsec3_wc_ce = NULL; ldns_rr *nsec3_wc_ex = NULL; ldns_rdf *chopped_dname = NULL; ldns_rr_list *nsecs; ldns_status result = LDNS_STATUS_ERR; nsecs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_NSEC3, LDNS_SECTION_ANY_NOQUESTION); if (nsecs) { wildcard_name = ldns_dname_new_frm_str("*"); chopped_dname = ldns_dname_left_chop(name); result = ldns_dname_cat(wildcard_name, chopped_dname); ldns_rdf_deep_free(chopped_dname); nsec3_ex = ldns_nsec3_exact_match(name, type, nsecs); nsec3_ce = ldns_nsec3_closest_encloser(name, type, nsecs); nsec3_wc_ce = ldns_nsec3_closest_encloser(wildcard_name, type, nsecs); nsec3_wc_ex = ldns_nsec3_exact_match(wildcard_name, type, nsecs); if (nsec3_ex) { if (verbosity >= 3) { printf(";; Error, exact match for for name found, but should not exist (draft -07 section 8.8)\n"); } result = LDNS_STATUS_NSEC3_ERR; } else if (!nsec3_ce) { if (verbosity >= 3) { printf(";; Error, closest encloser for exact match missing in wildcard response (draft -07 section 8.8)\n"); } result = LDNS_STATUS_NSEC3_ERR; /* } else if (!nsec3_wc_ex) { printf(";; Error, no wildcard nsec3 match: "); ldns_rdf_print(stdout, wildcard_name); printf(" (draft -07 section 8.8)\n"); result = LDNS_STATUS_NSEC3_ERR; */ /* } else if (!nsec */ } else { if (verbosity >= 3) { printf(";; wilcard expansion proven\n"); } result = LDNS_STATUS_OK; } } else { if (verbosity >= 3) { printf(";; Error: no NSEC or NSEC3 records in answer\n"); } result = LDNS_STATUS_CRYPTO_NO_RRSIG; } if (nsecs && nsec_rrs && nsec_rr_sigs) { (void) get_dnssec_rr(pkt, ldns_rr_owner(ldns_rr_list_rr(nsecs, 0)), LDNS_RR_TYPE_NSEC3, nsec_rrs, nsec_rr_sigs); } return result; }
/** * Clean up zone. * */ void zone_cleanup(zone_type* zone) { allocator_type* allocator; lock_basic_type zone_lock; lock_basic_type xfr_lock; if (!zone) { return; } allocator = zone->allocator; zone_lock = zone->zone_lock; xfr_lock = zone->xfr_lock; ldns_rdf_deep_free(zone->apex); adapter_cleanup(zone->adinbound); adapter_cleanup(zone->adoutbound); namedb_cleanup(zone->db); ixfr_cleanup(zone->ixfr); xfrd_cleanup(zone->xfrd); notify_cleanup(zone->notify); signconf_cleanup(zone->signconf); stats_cleanup(zone->stats); allocator_deallocate(allocator, (void*) zone->notify_command); allocator_deallocate(allocator, (void*) zone->notify_args); allocator_deallocate(allocator, (void*) zone->policy_name); allocator_deallocate(allocator, (void*) zone->signconf_filename); allocator_deallocate(allocator, (void*) zone->name); allocator_deallocate(allocator, (void*) zone); allocator_cleanup(allocator); lock_basic_destroy(&xfr_lock); lock_basic_destroy(&zone_lock); return; }
ldns_rr_list* loadKeyfile(const char *filename) { FILE *key_file; ldns_status status; ldns_rr_list *trusted_keys; ldns_zone *trusted_zone; // Try open trusted key file key_file = fopen(filename, "r"); if (!key_file) { if (mp_verbose >= 1) fprintf(stderr,"Error opening trusted-key file %s: %s\n", filename, strerror(errno)); return NULL; } ldns_rdf *origin = ldns_dname_new_frm_str("."); // Read key file status = ldns_zone_new_frm_fp(&trusted_zone, key_file, origin, 900, LDNS_RR_CLASS_IN); ldns_rdf_deep_free(origin); fclose(key_file); if (status == LDNS_STATUS_OK) { trusted_keys = ldns_rr_list_clone(ldns_zone_rrs(trusted_zone)); ldns_zone_deep_free(trusted_zone); } else { if (mp_verbose >= 1) fprintf(stderr,"loading keyfile failed."); return NULL; } return trusted_keys; }
/** * Update serial. * */ ods_status zone_update_serial(zone_type* zone) { ods_status status = ODS_STATUS_OK; rrset_type* rrset = NULL; rr_type* soa = NULL; ldns_rr* rr = NULL; ldns_rdf* soa_rdata = NULL; ods_log_assert(zone); ods_log_assert(zone->apex); ods_log_assert(zone->name); ods_log_assert(zone->db); ods_log_assert(zone->signconf); if (zone->db->serial_updated) { /* already done, unmark and return ok */ ods_log_debug("[%s] zone %s soa serial already up to date", zone_str, zone->name); zone->db->serial_updated = 0; return ODS_STATUS_OK; } rrset = zone_lookup_rrset(zone, zone->apex, LDNS_RR_TYPE_SOA); ods_log_assert(rrset); ods_log_assert(rrset->rrs); ods_log_assert(rrset->rrs[0].rr); rr = ldns_rr_clone(rrset->rrs[0].rr); if (!rr) { ods_log_error("[%s] unable to update zone %s soa serial: failed to " "clone soa rr", zone_str, zone->name); return ODS_STATUS_ERR; } status = namedb_update_serial(zone->db, zone->signconf->soa_serial, zone->db->inbserial); if (status != ODS_STATUS_OK) { ods_log_error("[%s] unable to update zone %s soa serial: %s", zone_str, zone->name, ods_status2str(status)); ldns_rr_free(rr); return status; } ods_log_verbose("[%s] zone %s set soa serial to %u", zone_str, zone->name, zone->db->intserial); soa_rdata = ldns_rr_set_rdf(rr, ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, zone->db->intserial), SE_SOA_RDATA_SERIAL); if (soa_rdata) { ldns_rdf_deep_free(soa_rdata); soa_rdata = NULL; } else { ods_log_error("[%s] unable to update zone %s soa serial: failed to " "replace soa serial rdata", zone_str, zone->name); ldns_rr_free(rr); return ODS_STATUS_ERR; } soa = rrset_add_rr(rrset, rr); ods_log_assert(soa); rrset_diff(rrset, 0, 0); zone->db->serial_updated = 0; return ODS_STATUS_OK; }
/** setup qinfo and edns */ static int setup_qinfo_edns(struct libworker* w, struct ctx_query* q, struct query_info* qinfo, struct edns_data* edns) { ldns_rdf* rdf; qinfo->qtype = (uint16_t)q->res->qtype; qinfo->qclass = (uint16_t)q->res->qclass; rdf = ldns_dname_new_frm_str(q->res->qname); if(!rdf) { return 0; } #ifdef UNBOUND_ALLOC_LITE qinfo->qname = memdup(ldns_rdf_data(rdf), ldns_rdf_size(rdf)); qinfo->qname_len = ldns_rdf_size(rdf); ldns_rdf_deep_free(rdf); rdf = 0; #else qinfo->qname = ldns_rdf_data(rdf); qinfo->qname_len = ldns_rdf_size(rdf); #endif edns->edns_present = 1; edns->ext_rcode = 0; edns->edns_version = 0; edns->bits = EDNS_DO; if(ldns_buffer_capacity(w->back->udp_buff) < 65535) edns->udp_size = (uint16_t)ldns_buffer_capacity( w->back->udp_buff); else edns->udp_size = 65535; ldns_rdf_free(rdf); return 1; }
ldns_rr_list* mrb_getrr_list(mrb_state *mrb, ldns_resolver *resolver, char *name, uint32_t rrtype,uint32_t rrclass, uint32_t opt, uint32_t rrsection) { ldns_pkt *pkt = NULL; ldns_rr_list *records= NULL; ldns_rdf *domain = NULL; domain = ldns_dname_new_frm_str(name); if(!domain) { return NULL; } pkt = ldns_resolver_query(resolver, domain, rrtype, rrclass, opt); ldns_rdf_deep_free(domain); if(!pkt) { return NULL; } records =ldns_pkt_rr_list_by_type(pkt, rrtype, rrsection); ldns_pkt_free(pkt); if(!records) { return NULL; } return records; }
ldns_rr_list *mrb_getaddress_rr_list(mrb_state *mrb, ldns_resolver *resolver, char *name) { ldns_pkt *pkt = NULL; ldns_rr_list *records= NULL; ldns_rdf *domain = NULL; domain = ldns_dname_new_frm_str(name); if(!domain) { return NULL; } pkt = ldns_resolver_query(resolver, domain, LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN, LDNS_RD); ldns_rdf_deep_free(domain); if(!pkt) { return NULL; } records =ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_A, LDNS_SECTION_ANSWER); ldns_pkt_free(pkt); if(!records) { return NULL; } return records; }
ldns_status ldns_resolver_new_default(ldns_resolver **res) { ldns_resolver *r; ldns_rdf *tmp; HKEY hKey; DWORD data_sz; char* buf; char* addr; RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters", 0, KEY_QUERY_VALUE, &hKey); RegQueryValueEx(hKey, "DhcpNameServer", NULL, NULL, NULL, &data_sz); buf = (char*)malloc(data_sz + 1); RegQueryValueEx(hKey, "DhcpNameServer", NULL, NULL, (LPBYTE)buf, &data_sz); RegCloseKey(hKey); if(buf[data_sz - 1] != 0) { buf[data_sz] = 0; } r = ldns_resolver_new(); if(!r) { free(buf); return LDNS_STATUS_MEM_ERR; } addr = strtok(buf, " "); while(addr != NULL) { tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, addr); if (!tmp) { // try ip4 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, addr); } // could not parse it, exit if (!tmp) { ldns_resolver_deep_free(r); free(buf); return LDNS_STATUS_SYNTAX_ERR; } (void)ldns_resolver_push_nameserver(r, tmp); ldns_rdf_deep_free(tmp); addr = strtok(NULL, " "); } free(buf); if(res) { *res = r; return LDNS_STATUS_OK; } else { return LDNS_STATUS_NULL; } }
void ldns_resolver_deep_free(ldns_resolver *res) { size_t i; if (res) { if (res->_searchlist) { for (i = 0; i < ldns_resolver_searchlist_count(res); i++) { ldns_rdf_deep_free(res->_searchlist[i]); } LDNS_FREE(res->_searchlist); } if (res->_nameservers) { for (i = 0; i < res->_nameserver_count; i++) { ldns_rdf_deep_free(res->_nameservers[i]); } LDNS_FREE(res->_nameservers); } if (ldns_resolver_domain(res)) { ldns_rdf_deep_free(ldns_resolver_domain(res)); } if (res->_tsig_keyname) { LDNS_FREE(res->_tsig_keyname); } if (res->_tsig_keydata) { LDNS_FREE(res->_tsig_keydata); } if (res->_tsig_algorithm) { LDNS_FREE(res->_tsig_algorithm); } if (res->_cur_axfr_pkt) { ldns_pkt_free(res->_cur_axfr_pkt); } if (res->_rtt) { LDNS_FREE(res->_rtt); } if (res->_dnssec_anchors) { ldns_rr_list_deep_free(res->_dnssec_anchors); } LDNS_FREE(res); } }
/** add hint to delegation hints */ static int ah(struct delegpt* dp, const char* sv, const char* ip) { struct sockaddr_storage addr; socklen_t addrlen; ldns_rdf* rdf = ldns_dname_new_frm_str(sv); if(!rdf) { log_err("could not parse %s", sv); return 0; } if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0) || !extstrtoaddr(ip, &addr, &addrlen) || !delegpt_add_target_mlc(dp, ldns_rdf_data(rdf), ldns_rdf_size(rdf), &addr, addrlen, 0, 0)) { ldns_rdf_deep_free(rdf); return 0; } ldns_rdf_deep_free(rdf); return 1; }
/** make NULL entries for stubs */ static int make_stub_holes(struct iter_forwards* fwd, struct config_file* cfg) { struct config_stub* s; for(s = cfg->stubs; s; s = s->next) { ldns_rdf* rdf = ldns_dname_new_frm_str(s->name); if(!rdf) { log_err("cannot parse stub name '%s'", s->name); return 0; } if(!fwd_add_stub_hole(fwd, LDNS_RR_CLASS_IN, ldns_rdf_data(rdf))) { ldns_rdf_deep_free(rdf); log_err("out of memory"); return 0; } ldns_rdf_deep_free(rdf); } return 1; }
/** * set a specific rdf * \param[in] type type of RR * \param[in] rr the rr itself * \param[in] rdf the rdf to set * \param[in] pos at which postion to set it * \return true or false */ static bool ldns_rr_set_function(ldns_rr_type type, ldns_rr *rr, ldns_rdf *rdf, size_t pos) { ldns_rdf *pop; if (!rr || ldns_rr_get_type(rr) != type) { return false; } pop = ldns_rr_set_rdf(rr, rdf, pos); ldns_rdf_deep_free(pop); return true; }
void zonefile_destroy(struct zonefile **z) { if (*z) { if ((*z)->fp) { if ((*z)->is_pipe) pclose((*z)->fp); else fclose((*z)->fp); } if ((*z)->origin) ldns_rdf_deep_free((*z)->origin); if ((*z)->prev) ldns_rdf_deep_free((*z)->prev); if ((*z)->domain) ldns_rdf_deep_free((*z)->domain); if ((*z)->rr_soa) ldns_rr_free((*z)->rr_soa); free(*z); *z = NULL; } }
/** set stub host names */ static int read_stubs_host(struct config_stub* s, struct delegpt* dp) { struct config_strlist* p; ldns_rdf* rdf; for(p = s->hosts; p; p = p->next) { log_assert(p->str); rdf = ldns_dname_new_frm_str(p->str); if(!rdf) { log_err("cannot parse stub %s nameserver name: '%s'", s->name, p->str); return 0; } if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0)) { ldns_rdf_deep_free(rdf); log_err("out of memory"); return 0; } ldns_rdf_deep_free(rdf); } return 1; }
/** set stub name */ static struct delegpt* read_stubs_name(struct config_stub* s) { struct delegpt* dp; ldns_rdf* rdf; if(!s->name) { log_err("stub zone without a name"); return NULL; } rdf = ldns_dname_new_frm_str(s->name); if(!rdf) { log_err("cannot parse stub zone name %s", s->name); return NULL; } if(!(dp=delegpt_create_mlc(ldns_rdf_data(rdf)))) { ldns_rdf_deep_free(rdf); log_err("out of memory"); return NULL; } ldns_rdf_deep_free(rdf); return dp; }
/** * Insert insecure anchor * @param anchors: anchor storage. * @param str: the domain name. * @return NULL on error, Else last trust anchor point */ static struct trust_anchor* anchor_insert_insecure(struct val_anchors* anchors, const char* str) { struct trust_anchor* ta; ldns_rdf* nm = ldns_dname_new_frm_str(str); if(!nm) { log_err("parse error in domain name '%s'", str); return NULL; } ta = anchor_store_new_key(anchors, ldns_rdf_data(nm), LDNS_RR_TYPE_DS, LDNS_RR_CLASS_IN, NULL, 0); ldns_rdf_deep_free(nm); return ta; }
/** process nsec3 params and perform hashing */ static void process_nsec3(int argc, char* argv[]) { char line[10240]; ldns_rdf* salt; ldns_rdf* in, *out; ldns_status status; status = ldns_str2rdf_nsec3_salt(&salt, argv[5]); if(status != LDNS_STATUS_OK) fatal_exit("Could not parse salt %s: %s", argv[5], ldns_get_errorstr_by_id(status)); log_assert(argc == 6); while(fgets(line, (int)sizeof(line), stdin)) { if(strlen(line) > 0) line[strlen(line)-1] = 0; /* remove trailing newline */ if(line[0]==0) continue; status = ldns_str2rdf_dname(&in, line); if(status != LDNS_STATUS_OK) fatal_exit("Could not parse name %s: %s", line, ldns_get_errorstr_by_id(status)); ldns_rdf_print(stdout, in); printf(" -> "); /* arg 3 is flags, unused */ out = ldns_nsec3_hash_name(in, (uint8_t)atoi(argv[2]), (uint16_t)atoi(argv[4]), ldns_rdf_data(salt)[0], ldns_rdf_data(salt)+1); if(!out) fatal_exit("Could not hash %s", line); ldns_rdf_print(stdout, out); printf("\n"); ldns_rdf_deep_free(in); ldns_rdf_deep_free(out); } ldns_rdf_deep_free(salt); }
ldns_status ldns_dnssec_zone_mark_glue(ldns_dnssec_zone *zone) { ldns_rbnode_t *cur_node; ldns_dnssec_name *cur_name; ldns_rdf *cur_owner, *cur_parent; cur_node = ldns_rbtree_first(zone->names); while (cur_node != LDNS_RBTREE_NULL) { cur_name = (ldns_dnssec_name *) cur_node->data; cur_node = ldns_rbtree_next(cur_node); if (ldns_dnssec_name_has_only_a(cur_name)) { /* assume glue XXX check for zone cur */ cur_owner = ldns_rdf_clone(ldns_rr_owner( cur_name->rrsets->rrs->rr)); while (ldns_dname_label_count(cur_owner) > ldns_dname_label_count(zone->soa->name)) { if (ldns_dnssec_zone_find_rrset(zone, cur_owner, LDNS_RR_TYPE_NS)) { /* fprintf(stderr, "[XX] Marking as glue: "); ldns_rdf_print(stderr, cur_name->name); fprintf(stderr, "\n"); */ cur_name->is_glue = true; } cur_parent = ldns_dname_left_chop(cur_owner); ldns_rdf_deep_free(cur_owner); cur_owner = cur_parent; } ldns_rdf_deep_free(cur_owner); } } return LDNS_STATUS_OK; }
ldns_rr_list *mrb_getname_rr_list(mrb_state *mrb, ldns_resolver *resolver,char *addr) { char *rev = NULL, *query = NULL; const char *arpa = "in-addr.arpa"; ldns_rdf *domain = NULL ; ldns_pkt *pkt = NULL; ldns_rr_list *records = NULL; rev = reverse_addr(addr); if(!rev) { return NULL; } query = (char *)malloc( strlen(rev) + strlen(arpa) + sizeof(char) * 4); strcpy(query, rev); strcat(query,"."); strcat(query,arpa); domain = ldns_dname_new_frm_str(query); free(query); if(!domain) { return NULL; } pkt = ldns_resolver_query(resolver, domain, LDNS_RR_TYPE_PTR, LDNS_RR_CLASS_IN, LDNS_RD); ldns_rdf_deep_free(domain); if(!pkt) { return NULL; } records = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_PTR, LDNS_RR_CLASS_IN); ldns_pkt_free(pkt); if(!records) { return NULL; } return records; }
static ldns_rbnode_t * ldns_dnssec_zone_find_nsec3_original(ldns_dnssec_zone *zone, ldns_rr *rr) { ldns_rdf *hashed_name; hashed_name = ldns_dname_label(ldns_rr_owner(rr), 0); if (hashed_name == NULL) { return NULL; } if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_NSEC3 && ! zone->_nsec3params){ ldns_dnssec_zone_hashed_names_from_nsec3(zone, rr); } if (zone->hashed_names == NULL) { ldns_rdf_deep_free(hashed_name); return NULL; } return ldns_rbtree_search(zone->hashed_names, hashed_name); }
ldns_resolver* createResolver(const char *dnsserver) { ldns_resolver *res = NULL; ldns_status status; ldns_rdf *ns_rdf; if (dnsserver) { // Use the given DNS server res = ldns_resolver_new(); if (!res) return NULL; // Create rdf from dnsserver ns_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, dnsserver); #ifdef USE_IPV6 if (!ns_rdf) ns_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, dnsserver); #endif if (!ns_rdf) { ldns_resolver_deep_free(res); return NULL; } else { status = ldns_resolver_push_nameserver(res, ns_rdf); ldns_rdf_deep_free(ns_rdf); if (status != LDNS_STATUS_OK) { ldns_resolver_free(res); return NULL; } } } else { // Use a DNS server from resolv.conf status = ldns_resolver_new_frm_file(&res, NULL); if (status != LDNS_STATUS_OK) { ldns_resolver_free(res); return NULL; } } // Enable TCP if requested ldns_resolver_set_usevc(res, mp_ldns_usevc); return res; }
/** parse commandline argument domain name */ static int parse_arg_name(SSL* ssl, char* str, uint8_t** res, size_t* len, int* labs) { ldns_rdf* rdf; *res = NULL; *len = 0; *labs = 0; rdf = ldns_dname_new_frm_str(str); if(!rdf) { ssl_printf(ssl, "error cannot parse name %s\n", str); return 0; } *res = memdup(ldns_rdf_data(rdf), ldns_rdf_size(rdf)); ldns_rdf_deep_free(rdf); if(!*res) { ssl_printf(ssl, "error out of memory\n"); return 0; } *labs = dname_count_size_labels(*res, len); return 1; }
switch_status_t ldns_lookup(const char *number, const char *root, char *server_name[ENUM_MAXNAMESERVERS] , enum_record_t **results) { ldns_resolver *res = NULL; ldns_rdf *domain = NULL; ldns_pkt *p = NULL; ldns_rr_list *naptr = NULL; ldns_status s = LDNS_STATUS_ERR; ldns_rdf *serv_rdf; switch_status_t status = SWITCH_STATUS_FALSE; char *name = NULL; struct timeval to = { 0, 0}; int inameserver = 0; int added_server = 0; if (!(name = reverse_number(number, root))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Parse Error!\n"); goto end; } if (!(domain = ldns_dname_new_frm_str(name))) { goto end; } if (server_name) { res = ldns_resolver_new(); switch_assert(res); for(inameserver=0; inameserver<ENUM_MAXNAMESERVERS; inameserver++) { if ( server_name[inameserver] != NULL ) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding Nameserver [%s]\n", server_name[inameserver]); if ((serv_rdf = ldns_rdf_new_addr_frm_str( server_name[inameserver] ))) { s = ldns_resolver_push_nameserver(res, serv_rdf); ldns_rdf_deep_free(serv_rdf); added_server = 1; } } } } if (!added_server) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No Nameservers specified, using host default\n"); /* create a new resolver from /etc/resolv.conf */ s = ldns_resolver_new_frm_file(&res, NULL); } if (s != LDNS_STATUS_OK) { goto end; } to.tv_sec = globals.timeout / 1000; to.tv_usec = (globals.timeout % 1000) * 1000; ldns_resolver_set_timeout(res, to); ldns_resolver_set_retry(res, (uint8_t)globals.retries); ldns_resolver_set_random(res, globals.random); if ((p = ldns_resolver_query(res, domain, LDNS_RR_TYPE_NAPTR, LDNS_RR_CLASS_IN, LDNS_RD))) { /* retrieve the NAPTR records from the answer section of that * packet */ if ((naptr = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NAPTR, LDNS_SECTION_ANSWER))) { size_t i; ldns_rr_list_sort(naptr); for (i = 0; i < ldns_rr_list_rr_count(naptr); i++) { parse_naptr(ldns_rr_list_rr(naptr, i), number, results); } //ldns_rr_list_print(stdout, naptr); ldns_rr_list_deep_free(naptr); status = SWITCH_STATUS_SUCCESS; } } end: switch_safe_free(name); if (domain) { ldns_rdf_deep_free(domain); } if (p) { ldns_pkt_free(p); } if (res) { ldns_resolver_deep_free(res); } return status; }
int main(int argc, char *argv[]) { ldns_resolver *res; ldns_rdf *domain; ldns_pkt *p; ldns_rr_list *mx; ldns_status s; p = NULL; mx = NULL; domain = NULL; res = NULL; if (argc != 2) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } else { /* create a rdf from the command line arg */ domain = ldns_dname_new_frm_str(argv[1]); if (!domain) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } } /* create a new resolver from /etc/resolv.conf */ s = ldns_resolver_new_frm_file(&res, NULL); if (s != LDNS_STATUS_OK) { exit(EXIT_FAILURE); } /* use the resolver to send a query for the mx * records of the domain given on the command line */ std::clock_t start; start = std::clock(); p = ldns_resolver_query(res, domain, LDNS_RR_TYPE_MX, LDNS_RR_CLASS_IN, LDNS_RD); if(!p) std::cout << "no packet is generated" << std::endl; else{ std::clock_t current; current = std::clock(); double latency = (current-start)*1000.0/CLOCKS_PER_SEC; std::cout <<"Qurey sent to " << domain << ", latency is " << latency << " ms." <<std::endl; } ldns_rdf_deep_free(domain); //if (!p) { // exit(EXIT_FAILURE); //} else { // /* retrieve the MX records from the answer section of that // * packet // */ // mx = ldns_pkt_rr_list_by_type(p, // LDNS_RR_TYPE_MX, // LDNS_SECTION_ANSWER); // if (!mx) { // fprintf(stderr, // " *** invalid answer name %s after MX query for %s\n", // argv[1], argv[1]); // ldns_pkt_free(p); // ldns_resolver_deep_free(res); // exit(EXIT_FAILURE); // } else { // ldns_rr_list_sort(mx); // ldns_rr_list_print(stdout, mx); // ldns_rr_list_deep_free(mx); // } //} ldns_pkt_free(p); ldns_resolver_deep_free(res); return 0; }