/
dbcreate.c
285 lines (271 loc) · 7.38 KB
/
dbcreate.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
/*
* dbcreate.c -- routines to create an nsd(8) name database
*
* Copyright (c) 2001-2006, NLnet Labs. All rights reserved.
*
* See LICENSE for the license.
*
*/
#include "config.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "namedb.h"
#include "udb.h"
#include "options.h"
#include "nsd.h"
#include "ixfr.h"
/* pathname directory separator character */
#define PATHSEP '/'
/** add an rdata (uncompressed) to the destination */
static size_t
add_rdata(rr_type* rr, unsigned i, uint8_t* buf, size_t buflen)
{
switch(rdata_atom_wireformat_type(rr->type, i)) {
case RDATA_WF_COMPRESSED_DNAME:
case RDATA_WF_UNCOMPRESSED_DNAME:
{
const dname_type* dname = domain_dname(
rdata_atom_domain(rr->rdatas[i]));
if(dname->name_size > buflen)
return 0;
memmove(buf, dname_name(dname), dname->name_size);
return dname->name_size;
}
default:
break;
}
if(rdata_atom_size(rr->rdatas[i]) > buflen)
return 0;
memmove(buf, rdata_atom_data(rr->rdatas[i]),
rdata_atom_size(rr->rdatas[i]));
return rdata_atom_size(rr->rdatas[i]);
}
/* marshal rdata into buffer, must be MAX_RDLENGTH in size */
size_t
rr_marshal_rdata(rr_type* rr, uint8_t* rdata, size_t sz)
{
size_t len = 0;
unsigned i;
assert(rr);
for(i=0; i<rr->rdata_count; i++) {
len += add_rdata(rr, i, rdata+len, sz-len);
}
return len;
}
int
print_rrs(FILE* out, struct zone* zone)
{
rrset_type *rrset;
domain_type *domain = zone->apex;
region_type* region = region_create(xalloc, free);
region_type* rr_region = region_create(xalloc, free);
buffer_type* rr_buffer = buffer_create(region, MAX_RDLENGTH);
struct state_pretty_rr* state = create_pretty_rr(region);
/* first print the SOA record for the zone */
if(zone->soa_rrset) {
size_t i;
for(i=0; i < zone->soa_rrset->rr_count; i++) {
if(!print_rr(out, state, &zone->soa_rrset->rrs[i],
rr_region, rr_buffer)){
log_msg(LOG_ERR, "There was an error "
"printing SOARR to zone %s",
zone->opts->name);
region_destroy(region);
region_destroy(rr_region);
return 0;
}
}
}
/* go through entire tree below the zone apex (incl subzones) */
while(domain && domain_is_subdomain(domain, zone->apex))
{
for(rrset = domain->rrsets; rrset; rrset=rrset->next)
{
size_t i;
if(rrset->zone != zone || rrset == zone->soa_rrset)
continue;
for(i=0; i < rrset->rr_count; i++) {
if(!print_rr(out, state, &rrset->rrs[i],
rr_region, rr_buffer)){
log_msg(LOG_ERR, "There was an error "
"printing RR to zone %s",
zone->opts->name);
region_destroy(region);
region_destroy(rr_region);
return 0;
}
}
}
domain = domain_next(domain);
}
region_destroy(region);
region_destroy(rr_region);
return 1;
}
static int
print_header(zone_type* zone, FILE* out, time_t* now, const char* logs)
{
char buf[4096+16];
/* ctime prints newline at end of this line */
snprintf(buf, sizeof(buf), "; zone %s written by NSD %s on %s",
zone->opts->name, PACKAGE_VERSION, ctime(now));
if(!write_data(out, buf, strlen(buf)))
return 0;
if(!logs || logs[0] == 0) return 1;
snprintf(buf, sizeof(buf), "; %s\n", logs);
return write_data(out, buf, strlen(buf));
}
static int
write_to_zonefile(zone_type* zone, const char* filename, const char* logs)
{
time_t now = time(0);
FILE *out = fopen(filename, "w");
if(!out) {
log_msg(LOG_ERR, "cannot write zone %s file %s: %s",
zone->opts->name, filename, strerror(errno));
return 0;
}
if(!print_header(zone, out, &now, logs)) {
fclose(out);
log_msg(LOG_ERR, "There was an error printing "
"the header to zone %s", zone->opts->name);
return 0;
}
if(!print_rrs(out, zone)) {
fclose(out);
return 0;
}
if(fclose(out) != 0) {
log_msg(LOG_ERR, "cannot write zone %s to file %s: fclose: %s",
zone->opts->name, filename, strerror(errno));
return 0;
}
return 1;
}
/** create directories above this file, .../dir/dir/dir/file */
int
create_dirs(const char* path)
{
char dir[4096];
char* p;
strlcpy(dir, path, sizeof(dir));
/* if we start with / then do not try to create '' */
if(dir[0] == PATHSEP)
p = strchr(dir+1, PATHSEP);
else p = strchr(dir, PATHSEP);
/* create each directory component from the left */
while(p) {
assert(*p == PATHSEP);
*p = 0; /* end the directory name here */
if(mkdir(dir
#ifndef MKDIR_HAS_ONE_ARG
, 0750
#endif
) == -1) {
if(errno != EEXIST) {
log_msg(LOG_ERR, "create dir %s: %s",
dir, strerror(errno));
*p = PATHSEP; /* restore input string */
return 0;
}
/* it already exists, OK, continue */
}
*p = PATHSEP;
p = strchr(p+1, PATHSEP);
}
return 1;
}
/** create pathname components and check if file exists */
static int
create_path_components(const char* path, int* notexist)
{
/* stat the file, to see if it exists, and if its directories exist */
struct stat s;
if(stat(path, &s) != 0) {
if(errno == ENOENT) {
*notexist = 1;
/* see if we need to create pathname components */
return create_dirs(path);
}
log_msg(LOG_ERR, "cannot stat %s: %s", path, strerror(errno));
return 0;
}
*notexist = 0;
return 1;
}
void
namedb_write_zonefile(struct nsd* nsd, struct zone_options* zopt)
{
const char* zfile;
int notexist = 0;
zone_type* zone;
/* if no zone exists, it has no contents or it has no zonefile
* configured, then no need to write data to disk */
if(!zopt->pattern->zonefile)
return;
zone = namedb_find_zone(nsd->db, (const dname_type*)zopt->node.key);
if(!zone || !zone->apex || !zone->soa_rrset)
return;
/* write if file does not exist, or if changed */
/* so, determine filename, create directory components, check exist*/
zfile = config_make_zonefile(zopt, nsd);
if(!create_path_components(zfile, ¬exist)) {
log_msg(LOG_ERR, "could not write zone %s to file %s because "
"the path could not be created", zopt->name, zfile);
return;
}
/* if not changed, do not write. */
if(notexist || zone->is_changed) {
char logs[4096];
char bakfile[4096];
struct timespec mtime;
/* write to zfile~ first, then rename if that works */
snprintf(bakfile, sizeof(bakfile), "%s~", zfile);
if(zone->logstr)
strlcpy(logs, zone->logstr, sizeof(logs));
else
logs[0] = 0;
VERBOSITY(1, (LOG_INFO, "writing zone %s to file %s",
zone->opts->name, zfile));
if(!write_to_zonefile(zone, bakfile, logs)) {
(void)unlink(bakfile); /* delete failed file */
return; /* error already printed */
}
if(rename(bakfile, zfile) == -1) {
log_msg(LOG_ERR, "rename(%s to %s) failed: %s",
bakfile, zfile, strerror(errno));
(void)unlink(bakfile); /* delete failed file */
return;
}
zone->is_changed = 0;
/* fetch the mtime of the just created zonefile so we
* do not waste effort reading it back in */
if(!file_get_mtime(zfile, &mtime, ¬exist)) {
get_time(&mtime);
}
zone->mtime = mtime;
if(zone->filename)
region_recycle(nsd->db->region, zone->filename,
strlen(zone->filename)+1);
zone->filename = region_strdup(nsd->db->region, zfile);
if(zone->logstr)
region_recycle(nsd->db->region, zone->logstr,
strlen(zone->logstr)+1);
zone->logstr = NULL;
if(zone_is_ixfr_enabled(zone) && zone->ixfr)
ixfr_write_to_file(zone, zfile);
}
}
void
namedb_write_zonefiles(struct nsd* nsd, struct nsd_options* options)
{
struct zone_options* zo;
RBTREE_FOR(zo, struct zone_options*, options->zone_options) {
namedb_write_zonefile(nsd, zo);
}
}