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)(ULONG_PTR)(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     if (!WSAINITIALIZED)
 514     {
 515         WSASetLastError(WSANOTINITIALISED);
 516         return SOCKET_ERROR;
 517     }
 518
 519     PCATALOG_ENTRY provider;
 520     if (!ReferenceProviderByHandle((HANDLE)s, &provider))
 521     {
 522         WSASetLastError(WSAENOTSOCK);
 523         return SOCKET_ERROR;
 524     }
 525
 526     switch (provider->ProtocolInfo.iNetworkByteOrder)
 527     {
 528     case BIGENDIAN:
 529         *lpnetshort = htons(hostshort);
 530         break;
 531     case LITTLEENDIAN:
 532 #ifdef LE
 533         *lpnetshort = hostshort;
 534 #else
 535         *lpnetshort = (((hostshort & 0xFF00) >> 8) | ((hostshort & 0x00FF) << 8));
 536 #endif
 537         break;
 538     }
 539     return 0;
 540 }
 541
 542
 543 /*
 544  * @unimplemented
 545  */
 546 BOOL
 547 EXPORT
 548 WSAIsBlocking(VOID)
 549 {
 550     UNIMPLEMENTED
 551
 552     return FALSE;
 553 }
 554
 555
 556 /*
 557  * @unimplemented
 558  */
 559 SOCKET
 560 EXPORT
 561 WSAJoinLeaf(IN  SOCKET s,
 562             IN  CONST struct sockaddr *name,
 563             IN  INT namelen,
 564             IN  LPWSABUF lpCallerData,
 565             OUT LPWSABUF lpCalleeData,
 566             IN  LPQOS lpSQOS,
 567             IN  LPQOS lpGQOS,
 568             IN  DWORD dwFlags)
 569 {
 570     UNIMPLEMENTED
 571
 572     WSASetLastError(WSASYSCALLFAILURE);
 573     return INVALID_SOCKET;
 574 }
 575
 576
 577 /*
 578  * @unimplemented
 579  */
 580 INT
 581 EXPORT
 582 WSANtohl(IN  SOCKET s,
 583          IN  ULONG netlong,
 584          OUT ULONG FAR* lphostlong)
 585 {
 586     UNIMPLEMENTED
 587
 588     WSASetLastError(WSASYSCALLFAILURE);
 589     return SOCKET_ERROR;
 590 }
 591
 592
 593 /*
 594  * @unimplemented
 595  */
 596 INT
 597 EXPORT
 598 WSANtohs(IN  SOCKET s,
 599          IN  USHORT netshort,
 600          OUT USHORT FAR* lphostshort)
 601 {
 602     if (!WSAINITIALIZED)
 603     {
 604         WSASetLastError(WSANOTINITIALISED);
 605         return SOCKET_ERROR;
 606     }
 607
 608     PCATALOG_ENTRY provider;
 609     if (!ReferenceProviderByHandle((HANDLE)s, &provider))
 610     {
 611         WSASetLastError(WSAENOTSOCK);
 612         return SOCKET_ERROR;
 613     }
 614
 615     switch (provider->ProtocolInfo.iNetworkByteOrder)
 616     {
 617     case BIGENDIAN:
 618         *lphostshort = ntohs(netshort);
 619         break;
 620     case LITTLEENDIAN:
 621 #ifdef LE
 622         *lphostshort = netshort;
 623 #else
 624         *lphostshort = (((netshort & 0xFF00) >> 8) | ((netshort & 0x00FF) << 8));
 625 #endif
 626         break;
 627     }
 628     return 0;
 629 }
 630
 631
 632 /*
 633  * @unimplemented
 634  */
 635 FARPROC
 636 EXPORT
 637 WSASetBlockingHook(IN  FARPROC lpBlockFunc)
 638 {
 639     UNIMPLEMENTED
 640
 641     return (FARPROC)0;
 642 }
 643
 644
 645 /*
 646  * @unimplemented
 647  */
 648 INT
 649 EXPORT
 650 WSAUnhookBlockingHook(VOID)
 651 {
 652     UNIMPLEMENTED
 653
 654     return 0;
 655 }
 656
 657
 658 /*
 659  * @unimplemented
 660  */
 661 INT
 662 EXPORT
 663 WSAProviderConfigChange(IN OUT  LPHANDLE lpNotificationHandle,
 664                         IN      LPWSAOVERLAPPED lpOverlapped,
 665                         IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 666 {
 667     UNIMPLEMENTED
 668
 669     WSASetLastError(WSASYSCALLFAILURE);
 670     return SOCKET_ERROR;
 671 }
 672
 673
 674 /*
 675  * @unimplemented
 676  */
 677 INT
 678 EXPORT
 679 WSACancelAsyncRequest(IN  HANDLE hAsyncTaskHandle)
 680 {
 681     UNIMPLEMENTED
 682
 683     WSASetLastError(WSASYSCALLFAILURE);
 684     return SOCKET_ERROR;
 685 }
 686
 687 /* WinSock Service Provider support functions */
 688
 689 /*
 690  * @unimplemented
 691  */
 692 INT
 693 EXPORT
 694 WPUCompleteOverlappedRequest(IN  SOCKET s,
 695                              IN  LPWSAOVERLAPPED lpOverlapped,
 696                              IN  DWORD dwError,
 697                              IN  DWORD cbTransferred,
 698                              OUT LPINT lpErrno)
 699 {
 700     UNIMPLEMENTED
 701
 702     WSASetLastError(WSASYSCALLFAILURE);
 703     return SOCKET_ERROR;
 704 }
 705
 706
 707 /*
 708  * @unimplemented
 709  */
 710 INT
 711 EXPORT
 712 WSPStartup(IN  WORD wVersionRequested,
 713            OUT LPWSPDATA lpWSPData,
 714            IN  LPWSAPROTOCOL_INFOW lpProtocolInfo,
 715            IN  WSPUPCALLTABLE UpcallTable,
 716            OUT LPWSPPROC_TABLE lpProcTable)
 717 {
 718     UNIMPLEMENTED
 719
 720     return WSASYSCALLFAILURE;
 721 }
 722
 723
 724 /*
 725  * @unimplemented
 726  */
 727 INT
 728 EXPORT
 729 WSCDeinstallProvider(IN  LPGUID lpProviderId,
 730                      OUT LPINT lpErrno)
 731 {
 732     UNIMPLEMENTED
 733
 734     WSASetLastError(WSASYSCALLFAILURE);
 735     return SOCKET_ERROR;
 736 }
 737
 738
 739 /*
 740  * @unimplemented
 741  */
 742 INT
 743 EXPORT
 744 WSCEnumProtocols(IN      LPINT lpiProtocols,
 745                  OUT     LPWSAPROTOCOL_INFOW lpProtocolBuffer,
 746                  IN OUT  LPDWORD lpdwBufferLength,
 747                  OUT     LPINT lpErrno)
 748 {
 749     UNIMPLEMENTED
 750
 751     WSASetLastError(WSASYSCALLFAILURE);
 752     return SOCKET_ERROR;
 753 }
 754
 755
 756 /*
 757  * @unimplemented
 758  */
 759 INT
 760 EXPORT
 761 WSCGetProviderPath(IN      LPGUID lpProviderId,
 762                    OUT     LPWSTR lpszProviderDllPath,
 763                    IN OUT  LPINT lpProviderDllPathLen,
 764                    OUT     LPINT lpErrno)
 765 {
 766     UNIMPLEMENTED
 767
 768     WSASetLastError(WSASYSCALLFAILURE);
 769     return SOCKET_ERROR;
 770 }
 771
 772
 773 /*
 774  * @unimplemented
 775  */
 776 INT
 777 EXPORT
 778 WSCInstallProvider(IN  LPGUID lpProviderId,
 779                    IN  CONST WCHAR* lpszProviderDllPath,
 780                    IN  CONST LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 781                    IN  DWORD dwNumberOfEntries,
 782                    OUT LPINT lpErrno)
 783 {
 784     UNIMPLEMENTED
 785
 786     WSASetLastError(WSASYSCALLFAILURE);
 787     return SOCKET_ERROR;
 788 }
 789
 790
 791 /*
 792  * @unimplemented
 793  */
 794 INT
 795 EXPORT
 796 WSCEnableNSProvider(IN  LPGUID lpProviderId,
 797                     IN  BOOL fEnable)
 798 {
 799     UNIMPLEMENTED
 800
 801     WSASetLastError(WSASYSCALLFAILURE);
 802     return SOCKET_ERROR;
 803 }
 804
 805
 806 /*
 807  * @unimplemented
 808  */
 809 INT
 810 EXPORT
 811 WSCInstallNameSpace(IN  LPWSTR lpszIdentifier,
 812                     IN  LPWSTR lpszPathName,
 813                     IN  DWORD dwNameSpace,
 814                     IN  DWORD dwVersion,
 815                     IN  LPGUID lpProviderId)
 816 {
 817     UNIMPLEMENTED
 818
 819     WSASetLastError(WSASYSCALLFAILURE);
 820     return SOCKET_ERROR;
 821 }
 822
 823
 824 /*
 825  * @unimplemented
 826  */
 827 INT
 828 EXPORT
 829 WSCUnInstallNameSpace(IN  LPGUID lpProviderId)
 830 {
 831     UNIMPLEMENTED
 832
 833     WSASetLastError(WSASYSCALLFAILURE);
 834     return SOCKET_ERROR;
 835 }
 836
 837
 838 /*
 839  * @unimplemented
 840  */
 841 INT
 842 EXPORT
 843 WSCWriteProviderOrder(IN  LPDWORD lpwdCatalogEntryId,
 844                       IN  DWORD dwNumberOfEntries)
 845 {
 846     UNIMPLEMENTED
 847
 848     return WSASYSCALLFAILURE;
 849 }
 850
 851 /*
 852  * @unimplemented
 853  */
 854 INT
 855 EXPORT
 856 WSANSPIoctl(HANDLE           hLookup,
 857             DWORD            dwControlCode,
 858             LPVOID           lpvInBuffer,
 859             DWORD            cbInBuffer,
 860             LPVOID           lpvOutBuffer,
 861             DWORD            cbOutBuffer,
 862             LPDWORD          lpcbBytesReturned,
 863             LPWSACOMPLETION  lpCompletion)
 864 {
 865     UNIMPLEMENTED
 866
 867     WSASetLastError(WSASYSCALLFAILURE);
 868     return SOCKET_ERROR;
 869 }
 870
 871
 872 /*
 873  * @unimplemented
 874  */
 875 INT
 876 EXPORT
 877 WSCUpdateProvider(LPGUID lpProviderId,
 878                   const WCHAR FAR * lpszProviderDllPath,
 879                   const LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 880                   DWORD dwNumberOfEntries,
 881                   LPINT lpErrno)
 882 {
 883     UNIMPLEMENTED
 884
 885     WSASetLastError(WSASYSCALLFAILURE);
 886     return SOCKET_ERROR;
 887 }
 888
 889 /*
 890  * @unimplemented
 891  */
 892 INT
 893 EXPORT
 894 WSCWriteNameSpaceOrder(LPGUID lpProviderId,
 895                        DWORD dwNumberOfEntries)
 896 {
 897     UNIMPLEMENTED
 898
 899     return WSASYSCALLFAILURE;
 900 }
 901
 902 /*
 903  * @unimplemented
 904  */
 905 INT
 906 EXPORT
 907 getnameinfo(const struct sockaddr FAR * sa,
 908             socklen_t       salen,
 909             char FAR *      host,
 910             DWORD           hostlen,
 911             char FAR *      serv,
 912             DWORD           servlen,
 913             INT             flags)
 914 {
 915     UNIMPLEMENTED
 916
 917     WSASetLastError(WSASYSCALLFAILURE);
 918     return SOCKET_ERROR;
 919 }
 920
 921 /*
 922  * @unimplemented
 923  */
 924 VOID EXPORT WEP()
 925 {
 926     UNIMPLEMENTED
 927 }
 928
 929 /*
 930  * @unimplemented
 931  */
 932 BOOL EXPORT WSApSetPostRoutine(PVOID Routine)
 933 {
 934     UNIMPLEMENTED
 935
 936     return FALSE;
 937 }
 938
 939 /* EOF */