Knot DNS 1.5.2

Update Knot DNS to new upstream release 1.5.2 + replace
pthread_spinlock_t with pthread_mutex_t to compile on the Mac OS X

# fixed version with upstream patch
I got this patch from upstream:
```
diff --git a/src/knot/zone/events.c b/src/knot/zone/events.c
index 92d1d7a..1235dad 100644
--- a/src/knot/zone/events.c
+++ b/src/knot/zone/events.c
@@ -403,11 +403,11 @@ static int event_update(zone_t *zone)
 	mem_trim();
 
 	/* Replan event if next update waiting. */
-	pthread_spin_lock(&zone->ddns_lock);
+	pthread_mutex_lock(&zone->ddns_lock);
 	
 	const bool empty = EMPTY_LIST(zone->ddns_queue);
 	
-	pthread_spin_unlock(&zone->ddns_lock);
+	pthread_mutex_unlock(&zone->ddns_lock);
 	
 	if (!empty) {
 		zone_events_schedule(zone, ZONE_EVENT_UPDATE, ZONE_EVENT_NOW);
@@ -641,14 +641,14 @@ static void duplicate_ddns_q(zone_t *zone, zone_t *old_zone)
 /*!< Replans DDNS event. */
 static void replan_update(zone_t *zone, zone_t *old_zone)
 {
-	pthread_spin_lock(&old_zone->ddns_lock);
+	pthread_mutex_lock(&old_zone->ddns_lock);
 
 	const bool have_updates = old_zone->ddns_queue_size > 0;
 	if (have_updates) {
 		duplicate_ddns_q(zone, (zone_t *)old_zone);
 	}
 	
-	pthread_spin_unlock(&old_zone->ddns_lock);
+	pthread_mutex_unlock(&old_zone->ddns_lock);
 	
 	if (have_updates) {
 		zone_events_schedule(zone, ZONE_EVENT_UPDATE, ZONE_EVENT_NOW);
diff --git a/src/knot/zone/zone.c b/src/knot/zone/zone.c
index de302bc..947965b 100644
--- a/src/knot/zone/zone.c
+++ b/src/knot/zone/zone.c
@@ -72,7 +72,7 @@ zone_t* zone_new(conf_zone_t *conf)
 	zone->conf = conf;
 
 	// DDNS
-	pthread_spin_init(&zone->ddns_lock, 0);
+	pthread_mutex_init(&zone->ddns_lock, 0);
 	zone->ddns_queue_size = 0;
 	init_list(&zone->ddns_queue);
 
@@ -95,7 +95,7 @@ void zone_free(zone_t **zone_ptr)
 	knot_dname_free(&zone->name, NULL);
 
 	free_ddns_queue(zone);
-	pthread_spin_destroy(&zone->ddns_lock);
+	pthread_mutex_destroy(&zone->ddns_lock);
 
 	/* Free assigned config. */
 	conf_free_zone(zone->conf);
@@ -266,13 +266,13 @@ int zone_update_enqueue(zone_t *zone, knot_pkt_t *pkt, struct process_query_para
 		return ret;
 	}
 
-	pthread_spin_lock(&zone->ddns_lock);
+	pthread_mutex_lock(&zone->ddns_lock);
 
 	/* Enqueue created request. */
 	add_tail(&zone->ddns_queue, (node_t *)req);
 	++zone->ddns_queue_size;
 
-	pthread_spin_unlock(&zone->ddns_lock);
+	pthread_mutex_unlock(&zone->ddns_lock);
 
 	/* Schedule UPDATE event. */
 	zone_events_schedule(zone, ZONE_EVENT_UPDATE, ZONE_EVENT_NOW);
@@ -286,10 +286,10 @@ size_t zone_update_dequeue(zone_t *zone, list_t *updates)
 		return 0;
 	}
 
-	pthread_spin_lock(&zone->ddns_lock);
+	pthread_mutex_lock(&zone->ddns_lock);
 	if (EMPTY_LIST(zone->ddns_queue)) {
 		/* Lost race during reload. */
-		pthread_spin_unlock(&zone->ddns_lock);
+		pthread_mutex_unlock(&zone->ddns_lock);
 		return 0;
 	}
 
@@ -298,7 +298,7 @@ size_t zone_update_dequeue(zone_t *zone, list_t *updates)
 	init_list(&zone->ddns_queue);
 	zone->ddns_queue_size = 0;
 
-	pthread_spin_unlock(&zone->ddns_lock);
+	pthread_mutex_unlock(&zone->ddns_lock);
 	
 	return update_count;
 }
diff --git a/src/knot/zone/zone.h b/src/knot/zone/zone.h
index 83c94e4..50d0a9c 100644
--- a/src/knot/zone/zone.h
+++ b/src/knot/zone/zone.h
@@ -58,7 +58,7 @@ typedef struct zone_t
 	zone_flag_t flags;
 
 	/*! \brief DDNS queue and lock. */
-	pthread_spinlock_t ddns_lock;
+	pthread_mutex_t ddns_lock;
 	size_t ddns_queue_size;
 	list_t ddns_queue;
 ```

The problem with "wait" approach is that Knot DNS 1.5.1 and earlier contains a remote crash vulnerability that rewrites the stack, so the users really should upgrade.

Or I could also do 1.4.7+upstream security patch, if that would be easier to pass through...