zscanner: apply new interface

src/knot/ctl/knotc_main.c

@@ -750,11 +750,11 @@ static int cmd_memstats(int argc, char *argv[], unsigned flags)
 		}
 
 		/* Create file loader. */
-		file_loader_t *loader = file_loader_create(zone->file, zone->name,
-		                                           KNOT_CLASS_IN, 3600,
-		                                           estimator_rrset_memsize_wrap,
-		                                           process_error,
-		                                           &est);
+		zs_loader_t *loader = zs_loader_create(zone->file, zone->name,
+		                                       KNOT_CLASS_IN, 3600,
+		                                       estimator_rrset_memsize_wrap,
+		                                       process_error,
+		                                       &est);
 		if (loader == NULL) {
 			rc = 1;
 			log_zone_error("Could not load zone %s\n", zone->name);
@@ -764,13 +764,13 @@ static int cmd_memstats(int argc, char *argv[], unsigned flags)
 		}
 
 		/* Do a parser run, but do not actually create the zone. */
-		int ret = file_loader_process(loader);
+		int ret = zs_loader_process(loader);
 		if (ret != KNOT_EOK) {
 			rc = 1;
 			log_zone_error("Failed to parse zone %s.\n", zone->name);
 			hattrie_apply_rev(est.node_table, estimator_free_trie_node, NULL);
 			hattrie_free(est.node_table);
-			file_loader_free(loader);
+			zs_loader_free(loader);
 			break;
 		}
 
@@ -791,7 +791,7 @@ static int cmd_memstats(int argc, char *argv[], unsigned flags)
 
 		log_zone_info("Zone %s: %zu RRs, used memory estimation is %zuMB.\n",
 		              zone->name, est.record_count, zone_size);
-		file_loader_free(loader);
+		zs_loader_free(loader);
 		total_size += zone_size;
 	}
 

src/knot/zone/estimator.c

@@ -21,7 +21,7 @@
 #include "libknot/dname.h"
 #include "common/lists.h"
 #include "knot/zone/node.h"
-#include "zscanner/scanner.h"
+#include "zscanner/zscanner.h"
 #include "common/descriptor.h"
 
 // Constants used for tweaking, mostly malloc overhead
@@ -108,7 +108,7 @@ static int insert_dname_into_table(hattrie_t *table, knot_dname_t *d,
 	}
 }
 
-static void rrset_memsize(zone_estim_t *est, const scanner_t *scanner)
+static void rrset_memsize(zone_estim_t *est, const zs_scanner_t *scanner)
 {
 	// Handle RRSet's owner
 	knot_dname_t *owner = knot_dname_copy(scanner->r_owner);
@@ -206,7 +206,7 @@ size_t estimator_trie_ahtable_memsize(hattrie_t *table)
 	return size;
 }
 
-void estimator_rrset_memsize_wrap(const scanner_t *scanner)
+void estimator_rrset_memsize_wrap(const zs_scanner_t *scanner)
 {
 	rrset_memsize(scanner->data, scanner);
 }

src/knot/zone/estimator.h

@@ -28,7 +28,7 @@
 #define _KNOT_ESTIMATOR_H_
 
 #include "common/hattrie/hat-trie.h"
-#include "zscanner/scanner.h"
+#include "zscanner/zscanner.h"
 
 // Mutiplicative constant, needed because of malloc's fragmentation
 static const double ESTIMATE_MAGIC = 1.2;
@@ -76,7 +76,7 @@ size_t estimator_trie_ahtable_memsize(hattrie_t *table);
  *
  * \param scanner Scanner context.
  */
-void estimator_rrset_memsize_wrap(const scanner_t *scanner);
+void estimator_rrset_memsize_wrap(const zs_scanner_t *scanner);
 
 /*!
  * \brief Cleanup function for use with hattrie.

src/knot/zone/zone-create.c

@@ -34,24 +34,24 @@
 #include "knot/dnssec/zone-nsec.h"
 #include "knot/other/debug.h"
 #include "knot/zone/zone-create.h"
-#include "zscanner/file_loader.h"
+#include "zscanner/zscanner.h"
 #include "libknot/rdata.h"
 
-void process_error(const scanner_t *s)
+void process_error(const zs_scanner_t *s)
 {
 	if (s->stop == true) {
 		log_zone_error("Fatal error in zone file %s:%"PRIu64": %s "
 		               "Stopping zone loading.\n",
 		               s->file_name, s->line_counter,
-		               zscanner_strerror(s->error_code));
+		               zs_strerror(s->error_code));
 	} else {
 		log_zone_error("Error in zone file %s:%"PRIu64": %s\n",
 		               s->file_name, s->line_counter,
-		               zscanner_strerror(s->error_code));
+		               zs_strerror(s->error_code));
 	}
 }
 
-static int add_rdata_to_rr(knot_rrset_t *rrset, const scanner_t *scanner)
+static int add_rdata_to_rr(knot_rrset_t *rrset, const zs_scanner_t *scanner)
 {
 	return knot_rrset_add_rr(rrset, scanner->r_data, scanner->r_data_length,
 	                         scanner->r_ttl, NULL);
@@ -134,7 +134,7 @@ int zcreator_step(zcreator_t *zc, knot_rrset_t *rr)
 }
 
 /*! \brief Creates RR from parser input, passes it to handling function. */
