/***
  This file is part of avahi.

  avahi is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  avahi 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 Lesser General
  Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with avahi; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.
***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <pthread.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <netinet/in.h>
#include <fcntl.h>

#include <sys/types.h>
#include <sys/socket.h>

#include <avahi-common/simple-watch.h>
#include <avahi-common/malloc.h>
#include <avahi-common/error.h>
#include <avahi-common/domain.h>
#include <avahi-common/alternative.h>
#include <avahi-common/llist.h>

#include <avahi-client/client.h>
#include <avahi-client/publish.h>
#include <avahi-client/lookup.h>

#include "warn.h"
#include "dns_sd.h"

enum {
    COMMAND_POLL = 'p',
    COMMAND_QUIT = 'q',
    COMMAND_POLL_DONE = 'P',
    COMMAND_POLL_FAILED = 'F'
};

struct type_info {
    char *type;
    AvahiStringList *subtypes;
    int n_subtypes;
};

struct browse_list_s {
    DNSServiceRef sdref;
    DNSServiceFlags flags;
    uint32_t interface;
    DNSServiceErrorType errors;
    const char *name;
    const char *type;
    const char *domain;
    void *userdata;

    AVAHI_LLIST_FIELDS(struct browse_list_s, list);
};
typedef struct browse_list_s browse_list_t;

struct query_list_s {
    DNSServiceRef sdref;
    DNSServiceFlags flags;
    uint32_t interface;
    DNSServiceErrorType errors;
    const char *name;
    uint16_t type;
    uint16_t clazz;
    uint16_t size;
    const void *rdata;
    uint32_t ttl;
    void *userdata;

    AVAHI_LLIST_FIELDS(struct query_list_s, list);
};
typedef struct query_list_s query_list_t;

struct domain_list_s {
    DNSServiceRef sdref;
    DNSServiceFlags flags;
    uint32_t interface;
    DNSServiceErrorType errors;
    const char *domain;
    void *userdata;

    AVAHI_LLIST_FIELDS(struct domain_list_s, list);
};
typedef struct domain_list_s domain_list_t;

struct _DNSServiceRef_t {
    int n_ref;

    AvahiSimplePoll *simple_poll;

    int thread_fd, main_fd;

    pthread_t thread;
    int thread_running;

    pthread_mutex_t mutex;

    void *context;
    DNSServiceBrowseReply service_browser_callback;
    DNSServiceResolveReply service_resolver_callback;
    DNSServiceDomainEnumReply domain_browser_callback;
    DNSServiceRegisterReply service_register_callback;
    DNSServiceQueryRecordReply query_resolver_callback;

    AvahiClient *client;
    AvahiServiceBrowser *service_browser;
    AvahiServiceResolver *service_resolver;
    AvahiDomainBrowser *domain_browser;
    AvahiRecordBrowser *record_browser;

    struct type_info type_info;
    char *service_name, *service_name_chosen, *service_domain, *service_host;
    uint16_t service_port;
    AvahiIfIndex service_interface;
    AvahiStringList *service_txt;

    AvahiEntryGroup *entry_group;

    AVAHI_LLIST_HEAD(browse_list_t, browse_list);
    AVAHI_LLIST_HEAD(query_list_t, query_list);
    AVAHI_LLIST_HEAD(domain_list_t, domain_list);
};

#define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }

static DNSServiceErrorType map_error(int error) {
    switch (error) {
        case AVAHI_OK :
            return kDNSServiceErr_NoError;

        case AVAHI_ERR_BAD_STATE :
            return kDNSServiceErr_BadState;

        case AVAHI_ERR_INVALID_HOST_NAME:
        case AVAHI_ERR_INVALID_DOMAIN_NAME:
        case AVAHI_ERR_INVALID_TTL:
        case AVAHI_ERR_IS_PATTERN:
        case AVAHI_ERR_INVALID_RECORD:
        case AVAHI_ERR_INVALID_SERVICE_NAME:
        case AVAHI_ERR_INVALID_SERVICE_TYPE:
        case AVAHI_ERR_INVALID_PORT:
        case AVAHI_ERR_INVALID_KEY:
        case AVAHI_ERR_INVALID_ADDRESS:
        case AVAHI_ERR_INVALID_SERVICE_SUBTYPE:
            return kDNSServiceErr_BadParam;


        case AVAHI_ERR_COLLISION:
            return kDNSServiceErr_NameConflict;

        case AVAHI_ERR_TOO_MANY_CLIENTS:
        case AVAHI_ERR_TOO_MANY_OBJECTS:
        case AVAHI_ERR_TOO_MANY_ENTRIES:
        case AVAHI_ERR_ACCESS_DENIED:
            return kDNSServiceErr_Refused;

        case AVAHI_ERR_INVALID_OPERATION:
        case AVAHI_ERR_INVALID_OBJECT:
            return kDNSServiceErr_Invalid;

        case AVAHI_ERR_NO_MEMORY:
            return kDNSServiceErr_NoMemory;

        case AVAHI_ERR_INVALID_INTERFACE:
        case AVAHI_ERR_INVALID_PROTOCOL:
            return kDNSServiceErr_BadInterfaceIndex;

        case AVAHI_ERR_INVALID_FLAGS:
            return kDNSServiceErr_BadFlags;

        case AVAHI_ERR_NOT_FOUND:
            return kDNSServiceErr_NoSuchName;

        case AVAHI_ERR_VERSION_MISMATCH:
            return kDNSServiceErr_Incompatible;

        case AVAHI_ERR_NO_NETWORK:
        case AVAHI_ERR_OS:
        case AVAHI_ERR_INVALID_CONFIG:
        case AVAHI_ERR_TIMEOUT:
        case AVAHI_ERR_DBUS_ERROR:
        case AVAHI_ERR_DISCONNECTED:
        case AVAHI_ERR_NO_DAEMON:
            break;

    }

    return kDNSServiceErr_Unknown;
}

static void type_info_init(struct type_info *i) {
    assert(i);
    i->type = NULL;
    i->subtypes = NULL;
    i->n_subtypes = 0;
}

static void type_info_free(struct type_info *i) {
    assert(i);

    avahi_free(i->type);
    avahi_string_list_free(i->subtypes);

    type_info_init(i);
}

static int type_info_parse(struct type_info *i, const char *t) {
    char *token = NULL;

    assert(i);
    assert(t);

    type_info_init(i);

    for (;;) {
        size_t l;

        if (*t == 0)
            break;

        l = strcspn(t, ",");

        if (l <= 0)
            goto fail;

        token = avahi_strndup(t, l);

        if (!token)
            goto fail;

        if (!i->type) {
            /* This is the first token, hence the main type */

            if (!avahi_is_valid_service_type_strict(token))
                goto fail;

            i->type = token;
            token = NULL;
        } else {
            char *fst;

            /* This is not the first token, hence a subtype */

            if (!(fst = avahi_strdup_printf("%s._sub.%s", token, i->type)))
                goto fail;

            if (!avahi_is_valid_service_subtype(fst)) {
                avahi_free(fst);
                goto fail;
            }

            i->subtypes = avahi_string_list_add(i->subtypes, fst);
            avahi_free(fst);

            avahi_free(token);
            token = NULL;

            i->n_subtypes++;
        }

        t += l;

        if (*t == ',')
            t++;
    }

    if (i->type)
        return 0;

