reactos/dll/win32/ws2_32/misc/stubs.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS WinSock 2 DLL
   4  * FILE:        misc/stubs.c
   5  * PURPOSE:     Stubs
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/09-2000 Created
   9  */
  10 #include <ws2_32.h>
  11 #include <catalog.h>
  12 #include <handle.h>
  13
  14
  15 /*
  16  * @implemented
  17  */
  18 INT
  19 EXPORT
  20 getpeername(IN     SOCKET s,
  21             OUT    LPSOCKADDR name,
  22             IN OUT INT FAR* namelen)
  23 {
  24     int Error;
  25     INT Errno;
  26     PCATALOG_ENTRY Provider;
  27
  28     if (!WSAINITIALIZED)
  29     {
  30         WSASetLastError(WSANOTINITIALISED);
  31         return SOCKET_ERROR;
  32     }
  33
  34     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
  35     {
  36         WSASetLastError(WSAENOTSOCK);
  37         return SOCKET_ERROR;
  38     }
  39
  40     Error = Provider->ProcTable.lpWSPGetPeerName(s,
  41                                                  name,
  42                                                  namelen,
  43                                                  &Errno);
  44
  45     DereferenceProviderByPointer(Provider);
  46
  47     if (Error == SOCKET_ERROR)
  48     {
  49         WSASetLastError(Errno);
  50     }
  51
  52     return Error;
  53 }
  54
  55
  56
  57 /*
  58  * @implemented
  59  */
  60 INT
  61 EXPORT
  62 getsockname(IN     SOCKET s,
  63             OUT    LPSOCKADDR name,
  64             IN OUT INT FAR* namelen)
  65 {
  66     int Error;
  67     INT Errno;
  68     PCATALOG_ENTRY Provider;
  69
  70     if (!WSAINITIALIZED)
  71     {
  72         WSASetLastError(WSANOTINITIALISED);
  73         return SOCKET_ERROR;
  74     }
  75
  76     if (!ReferenceProviderByHandle((HANDLE)s,
  77                                    &Provider))
  78     {
  79         WSASetLastError(WSAENOTSOCK);
  80         return SOCKET_ERROR;
  81     }
  82
  83     Error = Provider->ProcTable.lpWSPGetSockName(s,
  84                                                  name,
  85                                                  namelen,
  86                                                  &Errno);
  87
  88     DereferenceProviderByPointer(Provider);
  89
  90     if (Error == SOCKET_ERROR)
  91     {
  92         WSASetLastError(Errno);
  93     }
  94
  95     return Error;
  96 }
  97
  98
  99 /*
 100  * @implemented
 101  */
 102 INT
 103 EXPORT
 104 getsockopt(IN      SOCKET s,
 105            IN      INT level,
 106            IN      INT optname,
 107            OUT     CHAR FAR* optval,
 108            IN OUT  INT FAR* optlen)
 109 {
 110     PCATALOG_ENTRY Provider;
 111     INT Errno;
 112     int Error;
 113
 114     if (!WSAINITIALIZED)
 115     {
 116         WSASetLastError(WSANOTINITIALISED);
 117         return SOCKET_ERROR;
 118     }
 119
 120     if (!ReferenceProviderByHandle((HANDLE)s,
 121                                    &Provider))
 122     {
 123         WSASetLastError(WSAENOTSOCK);
 124         return SOCKET_ERROR;
 125     }
 126
 127     Error = Provider->ProcTable.lpWSPGetSockOpt(s,
 128                                                 level,
 129                                                 optname,
 130                                                 optval,
 131                                                 optlen,
 132                                                 &Errno);
 133
 134     DereferenceProviderByPointer(Provider);
 135
 136     if (Error == SOCKET_ERROR)
 137     {
 138         WSASetLastError(Errno);
 139     }
 140
 141     return Error;
 142 }
 143
 144
 145 /*
 146  * @implemented
 147  */
 148 INT
 149 EXPORT __stdcall
 150 setsockopt(IN  SOCKET s,
 151            IN  INT level,
 152            IN  INT optname,
 153            IN  CONST CHAR FAR* optval,
 154            IN  INT optlen)
 155 {
 156     PCATALOG_ENTRY Provider;
 157     INT Errno;
 158     int Error;
 159
 160     if (!WSAINITIALIZED)
 161     {
 162         WSASetLastError(WSANOTINITIALISED);
 163         return SOCKET_ERROR;
 164     }
 165
 166     if(IS_INTRESOURCE(optval))
 167     {
 168         SetLastError(WSAEFAULT);
 169         return SOCKET_ERROR;
 170     }
 171
 172     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 173     {
 174         WSASetLastError(WSAENOTSOCK);
 175         return SOCKET_ERROR;
 176     }
 177
 178     Error = Provider->ProcTable.lpWSPSetSockOpt(s,
 179                                                   level,
 180                                                 optname,
 181                                                 optval,
 182                                                 optlen,
 183                                                 &Errno);
 184
 185     DereferenceProviderByPointer(Provider);
 186
 187     if (Error == SOCKET_ERROR)
 188     {
 189         WSASetLastError(Errno);
 190     }
 191
 192     return Error;
 193 }
 194
 195
 196 /*
 197  * @implemented
 198  */
 199 INT
 200 EXPORT
 201 shutdown(IN  SOCKET s,
 202          IN  INT how)
 203 {
 204     PCATALOG_ENTRY Provider;
 205     INT Errno;
 206     int Error;
 207
 208     if (!WSAINITIALIZED)
 209     {
 210         WSASetLastError(WSANOTINITIALISED);
 211         return SOCKET_ERROR;
 212     }
 213
 214     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 215     {
 216         WSASetLastError(WSAENOTSOCK);
 217         return SOCKET_ERROR;
 218     }
 219
 220     Error = Provider->ProcTable.lpWSPShutdown(s,
 221                                               how,
 222                                               &Errno);
 223
 224     DereferenceProviderByPointer(Provider);
 225
 226     if (Error == SOCKET_ERROR)
 227     {
 228         WSASetLastError(Errno);
 229     }
 230
 231     return Error;
 232 }
 233
 234
 235 /*
 236  * @implemented
 237  */
 238 INT
 239 EXPORT
 240 WSAAsyncSelect(IN  SOCKET s,
 241                IN  HWND hWnd,
 242                IN  UINT wMsg,
 243                IN  LONG lEvent)
 244 {
 245     PCATALOG_ENTRY Provider;
 246     INT Errno;
 247     int Error;
 248
 249     if (!WSAINITIALIZED)
 250     {
 251         WSASetLastError(WSANOTINITIALISED);
 252         return SOCKET_ERROR;
 253     }
 254
 255     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 256     {
 257         WSASetLastError(WSAENOTSOCK);
 258         return SOCKET_ERROR;
 259     }
 260
 261     Error = Provider->ProcTable.lpWSPAsyncSelect(s,
 262                                                  hWnd,
 263                                                  wMsg,
 264                                                  lEvent,
 265                                                  &Errno);
 266
 267     DereferenceProviderByPointer(Provider);
 268
 269     if (Error == SOCKET_ERROR)
 270     {
 271         WSASetLastError(Errno);
 272     }
 273
 274     return Error;
 275 }
 276
 277
 278 /*
 279  * @unimplemented
 280  */
 281 INT
 282 EXPORT
 283 WSACancelBlockingCall(VOID)
 284 {
 285 #if 0
 286     INT Errno;
 287     int Error;
 288     PCATALOG_ENTRY Provider;
 289
 290     if (!WSAINITIALIZED)
 291     {
 292         WSASetLastError(WSANOTINITIALISED);
 293         return SOCKET_ERROR;
 294     }
 295
 296     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 297     {
 298         WSASetLastError(WSAENOTSOCK);
 299         return SOCKET_ERROR;
 300     }
 301
 302     Error = Provider->ProcTable.lpWSPCancelBlockingCall(&Errno);
 303
 304     DereferenceProviderByPointer(Provider);
 305
 306     if (Error == SOCKET_ERROR)
 307     {
 308         WSASetLastError(Errno);
 309     }
 310
 311     return Error;
 312 #endif
 313
 314     UNIMPLEMENTED
 315
 316     WSASetLastError(WSASYSCALLFAILURE);
 317     return SOCKET_ERROR;
 318 }
 319
 320
 321 /*
 322  * @unimplemented
 323  */
 324 INT
 325 EXPORT
 326 WSADuplicateSocketA(IN  SOCKET s,
 327                     IN  DWORD dwProcessId,
 328                     OUT LPWSAPROTOCOL_INFOA lpProtocolInfo)
 329 {
 330 #if 0
 331     WSAPROTOCOL_INFOA ProtocolInfoU;
 332
 333     Error  = WSADuplicateSocketW(s,
 334                                dwProcessId,
 335                                &ProtocolInfoU);
 336
 337     if (Error == NO_ERROR)
 338     {
 339         UnicodeToAnsi(lpProtocolInfo,
 340                       ProtocolInfoU,
 341                       sizeof(
 342
 343     }
 344
 345     return Error;
 346 #endif
 347
 348     UNIMPLEMENTED
 349
 350     WSASetLastError(WSASYSCALLFAILURE);
 351     return SOCKET_ERROR;
 352 }
 353
 354
 355
 356 /*
 357  * @implemented
 358  */
 359 INT
 360 EXPORT
 361 WSADuplicateSocketW(IN  SOCKET s,
 362                     IN  DWORD dwProcessId,
 363                     OUT LPWSAPROTOCOL_INFOW lpProtocolInfo)
 364 {
 365     INT Errno;
 366     int Error;
 367     PCATALOG_ENTRY Provider;
 368
 369     if (!WSAINITIALIZED)
 370     {
 371         WSASetLastError(WSANOTINITIALISED);
 372         return SOCKET_ERROR;
 373     }
 374
 375     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 376     {
 377         WSASetLastError(WSAENOTSOCK);
 378         return SOCKET_ERROR;
 379     }
 380
 381     Error = Provider->ProcTable.lpWSPDuplicateSocket(s,
 382                                                      dwProcessId,
 383                                                      lpProtocolInfo,
 384                                                      &Errno);
 385     DereferenceProviderByPointer(Provider);
 386
 387     if (Error == SOCKET_ERROR)
 388     {
 389         WSASetLastError(Errno);
 390     }
 391
 392     return Error;
 393 }
 394
 395
 396 /*
 397  * @unimplemented
 398  */
 399 INT
 400 EXPORT
 401 WSAEnumProtocolsA(IN      LPINT lpiProtocols,
 402                   OUT     LPWSAPROTOCOL_INFOA lpProtocolBuffer,
 403                   IN OUT  LPDWORD lpdwBufferLength)
 404 {
 405     UNIMPLEMENTED
 406
 407     WSASetLastError(WSASYSCALLFAILURE);
 408     return SOCKET_ERROR;
 409 }
 410
 411
 412 /*
 413  * @unimplemented
 414  */
 415 INT
 416 EXPORT
 417 WSAEnumProtocolsW(IN      LPINT lpiProtocols,
 418                   OUT     LPWSAPROTOCOL_INFOW lpProtocolBuffer,
 419                   IN OUT  LPDWORD lpdwBufferLength)
 420 {
 421     UNIMPLEMENTED
 422
 423     WSASetLastError(WSASYSCALLFAILURE);
 424     return SOCKET_ERROR;
 425 }
 426
 427
 428 /*
 429  * @implemented
 430  */
 431 BOOL
 432 EXPORT
 433 WSAGetOverlappedResult(IN  SOCKET s,
 434                        IN  LPWSAOVERLAPPED lpOverlapped,
 435                        OUT LPDWORD lpcbTransfer,
 436                        IN  BOOL fWait,
 437                        OUT LPDWORD lpdwFlags)
 438 {
 439     INT Errno;
 440     BOOL Success;
 441     PCATALOG_ENTRY Provider;
 442
 443     if (!WSAINITIALIZED)
 444     {
 445         WSASetLastError(WSANOTINITIALISED);
 446         return SOCKET_ERROR;
 447     }
 448
 449     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 450     {
 451         WSASetLastError(WSAENOTSOCK);
 452         return SOCKET_ERROR;
 453     }
 454
 455     Success = Provider->ProcTable.lpWSPGetOverlappedResult(s,
 456                                                           lpOverlapped,
 457                                                           lpcbTransfer,
 458                                                           fWait,
 459                                                           lpdwFlags,
 460                                                           &Errno);
 461     DereferenceProviderByPointer(Provider);
 462
 463     if (Success == FALSE)
 464     {
 465         WSASetLastError(Errno);
 466     }
 467
 468     return Success;
 469 }
 470
 471
 472 /*
 473  * @unimplemented
 474  */
 475 BOOL
 476 EXPORT
 477 WSAGetQOSByName(IN      SOCKET s,
 478                 IN OUT  LPWSABUF lpQOSName,
 479                 OUT     LPQOS lpQOS)
 480 {
 481     UNIMPLEMENTED
 482
 483     WSASetLastError(WSASYSCALLFAILURE);
 484     return FALSE;
 485 }
 486
 487
 488 /*
 489  * @unimplemented
 490  */
 491 INT
 492 EXPORT
 493 WSAHtonl(IN  SOCKET s,
 494          IN  ULONG hostLONG,
 495          OUT ULONG FAR* lpnetlong)
 496 {
 497     UNIMPLEMENTED
 498
 499     WSASetLastError(WSASYSCALLFAILURE);
 500     return SOCKET_ERROR;
 501 }
 502
 503
 504 /*
 505  * @unimplemented
 506  */
 507 INT
 508 EXPORT
 509 WSAHtons(IN  SOCKET s,
 510          IN  USHORT hostshort,
 511          OUT USHORT FAR* lpnetshort)
 512 {
 513     UNIMPLEMENTED
 514
 515     WSASetLastError(WSASYSCALLFAILURE);
 516     return SOCKET_ERROR;
 517 }
 518
 519
 520 /*
 521  * @unimplemented
 522  */
 523 BOOL
 524 EXPORT
 525 WSAIsBlocking(VOID)
 526 {
 527     UNIMPLEMENTED
 528
 529     return FALSE;
 530 }
 531
 532
 533 /*
 534  * @unimplemented
 535  */
 536 SOCKET
 537 EXPORT
 538 WSAJoinLeaf(IN  SOCKET s,
 539             IN  CONST struct sockaddr *name,
 540             IN  INT namelen,
 541             IN  LPWSABUF lpCallerData,
 542             OUT LPWSABUF lpCalleeData,
 543             IN  LPQOS lpSQOS,
 544             IN  LPQOS lpGQOS,
 545             IN  DWORD dwFlags)
 546 {
 547     UNIMPLEMENTED
 548
 549     WSASetLastError(WSASYSCALLFAILURE);
 550     return INVALID_SOCKET;
 551 }
 552
 553
 554 /*
 555  * @unimplemented
 556  */
 557 INT
 558 EXPORT
 559 WSANtohl(IN  SOCKET s,
 560          IN  ULONG netlong,
 561          OUT ULONG FAR* lphostlong)
 562 {
 563     UNIMPLEMENTED
 564
 565     WSASetLastError(WSASYSCALLFAILURE);
 566     return SOCKET_ERROR;
 567 }
 568
 569
 570 /*
 571  * @unimplemented
 572  */
 573 INT
 574 EXPORT
 575 WSANtohs(IN  SOCKET s,
 576          IN  USHORT netshort,
 577          OUT USHORT FAR* lphostshort)
 578 {
 579     UNIMPLEMENTED
 580
 581     WSASetLastError(WSASYSCALLFAILURE);
 582     return SOCKET_ERROR;
 583 }
 584
 585
 586 /*
 587  * @unimplemented
 588  */
 589 FARPROC
 590 EXPORT
 591 WSASetBlockingHook(IN  FARPROC lpBlockFunc)
 592 {
 593     UNIMPLEMENTED
 594
 595     return (FARPROC)0;
 596 }
 597
 598
 599 /*
 600  * @unimplemented
 601  */
 602 INT
 603 EXPORT
 604 WSAUnhookBlockingHook(VOID)
 605 {
 606     UNIMPLEMENTED
 607
 608     return 0;
 609 }
 610
 611
 612 /*
 613  * @unimplemented
 614  */
 615 INT
 616 EXPORT
 617 WSAProviderConfigChange(IN OUT  LPHANDLE lpNotificationHandle,
 618                         IN      LPWSAOVERLAPPED lpOverlapped,
 619                         IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 620 {
 621     UNIMPLEMENTED
 622
 623     WSASetLastError(WSASYSCALLFAILURE);
 624     return SOCKET_ERROR;
 625 }
 626
 627
 628 /*
 629  * @unimplemented
 630  */
 631 INT
 632 EXPORT
 633 WSACancelAsyncRequest(IN  HANDLE hAsyncTaskHandle)
 634 {
 635     UNIMPLEMENTED
 636
 637     WSASetLastError(WSASYSCALLFAILURE);
 638     return SOCKET_ERROR;
 639 }
 640
 641 /* WinSock Service Provider support functions */
 642
 643 /*
 644  * @unimplemented
 645  */
 646 INT
 647 EXPORT
 648 WPUCompleteOverlappedRequest(IN  SOCKET s,
 649                              IN  LPWSAOVERLAPPED lpOverlapped,
 650                              IN  DWORD dwError,
 651                              IN  DWORD cbTransferred,
 652                              OUT LPINT lpErrno)
 653 {
 654     UNIMPLEMENTED
 655
 656     WSASetLastError(WSASYSCALLFAILURE);
 657     return SOCKET_ERROR;
 658 }
 659
 660
 661 /*
 662  * @unimplemented
 663  */
 664 INT
 665 EXPORT
 666 WSPStartup(IN  WORD wVersionRequested,
 667            OUT LPWSPDATA lpWSPData,
 668            IN  LPWSAPROTOCOL_INFOW lpProtocolInfo,
 669            IN  WSPUPCALLTABLE UpcallTable,
 670            OUT LPWSPPROC_TABLE lpProcTable)
 671 {
 672     UNIMPLEMENTED
 673
 674     return WSASYSCALLFAILURE;
 675 }
 676
 677
 678 /*
 679  * @unimplemented
 680  */
 681 INT
 682 EXPORT
 683 WSCDeinstallProvider(IN  LPGUID lpProviderId,
 684                      OUT LPINT lpErrno)
 685 {
 686     UNIMPLEMENTED
 687
 688     WSASetLastError(WSASYSCALLFAILURE);
 689     return SOCKET_ERROR;
 690 }
 691
 692
 693 /*
 694  * @unimplemented
 695  */
 696 INT
 697 EXPORT
 698 WSCEnumProtocols(IN      LPINT lpiProtocols,
 699                  OUT     LPWSAPROTOCOL_INFOW lpProtocolBuffer,
 700                  IN OUT  LPDWORD lpdwBufferLength,
 701                  OUT     LPINT lpErrno)
 702 {
 703     UNIMPLEMENTED
 704
 705     WSASetLastError(WSASYSCALLFAILURE);
 706     return SOCKET_ERROR;
 707 }
 708
 709
 710 /*
 711  * @unimplemented
 712  */
 713 INT
 714 EXPORT
 715 WSCGetProviderPath(IN      LPGUID lpProviderId,
 716                    OUT     LPWSTR lpszProviderDllPath,
 717                    IN OUT  LPINT lpProviderDllPathLen,
 718                    OUT     LPINT lpErrno)
 719 {
 720     UNIMPLEMENTED
 721
 722     WSASetLastError(WSASYSCALLFAILURE);
 723     return SOCKET_ERROR;
 724 }
 725
 726
 727 /*
 728  * @unimplemented
 729  */
 730 INT
 731 EXPORT
 732 WSCInstallProvider(IN  CONST LPGUID lpProviderId,
 733                    IN  CONST LPWSTR lpszProviderDllPath,
 734                    IN  CONST LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 735                    IN  DWORD dwNumberOfEntries,
 736                    OUT LPINT lpErrno)
 737 {
 738     UNIMPLEMENTED
 739
 740     WSASetLastError(WSASYSCALLFAILURE);
 741     return SOCKET_ERROR;
 742 }
 743
 744
 745 /*
 746  * @unimplemented
 747  */
 748 INT
 749 EXPORT
 750 WSCEnableNSProvider(IN  LPGUID lpProviderId,
 751                     IN  BOOL fEnable)
 752 {
 753     UNIMPLEMENTED
 754
 755     WSASetLastError(WSASYSCALLFAILURE);
 756     return SOCKET_ERROR;
 757 }
 758
 759
 760 /*
 761  * @unimplemented
 762  */
 763 INT
 764 EXPORT
 765 WSCInstallNameSpace(IN  LPWSTR lpszIdentifier,
 766                     IN  LPWSTR lpszPathName,
 767                     IN  DWORD dwNameSpace,
 768                     IN  DWORD dwVersion,
 769                     IN  LPGUID lpProviderId)
 770 {
 771     UNIMPLEMENTED
 772
 773     WSASetLastError(WSASYSCALLFAILURE);
 774     return SOCKET_ERROR;
 775 }
 776
 777
 778 /*
 779  * @unimplemented
 780  */
 781 INT
 782 EXPORT
 783 WSCUnInstallNameSpace(IN  LPGUID lpProviderId)
 784 {
 785     UNIMPLEMENTED
 786
 787     WSASetLastError(WSASYSCALLFAILURE);
 788     return SOCKET_ERROR;
 789 }
 790
 791
 792 /*
 793  * @unimplemented
 794  */
 795 INT
 796 EXPORT
 797 WSCWriteProviderOrder(IN  LPDWORD lpwdCatalogEntryId,
 798                       IN  DWORD dwNumberOfEntries)
 799 {
 800     UNIMPLEMENTED
 801
 802     return WSASYSCALLFAILURE;
 803 }
 804
 805 /*
 806  * @unimplemented
 807  */
 808 INT
 809 EXPORT
 810 WSANSPIoctl(HANDLE           hLookup,
 811             DWORD            dwControlCode,
 812             LPVOID           lpvInBuffer,
 813             DWORD            cbInBuffer,
 814             LPVOID           lpvOutBuffer,
 815             DWORD            cbOutBuffer,
 816             LPDWORD          lpcbBytesReturned,
 817             LPWSACOMPLETION  lpCompletion)
 818 {
 819     UNIMPLEMENTED
 820
 821     WSASetLastError(WSASYSCALLFAILURE);
 822     return SOCKET_ERROR;
 823 }
 824
 825
 826 /*
 827  * @unimplemented
 828  */
 829 INT
 830 EXPORT
 831 WSCUpdateProvider(LPGUID lpProviderId,
 832                   const WCHAR FAR * lpszProviderDllPath,
 833                   const LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 834                   DWORD dwNumberOfEntries,
 835                   LPINT lpErrno)
 836 {
 837     UNIMPLEMENTED
 838
 839     WSASetLastError(WSASYSCALLFAILURE);
 840     return SOCKET_ERROR;
 841 }
 842
 843 /*
 844  * @unimplemented
 845  */
 846 INT
 847 EXPORT
 848 WSCWriteNameSpaceOrder(LPGUID lpProviderId,
 849                        DWORD dwNumberOfEntries)
 850 {
 851     UNIMPLEMENTED
 852
 853     return WSASYSCALLFAILURE;
 854 }
 855
 856 /*
 857  * @unimplemented
 858  */
 859 INT
 860 EXPORT
 861 getnameinfo(const struct sockaddr FAR * sa,
 862             socklen_t       salen,
 863             char FAR *      host,
 864             DWORD           hostlen,
 865             char FAR *      serv,
 866             DWORD           servlen,
 867             INT             flags)
 868 {
 869     UNIMPLEMENTED
 870
 871     WSASetLastError(WSASYSCALLFAILURE);
 872     return SOCKET_ERROR;
 873 }
 874
 875 /*
 876  * @unimplemented
 877  */
 878 VOID EXPORT WEP()
 879 {
 880     UNIMPLEMENTED
 881 }
 882
 883 /*
 884  * @unimplemented
 885  */
 886 BOOL EXPORT WSApSetPostRoutine(PVOID Routine)
 887 {
 888     UNIMPLEMENTED
 889
 890     return FALSE;
 891 }
 892
 893 /* EOF */