define-tag and local-zone-tag configuration.

git-svn-id: file:///svn/unbound/trunk@3708 be551aaa-1e26-0410-a405-d3ace91eadb9

doc/example.conf.in

@@ -481,6 +481,10 @@ server:
 	# plain value in bytes or you can append k, m or G. default is "1Mb".
 	# neg-cache-size: 1m
 
+	# define a number of tags here, you can use them to tag localzones.
+	# repeat the define-tag statement to add additional tags.
+	# define-tag: "tag1 tag2 tag3"
+
 	# By default, for a number of zones a small default 'nothing here'
 	# reply is built-in.  Query traffic is thus blocked.  If you
 	# wish to serve such zone you can unblock them by uncommenting one
@@ -573,6 +577,9 @@ server:
 	# you need to do the reverse notation yourself.
 	# local-data-ptr: "192.0.2.3 www.example.com"
 
+	# tag a localzone with a list of tag names (in "" with spaces between)
+	# local-zone-tag: "example.com" "tag2 tag3"
+
 	# service clients over SSL (on the TCP sockets), with plain DNS inside
 	# the SSL stream.  Give the certificate to use and private key.
 	# default is "" (disabled).  requires restart to take effect.

services/localzone.c

@@ -94,6 +94,7 @@ local_zone_delete(struct local_zone* z)
 	lock_rw_destroy(&z->lock);
 	regional_destroy(z->region);
 	free(z->name);
+	free(z->taglist);
 	free(z);
 }
 
@@ -506,6 +507,40 @@ lz_enter_rr_str(struct local_zones* zones, const char* rr)
 	return r;
 }
 
+/** enter tagstring into zone */
+static int
+lz_enter_zone_tag(struct local_zones* zones, char* zname, uint8_t* list,
+	size_t len, uint16_t rr_class)
+{
+	uint8_t dname[LDNS_MAX_DOMAINLEN+1];
+	size_t dname_len, dname_labs;
+	struct local_zone* z;
+	int r = 0;
+
+	if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) {
+		log_err("cannot parse zone name in local-zone-tag: %s", zname);
+		return 0;
+	}
+	dname_labs = dname_count_labels(dname);
+	
+	lock_rw_rdlock(&zones->lock);
+	z = local_zones_lookup(zones, dname, dname_len, dname_labs, rr_class);
+	if(!z) {
+		lock_rw_unlock(&zones->lock);
+		log_err("no local-zone for tag %s", zname);
+		return 0;
+	}
+	lock_rw_wrlock(&z->lock);
+	lock_rw_unlock(&zones->lock);
+	free(z->taglist);
+	z->taglist = memdup(list, len);
+	z->taglen = len;
+	if(z->taglist)
+		r = 1;
+	lock_rw_unlock(&z->lock);
+	return r;
+}
+
 /** parse local-zone: statements */
 static int
 lz_enter_zones(struct local_zones* zones, struct config_file* cfg)
@@ -800,6 +835,22 @@ lz_setup_implicit(struct local_zones* zones, struct config_file* cfg)
 	return 1;
 }
 
+/** enter local-zone-tag info */
+static int
+lz_enter_zone_tags(struct local_zones* zones, struct config_file* cfg)
+{
+	struct config_strbytelist* p;
+	int c = 0;
+	for(p = cfg->local_zone_tags; p; p = p->next) {
+		if(!lz_enter_zone_tag(zones, p->str, p->str2, p->str2len,
+			LDNS_RR_CLASS_IN))
+			return 0;
+		c++;
+	}
+	if(c) verbose(VERB_ALGO, "applied tags to %d local zones", c);
+	return 1;
+}
+	
 /** enter auth data */
 static int
 lz_enter_data(struct local_zones* zones, struct config_file* cfg)
@@ -842,6 +893,10 @@ local_zones_apply_cfg(struct local_zones* zones, struct config_file* cfg)
 
 	/* setup parent ptrs for lookup during data entry */
 	init_parents(zones);