fail:
    type_info_free(i);
    avahi_free(token);
    return -1;
}

static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
    if (!s)
        return NULL;

    if (*s == 0)
        return s;

    if (s[strlen(s)-1] == '.')
        return s;

    snprintf(buf, buf_len, "%s.", s);
    return buf;
}

static int read_command(int fd) {
    ssize_t r;
    char command;

    assert(fd >= 0);

    if ((r = read(fd, &command, 1)) != 1) {
        fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
        return -1;
    }

    return command;
}

static int write_command(int fd, char reply) {
    assert(fd >= 0);

    if (write(fd, &reply, 1) != 1) {
        fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
    DNSServiceRef sdref = userdata;
    int ret;

    assert(sdref);

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

/*     fprintf(stderr, "pre-syscall\n"); */
    ret = poll(ufds, nfds, timeout);
/*     fprintf(stderr, "post-syscall\n"); */

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    return ret;
}

static void * thread_func(void *data) {
    DNSServiceRef sdref = data;
    sigset_t mask;

    sigfillset(&mask);
    pthread_sigmask(SIG_BLOCK, &mask, NULL);

    sdref->thread = pthread_self();
    sdref->thread_running = 1;

    for (;;) {
        char command;

        if ((command = read_command(sdref->thread_fd)) < 0)
            break;

/*         fprintf(stderr, "Command: %c\n", command); */

        switch (command) {

            case COMMAND_POLL: {
                int ret;

                ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

                for (;;) {
                    errno = 0;

                    if ((ret = avahi_simple_poll_run(sdref->simple_poll)) < 0) {

                        if (errno == EINTR)
                            continue;

                        fprintf(stderr, __FILE__": avahi_simple_poll_run() failed: %s\n", strerror(errno));
                    }

                    break;
                }

                ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

                if (write_command(sdref->thread_fd, ret < 0 ? COMMAND_POLL_FAILED : COMMAND_POLL_DONE) < 0)
                    break;

                break;
            }

            case COMMAND_QUIT:
                return NULL;
        }

    }

    return NULL;
}

static DNSServiceRef sdref_new(void) {
    int fd[2] = { -1, -1 };
    DNSServiceRef sdref = NULL;
    pthread_mutexattr_t mutex_attr;

    if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
        goto fail;

    if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
        goto fail;

    sdref->n_ref = 1;
    sdref->thread_fd = fd[0];
    sdref->main_fd = fd[1];

    sdref->client = NULL;
    sdref->service_browser = NULL;
    sdref->service_resolver = NULL;
    sdref->domain_browser = NULL;
    sdref->entry_group = NULL;

    sdref->service_name = sdref->service_name_chosen = sdref->service_domain = sdref->service_host = NULL;
    sdref->service_txt = NULL;

    type_info_init(&sdref->type_info);

    ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr));
    pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
    ASSERT_SUCCESS(pthread_mutex_init(&sdref->mutex, &mutex_attr));

    AVAHI_LLIST_HEAD_INIT(browse_list_t, sdref->browse_list);
    AVAHI_LLIST_HEAD_INIT(query_list_t, sdref->query_list);
    AVAHI_LLIST_HEAD_INIT(domain_list_t, sdref->domain_list);

    sdref->thread_running = 0;

    if (!(sdref->simple_poll = avahi_simple_poll_new()))
        goto fail;

    avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);

    /* Start simple poll */
    if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
        goto fail;

    /* Queue an initial POLL command for the thread */
    if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
        goto fail;

    if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
        goto fail;

    sdref->thread_running = 1;

    return sdref;

