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_ipv4_address sw_ipv4_address_any(void) {
 236     AVAHI_WARN_UNSUPPORTED_ABORT;
 237 }
 238
 239 sw_ipv4_address sw_ipv4_address_loopback(void) {
 240     AVAHI_WARN_UNSUPPORTED_ABORT;
 241 }
 242
 243 sw_result sw_ipv4_address_init(sw_ipv4_address * self) {
 244     AVAHI_WARN_UNSUPPORTED;
 245     return SW_DISCOVERY_E_NOT_SUPPORTED;
 246 }
 247
 248 sw_result sw_ipv4_address_init_from_saddr(
 249     sw_ipv4_address * self,
 250     sw_saddr saddr) {
 251     AVAHI_WARN_UNSUPPORTED;
 252     return SW_DISCOVERY_E_NOT_SUPPORTED;
 253 }
 254
 255 sw_result sw_ipv4_address_init_from_name(
 256     sw_ipv4_address * self,
 257     sw_const_string name) {
 258     AVAHI_WARN_UNSUPPORTED;
 259     return SW_DISCOVERY_E_NOT_SUPPORTED;
 260 }
 261
 262 sw_result sw_ipv4_address_init_from_address(
 263     sw_ipv4_address * self,
 264     sw_ipv4_address addr) {
 265     AVAHI_WARN_UNSUPPORTED;
 266     return SW_DISCOVERY_E_NOT_SUPPORTED;
 267 }
 268
 269 sw_result sw_ipv4_address_init_from_this_host(sw_ipv4_address * self) {
 270     AVAHI_WARN_UNSUPPORTED;
 271     return SW_DISCOVERY_E_NOT_SUPPORTED;
 272 }
 273
 274 sw_result sw_ipv4_address_fina(sw_ipv4_address self) {
 275     AVAHI_WARN_UNSUPPORTED;
 276     return SW_DISCOVERY_E_NOT_SUPPORTED;
 277 }
 278
 279 sw_bool sw_ipv4_address_is_any(sw_ipv4_address self) {
 280     AVAHI_WARN_UNSUPPORTED_ABORT;
 281 }
 282
 283 sw_saddr sw_ipv4_address_saddr(sw_ipv4_address self) {
 284     AVAHI_WARN_UNSUPPORTED_ABORT;
 285 }
 286
 287 sw_string sw_ipv4_address_name(
 288     sw_ipv4_address self,
 289     sw_string name,
 290     sw_uint32 len) {
 291     AVAHI_WARN_UNSUPPORTED;
 292     return NULL;
 293 }
 294
 295 sw_result sw_ipv4_address_decompose(
 296     sw_ipv4_address self,
 297     sw_uint8 * a1,
 298     sw_uint8 * a2,
 299     sw_uint8 * a3,
 300     sw_uint8 * a4) {
 301     AVAHI_WARN_UNSUPPORTED;
 302     return SW_DISCOVERY_E_NOT_SUPPORTED;
 303 }
 304
 305 sw_bool sw_ipv4_address_equals(
 306     sw_ipv4_address self,
 307     sw_ipv4_address addr) {
 308     AVAHI_WARN_UNSUPPORTED_ABORT;
 309 }
 310
 311 sw_result sw_tcp_socket_init(sw_socket * self) {
 312     AVAHI_WARN_UNSUPPORTED;
 313     return SW_DISCOVERY_E_NOT_SUPPORTED;
 314 }
 315
 316 sw_result sw_tcp_socket_init_with_desc(
 317     sw_socket * self,
 318     sw_sockdesc_t desc) {
 319     AVAHI_WARN_UNSUPPORTED;
 320     return SW_DISCOVERY_E_NOT_SUPPORTED;
 321 }
 322
 323 sw_result sw_udp_socket_init(
 324     sw_socket * self) {
 325     AVAHI_WARN_UNSUPPORTED;
 326     return SW_DISCOVERY_E_NOT_SUPPORTED;
 327 }
 328
 329 sw_result sw_multicast_socket_init(
 330     sw_socket * self) {
 331     AVAHI_WARN_UNSUPPORTED;
 332     return SW_DISCOVERY_E_NOT_SUPPORTED;
 333 }
 334
 335 sw_result sw_socket_fina(sw_socket self) {
 336     AVAHI_WARN_UNSUPPORTED;
 337     return SW_DISCOVERY_E_NOT_SUPPORTED;
 338 }
 339
 340 sw_result sw_socket_bind(
 341     sw_socket self,
 342     sw_ipv4_address address,
 343     sw_port port) {
 344     AVAHI_WARN_UNSUPPORTED;
 345     return SW_DISCOVERY_E_NOT_SUPPORTED;
 346 }
 347
 348 sw_result sw_socket_join_multicast_group(
 349     sw_socket self,
 350     sw_ipv4_address local_address,
 351     sw_ipv4_address multicast_address,
 352     sw_uint32 ttl) {
 353     AVAHI_WARN_UNSUPPORTED;
 354     return SW_DISCOVERY_E_NOT_SUPPORTED;
 355 }
 356
 357 sw_result sw_socket_leave_multicast_group(sw_socket self) {
 358     AVAHI_WARN_UNSUPPORTED;
 359     return SW_DISCOVERY_E_NOT_SUPPORTED;
 360 }
 361
 362 sw_result sw_socket_listen(
 363     sw_socket self,
 364     int qsize) {
 365     AVAHI_WARN_UNSUPPORTED;
 366     return SW_DISCOVERY_E_NOT_SUPPORTED;
 367 }
 368
 369 sw_result sw_socket_connect(
 370     sw_socket self,
 371     sw_ipv4_address address,
 372     sw_port port) {
 373     AVAHI_WARN_UNSUPPORTED;
 374     return SW_DISCOVERY_E_NOT_SUPPORTED;
 375 }
 376
 377 sw_result sw_socket_accept(
 378     sw_socket self,
 379     sw_socket * socket) {
 380     AVAHI_WARN_UNSUPPORTED;
 381     return SW_DISCOVERY_E_NOT_SUPPORTED;
 382 }
 383
 384 sw_result sw_socket_send(
 385     sw_socket self,
 386     sw_octets buffer,
 387     sw_size_t len,
 388     sw_size_t * bytesWritten) {
 389     AVAHI_WARN_UNSUPPORTED;
 390     return SW_DISCOVERY_E_NOT_SUPPORTED;
 391 }
 392
 393 sw_result sw_socket_sendto(
 394     sw_socket self,
 395     sw_octets buffer,
 396     sw_size_t len,
 397     sw_size_t * bytesWritten,
 398     sw_ipv4_address to,
 399     sw_port port) {
 400     AVAHI_WARN_UNSUPPORTED;
 401     return SW_DISCOVERY_E_NOT_SUPPORTED;
 402 }
 403
 404 sw_result sw_socket_recv(
 405     sw_socket self,
 406     sw_octets buffer,
 407     sw_size_t max,
 408     sw_size_t * len) {
 409     AVAHI_WARN_UNSUPPORTED;
 410     return SW_DISCOVERY_E_NOT_SUPPORTED;
 411 }
 412
 413 sw_result sw_socket_recvfrom(
 414     sw_socket self,
 415     sw_octets buffer,
 416     sw_size_t max,
 417     sw_size_t * len,
 418     sw_ipv4_address * from,
 419     sw_port * port,
 420     sw_ipv4_address * dest,
 421     sw_uint32 * interface_index) {
 422     AVAHI_WARN_UNSUPPORTED;
 423     return SW_DISCOVERY_E_NOT_SUPPORTED;
 424 }
 425
 426 sw_result sw_socket_set_blocking_mode(
 427     sw_socket self,
 428     sw_bool blocking_mode) {
 429     AVAHI_WARN_UNSUPPORTED;
 430     return SW_DISCOVERY_E_NOT_SUPPORTED;
 431 }
 432
 433 sw_result sw_socket_set_options(
 434     sw_socket self,
 435     sw_socket_options options) {
 436     AVAHI_WARN_UNSUPPORTED;
 437     return SW_DISCOVERY_E_NOT_SUPPORTED;
 438 }
 439
 440 sw_ipv4_address sw_socket_ipv4_address(sw_socket self) {
 441     AVAHI_WARN_UNSUPPORTED_ABORT;
 442 }
 443
 444 sw_port sw_socket_port(sw_socket self) {
 445     AVAHI_WARN_UNSUPPORTED_ABORT;
 446 }
 447
 448 sw_sockdesc_t sw_socket_desc(sw_socket self) {
 449     AVAHI_WARN_UNSUPPORTED_ABORT;
 450 }
 451
 452 sw_result sw_socket_close(sw_socket self) {
 453     AVAHI_WARN_UNSUPPORTED;
 454     return SW_DISCOVERY_E_NOT_SUPPORTED;
 455 }
 456
 457 sw_result sw_socket_options_init(sw_socket_options * self) {
 458     AVAHI_WARN_UNSUPPORTED;
 459     return SW_DISCOVERY_E_NOT_SUPPORTED;
 460 }
 461
 462 sw_result sw_socket_options_fina(sw_socket_options self) {
 463     AVAHI_WARN_UNSUPPORTED;
 464     return SW_DISCOVERY_E_NOT_SUPPORTED;
 465 }
 466
 467 sw_result sw_socket_options_set_debug(
 468     sw_socket_options self,
 469     sw_bool val) {
 470     AVAHI_WARN_UNSUPPORTED;
 471     return SW_DISCOVERY_E_NOT_SUPPORTED;
 472 }
 473
 474 sw_result sw_socket_options_set_nodelay(
 475     sw_socket_options self,
 476     sw_bool val) {
 477     AVAHI_WARN_UNSUPPORTED;
 478     return SW_DISCOVERY_E_NOT_SUPPORTED;
 479 }
 480
 481 sw_result sw_socket_options_set_dontroute(
 482     sw_socket_options self,
 483     sw_bool val) {
 484     AVAHI_WARN_UNSUPPORTED;
 485     return SW_DISCOVERY_E_NOT_SUPPORTED;
 486 }
 487
 488 sw_result sw_socket_options_set_keepalive(
 489     sw_socket_options self,
 490     sw_bool val) {
 491     AVAHI_WARN_UNSUPPORTED;
 492     return SW_DISCOVERY_E_NOT_SUPPORTED;
 493 }
 494
 495 sw_result sw_socket_options_set_linger(
 496     sw_socket_options self,
 497     sw_bool onoff,
 498     sw_uint32 linger) {
 499     AVAHI_WARN_UNSUPPORTED;
 500     return SW_DISCOVERY_E_NOT_SUPPORTED;
 501 }
 502
 503 sw_result sw_socket_options_set_reuseaddr(
 504     sw_socket_options self,
 505     sw_bool val) {
 506     AVAHI_WARN_UNSUPPORTED;
 507     return SW_DISCOVERY_E_NOT_SUPPORTED;
 508 }
 509
 510 sw_result sw_socket_options_set_rcvbuf(
 511     sw_socket_options self,
 512     sw_uint32 val) {
 513     AVAHI_WARN_UNSUPPORTED;
 514     return SW_DISCOVERY_E_NOT_SUPPORTED;
 515 }
 516
 517 sw_result sw_socket_options_set_sndbuf(
 518     sw_socket_options self,
 519     sw_uint32 val) {
 520     AVAHI_WARN_UNSUPPORTED;
 521     return SW_DISCOVERY_E_NOT_SUPPORTED;
 522 }
 523
 524 int sw_socket_error_code(void) {
 525     AVAHI_WARN_UNSUPPORTED_ABORT;
 526 }
 527
 528 sw_result sw_corby_orb_init(
 529     sw_corby_orb * self,
 530     sw_salt salt,
 531     const sw_corby_orb_config * config,
 532     sw_corby_orb_observer observer,
 533     sw_corby_orb_observer_func func,
 534     sw_opaque_t extra) {
 535     AVAHI_WARN_UNSUPPORTED;
 536     return SW_DISCOVERY_E_NOT_SUPPORTED;
 537 }
 538
 539 sw_result sw_corby_orb_fina(sw_corby_orb self) {
 540     AVAHI_WARN_UNSUPPORTED;
 541     return SW_DISCOVERY_E_NOT_SUPPORTED;
 542 }
 543
 544 sw_result sw_corby_orb_register_servant(
 545     sw_corby_orb self,
 546     sw_corby_servant servant,
 547     sw_corby_servant_cb cb,
 548     sw_const_string oid,
 549     struct _sw_corby_object ** object,
 550     sw_const_string protocol_name) {
 551     AVAHI_WARN_UNSUPPORTED;
 552     return SW_DISCOVERY_E_NOT_SUPPORTED;
 553 }
 554
 555 sw_result sw_corby_orb_unregister_servant(
 556     sw_corby_orb self,
 557     sw_const_string oid) {
 558     AVAHI_WARN_UNSUPPORTED;
 559     return SW_DISCOVERY_E_NOT_SUPPORTED;
 560 }
 561
 562 sw_result sw_corby_orb_register_bidirectional_object(
 563     sw_corby_orb self,
 564     struct _sw_corby_object * object) {
 565     AVAHI_WARN_UNSUPPORTED;
 566     return SW_DISCOVERY_E_NOT_SUPPORTED;
 567 }
 568
 569 sw_result sw_corby_orb_register_channel(
 570     sw_corby_orb self,
 571     struct _sw_corby_channel * channel) {
 572     AVAHI_WARN_UNSUPPORTED;
 573     return SW_DISCOVERY_E_NOT_SUPPORTED;
 574 }
 575
 576 sw_corby_orb_delegate sw_corby_orb_get_delegate(sw_corby_orb self) {
 577     AVAHI_WARN_UNSUPPORTED_ABORT;
 578 }
 579
 580 sw_result sw_corby_orb_set_delegate(
 581     sw_corby_orb self,
 582     sw_corby_orb_delegate delegate) {
 583     AVAHI_WARN_UNSUPPORTED;
 584     return SW_DISCOVERY_E_NOT_SUPPORTED;
 585 }
 586
 587 sw_result sw_corby_orb_set_observer(
 588     sw_corby_orb self,
 589     sw_corby_orb_observer observer,
 590     sw_corby_orb_observer_func func,
 591     sw_opaque_t extra) {
 592     AVAHI_WARN_UNSUPPORTED;
 593     return SW_DISCOVERY_E_NOT_SUPPORTED;
 594 }
 595
 596 sw_result sw_corby_orb_protocol_to_address(
 597     sw_corby_orb self,
 598     sw_const_string tag,
 599     sw_string addr,
 600     sw_port * port) {
 601     AVAHI_WARN_UNSUPPORTED;
 602     return SW_DISCOVERY_E_NOT_SUPPORTED;
 603 }
 604
 605 sw_result sw_corby_orb_protocol_to_url(
 606     sw_corby_orb self,
 607     sw_const_string tag,
 608     sw_const_string name,
 609     sw_string url,
 610     sw_size_t url_len) {
 611     AVAHI_WARN_UNSUPPORTED;
 612     return SW_DISCOVERY_E_NOT_SUPPORTED;
 613 }
 614
 615 sw_result sw_corby_orb_read_channel(
 616     sw_corby_orb self,
 617     struct _sw_corby_channel * channel) {
 618     AVAHI_WARN_UNSUPPORTED;
 619     return SW_DISCOVERY_E_NOT_SUPPORTED;
 620 }
 621
 622 sw_result sw_corby_orb_dispatch_message(
 623     sw_corby_orb self,
 624     struct _sw_corby_channel * channel,
 625     struct _sw_corby_message * message,
 626     struct _sw_corby_buffer * buffer,
 627     sw_uint8 endian) {
 628     AVAHI_WARN_UNSUPPORTED;
 629     return SW_DISCOVERY_E_NOT_SUPPORTED;
 630 }
 631
 632 sw_result sw_corby_message_init(sw_corby_message * self) {
 633     AVAHI_WARN_UNSUPPORTED;
 634     return SW_DISCOVERY_E_NOT_SUPPORTED;
 635 }
 636
 637 sw_result sw_corby_message_fina(sw_corby_message self) {
 638     AVAHI_WARN_UNSUPPORTED;
 639     return SW_DISCOVERY_E_NOT_SUPPORTED;
 640 }
 641
 642 sw_result sw_corby_buffer_init(sw_corby_buffer * self) {
 643     AVAHI_WARN_UNSUPPORTED;
 644     return SW_DISCOVERY_E_NOT_SUPPORTED;
 645 }
 646
 647 sw_result sw_corby_buffer_init_with_size(
 648     sw_corby_buffer * self,
 649     sw_size_t size) {
 650     AVAHI_WARN_UNSUPPORTED;
 651     return SW_DISCOVERY_E_NOT_SUPPORTED;
 652 }
 653
 654 sw_result sw_corby_buffer_init_with_delegate(
 655     sw_corby_buffer * self,
 656     sw_corby_buffer_delegate delegate,
 657     sw_corby_buffer_overflow_func overflow,
 658     sw_corby_buffer_underflow_func underflow,
 659     sw_opaque_t extra) {
 660     AVAHI_WARN_UNSUPPORTED;
 661     return SW_DISCOVERY_E_NOT_SUPPORTED;
 662 }
 663
 664 sw_result sw_corby_buffer_init_with_size_and_delegate(
 665     sw_corby_buffer * self,
 666     sw_size_t size,
 667     sw_corby_buffer_delegate delegate,
 668     sw_corby_buffer_overflow_func overflow,
 669     sw_corby_buffer_underflow_func underflow,
 670     sw_opaque_t extra) {
 671     AVAHI_WARN_UNSUPPORTED;
 672     return SW_DISCOVERY_E_NOT_SUPPORTED;
 673 }
 674
 675 sw_result sw_corby_buffer_fina(sw_corby_buffer self) {
 676     AVAHI_WARN_UNSUPPORTED;
 677     return SW_DISCOVERY_E_NOT_SUPPORTED;
 678 }
 679
 680 void sw_corby_buffer_reset(sw_corby_buffer self) {
 681     AVAHI_WARN_UNSUPPORTED;
 682 }
 683
 684 sw_result sw_corby_buffer_set_octets(
 685     sw_corby_buffer self,
 686     sw_octets octets,
 687     sw_size_t size) {
 688     AVAHI_WARN_UNSUPPORTED;
 689     return SW_DISCOVERY_E_NOT_SUPPORTED;
 690 }
 691
 692 sw_octets sw_corby_buffer_octets(sw_corby_buffer self) {
 693     AVAHI_WARN_UNSUPPORTED;
 694     return NULL;
 695 }
 696
 697 sw_size_t sw_corby_buffer_bytes_used(sw_corby_buffer self) {
 698     AVAHI_WARN_UNSUPPORTED;
 699     return 0;
 700 }
 701
 702 sw_size_t sw_corby_buffer_size(sw_corby_buffer self) {
 703     AVAHI_WARN_UNSUPPORTED;
 704     return 0;
 705 }
 706
 707 sw_result sw_corby_buffer_put_int8(sw_corby_buffer self, sw_int8 val) {
 708     AVAHI_WARN_UNSUPPORTED;
 709     return SW_DISCOVERY_E_NOT_SUPPORTED;
 710 }
 711
 712 sw_result sw_corby_buffer_put_uint8(
 713     sw_corby_buffer self,
 714     sw_uint8 val) {
 715     AVAHI_WARN_UNSUPPORTED;
 716     return SW_DISCOVERY_E_NOT_SUPPORTED;
 717 }
 718
 719 sw_result sw_corby_buffer_put_int16(
 720     sw_corby_buffer self,
 721     sw_int16 val) {
 722     AVAHI_WARN_UNSUPPORTED;
 723     return SW_DISCOVERY_E_NOT_SUPPORTED;
 724 }
 725
 726 sw_result sw_corby_buffer_put_uint16(
 727     sw_corby_buffer self,
 728     sw_uint16 val) {
 729     AVAHI_WARN_UNSUPPORTED;
 730     return SW_DISCOVERY_E_NOT_SUPPORTED;
 731 }
 732
 733 sw_result sw_corby_buffer_put_int32(
 734     sw_corby_buffer self,
 735     sw_int32 val) {
 736     AVAHI_WARN_UNSUPPORTED;
 737     return SW_DISCOVERY_E_NOT_SUPPORTED;
 738 }
 739
 740 sw_result sw_corby_buffer_put_uint32(
 741     sw_corby_buffer self,
 742     sw_uint32 val) {
 743     AVAHI_WARN_UNSUPPORTED;
 744     return SW_DISCOVERY_E_NOT_SUPPORTED;
 745 }
 746
 747 sw_result sw_corby_buffer_put_octets(
 748     sw_corby_buffer self,
 749     sw_const_octets val,
 750     sw_size_t size) {
 751     AVAHI_WARN_UNSUPPORTED;
 752     return SW_DISCOVERY_E_NOT_SUPPORTED;
 753 }
 754
 755 sw_result sw_corby_buffer_put_sized_octets(
 756     sw_corby_buffer self,
 757     sw_const_octets val,
 758     sw_uint32 len) {
 759     AVAHI_WARN_UNSUPPORTED;
 760     return SW_DISCOVERY_E_NOT_SUPPORTED;
 761 }
 762
 763 sw_result sw_corby_buffer_put_cstring(
 764     sw_corby_buffer self,
 765     sw_const_string val) {
 766     AVAHI_WARN_UNSUPPORTED;
 767     return SW_DISCOVERY_E_NOT_SUPPORTED;
 768 }
 769
 770 sw_result sw_corby_buffer_put_object(
 771     sw_corby_buffer self,
 772     const struct _sw_corby_object * object) {
 773     AVAHI_WARN_UNSUPPORTED;
 774     return SW_DISCOVERY_E_NOT_SUPPORTED;
 775 }
 776
 777 sw_result sw_corby_buffer_put_pad(
 778     sw_corby_buffer self,
 779     sw_corby_buffer_pad pad) {
 780     AVAHI_WARN_UNSUPPORTED;
 781     return SW_DISCOVERY_E_NOT_SUPPORTED;
 782 }
 783
 784 sw_result sw_corby_buffer_get_int8(
 785     sw_corby_buffer self,
 786     sw_int8 * val) {
 787     AVAHI_WARN_UNSUPPORTED;
 788     return SW_DISCOVERY_E_NOT_SUPPORTED;
 789 }
 790
 791 sw_result sw_corby_buffer_get_uint8(
 792     sw_corby_buffer self,
 793     sw_uint8 * val) {
 794     AVAHI_WARN_UNSUPPORTED;
 795     return SW_DISCOVERY_E_NOT_SUPPORTED;
 796 }
 797
 798 sw_result sw_corby_buffer_get_int16(
 799     sw_corby_buffer self,
 800     sw_int16 * val,
 801     sw_uint8 endian) {
 802     AVAHI_WARN_UNSUPPORTED;
 803     return SW_DISCOVERY_E_NOT_SUPPORTED;
 804 }
 805
 806 sw_result sw_corby_buffer_get_uint16(
 807     sw_corby_buffer self,
 808     sw_uint16 * val,
 809     sw_uint8 endian) {
 810     AVAHI_WARN_UNSUPPORTED;
 811     return SW_DISCOVERY_E_NOT_SUPPORTED;
 812 }
 813
 814 sw_result sw_corby_buffer_get_int32(
 815     sw_corby_buffer self,
 816     sw_int32 * val,
 817     sw_uint8 endian) {
 818     AVAHI_WARN_UNSUPPORTED;
 819     return SW_DISCOVERY_E_NOT_SUPPORTED;
 820 }
 821
 822 sw_result sw_corby_buffer_get_uint32(
 823     sw_corby_buffer self,
 824     sw_uint32 * val,
 825     sw_uint8 endian) {
 826     AVAHI_WARN_UNSUPPORTED;
 827     return SW_DISCOVERY_E_NOT_SUPPORTED;
 828 }
 829
 830 sw_result sw_corby_buffer_get_octets(
 831     sw_corby_buffer self,
 832     sw_octets octets,
 833     sw_size_t size) {
 834     AVAHI_WARN_UNSUPPORTED;
 835     return SW_DISCOVERY_E_NOT_SUPPORTED;
 836 }
 837
 838 sw_result sw_corby_buffer_allocate_and_get_sized_octets(
 839     sw_corby_buffer self,
 840     sw_octets * val,
 841     sw_uint32 * size,
 842     sw_uint8 endian) {
 843     AVAHI_WARN_UNSUPPORTED;
 844     return SW_DISCOVERY_E_NOT_SUPPORTED;
 845 }
 846
 847 sw_result sw_corby_buffer_get_zerocopy_sized_octets(
 848     sw_corby_buffer self,
 849     sw_octets * val,
 850     sw_uint32 * size,
 851     sw_uint8 endian) {
 852     AVAHI_WARN_UNSUPPORTED;
 853     return SW_DISCOVERY_E_NOT_SUPPORTED;
 854 }
 855
 856 sw_result sw_corby_buffer_get_sized_octets(
 857     sw_corby_buffer self,
 858     sw_octets val,
 859     sw_uint32 * len,
 860     sw_uint8 endian) {
 861     AVAHI_WARN_UNSUPPORTED;
 862     return SW_DISCOVERY_E_NOT_SUPPORTED;
 863 }
 864
 865 sw_result sw_corby_buffer_allocate_and_get_cstring(
 866     sw_corby_buffer self,
 867     sw_string * val,
 868     sw_uint32 * len,
 869     sw_uint8 endian) {
 870     AVAHI_WARN_UNSUPPORTED;
 871     return SW_DISCOVERY_E_NOT_SUPPORTED;
 872 }
 873
 874 sw_result sw_corby_buffer_get_zerocopy_cstring(
 875     sw_corby_buffer self,
 876     sw_string * val,
 877     sw_uint32 * len,
 878     sw_uint8 endian) {
 879     AVAHI_WARN_UNSUPPORTED;
 880     return SW_DISCOVERY_E_NOT_SUPPORTED;
 881 }
 882
 883 sw_result sw_corby_buffer_get_cstring(
 884     sw_corby_buffer self,
 885     sw_string val,
 886     sw_uint32 * len,
 887     sw_uint8 endian) {
 888     AVAHI_WARN_UNSUPPORTED;
 889     return SW_DISCOVERY_E_NOT_SUPPORTED;
 890 }
 891
 892 sw_result sw_corby_buffer_get_object(
 893     sw_corby_buffer self,
 894     struct _sw_corby_object ** object,
 895     sw_uint8 endian) {
 896     AVAHI_WARN_UNSUPPORTED;
 897     return SW_DISCOVERY_E_NOT_SUPPORTED;
 898 }
 899
 900 sw_result sw_corby_channel_start_request(
 901     sw_corby_channel self,
 902     sw_const_corby_profile profile,
 903     struct _sw_corby_buffer ** buffer,
 904     sw_const_string op,
 905     sw_uint32 oplen,
 906     sw_bool reply_expected) {
 907     AVAHI_WARN_UNSUPPORTED;
 908     return SW_DISCOVERY_E_NOT_SUPPORTED;
 909 }
 910
 911 sw_result sw_corby_channel_start_reply(
 912     sw_corby_channel self,
 913     struct _sw_corby_buffer ** buffer,
 914     sw_uint32 request_id,
 915     sw_corby_reply_status status) {
 916     AVAHI_WARN_UNSUPPORTED;
 917     return SW_DISCOVERY_E_NOT_SUPPORTED;
 918 }
 919
 920 sw_result sw_corby_channel_send(
 921     sw_corby_channel self,
 922     struct _sw_corby_buffer * buffer,
 923     sw_corby_buffer_observer observer,
 924     sw_corby_buffer_written_func func,
 925     sw_opaque_t extra) {
 926     AVAHI_WARN_UNSUPPORTED;
 927     return SW_DISCOVERY_E_NOT_SUPPORTED;
 928 }
 929
 930 sw_result sw_corby_channel_recv(
 931     sw_corby_channel self,
 932     sw_salt * salt,
 933     struct _sw_corby_message ** message,
 934     sw_uint32 * request_id,
 935     sw_string * op,
 936     sw_uint32 * op_len,
 937     struct _sw_corby_buffer ** buffer,
 938     sw_uint8 * endian,
 939     sw_bool block) {
 940     AVAHI_WARN_UNSUPPORTED;
 941     return SW_DISCOVERY_E_NOT_SUPPORTED;
 942 }
 943
 944 sw_result sw_corby_channel_last_recv_from(
 945     sw_corby_channel self,
 946     sw_ipv4_address * from,
 947     sw_port * from_port) {
 948     AVAHI_WARN_UNSUPPORTED;
 949     return SW_DISCOVERY_E_NOT_SUPPORTED;
 950 }
 951
 952 sw_result sw_corby_channel_ff(
 953     sw_corby_channel self,
 954     struct _sw_corby_buffer * buffer) {
 955     AVAHI_WARN_UNSUPPORTED;
 956     return SW_DISCOVERY_E_NOT_SUPPORTED;
 957 }
 958
 959 sw_socket sw_corby_channel_socket(sw_corby_channel self) {
 960     AVAHI_WARN_UNSUPPORTED;
 961     return SW_DISCOVERY_E_NOT_SUPPORTED;
 962 }
 963
 964 sw_result sw_corby_channel_retain(sw_corby_channel self) {
 965     AVAHI_WARN_UNSUPPORTED;
 966     return SW_DISCOVERY_E_NOT_SUPPORTED;
 967 }
 968
 969 sw_result sw_corby_channel_set_delegate(
 970     sw_corby_channel self,
 971     sw_corby_channel_delegate delegate) {
 972     AVAHI_WARN_UNSUPPORTED;
 973     return SW_DISCOVERY_E_NOT_SUPPORTED;
 974 }
 975
 976 sw_corby_channel_delegate sw_corby_channel_get_delegate(
 977     sw_corby_channel self) {
 978     AVAHI_WARN_UNSUPPORTED_ABORT;
 979 }
 980
 981 void sw_corby_channel_set_app_data(
 982     sw_corby_channel self,
 983     sw_opaque app_data) {
 984     AVAHI_WARN_UNSUPPORTED;
 985 }
 986
 987 sw_opaque sw_corby_channel_get_app_data(sw_corby_channel self) {
 988     AVAHI_WARN_UNSUPPORTED_ABORT;
 989 }
 990
 991 sw_result sw_corby_channel_fina(sw_corby_channel self) {
 992     AVAHI_WARN_UNSUPPORTED;
 993     return SW_DISCOVERY_E_NOT_SUPPORTED;
 994 }
 995
 996 sw_result sw_corby_object_init_from_url(
 997     sw_corby_object * self,
 998     struct _sw_corby_orb * orb,
 999     sw_const_string url,
1000     sw_socket_options options,
1001     sw_uint32 bufsize) {
1002     AVAHI_WARN_UNSUPPORTED;
1003     return SW_DISCOVERY_E_NOT_SUPPORTED;
1004 }
1005
1006 sw_result sw_corby_object_fina(
1007     sw_corby_object self) {
1008     AVAHI_WARN_UNSUPPORTED;
1009     return SW_DISCOVERY_E_NOT_SUPPORTED;
1010 }
1011
1012 sw_result sw_corby_object_start_request(
1013     sw_corby_object self,
1014     sw_const_string op,
1015     sw_uint32 op_len,
1016     sw_bool reply_expected,
1017     sw_corby_buffer * buffer) {
1018     AVAHI_WARN_UNSUPPORTED;
1019     return SW_DISCOVERY_E_NOT_SUPPORTED;
1020 }
1021
1022 sw_result sw_corby_object_send(
1023     sw_corby_object self,
1024     sw_corby_buffer buffer,
1025     sw_corby_buffer_observer observer,
1026     sw_corby_buffer_written_func func,
1027     sw_opaque extra) {
1028     AVAHI_WARN_UNSUPPORTED;
1029     return SW_DISCOVERY_E_NOT_SUPPORTED;
1030 }
1031
1032 sw_result sw_corby_object_recv(
1033     sw_corby_object self,
1034     sw_corby_message * message,
1035     sw_corby_buffer * buffer,
1036     sw_uint8 * endian,
1037     sw_bool block) {
1038     AVAHI_WARN_UNSUPPORTED;
1039     return SW_DISCOVERY_E_NOT_SUPPORTED;
1040 }
1041
1042 sw_result sw_corby_object_channel(
1043     sw_corby_object self,
1044     sw_corby_channel * channel) {
1045     AVAHI_WARN_UNSUPPORTED;
1046     return SW_DISCOVERY_E_NOT_SUPPORTED;
1047 }
1048
1049 sw_result sw_corby_object_set_channel(
1050     sw_corby_object self,
1051     sw_corby_channel channel) {
1052     AVAHI_WARN_UNSUPPORTED;
1053     return SW_DISCOVERY_E_NOT_SUPPORTED;
1054 }
1055
1056 sw_result sw_discovery_init(
1057     sw_discovery * self) {
1058     AVAHI_WARN_UNSUPPORTED;
1059     return SW_DISCOVERY_E_NOT_SUPPORTED;
1060 }
1061
1062 sw_result sw_discovery_init_with_flags(
1063     sw_discovery * self,
1064     sw_discovery_init_flags flags) {
1065     AVAHI_WARN_UNSUPPORTED;
1066     return SW_DISCOVERY_E_NOT_SUPPORTED;
1067 }
1068
1069 sw_result sw_discovery_fina(sw_discovery self) {
1070     AVAHI_WARN_UNSUPPORTED;
1071     return SW_DISCOVERY_E_NOT_SUPPORTED;
1072 }
1073
1074 sw_result sw_discovery_publish_host(
1075     sw_discovery self,
1076     sw_uint32 interface_index,
1077     sw_const_string name,
1078     sw_const_string domain,
1079     sw_ipv4_address address,
1080     sw_discovery_publish_reply reply,
1081     sw_opaque extra,
1082     sw_discovery_oid * oid) {
1083     AVAHI_WARN_UNSUPPORTED;
1084     return SW_DISCOVERY_E_NOT_SUPPORTED;
1085 }
1086
1087 sw_result sw_discovery_publish(
1088     sw_discovery self,
1089     sw_uint32 interface_index,
1090     sw_const_string name,
1091     sw_const_string type,
1092     sw_const_string domain,
1093     sw_const_string host,
1094     sw_port port,
1095     sw_octets text_record,
1096     sw_uint32 text_record_len,
1097     sw_discovery_publish_reply reply,
1098     sw_opaque extra,
1099     sw_discovery_oid * oid) {
1100     AVAHI_WARN_UNSUPPORTED;
1101     return SW_DISCOVERY_E_NOT_SUPPORTED;
1102 }
1103
1104 sw_result sw_discovery_publish_update(
1105     sw_discovery self,
1106     sw_discovery_oid oid,
1107     sw_octets text_record,
1108     sw_uint32 text_record_len) {
1109     AVAHI_WARN_UNSUPPORTED;
1110     return SW_DISCOVERY_E_NOT_SUPPORTED;
1111 }
1112
1113 sw_result sw_discovery_browse_domains(
1114     sw_discovery self,
1115     sw_uint32 interface_index,
1116     sw_discovery_browse_reply reply,
1117     sw_opaque extra,
1118     sw_discovery_oid * oid) {
1119     AVAHI_WARN_UNSUPPORTED;
1120     return SW_DISCOVERY_E_NOT_SUPPORTED;
1121 }
1122
1123 sw_result sw_discovery_browse(
1124     sw_discovery self,
1125     sw_uint32 interface_index,
1126     sw_const_string type,
1127     sw_const_string domain,
1128     sw_discovery_browse_reply reply,
1129     sw_opaque extra,
1130     sw_discovery_oid * oid) {
1131     AVAHI_WARN_UNSUPPORTED;
1132     return SW_DISCOVERY_E_NOT_SUPPORTED;
1133 }
1134
1135 sw_result sw_discovery_resolve(
1136     sw_discovery self,
1137     sw_uint32 interface_index,
1138     sw_const_string name,
1139     sw_const_string type,
1140     sw_const_string domain,
1141     sw_discovery_resolve_reply reply,
1142     sw_opaque extra,
1143     sw_discovery_oid * oid) {
1144     AVAHI_WARN_UNSUPPORTED;
1145     return SW_DISCOVERY_E_NOT_SUPPORTED;
1146 }
1147
1148 sw_result sw_discovery_query_record(
1149     sw_discovery self,
1150     sw_uint32 interface_index,
1151     sw_uint32 flags,
1152     sw_const_string fullname,
1153     sw_uint16 rrtype,
1154     sw_uint16 rrclass,
1155     sw_discovery_query_record_reply reply,
1156     sw_opaque extra,
1157     sw_discovery_oid * oid) {
1158     AVAHI_WARN_UNSUPPORTED;
1159     return SW_DISCOVERY_E_NOT_SUPPORTED;
1160 }
1161
1162 sw_result sw_discovery_cancel(
1163     sw_discovery self,
1164     sw_discovery_oid oid) {
1165     AVAHI_WARN_UNSUPPORTED;
1166     return SW_DISCOVERY_E_NOT_SUPPORTED;
1167 }
1168
1169 sw_result sw_discovery_run(
1170     sw_discovery self) {
1171     AVAHI_WARN_UNSUPPORTED;
1172     return SW_DISCOVERY_E_NOT_SUPPORTED;
1173 }
1174
1175 sw_result sw_discovery_stop_run(
1176     sw_discovery self) {
1177     AVAHI_WARN_UNSUPPORTED;
1178     return SW_DISCOVERY_E_NOT_SUPPORTED;
1179 }
1180
1181 int sw_discovery_socket(sw_discovery self) {
1182     AVAHI_WARN_UNSUPPORTED_ABORT;
1183 }
1184
1185 sw_result sw_discovery_read_socket(sw_discovery self) {
1186     AVAHI_WARN_UNSUPPORTED;
1187     return SW_DISCOVERY_E_NOT_SUPPORTED;
1188 }
1189
1190 sw_result sw_discovery_salt(
1191     sw_discovery self,
1192     sw_salt * salt) {
1193     AVAHI_WARN_UNSUPPORTED;
1194     return SW_DISCOVERY_E_NOT_SUPPORTED;
1195 }
1196
1197 sw_result sw_text_record_init(
1198     sw_text_record * self) {
1199     AVAHI_WARN_UNSUPPORTED;
1200     return SW_DISCOVERY_E_NOT_SUPPORTED;
1201 }
1202
1203 sw_result sw_text_record_fina(
1204     sw_text_record self) {
1205     AVAHI_WARN_UNSUPPORTED;
1206     return SW_DISCOVERY_E_NOT_SUPPORTED;
1207 }
1208
1209 sw_result sw_text_record_add_string(
1210     sw_text_record self,
1211     sw_const_string string) {
1212     AVAHI_WARN_UNSUPPORTED;
1213     return SW_DISCOVERY_E_NOT_SUPPORTED;
1214 }
1215
1216 sw_result sw_text_record_add_key_and_string_value(
1217     sw_text_record self,
1218     sw_const_string key,
1219     sw_const_string val) {
1220     AVAHI_WARN_UNSUPPORTED;
1221     return SW_DISCOVERY_E_NOT_SUPPORTED;
1222 }
1223
1224 sw_result sw_text_record_add_key_and_binary_value(
1225     sw_text_record self,
1226     sw_const_string key,
1227     sw_octets val,
1228     sw_uint32 len) {
1229     AVAHI_WARN_UNSUPPORTED;
1230     return SW_DISCOVERY_E_NOT_SUPPORTED;
1231 }
1232
1233 sw_octets sw_text_record_bytes(sw_text_record self) {
1234     AVAHI_WARN_UNSUPPORTED;
1235     return NULL;
1236 }
1237
1238 sw_uint32 sw_text_record_len(sw_text_record self) {
1239     AVAHI_WARN_UNSUPPORTED;
1240     return 0;
1241 }
1242
1243 sw_result sw_text_record_iterator_init(
1244     sw_text_record_iterator * self,
1245     sw_octets text_record,
1246     sw_uint32 text_record_len) {
1247     AVAHI_WARN_UNSUPPORTED;
1248     return SW_DISCOVERY_E_NOT_SUPPORTED;
1249 }
1250
1251 sw_result sw_text_record_iterator_fina(
1252     sw_text_record_iterator self) {
1253     AVAHI_WARN_UNSUPPORTED;
1254     return SW_DISCOVERY_E_NOT_SUPPORTED;
1255 }
1256
1257 sw_result sw_text_record_iterator_next(
1258     sw_text_record_iterator self,
1259     char key[255],
1260     sw_uint8 val[255],
1261     sw_uint32 * val_len) {
1262     AVAHI_WARN_UNSUPPORTED;
1263     return SW_DISCOVERY_E_NOT_SUPPORTED;
1264 }
1265
1266 sw_result sw_text_record_string_iterator_init(
1267     sw_text_record_string_iterator * self,
1268     sw_const_string text_record_string) {
1269     AVAHI_WARN_UNSUPPORTED;
1270     return SW_DISCOVERY_E_NOT_SUPPORTED;
1271 }
1272
1273 sw_result sw_text_record_string_iterator_fina(
1274     sw_text_record_string_iterator self) {
1275     AVAHI_WARN_UNSUPPORTED;
1276     return SW_DISCOVERY_E_NOT_SUPPORTED;
1277 }
1278
1279 sw_result sw_text_record_string_iterator_next(
1280     sw_text_record_string_iterator self,
1281     char key[255],
1282     char val[255]) {
1283     AVAHI_WARN_UNSUPPORTED;
1284     return SW_DISCOVERY_E_NOT_SUPPORTED;
1285 }