1 /*** 2 This file is part of avahi. 3 4 avahi is free software; you can redistribute it and/or modify it 5 under the terms of the GNU Lesser General Public License as 6 published by the Free Software Foundation; either version 2.1 of the 7 License, or (at your option) any later version. 8 9 avahi is distributed in the hope that it will be useful, but WITHOUT 10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 11 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 12 Public License for more details. 13 14 You should have received a copy of the GNU Lesser General Public 15 License along with avahi; if not, write to the Free Software 16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 17 USA. 18 ***/ 19 20 #ifdef HAVE_CONFIG_H 21 #include <config.h> 22 #endif 23 24 #include <assert.h> 25 26 #include <pthread.h> 27 28 #include <avahi-common/strlst.h> 29 #include "avahi-common/avahi-malloc.h" 30 #include <avahi-common/domain.h> 31 #include <avahi-common/simple-watch.h> 32 #include <avahi-common/error.h> 33 #include <avahi-common/llist.h> 34 35 #include <avahi-client/client.h> 36 #include <avahi-client/publish.h> 37 #include <avahi-client/lookup.h> 38 39 #include "howl.h" 40 #include "warn.h" 41 42 #define OID_MAX 50 43 44 enum { 45 COMMAND_POLL = 'p', 46 COMMAND_QUIT = 'q', 47 COMMAND_POLL_DONE = 'P', 48 COMMAND_POLL_FAILED = 'F' 49 }; 50 51 typedef enum { 52 OID_UNUSED = 0, 53 OID_SERVICE_BROWSER, 54 OID_SERVICE_RESOLVER, 55 OID_DOMAIN_BROWSER, 56 OID_ENTRY_GROUP 57 } oid_type; 58 59 typedef struct service_data service_data; 60 61 typedef struct oid_data { 62 oid_type type; 63 sw_opaque extra; 64 sw_discovery discovery; 65 void *object; 66 sw_result (*reply)(void); 67 service_data *service_data; 68 } oid_data; 69 70 71 struct service_data { 72 char *name, *regtype, *domain, *host; 73 uint16_t port; 74 AvahiIfIndex interface; 75 AvahiStringList *txt; 76 AVAHI_LLIST_FIELDS(service_data, services); 77 }; 78 79 struct _sw_discovery { 80 int n_ref; 81 AvahiSimplePoll *simple_poll; 82 AvahiClient *client; 83 84 oid_data oid_table[OID_MAX]; 85 sw_discovery_oid oid_index; 86 87 int thread_fd, main_fd; 88 89 pthread_t thread; 90 int thread_running; 91 92 pthread_mutex_t mutex, salt_mutex; 93 94 AVAHI_LLIST_HEAD(service_data, services); 95 }; 96 97 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); } 98 99 #define OID_GET_INDEX(data) ((sw_discovery_oid) (((data) - ((data)->discovery->oid_table)))) 100 101 static sw_discovery discovery_ref(sw_discovery self); 102 static void discovery_unref(sw_discovery self); 103 104 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) { 105 if (!s) 106 return NULL; 107 108 if (*s == 0) 109 return s; 110 111 if (s[strlen(s)-1] == '.') 112 return s; 113 114 snprintf(buf, buf_len, "%s.", s); 115 return buf; 116 } 117 118 static sw_result map_error(int error) { 119 switch (error) { 120 case AVAHI_OK: 121 return SW_OKAY; 122 123 case AVAHI_ERR_NO_MEMORY: 124 return SW_E_MEM; 125 } 126 127 return SW_E_UNKNOWN; 128 } 129 130 static int read_command(int fd) { 131 ssize_t r; 132 char command; 133 134 assert(fd >= 0); 135 136 if ((r = read(fd, &command, 1)) != 1) { 137 fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF"); 138 return -1; 139 } 140 141 return command; 142 } 143 144 static int write_command(int fd, char reply) { 145 assert(fd >= 0); 146 147 if (write(fd, &reply, 1) != 1) { 148 fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno)); 149 return -1; 150 } 151 152 return 0; 153 } 154 155 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) { 156 sw_discovery self = userdata; 157 int ret; 158 159 assert(self); 160 161 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 162 ret = poll(ufds, nfds, timeout); 163 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 164 165 return ret; 166 } 167 168 static void * thread_func(void *data) { 169 sw_discovery self = data; 170 sigset_t mask; 171 172 sigfillset(&mask); 173 pthread_sigmask(SIG_BLOCK, &mask, NULL); 174 175 self->thread = pthread_self(); 176 self->thread_running = 1; 177 178 for (;;) { 179 char command; 180 181 if ((command = read_command(self->thread_fd)) < 0) 182 break; 183 184 /* fprintf(stderr, "Command: %c\n", command); */ 185 186 switch (command) { 187 188 case COMMAND_POLL: { 189 int ret; 190 191 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 192 193 for (;;) { 194 errno = 0; 195 196 if ((ret = avahi_simple_poll_run(self->simple_poll)) < 0) { 197 198 if (errno == EINTR) 199 continue; 200 201 fprintf(stderr, __FILE__": avahi_simple_poll_run() failed: %s\n", strerror(errno)); 202 } 203 204 break; 205 } 206 207 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 208 209 if (write_command(self->thread_fd, ret < 0 ? COMMAND_POLL_FAILED : COMMAND_POLL_DONE) < 0) 210 break; 211 212 break; 213 } 214 215 case COMMAND_QUIT: 216 return NULL; 217 } 218 219 } 220 221 return NULL; 222 } 223 224 static int oid_alloc(sw_discovery self, oid_type type) { 225 sw_discovery_oid i; 226 assert(self); 227 228 for (i = 0; i < OID_MAX; i++) { 229 230 while (self->oid_index >= OID_MAX) 231 self->oid_index -= OID_MAX; 232 233 if (self->oid_table[self->oid_index].type == OID_UNUSED) { 234 self->oid_table[self->oid_index].type = type; 235 self->oid_table[self->oid_index].discovery = self; 236 237 assert(OID_GET_INDEX(&self->oid_table[self->oid_index]) == self->oid_index); 238 239 return self->oid_index ++; 240 } 241 242 self->oid_index ++; 243 } 244 245 /* No free entry found */ 246 247 return (sw_discovery_oid) -1; 248 } 249 250 static void oid_release(sw_discovery self, sw_discovery_oid oid) { 251 assert(self); 252 assert(oid < OID_MAX); 253 254 assert(self->oid_table[oid].type != OID_UNUSED); 255 256 self->oid_table[oid].type = OID_UNUSED; 257 self->oid_table[oid].discovery = NULL; 258 self->oid_table[oid].reply = NULL; 259 self->oid_table[oid].object = NULL; 260 self->oid_table[oid].extra = NULL; 261 self->oid_table[oid].service_data = NULL; 262 } 263 264 static oid_data* oid_get(sw_discovery self, sw_discovery_oid oid) { 265 assert(self); 266 267 if (oid >= OID_MAX) 268 return NULL; 269 270 if (self->oid_table[oid].type == OID_UNUSED) 271 return NULL; 272 273 return &self->oid_table[oid]; 274 } 275 276 static service_data* service_data_new(sw_discovery self) { 277 service_data *sdata; 278 279 assert(self); 280 281 if (!(sdata = avahi_new0(service_data, 1))) 282 return NULL; 283 284 AVAHI_LLIST_PREPEND(service_data, services, self->services, sdata); 285 286 return sdata; 287 288 } 289 290 static void service_data_free(sw_discovery self, service_data* sdata) { 291 assert(self); 292 assert(sdata); 293 294 AVAHI_LLIST_REMOVE(service_data, services, self->services, sdata); 295 296 avahi_free(sdata->name); 297 avahi_free(sdata->regtype); 298 avahi_free(sdata->domain); 299 avahi_free(sdata->host); 300 avahi_string_list_free(sdata->txt); 301 avahi_free(sdata); 302 } 303 304 static void reg_client_callback(oid_data *data, AvahiClientState state); 305 306 static void client_callback(AvahiClient *s, AvahiClientState state, void* userdata) { 307 sw_discovery self = userdata; 308 sw_discovery_oid oid; 309 310 assert(s); 311 assert(self); 312 313 discovery_ref(self); 314 315 for (oid = 0; oid < OID_MAX; oid++) { 316 317 switch (self->oid_table[oid].type) { 318 319 case OID_ENTRY_GROUP: 320 reg_client_callback(&self->oid_table[oid], state); 321 break; 322 323 case OID_DOMAIN_BROWSER: 324 case OID_SERVICE_BROWSER: 325 ((sw_discovery_browse_reply) self->oid_table[oid].reply)(self, oid, SW_DISCOVERY_BROWSE_INVALID, 0, NULL, NULL, NULL, self->oid_table[oid].extra); 326 break; 327 328 case OID_SERVICE_RESOLVER: 329 case OID_UNUSED: 330 ; 331 } 332 } 333 334 discovery_unref(self); 335 } 336 337 sw_result sw_discovery_init(sw_discovery * self) { 338 int fd[2] = { -1, -1}; 339 sw_result result = SW_E_UNKNOWN; 340 pthread_mutexattr_t mutex_attr; 341 int error; 342 343 assert(self); 344 345 AVAHI_WARN_LINKAGE; 346 347 *self = NULL; 348 349 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0) 350 goto fail; 351 352 if (!(*self = avahi_new(struct _sw_discovery, 1))) { 353 result = SW_E_MEM; 354 goto fail; 355 } 356 357 (*self)->n_ref = 1; 358 (*self)->thread_fd = fd[0]; 359 (*self)->main_fd = fd[1]; 360 361 (*self)->client = NULL; 362 (*self)->simple_poll = NULL; 363 364 memset((*self)->oid_table, 0, sizeof((*self)->oid_table)); 365 (*self)->oid_index = 0; 366 367 (*self)->thread_running = 0; 368 369 AVAHI_LLIST_HEAD_INIT(service_info, (*self)->services); 370 371 ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr)); 372 pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE); 373 ASSERT_SUCCESS(pthread_mutex_init(&(*self)->mutex, &mutex_attr)); 374 ASSERT_SUCCESS(pthread_mutex_init(&(*self)->salt_mutex, &mutex_attr)); 375 376 if (!((*self)->simple_poll = avahi_simple_poll_new())) 377 goto fail; 378 379 avahi_simple_poll_set_func((*self)->simple_poll, poll_func, *self); 380 381 if (!((*self)->client = avahi_client_new(avahi_simple_poll_get((*self)->simple_poll), 0, client_callback, *self, &error))) { 382 result = map_error(error); 383 goto fail; 384 } 385 386 /* Start simple poll */ 387 if (avahi_simple_poll_prepare((*self)->simple_poll, -1) < 0) 388 goto fail; 389 390 /* Queue an initial POLL command for the thread */ 391 if (write_command((*self)->main_fd, COMMAND_POLL) < 0) 392 goto fail; 393 394 if (pthread_create(&(*self)->thread, NULL, thread_func, *self) != 0) 395 goto fail; 396 397 (*self)->thread_running = 1; 398 399 return SW_OKAY; 400 401 fail: 402 403 if (*self) 404 sw_discovery_fina(*self); 405 406 return result; 407 } 408 409 static int stop_thread(sw_discovery self) { 410 assert(self); 411 412 if (!self->thread_running) 413 return 0; 414 415 if (write_command(self->main_fd, COMMAND_QUIT) < 0) 416 return -1; 417 418 avahi_simple_poll_wakeup(self->simple_poll); 419 420 ASSERT_SUCCESS(pthread_join(self->thread, NULL)); 421 self->thread_running = 0; 422 return 0; 423 } 424 425 static sw_discovery discovery_ref(sw_discovery self) { 426 assert(self); 427 assert(self->n_ref >= 1); 428 429 self->n_ref++; 430 431 return self; 432 } 433 434 static void discovery_unref(sw_discovery self) { 435 assert(self); 436 assert(self->n_ref >= 1); 437 438 if (--self->n_ref > 0) 439 return; 440 441 stop_thread(self); 442 443 if (self->client) 444 avahi_client_free(self->client); 445 446 if (self->simple_poll) 447 avahi_simple_poll_free(self->simple_poll); 448 449 if (self->thread_fd >= 0) 450 close(self->thread_fd); 451 452 if (self->main_fd >= 0) 453 close(self->main_fd); 454 455 ASSERT_SUCCESS(pthread_mutex_destroy(&self->mutex)); 456 ASSERT_SUCCESS(pthread_mutex_destroy(&self->salt_mutex)); 457 458 while (self->services) 459 service_data_free(self, self->services); 460 461 avahi_free(self); 462 } 463 464 sw_result sw_discovery_fina(sw_discovery self) { 465 assert(self); 466 467 AVAHI_WARN_LINKAGE; 468 469 stop_thread(self); 470 discovery_unref(self); 471 472 return SW_OKAY; 473 } 474 475 sw_result sw_discovery_run(sw_discovery self) { 476 assert(self); 477 478 AVAHI_WARN_LINKAGE; 479 480 return sw_salt_run((sw_salt) self); 481 } 482 483 sw_result sw_discovery_stop_run(sw_discovery self) { 484 assert(self); 485 486 AVAHI_WARN_LINKAGE; 487 488 return sw_salt_stop_run((sw_salt) self); 489 } 490 491 int sw_discovery_socket(sw_discovery self) { 492 assert(self); 493 494 AVAHI_WARN_LINKAGE; 495 496 return self->main_fd; 497 } 498 499 sw_result sw_discovery_read_socket(sw_discovery self) { 500 sw_result result = SW_E_UNKNOWN; 501 502 assert(self); 503 504 discovery_ref(self); 505 506 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 507 508 /* Cleanup notification socket */ 509 if (read_command(self->main_fd) != COMMAND_POLL_DONE) 510 goto finish; 511 512 if (avahi_simple_poll_dispatch(self->simple_poll) < 0) 513 goto finish; 514 515 if (self->n_ref > 1) /* Perhaps we should die */ 516 517 /* Dispatch events */ 518 if (avahi_simple_poll_prepare(self->simple_poll, -1) < 0) 519 goto finish; 520 521 if (self->n_ref > 1) 522 523 /* Request the poll */ 524 if (write_command(self->main_fd, COMMAND_POLL) < 0) 525 goto finish; 526 527 result = SW_OKAY; 528 529 finish: 530 531 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 532 533 discovery_unref(self); 534 535 return result; 536 } 537 538 sw_result sw_discovery_salt(sw_discovery self, sw_salt *salt) { 539 assert(self); 540 assert(salt); 541 542 AVAHI_WARN_LINKAGE; 543 544 *salt = (sw_salt) self; 545 546 return SW_OKAY; 547 } 548 549 sw_result sw_salt_step(sw_salt self, sw_uint32 * msec) { 550 struct pollfd p; 551 int r; 552 sw_result result; 553 554 AVAHI_WARN_LINKAGE; 555 556 if (!((sw_discovery) self)->thread_running) 557 return SW_E_UNKNOWN; 558 559 memset(&p, 0, sizeof(p)); 560 p.fd = ((sw_discovery) self)->main_fd; 561 p.events = POLLIN; 562 563 if ((r = poll(&p, 1, msec ? (int) *msec : -1)) < 0) { 564 565 /* Don't treat EINTR as error */ 566 if (errno == EINTR) 567 return SW_OKAY; 568 569 return SW_E_UNKNOWN; 570 571 } else if (r == 0) { 572 573 /* Timeoout */ 574 return SW_OKAY; 575 576 } else { 577 /* Success */ 578 579 if (p.revents != POLLIN) 580 return SW_E_UNKNOWN; 581 582 if ((result = sw_discovery_read_socket((sw_discovery) self)) != SW_OKAY) 583 return result; 584 } 585 586 return SW_OKAY; 587 } 588 589 sw_result sw_salt_run(sw_salt self) { 590 sw_result ret; 591 592 AVAHI_WARN_LINKAGE; 593 594 assert(self); 595 596 for (;;) 597 if ((ret = sw_salt_step(self, NULL)) != SW_OKAY) 598 return ret; 599 } 600 601 sw_result sw_salt_stop_run(sw_salt self) { 602 AVAHI_WARN_LINKAGE; 603 604 assert(self); 605 606 if (stop_thread((sw_discovery) self) < 0) 607 return SW_E_UNKNOWN; 608 609 return SW_OKAY; 610 } 611 612 sw_result sw_salt_lock(sw_salt self) { 613 AVAHI_WARN_LINKAGE; 614 615 assert(self); 616 ASSERT_SUCCESS(pthread_mutex_lock(&((sw_discovery) self)->salt_mutex)); 617 618 return SW_OKAY; 619 } 620 621 sw_result sw_salt_unlock(sw_salt self) { 622 assert(self); 623 624 AVAHI_WARN_LINKAGE; 625 626 ASSERT_SUCCESS(pthread_mutex_unlock(&((sw_discovery) self)->salt_mutex)); 627 628 return SW_OKAY; 629 } 630 631 static void reg_report_status(oid_data *data, sw_discovery_publish_status status) { 632 sw_discovery_publish_reply reply; 633 634 assert(data); 635 636 reply = (sw_discovery_publish_reply) data->reply; 637 638 reply(data->discovery, 639 OID_GET_INDEX(data), 640 status, 641 data->extra); 642 } 643 644 static int reg_create_service(oid_data *data) { 645 int ret; 646 const char *real_type; 647 648 assert(data); 649 650 real_type = avahi_get_type_from_subtype(data->service_data->regtype); 651 652 if ((ret = avahi_entry_group_add_service_strlst( 653 data->object, 654 data->service_data->interface, 655 AVAHI_PROTO_INET, 656 0, 657 data->service_data->name, 658 real_type ? real_type : data->service_data->regtype, 659 data->service_data->domain, 660 data->service_data->host, 661 data->service_data->port, 662 data->service_data->txt)) < 0) 663 return ret; 664 665 if (real_type) { 666 /* Create a subtype entry */ 667 668 if (avahi_entry_group_add_service_subtype( 669 data->object, 670 data->service_data->interface, 671 AVAHI_PROTO_INET, 672 0, 673 data->service_data->name, 674 real_type, 675 data->service_data->domain, 676 data->service_data->regtype) < 0) 677 return ret; 678 679 } 680 681 if ((ret = avahi_entry_group_commit(data->object)) < 0) 682 return ret; 683 684 return 0; 685 } 686 687 static void reg_client_callback(oid_data *data, AvahiClientState state) { 688 assert(data); 689 690 /* We've not been setup completely */ 691 if (!data->object) 692 return; 693 694 switch (state) { 695 case AVAHI_CLIENT_FAILURE: 696 reg_report_status(data, SW_DISCOVERY_PUBLISH_INVALID); 697 break; 698 699 case AVAHI_CLIENT_S_RUNNING: { 700 int ret; 701 702 /* Register the service */ 703 if ((ret = reg_create_service(data)) < 0) { 704 reg_report_status(data, SW_DISCOVERY_PUBLISH_INVALID); 705 return; 706 } 707 708 break; 709 } 710 711 case AVAHI_CLIENT_S_COLLISION: 712 case AVAHI_CLIENT_S_REGISTERING: 713 714 /* Remove our entry */ 715 avahi_entry_group_reset(data->object); 716 break; 717 718 case AVAHI_CLIENT_CONNECTING: 719 /* Ignore */ 720 break; 721 } 722 723 } 724 725 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) { 726 oid_data *data = userdata; 727 728 assert(g); 729 assert(data); 730 731 switch (state) { 732 case AVAHI_ENTRY_GROUP_ESTABLISHED: 733 734 reg_report_status(data, SW_DISCOVERY_PUBLISH_STARTED); 735 break; 736 737 case AVAHI_ENTRY_GROUP_COLLISION: 738 739 reg_report_status(data, SW_DISCOVERY_PUBLISH_NAME_COLLISION); 740 break; 741 742 case AVAHI_ENTRY_GROUP_REGISTERING: 743 case AVAHI_ENTRY_GROUP_UNCOMMITED: 744 /* Ignore */ 745 break; 746 747 case AVAHI_ENTRY_GROUP_FAILURE: 748 reg_report_status(data, SW_DISCOVERY_PUBLISH_INVALID); 749 break; 750 751 } 752 } 753 754 sw_result sw_discovery_publish( 755 sw_discovery self, 756 sw_uint32 interface_index, 757 sw_const_string name, 758 sw_const_string type, 759 sw_const_string domain, 760 sw_const_string host, 761 sw_port port, 762 sw_octets text_record, 763 sw_uint32 text_record_len, 764 sw_discovery_publish_reply reply, 765 sw_opaque extra, 766 sw_discovery_oid * oid) { 767 768 oid_data *data; 769 sw_result result = SW_E_UNKNOWN; 770 service_data *sdata; 771 AvahiStringList *txt = NULL; 772 773 assert(self); 774 assert(name); 775 assert(type); 776 assert(reply); 777 assert(oid); 778 779 AVAHI_WARN_LINKAGE; 780 781 if (text_record && text_record_len > 0) 782 if (avahi_string_list_parse(text_record, text_record_len, &txt) < 0) 783 return SW_E_UNKNOWN; 784 785 if ((*oid = oid_alloc(self, OID_ENTRY_GROUP)) == (sw_discovery_oid) -1) { 786 avahi_string_list_free(txt); 787 return SW_E_UNKNOWN; 788 } 789 790 if (!(sdata = service_data_new(self))) { 791 avahi_string_list_free(txt); 792 oid_release(self, *oid); 793 return SW_E_MEM; 794 } 795 796 data = oid_get(self, *oid); 797 assert(data); 798 data->reply = (sw_result (*)(void)) reply; 799 data->extra = extra; 800 data->service_data = sdata; 801 802 sdata->interface = interface_index == 0 ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface_index; 803 sdata->name = avahi_strdup(name); 804 sdata->regtype = type ? avahi_normalize_name_strdup(type) : NULL; 805 sdata->domain = domain ? avahi_normalize_name_strdup(domain) : NULL; 806 sdata->host = host ? avahi_normalize_name_strdup(host) : NULL; 807 sdata->port = port; 808 sdata->txt = txt; 809 810 /* Some OOM checking would be cool here */ 811 812 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 813 814 if (!(data->object = avahi_entry_group_new(self->client, reg_entry_group_callback, data))) { 815 result = map_error(avahi_client_errno(self->client)); 816 goto finish; 817 } 818 819 if (avahi_client_get_state(self->client) == AVAHI_CLIENT_S_RUNNING) { 820 int error; 821 822 if ((error = reg_create_service(data)) < 0) { 823 result = map_error(error); 824 goto finish; 825 } 826 } 827 828 result = SW_OKAY; 829 830 finish: 831 832 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 833 834 if (result != SW_OKAY) 835 if (*oid != (sw_discovery_oid) -1) 836 sw_discovery_cancel(self, *oid); 837 838 return result; 839 } 840 841 static void domain_browser_callback( 842 AvahiDomainBrowser *b, 843 AvahiIfIndex interface, 844 AVAHI_GCC_UNUSED AvahiProtocol protocol, 845 AvahiBrowserEvent event, 846 const char *domain, 847 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags, 848 void *userdata) { 849 850 oid_data* data = userdata; 851 sw_discovery_browse_reply reply; 852 static char domain_fixed[AVAHI_DOMAIN_NAME_MAX]; 853 854 assert(b); 855 assert(data); 856 857 reply = (sw_discovery_browse_reply) data->reply; 858 859 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed)); 860 861 switch (event) { 862 case AVAHI_BROWSER_NEW: 863 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_ADD_DOMAIN, interface, NULL, NULL, domain, data->extra); 864 break; 865 866 case AVAHI_BROWSER_REMOVE: 867 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_REMOVE_DOMAIN, interface, NULL, NULL, domain, data->extra); 868 break; 869 870 case AVAHI_BROWSER_FAILURE: 871 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_INVALID, interface, NULL, NULL, domain, data->extra); 872 break; 873 874 case AVAHI_BROWSER_CACHE_EXHAUSTED: 875 case AVAHI_BROWSER_ALL_FOR_NOW: 876 break; 877 } 878 } 879 880 sw_result sw_discovery_browse_domains( 881 sw_discovery self, 882 sw_uint32 interface_index, 883 sw_discovery_browse_reply reply, 884 sw_opaque extra, 885 sw_discovery_oid * oid) { 886 887 oid_data *data; 888 AvahiIfIndex ifindex; 889 sw_result result = SW_E_UNKNOWN; 890 891 assert(self); 892 assert(reply); 893 assert(oid); 894 895 AVAHI_WARN_LINKAGE; 896 897 if ((*oid = oid_alloc(self, OID_DOMAIN_BROWSER)) == (sw_discovery_oid) -1) 898 return SW_E_UNKNOWN; 899 900 data = oid_get(self, *oid); 901 assert(data); 902 data->reply = (sw_result (*)(void)) reply; 903 data->extra = extra; 904 905 ifindex = interface_index == 0 ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface_index; 906 907 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 908 909 if (!(data->object = avahi_domain_browser_new(self->client, ifindex, AVAHI_PROTO_INET, NULL, AVAHI_DOMAIN_BROWSER_BROWSE, 0, domain_browser_callback, data))) { 910 result = map_error(avahi_client_errno(self->client)); 911 goto finish; 912 } 913 914 result = SW_OKAY; 915 916 finish: 917 918 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 919 920 if (result != SW_OKAY) 921 if (*oid != (sw_discovery_oid) -1) 922 sw_discovery_cancel(self, *oid); 923 924 return result; 925 } 926 927 static void service_resolver_callback( 928 AvahiServiceResolver *r, 929 AvahiIfIndex interface, 930 AVAHI_GCC_UNUSED AvahiProtocol protocol, 931 AvahiResolverEvent event, 932 const char *name, 933 const char *type, 934 const char *domain, 935 const char *host_name, 936 const AvahiAddress *a, 937 uint16_t port, 938 AvahiStringList *txt, 939 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags, 940 void *userdata) { 941 942 oid_data* data = userdata; 943 sw_discovery_resolve_reply reply; 944 945 assert(r); 946 assert(data); 947 948 reply = (sw_discovery_resolve_reply) data->reply; 949 950 switch (event) { 951 case AVAHI_RESOLVER_FOUND: { 952 953 char host_name_fixed[AVAHI_DOMAIN_NAME_MAX]; 954 uint8_t *p = NULL; 955 size_t l = 0; 956 sw_ipv4_address addr; 957 958 sw_ipv4_address_init_from_saddr(&addr, a->data.ipv4.address); 959 960 host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed)); 961 962 if ((p = avahi_new0(uint8_t, (l = avahi_string_list_serialize(txt, NULL, 0))+1))) 963 avahi_string_list_serialize(txt, p, l); 964 965 reply(data->discovery, OID_GET_INDEX(data), interface, name, type, domain, addr, port, p, l, data->extra); 966 967 avahi_free(p); 968 break; 969 } 970 971 case AVAHI_RESOLVER_FAILURE: 972 973 /* Apparently there is no way in HOWL to inform about failed resolvings ... */ 974 975 avahi_warn("A service failed to resolve in the HOWL compatiblity layer of Avahi which is used by '%s'. " 976 "Since the HOWL API doesn't offer any means to inform the application about this, we have to ignore the failure. " 977 "Please fix your application to use the native API of Avahi!", 978 avahi_exe_name()); 979 980 break; 981 } 982 } 983 984 sw_result sw_discovery_resolve( 985 sw_discovery self, 986 sw_uint32 interface_index, 987 sw_const_string name, 988 sw_const_string type, 989 sw_const_string domain, 990 sw_discovery_resolve_reply reply, 991 sw_opaque extra, 992 sw_discovery_oid * oid) { 993 994 oid_data *data; 995 AvahiIfIndex ifindex; 996 sw_result result = SW_E_UNKNOWN; 997 998 assert(self); 999 assert(name); 1000 assert(type); 1001 assert(reply); 1002 assert(oid); 1003 1004 AVAHI_WARN_LINKAGE; 1005 1006 if ((*oid = oid_alloc(self, OID_SERVICE_RESOLVER)) == (sw_discovery_oid) -1) 1007 return SW_E_UNKNOWN; 1008 1009 data = oid_get(self, *oid); 1010 assert(data); 1011 data->reply = (sw_result (*)(void)) reply; 1012 data->extra = extra; 1013 1014 ifindex = interface_index == 0 ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface_index; 1015 1016 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 1017 1018 if (!(data->object = avahi_service_resolver_new(self->client, ifindex, AVAHI_PROTO_INET, name, type, domain, AVAHI_PROTO_INET, 0, service_resolver_callback, data))) { 1019 result = map_error(avahi_client_errno(self->client)); 1020 goto finish; 1021 } 1022 1023 result = SW_OKAY; 1024 1025 finish: 1026 1027 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 1028 1029 if (result != SW_OKAY) 1030 if (*oid != (sw_discovery_oid) -1) 1031 sw_discovery_cancel(self, *oid); 1032 1033 return result; 1034 } 1035 1036 static void service_browser_callback( 1037 AvahiServiceBrowser *b, 1038 AvahiIfIndex interface, 1039 AVAHI_GCC_UNUSED AvahiProtocol protocol, 1040 AvahiBrowserEvent event, 1041 const char *name, 1042 const char *type, 1043 const char *domain, 1044 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags, 1045 void *userdata) { 1046 1047 oid_data* data = userdata; 1048 char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX]; 1049 sw_discovery_browse_reply reply; 1050 1051 assert(b); 1052 assert(data); 1053 1054 reply = (sw_discovery_browse_reply) data->reply; 1055 1056 type = add_trailing_dot(type, type_fixed, sizeof(type_fixed)); 1057 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed)); 1058 1059 switch (event) { 1060 case AVAHI_BROWSER_NEW: 1061 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_ADD_SERVICE, interface, name, type, domain, data->extra); 1062 break; 1063 1064 case AVAHI_BROWSER_REMOVE: 1065 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_REMOVE_SERVICE, interface, name, type, domain, data->extra); 1066 break; 1067 1068 case AVAHI_BROWSER_FAILURE: 1069 reply(data->discovery, OID_GET_INDEX(data), SW_DISCOVERY_BROWSE_INVALID, interface, name, type, domain, data->extra); 1070 break; 1071 1072 case AVAHI_BROWSER_CACHE_EXHAUSTED: 1073 case AVAHI_BROWSER_ALL_FOR_NOW: 1074 break; 1075 } 1076 } 1077 1078 sw_result sw_discovery_browse( 1079 sw_discovery self, 1080 sw_uint32 interface_index, 1081 sw_const_string type, 1082 sw_const_string domain, 1083 sw_discovery_browse_reply reply, 1084 sw_opaque extra, 1085 sw_discovery_oid * oid) { 1086 1087 oid_data *data; 1088 AvahiIfIndex ifindex; 1089 sw_result result = SW_E_UNKNOWN; 1090 1091 assert(self); 1092 assert(type); 1093 assert(reply); 1094 assert(oid); 1095 1096 AVAHI_WARN_LINKAGE; 1097 1098 if ((*oid = oid_alloc(self, OID_SERVICE_BROWSER)) == (sw_discovery_oid) -1) 1099 return SW_E_UNKNOWN; 1100 1101 data = oid_get(self, *oid); 1102 assert(data); 1103 data->reply = (sw_result (*)(void)) reply; 1104 data->extra = extra; 1105 1106 ifindex = interface_index == 0 ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface_index; 1107 1108 ASSERT_SUCCESS(pthread_mutex_lock(&self->mutex)); 1109 1110 if (!(data->object = avahi_service_browser_new(self->client, ifindex, AVAHI_PROTO_INET, type, domain, 0, service_browser_callback, data))) { 1111 result = map_error(avahi_client_errno(self->client)); 1112 goto finish; 1113 } 1114 1115 result = SW_OKAY; 1116 1117 finish: 1118 1119 ASSERT_SUCCESS(pthread_mutex_unlock(&self->mutex)); 1120 1121 if (result != SW_OKAY) 1122 if (*oid != (sw_discovery_oid) -1) 1123 sw_discovery_cancel(self, *oid); 1124 1125 return result; 1126 } 1127 1128 sw_result sw_discovery_cancel(sw_discovery self, sw_discovery_oid oid) { 1129 oid_data *data; 1130 assert(self); 1131 1132 AVAHI_WARN_LINKAGE; 1133 1134 if (!(data = oid_get(self, oid))) 1135 return SW_E_UNKNOWN; 1136 1137 if (data->object) { 1138 switch (data->type) { 1139 case OID_SERVICE_BROWSER: 1140 avahi_service_browser_free(data->object); 1141 break; 1142 1143 case OID_SERVICE_RESOLVER: 1144 avahi_service_resolver_free(data->object); 1145 break; 1146 1147 case OID_DOMAIN_BROWSER: 1148 avahi_domain_browser_free(data->object); 1149 break; 1150 1151 case OID_ENTRY_GROUP: 1152 avahi_entry_group_free(data->object); 1153 break; 1154 1155 case OID_UNUSED: 1156 ; 1157 } 1158 } 1159 1160 if (data->service_data) { 1161 assert(data->type == OID_ENTRY_GROUP); 1162 service_data_free(self, data->service_data); 1163 } 1164 1165 oid_release(self, oid); 1166 1167 return SW_OKAY; 1168 } 1169 1170 sw_result sw_discovery_init_with_flags( 1171 sw_discovery * self, 1172 sw_discovery_init_flags flags) { 1173 1174 assert(self); 1175 1176 AVAHI_WARN_LINKAGE; 1177 1178 if (flags != SW_DISCOVERY_USE_SHARED_SERVICE) 1179 return SW_E_NO_IMPL; 1180 1181 return sw_discovery_init(self); 1182 } 1183