fail:

    if (sdref)
        DNSServiceRefDeallocate(sdref);

    return NULL;
}

static void sdref_free(DNSServiceRef sdref) {
    assert(sdref);

    if (sdref->thread_running) {
        ASSERT_SUCCESS(write_command(sdref->main_fd, COMMAND_QUIT));
        avahi_simple_poll_wakeup(sdref->simple_poll);
        ASSERT_SUCCESS(pthread_join(sdref->thread, NULL));
    }

    if (sdref->client)
        avahi_client_free(sdref->client);

    if (sdref->simple_poll)
        avahi_simple_poll_free(sdref->simple_poll);

    if (sdref->thread_fd >= 0)
        close(sdref->thread_fd);

    if (sdref->main_fd >= 0)
        close(sdref->main_fd);

    ASSERT_SUCCESS(pthread_mutex_destroy(&sdref->mutex));

    avahi_free(sdref->service_name);
    avahi_free(sdref->service_name_chosen);
    avahi_free(sdref->service_domain);
    avahi_free(sdref->service_host);

    type_info_free(&sdref->type_info);

    avahi_string_list_free(sdref->service_txt);

    avahi_free(sdref);
}

static void sdref_ref(DNSServiceRef sdref) {
    assert(sdref);
    assert(sdref->n_ref >= 1);

    sdref->n_ref++;
}

static void sdref_unref(DNSServiceRef sdref) {
    assert(sdref);
    assert(sdref->n_ref >= 1);

    if (--(sdref->n_ref) <= 0)
        sdref_free(sdref);
}

int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {

    AVAHI_WARN_LINKAGE;

    if (!sdref || sdref->n_ref <= 0)
        return -1;

    return sdref->main_fd;
}

DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
    DNSServiceErrorType ret = kDNSServiceErr_Unknown;

    AVAHI_WARN_LINKAGE;

    if (!sdref || sdref->n_ref <= 0)
        return kDNSServiceErr_BadParam;

    sdref_ref(sdref);

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    /* Cleanup notification socket */
    if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
        goto finish;

    if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
        goto finish;

    if (sdref->n_ref > 1) /* Perhaps we should die */

        /* Dispatch events */
        if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
            goto finish;

    if (sdref->n_ref > 1)

        /* Request the poll */
        if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
            goto finish;

    ret = kDNSServiceErr_NoError;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    sdref_unref(sdref);

    return ret;
}

void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
    AVAHI_WARN_LINKAGE;

    if (sdref)
        sdref_unref(sdref);
}