-static void loader_process(const scanner_t *scanner)
+static void loader_process(const zs_scanner_t *scanner)
 {
 	zcreator_t *zc = scanner->data;
 	if (zc->ret != KNOT_EOK) {
@@ -219,10 +219,10 @@ int zonefile_open(zloader_t *loader, const conf_zone_t *conf)
 
 	/* Create file loader. */
 	memset(loader, 0, sizeof(zloader_t));
-	loader->file_loader = file_loader_create(conf->file, conf->name,
-	                                         KNOT_CLASS_IN, 3600,
-	                                         loader_process, process_error,
-	                                         zc);
+	loader->file_loader = zs_loader_create(conf->file, conf->name,
+	                                       KNOT_CLASS_IN, 3600,
+	                                       loader_process, process_error,
+	                                       zc);
 	if (loader->file_loader == NULL) {
 		free(zc);
 		return KNOT_ERROR;
@@ -246,10 +246,10 @@ knot_zone_contents_t *zonefile_load(zloader_t *loader)
 
 	zcreator_t *zc = loader->creator;
 	assert(zc);
-	int ret = file_loader_process(loader->file_loader);
+	int ret = zs_loader_process(loader->file_loader);
 	if (ret != ZSCANNER_OK) {
 		log_zone_error("%s: zone file could not be loaded (%s).\n",
-		               loader->source, zscanner_strerror(ret));
+		               loader->source, zs_strerror(ret));
 		goto fail;
 	}
 
@@ -322,7 +322,7 @@ void zonefile_close(zloader_t *loader)
 		return;
 	}
 
-	file_loader_free(loader->file_loader);
+	zs_loader_free(loader->file_loader);
 
 	free(loader->source);
 	free(loader->origin);

src/knot/zone/zone-create.h

@@ -49,7 +49,7 @@ typedef struct zloader_t {
 	char *origin;                /*!< Zone's origin string. */
 	bool semantic_checks;        /*!< Do semantic checks. */
 	err_handler_t *err_handler;  /*!< Semantic checks error handler. */
-	file_loader_t *file_loader;  /*!< Scanner's file loader. */
+	zs_loader_t *file_loader;    /*!< Scanner's file loader. */
 	zcreator_t *creator;         /*!< Loader context. */
 } zloader_t;
 
@@ -83,7 +83,7 @@ void zonefile_close(zloader_t *loader);
 
 int zcreator_step(zcreator_t *zl, knot_rrset_t *rr);
 
-void process_error(const scanner_t *scanner);
+void process_error(const zs_scanner_t *scanner);
 
 #endif /* _KNOTD_ZONELOAD_H_ */
 

src/libknot/dnssec/key.c

@@ -94,7 +94,7 @@ static char *strndup_with_suffix(const char *base, int length, char *suffix)
 	return result;
 }
 
-static void key_scan_set_done(const scanner_t *s)
+static void key_scan_set_done(const zs_scanner_t *s)
 {
 	*((bool *)s->data) = true;
 }
@@ -115,8 +115,8 @@ static int get_key_info_from_public_key(const char *filename,
 		return KNOT_KEY_EPUBLIC_KEY_OPEN;
 	}
 
