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 void sw_print_assert(
 194     int code,
 195     sw_const_string assert_string,
 196     sw_const_string file,
 197     sw_const_string func,
 198     int line) {
 199     AVAHI_WARN_UNSUPPORTED;
 200 }
 201
 202 void sw_print_debug(
 203     int level,
 204     sw_const_string format,
 205     ...) {
 206     AVAHI_WARN_UNSUPPORTED;
 207 }
 208
 209 sw_result sw_tcp_socket_init(sw_socket * self) {
 210     AVAHI_WARN_UNSUPPORTED;
 211     return SW_E_NO_IMPL;
 212 }
 213
 214 sw_result sw_tcp_socket_init_with_desc(
 215     sw_socket * self,
 216     sw_sockdesc_t desc) {
 217     AVAHI_WARN_UNSUPPORTED;
 218     return SW_E_NO_IMPL;
 219 }
 220
 221 sw_result sw_udp_socket_init(
 222     sw_socket * self) {
 223     AVAHI_WARN_UNSUPPORTED;
 224     return SW_E_NO_IMPL;
 225 }
 226
 227 sw_result sw_multicast_socket_init(
 228     sw_socket * self) {
 229     AVAHI_WARN_UNSUPPORTED;
 230     return SW_E_NO_IMPL;
 231 }
 232
 233 sw_result sw_socket_fina(sw_socket self) {
 234     AVAHI_WARN_UNSUPPORTED;
 235     return SW_E_NO_IMPL;
 236 }
 237
 238 sw_result sw_socket_bind(
 239     sw_socket self,
 240     sw_ipv4_address address,
 241     sw_port port) {
 242     AVAHI_WARN_UNSUPPORTED;
 243     return SW_E_NO_IMPL;
 244 }
 245
 246 sw_result sw_socket_join_multicast_group(
 247     sw_socket self,
 248     sw_ipv4_address local_address,
 249     sw_ipv4_address multicast_address,
 250     sw_uint32 ttl) {
 251     AVAHI_WARN_UNSUPPORTED;
 252     return SW_E_NO_IMPL;
 253 }
 254
 255 sw_result sw_socket_leave_multicast_group(sw_socket self) {
 256     AVAHI_WARN_UNSUPPORTED;
 257     return SW_E_NO_IMPL;
 258 }
 259
 260 sw_result sw_socket_listen(
 261     sw_socket self,
 262     int qsize) {
 263     AVAHI_WARN_UNSUPPORTED;
 264     return SW_E_NO_IMPL;
 265 }
 266
 267 sw_result sw_socket_connect(
 268     sw_socket self,
 269     sw_ipv4_address address,
 270     sw_port port) {
 271     AVAHI_WARN_UNSUPPORTED;
 272     return SW_E_NO_IMPL;
 273 }
 274
 275 sw_result sw_socket_accept(
 276     sw_socket self,
 277     sw_socket * socket) {
 278     AVAHI_WARN_UNSUPPORTED;
 279     return SW_E_NO_IMPL;
 280 }
 281
 282 sw_result sw_socket_send(
 283     sw_socket self,
 284     sw_octets buffer,
 285     sw_size_t len,
 286     sw_size_t * bytesWritten) {
 287     AVAHI_WARN_UNSUPPORTED;
 288     return SW_E_NO_IMPL;
 289 }
 290
 291 sw_result sw_socket_sendto(
 292     sw_socket self,
 293     sw_octets buffer,
 294     sw_size_t len,
 295     sw_size_t * bytesWritten,
 296     sw_ipv4_address to,
 297     sw_port port) {
 298     AVAHI_WARN_UNSUPPORTED;
 299     return SW_E_NO_IMPL;
 300 }
 301
 302 sw_result sw_socket_recv(
 303     sw_socket self,
 304     sw_octets buffer,
 305     sw_size_t max,
 306     sw_size_t * len) {
 307     AVAHI_WARN_UNSUPPORTED;
 308     return SW_E_NO_IMPL;
 309 }
 310
 311 sw_result sw_socket_recvfrom(
 312     sw_socket self,
 313     sw_octets buffer,
 314     sw_size_t max,
 315     sw_size_t * len,
 316     sw_ipv4_address * from,
 317     sw_port * port,
 318     sw_ipv4_address * dest,
 319     sw_uint32 * interface_index) {
 320     AVAHI_WARN_UNSUPPORTED;
 321     return SW_E_NO_IMPL;
 322 }
 323
 324 sw_result sw_socket_set_blocking_mode(
 325     sw_socket self,
 326     sw_bool blocking_mode) {
 327     AVAHI_WARN_UNSUPPORTED;
 328     return SW_E_NO_IMPL;
 329 }
 330
 331 sw_result sw_socket_set_options(
 332     sw_socket self,
 333     sw_socket_options options) {
 334     AVAHI_WARN_UNSUPPORTED;
 335     return SW_E_NO_IMPL;
 336 }
 337
 338 sw_ipv4_address sw_socket_ipv4_address(sw_socket self) {
 339     AVAHI_WARN_UNSUPPORTED_ABORT;
 340 }
 341
 342 sw_port sw_socket_port(sw_socket self) {
 343     AVAHI_WARN_UNSUPPORTED_ABORT;
 344 }
 345
 346 sw_sockdesc_t sw_socket_desc(sw_socket self) {
 347     AVAHI_WARN_UNSUPPORTED_ABORT;
 348 }
 349
 350 sw_result sw_socket_close(sw_socket self) {
 351     AVAHI_WARN_UNSUPPORTED;
 352     return SW_E_NO_IMPL;
 353 }
 354
 355 sw_result sw_socket_options_init(sw_socket_options * self) {
 356     AVAHI_WARN_UNSUPPORTED;
 357     return SW_E_NO_IMPL;
 358 }
 359
 360 sw_result sw_socket_options_fina(sw_socket_options self) {
 361     AVAHI_WARN_UNSUPPORTED;
 362     return SW_E_NO_IMPL;
 363 }
 364
 365 sw_result sw_socket_options_set_debug(
 366     sw_socket_options self,
 367     sw_bool val) {
 368     AVAHI_WARN_UNSUPPORTED;
 369     return SW_E_NO_IMPL;
 370 }
 371
 372 sw_result sw_socket_options_set_nodelay(
 373     sw_socket_options self,
 374     sw_bool val) {
 375     AVAHI_WARN_UNSUPPORTED;
 376     return SW_E_NO_IMPL;
 377 }
 378
 379 sw_result sw_socket_options_set_dontroute(
 380     sw_socket_options self,
 381     sw_bool val) {
 382     AVAHI_WARN_UNSUPPORTED;
 383     return SW_E_NO_IMPL;
 384 }
 385
 386 sw_result sw_socket_options_set_keepalive(
 387     sw_socket_options self,
 388     sw_bool val) {
 389     AVAHI_WARN_UNSUPPORTED;
 390     return SW_E_NO_IMPL;
 391 }
 392
 393 sw_result sw_socket_options_set_linger(
 394     sw_socket_options self,
 395     sw_bool onoff,
 396     sw_uint32 linger) {
 397     AVAHI_WARN_UNSUPPORTED;
 398     return SW_E_NO_IMPL;
 399 }
 400
 401 sw_result sw_socket_options_set_reuseaddr(
 402     sw_socket_options self,
 403     sw_bool val) {
 404     AVAHI_WARN_UNSUPPORTED;
 405     return SW_E_NO_IMPL;
 406 }
 407
 408 sw_result sw_socket_options_set_rcvbuf(
 409     sw_socket_options self,
 410     sw_uint32 val) {
 411     AVAHI_WARN_UNSUPPORTED;
 412     return SW_E_NO_IMPL;
 413 }
 414
 415 sw_result sw_socket_options_set_sndbuf(
 416     sw_socket_options self,
 417     sw_uint32 val) {
 418     AVAHI_WARN_UNSUPPORTED;
 419     return SW_E_NO_IMPL;
 420 }
 421
 422 int sw_socket_error_code(void) {
 423     AVAHI_WARN_UNSUPPORTED_ABORT;
 424 }
 425
 426 sw_result sw_corby_orb_init(
 427     sw_corby_orb * self,
 428     sw_salt salt,
 429     const sw_corby_orb_config * config,
 430     sw_corby_orb_observer observer,
 431     sw_corby_orb_observer_func func,
 432     sw_opaque_t extra) {
 433     AVAHI_WARN_UNSUPPORTED;
 434     return SW_E_NO_IMPL;
 435 }
 436
 437 sw_result sw_corby_orb_fina(sw_corby_orb self) {
 438     AVAHI_WARN_UNSUPPORTED;
 439     return SW_E_NO_IMPL;
 440 }
 441
 442 sw_result sw_corby_orb_register_servant(
 443     sw_corby_orb self,
 444     sw_corby_servant servant,
 445     sw_corby_servant_cb cb,
 446     sw_const_string oid,
 447     struct _sw_corby_object ** object,
 448     sw_const_string protocol_name) {
 449     AVAHI_WARN_UNSUPPORTED;
 450     return SW_E_NO_IMPL;
 451 }
 452
 453 sw_result sw_corby_orb_unregister_servant(
 454     sw_corby_orb self,
 455     sw_const_string oid) {
 456     AVAHI_WARN_UNSUPPORTED;
 457     return SW_E_NO_IMPL;
 458 }
 459
 460 sw_result sw_corby_orb_register_bidirectional_object(
 461     sw_corby_orb self,
 462     struct _sw_corby_object * object) {
 463     AVAHI_WARN_UNSUPPORTED;
 464     return SW_E_NO_IMPL;
 465 }
 466
 467 sw_result sw_corby_orb_register_channel(
 468     sw_corby_orb self,
 469     struct _sw_corby_channel * channel) {
 470     AVAHI_WARN_UNSUPPORTED;
 471     return SW_E_NO_IMPL;
 472 }
 473
 474 sw_corby_orb_delegate sw_corby_orb_get_delegate(sw_corby_orb self) {
 475     AVAHI_WARN_UNSUPPORTED_ABORT;
 476 }
 477
 478 sw_result sw_corby_orb_set_delegate(
 479     sw_corby_orb self,
 480     sw_corby_orb_delegate delegate) {
 481     AVAHI_WARN_UNSUPPORTED;
 482     return SW_E_NO_IMPL;
 483 }
 484
 485 sw_result sw_corby_orb_set_observer(
 486     sw_corby_orb self,
 487     sw_corby_orb_observer observer,
 488     sw_corby_orb_observer_func func,
 489     sw_opaque_t extra) {
 490     AVAHI_WARN_UNSUPPORTED;
 491     return SW_E_NO_IMPL;
 492 }
 493
 494 sw_result sw_corby_orb_protocol_to_address(
 495     sw_corby_orb self,
 496     sw_const_string tag,
 497     sw_string addr,
 498     sw_port * port) {
 499     AVAHI_WARN_UNSUPPORTED;
 500     return SW_E_NO_IMPL;
 501 }
 502
 503 sw_result sw_corby_orb_protocol_to_url(
 504     sw_corby_orb self,
 505     sw_const_string tag,
 506     sw_const_string name,
 507     sw_string url,
 508     sw_size_t url_len) {
 509     AVAHI_WARN_UNSUPPORTED;
 510     return SW_E_NO_IMPL;
 511 }
 512
 513 sw_result sw_corby_orb_read_channel(
 514     sw_corby_orb self,
 515     struct _sw_corby_channel * channel) {
 516     AVAHI_WARN_UNSUPPORTED;
 517     return SW_E_NO_IMPL;
 518 }
 519
 520 sw_result sw_corby_orb_dispatch_message(
 521     sw_corby_orb self,
 522     struct _sw_corby_channel * channel,
 523     struct _sw_corby_message * message,
 524     struct _sw_corby_buffer * buffer,
 525     sw_uint8 endian) {
 526     AVAHI_WARN_UNSUPPORTED;
 527     return SW_E_NO_IMPL;
 528 }
 529
 530 sw_result sw_corby_message_init(sw_corby_message * self) {
 531     AVAHI_WARN_UNSUPPORTED;
 532     return SW_E_NO_IMPL;
 533 }
 534
 535 sw_result sw_corby_message_fina(sw_corby_message self) {
 536     AVAHI_WARN_UNSUPPORTED;
 537     return SW_E_NO_IMPL;
 538 }
 539
 540 sw_result sw_corby_buffer_init(sw_corby_buffer * self) {
 541     AVAHI_WARN_UNSUPPORTED;
 542     return SW_E_NO_IMPL;
 543 }
 544
 545 sw_result sw_corby_buffer_init_with_size(
 546     sw_corby_buffer * self,
 547     sw_size_t size) {
 548     AVAHI_WARN_UNSUPPORTED;
 549     return SW_E_NO_IMPL;
 550 }
 551
 552 sw_result sw_corby_buffer_init_with_delegate(
 553     sw_corby_buffer * self,
 554     sw_corby_buffer_delegate delegate,
 555     sw_corby_buffer_overflow_func overflow,
 556     sw_corby_buffer_underflow_func underflow,
 557     sw_opaque_t extra) {
 558     AVAHI_WARN_UNSUPPORTED;
 559     return SW_E_NO_IMPL;
 560 }
 561
 562 sw_result sw_corby_buffer_init_with_size_and_delegate(
 563     sw_corby_buffer * self,
 564     sw_size_t size,
 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_fina(sw_corby_buffer self) {
 574     AVAHI_WARN_UNSUPPORTED;
 575     return SW_E_NO_IMPL;
 576 }
 577
 578 void sw_corby_buffer_reset(sw_corby_buffer self) {
 579     AVAHI_WARN_UNSUPPORTED;
 580 }
 581
 582 sw_result sw_corby_buffer_set_octets(
 583     sw_corby_buffer self,
 584     sw_octets octets,
 585     sw_size_t size) {
 586     AVAHI_WARN_UNSUPPORTED;
 587     return SW_E_NO_IMPL;
 588 }
 589
 590 sw_octets sw_corby_buffer_octets(sw_corby_buffer self) {
 591     AVAHI_WARN_UNSUPPORTED;
 592     return NULL;
 593 }
 594
 595 sw_size_t sw_corby_buffer_bytes_used(sw_corby_buffer self) {
 596     AVAHI_WARN_UNSUPPORTED;
 597     return 0;
 598 }
 599
 600 sw_size_t sw_corby_buffer_size(sw_corby_buffer self) {
 601     AVAHI_WARN_UNSUPPORTED;
 602     return 0;
 603 }
 604
 605 sw_result sw_corby_buffer_put_int8(sw_corby_buffer self, sw_int8 val) {
 606     AVAHI_WARN_UNSUPPORTED;
 607     return SW_E_NO_IMPL;
 608 }
 609
 610 sw_result sw_corby_buffer_put_uint8(
 611     sw_corby_buffer self,
 612     sw_uint8 val) {
 613     AVAHI_WARN_UNSUPPORTED;
 614     return SW_E_NO_IMPL;
 615 }
 616
 617 sw_result sw_corby_buffer_put_int16(
 618     sw_corby_buffer self,
 619     sw_int16 val) {
 620     AVAHI_WARN_UNSUPPORTED;
 621     return SW_E_NO_IMPL;
 622 }
 623
 624 sw_result sw_corby_buffer_put_uint16(
 625     sw_corby_buffer self,
 626     sw_uint16 val) {
 627     AVAHI_WARN_UNSUPPORTED;
 628     return SW_E_NO_IMPL;
 629 }
 630
 631 sw_result sw_corby_buffer_put_int32(
 632     sw_corby_buffer self,
 633     sw_int32 val) {
 634     AVAHI_WARN_UNSUPPORTED;
 635     return SW_E_NO_IMPL;
 636 }
 637
 638 sw_result sw_corby_buffer_put_uint32(
 639     sw_corby_buffer self,
 640     sw_uint32 val) {
 641     AVAHI_WARN_UNSUPPORTED;
 642     return SW_E_NO_IMPL;
 643 }
 644
 645 sw_result sw_corby_buffer_put_octets(
 646     sw_corby_buffer self,
 647     sw_const_octets val,
 648     sw_size_t size) {
 649     AVAHI_WARN_UNSUPPORTED;
 650     return SW_E_NO_IMPL;
 651 }
 652
 653 sw_result sw_corby_buffer_put_sized_octets(
 654     sw_corby_buffer self,
 655     sw_const_octets val,
 656     sw_uint32 len) {
 657     AVAHI_WARN_UNSUPPORTED;
 658     return SW_E_NO_IMPL;
 659 }
 660
 661 sw_result sw_corby_buffer_put_cstring(
 662     sw_corby_buffer self,
 663     sw_const_string val) {
 664     AVAHI_WARN_UNSUPPORTED;
 665     return SW_E_NO_IMPL;
 666 }
 667
 668 sw_result sw_corby_buffer_put_object(
 669     sw_corby_buffer self,
 670     const struct _sw_corby_object * object) {
 671     AVAHI_WARN_UNSUPPORTED;
 672     return SW_E_NO_IMPL;
 673 }
 674
 675 sw_result sw_corby_buffer_put_pad(
 676     sw_corby_buffer self,
 677     sw_corby_buffer_pad pad) {
 678     AVAHI_WARN_UNSUPPORTED;
 679     return SW_E_NO_IMPL;
 680 }
 681
 682 sw_result sw_corby_buffer_get_int8(
 683     sw_corby_buffer self,
 684     sw_int8 * val) {
 685     AVAHI_WARN_UNSUPPORTED;
 686     return SW_E_NO_IMPL;
 687 }
 688
 689 sw_result sw_corby_buffer_get_uint8(
 690     sw_corby_buffer self,
 691     sw_uint8 * val) {
 692     AVAHI_WARN_UNSUPPORTED;
 693     return SW_E_NO_IMPL;
 694 }
 695
 696 sw_result sw_corby_buffer_get_int16(
 697     sw_corby_buffer self,
 698     sw_int16 * val,
 699     sw_uint8 endian) {
 700     AVAHI_WARN_UNSUPPORTED;
 701     return SW_E_NO_IMPL;
 702 }
 703
 704 sw_result sw_corby_buffer_get_uint16(
 705     sw_corby_buffer self,
 706     sw_uint16 * val,
 707     sw_uint8 endian) {
 708     AVAHI_WARN_UNSUPPORTED;
 709     return SW_E_NO_IMPL;
 710 }
 711
 712 sw_result sw_corby_buffer_get_int32(
 713     sw_corby_buffer self,
 714     sw_int32 * val,
 715     sw_uint8 endian) {
 716     AVAHI_WARN_UNSUPPORTED;
 717     return SW_E_NO_IMPL;
 718 }
 719
 720 sw_result sw_corby_buffer_get_uint32(
 721     sw_corby_buffer self,
 722     sw_uint32 * val,
 723     sw_uint8 endian) {
 724     AVAHI_WARN_UNSUPPORTED;
 725     return SW_E_NO_IMPL;
 726 }
 727
 728 sw_result sw_corby_buffer_get_octets(
 729     sw_corby_buffer self,
 730     sw_octets octets,
 731     sw_size_t size) {
 732     AVAHI_WARN_UNSUPPORTED;
 733     return SW_E_NO_IMPL;
 734 }
 735
 736 sw_result sw_corby_buffer_allocate_and_get_sized_octets(
 737     sw_corby_buffer self,
 738     sw_octets * val,
 739     sw_uint32 * size,
 740     sw_uint8 endian) {
 741     AVAHI_WARN_UNSUPPORTED;
 742     return SW_E_NO_IMPL;
 743 }
 744
 745 sw_result sw_corby_buffer_get_zerocopy_sized_octets(
 746     sw_corby_buffer self,
 747     sw_octets * val,
 748     sw_uint32 * size,
 749     sw_uint8 endian) {
 750     AVAHI_WARN_UNSUPPORTED;
 751     return SW_E_NO_IMPL;
 752 }
 753
 754 sw_result sw_corby_buffer_get_sized_octets(
 755     sw_corby_buffer self,
 756     sw_octets val,
 757     sw_uint32 * len,
 758     sw_uint8 endian) {
 759     AVAHI_WARN_UNSUPPORTED;
 760     return SW_E_NO_IMPL;
 761 }
 762
 763 sw_result sw_corby_buffer_allocate_and_get_cstring(
 764     sw_corby_buffer self,
 765     sw_string * val,
 766     sw_uint32 * len,
 767     sw_uint8 endian) {
 768     AVAHI_WARN_UNSUPPORTED;
 769     return SW_E_NO_IMPL;
 770 }
 771
 772 sw_result sw_corby_buffer_get_zerocopy_cstring(
 773     sw_corby_buffer self,
 774     sw_string * val,
 775     sw_uint32 * len,
 776     sw_uint8 endian) {
 777     AVAHI_WARN_UNSUPPORTED;
 778     return SW_E_NO_IMPL;
 779 }
 780
 781 sw_result sw_corby_buffer_get_cstring(
 782     sw_corby_buffer self,
 783     sw_string val,
 784     sw_uint32 * len,
 785     sw_uint8 endian) {
 786     AVAHI_WARN_UNSUPPORTED;
 787     return SW_E_NO_IMPL;
 788 }
 789
 790 sw_result sw_corby_buffer_get_object(
 791     sw_corby_buffer self,
 792     struct _sw_corby_object ** object,
 793     sw_uint8 endian) {
 794     AVAHI_WARN_UNSUPPORTED;
 795     return SW_E_NO_IMPL;
 796 }
 797
 798 sw_result sw_corby_channel_start_request(
 799     sw_corby_channel self,
 800     sw_const_corby_profile profile,
 801     struct _sw_corby_buffer ** buffer,
 802     sw_const_string op,
 803     sw_uint32 oplen,
 804     sw_bool reply_expected) {
 805     AVAHI_WARN_UNSUPPORTED;
 806     return SW_E_NO_IMPL;
 807 }
 808
 809 sw_result sw_corby_channel_start_reply(
 810     sw_corby_channel self,
 811     struct _sw_corby_buffer ** buffer,
 812     sw_uint32 request_id,
 813     sw_corby_reply_status status) {
 814     AVAHI_WARN_UNSUPPORTED;
 815     return SW_E_NO_IMPL;
 816 }
 817
 818 sw_result sw_corby_channel_send(
 819     sw_corby_channel self,
 820     struct _sw_corby_buffer * buffer,
 821     sw_corby_buffer_observer observer,
 822     sw_corby_buffer_written_func func,
 823     sw_opaque_t extra) {
 824     AVAHI_WARN_UNSUPPORTED;
 825     return SW_E_NO_IMPL;
 826 }
 827
 828 sw_result sw_corby_channel_recv(
 829     sw_corby_channel self,
 830     sw_salt * salt,
 831     struct _sw_corby_message ** message,
 832     sw_uint32 * request_id,
 833     sw_string * op,
 834     sw_uint32 * op_len,
 835     struct _sw_corby_buffer ** buffer,
 836     sw_uint8 * endian,
 837     sw_bool block) {
 838     AVAHI_WARN_UNSUPPORTED;
 839     return SW_E_NO_IMPL;
 840 }
 841
 842 sw_result sw_corby_channel_last_recv_from(
 843     sw_corby_channel self,
 844     sw_ipv4_address * from,
 845     sw_port * from_port) {
 846     AVAHI_WARN_UNSUPPORTED;
 847     return SW_E_NO_IMPL;
 848 }
 849
 850 sw_result sw_corby_channel_ff(
 851     sw_corby_channel self,
 852     struct _sw_corby_buffer * buffer) {
 853     AVAHI_WARN_UNSUPPORTED;
 854     return SW_E_NO_IMPL;
 855 }
 856
 857 sw_socket sw_corby_channel_socket(sw_corby_channel self) {
 858     AVAHI_WARN_UNSUPPORTED;
 859     return SW_E_NO_IMPL;
 860 }
 861
 862 sw_result sw_corby_channel_retain(sw_corby_channel self) {
 863     AVAHI_WARN_UNSUPPORTED;
 864     return SW_E_NO_IMPL;
 865 }
 866
 867 sw_result sw_corby_channel_set_delegate(
 868     sw_corby_channel self,
 869     sw_corby_channel_delegate delegate) {
 870     AVAHI_WARN_UNSUPPORTED;
 871     return SW_E_NO_IMPL;
 872 }
 873
 874 sw_corby_channel_delegate sw_corby_channel_get_delegate(
 875     sw_corby_channel self) {
 876     AVAHI_WARN_UNSUPPORTED_ABORT;
 877 }
 878
 879 void sw_corby_channel_set_app_data(
 880     sw_corby_channel self,
 881     sw_opaque app_data) {
 882     AVAHI_WARN_UNSUPPORTED;
 883 }
 884
 885 sw_opaque sw_corby_channel_get_app_data(sw_corby_channel self) {
 886     AVAHI_WARN_UNSUPPORTED_ABORT;
 887 }
 888
 889 sw_result sw_corby_channel_fina(sw_corby_channel self) {
 890     AVAHI_WARN_UNSUPPORTED;
 891     return SW_E_NO_IMPL;
 892 }
 893
 894 sw_result sw_corby_object_init_from_url(
 895     sw_corby_object * self,
 896     struct _sw_corby_orb * orb,
 897     sw_const_string url,
 898     sw_socket_options options,
 899     sw_uint32 bufsize) {
 900     AVAHI_WARN_UNSUPPORTED;
 901     return SW_E_NO_IMPL;
 902 }
 903
 904 sw_result sw_corby_object_fina(
 905     sw_corby_object self) {
 906     AVAHI_WARN_UNSUPPORTED;
 907     return SW_E_NO_IMPL;
 908 }
 909
 910 sw_result sw_corby_object_start_request(
 911     sw_corby_object self,
 912     sw_const_string op,
 913     sw_uint32 op_len,
 914     sw_bool reply_expected,
 915     sw_corby_buffer * buffer) {
 916     AVAHI_WARN_UNSUPPORTED;
 917     return SW_E_NO_IMPL;
 918 }
 919
 920 sw_result sw_corby_object_send(
 921     sw_corby_object self,
 922     sw_corby_buffer buffer,
 923     sw_corby_buffer_observer observer,
 924     sw_corby_buffer_written_func func,
 925     sw_opaque extra) {
 926     AVAHI_WARN_UNSUPPORTED;
 927     return SW_E_NO_IMPL;
 928 }
 929
 930 sw_result sw_corby_object_recv(
 931     sw_corby_object self,
 932     sw_corby_message * message,
 933     sw_corby_buffer * buffer,
 934     sw_uint8 * endian,
 935     sw_bool block) {
 936     AVAHI_WARN_UNSUPPORTED;
 937     return SW_E_NO_IMPL;
 938 }
 939
 940 sw_result sw_corby_object_channel(
 941     sw_corby_object self,
 942     sw_corby_channel * channel) {
 943     AVAHI_WARN_UNSUPPORTED;
 944     return SW_E_NO_IMPL;
 945 }
 946
 947 sw_result sw_corby_object_set_channel(
 948     sw_corby_object self,
 949     sw_corby_channel channel) {
 950     AVAHI_WARN_UNSUPPORTED;
 951     return SW_E_NO_IMPL;
 952 }
 953
 954 sw_result sw_discovery_publish_host(
 955     sw_discovery self,
 956     sw_uint32 interface_index,
 957     sw_const_string name,
 958     sw_const_string domain,
 959     sw_ipv4_address address,
 960     sw_discovery_publish_reply reply,
 961     sw_opaque extra,
 962     sw_discovery_oid * oid) {
 963     AVAHI_WARN_UNSUPPORTED;
 964     return SW_E_NO_IMPL;
 965 }
 966
 967 sw_result sw_discovery_publish_update(
 968     sw_discovery self,
 969     sw_discovery_oid oid,
 970     sw_octets text_record,
 971     sw_uint32 text_record_len) {
 972     AVAHI_WARN_UNSUPPORTED;
 973     return SW_E_NO_IMPL;
 974 }
 975
 976 sw_result sw_discovery_query_record(
 977     sw_discovery self,
 978     sw_uint32 interface_index,
 979     sw_uint32 flags,
 980     sw_const_string fullname,
 981     sw_uint16 rrtype,
 982     sw_uint16 rrclass,
 983     sw_discovery_query_record_reply reply,
 984     sw_opaque extra,
 985     sw_discovery_oid * oid) {
 986     AVAHI_WARN_UNSUPPORTED;
 987     return SW_E_NO_IMPL;
 988 }
 989
 990 sw_result sw_text_record_string_iterator_init(
 991     sw_text_record_string_iterator * self,
 992     sw_const_string text_record_string) {
 993     AVAHI_WARN_UNSUPPORTED;
 994     return SW_E_NO_IMPL;
 995 }
 996
 997 sw_result sw_text_record_string_iterator_fina(
 998     sw_text_record_string_iterator self) {
 999     AVAHI_WARN_UNSUPPORTED;
1000     return SW_E_NO_IMPL;
1001 }
1002
1003 sw_result sw_text_record_string_iterator_next(
1004     sw_text_record_string_iterator self,
1005     char key[255],
1006     char val[255]) {
1007     AVAHI_WARN_UNSUPPORTED;
1008     return SW_E_NO_IMPL;
1009 }