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