-	scanner_t *scanner = scanner_create(filename, ".", KNOT_CLASS_IN, 0,
-	                                    NULL, NULL, NULL);
+	zs_scanner_t *scanner = zs_scanner_create(filename, ".", KNOT_CLASS_IN,
+	                                          0, NULL, NULL, NULL);
 	if (!scanner) {
 		fclose(keyfile);
 		return KNOT_ENOMEM;
@@ -144,21 +144,21 @@ static int get_key_info_from_public_key(const char *filename,
 			last_block = true;
 			read = 0;
 		}
-		result = scanner_process(buffer, buffer + read, last_block,
-		                         scanner);
+		result = zs_scanner_process(buffer, buffer + read, last_block,
+		                            scanner);
 	}
 
 	free(buffer);
 	fclose(keyfile);
 
 	if (scanner->r_type != KNOT_RRTYPE_DNSKEY) {
-		scanner_free(scanner);
+		zs_scanner_free(scanner);
 		return KNOT_KEY_EPUBLIC_KEY_INVALID;
 	}
 
 	knot_dname_t *owner = knot_dname_copy(scanner->r_owner);
 	if (!owner) {
-		scanner_free(scanner);
+		zs_scanner_free(scanner);
 		return KNOT_ENOMEM;
 	}
 	knot_dname_to_lower(owner);
