4 This file is part of avahi.
6 avahi is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 avahi is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14 Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with avahi; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
33 #include <netinet/in.h>
35 #include <avahi-common/simple-watch.h>
36 #include <avahi-common/malloc.h>
37 #include <avahi-common/error.h>
38 #include <avahi-client/client.h>
49 struct _DNSServiceRef_t {
50 AvahiSimplePoll *simple_poll;
52 int thread_fd, main_fd;
57 pthread_mutex_t mutex;
60 DNSServiceBrowseReply service_browser_callback;
61 DNSServiceResolveReply service_resolver_callback;
64 AvahiServiceBrowser *service_browser;
65 AvahiServiceResolver *service_resolver;
68 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
70 static int read_command(int fd) {
76 if ((r = read(fd, &command, 1)) != 1) {
77 fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
84 static int write_command(int fd, char reply) {
87 if (write(fd, &reply, 1) != 1) {
88 fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
95 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
96 DNSServiceRef sdref = userdata;
101 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
103 /* fprintf(stderr, "pre-syscall\n"); */
104 ret = poll(ufds, nfds, timeout);
105 /* fprintf(stderr, "post-syscall\n"); */
107 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
112 static void * thread_func(void *data) {
113 DNSServiceRef sdref = data;
117 pthread_sigmask(SIG_BLOCK, &mask, NULL);
119 sdref->thread = pthread_self();
120 sdref->thread_running = 1;
125 if ((command = read_command(sdref->thread_fd)) < 0)
128 /* fprintf(stderr, "Command: %c\n", command); */
134 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
137 if (avahi_simple_poll_run(sdref->simple_poll) < 0) {
138 fprintf(stderr, __FILE__": avahi_simple_poll_run() failed.\n");
139 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
143 if (write_command(sdref->thread_fd, COMMAND_POLLED) < 0) {
144 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
148 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
161 static DNSServiceRef sdref_new(void) {
162 int fd[2] = { -1, -1 };
163 DNSServiceRef sdref = NULL;
165 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
168 if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
171 sdref->thread_fd = fd[0];
172 sdref->main_fd = fd[1];
174 sdref->client = NULL;
175 sdref->service_browser = NULL;
176 sdref->service_resolver = NULL;
178 pthread_mutex_init(&sdref->mutex, NULL);
180 sdref->thread_running = 0;
182 if (!(sdref->simple_poll = avahi_simple_poll_new()))
185 avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
187 /* Start simple poll */
188 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
191 /* Queue a initiall POLL command for the thread */
192 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
195 if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
198 sdref->thread_running = 1;
205 DNSServiceRefDeallocate(sdref);
210 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdRef) {
213 return sdRef->main_fd;
216 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
217 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
219 if (pthread_mutex_lock(&sdref->mutex) != 0)
220 return kDNSServiceErr_Unknown;
222 /* Cleanup notification socket */
223 if (read_command(sdref->main_fd) != COMMAND_POLLED)
226 if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
229 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
232 /* Request the poll */
233 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
236 ret = kDNSServiceErr_NoError;
240 pthread_mutex_unlock(&sdref->mutex);
245 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
248 fprintf(stderr, "deallocating()\n");
250 if (sdref->thread_running) {
251 write_command(sdref->main_fd, COMMAND_QUIT);
252 avahi_simple_poll_wakeup(sdref->simple_poll);
253 pthread_join(sdref->thread, NULL);
257 avahi_client_free(sdref->client);
259 if (sdref->thread_fd >= 0)
260 close(sdref->thread_fd);
262 if (sdref->main_fd >= 0)
263 close(sdref->main_fd);
265 if (sdref->simple_poll)
266 avahi_simple_poll_free(sdref->simple_poll);
268 pthread_mutex_destroy(&sdref->mutex);
273 static DNSServiceErrorType map_error(int error) {
276 return kDNSServiceErr_NoError;
278 case AVAHI_ERR_BAD_STATE :
279 return kDNSServiceErr_BadState;
281 case AVAHI_ERR_INVALID_HOST_NAME:
282 case AVAHI_ERR_INVALID_DOMAIN_NAME:
283 case AVAHI_ERR_INVALID_TTL:
284 case AVAHI_ERR_IS_PATTERN:
285 case AVAHI_ERR_INVALID_RECORD:
286 case AVAHI_ERR_INVALID_SERVICE_NAME:
287 case AVAHI_ERR_INVALID_SERVICE_TYPE:
288 case AVAHI_ERR_INVALID_PORT:
289 case AVAHI_ERR_INVALID_KEY:
290 case AVAHI_ERR_INVALID_ADDRESS:
291 return kDNSServiceErr_BadParam;
294 case AVAHI_ERR_LOCAL_COLLISION:
295 return kDNSServiceErr_NameConflict;
297 case AVAHI_ERR_TOO_MANY_CLIENTS:
298 case AVAHI_ERR_TOO_MANY_OBJECTS:
299 case AVAHI_ERR_TOO_MANY_ENTRIES:
300 case AVAHI_ERR_ACCESS_DENIED:
301 return kDNSServiceErr_Refused;
303 case AVAHI_ERR_INVALID_OPERATION:
304 case AVAHI_ERR_INVALID_OBJECT:
305 return kDNSServiceErr_Invalid;
307 case AVAHI_ERR_NO_MEMORY:
308 return kDNSServiceErr_NoMemory;
310 case AVAHI_ERR_INVALID_INTERFACE:
311 case AVAHI_ERR_INVALID_PROTOCOL:
312 return kDNSServiceErr_BadInterfaceIndex;
314 case AVAHI_ERR_INVALID_FLAGS:
315 return kDNSServiceErr_BadFlags;
317 case AVAHI_ERR_NOT_FOUND:
318 return kDNSServiceErr_NoSuchName;
320 case AVAHI_ERR_VERSION_MISMATCH:
321 return kDNSServiceErr_Incompatible;
323 case AVAHI_ERR_NO_NETWORK:
325 case AVAHI_ERR_INVALID_CONFIG:
326 case AVAHI_ERR_TIMEOUT:
327 case AVAHI_ERR_DBUS_ERROR:
328 case AVAHI_ERR_NOT_CONNECTED:
329 case AVAHI_ERR_NO_DAEMON:
334 return kDNSServiceErr_Unknown;
337 static void service_browser_callback(
338 AvahiServiceBrowser *b,
339 AvahiIfIndex interface,
340 AvahiProtocol protocol,
341 AvahiBrowserEvent event,
345 AvahiLookupResultFlags flags,
348 DNSServiceRef sdref = userdata;
354 case AVAHI_BROWSER_NEW:
355 sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
358 case AVAHI_BROWSER_REMOVE:
359 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
362 case AVAHI_BROWSER_FAILURE:
363 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_Unknown, name, type, domain, sdref->context);
366 case AVAHI_BROWSER_NOT_FOUND:
367 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, name, type, domain, sdref->context);
370 case AVAHI_BROWSER_CACHE_EXHAUSTED:
371 case AVAHI_BROWSER_ALL_FOR_NOW:
376 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
377 DNSServiceRef *ret_sdref,
378 DNSServiceFlags flags,
382 DNSServiceBrowseReply callback,
385 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
387 DNSServiceRef sdref = NULL;
388 AvahiIfIndex ifindex;
395 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0)
396 return kDNSServiceErr_Unsupported;
398 if (!(sdref = sdref_new()))
399 return kDNSServiceErr_Unknown;
401 sdref->context = context;
402 sdref->service_browser_callback = callback;
404 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
406 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), NULL, NULL, &error))) {
407 ret = map_error(error);
411 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
413 if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
414 ret = map_error(avahi_client_errno(sdref->client));
419 ret = kDNSServiceErr_NoError;
424 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
426 if (ret != kDNSServiceErr_NoError)
427 DNSServiceRefDeallocate(sdref);
432 static void service_resolver_callback(
433 AvahiServiceResolver *r,
434 AvahiIfIndex interface,
435 AvahiProtocol protocol,
436 AvahiResolverEvent event,
440 const char *host_name,
441 const AvahiAddress *a,
443 AvahiStringList *txt,
444 AvahiLookupResultFlags flags,
447 DNSServiceRef sdref = userdata;
453 case AVAHI_RESOLVER_FOUND: {
458 if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
459 avahi_string_list_serialize(txt, p, l);
461 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, "blaa", host_name, htons(port), l, p, sdref->context);
467 case AVAHI_RESOLVER_TIMEOUT:
468 case AVAHI_RESOLVER_NOT_FOUND:
469 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, NULL, NULL, 0, 0, NULL, sdref->context);
472 case AVAHI_RESOLVER_FAILURE:
473 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_Unknown, NULL, NULL, 0, 0, NULL, sdref->context);
479 DNSServiceErrorType DNSSD_API DNSServiceResolve(
480 DNSServiceRef *ret_sdref,
481 DNSServiceFlags flags,
486 DNSServiceResolveReply callback,
489 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
491 DNSServiceRef sdref = NULL;
492 AvahiIfIndex ifindex;
500 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0)
501 return kDNSServiceErr_Unsupported;
503 if (!(sdref = sdref_new()))
504 return kDNSServiceErr_Unknown;
506 sdref->context = context;
507 sdref->service_resolver_callback = callback;
509 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
511 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), NULL, NULL, &error))) {
512 ret = map_error(error);
516 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
518 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))) {
519 ret = map_error(avahi_client_errno(sdref->client));
524 ret = kDNSServiceErr_NoError;
529 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
531 if (ret != kDNSServiceErr_NoError)
532 DNSServiceRefDeallocate(sdref);