/** * Read a file with trust anchors * @param anchors: anchor storage. * @param buffer: parsing buffer. * @param fname: string. * @param onlyone: only one trust anchor allowed in file. * @return NULL on error. Else last trust-anchor point. */ static struct trust_anchor* anchor_read_file(struct val_anchors* anchors, sldns_buffer* buffer, const char* fname, int onlyone) { struct trust_anchor* ta = NULL, *tanew; struct sldns_file_parse_state pst; int status; size_t len, dname_len; uint8_t* rr = sldns_buffer_begin(buffer); int ok = 1; FILE* in = fopen(fname, "r"); if(!in) { log_err("error opening file %s: %s", fname, strerror(errno)); return 0; } memset(&pst, 0, sizeof(pst)); pst.default_ttl = 3600; pst.lineno = 1; while(!feof(in)) { len = sldns_buffer_capacity(buffer); dname_len = 0; status = sldns_fp2wire_rr_buf(in, rr, &len, &dname_len, &pst); if(len == 0) /* empty, $TTL, $ORIGIN */ continue; if(status != 0) { log_err("parse error in %s:%d:%d : %s", fname, pst.lineno, LDNS_WIREPARSE_OFFSET(status), sldns_get_errorstr_parse(status)); ok = 0; break; } if(sldns_wirerr_get_type(rr, len, dname_len) != LDNS_RR_TYPE_DS && sldns_wirerr_get_type(rr, len, dname_len) != LDNS_RR_TYPE_DNSKEY) { continue; } if(!(tanew=anchor_store_new_rr(anchors, rr, len, dname_len))) { log_err("mem error at %s line %d", fname, pst.lineno); ok = 0; break; } if(onlyone && ta && ta != tanew) { log_err("error at %s line %d: no multiple anchor " "domains allowed (you can have multiple " "keys, but they must have the same name).", fname, pst.lineno); ok = 0; break; } ta = tanew; } fclose(in); if(!ok) return NULL; /* empty file is OK when multiple anchors are allowed */ if(!onlyone && !ta) return (struct trust_anchor*)1; return ta; }
/** load an RR into rrset */ static int load_rr(SSL* ssl, sldns_buffer* buf, struct regional* region, struct ub_packed_rrset_key* rk, struct packed_rrset_data* d, unsigned int i, int is_rrsig, int* go_on, time_t now) { uint8_t rr[LDNS_RR_BUF_SIZE]; size_t rr_len = sizeof(rr), dname_len = 0; int status; /* read the line */ if(!ssl_read_buf(ssl, buf)) return 0; if(strncmp((char*)sldns_buffer_begin(buf), "BADRR\n", 6) == 0) { *go_on = 0; return 1; } status = sldns_str2wire_rr_buf((char*)sldns_buffer_begin(buf), rr, &rr_len, &dname_len, 3600, NULL, 0, NULL, 0); if(status != 0) { log_warn("error cannot parse rr: %s: %s", sldns_get_errorstr_parse(status), (char*)sldns_buffer_begin(buf)); return 0; } if(is_rrsig && sldns_wirerr_get_type(rr, rr_len, dname_len) != LDNS_RR_TYPE_RRSIG) { log_warn("error expected rrsig but got %s", (char*)sldns_buffer_begin(buf)); return 0; } /* convert ldns rr into packed_rr */ d->rr_ttl[i] = (time_t)sldns_wirerr_get_ttl(rr, rr_len, dname_len) + now; sldns_buffer_clear(buf); d->rr_len[i] = sldns_wirerr_get_rdatalen(rr, rr_len, dname_len)+2; d->rr_data[i] = (uint8_t*)regional_alloc_init(region, sldns_wirerr_get_rdatawl(rr, rr_len, dname_len), d->rr_len[i]); if(!d->rr_data[i]) { log_warn("error out of memory"); return 0; } /* if first entry, fill the key structure */ if(i==0) { rk->rk.type = htons(sldns_wirerr_get_type(rr, rr_len, dname_len)); rk->rk.rrset_class = htons(sldns_wirerr_get_class(rr, rr_len, dname_len)); rk->rk.dname_len = dname_len; rk->rk.dname = regional_alloc_init(region, rr, dname_len); if(!rk->rk.dname) { log_warn("error out of memory"); return 0; } } return 1; }
/** return name and class and rdata of rr; parses string */ static int get_rr_content(const char* str, uint8_t** nm, uint16_t* type, uint16_t* dclass, time_t* ttl, uint8_t* rr, size_t len, uint8_t** rdata, size_t* rdata_len) { size_t dname_len = 0; int e = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600, NULL, 0, NULL, 0); if(e) { log_err("error parsing local-data at %d: '%s': %s", LDNS_WIREPARSE_OFFSET(e), str, sldns_get_errorstr_parse(e)); return 0; } *nm = memdup(rr, dname_len); if(!*nm) { log_err("out of memory"); return 0; } *dclass = sldns_wirerr_get_class(rr, len, dname_len); *type = sldns_wirerr_get_type(rr, len, dname_len); *ttl = (time_t)sldns_wirerr_get_ttl(rr, len, dname_len); *rdata = sldns_wirerr_get_rdatawl(rr, len, dname_len); *rdata_len = sldns_wirerr_get_rdatalen(rr, len, dname_len)+2; return 1; }
/** * Add new RR. It converts ldns RR to wire format. * @param anchors: anchor storage. * @param rr: the wirerr. * @param rl: length of rr. * @param dl: length of dname. * @return NULL on error, else the trust anchor. */ static struct trust_anchor* anchor_store_new_rr(struct val_anchors* anchors, uint8_t* rr, size_t rl, size_t dl) { struct trust_anchor* ta; if(!(ta=anchor_store_new_key(anchors, rr, sldns_wirerr_get_type(rr, rl, dl), sldns_wirerr_get_class(rr, rl, dl), sldns_wirerr_get_rdatawl(rr, rl, dl), sldns_wirerr_get_rdatalen(rr, rl, dl)+2))) { return NULL; } log_nametypeclass(VERB_QUERY, "adding trusted key", rr, sldns_wirerr_get_type(rr, rl, dl), sldns_wirerr_get_class(rr, rl, dl)); return ta; }
/** read qinfo from next three words */ static char* load_qinfo(char* str, struct query_info* qinfo, struct regional* region) { /* s is part of the buf */ char* s = str; uint8_t rr[LDNS_RR_BUF_SIZE]; size_t rr_len = sizeof(rr), dname_len = 0; int status; /* skip three words */ s = strchr(str, ' '); if(s) s = strchr(s+1, ' '); if(s) s = strchr(s+1, ' '); if(!s) { log_warn("error line too short, %s", str); return NULL; } s[0] = 0; s++; /* parse them */ status = sldns_str2wire_rr_question_buf(str, rr, &rr_len, &dname_len, NULL, 0, NULL, 0); if(status != 0) { log_warn("error cannot parse: %s %s", sldns_get_errorstr_parse(status), str); return NULL; } qinfo->qtype = sldns_wirerr_get_type(rr, rr_len, dname_len); qinfo->qclass = sldns_wirerr_get_class(rr, rr_len, dname_len); qinfo->qname_len = dname_len; qinfo->qname = (uint8_t*)regional_alloc_init(region, rr, dname_len); qinfo->local_alias = NULL; if(!qinfo->qname) { log_warn("error out of memory"); return NULL; } return s; }
/** read root hints from file */ static int read_root_hints(struct iter_hints* hints, char* fname) { struct sldns_file_parse_state pstate; struct delegpt* dp; uint8_t rr[LDNS_RR_BUF_SIZE]; size_t rr_len, dname_len; int status; uint16_t c = LDNS_RR_CLASS_IN; FILE* f = fopen(fname, "r"); if(!f) { log_err("could not read root hints %s: %s", fname, strerror(errno)); return 0; } dp = delegpt_create_mlc(NULL); if(!dp) { log_err("out of memory reading root hints"); fclose(f); return 0; } verbose(VERB_QUERY, "Reading root hints from %s", fname); memset(&pstate, 0, sizeof(pstate)); pstate.lineno = 1; dp->has_parent_side_NS = 1; while(!feof(f)) { rr_len = sizeof(rr); dname_len = 0; status = sldns_fp2wire_rr_buf(f, rr, &rr_len, &dname_len, &pstate); if(status != 0) { log_err("reading root hints %s %d:%d: %s", fname, pstate.lineno, LDNS_WIREPARSE_OFFSET(status), sldns_get_errorstr_parse(status)); goto stop_read; } if(rr_len == 0) continue; /* EMPTY line, TTL or ORIGIN */ if(sldns_wirerr_get_type(rr, rr_len, dname_len) == LDNS_RR_TYPE_NS) { if(!delegpt_add_ns_mlc(dp, sldns_wirerr_get_rdata(rr, rr_len, dname_len), 0)) { log_err("out of memory reading root hints"); goto stop_read; } c = sldns_wirerr_get_class(rr, rr_len, dname_len); if(!dp->name) { if(!delegpt_set_name_mlc(dp, rr)) { log_err("out of memory."); goto stop_read; } } } else if(sldns_wirerr_get_type(rr, rr_len, dname_len) == LDNS_RR_TYPE_A && sldns_wirerr_get_rdatalen(rr, rr_len, dname_len) == INET_SIZE) { struct sockaddr_in sa; socklen_t len = (socklen_t)sizeof(sa); memset(&sa, 0, len); sa.sin_family = AF_INET; sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT); memmove(&sa.sin_addr, sldns_wirerr_get_rdata(rr, rr_len, dname_len), INET_SIZE); if(!delegpt_add_target_mlc(dp, rr, dname_len, (struct sockaddr_storage*)&sa, len, 0, 0)) { log_err("out of memory reading root hints"); goto stop_read; } } else if(sldns_wirerr_get_type(rr, rr_len, dname_len) == LDNS_RR_TYPE_AAAA && sldns_wirerr_get_rdatalen(rr, rr_len, dname_len) == INET6_SIZE) { struct sockaddr_in6 sa; socklen_t len = (socklen_t)sizeof(sa); memset(&sa, 0, len); sa.sin6_family = AF_INET6; sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT); memmove(&sa.sin6_addr, sldns_wirerr_get_rdata(rr, rr_len, dname_len), INET6_SIZE); if(!delegpt_add_target_mlc(dp, rr, dname_len, (struct sockaddr_storage*)&sa, len, 0, 0)) { log_err("out of memory reading root hints"); goto stop_read; } } else { char buf[17]; sldns_wire2str_type_buf(sldns_wirerr_get_type(rr, rr_len, dname_len), buf, sizeof(buf)); log_warn("root hints %s:%d skipping type %s", fname, pstate.lineno, buf); } } fclose(f); if(!dp->name) { log_warn("root hints %s: no NS content", fname); delegpt_free_mlc(dp); return 1; } if(!hints_insert(hints, c, dp, 0)) { return 0; } delegpt_log(VERB_QUERY, dp); return 1; stop_read: delegpt_free_mlc(dp); fclose(f); return 0; }
/** find local data tag string match for the given type in the list */ static int find_tag_datas(struct query_info* qinfo, struct config_strlist* list, struct ub_packed_rrset_key* r, struct regional* temp, uint8_t* zname, size_t zlen) { struct config_strlist* p; char buf[65536]; uint8_t rr[LDNS_RR_BUF_SIZE]; size_t len; int res; struct packed_rrset_data* d; for(p=list; p; p=p->next) { len = sizeof(rr); /* does this element match the type? */ snprintf(buf, sizeof(buf), ". %s", p->str); res = sldns_str2wire_rr_buf(buf, rr, &len, NULL, 3600, zname, zlen, NULL, 0); if(res != 0) /* parse errors are already checked before, in * acllist check_data, skip this for robustness */ continue; if(len < 1 /* . */ + 8 /* typeclassttl*/ + 2 /*rdatalen*/) continue; if(sldns_wirerr_get_type(rr, len, 1) != qinfo->qtype) continue; /* do we have entries already? if not setup key */ if(r->rk.dname == NULL) { r->entry.key = r; r->rk.dname = qinfo->qname; r->rk.dname_len = qinfo->qname_len; r->rk.type = htons(qinfo->qtype); r->rk.rrset_class = htons(qinfo->qclass); r->rk.flags = 0; d = (struct packed_rrset_data*)regional_alloc_zero( temp, sizeof(struct packed_rrset_data) + sizeof(size_t) + sizeof(uint8_t*) + sizeof(time_t)); if(!d) return 0; /* out of memory */ r->entry.data = d; d->ttl = sldns_wirerr_get_ttl(rr, len, 1); d->rr_len = (size_t*)((uint8_t*)d + sizeof(struct packed_rrset_data)); d->rr_data = (uint8_t**)&(d->rr_len[1]); d->rr_ttl = (time_t*)&(d->rr_data[1]); } d = (struct packed_rrset_data*)r->entry.data; /* add entry to the data */ if(d->count != 0) { size_t* oldlen = d->rr_len; uint8_t** olddata = d->rr_data; time_t* oldttl = d->rr_ttl; /* increase arrays for lookup */ /* this is of course slow for very many records, * but most redirects are expected with few records */ d->rr_len = (size_t*)regional_alloc_zero(temp, (d->count+1)*sizeof(size_t)); d->rr_data = (uint8_t**)regional_alloc_zero(temp, (d->count+1)*sizeof(uint8_t*)); d->rr_ttl = (time_t*)regional_alloc_zero(temp, (d->count+1)*sizeof(time_t)); if(!d->rr_len || !d->rr_data || !d->rr_ttl) return 0; /* out of memory */ /* first one was allocated after struct d, but new * ones get their own array increment alloc, so * copy old content */ memmove(d->rr_len, oldlen, d->count*sizeof(size_t)); memmove(d->rr_data, olddata, d->count*sizeof(uint8_t*)); memmove(d->rr_ttl, oldttl, d->count*sizeof(time_t)); } d->rr_len[d->count] = sldns_wirerr_get_rdatalen(rr, len, 1)+2; d->rr_ttl[d->count] = sldns_wirerr_get_ttl(rr, len, 1); d->rr_data[d->count] = regional_alloc_init(temp, sldns_wirerr_get_rdatawl(rr, len, 1), d->rr_len[d->count]); if(!d->rr_data[d->count]) if(!d) return 0; /* out of memory */ d->count++; } if(r->rk.dname) return 1; return 0; }