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