main/gdnsd: upgrade to 1.6.9 and fixes

cherry-picked commits:
 1952e27 upgrade to 1.6.5 and update init.d
 939241b upgrade to 1.6.7
 0425fea cherry pick some improvements from bug tracker
 b7a63d5 add preliminary support for djbdns config files
 1c5eeb6 build fix (regenerate autotools)
 6705665 add a fix for startup race
 5932040 upgrade to 1.6.8
 db3867d refresh autodc patch
 75e96f2 build fix for automake-1.13
 aa04d0a upgrade to 1.6.9

4 files changed, 731 insertions, 16 deletions

diff --git a/main/gdnsd/0001-preliminary-djbdns-support.patch b/main/gdnsd/0001-preliminary-djbdns-support.patch
new file mode 100644
index 0000000000..2384368571
--- /dev/null
+++ b/main/gdnsd/0001-preliminary-djbdns-support.patch
@@ -0,0 +1,576 @@
+From d72aa39cb88178792c1e058b0b757b7cd9466e82 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Timo=20Ter=C3=A4s?= <timo.teras@iki.fi>
+Date: Tue, 8 May 2012 16:57:06 +0300
+Subject: [PATCH]     preliminary djbdns support
+
+---
+ docs/TODO         |    2 +-
+ gdnsd/Makefile.am |    2 +-
+ gdnsd/conf.c      |    6 +-
+ gdnsd/conf.h      |    1 +
+ gdnsd/ltree.c     |   10 +-
+ gdnsd/zscan-djb.c |  442 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ gdnsd/zscan.h     |    3 +
+ 7 files changed, 460 insertions(+), 6 deletions(-)
+ create mode 100644 gdnsd/zscan-djb.c
+
+diff --git a/docs/TODO b/docs/TODO
+index 2f84a9f..2a7fd9c 100644
+--- a/docs/TODO
++++ b/docs/TODO
+@@ -58,7 +58,7 @@ Realistically, AXFR is pretty far down the priority list.  I think a higher-prio
+ 
+ Other zonefile formats:
+ -------------------------
+-Load other zonefile (or zone data in general) formats?  The BIND syntax sucks, but I'm keeping it as the default, it's too widespread not to.  However, the zonefile scanner is mostly cleanly separated from the rest of the code, and it wouldn't be that hard to add support for more formats (djbdns? a SQL connection? in both cases, they could periodically update using the same switching mechanism as stat() watcher above...).
++Load other zonefile (or zone data in general) formats?  The BIND syntax sucks, but I'm keeping it as the default, it's too widespread not to.  However, the zonefile scanner is mostly cleanly separated from the rest of the code, and it wouldn't be that hard to add support for more formats (a SQL connection? in both cases, they could periodically update using the same switching mechanism as stat() watcher above...).
+ 
+ Stuff from conversations w/ Paul Dekkers: --------
+ 
+diff --git a/gdnsd/Makefile.am b/gdnsd/Makefile.am
+index feaed57..266b344 100644
+--- a/gdnsd/Makefile.am
++++ b/gdnsd/Makefile.am
+@@ -12,7 +12,7 @@ AM_CPPFLAGS = -I$(srcdir)/libgdnsd -I$(builddir)/libgdnsd -DVARDIR=\"$(localstat
+ 
+ # How to build gdnsd
+ sbin_PROGRAMS = gdnsd
+-gdnsd_SOURCES = main.c conf.c $(ZSCAN_C) ltarena.c ltree.c dnspacket.c dnsio_udp.c dnsio_tcp.c statio.c monio.c conf.h dnsio_tcp.h dnsio_udp.h dnspacket.h dnswire.h ltarena.h ltree.h statio.h monio.h zscan.h pkterr.h gdnsd.h
++gdnsd_SOURCES = main.c conf.c $(ZSCAN_C) ltarena.c ltree.c zscan-djb.c dnspacket.c dnsio_udp.c dnsio_tcp.c statio.c monio.c conf.h dnsio_tcp.h dnsio_udp.h dnspacket.h dnswire.h ltarena.h ltree.h statio.h monio.h zscan.h pkterr.h gdnsd.h
+ gdnsd_LDADD = libgdnsd/libgdnsd.la $(CAPLIBS)
+ 
+ zscan.c:	zscan.rl
+diff --git a/gdnsd/conf.c b/gdnsd/conf.c
+index b79cbb2..a3357d4 100644
+--- a/gdnsd/conf.c
++++ b/gdnsd/conf.c
+@@ -55,6 +55,7 @@ global_config_t gconfig = {
+     .pidfile = def_pidfile,
+     .username = def_username,
+     .chroot_path = def_chroot_path,
++    .djbdns_path = NULL,
+     .include_optional_ns = false,
+     .realtime_stats = false,
+     .lock_mem = false,
+@@ -577,7 +578,7 @@ void conf_load(const char* cfg_file) {
+ 
+     const vscf_data_t* options = vscf_hash_get_data_byconstkey(cfg_root, "options", true);
+ 
+-    const char* zdopt = NULL;
++    const char* zdopt = NULL, * djbopt = NULL;
+     char* zones_dir = NULL;
+     const vscf_data_t* listen_opt = NULL;
+     const vscf_data_t* http_listen_opt = NULL;
+@@ -628,6 +629,7 @@ void conf_load(const char* cfg_file) {
+         CFG_OPT_STR(options, pidfile);
+         CFG_OPT_STR(options, username);
+         CFG_OPT_STR(options, chroot_path);
++        CFG_OPT_STR_NOCOPY(options, djbdns_path, djbopt);
+         CFG_OPT_STR_NOCOPY(options, zones_dir, zdopt);
+         listen_opt = vscf_hash_get_data_byconstkey(options, "listen", true);
+         http_listen_opt = vscf_hash_get_data_byconstkey(options, "http_listen", true);
+@@ -637,6 +639,8 @@ void conf_load(const char* cfg_file) {
+ 
+     // Potentially a subdirectory of cfg_dir
+     zones_dir = make_zones_dir(gdnsd_get_cfdir(), zdopt);
++    if (djbopt)
++        gconfig.djbdns_path = make_zones_dir(gdnsd_get_cfdir(), djbopt);
+ 
+     // Set up the http listener data
+     process_http_listen(http_listen_opt, def_http_port);
+diff --git a/gdnsd/conf.h b/gdnsd/conf.h
+index 07a39d4..4374aa6 100644
+--- a/gdnsd/conf.h
++++ b/gdnsd/conf.h
+@@ -48,6 +48,7 @@ typedef struct {
+     const char*     pidfile;
+     const char*     username;
+     const char*     chroot_path;
++    const char*     djbdns_path;
+     bool     include_optional_ns;
+     bool     realtime_stats;
+     bool     lock_mem;
+diff --git a/gdnsd/ltree.c b/gdnsd/ltree.c
+index 8d3debf..ef5d46c 100644
+--- a/gdnsd/ltree.c
++++ b/gdnsd/ltree.c
+@@ -1126,9 +1126,13 @@ void ltree_load_zones(void) {
+         ltree_find_or_add_dname(zone->dname, true);
+     }
+ 
+-    for(unsigned i = 0; i < gconfig.num_zones; i++) {
+-        const zoneinfo_t* zone = &gconfig.zones[i];
+-        scan_zone(zone);
++    if (!gconfig.djbdns_path) {
++        for(unsigned i = 0; i < gconfig.num_zones; i++) {
++            const zoneinfo_t* zone = &gconfig.zones[i];
++            scan_zone(zone);
++        }
++    } else {
++        read_djb_directory(gconfig.djbdns_path);
+     }
+ 
+     // Close the ltarena to further allocations.  Mostly
+diff --git a/gdnsd/zscan-djb.c b/gdnsd/zscan-djb.c
+new file mode 100644
+index 0000000..fb18133
+--- /dev/null
++++ b/gdnsd/zscan-djb.c
+@@ -0,0 +1,442 @@
++/* Copyright © 2012 Timo Teräs <timo.teras@iki.fi>
++ *
++ * This file is part of gdnsd.
++ *
++ * gdnsd 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.
++ *
++ * gdnsd 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 gdnsd.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ */
++
++#include "zscan.h"
++
++#include <string.h>
++#include <stdlib.h>
++#include <unistd.h>
++#include <sys/stat.h>
++#include <fcntl.h>
++#include <dirent.h>
++
++#include "conf.h"
++#include "ltree.h"
++#include "ltarena.h"
++#include "gdnsd-misc.h"
++
++#define TTL_NS 259200
++#define TTL_POSITIVE 86400
++#define TTL_NEGATIVE 2560
++
++#define parse_warn(_fmt...) \
++    log_warn("Zonefile parse error: " _fmt)
++
++#define parse_error(_fmt...) \
++    log_fatal("Zonefile parse error: " _fmt)
++
++typedef struct {
++    char* ptr;
++    unsigned len;
++} field_t;
++
++typedef struct {
++    uint8_t ns[256];
++    uint8_t email[256];
++    unsigned ttl;
++    unsigned serial;
++    unsigned refresh;
++    unsigned retry;
++    unsigned expire;
++    unsigned cache;
++
++    unsigned mtime;
++} soa_info_t;
++
++static const uint8_t dname_root[] = {1,0};
++static const uint8_t dname_ns[]   = {4,2,'n','s',255};
++static const uint8_t dname_mx[]   = {4,2,'m','x',255};
++static const uint8_t dname_srv[]  = {5,3,'s','r','v',255};
++
++F_NONNULL
++static uint8_t *parse_dname(uint8_t *dname, field_t *f) {
++    dname_status_t status = dname_from_string(dname, (const uint8_t*) f->ptr, f->len);
++
++    switch(status) {
++        case DNAME_INVALID:
++            parse_error("'%.*s' is not a domain name", f->len, f->ptr);
++            break;
++        case DNAME_VALID:
++            break;
++        case DNAME_PARTIAL:
++            if(dname_cat(dname, dname_root) == DNAME_INVALID)
++                parse_error("'%.*s' is not a valid name", f->len, f->ptr);
++            break;
++    }
++    return dname;
++}
++
++F_NONNULL
++static uint8_t *expand_dname(uint8_t *dname, field_t *f, const uint8_t *subzone, const uint8_t *zone) {
++    /* fully qualified name in the primary field? */
++    if (strchr(f->ptr, '.') != NULL)
++        return parse_dname(dname, f);
++
++    /* construct dname of form <fieldname>.<subzone>.<zone>
++     * e.g. ns1.ns.example.com */
++    dname_from_string(dname, (const uint8_t*) f->ptr, f->len);
++    dname_cat(dname, subzone);
++    switch (dname_cat(dname, zone)) {
++        case DNAME_VALID:
++            break;
++        case DNAME_PARTIAL:
++            if(dname_cat(dname, dname_root) != DNAME_INVALID)
++                break;
++            /* fallthrough */
++        case DNAME_INVALID:
++            parse_error("unable to expand '%.*s' as to valid domain name", f->len, f->ptr);
++            break;
++    }
++
++    return dname;
++}
++
++F_NONNULL
++static uint32_t parse_ipv4(field_t *f) {
++    struct in_addr addr;
++
++    if(inet_pton(AF_INET, f->ptr, &addr) <= 0)
++        parse_error("IPv4 address '%s' invalid", f->ptr);
++
++    return addr.s_addr;
++}
++
++F_NONNULL
++static unsigned parse_ttl(field_t *f, unsigned defttl) {
++    char *end;
++    if (f->len == 0)
++        return defttl;
++    unsigned ttl = strtol(f->ptr, &end, 10);
++    if (end != f->ptr + f->len)
++        parse_error("Invalid TTL '%.*s'", f->len, f->ptr);
++    return ttl;
++}
++
++F_NONNULL
++static unsigned parse_int(field_t *f) {
++    char *end;
++    unsigned ttl = strtol(f->ptr, &end, 10);
++    if (end != f->ptr + f->len)
++        parse_error("Invalid integer value '%.*s'", f->len, f->ptr);
++    return ttl;
++}
++
++F_NONNULL
++static void parse_txt(field_t *f) {
++    char ch;
++    unsigned int i;
++    unsigned int j;
++
++    j = 0;
++    i = 0;
++    while (i < f->len) {
++        ch = f->ptr[i++];
++        if (ch == '\\') {
++            if (i >= f->len) break;
++            ch = f->ptr[i++];
++            if ((ch >= '0') && (ch <= '7')) {
++                ch -= '0';
++                if ((i < f->len) && (f->ptr[i] >= '0') && (f->ptr[i] <= '7')) {
++                    ch <<= 3;
++                    ch += f->ptr[i++] - '0';
++                    if ((i < f->len) && (f->ptr[i] >= '0') && (f->ptr[i] <= '7')) {
++                        ch <<= 3;
++                        ch += f->ptr[i++] - '0';
++                    }
++                }
++            }
++        }
++        f->ptr[j++] = ch;
++    }
++    f->len = j;
++    f->ptr[j] = 0;
++}
++
++#define TTDCHECK(fno) if (field[fno].len) { skipped++; continue; }
++#define LOCCHECK(fno) if (field[fno].len) { skipped++; continue; }
++
++unsigned read_djb_file(const char *filename, soa_info_t *soas, unsigned mtime) {
++    field_t field[15];
++    unsigned skipped = 0;
++
++    dmn_assert(filename);
++
++    log_debug("Scanning djbzone file '%s'", filename);
++
++    FILE *f = fopen(filename, "rt");
++    if(f == NULL)
++        log_fatal("Cannot open zone file '%s' for reading: %s", filename, logf_errno());
++
++    size_t allocated = 0;
++    ssize_t len;
++    char *line = NULL;
++    uint8_t dname[256], dname2[256], **texts = NULL;
++    unsigned i, ttl;
++
++    while ((len = getline(&line, &allocated, f)) != -1) {
++        if (len == 0 || line[0] == '#' || line[0] == '-')
++            continue;
++        if (line[len-1] == '\n') {
++            line[len-1] = 0;
++            len--;
++        }
++        if (len == 0)
++            continue;
++
++        /* Skip location records */
++        if (line[0] == '%')
++            continue;
++
++        char *c;
++        for (i = 0, c = line + 1; i < sizeof(field)/sizeof(field[0]); i++) {
++            field[i].ptr = c ?: "";
++            field[i].len = 0;
++            if (c) {
++                char *n = strchr(c, ':');
++                if (n) {
++                    field[i].len = n - c;
++                    *n = 0;
++                    c = n + 1;
++                } else {
++                    field[i].len = strlen(c);
++                    c = NULL;
++                }
++            }
++        }
++
++        parse_dname(dname, &field[0]);
++
++        for (i = 0; i < gconfig.num_zones; i++) {
++            if (dname_isinzone(gconfig.zones[i].dname, dname))
++                break;
++        }
++        if (i >= gconfig.num_zones)
++            continue;
++
++        if (mtime > soas[i].mtime)
++            soas[i].mtime = mtime;
++
++        switch (line[0]) {
++        case 'Z': /* SOA */
++            TTDCHECK(9);
++            LOCCHECK(10);
++            if (dname_cmp(gconfig.zones[i].dname, dname) == 0) {
++                parse_dname(soas[i].ns, &field[1]);
++                parse_dname(soas[i].email, &field[2]);
++                soas[i].ttl     = parse_ttl(&field[8], TTL_NEGATIVE);
++                soas[i].serial  = parse_int(&field[3]);
++                soas[i].refresh = parse_int(&field[4]) ?:   16384;
++                soas[i].retry   = parse_int(&field[5]) ?:    2048;
++                soas[i].expire  = parse_int(&field[6]) ?: 1048576;
++                soas[i].cache   = parse_int(&field[7]) ?:    2560;
++            } else {
++                uint8_t email[256];
++                ltree_add_rec_soa(dname,
++                                  parse_dname(dname2, &field[1]),
++                                  parse_dname(email, &field[2]),
++                                  parse_ttl(&field[8], TTL_NEGATIVE),
++                                  parse_int(&field[3]) ?:   mtime, /* serial */
++                                  parse_int(&field[4]) ?:   16384, /* refresh */
++                                  parse_int(&field[5]) ?:    2048, /* retry */
++                                  parse_int(&field[6]) ?: 1048576, /* expire */
++                                  parse_int(&field[7]) ?:    2560  /* cache */);
++            }
++            break;
++        case '.': /* NS + SOA (+ A) */
++        case '&': /* NS (+ A) */
++            TTDCHECK(4);
++            LOCCHECK(5);
++            expand_dname(dname2, &field[2], dname_ns, dname);
++            ttl = parse_ttl(&field[3], TTL_NS);
++            ltree_add_rec_ns(dname, dname2, ttl);
++            if (field[1].len) {
++                ltree_add_rec_a(dname2,
++                                parse_ipv4(&field[1]),
++                                ttl, 0, NULL);
++            }
++            break;
++        case '@': /* MX (+ A) */
++            TTDCHECK(5);
++            LOCCHECK(6);
++            expand_dname(dname2, &field[2], dname_mx, dname);
++            ttl = parse_ttl(&field[4], TTL_POSITIVE);
++            ltree_add_rec_mx(dname, dname2, ttl, parse_int(&field[3]));
++            if (field[1].len) {
++                ltree_add_rec_a(dname2,
++                                parse_ipv4(&field[1]),
++                                ttl, 0, NULL);
++            }
++            break;
++        case '+': /* A */
++        case '=': /* A + PTR */
++            TTDCHECK(3);
++            ttl = parse_ttl(&field[2], TTL_POSITIVE);
++            if (field[4].len == 2 && memcmp(field[4].ptr, "~~", 2) == 0) {
++                ltree_add_rec_dynaddr(dname, (const uint8_t *) field[1].ptr,
++                                      ttl, 0, 0);
++            } else {
++                LOCCHECK(4);
++                ltree_add_rec_a(dname, parse_ipv4(&field[1]), ttl, 0, NULL);
++#if 0
++                /* FIXME: autogen PTR record */
++                if (line[0] == '=') {
++                    ltree_add_rec_ptr();
++                }
++#endif
++            }
++            break;
++        case 'C': /* CNAME */
++            TTDCHECK(3);
++            ttl = parse_ttl(&field[2], TTL_POSITIVE);
++            if (field[4].len == 2 && memcmp(field[4].ptr, "~~", 2) == 0) {
++                ltree_add_rec_dyncname(dname, (const uint8_t *) field[1].ptr,
++                                       dname_root, ttl);
++            } else {
++                LOCCHECK(4);
++                ltree_add_rec_cname(dname, parse_dname(dname2, &field[1]), ttl);
++            }
++            break;
++        case '\'': /* TXT */
++            TTDCHECK(3);
++            LOCCHECK(4);
++
++            parse_txt(&field[1]);
++
++            unsigned bytes = field[1].len;
++            const char* src = field[1].ptr;
++            unsigned chunks = (bytes + 254) / 255;
++
++            if(bytes > 255 && gconfig.disable_text_autosplit)
++                parse_error("Text chunk too long (>255 unescaped)");
++            if(bytes > 65500)
++                parse_error("Text chunk too long (>65500 unescaped)");
++
++            texts = realloc(texts, sizeof(uint8_t *) * (chunks + 1));
++            for (i = 0; i < chunks; i++) {
++                int s = (bytes > 255 ? 255 : bytes);
++                texts[i] = lta_malloc_1(s + 1);
++                texts[i][0] = s;
++                memcpy(&texts[i][1], src, s);
++
++                bytes -= s;
++                src += s;
++            }
++            texts[i] = NULL;
++            ltree_add_rec_txt(dname, chunks, texts,
++                              parse_ttl(&field[2], TTL_POSITIVE));
++            break;
++        case 'S': /* SRV (+ A) */
++            TTDCHECK(7);
++            LOCCHECK(8);
++            expand_dname(dname2, &field[2], dname_srv, dname);
++            ttl = parse_ttl(&field[6], TTL_POSITIVE);
++            ltree_add_rec_srv(dname, dname2,
++                              ttl,
++                              parse_int(&field[4]),
++                              parse_int(&field[5]),
++                              parse_int(&field[3]));
++            if (field[1].len) {
++                ltree_add_rec_a(dname2,
++                                parse_ipv4(&field[1]),
++                                ttl, 0, NULL);
++            }
++            break;
++        case 'N': /* NAPTR */
++            TTDCHECK(8);
++            LOCCHECK(9);
++            parse_txt(&field[3]);
++            parse_txt(&field[4]);
++            parse_txt(&field[5]);
++            if (field[3].len > 255 || field[4].len > 255 || field[5].len > 255)
++                parse_error("NAPTR label cannot exceed 255 chars");
++
++            texts = realloc(texts, sizeof(uint8_t *) * (3 + 1));
++            for (i = 0; i < 3; i++) {
++                texts[i] = lta_malloc_1(field[3+i].len + 1);
++                texts[i][0] = field[3+i].len;
++                memcpy(&texts[i][1], field[3+i].ptr, field[3+i].len);
++            }
++            texts[i] = NULL;
++            ltree_add_rec_naptr(dname,
++                                parse_dname(dname2, &field[6]),
++                                parse_ttl(&field[7], TTL_POSITIVE),
++                                parse_int(&field[1]),
++                                parse_int(&field[2]),
++                                3, texts);
++            break;
++#if 0
++        case '3': /* AAAA */
++        case '6': /* AAAA + PTR */
++        case '^': /* PTR */
++        case ':': /* raw */
++#endif
++        default:
++            log_warn("Unsupported djbdns record type '%c'", line[0]);
++        }
++    }
++    free(texts);
++    free(line);
++    fclose(f);
++
++    return skipped;
++}
++
++void read_djb_directory(const char *path) {
++    struct dirent *e;
++    DIR *dir;
++    unsigned i, skipped = 0;
++    soa_info_t *soas;
++
++    soas = calloc(gconfig.num_zones, sizeof(soa_info_t));
++
++    dir = opendir(path);
++    if (dir == NULL)
++        log_fatal("Cannot open djbzone directory '%s': %s", path, logf_errno());
++    while ((e = readdir(dir)) != NULL) {
++        if (e->d_name[0] == '.')
++            continue;
++        struct stat st;
++        char *fn = gdnsd_make_abs_fn(gconfig.djbdns_path, e->d_name);
++        if (stat(fn, &st))
++            log_fatal("Cannot stat djbzone file '%s': %s", e->d_name, logf_errno());
++        if((st.st_mode & S_IFMT) == S_IFREG)
++            skipped += read_djb_file(fn, soas, st.st_mtime);
++        free(fn);
++    }
++    closedir(dir);
++
++    for (i = 0; i < gconfig.num_zones; i++) {
++        if (soas[i].mtime == 0)
++            continue;
++
++        ltree_add_rec_soa(gconfig.zones[i].dname,
++                          soas[i].ns, soas[i].email,
++                          soas[i].ttl,
++                          soas[i].serial ? : soas[i].mtime,
++                          soas[i].refresh,
++                          soas[i].retry,
++                          soas[i].expire,
++                          soas[i].cache);
++    }
++
++    free(soas);
++
++    if (skipped)
++        log_warn("Skipped: %d records with TTD or location", skipped);
++}
+diff --git a/gdnsd/zscan.h b/gdnsd/zscan.h
+index faaba1f..d246617 100644
+--- a/gdnsd/zscan.h
++++ b/gdnsd/zscan.h
+@@ -36,4 +36,7 @@ typedef struct {
+ F_NONNULL
+ void scan_zone(const zoneinfo_t* zone);
+ 
++F_NONNULL
++void read_djb_directory(const char* path);
++
+ #endif // _GDNSD_ZSCAN_H
+-- 
+1.7.10.2
+
diff --git a/main/gdnsd/APKBUILD b/main/gdnsd/APKBUILD
index 6da9d6caad..d9fafbf4ce 100644
--- a/main/gdnsd/APKBUILD
+++ b/main/gdnsd/APKBUILD
@@ -1,18 +1,21 @@
 # Contributor: Natanael Copa <ncopa@alpinelinux.org>
-# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
+# Maintainer: Timo Teräs <timo.teras@iki.fi>
 pkgname=gdnsd
-pkgver=1.6.2
-pkgrel=2
+pkgver=1.6.9
+pkgrel=0
 pkgdesc="Geographic Authoritative DNS server"
-url="http://code.google.com/p/gdnsd/"
+url="https://github.com/blblack/gdnsd/"
 arch="all"
 license="GPL-3"
 depends=""
 depends_dev=""
-makedepends="libev-dev libcap-dev"
+makedepends="libev-dev libcap-dev autoconf automake libtool"
 install="$pkgname.pre-install"
 subpackages="$pkgname-dev $pkgname-doc"
-source="http://gdnsd.googlecode.com/files/gdnsd-$pkgver.tar.xz
+source="https://github.com/downloads/blblack/gdnsd/gdnsd-$pkgver.tar.xz
+	geoip-autodc.patch
+	geoip-speedup.patch
+	0001-preliminary-djbdns-support.patch
 	gdnsd.initd"
 
 _builddir="$srcdir"/gdnsd-$pkgver
@@ -24,6 +27,10 @@ prepare() {
 		*.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
 		esac
 	done
+	libtoolize --force || return 1
+	aclocal -I m4 || return 1
+	autoconf || return 1
+	automake --add-missing || return 1
 }
 
 build() {
@@ -34,8 +41,8 @@ build() {
 		--enable-fast-install \
 		|| return 1
 	make || return 1
-	install -Dm755 "$srcdir"/gdnsd.initd "$pkgdir"/etc/init.d/gdnsd \
-		|| return 1
+	install -Dm755 "$srcdir"/gdnsd.initd \
+		"$pkgdir"/etc/init.d/gdnsd || return 1
 }
 
 package() {
@@ -43,7 +50,12 @@ package() {
 	make DESTDIR="$pkgdir" install || return 1
 	rm -f "$pkgdir"/usr/lib/*.la \
 		"$pkgdir"/usr/lib/gdnsd/*.la
+        install -Dm755 "$srcdir"/gdnsd.initd \
+		"$pkgdir"/etc/init.d/gdnsd || return 1
 }
 
-md5sums="082f874d24cdc7073950ed6294f8d39b  gdnsd-1.6.2.tar.xz
-dad20779adfb4b85b57b45c7c903a636  gdnsd.initd"
+md5sums="c8ea1da00fabc52e3d685528444f1279  gdnsd-1.6.9.tar.xz
+02eb668b6cad54552568a35985f44a09  geoip-autodc.patch
+7fb697653b8295322e53492f9051e831  geoip-speedup.patch
+4c8ff14e377fb8f1854b68b7bf9be282  0001-preliminary-djbdns-support.patch
+00f2838e0908effaaa2f6e6a1699f25b  gdnsd.initd"
diff --git a/main/gdnsd/gdnsd.initd b/main/gdnsd/gdnsd.initd
index e11a73d1d6..2dbb568974 100755
--- a/main/gdnsd/gdnsd.initd
+++ b/main/gdnsd/gdnsd.initd
@@ -1,18 +1,44 @@
 #!/sbin/runscript
 
+name="gdnsd daemon"
+extra_commands="configtest"
+extra_started_commands="reload"
+description_configtest="Run syntax tests for configuration files only."
+description_reload="Fast reload: check config, load files, kill old server, start new server (in this order)."
+
+if [ -z "${GDNSD_CONFFILE}" ]; then
+	if [ "${SVCNAME}" = "gdnsd" ]; then
+		GDNSD_CONFFILE=/etc/gdnsd/config
+	else
+		GDNSD_CONFFILE=/etc/gdnsd/${SVCNAME}.config
+	fi
+fi
+
 depend() {
 	need net
+	use logger
 	after firewall
+	provide auth-dns
 }
 
-start() {
-	ebegin "Starting dnsd"
-	start-stop-daemon --start --exec /usr/sbin/dnsd -- -d $DNSD_OPTS
+act() {
+	ebegin "$1 ${SVCNAME}"
+	/usr/sbin/gdnsd -c ${GDNSD_CONFFILE} ${GDNSD_OPTS} $2
 	eend $?
 }
 
+start() {
+	act "Starting" start
+}
+
 stop () {
-	ebegin "Stopping dnsd"
-	start-stop-daemon --stop --exec /usr/sbin/dnsd
-	eend $?
+	act "Stopping" stop
+}
+
+reload() {
+	act "Reloading" restart
+}
+
+configtest() {
+	act "Checking configuration" checkconf
 }
diff --git a/main/gdnsd/geoip-speedup.patch b/main/gdnsd/geoip-speedup.patch
new file mode 100644
index 0000000000..3816df44ed
--- /dev/null
+++ b/main/gdnsd/geoip-speedup.patch
@@ -0,0 +1,101 @@
+From: Timo TerÃs <timo.teras@iki.fi>
+
+plugin_geoip: speed up cities database loading
+
+Gives over 10x speed-up in loading the large cities database.
+http://code.google.com/p/gdnsd/issues/detail?id=18
+
+diff --git a/plugins/meta/libgdmaps/gdmaps.c b/plugins/meta/libgdmaps/gdmaps.c
+index 9d20351..6bbc410 100644
+--- a/plugins/meta/libgdmaps/gdmaps.c
++++ b/plugins/meta/libgdmaps/gdmaps.c
+@@ -1215,6 +1215,12 @@ typedef struct {
+ } gdmap_t;
+ 
+ typedef struct {
++    unsigned offset;
++    unsigned dclist;
++} offset_cache_item_t;
++#define OFFSET_CACHE_SIZE (1 << 18)
++
++typedef struct {
+     char* pathname;
+     uint8_t* data;
+     const fips_t* fips;
+@@ -1223,6 +1229,8 @@ typedef struct {
+     int type;
+     unsigned base;
+     bool ipv6;
++
++    offset_cache_item_t *offset_cache[OFFSET_CACHE_SIZE];
+ } geoip_db_t;
+ 
+ F_NONNULL
+@@ -1230,7 +1238,7 @@ static int geoip_db_close(geoip_db_t* db);
+ F_NONNULLX(1)
+ static geoip_db_t* geoip_db_open(const char* pathname, const fips_t* fips, const char* map_name, const bool city_required);
+ F_NONNULLX(1, 2, 3)
+-static int geoip_tree_xlate(const gdmap_t* gdmap, ntree_t* tree, const geoip_db_t* db, const geoip_db_t* db_v4o);
++static int geoip_tree_xlate(const gdmap_t* gdmap, ntree_t* tree, geoip_db_t* db, geoip_db_t* db_v4o);
+ 
+ F_NONNULL
+ static ntree_t* gdmap_make_tree(const gdmap_t* gdmap, const dclists_t* old_dclists) {
+@@ -1957,10 +1965,18 @@ static unsigned city_lookup_dclist(const geoip_db_t* db, unsigned int offs, cons
+ }
+ 
+ F_NONNULL
+-static unsigned get_dclist(const gdmap_t* gdmap, const ntree_t* tree, const geoip_db_t* db, const unsigned int offset) {
++static unsigned get_dclist(const gdmap_t* gdmap, const ntree_t* tree, geoip_db_t* db, const unsigned int offset) {
+     dmn_assert(gdmap); dmn_assert(db);
+ 
+     unsigned dclist = 0;
++    unsigned bucket_size = 0;
++    unsigned ndx = offset % OFFSET_CACHE_SIZE;
++
++    if (db->offset_cache[ndx]) {
++        for (bucket_size = 0; db->offset_cache[ndx][bucket_size].offset; bucket_size++)
++            if (db->offset_cache[ndx][bucket_size].offset == offset)
++                return db->offset_cache[ndx][bucket_size].dclist;
++    }
+ 
+     switch(db->type) {
+         case GEOIP_CITY_EDITION_REV1_V6:
+@@ -1983,6 +1999,11 @@ static unsigned get_dclist(const gdmap_t* gdmap, const ntree_t* tree, const geoi
+             break;
+     }
+ 
++    db->offset_cache[ndx] = realloc(db->offset_cache[ndx], sizeof(offset_cache_item_t) * (bucket_size+2));
++    db->offset_cache[ndx][bucket_size].offset = offset;
++    db->offset_cache[ndx][bucket_size].dclist = dclist;
++    db->offset_cache[ndx][bucket_size+1].offset = 0;
++
+     return dclist;
+ }
+ 
+@@ -1991,7 +2012,7 @@ static unsigned get_dclist(const gdmap_t* gdmap, const ntree_t* tree, const geoi
+ // C really needs a better macro/template idea :(
+ #define DEFUN_TREE_XLATE(IPVN, IPTYPE, IPZERO, BITDEPTH, V4ROOT_CODE, SKIP_CODE) \
+ F_NONNULL              \
+-static int geoip_tree_xlate_ ## IPVN(const gdmap_t* gdmap, ntree_t* tree, const geoip_db_t* db) { \
++static int geoip_tree_xlate_ ## IPVN(const gdmap_t* gdmap, ntree_t* tree, geoip_db_t* db) { \
+     dmn_assert(gdmap); dmn_assert(tree); dmn_assert(db); \
+     struct {                                             \
+         int depth;                                       \
+@@ -2107,7 +2128,7 @@ DEFUN_TREE_XLATE(v4, uint32_t, 0, 32, ;, ;)
+ 
+ DEFUN_TREE_XLATE(v6, struct in6_addr, ip6_zero, 128, V6_V4ROOT_CODE, V6_SKIP_CODE)
+ 
+-static int geoip_tree_xlate(const gdmap_t* gdmap, ntree_t* tree, const geoip_db_t* db, const geoip_db_t* db_v4o) {
++static int geoip_tree_xlate(const gdmap_t* gdmap, ntree_t* tree, geoip_db_t* db, geoip_db_t* db_v4o) {
+     dmn_assert(gdmap); dmn_assert(tree); dmn_assert(db);
+ 
+     log_info("plugin_geoip: map '%s': Processing GeoIP database '%s'...", gdmap->name, gdmap->geoip_path);
+@@ -2145,6 +2166,8 @@ static int geoip_db_close(geoip_db_t* db) {
+         }
+     }
+ 
++    for (unsigned i = 0; i < OFFSET_CACHE_SIZE; i++)
++        free(db->offset_cache[i]);
+     if(db->pathname)
+         free(db->pathname);
+     free(db);