static void service_browser_callback(
    AvahiServiceBrowser *b,
    AvahiIfIndex interface,
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
    AvahiBrowserEvent event,
    const char *name,
    const char *type,
    const char *domain,
    AvahiLookupResultFlags flags,
    void *userdata) {

    DNSServiceRef sdref = userdata;
    char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
    assert(b);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
    domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));

    switch (event) {
        case AVAHI_BROWSER_NEW:
            if (flags & AVAHI_LOOKUP_RESULT_CACHED) {
                browse_list_t *entry = calloc(1, sizeof(browse_list_t));

                /* store the entry */
                AVAHI_LLIST_INIT(browse_list_t, list, entry);

                entry->sdref = sdref;
                entry->flags = kDNSServiceFlagsAdd;
                entry->interface = interface;
                entry->errors = kDNSServiceErr_NoError;
                entry->name = strdup(name);
                entry->type = strdup(type);
                entry->domain = strdup(domain);
                entry->userdata = sdref->context;

                AVAHI_LLIST_PREPEND(browse_list_t,
                                    list,
                                    sdref->browse_list,
                                    entry);
            } else {
                sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
            }
            break;

        case AVAHI_BROWSER_REMOVE:
            sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
            break;

        case AVAHI_BROWSER_FAILURE:
            sdref->service_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, NULL, sdref->context);
            break;

        case AVAHI_BROWSER_CACHE_EXHAUSTED:
            /* send items in llist */
            if (!sdref->browse_list)
                break;

            browse_list_t *entry = sdref->browse_list;
            while ( entry ) {

                /* send it */
                int new_flags = entry->flags;
                if (entry->list_next) new_flags |= kDNSServiceFlagsMoreComing;

                entry->sdref->service_browser_callback(entry->sdref, new_flags, entry->interface, entry->errors, entry->name, entry->type, entry->domain, entry->userdata);

                /* remove entry */
                browse_list_t *tmp = entry->list_next;
                free(entry->name);
                free(entry->type);
                free(entry->domain);
                free(entry);
                entry = tmp;
            }
            sdref->browse_list = NULL;
            break;

        case AVAHI_BROWSER_ALL_FOR_NOW:
            break;
    }
}

static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
    DNSServiceRef sdref = userdata;
    int error = kDNSServiceErr_Unknown;

    assert(s);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    switch (state) {

        case AVAHI_CLIENT_FAILURE:

            if (sdref->service_browser_callback)
                sdref->service_browser_callback(sdref, 0, 0, error, NULL, NULL, NULL, sdref->context);
            else if (sdref->service_resolver_callback)
                sdref->service_resolver_callback(sdref, 0, 0, error, NULL, NULL, 0, 0, NULL, sdref->context);
            else if (sdref->domain_browser_callback)
                sdref->domain_browser_callback(sdref, 0, 0, error, NULL, sdref->context);
            else if (sdref->query_resolver_callback)
                sdref->query_resolver_callback(sdref, 0, 0, error, NULL, 0, 0, 0, NULL, 0, sdref->context);

            break;

        case AVAHI_CLIENT_S_RUNNING:
        case AVAHI_CLIENT_S_COLLISION:
        case AVAHI_CLIENT_S_REGISTERING:
        case AVAHI_CLIENT_CONNECTING:
            break;
    }
}

DNSServiceErrorType DNSSD_API DNSServiceBrowse(
        DNSServiceRef *ret_sdref,
        DNSServiceFlags flags,
        uint32_t interface,
        const char *regtype,
        const char *domain,
        DNSServiceBrowseReply callback,
        void *context) {

    DNSServiceErrorType ret = kDNSServiceErr_Unknown;
    int error;
    DNSServiceRef sdref = NULL;
    AvahiIfIndex ifindex;
    struct type_info type_info;

    AVAHI_WARN_LINKAGE;

    if (!ret_sdref || !regtype)
        return kDNSServiceErr_BadParam;
    *ret_sdref = NULL;

    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    type_info_init(&type_info);

    if (type_info_parse(&type_info, regtype) < 0 || type_info.n_subtypes > 1) {
        type_info_free(&type_info);

        if (!avahi_is_valid_service_type_generic(regtype))
            return kDNSServiceErr_Unsupported;
    } else
        regtype = type_info.subtypes ? (char*) type_info.subtypes->text : type_info.type;

    if (!(sdref = sdref_new())) {
        type_info_free(&type_info);
        return kDNSServiceErr_Unknown;
    }

    sdref->context = context;
    sdref->service_browser_callback = callback;

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
        ret =  map_error(error);
        goto finish;
    }

    ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;

    if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
        ret = map_error(avahi_client_errno(sdref->client));
        goto finish;
    }

    ret = kDNSServiceErr_NoError;
    *ret_sdref = sdref;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    if (ret != kDNSServiceErr_NoError)
        DNSServiceRefDeallocate(sdref);

    type_info_free(&type_info);

    return ret;
}

