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