horok/bind9
1
0
Fork 0
Code Activity
bind9/lib/dns/gen.c
Daniel Baumann f66ff7eae6
Adding upstream version 1:9.20.9. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-21 13:32:37 +02:00

1030 lines
26 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
/*! \file */
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif /* ifndef PATH_MAX */
#ifndef ULLONG_MAX
#define ULLONG_MAX (~0ULL)
#endif /* ifndef ULLONG_MAX */
#define INSIST(cond) \
if (!(cond)) { \
fprintf(stderr, "%s:%d: INSIST(%s)\n", __FILE__, __LINE__, \
#cond); \
abort(); \
}
#define FROMTEXTARGS "rdclass, type, lexer, origin, options, target, callbacks"
#define FROMTEXTCLASS "rdclass"
#define FROMTEXTTYPE "type"
#define FROMTEXTDEF "result = DNS_R_UNKNOWN"
#define TOTEXTARGS "rdata, tctx, target"
#define TOTEXTCLASS "rdata->rdclass"
#define TOTEXTTYPE "rdata->type"
#define TOTEXTDEF "use_default = true"
#define FROMWIREARGS "rdclass, type, source, dctx, target"
#define FROMWIRECLASS "rdclass"
#define FROMWIRETYPE "type"
#define FROMWIREDEF "use_default = true"
#define TOWIREARGS "rdata, cctx, target"
#define TOWIRECLASS "rdata->rdclass"
#define TOWIRETYPE "rdata->type"
#define TOWIREDEF "use_default = true"
#define FROMSTRUCTARGS "rdclass, type, source, target"
#define FROMSTRUCTCLASS "rdclass"
#define FROMSTRUCTTYPE "type"
#define FROMSTRUCTDEF "use_default = true"
#define TOSTRUCTARGS "rdata, target, mctx"
#define TOSTRUCTCLASS "rdata->rdclass"
#define TOSTRUCTTYPE "rdata->type"
#define TOSTRUCTDEF "use_default = true"
#define FREESTRUCTARGS "source"
#define FREESTRUCTCLASS "common->rdclass"
#define FREESTRUCTTYPE "common->rdtype"
#define FREESTRUCTDEF NULL
#define COMPAREARGS "rdata1, rdata2"
#define COMPARECLASS "rdata1->rdclass"
#define COMPARETYPE "rdata1->type"
#define COMPAREDEF "use_default = true"
#define ADDITIONALDATAARGS "rdata, owner, add, arg"
#define ADDITIONALDATACLASS "rdata->rdclass"
#define ADDITIONALDATATYPE "rdata->type"
#define ADDITIONALDATADEF "use_default = true"
#define DIGESTARGS "rdata, digest, arg"
#define DIGESTCLASS "rdata->rdclass"
#define DIGESTTYPE "rdata->type"
#define DIGESTDEF "use_default = true"
#define CHECKOWNERARGS "name, rdclass, type, wildcard"
#define CHECKOWNERCLASS "rdclass"
#define CHECKOWNERTYPE "type"
#define CHECKOWNERDEF "result = true"
#define CHECKNAMESARGS "rdata, owner, bad"
#define CHECKNAMESCLASS "rdata->rdclass"
#define CHECKNAMESTYPE "rdata->type"
#define CHECKNAMESDEF "result = true"
static const char copyright[] = "/*\n"
" * Copyright (C) 1998%s Internet Systems "
"Consortium, Inc. (\"ISC\")\n"
" *\n"
" * This Source Code Form is subject to the "
"terms of the Mozilla Public\n"
" * License, v. 2.0. If a copy of the MPL was "
"not distributed with this\n"
" * file, you can obtain one at "
"https://mozilla.org/MPL/2.0/.\n"
" */\n"
"\n"
"/***************\n"
" ***************\n"
" *************** THIS FILE IS AUTOMATICALLY "
"GENERATED BY gen.c.\n"
" *************** DO NOT EDIT!\n"
" ***************\n"
" ***************/\n"
"\n"
"/*! \\file */\n"
"\n";
#define STR_EXPAND(tok) #tok
#define STR(tok) STR_EXPAND(tok)
#define TYPENAMES 256
#define TYPECLASSLEN 20 /* DNS mnemonic size. Must be less than 100. */
#define TYPECLASSBUF (TYPECLASSLEN + 1)
#define TYPECLASSFMT "%" STR(TYPECLASSLEN) "[-0-9a-z]_%u"
#define ATTRIBUTESIZE 256
static struct cc {
struct cc *next;
uint16_t rdclass;
char classbuf[TYPECLASSBUF];
} *classes;
static struct tt {
struct tt *next;
uint16_t rdclass;
uint16_t type;
char classbuf[TYPECLASSBUF];
char typebuf[TYPECLASSBUF];
char dirbuf[PATH_MAX - 30];
} *types;
static struct ttnam {
char typebuf[TYPECLASSBUF];
char macroname[TYPECLASSBUF];
char attr[ATTRIBUTESIZE];
bool todo;
uint8_t hash;
uint16_t type;
} typenames[TYPENAMES];
static int ttnam_count;
typedef struct {
DIR *handle;
char *filename;
} isc_dir_t;
static char *
upper(char *);
static char *
funname(const char *, char *);
static void
doswitch(const char *, const char *, const char *, const char *, const char *,
const char *);
static void
add(unsigned int, const char *, int, const char *, const char *);
static void
sd(unsigned int, const char *, const char *, char);
static void
insert_into_typenames(int, const char *, const char *);
static uint8_t
HASH(char *string) {
size_t n;
unsigned char a, b;
n = strlen(string);
INSIST(n > 0);
a = tolower((unsigned char)string[0]);
b = tolower((unsigned char)string[n - 1]);
return ((a + n) * b) % 256;
}
static bool
start_directory(const char *path, isc_dir_t *dir) {
dir->handle = opendir(path);
if (dir->handle != NULL) {
return true;
} else {
return false;
}
}
static bool
next_file(isc_dir_t *dir) {
struct dirent *dirent;
dir->filename = NULL;
if (dir->handle != NULL) {
errno = 0;
dirent = readdir(dir->handle);
if (dirent != NULL) {
dir->filename = dirent->d_name;
} else {
if (errno != 0) {
fprintf(stderr,
"Error: reading directory: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
}
}
if (dir->filename != NULL) {
return true;
} else {
return false;
}
}
static void
end_directory(isc_dir_t *dir) {
if (dir->handle != NULL) {
(void)closedir(dir->handle);
}
dir->handle = NULL;
}
/*%
* If you use more than 10 of these in, say, a printf(), you'll have problems.
*/
static char *
upper(char *s) {
static int buf_to_use = 0;
static char buf[10][256];
char *b;
int c;
buf_to_use++;
if (buf_to_use > 9) {
buf_to_use = 0;
}
b = buf[buf_to_use];
memset(b, 0, 256);
while ((c = (*s++) & 0xff)) {
*b++ = islower(c) ? toupper(c) : c;
}
*b = '\0';
return buf[buf_to_use];
}
static char *
funname(const char *s, char *buf) {
char *b = buf;
char c;
INSIST(strlen(s) < TYPECLASSBUF);
while ((c = *s++)) {
*b++ = (c == '-') ? '_' : c;
}
*b = '\0';
return buf;
}
static void
doswitch(const char *name, const char *function, const char *args,
const char *tsw, const char *csw, const char *res) {
struct tt *tt;
int first = 1;
int lasttype = 0;
int subswitch = 0;
char buf1[TYPECLASSBUF], buf2[TYPECLASSBUF];
const char *result = " result =";
if (res == NULL) {
result = "";
}
for (tt = types; tt != NULL; tt = tt->next) {
if (first) {
printf("\n#define %s \\\n", name);
printf("\tswitch (%s) { \\\n" /*}*/, tsw);
first = 0;
}
if (tt->type != lasttype && subswitch) {
if (res == NULL) {
printf("\t\tdefault: break; \\\n");
} else {
printf("\t\tdefault: %s; break; \\\n", res);
}
printf("\t\t} \\\n");
printf("\t\tbreak; \\\n");
subswitch = 0;
}
if (tt->rdclass && tt->type != lasttype) {
printf("\tcase %d: switch (%s) { \\\n" /*}*/, tt->type,
csw);
subswitch = 1;
}
if (tt->rdclass == 0) {
printf("\tcase %d:%s %s_%s(%s); break;", tt->type,
result, function, funname(tt->typebuf, buf1),
args);
} else {
printf("\t\tcase %d:%s %s_%s_%s(%s); break;",
tt->rdclass, result, function,
funname(tt->classbuf, buf1),
funname(tt->typebuf, buf2), args);
}
printf(" \\\n");
lasttype = tt->type;
}
if (subswitch) {
if (res == NULL) {
printf("\t\tdefault: break; \\\n");
} else {
printf("\t\tdefault: %s; break; \\\n", res);
}
printf("\t\t} \\\n");
printf("\t\tbreak; \\\n");
}
if (first) {
if (res == NULL) {
printf("\n#define %s\n", name);
} else {
printf("\n#define %s %s;\n", name, res);
}
} else {
if (res == NULL) {
printf("\tdefault: break; \\\n");
} else {
printf("\tdefault: %s; break; \\\n", res);
}
printf("\t}\n");
}
}
static void
insert_into_typenames(int type, const char *typebuf, const char *attr) {
struct ttnam *ttn = NULL;
size_t c;
int i, n;
char tmp[256];
INSIST(strlen(typebuf) < TYPECLASSBUF);
for (i = 0; i < TYPENAMES && typenames[i].typebuf[0] != 0; i++) {
if (typenames[i].type != type) {
continue;
}
if (strcmp(typebuf, typenames[i].typebuf) != 0) {
fprintf(stderr,
"Error: type %d has two names: %s, %s\n", type,
typenames[i].typebuf, typebuf);
exit(EXIT_FAILURE);
}
ttn = &typenames[i];
}
/* Subtract one to leave an empty sentinel entry at the end */
if (i >= TYPENAMES - 1) {
fprintf(stderr, "Error: typenames array too small\n");
exit(EXIT_FAILURE);
} else if (ttn == NULL) {
ttn = &typenames[i];
ttnam_count = i + 1;
}
/* XXXMUKS: This is redundant due to the INSIST above. */
if (strlen(typebuf) > sizeof(ttn->typebuf) - 1) {
fprintf(stderr, "Error: type name %s is too long\n", typebuf);
exit(EXIT_FAILURE);
}
strncpy(ttn->typebuf, typebuf, sizeof(ttn->typebuf));
ttn->typebuf[sizeof(ttn->typebuf) - 1] = '\0';
strncpy(ttn->macroname, ttn->typebuf, sizeof(ttn->macroname));
ttn->macroname[sizeof(ttn->macroname) - 1] = '\0';
ttn->type = type;
c = strlen(ttn->macroname);
while (c > 0) {
if (ttn->macroname[c - 1] == '-') {
ttn->macroname[c - 1] = '_';
}
c--;
}
if (attr == NULL) {
n = snprintf(tmp, sizeof(tmp), "RRTYPE_%s_ATTRIBUTES",
upper(ttn->macroname));
INSIST(n > 0 && (unsigned int)n < sizeof(tmp));
attr = tmp;
}
if (ttn->attr[0] != 0 && strcmp(attr, ttn->attr) != 0) {
fprintf(stderr,
"Error: type %d has different attributes: "
"%s, %s\n",
type, ttn->attr, attr);
exit(EXIT_FAILURE);
}
if (strlen(attr) > sizeof(ttn->attr) - 1) {
fprintf(stderr, "Error: attr (%s) [name %s] is too long\n",
attr, typebuf);
exit(EXIT_FAILURE);
}
strncpy(ttn->attr, attr, sizeof(ttn->attr));
ttn->attr[sizeof(ttn->attr) - 1] = '\0';
ttn->hash = HASH(ttn->typebuf);
ttn->todo = true;
}
static void
add(unsigned int rdclass, const char *classbuf, int type, const char *typebuf,
const char *dirbuf) {
struct tt *newtt = (struct tt *)malloc(sizeof(*newtt));
struct tt *tt, *oldtt;
struct cc *newcc;
struct cc *cc, *oldcc;
INSIST(strlen(typebuf) < TYPECLASSBUF);
INSIST(strlen(classbuf) < TYPECLASSBUF);
INSIST(strlen(dirbuf) < PATH_MAX);
insert_into_typenames(type, typebuf, NULL);
if (newtt == NULL) {
fprintf(stderr, "malloc() failed\n");
exit(EXIT_FAILURE);
}
newtt->next = NULL;
newtt->rdclass = rdclass;
newtt->type = type;
strncpy(newtt->classbuf, classbuf, sizeof(newtt->classbuf));
newtt->classbuf[sizeof(newtt->classbuf) - 1] = '\0';
strncpy(newtt->typebuf, typebuf, sizeof(newtt->typebuf));
newtt->typebuf[sizeof(newtt->typebuf) - 1] = '\0';
if (strncmp(dirbuf, "./", 2) == 0) {
dirbuf += 2;
}
strncpy(newtt->dirbuf, dirbuf, sizeof(newtt->dirbuf));
newtt->dirbuf[sizeof(newtt->dirbuf) - 1] = '\0';
tt = types;
oldtt = NULL;
while ((tt != NULL) && (tt->type < type)) {
oldtt = tt;
tt = tt->next;
}
while ((tt != NULL) && (tt->type == type) && (tt->rdclass < rdclass)) {
INSIST(strcmp(tt->typebuf, typebuf) == 0);
oldtt = tt;
tt = tt->next;
}
INSIST(tt == NULL || tt->type != type || tt->rdclass != rdclass);
newtt->next = tt;
if (oldtt != NULL) {
oldtt->next = newtt;
} else {
types = newtt;
}
/*
* Do a class switch for this type.
*/
if (rdclass == 0) {
return;
}
newcc = (struct cc *)malloc(sizeof(*newcc));
if (newcc == NULL) {
fprintf(stderr, "malloc() failed\n");
exit(EXIT_FAILURE);
}
newcc->rdclass = rdclass;
strncpy(newcc->classbuf, classbuf, sizeof(newcc->classbuf));
newcc->classbuf[sizeof(newcc->classbuf) - 1] = '\0';
cc = classes;
oldcc = NULL;
while ((cc != NULL) && (cc->rdclass < rdclass)) {
oldcc = cc;
cc = cc->next;
}
if ((cc != NULL) && cc->rdclass == rdclass) {
free((char *)newcc);
return;
}
newcc->next = cc;
if (oldcc != NULL) {
oldcc->next = newcc;
} else {
classes = newcc;
}
}
static void
sd(unsigned int rdclass, const char *classbuf, const char *dirbuf,
char filetype) {
char buf[TYPECLASSLEN + sizeof("_4294967295.h")];
char typebuf[TYPECLASSBUF];
unsigned int type;
int n;
isc_dir_t dir;
if (!start_directory(dirbuf, &dir)) {
return;
}
while (next_file(&dir)) {
if (sscanf(dir.filename, TYPECLASSFMT, typebuf, &type) != 2) {
continue;
}
/*
* sscanf accepts leading sign and zeros before type so
* compare the scanned items against the filename. Filter
* out mismatches. Also filter out bad file extensions.
*/
n = snprintf(buf, sizeof(buf), "%s_%u.%c", typebuf, type,
filetype);
INSIST(n > 0 && (unsigned int)n < sizeof(buf));
if (strcmp(buf, dir.filename) != 0) {
continue;
}
if (type > 65535) {
fprintf(stderr, "Error: type value > 65535 (%s)\n",
dir.filename);
exit(EXIT_FAILURE);
}
add(rdclass, classbuf, type, typebuf, dirbuf);
}
end_directory(&dir);
}
static int
ttnam_cmp(const void *va, const void *vb) {
const struct ttnam *ttna = va, *ttnb = vb;
return ttna->type - ttnb->type;
}
int
main(int argc, char **argv) {
char buf[PATH_MAX];
char srcdir[PATH_MAX];
unsigned int rdclass;
char classbuf[TYPECLASSBUF];
struct tt *tt;
struct cc *cc;
struct ttnam *ttn, *ttn2;
time_t now;
char year[11];
int lasttype;
int code = 1;
int class_enum = 0;
int type_enum = 0;
int structs = 0;
int depend = 0;
int c, n;
char buf1[TYPECLASSBUF];
char filetype = 'c';
FILE *fd;
char *prefix = NULL;
char *suffix = NULL;
char *file = NULL;
char *source_date_epoch;
unsigned long long epoch;
char *endptr;
isc_dir_t dir;
srcdir[0] = '\0';
while ((c = getopt(argc, argv, "cdits:F:P:S:")) != -1) {
switch (c) {
case 'c':
code = 0;
depend = 0;
type_enum = 0;
class_enum = 1;
filetype = 'c';
structs = 0;
break;
case 'd':
code = 0;
depend = 1;
class_enum = 0;
type_enum = 0;
structs = 0;
filetype = 'h';
break;
case 't':
code = 0;
depend = 0;
class_enum = 0;
type_enum = 1;
filetype = 'c';
structs = 0;
break;
case 'i':
code = 0;
depend = 0;
class_enum = 0;
type_enum = 0;
structs = 1;
filetype = 'h';
break;
case 's':
if (strlen(optarg) >
PATH_MAX - 2 * TYPECLASSLEN -
sizeof("/rdata/_65535_65535"))
{
fprintf(stderr, "\"%s\" too long\n", optarg);
exit(EXIT_FAILURE);
}
n = snprintf(srcdir, sizeof(srcdir), "%s/", optarg);
INSIST(n > 0 && (unsigned int)n < sizeof(srcdir));
break;
case 'F':
file = optarg;
break;
case 'P':
prefix = optarg;
break;
case 'S':
suffix = optarg;
break;
case '?':
exit(EXIT_FAILURE);
}
}
n = snprintf(buf, sizeof(buf), "%srdata", srcdir);
INSIST(n > 0 && (unsigned int)n < sizeof(srcdir));
INSIST(start_directory(buf, &dir));
while (next_file(&dir)) {
if (sscanf(dir.filename, TYPECLASSFMT, classbuf, &rdclass) != 2)
{
continue;
}
/*
* sscanf accepts leading sign and zeros before type so
* compare the scanned items against the filename. Filter
* out mismatches.
*/
n = snprintf(buf, sizeof(buf), "%srdata/%s_%u", srcdir,
classbuf, rdclass);
INSIST(n > 0 && (unsigned int)n < sizeof(buf));
if (strcmp(buf + 6 + strlen(srcdir), dir.filename) != 0) {
continue;
}
if (rdclass > 65535) {
fprintf(stderr, "Error: class value > 65535 (%s)\n",
dir.filename);
exit(EXIT_FAILURE);
}
sd(rdclass, classbuf, buf, filetype);
}
end_directory(&dir);
n = snprintf(buf, sizeof(buf), "%srdata/generic", srcdir);
INSIST(n > 0 && (unsigned int)n < sizeof(srcdir));
sd(0, "", buf, filetype);
source_date_epoch = getenv("SOURCE_DATE_EPOCH");
if (source_date_epoch) {
errno = 0;
epoch = strtoull(source_date_epoch, &endptr, 10);
if ((errno == ERANGE && (epoch == ULLONG_MAX || epoch == 0)) ||
(errno != 0 && epoch == 0))
{
fprintf(stderr,
"Environment variable "
"$SOURCE_DATE_EPOCH: strtoull: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
if (endptr == source_date_epoch) {
fprintf(stderr,
"Environment variable "
"$SOURCE_DATE_EPOCH: "
"No digits were found: %s\n",
endptr);
exit(EXIT_FAILURE);
}
if (*endptr != '\0') {
fprintf(stderr,
"Environment variable "
"$SOURCE_DATE_EPOCH: Trailing garbage: %s\n",
endptr);
exit(EXIT_FAILURE);
}
if (epoch > ULONG_MAX) {
fprintf(stderr,
"Environment variable "
"$SOURCE_DATE_EPOCH: value must be "
"smaller than or equal to: %lu but "
"was found to be: %llu \n",
ULONG_MAX, epoch);
exit(EXIT_FAILURE);
}
now = epoch;
} else {
time(&now);
}
if (now != -1) {
struct tm t, *tm = gmtime_r(&now, &t);
if (tm != NULL && tm->tm_year > 104) {
n = snprintf(year, sizeof(year), "-%d",
tm->tm_year + 1900);
INSIST(n > 0 && (unsigned int)n < sizeof(year));
} else {
snprintf(year, sizeof(year), "-2016");
}
} else {
snprintf(year, sizeof(year), "-2016");
}
if (!depend) {
printf(copyright, year);
}
if (code) {
printf("#pragma once\n");
printf("#include <stdbool.h>\n");
printf("#include <isc/result.h>\n\n");
printf("#include <dns/name.h>\n\n");
for (tt = types; tt != NULL; tt = tt->next) {
printf("#include \"%s/%s_%d.c\"\n", tt->dirbuf,
tt->typebuf, tt->type);
}
printf("\n\n");
doswitch("FROMTEXTSWITCH", "fromtext", FROMTEXTARGS,
FROMTEXTTYPE, FROMTEXTCLASS, FROMTEXTDEF);
doswitch("TOTEXTSWITCH", "totext", TOTEXTARGS, TOTEXTTYPE,
TOTEXTCLASS, TOTEXTDEF);
doswitch("FROMWIRESWITCH", "fromwire", FROMWIREARGS,
FROMWIRETYPE, FROMWIRECLASS, FROMWIREDEF);
doswitch("TOWIRESWITCH", "towire", TOWIREARGS, TOWIRETYPE,
TOWIRECLASS, TOWIREDEF);
doswitch("COMPARESWITCH", "compare", COMPAREARGS, COMPARETYPE,
COMPARECLASS, COMPAREDEF);
doswitch("CASECOMPARESWITCH", "casecompare", COMPAREARGS,
COMPARETYPE, COMPARECLASS, COMPAREDEF);
doswitch("FROMSTRUCTSWITCH", "fromstruct", FROMSTRUCTARGS,
FROMSTRUCTTYPE, FROMSTRUCTCLASS, FROMSTRUCTDEF);
doswitch("TOSTRUCTSWITCH", "tostruct", TOSTRUCTARGS,
TOSTRUCTTYPE, TOSTRUCTCLASS, TOSTRUCTDEF);
doswitch("FREESTRUCTSWITCH", "freestruct", FREESTRUCTARGS,
FREESTRUCTTYPE, FREESTRUCTCLASS, FREESTRUCTDEF);
doswitch("ADDITIONALDATASWITCH", "additionaldata",
ADDITIONALDATAARGS, ADDITIONALDATATYPE,
ADDITIONALDATACLASS, ADDITIONALDATADEF);
doswitch("DIGESTSWITCH", "digest", DIGESTARGS, DIGESTTYPE,
DIGESTCLASS, DIGESTDEF);
doswitch("CHECKOWNERSWITCH", "checkowner", CHECKOWNERARGS,
CHECKOWNERTYPE, CHECKOWNERCLASS, CHECKOWNERDEF);
doswitch("CHECKNAMESSWITCH", "checknames", CHECKNAMESARGS,
CHECKNAMESTYPE, CHECKNAMESCLASS, CHECKNAMESDEF);
/*
* From here down, we are processing the rdata names and
* attributes.
*/
#define METANOTQUESTION \
"DNS_RDATATYPEATTR_META | " \
"DNS_RDATATYPEATTR_NOTQUESTION"
#define METAQUESTIONONLY \
"DNS_RDATATYPEATTR_META | " \
"DNS_RDATATYPEATTR_QUESTIONONLY"
#define RESERVEDNAME "0"
#define RESERVED "DNS_RDATATYPEATTR_RESERVED"
/*
* Add in reserved/special types. This will let us
* sort them without special cases.
*/
insert_into_typenames(100, "uinfo", RESERVEDNAME);
insert_into_typenames(101, "uid", RESERVEDNAME);
insert_into_typenames(102, "gid", RESERVEDNAME);
insert_into_typenames(103, "unspec", RESERVEDNAME);
insert_into_typenames(251, "ixfr", METAQUESTIONONLY);
insert_into_typenames(252, "axfr", METAQUESTIONONLY);
insert_into_typenames(253, "mailb", METAQUESTIONONLY);
insert_into_typenames(254, "maila", METAQUESTIONONLY);
insert_into_typenames(255, "any", METAQUESTIONONLY);
/*
* For reproducible builds, ensure the directory read
* order does not affect the order of switch cases.
*/
qsort(typenames, ttnam_count, sizeof(struct ttnam), ttnam_cmp);
/*
* Spit out a quick and dirty hash function. Here,
* we walk through the list of type names, and calculate
* a hash. This isn't perfect, but it will generate "pretty
* good" estimates. Lowercase the characters before
* computing in all cases.
*
* Here, walk the list from top to bottom, calculating
* the hash (mod 256) for each name.
*/
printf("#define RDATATYPE_COMPARE(_s, _d, _tn, _n, _tp) \\\n");
printf("\tdo { \\\n");
printf("\t\tif (sizeof(_s) - 1 == _n && \\\n"
"\t\t strncasecmp(_s,(_tn),"
"(sizeof(_s) - 1)) == 0) { \\\n");
printf("\t\t\tif ((dns_rdatatype_attributes(_d) & "
"DNS_RDATATYPEATTR_RESERVED) != 0) \\\n");
printf("\t\t\t\treturn (ISC_R_NOTIMPLEMENTED); \\\n");
printf("\t\t\t*(_tp) = _d; \\\n");
printf("\t\t\treturn (ISC_R_SUCCESS); \\\n");
printf("\t\t} \\\n");
printf("\t} while (0)\n\n");
printf("#define RDATATYPE_FROMTEXT_SW(_hash,"
"_typename,_length,_typep) \\\n");
printf("\tswitch (_hash) { \\\n");
for (ttn = typenames; ttn->typebuf[0] != 0; ttn++) {
/*
* Skip entries we already processed.
*/
if (!ttn->todo) {
continue;
}
printf("\t\tcase %u: \\\n", ttn->hash);
/*
* Find all other entries that happen to match
* this hash.
*/
for (ttn2 = typenames; ttn2->typebuf[0] != 0; ttn2++) {
if (ttn2->todo && ttn2->hash == ttn->hash) {
printf("\t\t\tRDATATYPE_COMPARE"
"(\"%s\", %d, _typename, "
" _length, _typep); \\\n",
ttn2->typebuf, ttn2->type);
ttn2->todo = false;
}
}
printf("\t\t\tbreak; \\\n");
}
printf("\t}\n");
printf("#define RDATATYPE_ATTRIBUTE_SW \\\n");
printf("\tswitch (type) { \\\n");
for (ttn = typenames; ttn->typebuf[0] != 0; ttn++) {
printf("\tcase %d: return (%s); \\\n", ttn->type,
upper(ttn->attr));
}
printf("\t}\n");
printf("#define RDATATYPE_TOTEXT_SW \\\n");
printf("\tswitch (type) { \\\n");
for (ttn = typenames; ttn->typebuf[0] != 0; ttn++) {
/*
* Remove KEYDATA (65533) from the type to memonic
* translation as it is internal use only. This
* stops the tools from displaying KEYDATA instead
* of TYPE65533.
*/
if (ttn->type == 65533U) {
continue;
}
printf("\tcase %d: return "
"(str_totext(\"%s\", target)); \\\n",
ttn->type, upper(ttn->typebuf));
}
printf("\t}\n");
} else if (type_enum) {
char *s;
printf("#pragma once\n");
printf("enum {\n");
printf("\tdns_rdatatype_none = 0,\n");
lasttype = 0;
for (tt = types; tt != NULL; tt = tt->next) {
if (tt->type != lasttype) {
printf("\tdns_rdatatype_%s = %d,\n",
funname(tt->typebuf, buf1),
lasttype = tt->type);
}
}
printf("\tdns_rdatatype_ixfr = 251,\n");
printf("\tdns_rdatatype_axfr = 252,\n");
printf("\tdns_rdatatype_mailb = 253,\n");
printf("\tdns_rdatatype_maila = 254,\n");
printf("\tdns_rdatatype_any = 255\n");
printf("};\n\n");
printf("#define dns_rdatatype_none\t"
"((dns_rdatatype_t)dns_rdatatype_none)\n");
for (tt = types; tt != NULL; tt = tt->next) {
if (tt->type != lasttype) {
s = funname(tt->typebuf, buf1);
printf("#define dns_rdatatype_%s\t%s"
"((dns_rdatatype_t)dns_rdatatype_%s)\n",
s, strlen(s) < 2U ? "\t" : "", s);
lasttype = tt->type;
}
}
printf("#define dns_rdatatype_ixfr\t"
"((dns_rdatatype_t)dns_rdatatype_ixfr)\n");
printf("#define dns_rdatatype_axfr\t"
"((dns_rdatatype_t)dns_rdatatype_axfr)\n");
printf("#define dns_rdatatype_mailb\t"
"((dns_rdatatype_t)dns_rdatatype_mailb)\n");
printf("#define dns_rdatatype_maila\t"
"((dns_rdatatype_t)dns_rdatatype_maila)\n");
printf("#define dns_rdatatype_any\t"
"((dns_rdatatype_t)dns_rdatatype_any)\n");
} else if (class_enum) {
char *s;
int classnum;
printf("#pragma once\n");
printf("enum {\n");
printf("\tdns_rdataclass_reserved0 = 0,\n");
printf("#define dns_rdataclass_reserved0 \\\n\t\t\t\t"
"((dns_rdataclass_t)dns_rdataclass_reserved0)\n");
#define PRINTCLASS(name, num) \
do { \
s = funname(name, buf1); \
classnum = num; \
printf("\tdns_rdataclass_%s = %d%s\n", s, classnum, \
classnum != 255 ? "," : ""); \
printf("#define dns_rdataclass_%s\t" \
"((dns_rdataclass_t)dns_rdataclass_%s)\n", \
s, s); \
} while (0)
for (cc = classes; cc != NULL; cc = cc->next) {
if (cc->rdclass == 3) {
PRINTCLASS("chaos", 3);
} else if (cc->rdclass == 255) {
PRINTCLASS("none", 254);
}
PRINTCLASS(cc->classbuf, cc->rdclass);
}
#undef PRINTCLASS
printf("};\n\n");
} else if (structs) {
if (prefix != NULL) {
if ((fd = fopen(prefix, "r")) != NULL) {
while (fgets(buf, sizeof(buf), fd) != NULL) {
printf("%s", buf);
}
fclose(fd);
}
}
for (tt = types; tt != NULL; tt = tt->next) {
snprintf(buf, sizeof(buf), "%s/%s_%d.h", tt->dirbuf,
tt->typebuf, tt->type);
if ((fd = fopen(buf, "r")) != NULL) {
while (fgets(buf, sizeof(buf), fd) != NULL) {
printf("%s", buf);
}
fclose(fd);
}
}
if (suffix != NULL) {
if ((fd = fopen(suffix, "r")) != NULL) {
while (fgets(buf, sizeof(buf), fd) != NULL) {
printf("%s", buf);
}
fclose(fd);
}
}
} else if (depend) {
for (tt = types; tt != NULL; tt = tt->next) {
printf("%s:\t%s/%s_%d.h\n", file, tt->dirbuf,
tt->typebuf, tt->type);
}
}
if (ferror(stdout) != 0) {
exit(EXIT_FAILURE);
}
return 0;
}
View git blame Copy permalink