static void service_resolver_callback(
    AvahiServiceResolver *r,
    AvahiIfIndex interface,
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
    AvahiResolverEvent event,
    const char *name,
    const char *type,
    const char *domain,
    const char *host_name,
    AVAHI_GCC_UNUSED const AvahiAddress *a,
    uint16_t port,
    AvahiStringList *txt,
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
    void *userdata) {

    DNSServiceRef sdref = userdata;

    assert(r);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    switch (event) {
        case AVAHI_RESOLVER_FOUND: {

            char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
            char full_name[AVAHI_DOMAIN_NAME_MAX];
            int ret;
            char *p = NULL;
            size_t l = 0;

            host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));

            if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
                avahi_string_list_serialize(txt, p, l);

            ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
            assert(ret == AVAHI_OK);

            strcat(full_name, ".");

            sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, (unsigned char*) p, sdref->context);

            avahi_free(p);
            break;
        }

        case AVAHI_RESOLVER_FAILURE:
            sdref->service_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, 0, 0, NULL, sdref->context);
            break;
    }
}

DNSServiceErrorType DNSSD_API DNSServiceResolve(
    DNSServiceRef *ret_sdref,
    DNSServiceFlags flags,
    uint32_t interface,
    const char *name,
    const char *regtype,
    const char *domain,
    DNSServiceResolveReply callback,
    void *context) {

    DNSServiceErrorType ret = kDNSServiceErr_Unknown;
    int error;
    DNSServiceRef sdref = NULL;
    AvahiIfIndex ifindex;

    AVAHI_WARN_LINKAGE;

    if (!ret_sdref || !name || !regtype || !domain || !callback)
        return kDNSServiceErr_BadParam;
    *ret_sdref = NULL;

    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    if (!(sdref = sdref_new()))
        return kDNSServiceErr_Unknown;

    sdref->context = context;
    sdref->service_resolver_callback = callback;

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
        ret =  map_error(error);
        goto finish;
    }

    ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;

    if (!(sdref->service_resolver = avahi_service_resolver_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, name, regtype, domain, AVAHI_PROTO_UNSPEC, 0, service_resolver_callback, sdref))) {
        ret = map_error(avahi_client_errno(sdref->client));
        goto finish;
    }


    ret = kDNSServiceErr_NoError;
    *ret_sdref = sdref;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    if (ret != kDNSServiceErr_NoError)
        DNSServiceRefDeallocate(sdref);

    return ret;
}

int DNSSD_API DNSServiceConstructFullName (
    char *fullName,
    const char *service,
    const char *regtype,
    const char *domain) {

    AVAHI_WARN_LINKAGE;

    if (!fullName || !regtype || !domain)
        return -1;

    if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
        return -1;

    return 0;
}

static void domain_browser_callback(
    AvahiDomainBrowser *b,
    AvahiIfIndex interface,
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
    AvahiBrowserEvent event,
    const char *domain,
    AvahiLookupResultFlags flags,
    void *userdata) {

    DNSServiceRef sdref = userdata;
    static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];

    assert(b);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));

    switch (event) {
        case AVAHI_BROWSER_NEW:
            if (flags & AVAHI_LOOKUP_RESULT_CACHED) {
                domain_list_t *entry = calloc(1, sizeof(domain_list_t));

                /* store the entry */
                AVAHI_LLIST_INIT(domain_list_t, list, entry);

                entry->sdref = sdref;
                entry->flags = kDNSServiceFlagsAdd;
                entry->interface = interface;
                entry->errors = kDNSServiceErr_NoError;
                entry->domain = strdup(domain);
                entry->userdata = sdref->context;

                AVAHI_LLIST_PREPEND(domain_list_t,
                                    list,
                                    sdref->domain_list,
                                    entry);
            } else {
                sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
            }
            break;

        case AVAHI_BROWSER_REMOVE:
            sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
            break;

        case AVAHI_BROWSER_FAILURE:
            sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
            break;

        case AVAHI_BROWSER_CACHE_EXHAUSTED:
            /* send items in llist */
            if (!sdref->domain_list)
                break;

            domain_list_t *entry = sdref->domain_list;
            while ( entry ) {

                /* send it */
                int new_flags = entry->flags;
                if (entry->list_next) new_flags |= kDNSServiceFlagsMoreComing;

                entry->sdref->domain_browser_callback(entry->sdref, new_flags, entry->interface, entry->errors, entry->domain, entry->userdata);

                /* remove entry */
                domain_list_t *tmp = entry->list_next;
                free(entry->domain);
                free(entry);
                entry = tmp;
            }
            sdref->domain_list = NULL;
            break;

        case AVAHI_BROWSER_ALL_FOR_NOW:
            break;
    }
}

DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
    DNSServiceRef *ret_sdref,
    DNSServiceFlags flags,
    uint32_t interface,
    DNSServiceDomainEnumReply callback,
    void *context) {

    DNSServiceErrorType ret = kDNSServiceErr_Unknown;
    int error;
    DNSServiceRef sdref = NULL;
    AvahiIfIndex ifindex;

    AVAHI_WARN_LINKAGE;

    if (!ret_sdref || !callback)
        return kDNSServiceErr_BadParam;
    *ret_sdref = NULL;

    if (interface == kDNSServiceInterfaceIndexLocalOnly ||
        (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains)) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    if (!(sdref = sdref_new()))
        return kDNSServiceErr_Unknown;

    sdref->context = context;
    sdref->domain_browser_callback = callback;

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
        ret =  map_error(error);
        goto finish;
    }

    ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;

    if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
                                                           flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
                                                           0, domain_browser_callback, sdref))) {
        ret = map_error(avahi_client_errno(sdref->client));
        goto finish;
    }

    ret = kDNSServiceErr_NoError;
    *ret_sdref = sdref;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    if (ret != kDNSServiceErr_NoError)
        DNSServiceRefDeallocate(sdref);

    return ret;
}

static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
    char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
    const char *regtype, *domain;
    assert(sdref);
    assert(sdref->n_ref >= 1);

    if (!sdref->service_register_callback)
        return;

    regtype = add_trailing_dot(sdref->type_info.type, regtype_fixed, sizeof(regtype_fixed));
    domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));

    sdref->service_register_callback(
        sdref, 0, error,
        sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
        regtype,
        domain,
        sdref->context);
}

static int reg_create_service(DNSServiceRef sdref) {
    int ret;
    AvahiStringList *l;

    assert(sdref);
    assert(sdref->n_ref >= 1);

    if ((ret = avahi_entry_group_add_service_strlst(
        sdref->entry_group,
        sdref->service_interface,
        AVAHI_PROTO_UNSPEC,
        0,
        sdref->service_name_chosen,
        sdref->type_info.type,
        sdref->service_domain,
        sdref->service_host,
        sdref->service_port,
        sdref->service_txt)) < 0)
        return ret;

    for (l = sdref->type_info.subtypes; l; l = l->next) {
        /* Create a subtype entry */

        if (avahi_entry_group_add_service_subtype(
                sdref->entry_group,
                sdref->service_interface,
                AVAHI_PROTO_UNSPEC,
                0,
                sdref->service_name_chosen,
                sdref->type_info.type,
                sdref->service_domain,
                (const char*) l->text) < 0)
            return ret;
    }

    if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
        return ret;

    return 0;
}

static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
    DNSServiceRef sdref = userdata;

    assert(s);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    /* We've not been setup completely */
    if (!sdref->entry_group)
        return;

    switch (state) {
        case AVAHI_CLIENT_FAILURE:
            reg_report_error(sdref, kDNSServiceErr_Unknown);
            break;

        case AVAHI_CLIENT_S_RUNNING: {
            int ret;

            if (!sdref->service_name) {
                const char *n;
                /* If the service name is taken from the host name, copy that */

                avahi_free(sdref->service_name_chosen);
                sdref->service_name_chosen = NULL;

                if (!(n = avahi_client_get_host_name(sdref->client))) {
                    reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
                    return;
                }

                if (!(sdref->service_name_chosen = avahi_strdup(n))) {
                    reg_report_error(sdref, kDNSServiceErr_NoMemory);
                    return;
                }
            }

            if (!sdref->service_name_chosen) {

                assert(sdref->service_name);

                if (!(sdref->service_name_chosen = avahi_strdup(sdref->service_name))) {
                    reg_report_error(sdref, kDNSServiceErr_NoMemory);
                    return;
                }
            }

            /* Register the service */

            if ((ret = reg_create_service(sdref)) < 0) {
                reg_report_error(sdref, map_error(ret));
                return;
            }

            break;
        }

        case AVAHI_CLIENT_S_COLLISION:
        case AVAHI_CLIENT_S_REGISTERING:

            /* Remove our entry */
            avahi_entry_group_reset(sdref->entry_group);

            break;

        case AVAHI_CLIENT_CONNECTING:
            /* Ignore */
            break;
    }

}

