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
|
/* Copyright (C) 2024 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <assert.h>
#include "utils/kzonecheck/zone_check.h"
#include "knot/zone/contents.h"
#include "knot/zone/digest.h"
#include "knot/zone/zonefile.h"
#include "knot/zone/zone-dump.h"
#include "utils/common/msg.h"
typedef struct {
sem_handler_t handler;
unsigned errors[SEM_ERR_UNKNOWN + 1]; /*!< Counting errors by type. */
unsigned error_count; /*!< Total error count. */
} err_handler_stats_t;
static void err_callback(sem_handler_t *handler, const zone_contents_t *zone,
const knot_dname_t *node, sem_error_t error, const char *data)
{
assert(handler != NULL);
assert(zone != NULL);
err_handler_stats_t *stats = (err_handler_stats_t *)handler;
knot_dname_txt_storage_t buff;
char *owner = knot_dname_to_str(buff, (node != NULL ? node : zone->apex->owner),
sizeof(buff));
if (owner == NULL) {
owner = "";
}
fprintf(stderr, "[%s] %s%s%s\n", owner, sem_error_msg(error),
(data != NULL ? " " : ""),
(data != NULL ? data : ""));
stats->errors[error]++;
stats->error_count++;
}
static void print_statistics(err_handler_stats_t *stats)
{
fprintf(stderr, "\nError summary:\n");
for (sem_error_t i = 0; i <= SEM_ERR_UNKNOWN; ++i) {
if (stats->errors[i] > 0) {
fprintf(stderr, "%4u\t%s\n", stats->errors[i], sem_error_msg(i));
}
}
}
int zone_check(const char *zone_file, const knot_dname_t *zone_name, bool zonemd,
uint32_t dflt_ttl, semcheck_optional_t optional, time_t time, bool print)
{
err_handler_stats_t stats = {
.handler = { .cb = err_callback },
};
zloader_t zl;
int ret = zonefile_open(&zl, zone_file, zone_name, dflt_ttl, optional, time);
switch (ret) {
case KNOT_EOK:
break;
case KNOT_EACCES:
case KNOT_EFILE:
ERR2("failed to load the zone file");
return ret;
default:
ERR2("failed to run semantic checks (%s)", knot_strerror(ret));
return ret;
}
zl.err_handler = (sem_handler_t *)&stats;
zl.creator->master = true;
zone_contents_t *contents = zonefile_load(&zl);
zonefile_close(&zl);
if (contents == NULL && !stats.handler.error) {
ERR2("failed to run semantic checks");
return KNOT_ERROR;
}
if (stats.error_count > 0) {
print_statistics(&stats);
if (stats.handler.error) {
fprintf(stderr, "\n");
ERR2("serious semantic error detected");
ret = KNOT_EINVAL;
} else {
ret = KNOT_ESEMCHECK;
}
}
if (zonemd) {
ret = zone_contents_digest_verify(contents);
if (ret != KNOT_EOK) {
if (stats.error_count > 0 && !stats.handler.error) {
fprintf(stderr, "\n");
}
ERR2("invalid ZONEMD");
}
}
if (print) {
if (ret != KNOT_EOK) {
fprintf(stderr, "\n");
}
printf(";; Zone dump (Knot DNS %s)\n", PACKAGE_VERSION);
zone_dump_text(contents, stdout, false, NULL);
}
zone_contents_deep_free(contents);
return ret;
}
|
