git.meshlink.io Git - catta/blob - avahi-compat-howl/unsupported.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   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.
  10
  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.
  15
  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
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include "howl.h"
  27 #include "warn.h"
  28
  29 sw_string sw_strdup(sw_const_string str) {
  30     AVAHI_WARN_UNSUPPORTED_ABORT;
  31     return NULL;
  32 }
  33
  34 sw_opaque _sw_debug_malloc(
  35     sw_size_t size,
  36     sw_const_string function,
  37     sw_const_string file,
  38     sw_uint32 line) {
  39     AVAHI_WARN_UNSUPPORTED_ABORT;
  40     return NULL;
  41 }
  42
  43 sw_opaque _sw_debug_realloc(
  44    sw_opaque_t mem,
  45    sw_size_t size,
  46    sw_const_string function,
  47    sw_const_string file,
  48    sw_uint32 line) {
  49     AVAHI_WARN_UNSUPPORTED_ABORT;
  50     return NULL;
  51 }
  52
  53 void _sw_debug_free(
  54     sw_opaque_t mem,
  55     sw_const_string function,
  56     sw_const_string file,
  57     sw_uint32 line) {
  58     AVAHI_WARN_UNSUPPORTED;
  59 }
  60
  61 sw_const_string sw_strerror(/* howl sucks */) {
  62     AVAHI_WARN_UNSUPPORTED_ABORT;
  63     return NULL;
  64 }
  65
  66 sw_result sw_timer_init(sw_timer * self) {
  67     AVAHI_WARN_UNSUPPORTED;
  68     return SW_E_NO_IMPL;
  69 }
  70
  71 sw_result sw_timer_fina(sw_timer self) {
  72     AVAHI_WARN_UNSUPPORTED;
  73     return SW_E_NO_IMPL;
  74 }
  75
  76 sw_result sw_time_init(sw_time * self) {
  77     AVAHI_WARN_UNSUPPORTED;
  78     return SW_E_NO_IMPL;
  79 }
  80
  81 sw_result sw_time_init_now(sw_time * self) {
  82     AVAHI_WARN_UNSUPPORTED;
  83     return SW_E_NO_IMPL;
  84 }
  85
  86 sw_result sw_time_fina(sw_time self) {
  87     AVAHI_WARN_UNSUPPORTED;
  88     return SW_E_NO_IMPL;
  89 }
  90
  91 sw_time sw_time_add(
  92     sw_time self,
  93     sw_time y) {
  94     AVAHI_WARN_UNSUPPORTED_ABORT;
  95 }
  96
  97 sw_time sw_time_sub(
  98   sw_time self,
  99   sw_time y) {
 100     AVAHI_WARN_UNSUPPORTED_ABORT;
 101 }
 102
 103 sw_int32 sw_time_cmp(
 104   sw_time self,
 105   sw_time y) {
 106     AVAHI_WARN_UNSUPPORTED_ABORT;
 107 }
 108
 109 sw_result sw_salt_init(
 110     sw_salt * self,
 111     int argc,
 112     char ** argv) {
 113     AVAHI_WARN_UNSUPPORTED;
 114     return SW_E_NO_IMPL;
 115 }
 116
 117 sw_result sw_salt_fina(sw_salt self) {
 118     AVAHI_WARN_UNSUPPORTED;
 119     return SW_E_NO_IMPL;
 120 }
 121
 122 sw_result sw_salt_register_socket(
 123     sw_salt self,
 124     struct _sw_socket * socket,
 125     sw_socket_event events,
 126     sw_socket_handler handler,
 127     sw_socket_handler_func func,
 128     sw_opaque extra) {
 129     AVAHI_WARN_UNSUPPORTED;
 130     return SW_E_NO_IMPL;
 131 }
 132
 133 sw_result sw_salt_unregister_socket(
 134     sw_salt self,
 135     struct _sw_socket * socket) {
 136     AVAHI_WARN_UNSUPPORTED;
 137     return SW_E_NO_IMPL;
 138 }
 139
 140
 141 sw_result sw_salt_register_timer(
 142     sw_salt self,
 143     struct _sw_timer * timer,
 144     sw_time timeout,
 145     sw_timer_handler handler,
 146     sw_timer_handler_func func,
 147     sw_opaque extra) {
 148     AVAHI_WARN_UNSUPPORTED;
 149     return SW_E_NO_IMPL;
 150 }
 151
 152 sw_result sw_salt_unregister_timer(
 153     sw_salt self,
 154     struct _sw_timer * timer) {
 155     AVAHI_WARN_UNSUPPORTED;
 156     return SW_E_NO_IMPL;
 157 }
 158
 159 sw_result sw_salt_register_network_interface(
 160     sw_salt self,
 161     struct _sw_network_interface * netif,
 162     sw_network_interface_handler handler,
 163     sw_network_interface_handler_func func,
 164     sw_opaque extra) {
 165     AVAHI_WARN_UNSUPPORTED;
 166     return SW_E_NO_IMPL;
 167 }
 168
 169 sw_result sw_salt_unregister_network_interface_handler(sw_salt self) {
 170     AVAHI_WARN_UNSUPPORTED;
 171     return SW_E_NO_IMPL;
 172 }
 173
 174 sw_result sw_salt_register_signal(
 175     sw_salt self,
 176     struct _sw_signal * signal,
 177     sw_signal_handler handler,
 178     sw_signal_handler_func func,
 179     sw_opaque extra) {
 180
 181     AVAHI_WARN_UNSUPPORTED;
 182     return SW_E_NO_IMPL;
 183 }
 184
 185 sw_result sw_salt_unregister_signal(
 186     sw_salt self,
 187     struct _sw_signal * signal) {
 188
 189     AVAHI_WARN_UNSUPPORTED;
 190     return SW_E_NO_IMPL;
 191 }
 192
 193 sw_result sw_salt_lock(sw_salt self) {
 194     AVAHI_WARN_UNSUPPORTED;
 195     return SW_E_NO_IMPL;
 196 }
 197
 198 sw_result sw_salt_unlock(sw_salt self) {
 199     AVAHI_WARN_UNSUPPORTED;
 200     return SW_E_NO_IMPL;
 201 }
 202
 203
 204 void sw_print_assert(
 205     int code,
 206     sw_const_string assert_string,
 207     sw_const_string file,
 208     sw_const_string func,
 209     int line) {
 210     AVAHI_WARN_UNSUPPORTED;
 211 }
 212
 213 void sw_print_debug(
 214     int level,
 215     sw_const_string format,
 216     ...) {
 217     AVAHI_WARN_UNSUPPORTED;
 218 }
 219
 220 sw_result sw_tcp_socket_init(sw_socket * self) {
 221     AVAHI_WARN_UNSUPPORTED;
 222     return SW_E_NO_IMPL;
 223 }
 224
 225 sw_result sw_tcp_socket_init_with_desc(
 226     sw_socket * self,
 227     sw_sockdesc_t desc) {
 228     AVAHI_WARN_UNSUPPORTED;
 229     return SW_E_NO_IMPL;
 230 }
 231
 232 sw_result sw_udp_socket_init(
 233     sw_socket * self) {
 234     AVAHI_WARN_UNSUPPORTED;
 235     return SW_E_NO_IMPL;
 236 }
 237
 238 sw_result sw_multicast_socket_init(
 239     sw_socket * self) {
 240     AVAHI_WARN_UNSUPPORTED;
 241     return SW_E_NO_IMPL;
 242 }
 243
 244 sw_result sw_socket_fina(sw_socket self) {
 245     AVAHI_WARN_UNSUPPORTED;
 246     return SW_E_NO_IMPL;
 247 }
 248
 249 sw_result sw_socket_bind(
 250     sw_socket self,
 251     sw_ipv4_address address,
 252     sw_port port) {
 253     AVAHI_WARN_UNSUPPORTED;
 254     return SW_E_NO_IMPL;
 255 }
 256
 257 sw_result sw_socket_join_multicast_group(
 258     sw_socket self,
 259     sw_ipv4_address local_address,
 260     sw_ipv4_address multicast_address,
 261     sw_uint32 ttl) {
 262     AVAHI_WARN_UNSUPPORTED;
 263     return SW_E_NO_IMPL;
 264 }
 265
 266 sw_result sw_socket_leave_multicast_group(sw_socket self) {
 267     AVAHI_WARN_UNSUPPORTED;
 268     return SW_E_NO_IMPL;
 269 }
 270
 271 sw_result sw_socket_listen(
 272     sw_socket self,
 273     int qsize) {
 274     AVAHI_WARN_UNSUPPORTED;
 275     return SW_E_NO_IMPL;
 276 }
 277
 278 sw_result sw_socket_connect(
 279     sw_socket self,
 280     sw_ipv4_address address,
 281     sw_port port) {
 282     AVAHI_WARN_UNSUPPORTED;
 283     return SW_E_NO_IMPL;
 284 }
 285
 286 sw_result sw_socket_accept(
 287     sw_socket self,
 288     sw_socket * socket) {
 289     AVAHI_WARN_UNSUPPORTED;
 290     return SW_E_NO_IMPL;
 291 }
 292
 293 sw_result sw_socket_send(
 294     sw_socket self,
 295     sw_octets buffer,
 296     sw_size_t len,
 297     sw_size_t * bytesWritten) {
 298     AVAHI_WARN_UNSUPPORTED;
 299     return SW_E_NO_IMPL;
 300 }
 301
 302 sw_result sw_socket_sendto(
 303     sw_socket self,
 304     sw_octets buffer,
 305     sw_size_t len,
 306     sw_size_t * bytesWritten,
 307     sw_ipv4_address to,
 308     sw_port port) {
 309     AVAHI_WARN_UNSUPPORTED;
 310     return SW_E_NO_IMPL;
 311 }
 312
 313 sw_result sw_socket_recv(
 314     sw_socket self,
 315     sw_octets buffer,
 316     sw_size_t max,
 317     sw_size_t * len) {
 318     AVAHI_WARN_UNSUPPORTED;
 319     return SW_E_NO_IMPL;
 320 }
 321
 322 sw_result sw_socket_recvfrom(
 323     sw_socket self,
 324     sw_octets buffer,
 325     sw_size_t max,
 326     sw_size_t * len,
 327     sw_ipv4_address * from,
 328     sw_port * port,
 329     sw_ipv4_address * dest,
 330     sw_uint32 * interface_index) {
 331     AVAHI_WARN_UNSUPPORTED;
 332     return SW_E_NO_IMPL;
 333 }
 334
 335 sw_result sw_socket_set_blocking_mode(
 336     sw_socket self,
 337     sw_bool blocking_mode) {
 338     AVAHI_WARN_UNSUPPORTED;
 339     return SW_E_NO_IMPL;
 340 }
 341
 342 sw_result sw_socket_set_options(
 343     sw_socket self,
 344     sw_socket_options options) {
 345     AVAHI_WARN_UNSUPPORTED;
 346     return SW_E_NO_IMPL;
 347 }
 348
 349 sw_ipv4_address sw_socket_ipv4_address(sw_socket self) {
 350     AVAHI_WARN_UNSUPPORTED_ABORT;
 351 }
 352
 353 sw_port sw_socket_port(sw_socket self) {
 354     AVAHI_WARN_UNSUPPORTED_ABORT;
 355 }
 356
 357 sw_sockdesc_t sw_socket_desc(sw_socket self) {
 358     AVAHI_WARN_UNSUPPORTED_ABORT;
 359 }
 360
 361 sw_result sw_socket_close(sw_socket self) {
 362     AVAHI_WARN_UNSUPPORTED;
 363     return SW_E_NO_IMPL;
 364 }
 365
 366 sw_result sw_socket_options_init(sw_socket_options * self) {
 367     AVAHI_WARN_UNSUPPORTED;
 368     return SW_E_NO_IMPL;
 369 }
 370
 371 sw_result sw_socket_options_fina(sw_socket_options self) {
 372     AVAHI_WARN_UNSUPPORTED;
 373     return SW_E_NO_IMPL;
 374 }
 375
 376 sw_result sw_socket_options_set_debug(
 377     sw_socket_options self,
 378     sw_bool val) {
 379     AVAHI_WARN_UNSUPPORTED;
 380     return SW_E_NO_IMPL;
 381 }
 382
 383 sw_result sw_socket_options_set_nodelay(
 384     sw_socket_options self,
 385     sw_bool val) {
 386     AVAHI_WARN_UNSUPPORTED;
 387     return SW_E_NO_IMPL;
 388 }
 389
 390 sw_result sw_socket_options_set_dontroute(
 391     sw_socket_options self,
 392     sw_bool val) {
 393     AVAHI_WARN_UNSUPPORTED;
 394     return SW_E_NO_IMPL;
 395 }
 396
 397 sw_result sw_socket_options_set_keepalive(
 398     sw_socket_options self,
 399     sw_bool val) {
 400     AVAHI_WARN_UNSUPPORTED;
 401     return SW_E_NO_IMPL;
 402 }
 403
 404 sw_result sw_socket_options_set_linger(
 405     sw_socket_options self,
 406     sw_bool onoff,
 407     sw_uint32 linger) {
 408     AVAHI_WARN_UNSUPPORTED;
 409     return SW_E_NO_IMPL;
 410 }
 411
 412 sw_result sw_socket_options_set_reuseaddr(
 413     sw_socket_options self,
 414     sw_bool val) {
 415     AVAHI_WARN_UNSUPPORTED;
 416     return SW_E_NO_IMPL;
 417 }
 418
 419 sw_result sw_socket_options_set_rcvbuf(
 420     sw_socket_options self,
 421     sw_uint32 val) {
 422     AVAHI_WARN_UNSUPPORTED;
 423     return SW_E_NO_IMPL;
 424 }
 425
 426 sw_result sw_socket_options_set_sndbuf(
 427     sw_socket_options self,
 428     sw_uint32 val) {
 429     AVAHI_WARN_UNSUPPORTED;
 430     return SW_E_NO_IMPL;
 431 }
 432
 433 int sw_socket_error_code(void) {
 434     AVAHI_WARN_UNSUPPORTED_ABORT;
 435 }
 436
 437 sw_result sw_corby_orb_init(
 438     sw_corby_orb * self,
 439     sw_salt salt,
 440     const sw_corby_orb_config * config,
 441     sw_corby_orb_observer observer,
 442     sw_corby_orb_observer_func func,
 443     sw_opaque_t extra) {
 444     AVAHI_WARN_UNSUPPORTED;
 445     return SW_E_NO_IMPL;
 446 }
 447
 448 sw_result sw_corby_orb_fina(sw_corby_orb self) {
 449     AVAHI_WARN_UNSUPPORTED;
 450     return SW_E_NO_IMPL;
 451 }
 452
 453 sw_result sw_corby_orb_register_servant(
 454     sw_corby_orb self,
 455     sw_corby_servant servant,
 456     sw_corby_servant_cb cb,
 457     sw_const_string oid,
 458     struct _sw_corby_object ** object,
 459     sw_const_string protocol_name) {
 460     AVAHI_WARN_UNSUPPORTED;
 461     return SW_E_NO_IMPL;
 462 }
 463
 464 sw_result sw_corby_orb_unregister_servant(
 465     sw_corby_orb self,
 466     sw_const_string oid) {
 467     AVAHI_WARN_UNSUPPORTED;
 468     return SW_E_NO_IMPL;
 469 }
 470
 471 sw_result sw_corby_orb_register_bidirectional_object(
 472     sw_corby_orb self,
 473     struct _sw_corby_object * object) {
 474     AVAHI_WARN_UNSUPPORTED;
 475     return SW_E_NO_IMPL;
 476 }
 477
 478 sw_result sw_corby_orb_register_channel(
 479     sw_corby_orb self,
 480     struct _sw_corby_channel * channel) {
 481     AVAHI_WARN_UNSUPPORTED;
 482     return SW_E_NO_IMPL;
 483 }
 484
 485 sw_corby_orb_delegate sw_corby_orb_get_delegate(sw_corby_orb self) {
 486     AVAHI_WARN_UNSUPPORTED_ABORT;
 487 }
 488
 489 sw_result sw_corby_orb_set_delegate(
 490     sw_corby_orb self,
 491     sw_corby_orb_delegate delegate) {
 492     AVAHI_WARN_UNSUPPORTED;
 493     return SW_E_NO_IMPL;
 494 }
 495
 496 sw_result sw_corby_orb_set_observer(
 497     sw_corby_orb self,
 498     sw_corby_orb_observer observer,
 499     sw_corby_orb_observer_func func,
 500     sw_opaque_t extra) {
 501     AVAHI_WARN_UNSUPPORTED;
 502     return SW_E_NO_IMPL;
 503 }
 504
 505 sw_result sw_corby_orb_protocol_to_address(
 506     sw_corby_orb self,
 507     sw_const_string tag,
 508     sw_string addr,
 509     sw_port * port) {
 510     AVAHI_WARN_UNSUPPORTED;
 511     return SW_E_NO_IMPL;
 512 }
 513
 514 sw_result sw_corby_orb_protocol_to_url(
 515     sw_corby_orb self,
 516     sw_const_string tag,
 517     sw_const_string name,
 518     sw_string url,
 519     sw_size_t url_len) {
 520     AVAHI_WARN_UNSUPPORTED;
 521     return SW_E_NO_IMPL;
 522 }
 523
 524 sw_result sw_corby_orb_read_channel(
 525     sw_corby_orb self,
 526     struct _sw_corby_channel * channel) {
 527     AVAHI_WARN_UNSUPPORTED;
 528     return SW_E_NO_IMPL;
 529 }
 530
 531 sw_result sw_corby_orb_dispatch_message(
 532     sw_corby_orb self,
 533     struct _sw_corby_channel * channel,
 534     struct _sw_corby_message * message,
 535     struct _sw_corby_buffer * buffer,
 536     sw_uint8 endian) {
 537     AVAHI_WARN_UNSUPPORTED;
 538     return SW_E_NO_IMPL;
 539 }
 540
 541 sw_result sw_corby_message_init(sw_corby_message * self) {
 542     AVAHI_WARN_UNSUPPORTED;
 543     return SW_E_NO_IMPL;
 544 }
 545
 546 sw_result sw_corby_message_fina(sw_corby_message self) {
 547     AVAHI_WARN_UNSUPPORTED;
 548     return SW_E_NO_IMPL;
 549 }
 550
 551 sw_result sw_corby_buffer_init(sw_corby_buffer * self) {
 552     AVAHI_WARN_UNSUPPORTED;
 553     return SW_E_NO_IMPL;
 554 }
 555
 556 sw_result sw_corby_buffer_init_with_size(
 557     sw_corby_buffer * self,
 558     sw_size_t size) {
 559     AVAHI_WARN_UNSUPPORTED;
 560     return SW_E_NO_IMPL;
 561 }
 562
 563 sw_result sw_corby_buffer_init_with_delegate(
 564     sw_corby_buffer * self,
 565     sw_corby_buffer_delegate delegate,
 566     sw_corby_buffer_overflow_func overflow,
 567     sw_corby_buffer_underflow_func underflow,
 568     sw_opaque_t extra) {
 569     AVAHI_WARN_UNSUPPORTED;
 570     return SW_E_NO_IMPL;
 571 }
 572
 573 sw_result sw_corby_buffer_init_with_size_and_delegate(
 574     sw_corby_buffer * self,
 575     sw_size_t size,
 576     sw_corby_buffer_delegate delegate,
 577     sw_corby_buffer_overflow_func overflow,
 578     sw_corby_buffer_underflow_func underflow,
 579     sw_opaque_t extra) {
 580     AVAHI_WARN_UNSUPPORTED;
 581     return SW_E_NO_IMPL;
 582 }
 583
 584 sw_result sw_corby_buffer_fina(sw_corby_buffer self) {
 585     AVAHI_WARN_UNSUPPORTED;
 586     return SW_E_NO_IMPL;
 587 }
 588
 589 void sw_corby_buffer_reset(sw_corby_buffer self) {
 590     AVAHI_WARN_UNSUPPORTED;
 591 }
 592
 593 sw_result sw_corby_buffer_set_octets(
 594     sw_corby_buffer self,
 595     sw_octets octets,
 596     sw_size_t size) {
 597     AVAHI_WARN_UNSUPPORTED;
 598     return SW_E_NO_IMPL;
 599 }
 600
 601 sw_octets sw_corby_buffer_octets(sw_corby_buffer self) {
 602     AVAHI_WARN_UNSUPPORTED;
 603     return NULL;
 604 }
 605
 606 sw_size_t sw_corby_buffer_bytes_used(sw_corby_buffer self) {
 607     AVAHI_WARN_UNSUPPORTED;
 608     return 0;
 609 }
 610
 611 sw_size_t sw_corby_buffer_size(sw_corby_buffer self) {
 612     AVAHI_WARN_UNSUPPORTED;
 613     return 0;
 614 }
 615
 616 sw_result sw_corby_buffer_put_int8(sw_corby_buffer self, sw_int8 val) {
 617     AVAHI_WARN_UNSUPPORTED;
 618     return SW_E_NO_IMPL;
 619 }
 620
 621 sw_result sw_corby_buffer_put_uint8(
 622     sw_corby_buffer self,
 623     sw_uint8 val) {
 624     AVAHI_WARN_UNSUPPORTED;
 625     return SW_E_NO_IMPL;
 626 }
 627
 628 sw_result sw_corby_buffer_put_int16(
 629     sw_corby_buffer self,
 630     sw_int16 val) {
 631     AVAHI_WARN_UNSUPPORTED;
 632     return SW_E_NO_IMPL;
 633 }
 634
 635 sw_result sw_corby_buffer_put_uint16(
 636     sw_corby_buffer self,
 637     sw_uint16 val) {
 638     AVAHI_WARN_UNSUPPORTED;
 639     return SW_E_NO_IMPL;
 640 }
 641
 642 sw_result sw_corby_buffer_put_int32(
 643     sw_corby_buffer self,
 644     sw_int32 val) {
 645     AVAHI_WARN_UNSUPPORTED;
 646     return SW_E_NO_IMPL;
 647 }
 648
 649 sw_result sw_corby_buffer_put_uint32(
 650     sw_corby_buffer self,
 651     sw_uint32 val) {
 652     AVAHI_WARN_UNSUPPORTED;
 653     return SW_E_NO_IMPL;
 654 }
 655
 656 sw_result sw_corby_buffer_put_octets(
 657     sw_corby_buffer self,
 658     sw_const_octets val,
 659     sw_size_t size) {
 660     AVAHI_WARN_UNSUPPORTED;
 661     return SW_E_NO_IMPL;
 662 }
 663
 664 sw_result sw_corby_buffer_put_sized_octets(
 665     sw_corby_buffer self,
 666     sw_const_octets val,
 667     sw_uint32 len) {
 668     AVAHI_WARN_UNSUPPORTED;
 669     return SW_E_NO_IMPL;
 670 }
 671
 672 sw_result sw_corby_buffer_put_cstring(
 673     sw_corby_buffer self,
 674     sw_const_string val) {
 675     AVAHI_WARN_UNSUPPORTED;
 676     return SW_E_NO_IMPL;
 677 }
 678
 679 sw_result sw_corby_buffer_put_object(
 680     sw_corby_buffer self,
 681     const struct _sw_corby_object * object) {
 682     AVAHI_WARN_UNSUPPORTED;
 683     return SW_E_NO_IMPL;
 684 }
 685
 686 sw_result sw_corby_buffer_put_pad(
 687     sw_corby_buffer self,
 688     sw_corby_buffer_pad pad) {
 689     AVAHI_WARN_UNSUPPORTED;
 690     return SW_E_NO_IMPL;
 691 }
 692
 693 sw_result sw_corby_buffer_get_int8(
 694     sw_corby_buffer self,
 695     sw_int8 * val) {
 696     AVAHI_WARN_UNSUPPORTED;
 697     return SW_E_NO_IMPL;
 698 }
 699
 700 sw_result sw_corby_buffer_get_uint8(
 701     sw_corby_buffer self,
 702     sw_uint8 * val) {
 703     AVAHI_WARN_UNSUPPORTED;
 704     return SW_E_NO_IMPL;
 705 }
 706
 707 sw_result sw_corby_buffer_get_int16(
 708     sw_corby_buffer self,
 709     sw_int16 * val,
 710     sw_uint8 endian) {
 711     AVAHI_WARN_UNSUPPORTED;
 712     return SW_E_NO_IMPL;
 713 }
 714
 715 sw_result sw_corby_buffer_get_uint16(
 716     sw_corby_buffer self,
 717     sw_uint16 * val,
 718     sw_uint8 endian) {
 719     AVAHI_WARN_UNSUPPORTED;
 720     return SW_E_NO_IMPL;
 721 }
 722
 723 sw_result sw_corby_buffer_get_int32(
 724     sw_corby_buffer self,
 725     sw_int32 * val,
 726     sw_uint8 endian) {
 727     AVAHI_WARN_UNSUPPORTED;
 728     return SW_E_NO_IMPL;
 729 }
 730
 731 sw_result sw_corby_buffer_get_uint32(
 732     sw_corby_buffer self,
 733     sw_uint32 * val,
 734     sw_uint8 endian) {
 735     AVAHI_WARN_UNSUPPORTED;
 736     return SW_E_NO_IMPL;
 737 }
 738
 739 sw_result sw_corby_buffer_get_octets(
 740     sw_corby_buffer self,
 741     sw_octets octets,
 742     sw_size_t size) {
 743     AVAHI_WARN_UNSUPPORTED;
 744     return SW_E_NO_IMPL;
 745 }
 746
 747 sw_result sw_corby_buffer_allocate_and_get_sized_octets(
 748     sw_corby_buffer self,
 749     sw_octets * val,
 750     sw_uint32 * size,
 751     sw_uint8 endian) {
 752     AVAHI_WARN_UNSUPPORTED;
 753     return SW_E_NO_IMPL;
 754 }
 755
 756 sw_result sw_corby_buffer_get_zerocopy_sized_octets(
 757     sw_corby_buffer self,
 758     sw_octets * val,
 759     sw_uint32 * size,
 760     sw_uint8 endian) {
 761     AVAHI_WARN_UNSUPPORTED;
 762     return SW_E_NO_IMPL;
 763 }
 764
 765 sw_result sw_corby_buffer_get_sized_octets(
 766     sw_corby_buffer self,
 767     sw_octets val,
 768     sw_uint32 * len,
 769     sw_uint8 endian) {
 770     AVAHI_WARN_UNSUPPORTED;
 771     return SW_E_NO_IMPL;
 772 }
 773
 774 sw_result sw_corby_buffer_allocate_and_get_cstring(
 775     sw_corby_buffer self,
 776     sw_string * val,
 777     sw_uint32 * len,
 778     sw_uint8 endian) {
 779     AVAHI_WARN_UNSUPPORTED;
 780     return SW_E_NO_IMPL;
 781 }
 782
 783 sw_result sw_corby_buffer_get_zerocopy_cstring(
 784     sw_corby_buffer self,
 785     sw_string * val,
 786     sw_uint32 * len,
 787     sw_uint8 endian) {
 788     AVAHI_WARN_UNSUPPORTED;
 789     return SW_E_NO_IMPL;
 790 }
 791
 792 sw_result sw_corby_buffer_get_cstring(
 793     sw_corby_buffer self,
 794     sw_string val,
 795     sw_uint32 * len,
 796     sw_uint8 endian) {
 797     AVAHI_WARN_UNSUPPORTED;
 798     return SW_E_NO_IMPL;
 799 }
 800
 801 sw_result sw_corby_buffer_get_object(
 802     sw_corby_buffer self,
 803     struct _sw_corby_object ** object,
 804     sw_uint8 endian) {
 805     AVAHI_WARN_UNSUPPORTED;
 806     return SW_E_NO_IMPL;
 807 }
 808
 809 sw_result sw_corby_channel_start_request(
 810     sw_corby_channel self,
 811     sw_const_corby_profile profile,
 812     struct _sw_corby_buffer ** buffer,
 813     sw_const_string op,
 814     sw_uint32 oplen,
 815     sw_bool reply_expected) {
 816     AVAHI_WARN_UNSUPPORTED;
 817     return SW_E_NO_IMPL;
 818 }
 819
 820 sw_result sw_corby_channel_start_reply(
 821     sw_corby_channel self,
 822     struct _sw_corby_buffer ** buffer,
 823     sw_uint32 request_id,
 824     sw_corby_reply_status status) {
 825     AVAHI_WARN_UNSUPPORTED;
 826     return SW_E_NO_IMPL;
 827 }
 828
 829 sw_result sw_corby_channel_send(
 830     sw_corby_channel self,
 831     struct _sw_corby_buffer * buffer,
 832     sw_corby_buffer_observer observer,
 833     sw_corby_buffer_written_func func,
 834     sw_opaque_t extra) {
 835     AVAHI_WARN_UNSUPPORTED;
 836     return SW_E_NO_IMPL;
 837 }
 838
 839 sw_result sw_corby_channel_recv(
 840     sw_corby_channel self,
 841     sw_salt * salt,
 842     struct _sw_corby_message ** message,
 843     sw_uint32 * request_id,
 844     sw_string * op,
 845     sw_uint32 * op_len,
 846     struct _sw_corby_buffer ** buffer,
 847     sw_uint8 * endian,
 848     sw_bool block) {
 849     AVAHI_WARN_UNSUPPORTED;
 850     return SW_E_NO_IMPL;
 851 }
 852
 853 sw_result sw_corby_channel_last_recv_from(
 854     sw_corby_channel self,
 855     sw_ipv4_address * from,
 856     sw_port * from_port) {
 857     AVAHI_WARN_UNSUPPORTED;
 858     return SW_E_NO_IMPL;
 859 }
 860
 861 sw_result sw_corby_channel_ff(
 862     sw_corby_channel self,
 863     struct _sw_corby_buffer * buffer) {
 864     AVAHI_WARN_UNSUPPORTED;
 865     return SW_E_NO_IMPL;
 866 }
 867
 868 sw_socket sw_corby_channel_socket(sw_corby_channel self) {
 869     AVAHI_WARN_UNSUPPORTED;
 870     return SW_E_NO_IMPL;
 871 }
 872
 873 sw_result sw_corby_channel_retain(sw_corby_channel self) {
 874     AVAHI_WARN_UNSUPPORTED;
 875     return SW_E_NO_IMPL;
 876 }
 877
 878 sw_result sw_corby_channel_set_delegate(
 879     sw_corby_channel self,
 880     sw_corby_channel_delegate delegate) {
 881     AVAHI_WARN_UNSUPPORTED;
 882     return SW_E_NO_IMPL;
 883 }
 884
 885 sw_corby_channel_delegate sw_corby_channel_get_delegate(
 886     sw_corby_channel self) {
 887     AVAHI_WARN_UNSUPPORTED_ABORT;
 888 }
 889
 890 void sw_corby_channel_set_app_data(
 891     sw_corby_channel self,
 892     sw_opaque app_data) {
 893     AVAHI_WARN_UNSUPPORTED;
 894 }
 895
 896 sw_opaque sw_corby_channel_get_app_data(sw_corby_channel self) {
 897     AVAHI_WARN_UNSUPPORTED_ABORT;
 898 }
 899
 900 sw_result sw_corby_channel_fina(sw_corby_channel self) {
 901     AVAHI_WARN_UNSUPPORTED;
 902     return SW_E_NO_IMPL;
 903 }
 904
 905 sw_result sw_corby_object_init_from_url(
 906     sw_corby_object * self,
 907     struct _sw_corby_orb * orb,
 908     sw_const_string url,
 909     sw_socket_options options,
 910     sw_uint32 bufsize) {
 911     AVAHI_WARN_UNSUPPORTED;
 912     return SW_E_NO_IMPL;
 913 }
 914
 915 sw_result sw_corby_object_fina(
 916     sw_corby_object self) {
 917     AVAHI_WARN_UNSUPPORTED;
 918     return SW_E_NO_IMPL;
 919 }
 920
 921 sw_result sw_corby_object_start_request(
 922     sw_corby_object self,
 923     sw_const_string op,
 924     sw_uint32 op_len,
 925     sw_bool reply_expected,
 926     sw_corby_buffer * buffer) {
 927     AVAHI_WARN_UNSUPPORTED;
 928     return SW_E_NO_IMPL;
 929 }
 930
 931 sw_result sw_corby_object_send(
 932     sw_corby_object self,
 933     sw_corby_buffer buffer,
 934     sw_corby_buffer_observer observer,
 935     sw_corby_buffer_written_func func,
 936     sw_opaque extra) {
 937     AVAHI_WARN_UNSUPPORTED;
 938     return SW_E_NO_IMPL;
 939 }
 940
 941 sw_result sw_corby_object_recv(
 942     sw_corby_object self,
 943     sw_corby_message * message,
 944     sw_corby_buffer * buffer,
 945     sw_uint8 * endian,
 946     sw_bool block) {
 947     AVAHI_WARN_UNSUPPORTED;
 948     return SW_E_NO_IMPL;
 949 }
 950
 951 sw_result sw_corby_object_channel(
 952     sw_corby_object self,
 953     sw_corby_channel * channel) {
 954     AVAHI_WARN_UNSUPPORTED;
 955     return SW_E_NO_IMPL;
 956 }
 957
 958 sw_result sw_corby_object_set_channel(
 959     sw_corby_object self,
 960     sw_corby_channel channel) {
 961     AVAHI_WARN_UNSUPPORTED;
 962     return SW_E_NO_IMPL;
 963 }
 964
 965 sw_result sw_discovery_publish_host(
 966     sw_discovery self,
 967     sw_uint32 interface_index,
 968     sw_const_string name,
 969     sw_const_string domain,
 970     sw_ipv4_address address,
 971     sw_discovery_publish_reply reply,
 972     sw_opaque extra,
 973     sw_discovery_oid * oid) {
 974     AVAHI_WARN_UNSUPPORTED;
 975     return SW_E_NO_IMPL;
 976 }
 977
 978 sw_result sw_discovery_publish_update(
 979     sw_discovery self,
 980     sw_discovery_oid oid,
 981     sw_octets text_record,
 982     sw_uint32 text_record_len) {
 983     AVAHI_WARN_UNSUPPORTED;
 984     return SW_E_NO_IMPL;
 985 }
 986
 987 sw_result sw_discovery_query_record(
 988     sw_discovery self,
 989     sw_uint32 interface_index,
 990     sw_uint32 flags,
 991     sw_const_string fullname,
 992     sw_uint16 rrtype,
 993     sw_uint16 rrclass,
 994     sw_discovery_query_record_reply reply,
 995     sw_opaque extra,
 996     sw_discovery_oid * oid) {
 997     AVAHI_WARN_UNSUPPORTED;
 998     return SW_E_NO_IMPL;
 999 }
1000
1001 sw_result sw_text_record_string_iterator_init(
1002     sw_text_record_string_iterator * self,
1003     sw_const_string text_record_string) {
1004     AVAHI_WARN_UNSUPPORTED;
1005     return SW_E_NO_IMPL;
1006 }
1007
1008 sw_result sw_text_record_string_iterator_fina(
1009     sw_text_record_string_iterator self) {
1010     AVAHI_WARN_UNSUPPORTED;
1011     return SW_E_NO_IMPL;
1012 }
1013
1014 sw_result sw_text_record_string_iterator_next(
1015     sw_text_record_string_iterator self,
1016     char key[255],
1017     char val[255]) {
1018     AVAHI_WARN_UNSUPPORTED;
1019     return SW_E_NO_IMPL;
1020 }