+	/* insert local zone tags */
+	if(!lz_enter_zone_tags(zones, cfg)) {
+		return 0;
+	}
 	/* insert local data */
 	if(!lz_enter_data(zones, cfg)) {
 		return 0;

services/localzone.h

@@ -115,6 +115,10 @@ struct local_zone {
 
 	/** how to process zone */
 	enum localzone_type type;
+	/** tag bitlist */
+	uint8_t* taglist;
+	/** length of the taglist (in bytes) */
+	size_t taglen;
 
 	/** in this region the zone's data is allocated.
 	 * the struct local_zone itself is malloced. */

testcode/unitmain.c

@@ -380,6 +380,28 @@ config_memsize_test(void)
 	unit_assert( cfg_parse_memsize("0 Gb", &v) && v==0*1024*1024);
 }
 
+/** test config_file: test tag code */
+static void
+config_tag_test(void) 
+{
+	unit_show_func("util/config_file.c", "taglist_intersect");
+	unit_assert( taglist_intersect(
+		(uint8_t*)"\000\000\000", 3, (uint8_t*)"\001\000\001", 3
+		) == 0);
+	unit_assert( taglist_intersect(
+		(uint8_t*)"\000\000\001", 3, (uint8_t*)"\001\000\001", 3
+		) == 1);
+	unit_assert( taglist_intersect(
+		(uint8_t*)"\001\000\000", 3, (uint8_t*)"\001\000\001", 3
+		) == 1);
+	unit_assert( taglist_intersect(
+		(uint8_t*)"\001", 1, (uint8_t*)"\001\000\001", 3
+		) == 1);
+	unit_assert( taglist_intersect(
+		(uint8_t*)"\001\000\001", 3, (uint8_t*)"\001", 1
+		) == 1);
+}
+	
 #include "util/rtt.h"
 /** test RTT code */
 static void
@@ -577,6 +599,7 @@ main(int argc, char* argv[])
 	verify_test();
 	net_test();
 	config_memsize_test();
+	config_tag_test();
 	dname_test();
 	rtt_test();
 	anchors_test();

util/config_file.c

@@ -483,9 +483,11 @@ int config_set_option(struct config_file* cfg, const char* opt,
 	else S_POW2("ratelimit-slabs:", ratelimit_slabs)
 	else S_NUMBER_OR_ZERO("ratelimit-factor:", ratelimit_factor)
 	else S_YNO("qname-minimisation:", qname_minimisation)
+	else if(strcmp(opt, "define-tag:") ==0) {
+		return config_add_tag(cfg, val);
 	/* val_sig_skew_min and max are copied into val_env during init,
 	 * so this does not update val_env with set_option */
-	else if(strcmp(opt, "val-sig-skew-min:") == 0)
+	} else if(strcmp(opt, "val-sig-skew-min:") == 0)
 	{ IS_NUMBER_OR_ZERO; cfg->val_sig_skew_min = (int32_t)atoi(val); }
 	else if(strcmp(opt, "val-sig-skew-max:") == 0)
 	{ IS_NUMBER_OR_ZERO; cfg->val_sig_skew_max = (int32_t)atoi(val); }
@@ -506,7 +508,8 @@ int config_set_option(struct config_file* cfg, const char* opt,
 		 * stub-zone, name, stub-addr, stub-host, stub-prime
 		 * forward-first, stub-first,
 		 * forward-zone, name, forward-addr, forward-host,
-		 * ratelimit-for-domain, ratelimit-below-domain */
+		 * ratelimit-for-domain, ratelimit-below-domain,
+		 * local-zone-tag */
 		return 0;
 	}
 	return 1;
@@ -630,9 +633,23 @@ config_collate_cat(struct config_strlist* list)
 /** compare and print list option */
 #define O_LS2(opt, name, lst) if(strcmp(opt, name)==0) { \
 	struct config_str2list* p = cfg->lst; \
-	for(p = cfg->lst; p; p = p->next) \
-		snprintf(buf, len, "%s %s\n", p->str, p->str2); \
+	for(p = cfg->lst; p; p = p->next) { \
+		snprintf(buf, len, "%s %s", p->str, p->str2); \
 		func(buf, arg); \
+	} \
+	}
+/** compare and print taglist option */
+#define O_LTG(opt, name, lst) if(strcmp(opt, name)==0) { \
+	char* tmpstr = NULL; \
+	struct config_strbytelist *p = cfg->lst; \
+	for(p = cfg->lst; p; p = p->next) {\
+		tmpstr = config_taglist2str(cfg, p->str2, p->str2len); \
+		if(tmpstr) {\
+			snprintf(buf, len, "%s %s", p->str, tmpstr); \
+			func(buf, arg); \
+			free(tmpstr); \
+		} \
+	} \
 	}
 
 int
