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 36 #include "client.h" 37 #include "internal.h" 38 39 void avahi_entry_group_set_state(AvahiEntryGroup *group, AvahiEntryGroupState state) { 40 assert(group); 41 42 if (group->state_valid && group->state == state) 43 return; 44 45 group->state = state; 46 group->state_valid = 1; 47 48 if (group->callback) 49 group->callback(group, state, group->userdata); 50 } 51 52 static int retrieve_state(AvahiEntryGroup *group) { 53 DBusMessage *message = NULL, *reply = NULL; 54 DBusError error; 55 int r = AVAHI_OK; 56 int32_t state; 57 AvahiClient *client; 58 59 dbus_error_init(&error); 60 61 assert(group); 62 client = group->client; 63 64 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState"))) { 65 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 66 goto fail; 67 } 68 69 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 70 dbus_error_is_set (&error)) { 71 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 72 goto fail; 73 } 74 75 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID) || 76 dbus_error_is_set (&error)) { 77 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 78 goto fail; 79 } 80 81 dbus_message_unref(message); 82 dbus_message_unref(reply); 83 84 return state; 85 86 fail: 87 if (dbus_error_is_set(&error)) { 88 r = avahi_client_set_dbus_error(client, &error); 89 dbus_error_free(&error); 90 } 91 92 if (message) 93 dbus_message_unref(message); 94 95 if (reply) 96 dbus_message_unref(reply); 97 98 return r; 99 } 100 101 AvahiEntryGroup* avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *userdata) { 102 AvahiEntryGroup *group = NULL; 103 DBusMessage *message = NULL, *reply = NULL; 104 DBusError error; 105 char *path; 106 int state; 107 108 assert(client); 109 110 dbus_error_init (&error); 111 112 if (!avahi_client_is_connected(client)) { 113 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE); 114 goto fail; 115 } 116 117 if (!(group = avahi_new(AvahiEntryGroup, 1))) { 118 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 119 goto fail; 120 } 121 122 group->client = client; 123 group->callback = callback; 124 group->userdata = userdata; 125 group->state_valid = 0; 126 group->path = NULL; 127 AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, group); 128 129 if (!(message = dbus_message_new_method_call( 130 AVAHI_DBUS_NAME, 131 AVAHI_DBUS_PATH_SERVER, 132 AVAHI_DBUS_INTERFACE_SERVER, 133 "EntryGroupNew"))) { 134 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 135 goto fail; 136 } 137 138 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) || 139 dbus_error_is_set (&error)) { 140 avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR); 141 goto fail; 142 } 143 144 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) || 145 dbus_error_is_set (&error)) { 146 avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR); 147 goto fail; 148 } 149 150 if (!(group->path = avahi_strdup (path))) { 151 152 /* FIXME: We don't remove the object on the server side */ 153 154 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 155 goto fail; 156 } 157 158 if ((state = retrieve_state(group)) < 0) { 159 avahi_client_set_errno(client, state); 160 goto fail; 161 } 162 163 avahi_entry_group_set_state(group, (AvahiEntryGroupState) state); 164 165 dbus_message_unref(message); 166 dbus_message_unref(reply); 167 168 return group; 169 170 fail: 171 if (dbus_error_is_set(&error)) { 172 avahi_client_set_dbus_error(client, &error); 173 dbus_error_free(&error); 174 } 175 176 if (group) 177 avahi_entry_group_free(group); 178 179 if (message) 180 dbus_message_unref(message); 181 182 if (reply) 183 dbus_message_unref(reply); 184 185 return NULL; 186 } 187 188 static int entry_group_simple_method_call(AvahiEntryGroup *group, const char *method) { 189 DBusMessage *message = NULL, *reply = NULL; 190 DBusError error; 191 int r = AVAHI_OK; 192 AvahiClient *client; 193 194 dbus_error_init(&error); 195 196 assert(group); 197 client = group->client; 198 199 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, method))) { 200 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 201 goto fail; 202 } 203 204 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 205 dbus_error_is_set (&error)) { 206 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 207 goto fail; 208 } 209 210 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 211 dbus_error_is_set (&error)) { 212 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 213 goto fail; 214 } 215 216 dbus_message_unref(message); 217 dbus_message_unref(reply); 218 219 return AVAHI_OK; 220 221 fail: 222 if (dbus_error_is_set(&error)) { 223 r = avahi_client_set_dbus_error(client, &error); 224 dbus_error_free(&error); 225 } 226 227 if (message) 228 dbus_message_unref(message); 229 230 if (reply) 231 dbus_message_unref(reply); 232 233 return r; 234 } 235 236 int avahi_entry_group_free(AvahiEntryGroup *group) { 237 AvahiClient *client = group->client; 238 int r = AVAHI_OK; 239 240 assert(group); 241 242 if (group->path && avahi_client_is_connected(client)) 243 r = entry_group_simple_method_call(group, "Free"); 244 245 AVAHI_LLIST_REMOVE(AvahiEntryGroup, groups, client->groups, group); 246 247 avahi_free(group->path); 248 avahi_free(group); 249 250 return r; 251 } 252 253 int avahi_entry_group_commit(AvahiEntryGroup *group) { 254 int ret; 255 assert(group); 256 257 if (!group->path || !avahi_client_is_connected(group->client)) 258 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 259 260 if ((ret = entry_group_simple_method_call(group, "Commit")) < 0) 261 return ret; 262 263 group->state_valid = 0; 264 return ret; 265 } 266 267 int avahi_entry_group_reset(AvahiEntryGroup *group) { 268 int ret; 269 assert(group); 270 271 if (!group->path || !avahi_client_is_connected(group->client)) 272 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 273 274 if ((ret = entry_group_simple_method_call(group, "Reset")) < 0) 275 return ret; 276 277 group->state_valid = 0; 278 return ret; 279 } 280 281 int avahi_entry_group_get_state (AvahiEntryGroup *group) { 282 assert (group); 283 284 if (group->state_valid) 285 return group->state; 286 287 return retrieve_state(group); 288 } 289 290 AvahiClient* avahi_entry_group_get_client (AvahiEntryGroup *group) { 291 assert(group); 292 293 return group->client; 294 } 295 296 int avahi_entry_group_is_empty (AvahiEntryGroup *group) { 297 DBusMessage *message = NULL, *reply = NULL; 298 DBusError error; 299 int r = AVAHI_OK; 300 int b; 301 AvahiClient *client; 302 303 assert(group); 304 client = group->client; 305 306 if (!group->path || !avahi_client_is_connected(group->client)) 307 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 308 309 dbus_error_init(&error); 310 311 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty"))) { 312 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 313 goto fail; 314 } 315 316 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 317 dbus_error_is_set (&error)) { 318 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 319 goto fail; 320 } 321 322 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID) || 323 dbus_error_is_set (&error)) { 324 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 325 goto fail; 326 } 327 328 dbus_message_unref(message); 329 dbus_message_unref(reply); 330 331 return !!b; 332 333 fail: 334 if (dbus_error_is_set(&error)) { 335 r = avahi_client_set_dbus_error(client, &error); 336 dbus_error_free(&error); 337 } 338 339 if (message) 340 dbus_message_unref(message); 341 342 if (reply) 343 dbus_message_unref(reply); 344 345 return r; 346 } 347 348 static int append_rdata(DBusMessage *message, const void *rdata, size_t size) { 349 DBusMessageIter iter, sub; 350 351 assert(message); 352 353 dbus_message_iter_init_append(message, &iter); 354 355 if (!(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub)) || 356 !(dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &rdata, size)) || 357 !(dbus_message_iter_close_container(&iter, &sub))) 358 return -1; 359 360 return 0; 361 } 362 363 static int append_string_list(DBusMessage *message, AvahiStringList *txt) { 364 DBusMessageIter iter, sub; 365 int r = -1; 366 AvahiStringList *p; 367 368 assert(message); 369 370 dbus_message_iter_init_append(message, &iter); 371 372 /* Reverse the string list, so that we can pass it in-order to the server */ 373 txt = avahi_string_list_reverse(txt); 374 375 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub)) 376 goto fail; 377 378 /* Assemble the AvahiStringList into an Array of Array of Bytes to send over dbus */ 379 for (p = txt; p != NULL; p = p->next) { 380 DBusMessageIter sub2; 381 const uint8_t *data = p->text; 382 383 if (!(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2)) || 384 !(dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size)) || 385 !(dbus_message_iter_close_container(&sub, &sub2))) 386 goto fail; 387 } 388 389 if (!dbus_message_iter_close_container(&iter, &sub)) 390 goto fail; 391 392 r = 0; 393 394 fail: 395 396 /* Reverse the string list to the original state */ 397 txt = avahi_string_list_reverse(txt); 398 399 return r; 400 } 401 402 int avahi_entry_group_add_service_strlst( 403 AvahiEntryGroup *group, 404 AvahiIfIndex interface, 405 AvahiProtocol protocol, 406 AvahiPublishFlags flags, 407 const char *name, 408 const char *type, 409 const char *domain, 410 const char *host, 411 uint16_t port, 412 AvahiStringList *txt) { 413 414 DBusMessage *message = NULL, *reply = NULL; 415 int r = AVAHI_OK; 416 DBusError error; 417 AvahiClient *client; 418 int32_t i_interface, i_protocol; 419 uint32_t u_flags; 420 421 assert(group); 422 assert(name); 423 assert(type); 424 425 client = group->client; 426 427 if (!group->path || !avahi_client_is_connected(group->client)) 428 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 429 430 if (!domain) 431 domain = ""; 432 433 if (!host) 434 host = ""; 435 436 dbus_error_init(&error); 437 438 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService"))) { 439 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 440 goto fail; 441 } 442 443 i_interface = (int32_t) interface; 444 i_protocol = (int32_t) protocol; 445 u_flags = (uint32_t) flags; 446 447 if (!dbus_message_append_args( 448 message, 449 DBUS_TYPE_INT32, &i_interface, 450 DBUS_TYPE_INT32, &i_protocol, 451 DBUS_TYPE_UINT32, &u_flags, 452 DBUS_TYPE_STRING, &name, 453 DBUS_TYPE_STRING, &type, 454 DBUS_TYPE_STRING, &domain, 455 DBUS_TYPE_STRING, &host, 456 DBUS_TYPE_UINT16, &port, 457 DBUS_TYPE_INVALID) || 458 append_string_list(message, txt) < 0) { 459 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); 460 goto fail; 461 } 462 463 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 464 dbus_error_is_set (&error)) { 465 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 466 goto fail; 467 } 468 469 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 470 dbus_error_is_set (&error)) { 471 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 472 goto fail; 473 } 474 475 dbus_message_unref(message); 476 dbus_message_unref(reply); 477 478 return AVAHI_OK; 479 480 fail: 481 482 if (dbus_error_is_set(&error)) { 483 r = avahi_client_set_dbus_error(client, &error); 484 dbus_error_free(&error); 485 } 486 487 if (message) 488 dbus_message_unref(message); 489 490 if (reply) 491 dbus_message_unref(reply); 492 493 return r; 494 } 495 496 int avahi_entry_group_add_service( 497 AvahiEntryGroup *group, 498 AvahiIfIndex interface, 499 AvahiProtocol protocol, 500 AvahiPublishFlags flags, 501 const char *name, 502 const char *type, 503 const char *domain, 504 const char *host, 505 uint16_t port, 506 ...) { 507 508 va_list va; 509 int r; 510 AvahiStringList *txt; 511 512 assert(group); 513 514 va_start(va, port); 515 txt = avahi_string_list_new_va(va); 516 r = avahi_entry_group_add_service_strlst(group, interface, protocol, flags, name, type, domain, host, port, txt); 517 avahi_string_list_free(txt); 518 va_end(va); 519 return r; 520 } 521 522 int avahi_entry_group_add_service_subtype( 523 AvahiEntryGroup *group, 524 AvahiIfIndex interface, 525 AvahiProtocol protocol, 526 AvahiPublishFlags flags, 527 const char *name, 528 const char *type, 529 const char *domain, 530 const char *subtype) { 531 532 DBusMessage *message = NULL, *reply = NULL; 533 int r = AVAHI_OK; 534 DBusError error; 535 AvahiClient *client; 536 int32_t i_interface, i_protocol; 537 uint32_t u_flags; 538 539 assert(group); 540 assert(name); 541 assert(type); 542 assert(subtype); 543 544 client = group->client; 545 546 if (!group->path || !avahi_client_is_connected(group->client)) 547 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 548 549 if (!domain) 550 domain = ""; 551 552 dbus_error_init(&error); 553 554 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype"))) { 555 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 556 goto fail; 557 } 558 559 i_interface = (int32_t) interface; 560 i_protocol = (int32_t) protocol; 561 u_flags = (uint32_t) flags; 562 563 if (!dbus_message_append_args( 564 message, 565 DBUS_TYPE_INT32, &i_interface, 566 DBUS_TYPE_INT32, &i_protocol, 567 DBUS_TYPE_UINT32, &u_flags, 568 DBUS_TYPE_STRING, &name, 569 DBUS_TYPE_STRING, &type, 570 DBUS_TYPE_STRING, &domain, 571 DBUS_TYPE_STRING, &subtype, 572 DBUS_TYPE_INVALID)) { 573 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); 574 goto fail; 575 } 576 577 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 578 dbus_error_is_set (&error)) { 579 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 580 goto fail; 581 } 582 583 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 584 dbus_error_is_set (&error)) { 585 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 586 goto fail; 587 } 588 589 dbus_message_unref(message); 590 dbus_message_unref(reply); 591 592 return AVAHI_OK; 593 594 fail: 595 596 if (dbus_error_is_set(&error)) { 597 r = avahi_client_set_dbus_error(client, &error); 598 dbus_error_free(&error); 599 } 600 601 if (message) 602 dbus_message_unref(message); 603 604 if (reply) 605 dbus_message_unref(reply); 606 607 return r; 608 609 } 610 611 int avahi_entry_group_update_service_txt( 612 AvahiEntryGroup *group, 613 AvahiIfIndex interface, 614 AvahiProtocol protocol, 615 AvahiPublishFlags flags, 616 const char *name, 617 const char *type, 618 const char *domain, 619 ...) { 620 621 va_list va; 622 int r; 623 AvahiStringList *txt; 624 625 va_start(va, domain); 626 txt = avahi_string_list_new_va(va); 627 r = avahi_entry_group_update_service_txt_strlst(group, interface, protocol, flags, name, type, domain, txt); 628 avahi_string_list_free(txt); 629 va_end(va); 630 return r; 631 } 632 633 int avahi_entry_group_update_service_txt_strlst( 634 AvahiEntryGroup *group, 635 AvahiIfIndex interface, 636 AvahiProtocol protocol, 637 AvahiPublishFlags flags, 638 const char *name, 639 const char *type, 640 const char *domain, 641 AvahiStringList *txt) { 642 643 DBusMessage *message = NULL, *reply = NULL; 644 int r = AVAHI_OK; 645 DBusError error; 646 AvahiClient *client; 647 int32_t i_interface, i_protocol; 648 uint32_t u_flags; 649 650 assert(group); 651 assert(name); 652 assert(type); 653 654 client = group->client; 655 656 if (!group->path || !avahi_client_is_connected(group->client)) 657 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 658 659 if (!domain) 660 domain = ""; 661 662 dbus_error_init(&error); 663 664 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt"))) { 665 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 666 goto fail; 667 } 668 669 i_interface = (int32_t) interface; 670 i_protocol = (int32_t) protocol; 671 u_flags = (uint32_t) flags; 672 673 if (!dbus_message_append_args( 674 message, 675 DBUS_TYPE_INT32, &i_interface, 676 DBUS_TYPE_INT32, &i_protocol, 677 DBUS_TYPE_UINT32, &u_flags, 678 DBUS_TYPE_STRING, &name, 679 DBUS_TYPE_STRING, &type, 680 DBUS_TYPE_STRING, &domain, 681 DBUS_TYPE_INVALID) || 682 append_string_list(message, txt) < 0) { 683 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); 684 goto fail; 685 } 686 687 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 688 dbus_error_is_set (&error)) { 689 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 690 goto fail; 691 } 692 693 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 694 dbus_error_is_set (&error)) { 695 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 696 goto fail; 697 } 698 699 dbus_message_unref(message); 700 dbus_message_unref(reply); 701 702 return AVAHI_OK; 703 704 fail: 705 706 if (dbus_error_is_set(&error)) { 707 r = avahi_client_set_dbus_error(client, &error); 708 dbus_error_free(&error); 709 } 710 711 if (message) 712 dbus_message_unref(message); 713 714 if (reply) 715 dbus_message_unref(reply); 716 717 return r; 718 } 719 720 /** Add a host/address pair */ 721 int avahi_entry_group_add_address( 722 AvahiEntryGroup *group, 723 AvahiIfIndex interface, 724 AvahiProtocol protocol, 725 AvahiPublishFlags flags, 726 const char *name, 727 const AvahiAddress *a) { 728 729 DBusMessage *message = NULL, *reply = NULL; 730 int r = AVAHI_OK; 731 DBusError error; 732 AvahiClient *client; 733 int32_t i_interface, i_protocol; 734 uint32_t u_flags; 735 char s_address[AVAHI_ADDRESS_STR_MAX]; 736 char *p_address = s_address; 737 738 assert(name); 739 740 client = group->client; 741 742 if (!group->path || !avahi_client_is_connected(group->client)) 743 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 744 745 dbus_error_init(&error); 746 747 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress"))) { 748 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 749 goto fail; 750 } 751 752 i_interface = (int32_t) interface; 753 i_protocol = (int32_t) protocol; 754 u_flags = (uint32_t) flags; 755 756 if (!avahi_address_snprint (s_address, sizeof (s_address), a)) 757 { 758 r = avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS); 759 goto fail; 760 } 761 762 if (!dbus_message_append_args( 763 message, 764 DBUS_TYPE_INT32, &i_interface, 765 DBUS_TYPE_INT32, &i_protocol, 766 DBUS_TYPE_UINT32, &u_flags, 767 DBUS_TYPE_STRING, &name, 768 DBUS_TYPE_STRING, &p_address, 769 DBUS_TYPE_INVALID)) { 770 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY); 771 goto fail; 772 } 773 774 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) || 775 dbus_error_is_set (&error)) { 776 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 777 goto fail; 778 } 779 780 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 781 dbus_error_is_set (&error)) { 782 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 783 goto fail; 784 } 785 786 dbus_message_unref(message); 787 dbus_message_unref(reply); 788 789 return AVAHI_OK; 790 791 fail: 792 793 if (dbus_error_is_set(&error)) { 794 r = avahi_client_set_dbus_error(client, &error); 795 dbus_error_free(&error); 796 } 797 798 if (message) 799 dbus_message_unref(message); 800 801 if (reply) 802 dbus_message_unref(reply); 803 804 return r; 805 } 806 807 /** Add an arbitrary record */ 808 int avahi_entry_group_add_record( 809 AvahiEntryGroup *group, 810 AvahiIfIndex interface, 811 AvahiProtocol protocol, 812 AvahiPublishFlags flags, 813 const char *name, 814 uint16_t clazz, 815 uint16_t type, 816 uint32_t ttl, 817 const void *rdata, 818 size_t size) { 819 820 DBusMessage *message = NULL, *reply = NULL; 821 int r = AVAHI_OK; 822 DBusError error; 823 AvahiClient *client; 824 int32_t i_interface, i_protocol; 825 uint32_t u_flags; 826 827 assert(name); 828 829 client = group->client; 830 831 if (!group->path || !avahi_client_is_connected(group->client)) 832 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE); 833 834 dbus_error_init(&error); 835 836 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddRecord"))) { 837 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY); 838 goto fail; 839 } 840 841 i_interface = (int32_t) interface; 842 i_protocol = (int32_t) protocol; 843 u_flags = (uint32_t) flags; 844 845 if (!dbus_message_append_args( 846 message, 847 DBUS_TYPE_INT32, &i_interface, 848 DBUS_TYPE_INT32, &i_protocol, 849 DBUS_TYPE_UINT32, &u_flags, 850 DBUS_TYPE_STRING, &name, 851 DBUS_TYPE_UINT16, &clazz, 852 DBUS_TYPE_UINT16, &type, 853 DBUS_TYPE_UINT32, &ttl, 854 DBUS_TYPE_INVALID) || append_rdata(message, rdata, size) < 0) { 855 r = avahi_client_set_errno(group->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 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 862 goto fail; 863 } 864 865 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) || 866 dbus_error_is_set (&error)) { 867 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR); 868 goto fail; 869 } 870 871 dbus_message_unref(message); 872 dbus_message_unref(reply); 873 874 return AVAHI_OK; 875 876 fail: 877 878 if (dbus_error_is_set(&error)) { 879 r = avahi_client_set_dbus_error(client, &error); 880 dbus_error_free(&error); 881 } 882 883 if (message) 884 dbus_message_unref(message); 885 886 if (reply) 887 dbus_message_unref(reply); 888 889 return r; 890 } 891