static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
    DNSServiceRef sdref = userdata;

    assert(g);

    switch (state) {
        case AVAHI_ENTRY_GROUP_ESTABLISHED:

            /* Inform the user */
            reg_report_error(sdref, kDNSServiceErr_NoError);

            break;

        case AVAHI_ENTRY_GROUP_COLLISION: {
            char *n;
            int ret;

            /* Remove our entry */
            avahi_entry_group_reset(sdref->entry_group);

            assert(sdref->service_name_chosen);

            /* Pick a new name */
            if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
                reg_report_error(sdref, kDNSServiceErr_NoMemory);
                return;
            }
            avahi_free(sdref->service_name_chosen);
            sdref->service_name_chosen = n;

            /* Register the service with that new name */
            if ((ret = reg_create_service(sdref)) < 0) {
                reg_report_error(sdref, map_error(ret));
                return;
            }

            break;
        }

        case AVAHI_ENTRY_GROUP_REGISTERING:
        case AVAHI_ENTRY_GROUP_UNCOMMITED:
            /* Ignore */
            break;

        case AVAHI_ENTRY_GROUP_FAILURE:
            /* Inform the user */
            reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
            break;

    }
}

DNSServiceErrorType DNSSD_API DNSServiceRegister (
        DNSServiceRef *ret_sdref,
        DNSServiceFlags flags,
        uint32_t interface,
        const char *name,
        const char *regtype,
        const char *domain,
        const char *host,
        uint16_t port,
        uint16_t txtLen,
        const void *txtRecord,
        DNSServiceRegisterReply callback,
        void *context) {

    DNSServiceErrorType ret = kDNSServiceErr_Unknown;
    int error;
    DNSServiceRef sdref = NULL;
    AvahiStringList *txt = NULL;
    struct type_info type_info;

    AVAHI_WARN_LINKAGE;

    if (!ret_sdref || !regtype)
        return kDNSServiceErr_BadParam;
    *ret_sdref = NULL;

    if (!txtRecord) {
        txtLen = 1;
        txtRecord = "";
    }

    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    if (txtLen > 0)
        if (avahi_string_list_parse(txtRecord, txtLen, &txt) < 0)
            return kDNSServiceErr_Invalid;

    if (type_info_parse(&type_info, regtype) < 0) {
        avahi_string_list_free(txt);
        return kDNSServiceErr_Invalid;
    }

    if (!(sdref = sdref_new())) {
        avahi_string_list_free(txt);
        type_info_free(&type_info);
        return kDNSServiceErr_Unknown;
    }

    sdref->context = context;
    sdref->service_register_callback = callback;

    sdref->type_info = type_info;
    sdref->service_name = avahi_strdup(name);
    sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
    sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
    sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
    sdref->service_port = ntohs(port);
    sdref->service_txt = txt;

    /* Some OOM checking would be cool here */

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, reg_client_callback, sdref, &error))) {
        ret =  map_error(error);
        goto finish;
    }

    if (!sdref->service_domain) {
        const char *d;

        if (!(d = avahi_client_get_domain_name(sdref->client))) {
            ret = map_error(avahi_client_errno(sdref->client));
            goto finish;
        }

        if (!(sdref->service_domain = avahi_strdup(d))) {
            ret = kDNSServiceErr_NoMemory;
            goto finish;
        }
    }

    if (!(sdref->entry_group = avahi_entry_group_new(sdref->client, reg_entry_group_callback, sdref))) {
        ret = map_error(avahi_client_errno(sdref->client));
        goto finish;
    }

    if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
        const char *n;

        if (sdref->service_name)
            n = sdref->service_name;
        else {
            if (!(n = avahi_client_get_host_name(sdref->client))) {
                ret = map_error(avahi_client_errno(sdref->client));
                goto finish;
            }
        }

        if (!(sdref->service_name_chosen = avahi_strdup(n))) {
            ret = kDNSServiceErr_NoMemory;
            goto finish;
        }


        if ((error = reg_create_service(sdref)) < 0) {
            ret = map_error(error);
            goto finish;
        }
    }

    ret = kDNSServiceErr_NoError;
    *ret_sdref = sdref;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    if (ret != kDNSServiceErr_NoError)
        DNSServiceRefDeallocate(sdref);

    return ret;
}

DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord(
         DNSServiceRef sdref,
         DNSRecordRef rref,
         DNSServiceFlags flags,
         uint16_t rdlen,
         const void *rdata,
         AVAHI_GCC_UNUSED uint32_t ttl) {

    int ret = kDNSServiceErr_Unknown;
    AvahiStringList *txt = NULL;

    AVAHI_WARN_LINKAGE;

    if (!sdref || sdref->n_ref <= 0)
        return kDNSServiceErr_BadParam;

    if (flags || rref) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    if (rdlen > 0)
        if (avahi_string_list_parse(rdata, rdlen, &txt) < 0)
            return kDNSServiceErr_Invalid;

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!avahi_string_list_equal(txt, sdref->service_txt)) {

        avahi_string_list_free(sdref->service_txt);
        sdref->service_txt = txt;

        if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING &&
            sdref->entry_group &&
            (avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_ESTABLISHED ||
            avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING))

            if (avahi_entry_group_update_service_txt_strlst(
                        sdref->entry_group,
                        sdref->service_interface,
                        AVAHI_PROTO_UNSPEC,
                        0,
                        sdref->service_name_chosen,
                        sdref->type_info.type,
                        sdref->service_domain,
                        sdref->service_txt) < 0) {

                ret = map_error(avahi_client_errno(sdref->client));
                goto finish;
            }

    } else
        avahi_string_list_free(txt);

    ret = kDNSServiceErr_NoError;