@@ -762,6 +779,8 @@ config_get_option(struct config_file* cfg, const char* opt,
 	else O_DEC(opt, "val-sig-skew-min", val_sig_skew_min)
 	else O_DEC(opt, "val-sig-skew-max", val_sig_skew_max)
 	else O_YNO(opt, "qname-minimisation", qname_minimisation)
+	else O_IFC(opt, "define-tag", num_tags, tagname)
+	else O_LTG(opt, "local-zone-tag", local_zone_tags)
 	/* not here:
 	 * outgoing-permit, outgoing-avoid - have list of ports
 	 * local-zone - zones and nodefault variables
@@ -934,6 +953,33 @@ config_delstubs(struct config_stub* p)
 	}
 }
 
+/** delete string array */
+static void
+config_del_strarray(char** array, int num)
+{
+	int i;
+	if(!array)
+		return;
+	for(i=0; i<num; i++) {
+		free(array[i]);
+	}
+	free(array);
+}
+
+/** delete stringbytelist */
+static void
+config_del_strbytelist(struct config_strbytelist* p)
+{
+	struct config_strbytelist* np;
+	while(p) {
+		np = p->next;
+		free(p->str);
+		free(p->str2);
+		free(p);
+		p = np;
+	}
+}
+
 void 
 config_delete(struct config_file* cfg)
 {
@@ -946,18 +992,8 @@ config_delete(struct config_file* cfg)
 	free(cfg->target_fetch_policy);
 	free(cfg->ssl_service_key);
 	free(cfg->ssl_service_pem);
-	if(cfg->ifs) {
-		int i;
-		for(i=0; i<cfg->num_ifs; i++)
-			free(cfg->ifs[i]);
-		free(cfg->ifs);
-	}
-	if(cfg->out_ifs) {
-		int i;
-		for(i=0; i<cfg->num_out_ifs; i++)
-			free(cfg->out_ifs[i]);
-		free(cfg->out_ifs);
-	}
+	config_del_strarray(cfg->ifs, cfg->num_ifs);
+	config_del_strarray(cfg->out_ifs, cfg->num_out_ifs);
 	config_delstubs(cfg->stubs);
 	config_delstubs(cfg->forwards);
 	config_delstrlist(cfg->donotqueryaddrs);
@@ -981,6 +1017,8 @@ config_delete(struct config_file* cfg)
 	config_deldblstrlist(cfg->local_zones);
 	config_delstrlist(cfg->local_zones_nodefault);
 	config_delstrlist(cfg->local_data);
+	config_del_strarray(cfg->tagname, cfg->num_tags);
+	config_del_strbytelist(cfg->local_zone_tags);
 	config_delstrlist(cfg->control_ifs);
 	free(cfg->server_key_file);
 	free(cfg->server_cert_file);
@@ -1169,6 +1207,24 @@ cfg_str2list_insert(struct config_str2list** head, char* item, char* i2)
 	return 1;
 }
 
+int
+cfg_strbytelist_insert(struct config_strbytelist** head, char* item,
+	uint8_t* i2, size_t i2len)
+{
+	struct config_strbytelist* s;
+	if(!item || !i2 || !head)
+		return 0;
+	s = (struct config_strbytelist*)calloc(1, sizeof(*s));
+	if(!s)
+		return 0;
+	s->str = item;
+	s->str2 = i2;
+	s->str2len = i2len;
+	s->next = *head;
+	*head = s;
+	return 1;
+}
+
 time_t 
 cfg_convert_timeval(const char* str)
 {
@@ -1273,6 +1329,124 @@ cfg_parse_memsize(const char* str, size_t* res)
 	return 1;
 }
 
+int
+find_tag_id(struct config_file* cfg, const char* tag)
+{
+	int i;
+	for(i=0; i<cfg->num_tags; i++) {
+		if(strcmp(cfg->tagname[i], tag) == 0)
+			return i;
+	}
+	return -1;
+}
+
+int
+config_add_tag(struct config_file* cfg, const char* tag)
+{
+	char** newarray;
+	char* newtag;
+	if(find_tag_id(cfg, tag) != -1)
+		return 1; /* nothing to do */
+	newarray = (char**)malloc(sizeof(char*)*(cfg->num_tags+1));
+	if(!newarray)
+		return 0;
+	newtag = strdup(tag);
+	if(!newtag) {
+		free(newarray);
+		return 0;
+	}
+	if(cfg->tagname) {
+		memcpy(newarray, cfg->tagname, sizeof(char*)*cfg->num_tags);
+		free(cfg->tagname);
+	}
+	newarray[cfg->num_tags] = newtag;
+	cfg->tagname = newarray;
+	cfg->num_tags++;
+	return 1;
+}
+
+/** set a bit in a bit array */
+static void
+cfg_set_bit(uint8_t* bitlist, size_t len, int id)
+{
+	int pos = id/8;
+	log_assert((size_t)pos < len);
+	bitlist[pos] |= 1<<(id%8);
+}
+
+uint8_t* config_parse_taglist(struct config_file* cfg, char* str,
+        size_t* listlen)
+{
+	uint8_t* taglist = NULL;
+	size_t len = 0;
+	char* p, *s;
+
+	/* allocate */
+	if(cfg->num_tags == 0) {
+		log_err("parse taglist, but no tags defined");
+		return 0;
+	}
+	len = (cfg->num_tags+7)/8;
+	taglist = calloc(1, len);
+	if(!taglist) {
+		log_err("out of memory");
+		return 0;
+	}
+	
+	/* parse */
+	s = str;
+	while((p=strsep(&s, " \t\n")) != NULL) {
+		if(*p) {
+			int id = find_tag_id(cfg, p);
+			/* set this bit in the bitlist */
+			if(id == -1) {
+				log_err("unknown tag: %s", p);
+				free(taglist);
+				return 0;
+			}
+			cfg_set_bit(taglist, len, id);
+		}
+	}
+
+	*listlen = len;
+	return taglist;
+}
+
+char* config_taglist2str(struct config_file* cfg, uint8_t* taglist,
+        size_t taglen)
+{
+	char buf[10240];
+	size_t i, len = 0;
+	int j;
+	buf[0] = 0;
+	for(i=0; i<taglen; i++) {
+		if(taglist[i] == 0)
+			continue;
+		for(j=0; j<8; j++) {
+			if((taglist[i] & (1<<j)) != 0) {
+				int id = i*8 + j;
+				snprintf(buf+len, sizeof(buf)-len, "%s%s",
+					(len==0?"":" "), cfg->tagname[id]);
+				len += strlen(buf+len);
+			}
+		}
+	}
+	return strdup(buf);
+}
+
+int taglist_intersect(uint8_t* list1, size_t list1len, uint8_t* list2,
+	size_t list2len)
+{
+	size_t i;
+	if(!list1 || !list2)
+		return 0;
+	for(i=0; i<list1len && i<list2len; i++) {
+		if((list1[i] & list2[i]) != 0)
+			return 1;
+	}
+	return 0;
+}
+
 void 
 config_apply(struct config_file* config)
 {

util/config_file.h

@@ -44,6 +44,7 @@
 struct config_stub;
 struct config_strlist;
 struct config_str2list;
+struct config_strbytelist;
 struct module_qstate;
 struct sock_list;
 struct ub_packed_rrset_key;
@@ -295,6 +296,12 @@ struct config_file {
 	int unblock_lan_zones;
 	/** insecure lan zones (don't validate AS112 zones) */
 	int insecure_lan_zones;
+	/** list of zonename, tagbitlist */
+	struct config_strbytelist* local_zone_tags;
+	/** tag list, array with tagname[i] is malloced string */
+	char** tagname;
+	/** number of items in the taglist */
+	int num_tags;
 
 	/** remote control section. enable toggle. */
 	int remote_control_enable;
@@ -423,6 +430,19 @@ struct config_str2list {
 	char* str2;
 };
 
+/**
+ * List of string, bytestring for config options
+ */
+struct config_strbytelist {
+	/** next item in list */
+	struct config_strbytelist* next;
+	/** first string */
+	char* str;
+	/** second bytestring */
+	uint8_t* str2;
+	size_t str2len;
+};
+
 /** List head for strlist processing, used for append operation. */
 struct config_strlist_head {
 	/** first in list of text items */
@@ -561,6 +581,17 @@ int cfg_strlist_insert(struct config_strlist** head, char* item);
  */
 int cfg_str2list_insert(struct config_str2list** head, char* item, char* i2);
 
+/**
+ * Insert string into strbytelist.
+ * @param head: pointer to str2list head variable.
+ * @param item: new item. malloced by caller. If NULL the insertion fails.
+ * @param i2: 2nd string, malloced by caller. If NULL the insertion fails.
+ * @param i2len: length of the i2 bytestring.
+ * @return: true on success.
+ */
+int cfg_strbytelist_insert(struct config_strbytelist** head, char* item,
+	uint8_t* i2, size_t i2len);
+
 /**
  * Find stub in config list, also returns prevptr (for deletion).
  * @param pp: call routine with pointer to a pointer to the start of the list,
@@ -626,6 +657,54 @@ int cfg_count_numbers(const char* str);
  */
 int cfg_parse_memsize(const char* str, size_t* res);
 
+/**
+ * Add a tag name to the config.  It is added at the end with a new ID value.
+ * @param cfg: the config structure.
+ * @param tag: string (which is copied) with the name.
+ * @return: false on alloc failure.
+ */
+int config_add_tag(struct config_file* cfg, const char* tag);
+
+/**
+ * Find tag ID in the tag list.
+ * @param cfg: the config structure.
+ * @param tag: string with tag name to search for.
+ * @return: 0..(num_tags-1) with tag ID, or -1 if tagname is not found.
+ */
+int find_tag_id(struct config_file* cfg, const char* tag);
+
+/**
+ * parse taglist from string into bytestring with bitlist.
+ * @param cfg: the config structure (with tagnames)
+ * @param str: the string to parse.  Parse puts 0 bytes in string. 
+ * @param listlen: returns length of in bytes.
+ * @return malloced bytes with a bitlist of the tags.  or NULL on parse error
+ * or malloc failure.
+ */
+uint8_t* config_parse_taglist(struct config_file* cfg, char* str,
+	size_t* listlen);
+
+/**
+ * convert tag bitlist to a malloced string with tag names.  For debug output.
+ * @param cfg: the config structure (with tagnames)
+ * @param taglist: the tag bitlist.
+ * @param len: length of the tag bitlist.
+ * @return malloced string or NULL.
+ */
+char* config_taglist2str(struct config_file* cfg, uint8_t* taglist,
+	size_t len);
+
+/**
+ * see if two taglists intersect (have tags in common).
+ * @param list1: first tag bitlist.
+ * @param list1len: length in bytes of first list.
+ * @param list2: second tag bitlist.
+ * @param list2len: length in bytes of second list.
+ * @return true if there are tags in common, 0 if not.
+ */
+int taglist_intersect(uint8_t* list1, size_t list1len, uint8_t* list2,
+	size_t list2len);
+
 /**
  * Parse local-zone directive into two strings and register it in the config.
  * @param cfg: to put it in.

util/configlexer.lex

@@ -343,6 +343,8 @@ rrset-roundrobin{COLON}		{ YDVAR(1, VAR_RRSET_ROUNDROBIN) }
 max-udp-size{COLON}		{ YDVAR(1, VAR_MAX_UDP_SIZE) }
 dns64-prefix{COLON}		{ YDVAR(1, VAR_DNS64_PREFIX) }
 dns64-synthall{COLON}		{ YDVAR(1, VAR_DNS64_SYNTHALL) }
+define-tag{COLON}		{ YDVAR(1, VAR_DEFINE_TAG) }
+local-zone-tag{COLON}		{ YDVAR(2, VAR_LOCAL_ZONE_TAG) }
 dnstap{COLON}			{ YDVAR(0, VAR_DNSTAP) }
 dnstap-enable{COLON}		{ YDVAR(1, VAR_DNSTAP_ENABLE) }
 dnstap-socket-path{COLON}	{ YDVAR(1, VAR_DNSTAP_SOCKET_PATH) }

util/configparser.h

@@ -208,7 +208,9 @@ extern int yydebug;
     VAR_CACHE_MAX_NEGATIVE_TTL = 418,
     VAR_PERMIT_SMALL_HOLDDOWN = 419,
     VAR_QNAME_MINIMISATION = 420,
-    VAR_IP_FREEBIND = 421
+    VAR_IP_FREEBIND = 421,
+    VAR_DEFINE_TAG = 422,
+    VAR_LOCAL_ZONE_TAG = 423
   };
 #endif
 /* Tokens.  */
@@ -376,6 +378,8 @@ extern int yydebug;
 #define VAR_PERMIT_SMALL_HOLDDOWN 419
 #define VAR_QNAME_MINIMISATION 420
 #define VAR_IP_FREEBIND 421
+#define VAR_DEFINE_TAG 422
+#define VAR_LOCAL_ZONE_TAG 423
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
@@ -386,7 +390,7 @@ union YYSTYPE
 
 	char*	str;
 
-#line 390 "util/configparser.h" /* yacc.c:1909  */
+#line 394 "util/configparser.h" /* yacc.c:1909  */
 };
 
 typedef union YYSTYPE YYSTYPE;

util/configparser.y

@@ -124,7 +124,7 @@ extern struct config_parser_state* cfg_parser;
 %token VAR_RATELIMIT VAR_RATELIMIT_SLABS VAR_RATELIMIT_SIZE
 %token VAR_RATELIMIT_FOR_DOMAIN VAR_RATELIMIT_BELOW_DOMAIN VAR_RATELIMIT_FACTOR
 %token VAR_CAPS_WHITELIST VAR_CACHE_MAX_NEGATIVE_TTL VAR_PERMIT_SMALL_HOLDDOWN
-%token VAR_QNAME_MINIMISATION VAR_IP_FREEBIND
+%token VAR_QNAME_MINIMISATION VAR_IP_FREEBIND VAR_DEFINE_TAG VAR_LOCAL_ZONE_TAG
 
 %%
 toplevelvars: /* empty */ | toplevelvars toplevelvar ;
@@ -192,7 +192,7 @@ content_server: server_num_threads | server_verbosity | server_port |
 	server_ratelimit_below_domain | server_ratelimit_factor |
 	server_caps_whitelist | server_cache_max_negative_ttl |
 	server_permit_small_holddown | server_qname_minimisation |
-	server_ip_freebind
+	server_ip_freebind | server_define_tag | server_local_zone_tag
 	;
 stubstart: VAR_STUB_ZONE
 	{
@@ -1297,6 +1297,39 @@ server_dns64_synthall: VAR_DNS64_SYNTHALL STRING_ARG
 		free($2);
 	}
 	;
+server_define_tag: VAR_DEFINE_TAG STRING_ARG
+	{
+		char* p, *s = $2;
+		OUTYY(("P(server_define_tag:%s)\n", $2));
+		while((p=strsep(&s, " \t\n")) != NULL) {
+			if(*p) {
+				if(!config_add_tag(cfg_parser->cfg, p))
+					yyerror("could not define-tag, "
+						"out of memory");
+			}
+		}
+		free($2);
+	}
+	;
+server_local_zone_tag: VAR_LOCAL_ZONE_TAG STRING_ARG STRING_ARG
+	{
+		size_t len = 0;
+		uint8_t* bitlist = config_parse_taglist(cfg_parser->cfg, $3,
+			&len);
+		free($3);
+		OUTYY(("P(server_local_zone_tag:%s)\n", $2));
+		if(!bitlist)
+			yyerror("could not parse tags, (define-tag them first)");
+		if(bitlist) {
+			if(!cfg_strbytelist_insert(
+				&cfg_parser->cfg->local_zone_tags,
+				$2, bitlist, len)) {
+				yyerror("out of memory");
+				free($2);
+			}
+		}
+	}
+	;
 server_ratelimit: VAR_RATELIMIT STRING_ARG 
 	{ 
 		OUTYY(("P(server_ratelimit:%s)\n", $2));