@@ -167,7 +167,7 @@ static int get_key_info_from_public_key(const char *filename,
 	result = knot_binary_from_string(scanner->r_data, scanner->r_data_length,
 	                                 &rdata_bin);
 	if (result != KNOT_EOK) {
-		scanner_free(scanner);
+		zs_scanner_free(scanner);
 		knot_dname_free(&owner);
 		return result;
 	}
@@ -175,7 +175,7 @@ static int get_key_info_from_public_key(const char *filename,
 	*name = owner;
 	*rdata = rdata_bin;
 
-	scanner_free(scanner);
+	zs_scanner_free(scanner);
 
 	return KNOT_EOK;
 }

src/utils/nsupdate/nsupdate_exec.c

@@ -139,13 +139,13 @@ static int dname_isvalid(const char *lp, size_t len) {
 }
 
 /* This is probably redundant, but should be a bit faster so let's keep it. */
-static int parse_full_rr(scanner_t *s, const char* lp)
+static int parse_full_rr(zs_scanner_t *s, const char* lp)
 {
-	if (scanner_process(lp, lp + strlen(lp), 0, s) < 0) {
+	if (zs_scanner_process(lp, lp + strlen(lp), 0, s) < 0) {
 		return KNOT_EPARSEFAIL;
 	}
 	char nl = '\n'; /* Ensure newline after complete RR */
-	if (scanner_process(&nl, &nl+sizeof(char), 1, s) < 0) { /* Terminate */
+	if (zs_scanner_process(&nl, &nl+sizeof(char), 1, s) < 0) { /* Terminate */
 		return KNOT_EPARSEFAIL;
 	}
 
@@ -160,7 +160,7 @@ static int parse_full_rr(scanner_t *s, const char* lp)
 	return KNOT_EOK;
 }
 
-static int parse_partial_rr(scanner_t *s, const char *lp, unsigned flags) {
+static int parse_partial_rr(zs_scanner_t *s, const char *lp, unsigned flags) {
 	int ret = KNOT_EOK;
 	char b1[32], b2[32]; /* Should suffice for both class/type */
 
@@ -246,7 +246,7 @@ static int parse_partial_rr(scanner_t *s, const char *lp, unsigned flags) {
 	/* Need to parse rdata, synthetize input. */
 	char *rr = sprintf_alloc("%s %u %s %s %s\n",
 	                         owner_s, s->r_ttl, b1, b2, lp);
-	if (scanner_process(rr, rr + strlen(rr), 1, s) < 0) {
+	if (zs_scanner_process(rr, rr + strlen(rr), 1, s) < 0) {
 		ret = KNOT_EPARSEFAIL;
 	}
 
@@ -289,7 +289,7 @@ static srv_info_t *parse_host(const char *lp, const char* default_port)
 }
 
 /* Append parsed RRSet to list. */
-static int rr_list_append(scanner_t *s, list_t *target_list, mm_ctx_t *mm)
+static int rr_list_append(zs_scanner_t *s, list_t *target_list, mm_ctx_t *mm)
 {
 	/* Form a rrset. */
 	knot_dname_t *owner = knot_dname_copy(s->r_owner);
@@ -541,7 +541,7 @@ int cmd_del(const char* lp, nsupdate_params_t *params)
 {
 	DBG("%s: lp='%s'\n", __func__, lp);
 
-	scanner_t *rrp = params->parser;
+	zs_scanner_t *rrp = params->parser;
 	if (parse_partial_rr(rrp, lp, PARSE_NODEFAULT) != KNOT_EOK) {
 		return KNOT_EPARSEFAIL;
 	}
@@ -575,7 +575,7 @@ int cmd_class(const char* lp, nsupdate_params_t *params)
 		return KNOT_EPARSEFAIL;
 	} else {
 		params->class_num = cls;
-		scanner_t *s = params->parser;
+		zs_scanner_t *s = params->parser;
 		s->default_class = params->class_num;
 	}
 
@@ -609,7 +609,7 @@ int cmd_prereq_domain(const char *lp, nsupdate_params_t *params, unsigned type)
 	UNUSED(type);
 	DBG("%s: lp='%s'\n", __func__, lp);
 
-	scanner_t *s = params->parser;
+	zs_scanner_t *s = params->parser;
 	int ret = parse_partial_rr(s, lp, PARSE_NODEFAULT|PARSE_NAMEONLY);
 	if (ret != KNOT_EOK) {
 		return ret;
@@ -623,7 +623,7 @@ int cmd_prereq_rrset(const char *lp, nsupdate_params_t *params, unsigned type)
 	UNUSED(type);
 	DBG("%s: lp='%s'\n", __func__, lp);
 
-	scanner_t *rrp = params->parser;
+	zs_scanner_t *rrp = params->parser;
 	if (parse_partial_rr(rrp, lp, 0) != KNOT_EOK) {
 		return KNOT_EPARSEFAIL;
 	}
@@ -664,7 +664,7 @@ int cmd_prereq(const char* lp, nsupdate_params_t *params)
 
 	/* Append to packet. */
 	if (ret == KNOT_EOK) {
-		scanner_t *s = params->parser;
+		zs_scanner_t *s = params->parser;
 		s->r_ttl = 0; /* Set TTL = 0 for prereq. */
 		/* YX{RRSET,DOMAIN} - cls ANY */
 		if (prereq_type == PQ_YXRRSET || prereq_type == PQ_YXDOMAIN) {

src/utils/nsupdate/nsupdate_params.c

@@ -54,11 +54,11 @@ static const style_t DEFAULT_STYLE_NSUPDATE = {
 	.show_footer = false,
 };
 
-static void parse_err(const scanner_t *s) {
-	ERR("failed to parse RR: %s\n", zscanner_strerror(s->error_code));
+static void parse_err(const zs_scanner_t *s) {
+	ERR("failed to parse RR: %s\n", zs_strerror(s->error_code));
 }
 
-static int parser_set_default(scanner_t *s, const char *fmt, ...)
+static int parser_set_default(zs_scanner_t *s, const char *fmt, ...)
 {
 	/* Format string. */
 	char buf[512]; /* Must suffice for domain name and TTL. */
@@ -72,7 +72,7 @@ static int parser_set_default(scanner_t *s, const char *fmt, ...)
 	}
 
 	/* fmt must contain newline */
-	if (scanner_process(buf, buf + n, 1, s) < 0) {
+	if (zs_scanner_process(buf, buf + n, 1, s) < 0) {
 		return KNOT_EPARSEFAIL;
 	}
 
@@ -107,8 +107,8 @@ static int nsupdate_init(nsupdate_params_t *params)
 	params->zone = strdup(".");
 
 	/* Initialize RR parser. */
-	params->parser = scanner_create(NULL, ".", params->class_num, 0, NULL,
-	                             parse_err, NULL);
+	params->parser = zs_scanner_create(NULL, ".", params->class_num, 0,
+	                                   NULL, parse_err, NULL);
 	if (!params->parser)
 		return KNOT_ENOMEM;
 
@@ -137,7 +137,7 @@ void nsupdate_clean(nsupdate_params_t *params)
 	srv_info_free(params->server);
 	srv_info_free(params->srcif);
 	free(params->zone);
-	scanner_free(params->parser);
+	zs_scanner_free(params->parser);
 	knot_pkt_free(&params->query);
 	knot_pkt_free(&params->answer);
 	knot_free_key_params(&params->key_params);

src/utils/nsupdate/nsupdate_params.h

@@ -31,7 +31,7 @@
 
 #include "libknot/libknot.h"
 #include "common/lists.h"		// list
-#include "zscanner/zscanner.h"		// scanner_t
+#include "zscanner/zscanner.h"		// zs_scanner_t
 #include "utils/common/netio.h"		// server_t
 #include "utils/common/params.h"	// protocol_t
 #include "libknot/dnssec/key.h"		// knot_key_params_t
@@ -68,7 +68,7 @@ typedef struct {
 	/*!< Current zone. */
 	char		*zone;
 	/*!< RR parser. */
-	scanner_t	*parser;
+	zs_scanner_t	*parser;
 	/*!< Current packet. */
 	knot_pkt_t	*query;
 	/*!< Current response. */