1372 lines
36 KiB
C
1372 lines
36 KiB
C
/***
|
|
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 <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/avahi-malloc.h"
|
|
#include <avahi-common/error.h>
|
|
#include <avahi-common/domain.h>
|
|
#include <avahi-common/alternative.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 _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;
|
|
};
|
|
|
|
#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));
|
|
|
|
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,
|
|
AVAHI_GCC_UNUSED 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:
|
|
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:
|
|
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,
|
|
AVAHI_GCC_UNUSED 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:
|
|
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:
|
|
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,
|
|
AVAHI_GCC_UNUSED 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;
|
|
|
|
sdref->query_resolver_callback(sdref, qflags, interface, kDNSServiceErr_NoError, name, type, clazz, size, rdata, 0, sdref->context);
|
|
break;
|
|
}
|
|
|
|
case AVAHI_BROWSER_ALL_FOR_NOW:
|
|
case AVAHI_BROWSER_CACHE_EXHAUSTED:
|
|
/* not implemented */
|
|
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;
|
|
}
|