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 <stdlib.h> 25 #include <stdio.h> 26 #include <string.h> 27 28 #include <dbus/dbus.h> 29 30 #include <avahi-client/client.h> 31 #include <avahi-common/dbus.h> 32 #include <avahi-common/llist.h> 33 #include <avahi-common/error.h> 34 #include "avahi-common/avahi-malloc.h" 35 #include <avahi-common/domain.h> 36 37 #include "client.h" 38 #include "internal.h" 39 #include "xdg-config.h" 40 41 static void parse_environment(AvahiDomainBrowser *b) { 42 char buf[AVAHI_DOMAIN_NAME_MAX*3], *e, *t, *p; 43 44 assert(b); 45 46 if (!(e = getenv("AVAHI_BROWSE_DOMAINS"))) 47 return; 48 49 snprintf(buf, sizeof(buf), "%s", e); 50 51 for (t = strtok_r(buf, ":", &p); t; t = strtok_r(NULL, ":", &p)) { 52 char domain[AVAHI_DOMAIN_NAME_MAX]; 53 if (avahi_normalize_name(t, domain, sizeof(domain))) 54 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain); 55 } 56 } 57 58 static void parse_domain_file(AvahiDomainBrowser *b) { 59 FILE *f; 60 char buf[AVAHI_DOMAIN_NAME_MAX]; 61 62 assert(b); 63 64 if (!(f = avahi_xdg_config_open("avahi/browse-domains"))) 65 return; 66 67 68 while (fgets(buf, sizeof(buf)-1, f)) { 69 char domain[AVAHI_DOMAIN_NAME_MAX]; 70 buf[strcspn(buf, "\n\r")] = 0; 71 72 if (avahi_normalize_name(buf, domain, sizeof(domain))) 73 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain); 74 } 75 } 76 77 static void domain_browser_ref(AvahiDomainBrowser *db) { 78 assert(db); 79 assert(db->ref >= 1); 80 db->ref++; 81 } 82 83 static void defer_timeout_callback(AvahiTimeout *t, void *userdata) { 84 AvahiDomainBrowser *db = userdata; 85 AvahiStringList *l; 86 assert(t); 87 88 db->client->poll_api->timeout_free(db->defer_timeout); 89 db->defer_timeout = NULL; 90 91 domain_browser_ref(db); 92 93 for (l = db->static_browse_domains; l; l = l->next) { 94 95 if (db->ref <= 1) 96 break; 97 98 db->callback(db, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_BROWSER_NEW, (char*) l->text, AVAHI_LOOKUP_RESULT_STATIC, db->userdata); 99 } 100 101 avahi_domain_browser_free(db); 102 } 103 104 AvahiDomainBrowser* avahi_domain_browser_new( 105 AvahiClient *client, 106 AvahiIfIndex interface, 107 AvahiProtocol protocol, 108 const char *domain, 109 AvahiDomainBrowserType btype, 110 AvahiLookupFlags flags, 111 AvahiDomainBrowserCallback callback, 112 void *userdata) { 113 114 AvahiDomainBrowser *db = NULL; 115 DBusMessage *message = NULL, *reply = NULL; 116 DBusError error; 117 char *path; 118 int32_t i_interface, i_protocol, bt; 119 uint32_t u_flags; 120 121 assert(client); 122 assert(callback); 123 124 dbus_error_init (&error); 125 126 if (!avahi_client_is_connected(client)) { 127 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); 128 goto fail; 129 } 130 131 if (!domain) 132 domain = ""; 133 134 if (!(db = avahi_new (AvahiDomainBrowser, 1))) { 135 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 136 goto fail; 137 } 138 139 db->ref = 1; 140 db->client = client; 141 db->callback = callback; 142 db->userdata = userdata; 143 db->path = NULL; 144 db->interface = interface; 145 db->protocol = protocol; 146 db->static_browse_domains = NULL; 147 db->defer_timeout = NULL; 148 149 AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, db); 150 151 if (!(client->flags & AVAHI_CLIENT_IGNORE_USER_CONFIG)) { 152 parse_environment(db); 153 parse_domain_file(db); 154 } 155 156 db->static_browse_domains = avahi_string_list_reverse(db->static_browse_domains); 157 158 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew"))) { 159 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 160 goto fail; 161 } 162 163 i_interface = (int32_t) interface; 164 i_protocol = (int32_t) protocol; 165 u_flags = (uint32_t) flags; 166 bt = btype; 167 168 if (!(dbus_message_append_args( 169 message, 170 DBUS_TYPE_INT32, &i_interface, 171 DBUS_TYPE_INT32, &i_protocol, 172 DBUS_TYPE_STRING, &domain, 173 DBUS_TYPE_INT32, &bt, 174 DBUS_TYPE_UINT32, &u_flags, 175 DBUS_TYPE_INVALID))) { 176 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 177 goto fail; 178 } 179 180 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || 181 dbus_error_is_set(&error)) { 182 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 183 goto fail; 184 } 185 186 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || 187 dbus_error_is_set(&error) || 188 !path) { 189 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 190 goto fail; 191 } 192 193 if (!(db->path = avahi_strdup(path))) { 194 195 /* FIXME: We don't remove the object on the server side */ 196 197 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 198 goto fail; 199 } 200 201 if (db->static_browse_domains && btype == AVAHI_DOMAIN_BROWSER_BROWSE) { 202 struct timeval tv = { 0, 0 }; 203 204 if (!(db->defer_timeout = client->poll_api->timeout_new(client->poll_api, &tv, defer_timeout_callback, db))) { 205 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 206 goto fail; 207 } 208 } 209 210 dbus_message_unref(message); 211 dbus_message_unref(reply); 212 213 return db; 214 215 fail: 216 217 if (dbus_error_is_set(&error)) { 218 avahi_client_set_dbus_error(client, &error); 219 dbus_error_free(&error); 220 } 221 222 if (db) 223 avahi_domain_browser_free(db); 224 225 if (message) 226 dbus_message_unref(message); 227 228 if (reply) 229 dbus_message_unref(reply); 230 231 return NULL; 232 } 233 234 AvahiClient* avahi_domain_browser_get_client (AvahiDomainBrowser *b) { 235 assert(b); 236 return b->client; 237 } 238 239 int avahi_domain_browser_free (AvahiDomainBrowser *b) { 240 AvahiClient *client; 241 int r = AVAHI_OK; 242 243 assert(b); 244 assert(b->ref >= 1); 245 246 if (--(b->ref) >= 1) 247 return AVAHI_OK; 248 249 client = b->client; 250 251 if (b->path && avahi_client_is_connected(b->client)) 252 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free"); 253 254 AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b); 255 256 if (b->defer_timeout) 257 b->client->poll_api->timeout_free(b->defer_timeout); 258 259 avahi_string_list_free(b->static_browse_domains); 260 avahi_free(b->path); 261 avahi_free(b); 262 263 return r; 264 } 265 266 DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { 267 AvahiDomainBrowser *db = NULL; 268 DBusError error; 269 const char *path; 270 char *domain = NULL; 271 int32_t interface, protocol; 272 uint32_t flags = 0; 273 AvahiStringList *l; 274 275 assert(client); 276 assert(message); 277 278 dbus_error_init (&error); 279 280 if (!(path = dbus_message_get_path(message))) 281 goto fail; 282 283 for (db = client->domain_browsers; db; db = db->domain_browsers_next) 284 if (strcmp (db->path, path) == 0) 285 break; 286 287 if (!db) 288 goto fail; 289 290 interface = db->interface; 291 protocol = db->protocol; 292 293 switch (event) { 294 case AVAHI_BROWSER_NEW: 295 case AVAHI_BROWSER_REMOVE: 296 297 if (!dbus_message_get_args( 298 message, &error, 299 DBUS_TYPE_INT32, &interface, 300 DBUS_TYPE_INT32, &protocol, 301 DBUS_TYPE_STRING, &domain, 302 DBUS_TYPE_UINT32, &flags, 303 DBUS_TYPE_INVALID) || 304 dbus_error_is_set (&error)) { 305 fprintf(stderr, "Failed to parse browser event.\n"); 306 goto fail; 307 } 308 309 break; 310 311 case AVAHI_BROWSER_CACHE_EXHAUSTED: 312 case AVAHI_BROWSER_ALL_FOR_NOW: 313 break; 314 315 case AVAHI_BROWSER_FAILURE: { 316 char *etxt; 317 318 if (!dbus_message_get_args( 319 message, &error, 320 DBUS_TYPE_STRING, &etxt, 321 DBUS_TYPE_INVALID) || 322 dbus_error_is_set (&error)) { 323 fprintf(stderr, "Failed to parse browser event.\n"); 324 goto fail; 325 } 326 327 avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt)); 328 break; 329 } 330 } 331 332 if (domain) 333 for (l = db->static_browse_domains; l; l = l->next) 334 if (avahi_domain_equal((char*) l->text, domain)) { 335 /* We had this entry already in the static entries */ 336 return DBUS_HANDLER_RESULT_HANDLED; 337 } 338 339 db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata); 340 341 return DBUS_HANDLER_RESULT_HANDLED; 342 343 fail: 344 dbus_error_free (&error); 345 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 346 } 347 348 /* AvahiServiceTypeBrowser */ 349 350 AvahiServiceTypeBrowser* avahi_service_type_browser_new( 351 AvahiClient *client, 352 AvahiIfIndex interface, 353 AvahiProtocol protocol, 354 const char *domain, 355 AvahiLookupFlags flags, 356 AvahiServiceTypeBrowserCallback callback, 357 void *userdata) { 358 359 AvahiServiceTypeBrowser *b = NULL; 360 DBusMessage *message = NULL, *reply = NULL; 361 DBusError error; 362 char *path; 363 int32_t i_interface, i_protocol; 364 uint32_t u_flags; 365 366 assert(client); 367 assert(callback); 368 369 dbus_error_init(&error); 370 371 if (!avahi_client_is_connected(client)) { 372 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); 373 goto fail; 374 } 375 376 if (!domain) 377 domain = ""; 378 379 if (!(b = avahi_new(AvahiServiceTypeBrowser, 1))) { 380 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 381 goto fail; 382 } 383 384 b->client = client; 385 b->callback = callback; 386 b->userdata = userdata; 387 b->path = NULL; 388 b->domain = NULL; 389 b->interface = interface; 390 b->protocol = protocol; 391 392 AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, b); 393 394 if (domain[0]) 395 if (!(b->domain = avahi_strdup(domain))) { 396 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 397 goto fail; 398 } 399 400 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew"))) { 401 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 402 goto fail; 403 } 404 405 i_interface = (int32_t) interface; 406 i_protocol = (int32_t) protocol; 407 u_flags = (uint32_t) flags; 408 409 if (!dbus_message_append_args( 410 message, 411 DBUS_TYPE_INT32, &i_interface, 412 DBUS_TYPE_INT32, &i_protocol, 413 DBUS_TYPE_STRING, &domain, 414 DBUS_TYPE_UINT32, &u_flags, 415 DBUS_TYPE_INVALID)) { 416 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 417 goto fail; 418 } 419 420 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || 421 dbus_error_is_set(&error)) { 422 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 423 goto fail; 424 } 425 426 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || 427 dbus_error_is_set(&error) || 428 !path) { 429 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 430 goto fail; 431 } 432 433 if (!(b->path = avahi_strdup(path))) { 434 435 /* FIXME: We don't remove the object on the server side */ 436 437 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 438 goto fail; 439 } 440 441 dbus_message_unref(message); 442 dbus_message_unref(reply); 443 444 return b; 445 446 fail: 447 448 if (dbus_error_is_set(&error)) { 449 avahi_client_set_dbus_error(client, &error); 450 dbus_error_free(&error); 451 } 452 453 if (b) 454 avahi_service_type_browser_free(b); 455 456 if (message) 457 dbus_message_unref(message); 458 459 if (reply) 460 dbus_message_unref(reply); 461 462 return NULL; 463 } 464 465 AvahiClient* avahi_service_type_browser_get_client (AvahiServiceTypeBrowser *b) { 466 assert(b); 467 return b->client; 468 } 469 470 int avahi_service_type_browser_free (AvahiServiceTypeBrowser *b) { 471 AvahiClient *client; 472 int r = AVAHI_OK; 473 474 assert(b); 475 client = b->client; 476 477 if (b->path && avahi_client_is_connected(b->client)) 478 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free"); 479 480 AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b); 481 482 avahi_free(b->path); 483 avahi_free(b->domain); 484 avahi_free(b); 485 return r; 486 } 487 488 DBusHandlerResult avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { 489 AvahiServiceTypeBrowser *b = NULL; 490 DBusError error; 491 const char *path; 492 char *domain, *type = NULL; 493 int32_t interface, protocol; 494 uint32_t flags = 0; 495 496 assert(client); 497 assert(message); 498 499 dbus_error_init (&error); 500 501 if (!(path = dbus_message_get_path(message))) 502 goto fail; 503 504 for (b = client->service_type_browsers; b; b = b->service_type_browsers_next) 505 if (strcmp (b->path, path) == 0) 506 break; 507 508 if (!b) 509 goto fail; 510 511 domain = b->domain; 512 interface = b->interface; 513 protocol = b->protocol; 514 515 switch (event) { 516 case AVAHI_BROWSER_NEW: 517 case AVAHI_BROWSER_REMOVE: 518 if (!dbus_message_get_args( 519 message, &error, 520 DBUS_TYPE_INT32, &interface, 521 DBUS_TYPE_INT32, &protocol, 522 DBUS_TYPE_STRING, &type, 523 DBUS_TYPE_STRING, &domain, 524 DBUS_TYPE_UINT32, &flags, 525 DBUS_TYPE_INVALID) || 526 dbus_error_is_set(&error)) { 527 fprintf(stderr, "Failed to parse browser event.\n"); 528 goto fail; 529 } 530 break; 531 532 case AVAHI_BROWSER_CACHE_EXHAUSTED: 533 case AVAHI_BROWSER_ALL_FOR_NOW: 534 break; 535 536 case AVAHI_BROWSER_FAILURE: { 537 char *etxt; 538 539 if (!dbus_message_get_args( 540 message, &error, 541 DBUS_TYPE_STRING, &etxt, 542 DBUS_TYPE_INVALID) || 543 dbus_error_is_set (&error)) { 544 fprintf(stderr, "Failed to parse browser event.\n"); 545 goto fail; 546 } 547 548 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); 549 break; 550 } 551 } 552 553 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, type, domain, (AvahiLookupResultFlags) flags, b->userdata); 554 555 return DBUS_HANDLER_RESULT_HANDLED; 556 557 fail: 558 dbus_error_free (&error); 559 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 560 } 561 562 /* AvahiServiceBrowser */ 563 564 AvahiServiceBrowser* avahi_service_browser_new( 565 AvahiClient *client, 566 AvahiIfIndex interface, 567 AvahiProtocol protocol, 568 const char *type, 569 const char *domain, 570 AvahiLookupFlags flags, 571 AvahiServiceBrowserCallback callback, 572 void *userdata) { 573 574 AvahiServiceBrowser *b = NULL; 575 DBusMessage *message = NULL, *reply = NULL; 576 DBusError error; 577 char *path; 578 int32_t i_protocol, i_interface; 579 uint32_t u_flags; 580 581 assert(client); 582 assert(type); 583 assert(callback); 584 585 dbus_error_init(&error); 586 587 if (!avahi_client_is_connected(client)) { 588 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); 589 goto fail; 590 } 591 592 if (!domain) 593 domain = ""; 594 595 if (!(b = avahi_new(AvahiServiceBrowser, 1))) { 596 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 597 goto fail; 598 } 599 600 b->client = client; 601 b->callback = callback; 602 b->userdata = userdata; 603 b->path = NULL; 604 b->type = b->domain = NULL; 605 b->interface = interface; 606 b->protocol = protocol; 607 608 AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, b); 609 610 if (!(b->type = avahi_strdup(type))) { 611 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 612 goto fail; 613 } 614 615 if (domain && domain[0]) 616 if (!(b->domain = avahi_strdup(domain))) { 617 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 618 goto fail; 619 } 620 621 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew"))) { 622 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 623 goto fail; 624 } 625 626 i_interface = (int32_t) interface; 627 i_protocol = (int32_t) protocol; 628 u_flags = (uint32_t) flags; 629 630 if (!dbus_message_append_args( 631 message, 632 DBUS_TYPE_INT32, &i_interface, 633 DBUS_TYPE_INT32, &i_protocol, 634 DBUS_TYPE_STRING, &type, 635 DBUS_TYPE_STRING, &domain, 636 DBUS_TYPE_UINT32, &u_flags, 637 DBUS_TYPE_INVALID)) { 638 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 639 goto fail; 640 } 641 642 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || 643 dbus_error_is_set(&error)) { 644 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 645 goto fail; 646 } 647 648 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || 649 dbus_error_is_set(&error) || 650 !path) { 651 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 652 goto fail; 653 } 654 655 if (!(b->path = avahi_strdup(path))) { 656 657 /* FIXME: We don't remove the object on the server side */ 658 659 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 660 goto fail; 661 } 662 663 dbus_message_unref(message); 664 dbus_message_unref(reply); 665 666 return b; 667 668 fail: 669 if (dbus_error_is_set(&error)) { 670 avahi_client_set_dbus_error(client, &error); 671 dbus_error_free(&error); 672 } 673 674 if (b) 675 avahi_service_browser_free(b); 676 677 if (message) 678 dbus_message_unref(message); 679 680 if (reply) 681 dbus_message_unref(reply); 682 683 return NULL; 684 } 685 686 AvahiClient* avahi_service_browser_get_client (AvahiServiceBrowser *b) { 687 assert(b); 688 return b->client; 689 } 690 691 int avahi_service_browser_free (AvahiServiceBrowser *b) { 692 AvahiClient *client; 693 int r = AVAHI_OK; 694 695 assert(b); 696 client = b->client; 697 698 if (b->path && avahi_client_is_connected(b->client)) 699 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free"); 700 701 AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b); 702 703 avahi_free(b->path); 704 avahi_free(b->type); 705 avahi_free(b->domain); 706 avahi_free(b); 707 return r; 708 } 709 710 DBusHandlerResult avahi_service_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { 711 AvahiServiceBrowser *b = NULL; 712 DBusError error; 713 const char *path; 714 char *name = NULL, *type, *domain; 715 int32_t interface, protocol; 716 uint32_t flags = 0; 717 718 dbus_error_init (&error); 719 720 if (!(path = dbus_message_get_path(message))) 721 goto fail; 722 723 for (b = client->service_browsers; b; b = b->service_browsers_next) 724 if (strcmp (b->path, path) == 0) 725 break; 726 727 if (!b) 728 goto fail; 729 730 type = b->type; 731 domain = b->domain; 732 interface = b->interface; 733 protocol = b->protocol; 734 735 switch (event) { 736 case AVAHI_BROWSER_NEW: 737 case AVAHI_BROWSER_REMOVE: 738 739 if (!dbus_message_get_args ( 740 message, &error, 741 DBUS_TYPE_INT32, &interface, 742 DBUS_TYPE_INT32, &protocol, 743 DBUS_TYPE_STRING, &name, 744 DBUS_TYPE_STRING, &type, 745 DBUS_TYPE_STRING, &domain, 746 DBUS_TYPE_UINT32, &flags, 747 DBUS_TYPE_INVALID) || 748 dbus_error_is_set(&error)) { 749 fprintf(stderr, "Failed to parse browser event.\n"); 750 goto fail; 751 } 752 break; 753 754 case AVAHI_BROWSER_CACHE_EXHAUSTED: 755 case AVAHI_BROWSER_ALL_FOR_NOW: 756 break; 757 758 case AVAHI_BROWSER_FAILURE: { 759 char *etxt; 760 761 if (!dbus_message_get_args( 762 message, &error, 763 DBUS_TYPE_STRING, &etxt, 764 DBUS_TYPE_INVALID) || 765 dbus_error_is_set (&error)) { 766 fprintf(stderr, "Failed to parse browser event.\n"); 767 goto fail; 768 } 769 770 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); 771 break; 772 } 773 } 774 775 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, type, domain, (AvahiLookupResultFlags) flags, b->userdata); 776 777 return DBUS_HANDLER_RESULT_HANDLED; 778 779 fail: 780 dbus_error_free (&error); 781 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 782 } 783 784 /* AvahiRecordBrowser */ 785 786 AvahiRecordBrowser* avahi_record_browser_new( 787 AvahiClient *client, 788 AvahiIfIndex interface, 789 AvahiProtocol protocol, 790 const char *name, 791 uint16_t clazz, 792 uint16_t type, 793 AvahiLookupFlags flags, 794 AvahiRecordBrowserCallback callback, 795 void *userdata) { 796 797 AvahiRecordBrowser *b = NULL; 798 DBusMessage *message = NULL, *reply = NULL; 799 DBusError error; 800 char *path; 801 int32_t i_protocol, i_interface; 802 uint32_t u_flags; 803 804 assert(client); 805 assert(name); 806 assert(callback); 807 808 dbus_error_init(&error); 809 810 if (!avahi_client_is_connected(client)) { 811 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); 812 goto fail; 813 } 814 815 if (!(b = avahi_new(AvahiRecordBrowser, 1))) { 816 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 817 goto fail; 818 } 819 820 b->client = client; 821 b->callback = callback; 822 b->userdata = userdata; 823 b->path = NULL; 824 b->name = NULL; 825 b->clazz = clazz; 826 b->type = type; 827 b->interface = interface; 828 b->protocol = protocol; 829 830 AVAHI_LLIST_PREPEND(AvahiRecordBrowser, record_browsers, client->record_browsers, b); 831 832 if (!(b->name = avahi_strdup(name))) { 833 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 834 goto fail; 835 } 836 837 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "RecordBrowserNew"))) { 838 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 839 goto fail; 840 } 841 842 i_interface = (int32_t) interface; 843 i_protocol = (int32_t) protocol; 844 u_flags = (uint32_t) flags; 845 846 if (!dbus_message_append_args( 847 message, 848 DBUS_TYPE_INT32, &i_interface, 849 DBUS_TYPE_INT32, &i_protocol, 850 DBUS_TYPE_STRING, &name, 851 DBUS_TYPE_UINT16, &clazz, 852 DBUS_TYPE_UINT16, &type, 853 DBUS_TYPE_UINT32, &u_flags, 854 DBUS_TYPE_INVALID)) { 855 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 856 goto fail; 857 } 858 859 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || 860 dbus_error_is_set(&error)) { 861 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 862 goto fail; 863 } 864 865 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || 866 dbus_error_is_set(&error) || 867 !path) { 868 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 869 goto fail; 870 } 871 872 if (!(b->path = avahi_strdup(path))) { 873 874 /* FIXME: We don't remove the object on the server side */ 875 876 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 877 goto fail; 878 } 879 880 dbus_message_unref(message); 881 dbus_message_unref(reply); 882 883 return b; 884 885 fail: 886 if (dbus_error_is_set(&error)) { 887 avahi_client_set_dbus_error(client, &error); 888 dbus_error_free(&error); 889 } 890 891 if (b) 892 avahi_record_browser_free(b); 893 894 if (message) 895 dbus_message_unref(message); 896 897 if (reply) 898 dbus_message_unref(reply); 899 900 return NULL; 901 } 902 903 AvahiClient* avahi_record_browser_get_client (AvahiRecordBrowser *b) { 904 assert(b); 905 return b->client; 906 } 907 908 int avahi_record_browser_free (AvahiRecordBrowser *b) { 909 AvahiClient *client; 910 int r = AVAHI_OK; 911 912 assert(b); 913 client = b->client; 914 915 if (b->path && avahi_client_is_connected(b->client)) 916 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Free"); 917 918 AVAHI_LLIST_REMOVE(AvahiRecordBrowser, record_browsers, b->client->record_browsers, b); 919 920 avahi_free(b->path); 921 avahi_free(b->name); 922 avahi_free(b); 923 return r; 924 } 925 926 DBusHandlerResult avahi_record_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { 927 AvahiRecordBrowser *b = NULL; 928 DBusError error; 929 const char *path; 930 char *name; 931 int32_t interface, protocol; 932 uint32_t flags = 0; 933 uint16_t clazz, type; 934 void *rdata = NULL; 935 int rdata_size = 0; 936 937 dbus_error_init (&error); 938 939 if (!(path = dbus_message_get_path(message))) 940 goto fail; 941 942 for (b = client->record_browsers; b; b = b->record_browsers_next) 943 if (strcmp (b->path, path) == 0) 944 break; 945 946 if (!b) 947 goto fail; 948 949 interface = b->interface; 950 protocol = b->protocol; 951 clazz = b->clazz; 952 type = b->type; 953 name = b->name; 954 955 switch (event) { 956 case AVAHI_BROWSER_NEW: 957 case AVAHI_BROWSER_REMOVE: { 958 DBusMessageIter iter, sub; 959 int j; 960 961 if (!dbus_message_get_args ( 962 message, &error, 963 DBUS_TYPE_INT32, &interface, 964 DBUS_TYPE_INT32, &protocol, 965 DBUS_TYPE_STRING, &name, 966 DBUS_TYPE_UINT16, &clazz, 967 DBUS_TYPE_UINT16, &type, 968 DBUS_TYPE_INVALID) || 969 dbus_error_is_set(&error)) { 970 fprintf(stderr, "Failed to parse browser event.\n"); 971 goto fail; 972 } 973 974 975 dbus_message_iter_init(message, &iter); 976 977 for (j = 0; j < 5; j++) 978 dbus_message_iter_next(&iter); 979 980 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || 981 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) 982 goto fail; 983 984 dbus_message_iter_recurse(&iter, &sub); 985 dbus_message_iter_get_fixed_array(&sub, &rdata, &rdata_size); 986 987 dbus_message_iter_next(&iter); 988 989 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) 990 goto fail; 991 992 dbus_message_iter_get_basic(&iter, &flags); 993 994 break; 995 } 996 997 case AVAHI_BROWSER_CACHE_EXHAUSTED: 998 case AVAHI_BROWSER_ALL_FOR_NOW: 999 break; 1000 1001 case AVAHI_BROWSER_FAILURE: { 1002 char *etxt; 1003 1004 if (!dbus_message_get_args( 1005 message, &error, 1006 DBUS_TYPE_STRING, &etxt, 1007 DBUS_TYPE_INVALID) || 1008 dbus_error_is_set (&error)) { 1009 fprintf(stderr, "Failed to parse browser event.\n"); 1010 goto fail; 1011 } 1012 1013 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); 1014 break; 1015 } 1016 } 1017 1018 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, clazz, type, rdata, (size_t) rdata_size, (AvahiLookupResultFlags) flags, b->userdata); 1019 1020 return DBUS_HANDLER_RESULT_HANDLED; 1021 1022 fail: 1023 dbus_error_free (&error); 1024 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; 1025 } 1026