finish:
    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    return ret;
}

static void query_resolver_callback(
        AvahiRecordBrowser *r,
        AvahiIfIndex interface,
        AVAHI_GCC_UNUSED AvahiProtocol protocol,
        AvahiBrowserEvent event,
        const char *name,
        uint16_t clazz,
        uint16_t type,
        const void* rdata,
        size_t size,
        AvahiLookupResultFlags flags,
        void *userdata) {

    DNSServiceRef sdref = userdata;

    assert(r);
    assert(sdref);
    assert(sdref->n_ref >= 1);

    switch (event) {

    case AVAHI_BROWSER_NEW:
    case AVAHI_BROWSER_REMOVE: {
        DNSServiceFlags qflags = 0;
        if (event == AVAHI_BROWSER_NEW)
            qflags |= kDNSServiceFlagsAdd;

        if (flags & AVAHI_LOOKUP_RESULT_CACHED) {
            query_list_t *entry = calloc(1, sizeof(query_list_t));

            /* store the entry */
            AVAHI_LLIST_INIT(query_list_t, list, entry);

            entry->sdref = sdref;
            entry->flags = qflags;
            entry->interface = interface;
            entry->errors = kDNSServiceErr_NoError;
            entry->name = strdup(name);
            entry->type = type;
            entry->clazz = clazz;
            entry->size = size;
            entry->rdata = rdata;
            entry->ttl = 0;
            entry->userdata = sdref->context;

            AVAHI_LLIST_PREPEND(query_list_t,
                                list,
                                sdref->query_list,
                                entry);
        } else {
            sdref->query_resolver_callback(sdref, qflags, interface, kDNSServiceErr_NoError, name, type, clazz, size, rdata, 0, sdref->context);
        }
        break;
    }

    case AVAHI_BROWSER_ALL_FOR_NOW:
        break;

    case AVAHI_BROWSER_CACHE_EXHAUSTED:
        /* send items in llist */
        if (!sdref->query_list)
            break;

        query_list_t *entry = sdref->query_list;
	while (entry ) {

            /* send it */
            int new_flags = entry->flags;
            if (entry->list_next) new_flags |= kDNSServiceFlagsMoreComing;

            entry->sdref->query_resolver_callback(entry->sdref, new_flags, entry->interface, entry->errors, entry->name, entry->type, entry->clazz, entry->size, entry->rdata, entry->ttl, entry->userdata);

            /* remove entry */
            query_list_t *tmp = entry->list_next;
            free(entry->name);
            free(entry);
            entry = tmp;
        }
        sdref->query_list = NULL;
        break;

    case AVAHI_BROWSER_FAILURE:
        sdref->query_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, 0, 0, 0, NULL, 0, sdref->context);
        break;
    }
}

DNSServiceErrorType DNSSD_API DNSServiceQueryRecord (
    DNSServiceRef *ret_sdref,
    DNSServiceFlags flags,
    uint32_t interface,
    const char *fullname,
    uint16_t type,
    uint16_t clazz,
    DNSServiceQueryRecordReply callback,
    void *context) {

    DNSServiceErrorType ret = kDNSServiceErr_Unknown;
    int error;
    DNSServiceRef sdref = NULL;
    AvahiIfIndex ifindex;

    AVAHI_WARN_LINKAGE;

    if (!ret_sdref || !fullname)
        return kDNSServiceErr_BadParam;
    *ret_sdref = NULL;

    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
        AVAHI_WARN_UNSUPPORTED;
        return kDNSServiceErr_Unsupported;
    }

    if (!(sdref = sdref_new()))
        return kDNSServiceErr_Unknown;

    sdref->context = context;
    sdref->query_resolver_callback = callback;

    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));

    if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
        ret =  map_error(error);
        goto finish;
    }

    ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;

    if (!(sdref->record_browser = avahi_record_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, fullname, clazz, type, 0, query_resolver_callback, sdref))) {
        ret = map_error(avahi_client_errno(sdref->client));
        goto finish;
    }

    ret = kDNSServiceErr_NoError;
    *ret_sdref = sdref;

finish:

    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));

    if (ret != kDNSServiceErr_NoError)
        DNSServiceRefDeallocate(sdref);

    return ret;
}
