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 (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 167     {
 168         WSASetLastError(WSAENOTSOCK);
 169         return SOCKET_ERROR;
 170     }
 171
 172     Error = Provider->ProcTable.lpWSPSetSockOpt(s,
 173                                                   level,
 174                                                 optname,
 175                                                 optval,
 176                                                 optlen,
 177                                                 &Errno);
 178
 179     DereferenceProviderByPointer(Provider);
 180
 181     if (Error == SOCKET_ERROR)
 182     {
 183         WSASetLastError(Errno);
 184     }
 185
 186     return Error;
 187 }
 188
 189
 190 /*
 191  * @implemented
 192  */
 193 INT
 194 EXPORT
 195 shutdown(IN  SOCKET s,
 196          IN  INT how)
 197 {
 198     PCATALOG_ENTRY Provider;
 199     INT Errno;
 200     int Error;
 201
 202     if (!WSAINITIALIZED)
 203     {
 204         WSASetLastError(WSANOTINITIALISED);
 205         return SOCKET_ERROR;
 206     }
 207
 208     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 209     {
 210         WSASetLastError(WSAENOTSOCK);
 211         return SOCKET_ERROR;
 212     }
 213
 214     Error = Provider->ProcTable.lpWSPShutdown(s,
 215                                               how,
 216                                               &Errno);
 217
 218     DereferenceProviderByPointer(Provider);
 219
 220     if (Error == SOCKET_ERROR)
 221     {
 222         WSASetLastError(Errno);
 223     }
 224
 225     return Error;
 226 }
 227
 228
 229 /*
 230  * @implemented
 231  */
 232 INT
 233 EXPORT
 234 WSAAsyncSelect(IN  SOCKET s,
 235                IN  HWND hWnd,
 236                IN  UINT wMsg,
 237                IN  LONG lEvent)
 238 {
 239     PCATALOG_ENTRY Provider;
 240     INT Errno;
 241     int Error;
 242
 243     if (!WSAINITIALIZED)
 244     {
 245         WSASetLastError(WSANOTINITIALISED);
 246         return SOCKET_ERROR;
 247     }
 248
 249     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 250     {
 251         WSASetLastError(WSAENOTSOCK);
 252         return SOCKET_ERROR;
 253     }
 254
 255     Error = Provider->ProcTable.lpWSPAsyncSelect(s,
 256                                                  hWnd,
 257                                                  wMsg,
 258                                                  lEvent,
 259                                                  &Errno);
 260
 261     DereferenceProviderByPointer(Provider);
 262
 263     if (Error == SOCKET_ERROR)
 264     {
 265         WSASetLastError(Errno);
 266     }
 267
 268     return Error;
 269 }
 270
 271
 272 /*
 273  * @unimplemented
 274  */
 275 INT
 276 EXPORT
 277 WSACancelBlockingCall(VOID)
 278 {
 279 #if 0
 280     INT Errno;
 281     int Error;
 282     PCATALOG_ENTRY Provider;
 283
 284     if (!WSAINITIALIZED)
 285     {
 286         WSASetLastError(WSANOTINITIALISED);
 287         return SOCKET_ERROR;
 288     }
 289
 290     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 291     {
 292         WSASetLastError(WSAENOTSOCK);
 293         return SOCKET_ERROR;
 294     }
 295
 296     Error = Provider->ProcTable.lpWSPCancelBlockingCall(&Errno);
 297
 298     DereferenceProviderByPointer(Provider);
 299
 300     if (Error == SOCKET_ERROR)
 301     {
 302         WSASetLastError(Errno);
 303     }
 304
 305     return Error;
 306 #endif
 307
 308     UNIMPLEMENTED
 309
 310     WSASetLastError(WSASYSCALLFAILURE);
 311     return SOCKET_ERROR;
 312 }
 313
 314
 315 /*
 316  * @unimplemented
 317  */
 318 INT
 319 EXPORT
 320 WSADuplicateSocketA(IN  SOCKET s,
 321                     IN  DWORD dwProcessId,
 322                     OUT LPWSAPROTOCOL_INFOA lpProtocolInfo)
 323 {
 324 #if 0
 325     WSAPROTOCOL_INFOA ProtocolInfoU;
 326
 327     Error  = WSADuplicateSocketW(s,
 328                                dwProcessId,
 329                                &ProtocolInfoU);
 330
 331     if (Error == NO_ERROR)
 332     {
 333         UnicodeToAnsi(lpProtocolInfo,
 334                       ProtocolInfoU,
 335                       sizeof(
 336
 337     }
 338
 339     return Error;
 340 #endif
 341
 342     UNIMPLEMENTED
 343
 344     WSASetLastError(WSASYSCALLFAILURE);
 345     return SOCKET_ERROR;
 346 }
 347
 348
 349
 350 /*
 351  * @implemented
 352  */
 353 INT
 354 EXPORT
 355 WSADuplicateSocketW(IN  SOCKET s,
 356                     IN  DWORD dwProcessId,
 357                     OUT LPWSAPROTOCOL_INFOW lpProtocolInfo)
 358 {
 359     INT Errno;
 360     int Error;
 361     PCATALOG_ENTRY Provider;
 362
 363     if (!WSAINITIALIZED)
 364     {
 365         WSASetLastError(WSANOTINITIALISED);
 366         return SOCKET_ERROR;
 367     }
 368
 369     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 370     {
 371         WSASetLastError(WSAENOTSOCK);
 372         return SOCKET_ERROR;
 373     }
 374
 375     Error = Provider->ProcTable.lpWSPDuplicateSocket(s,
 376                                                      dwProcessId,
 377                                                      lpProtocolInfo,
 378                                                      &Errno);
 379     DereferenceProviderByPointer(Provider);
 380
 381     if (Error == SOCKET_ERROR)
 382     {
 383         WSASetLastError(Errno);
 384     }
 385
 386     return Error;
 387 }
 388
 389
 390 /*
 391  * @unimplemented
 392  */
 393 INT
 394 EXPORT
 395 WSAEnumProtocolsA(IN      LPINT lpiProtocols,
 396                   OUT     LPWSAPROTOCOL_INFOA lpProtocolBuffer,
 397                   IN OUT  LPDWORD lpdwBufferLength)
 398 {
 399     UNIMPLEMENTED
 400
 401     WSASetLastError(WSASYSCALLFAILURE);
 402     return SOCKET_ERROR;
 403 }
 404
 405
 406 /*
 407  * @unimplemented
 408  */
 409 INT
 410 EXPORT
 411 WSAEnumProtocolsW(IN      LPINT lpiProtocols,
 412                   OUT     LPWSAPROTOCOL_INFOW lpProtocolBuffer,
 413                   IN OUT  LPDWORD lpdwBufferLength)
 414 {
 415     UNIMPLEMENTED
 416
 417     WSASetLastError(WSASYSCALLFAILURE);
 418     return SOCKET_ERROR;
 419 }
 420
 421
 422 /*
 423  * @implemented
 424  */
 425 BOOL
 426 EXPORT
 427 WSAGetOverlappedResult(IN  SOCKET s,
 428                        IN  LPWSAOVERLAPPED lpOverlapped,
 429                        OUT LPDWORD lpcbTransfer,
 430                        IN  BOOL fWait,
 431                        OUT LPDWORD lpdwFlags)
 432 {
 433     INT Errno;
 434     BOOL Success;
 435     PCATALOG_ENTRY Provider;
 436
 437     if (!WSAINITIALIZED)
 438     {
 439         WSASetLastError(WSANOTINITIALISED);
 440         return SOCKET_ERROR;
 441     }
 442
 443     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 444     {
 445         WSASetLastError(WSAENOTSOCK);
 446         return SOCKET_ERROR;
 447     }
 448
 449     Success = Provider->ProcTable.lpWSPGetOverlappedResult(s,
 450                                                           lpOverlapped,
 451                                                           lpcbTransfer,
 452                                                           fWait,
 453                                                           lpdwFlags,
 454                                                           &Errno);
 455     DereferenceProviderByPointer(Provider);
 456
 457     if (Success == FALSE)
 458     {
 459         WSASetLastError(Errno);
 460     }
 461
 462     return Success;
 463 }
 464
 465
 466 /*
 467  * @unimplemented
 468  */
 469 BOOL
 470 EXPORT
 471 WSAGetQOSByName(IN      SOCKET s,
 472                 IN OUT  LPWSABUF lpQOSName,
 473                 OUT     LPQOS lpQOS)
 474 {
 475     UNIMPLEMENTED
 476
 477     WSASetLastError(WSASYSCALLFAILURE);
 478     return FALSE;
 479 }
 480
 481
 482 /*
 483  * @unimplemented
 484  */
 485 INT
 486 EXPORT
 487 WSAHtonl(IN  SOCKET s,
 488          IN  ULONG hostLONG,
 489          OUT ULONG FAR* lpnetlong)
 490 {
 491     UNIMPLEMENTED
 492
 493     WSASetLastError(WSASYSCALLFAILURE);
 494     return SOCKET_ERROR;
 495 }
 496
 497
 498 /*
 499  * @unimplemented
 500  */
 501 INT
 502 EXPORT
 503 WSAHtons(IN  SOCKET s,
 504          IN  USHORT hostshort,
 505          OUT USHORT FAR* lpnetshort)
 506 {
 507     UNIMPLEMENTED
 508
 509     WSASetLastError(WSASYSCALLFAILURE);
 510     return SOCKET_ERROR;
 511 }
 512
 513
 514 /*
 515  * @unimplemented
 516  */
 517 BOOL
 518 EXPORT
 519 WSAIsBlocking(VOID)
 520 {
 521     UNIMPLEMENTED
 522
 523     return FALSE;
 524 }
 525
 526
 527 /*
 528  * @unimplemented
 529  */
 530 SOCKET
 531 EXPORT
 532 WSAJoinLeaf(IN  SOCKET s,
 533             IN  CONST struct sockaddr *name,
 534             IN  INT namelen,
 535             IN  LPWSABUF lpCallerData,
 536             OUT LPWSABUF lpCalleeData,
 537             IN  LPQOS lpSQOS,
 538             IN  LPQOS lpGQOS,
 539             IN  DWORD dwFlags)
 540 {
 541     UNIMPLEMENTED
 542
 543     WSASetLastError(WSASYSCALLFAILURE);
 544     return INVALID_SOCKET;
 545 }
 546
 547
 548 /*
 549  * @unimplemented
 550  */
 551 INT
 552 EXPORT
 553 WSANtohl(IN  SOCKET s,
 554          IN  ULONG netlong,
 555          OUT ULONG FAR* lphostlong)
 556 {
 557     UNIMPLEMENTED
 558
 559     WSASetLastError(WSASYSCALLFAILURE);
 560     return SOCKET_ERROR;
 561 }
 562
 563
 564 /*
 565  * @unimplemented
 566  */
 567 INT
 568 EXPORT
 569 WSANtohs(IN  SOCKET s,
 570          IN  USHORT netshort,
 571          OUT USHORT FAR* lphostshort)
 572 {
 573     UNIMPLEMENTED
 574
 575     WSASetLastError(WSASYSCALLFAILURE);
 576     return SOCKET_ERROR;
 577 }
 578
 579
 580 /*
 581  * @unimplemented
 582  */
 583 FARPROC
 584 EXPORT
 585 WSASetBlockingHook(IN  FARPROC lpBlockFunc)
 586 {
 587     UNIMPLEMENTED
 588
 589     return (FARPROC)0;
 590 }
 591
 592
 593 /*
 594  * @unimplemented
 595  */
 596 INT
 597 EXPORT
 598 WSAUnhookBlockingHook(VOID)
 599 {
 600     UNIMPLEMENTED
 601
 602     return 0;
 603 }
 604
 605
 606 /*
 607  * @unimplemented
 608  */
 609 INT
 610 EXPORT
 611 WSAProviderConfigChange(IN OUT  LPHANDLE lpNotificationHandle,
 612                         IN      LPWSAOVERLAPPED lpOverlapped,
 613                         IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 614 {
 615     UNIMPLEMENTED
 616
 617     WSASetLastError(WSASYSCALLFAILURE);
 618     return SOCKET_ERROR;
 619 }
 620
 621
 622 /*
 623  * @unimplemented
 624  */
 625 INT
 626 EXPORT
 627 WSACancelAsyncRequest(IN  HANDLE hAsyncTaskHandle)
 628 {
 629     UNIMPLEMENTED
 630
 631     WSASetLastError(WSASYSCALLFAILURE);
 632     return SOCKET_ERROR;
 633 }
 634
 635 /* WinSock Service Provider support functions */
 636
 637 /*
 638  * @unimplemented
 639  */
 640 INT
 641 EXPORT
 642 WPUCompleteOverlappedRequest(IN  SOCKET s,
 643                              IN  LPWSAOVERLAPPED lpOverlapped,
 644                              IN  DWORD dwError,
 645                              IN  DWORD cbTransferred,
 646                              OUT LPINT lpErrno)
 647 {
 648     UNIMPLEMENTED
 649
 650     WSASetLastError(WSASYSCALLFAILURE);
 651     return SOCKET_ERROR;
 652 }
 653
 654
 655 /*
 656  * @unimplemented
 657  */
 658 INT
 659 EXPORT
 660 WSPStartup(IN  WORD wVersionRequested,
 661            OUT LPWSPDATA lpWSPData,
 662            IN  LPWSAPROTOCOL_INFOW lpProtocolInfo,
 663            IN  WSPUPCALLTABLE UpcallTable,
 664            OUT LPWSPPROC_TABLE lpProcTable)
 665 {
 666     UNIMPLEMENTED
 667
 668     return WSASYSCALLFAILURE;
 669 }
 670
 671
 672 /*
 673  * @unimplemented
 674  */
 675 INT
 676 EXPORT
 677 WSCDeinstallProvider(IN  LPGUID lpProviderId,
 678                      OUT LPINT lpErrno)
 679 {
 680     UNIMPLEMENTED
 681
 682     WSASetLastError(WSASYSCALLFAILURE);
 683     return SOCKET_ERROR;
 684 }
 685
 686
 687 /*
 688  * @unimplemented
 689  */
 690 INT
 691 EXPORT
 692 WSCEnumProtocols(IN      LPINT lpiProtocols,
 693                  OUT     LPWSAPROTOCOL_INFOW lpProtocolBuffer,
 694                  IN OUT  LPDWORD lpdwBufferLength,
 695                  OUT     LPINT lpErrno)
 696 {
 697     UNIMPLEMENTED
 698
 699     WSASetLastError(WSASYSCALLFAILURE);
 700     return SOCKET_ERROR;
 701 }
 702
 703
 704 /*
 705  * @unimplemented
 706  */
 707 INT
 708 EXPORT
 709 WSCGetProviderPath(IN      LPGUID lpProviderId,
 710                    OUT     LPWSTR lpszProviderDllPath,
 711                    IN OUT  LPINT lpProviderDllPathLen,
 712                    OUT     LPINT lpErrno)
 713 {
 714     UNIMPLEMENTED
 715
 716     WSASetLastError(WSASYSCALLFAILURE);
 717     return SOCKET_ERROR;
 718 }
 719
 720
 721 /*
 722  * @unimplemented
 723  */
 724 INT
 725 EXPORT
 726 WSCInstallProvider(IN  CONST LPGUID lpProviderId,
 727                    IN  CONST LPWSTR lpszProviderDllPath,
 728                    IN  CONST LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 729                    IN  DWORD dwNumberOfEntries,
 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 WSCEnableNSProvider(IN  LPGUID lpProviderId,
 745                     IN  BOOL fEnable)
 746 {
 747     UNIMPLEMENTED
 748
 749     WSASetLastError(WSASYSCALLFAILURE);
 750     return SOCKET_ERROR;
 751 }
 752
 753
 754 /*
 755  * @unimplemented
 756  */
 757 INT
 758 EXPORT
 759 WSCInstallNameSpace(IN  LPWSTR lpszIdentifier,
 760                     IN  LPWSTR lpszPathName,
 761                     IN  DWORD dwNameSpace,
 762                     IN  DWORD dwVersion,
 763                     IN  LPGUID lpProviderId)
 764 {
 765     UNIMPLEMENTED
 766
 767     WSASetLastError(WSASYSCALLFAILURE);
 768     return SOCKET_ERROR;
 769 }
 770
 771
 772 /*
 773  * @unimplemented
 774  */
 775 INT
 776 EXPORT
 777 WSCUnInstallNameSpace(IN  LPGUID lpProviderId)
 778 {
 779     UNIMPLEMENTED
 780
 781     WSASetLastError(WSASYSCALLFAILURE);
 782     return SOCKET_ERROR;
 783 }
 784
 785
 786 /*
 787  * @unimplemented
 788  */
 789 INT
 790 EXPORT
 791 WSCWriteProviderOrder(IN  LPDWORD lpwdCatalogEntryId,
 792                       IN  DWORD dwNumberOfEntries)
 793 {
 794     UNIMPLEMENTED
 795
 796     return WSASYSCALLFAILURE;
 797 }
 798
 799 /*
 800  * @unimplemented
 801  */
 802 INT
 803 EXPORT
 804 WSANSPIoctl(HANDLE           hLookup,
 805             DWORD            dwControlCode,
 806             LPVOID           lpvInBuffer,
 807             DWORD            cbInBuffer,
 808             LPVOID           lpvOutBuffer,
 809             DWORD            cbOutBuffer,
 810             LPDWORD          lpcbBytesReturned,
 811             LPWSACOMPLETION  lpCompletion)
 812 {
 813     UNIMPLEMENTED
 814
 815     WSASetLastError(WSASYSCALLFAILURE);
 816     return SOCKET_ERROR;
 817 }
 818
 819
 820 /*
 821  * @unimplemented
 822  */
 823 INT
 824 EXPORT
 825 WSCUpdateProvider(LPGUID lpProviderId,
 826                   const WCHAR FAR * lpszProviderDllPath,
 827                   const LPWSAPROTOCOL_INFOW lpProtocolInfoList,
 828                   DWORD dwNumberOfEntries,
 829                   LPINT lpErrno)
 830 {
 831     UNIMPLEMENTED
 832
 833     WSASetLastError(WSASYSCALLFAILURE);
 834     return SOCKET_ERROR;
 835 }
 836
 837 /*
 838  * @unimplemented
 839  */
 840 INT
 841 EXPORT
 842 WSCWriteNameSpaceOrder(LPGUID lpProviderId,
 843                        DWORD dwNumberOfEntries)
 844 {
 845     UNIMPLEMENTED
 846
 847     return WSASYSCALLFAILURE;
 848 }
 849
 850 /*
 851  * @unimplemented
 852  */
 853 INT
 854 EXPORT
 855 getnameinfo(const struct sockaddr FAR * sa,
 856             socklen_t       salen,
 857             char FAR *      host,
 858             DWORD           hostlen,
 859             char FAR *      serv,
 860             DWORD           servlen,
 861             INT             flags)
 862 {
 863     UNIMPLEMENTED
 864
 865     WSASetLastError(WSASYSCALLFAILURE);
 866     return SOCKET_ERROR;
 867 }
 868
 869 /*
 870  * @unimplemented
 871  */
 872 VOID EXPORT WEP()
 873 {
 874     UNIMPLEMENTED
 875 }
 876
 877 /*
 878  * @unimplemented
 879  */
 880 BOOL EXPORT WSApSetPostRoutine(PVOID Routine)
 881 {
 882     UNIMPLEMENTED
 883
 884     return FALSE;
 885 }
 886
 887 /* EOF */