mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-09-02 07:35:26 +00:00
Code Issues Releases Wiki Activity

rewrite large chunks of code.

Browse Source
This commit is contained in:
Brian Wellington
2001-09-19 19:14:35 +00:00
parent 2dee13b8b8
commit f8dd2aeebd
1 changed files with 65 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
bin/dnssec/dnssec-makekeyset.c
View File

@@ -17,7 +17,7 @@
* PERFORMANCE OF THIS SOFTWARE. * PERFORMANCE OF THIS SOFTWARE.
*/ */
/* $Id: dnssec-makekeyset.c,v 1.54 2001/09/18 21:21:18 bwelling Exp $ */ /* $Id: dnssec-makekeyset.c,v 1.55 2001/09/19 19:14:35 bwelling Exp $ */
#include <config.h> #include <config.h>
@@ -30,11 +30,11 @@
#include <isc/util.h> #include <isc/util.h>
#include <dns/db.h> #include <dns/db.h>
#include <dns/diff.h>
#include <dns/dnssec.h> #include <dns/dnssec.h>
#include <dns/fixedname.h> #include <dns/fixedname.h>
#include <dns/log.h> #include <dns/log.h>
#include <dns/rdata.h> #include <dns/rdata.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h> #include <dns/rdataset.h>
#include <dns/result.h> #include <dns/result.h>
#include <dns/secalg.h> #include <dns/secalg.h>
@@ -44,8 +44,6 @@
#include "dnssectool.h" #include "dnssectool.h"
#define BUFSIZE 2048
const char *program = "dnssec-makekeyset"; const char *program = "dnssec-makekeyset";
int verbose; int verbose;
@@ -112,19 +110,6 @@ zonekey_on_list(dst_key_t *key) {
return (ISC_FALSE); return (ISC_FALSE);
} }
static isc_boolean_t
rdata_on_list(dns_rdata_t *rdata, dns_rdatalist_t *list) {
dns_rdata_t *trdata;
for (trdata = ISC_LIST_HEAD(list->rdata);
trdata != NULL;
trdata = ISC_LIST_NEXT(trdata, link))
{
if (dns_rdata_compare(trdata, rdata) == 0)
return (ISC_TRUE);
}
return (ISC_FALSE);
}
int int
main(int argc, char *argv[]) { main(int argc, char *argv[]) {
int i, ch; int i, ch;
@@ -133,20 +118,21 @@ main(int argc, char *argv[]) {
dns_name_t *domain = NULL; dns_name_t *domain = NULL;
char *output = NULL; char *output = NULL;
char *endp; char *endp;
unsigned char *data; unsigned char data[65536];
dns_db_t *db; dns_db_t *db;
dns_dbnode_t *node;
dns_dbversion_t *version; dns_dbversion_t *version;
dns_diff_t diff;
dns_difftuple_t *tuple;
dns_fixedname_t tname;
dst_key_t *key = NULL; dst_key_t *key = NULL;
dns_rdata_t *rdata; dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t rdatalist, sigrdatalist; dns_rdataset_t rdataset;
dns_rdataset_t rdataset, sigrdataset; dns_rdataclass_t rdclass;
isc_result_t result; isc_result_t result;
isc_buffer_t b; isc_buffer_t b;
isc_region_t r; isc_region_t r;
isc_log_t *log = NULL; isc_log_t *log = NULL;
keynode_t *keynode; keynode_t *keynode;
dns_name_t *savedname = NULL;
unsigned int eflags; unsigned int eflags;
isc_boolean_t pseudorandom = ISC_FALSE; isc_boolean_t pseudorandom = ISC_FALSE;
isc_boolean_t tryverify = ISC_FALSE; isc_boolean_t tryverify = ISC_FALSE;
@@ -236,11 +222,8 @@ main(int argc, char *argv[]) {
setup_logging(verbose, mctx, &log); setup_logging(verbose, mctx, &log);
dns_rdatalist_init(&rdatalist); dns_diff_init(mctx, &diff);
rdatalist.rdclass = 0; rdclass = 0;
rdatalist.type = dns_rdatatype_key;
rdatalist.covers = 0;
rdatalist.ttl = ttl;
ISC_LIST_INIT(keylist); ISC_LIST_INIT(keylist);
@@ -253,8 +236,8 @@ main(int argc, char *argv[]) {
mctx, &key); mctx, &key);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("error loading key from %s", argv[i]); fatal("error loading key from %s", argv[i]);
if (rdatalist.rdclass == 0) if (rdclass == 0)
rdatalist.rdclass = dst_key_class(key); rdclass = dst_key_class(key);
isc_buffer_init(&namebuf, namestr, sizeof namestr); isc_buffer_init(&namebuf, namestr, sizeof namestr);
result = dns_name_tofilenametext(dst_key_name(key), result = dns_name_tofilenametext(dst_key_name(key),
@@ -262,39 +245,27 @@ main(int argc, char *argv[]) {
&namebuf); &namebuf);
check_result(result, "dns_name_tofilenametext"); check_result(result, "dns_name_tofilenametext");
isc_buffer_putuint8(&namebuf, 0); isc_buffer_putuint8(&namebuf, 0);
if (savedname == NULL) { if (domain == NULL) {
savedname = isc_mem_get(mctx, sizeof(dns_name_t)); dns_fixedname_init(&fdomain);
if (savedname == NULL) domain = dns_fixedname_name(&fdomain);
fatal("out of memory"); dns_name_copy(dst_key_name(key), domain, NULL);
dns_name_init(savedname, NULL);
result = dns_name_dup(dst_key_name(key), mctx,
savedname);
if (result != ISC_R_SUCCESS)
fatal("out of memory");
} else { } else {
char savednamestr[DNS_NAME_FORMATSIZE]; char str[DNS_NAME_FORMATSIZE];
dns_name_format(savedname, savednamestr, dns_name_format(domain, str, sizeof str);
sizeof savednamestr); fatal("all keys must have the same owner - %s "
if (!dns_name_equal(savedname, dst_key_name(key))) "and %s do not match", str, namestr);
fatal("all keys must have the same owner - %s "
"and %s do not match",
savednamestr, namestr);
} }
if (output == NULL) { if (output == NULL) {
output = isc_mem_allocate(mctx, output = isc_mem_allocate(mctx,
strlen("keyset-") + strlen("keyset-") +
strlen(namestr) + 1); strlen(namestr) + 1);
if (output == NULL) if (output == NULL)
fatal("out of memory"); fatal("out of memory");
strcpy(output, "keyset-"); sprintf(output, "keyset-%s", namestr);
strcat(output, namestr);
}
if (domain == NULL) {
dns_fixedname_init(&fdomain);
domain = dns_fixedname_name(&fdomain);
dns_name_copy(dst_key_name(key), domain, NULL);
} }
if (dst_key_iszonekey(key)) { if (dst_key_iszonekey(key)) {
dst_key_t *zonekey = NULL; dst_key_t *zonekey = NULL;
result = dst_key_fromnamedfile(argv[i], result = dst_key_fromnamedfile(argv[i],
@@ -314,39 +285,41 @@ main(int argc, char *argv[]) {
} else } else
dst_key_free(&zonekey); dst_key_free(&zonekey);
} }
rdata = isc_mem_get(mctx, sizeof(dns_rdata_t)); dns_rdata_reset(&rdata);
if (rdata == NULL) isc_buffer_init(&b, data, sizeof(data));
fatal("out of memory");
dns_rdata_init(rdata);
data = isc_mem_get(mctx, BUFSIZE);
if (data == NULL)
fatal("out of memory");
isc_buffer_init(&b, data, BUFSIZE);
result = dst_key_todns(key, &b); result = dst_key_todns(key, &b);
dst_key_free(&key);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("failed to convert key %s to a DNS KEY: %s", fatal("failed to convert key %s to a DNS KEY: %s",
argv[i], isc_result_totext(result)); argv[i], isc_result_totext(result));
isc_buffer_usedregion(&b, &r); isc_buffer_usedregion(&b, &r);
dns_rdata_fromregion(rdata, rdatalist.rdclass, dns_rdata_fromregion(&rdata, rdclass, dns_rdatatype_key, &r);
dns_rdatatype_key, &r); tuple = NULL;
if (!rdata_on_list(rdata, &rdatalist)) result = dns_difftuple_create(mctx, DNS_DIFFOP_ADD,
ISC_LIST_APPEND(rdatalist.rdata, rdata, link); domain, ttl, &rdata, &tuple);
else { check_result(result, "dns_difftuple_create");
isc_mem_put(mctx, data, BUFSIZE); dns_diff_append(&diff, &tuple);
isc_mem_put(mctx, rdata, sizeof *rdata);
}
dst_key_free(&key);
} }
dns_rdataset_init(&rdataset); db = NULL;
result = dns_rdatalist_tordataset(&rdatalist, &rdataset); result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
check_result(result, "dns_rdatalist_tordataset()"); rdclass, 0, NULL, &db);
if (result != ISC_R_SUCCESS)
fatal("failed to create a database");
dns_rdatalist_init(&sigrdatalist); version = NULL;
sigrdatalist.rdclass = rdatalist.rdclass; dns_db_newversion(db, &version);
sigrdatalist.type = dns_rdatatype_sig;
sigrdatalist.covers = dns_rdatatype_key; result = dns_diff_apply(&diff, db, version);
sigrdatalist.ttl = ttl; check_result(result, "dns_diff_apply");
dns_diff_clear(&diff);
dns_fixedname_init(&tname);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, domain, version, dns_rdatatype_key, 0, 0,
NULL, dns_fixedname_name(&tname), &rdataset,
NULL);
check_result(result, "dns_db_find");
if (ISC_LIST_EMPTY(keylist)) if (ISC_LIST_EMPTY(keylist))
fprintf(stderr, fprintf(stderr,
@@ -356,17 +329,11 @@ main(int argc, char *argv[]) {
keynode != NULL; keynode != NULL;
keynode = ISC_LIST_NEXT(keynode, link)) keynode = ISC_LIST_NEXT(keynode, link))
{ {
rdata = isc_mem_get(mctx, sizeof(dns_rdata_t)); dns_rdata_reset(&rdata);
if (rdata == NULL) isc_buffer_init(&b, data, sizeof(data));
fatal("out of memory");
dns_rdata_init(rdata);
data = isc_mem_get(mctx, BUFSIZE);
if (data == NULL)
fatal("out of memory");
isc_buffer_init(&b, data, BUFSIZE);
result = dns_dnssec_sign(domain, &rdataset, keynode->key, result = dns_dnssec_sign(domain, &rdataset, keynode->key,
&starttime, &endtime, mctx, &b, &starttime, &endtime, mctx, &b,
rdata); &rdata);
isc_entropy_stopcallbacksources(ectx); isc_entropy_stopcallbacksources(ectx);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
char keystr[KEY_FORMATSIZE]; char keystr[KEY_FORMATSIZE];
@@ -377,7 +344,7 @@ main(int argc, char *argv[]) {
if (tryverify) { if (tryverify) {
result = dns_dnssec_verify(domain, &rdataset, result = dns_dnssec_verify(domain, &rdataset,
keynode->key, ISC_TRUE, keynode->key, ISC_TRUE,
mctx, rdata); mctx, &rdata);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
char keystr[KEY_FORMATSIZE]; char keystr[KEY_FORMATSIZE];
key_format(keynode->key, keystr, sizeof keystr); key_format(keynode->key, keystr, sizeof keystr);
@@ -386,34 +353,19 @@ main(int argc, char *argv[]) {
keystr, isc_result_totext(result)); keystr, isc_result_totext(result));
} }
} }
ISC_LIST_APPEND(sigrdatalist.rdata, rdata, link); tuple = NULL;
dns_rdataset_init(&sigrdataset); result = dns_difftuple_create(mctx, DNS_DIFFOP_ADD,
result = dns_rdatalist_tordataset(&sigrdatalist, &sigrdataset); domain, ttl, &rdata, &tuple);
check_result(result, "dns_rdatalist_tordataset()"); check_result(result, "dns_difftuple_create");
dns_diff_append(&diff, &tuple);
} }
db = NULL; result = dns_diff_apply(&diff, db, version);
result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone, check_result(result, "dns_diff_apply");
rdataset.rdclass, 0, NULL, &db); dns_diff_clear(&diff);
if (result != ISC_R_SUCCESS) {
char domainstr[DNS_NAME_FORMATSIZE];
dns_name_format(domain, domainstr, sizeof domainstr);
fatal("failed to create a database for %s", domainstr);
}
version = NULL; dns_rdataset_disassociate(&rdataset);
dns_db_newversion(db, &version);
node = NULL;
result = dns_db_findnode(db, domain, ISC_TRUE, &node);
check_result(result, "dns_db_findnode()");
dns_db_addrdataset(db, node, version, 0, &rdataset, 0, NULL);
if (!ISC_LIST_EMPTY(keylist))
dns_db_addrdataset(db, node, version, 0, &sigrdataset, 0,
NULL);
dns_db_detachnode(db, &node);
dns_db_closeversion(db, &version, ISC_TRUE); dns_db_closeversion(db, &version, ISC_TRUE);
result = dns_db_dump(db, version, output); result = dns_db_dump(db, version, output);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
@@ -427,20 +379,6 @@ main(int argc, char *argv[]) {
dns_db_detach(&db); dns_db_detach(&db);
dns_rdataset_disassociate(&rdataset);
while (!ISC_LIST_EMPTY(rdatalist.rdata)) {
rdata = ISC_LIST_HEAD(rdatalist.rdata);
ISC_LIST_UNLINK(rdatalist.rdata, rdata, link);
isc_mem_put(mctx, rdata->data, BUFSIZE);
isc_mem_put(mctx, rdata, sizeof *rdata);
}
while (!ISC_LIST_EMPTY(sigrdatalist.rdata)) {
rdata = ISC_LIST_HEAD(sigrdatalist.rdata);
ISC_LIST_UNLINK(sigrdatalist.rdata, rdata, link);
isc_mem_put(mctx, rdata->data, BUFSIZE);
isc_mem_put(mctx, rdata, sizeof *rdata);
}
while (!ISC_LIST_EMPTY(keylist)) { while (!ISC_LIST_EMPTY(keylist)) {
keynode = ISC_LIST_HEAD(keylist); keynode = ISC_LIST_HEAD(keylist);
ISC_LIST_UNLINK(keylist, keynode, link); ISC_LIST_UNLINK(keylist, keynode, link);
@@ -448,11 +386,6 @@ main(int argc, char *argv[]) {
isc_mem_put(mctx, keynode, sizeof(keynode_t)); isc_mem_put(mctx, keynode, sizeof(keynode_t));
} }
if (savedname != NULL) {
dns_name_free(savedname, mctx);
isc_mem_put(mctx, savedname, sizeof(dns_name_t));
}
cleanup_logging(&log); cleanup_logging(&log);
cleanup_entropy(&ectx); cleanup_entropy(&ectx);