reactos/dll/win32/ws2_32/src/getxbyxx.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS WinSock 2 API
   4  * FILE:        dll/win32/ws2_32_new/src/getxbyxx.c
   5  * PURPOSE:     Get X by Y Functions for Name Resolution.
   6  * PROGRAMMER:  Alex Ionescu (alex@relsoft.net)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ws2_32.h>
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* DATA **********************************************************************/
  17
  18 AFPROTOCOLS afp[2] = {{AF_INET, IPPROTO_UDP}, {AF_INET, IPPROTO_TCP}};
  19
  20 /* FUNCTIONS *****************************************************************/
  21
  22 VOID
  23 WSAAPI
  24 FixList(PCHAR **List,
  25         ULONG_PTR Base)
  26 {
  27     /* Make sure it's valid */
  28     if(*List)
  29     {
  30         PCHAR *Addr;
  31
  32         /* Get the right base */
  33         Addr = *List = (PCHAR*)(((ULONG_PTR)*List + Base));
  34
  35         /* Loop the pointers */
  36         while(*Addr)
  37         {
  38             /* Rebase them too */
  39             *Addr = (PCHAR)(((ULONG_PTR)*Addr + Base));
  40             Addr++;
  41         }
  42     }
  43 }
  44
  45 VOID
  46 WSAAPI
  47 UnpackServEnt(PSERVENT Servent)
  48 {
  49     ULONG_PTR ServentPtr = (ULONG_PTR)Servent;
  50
  51     /* Convert all the List Offsets to Pointers */
  52     FixList(&Servent->s_aliases, ServentPtr);
  53
  54     /* Convert the Name and Protocol Offsets to Pointers */
  55     Servent->s_name = (PCHAR)(Servent->s_name + ServentPtr);
  56     Servent->s_proto = (PCHAR)(Servent->s_proto + ServentPtr);
  57 }
  58
  59 VOID
  60 WSAAPI
  61 UnpackHostEnt(PHOSTENT Hostent)
  62 {
  63     ULONG_PTR HostentPtr = (ULONG_PTR)Hostent;
  64
  65     /* Convert the Name Offset to a Pointer */
  66     if(Hostent->h_name) Hostent->h_name = (PCHAR)(Hostent->h_name + HostentPtr);
  67
  68     /* Convert all the List Offsets to Pointers */
  69     FixList(&Hostent->h_aliases, HostentPtr);
  70     FixList(&Hostent->h_addr_list, HostentPtr);
  71 }
  72
  73 VOID
  74 WSAAPI
  75 Local_Ip4AddresstoString(IN PCHAR AddressBuffer,
  76                          IN PCHAR Address)
  77 {
  78     /* Convert the address into IPv4 format */
  79     sprintf(AddressBuffer, "%u.%u.%u.%u",
  80             ((unsigned)Address[0] & 0xff),
  81             ((unsigned)Address[1] & 0xff),
  82             ((unsigned)Address[2] & 0xff),
  83             ((unsigned)Address[3] & 0xff));
  84 }
  85
  86 VOID
  87 WSAAPI
  88 Local_Ip6AddresstoString(IN PCHAR AddressBuffer,
  89                          IN PCHAR Address)
  90 {
  91     DWORD i;
  92
  93     /* Convert the address into IPv6 format */
  94     for (i = 0; i < 8; i++)
  95     {
  96         sprintf(AddressBuffer, "%x:",
  97                 ((unsigned)Address[0] & 0xff));
  98     }
  99 }
 100
 101 LPBLOB
 102 WSAAPI
 103 getxyDataEnt(IN OUT PCHAR *Results,
 104              IN DWORD Length,
 105              IN LPSTR Name,
 106              IN LPCGUID Type,
 107              IN LPSTR *NewName)
 108 {
 109     PWSAQUERYSETA WsaQuery = (PWSAQUERYSETA)*Results;
 110     INT ErrorCode;
 111     DWORD NewLength = Length;
 112     HANDLE RnRHandle;
 113     LPBLOB Blob = NULL;
 114     PVOID NewResults = NULL;
 115     DWORD dwControlFlags = LUP_RETURN_NAME;
 116
 117     /* Assume empty return name */
 118     if (NewName) *NewName = NULL;
 119
 120     /* Set up the Winsock Service Query */
 121     RtlZeroMemory(WsaQuery, sizeof(*WsaQuery));
 122     WsaQuery->dwSize = sizeof(*WsaQuery);
 123     WsaQuery->lpszServiceInstanceName = Name;
 124     WsaQuery->lpServiceClassId = (LPGUID)Type;
 125     WsaQuery->dwNameSpace = NS_ALL;
 126     WsaQuery->dwNumberOfProtocols = sizeof(afp)/sizeof(afp[0]);
 127     WsaQuery->lpafpProtocols = afp;
 128
 129     if(!IsEqualGUID(Type, &HostnameGuid))
 130         dwControlFlags |= LUP_RETURN_BLOB;
 131
 132     /* Send the Query Request to find a Service */
 133     ErrorCode = WSALookupServiceBeginA(WsaQuery,
 134                                        dwControlFlags,
 135                                        &RnRHandle);
 136
 137     if(ErrorCode == ERROR_SUCCESS)
 138     {
 139         while (TRUE)
 140         {
 141             /* Service was found, send the real query */
 142             ErrorCode = WSALookupServiceNextA(RnRHandle,
 143                                               0,
 144                                               &NewLength,
 145                                               WsaQuery);
 146
 147             /* Return the information requested */
 148             if(ErrorCode == ERROR_SUCCESS)
 149             {
 150                 /* Get the Blob and check if we have one */
 151                 Blob = WsaQuery->lpBlob;
 152                 if(Blob)
 153                 {
 154                     /* Did they want the name back? */
 155                     if(NewName) *NewName = WsaQuery->lpszServiceInstanceName;
 156                 }
 157                 else
 158                 {
 159                     /* Check if this was a Hostname lookup */
 160                     if (IsEqualGUID(Type, &HostnameGuid))
 161                     {
 162                         /* Return the name anyways */
 163                         if(NewName) *NewName = WsaQuery->lpszServiceInstanceName;
 164                     }
 165                     else
 166                     {
 167                         /* We don't have a blob, sorry */
 168                         ErrorCode = WSANO_DATA;
 169                     }
 170                 }
 171             }
 172             else
 173             {
 174                 /* WSALookupServiceEnd will set its own error, so save ours */
 175                 ErrorCode = GetLastError();
 176
 177                 /* Check if we failed because of missing buffer space */
 178                 if ((ErrorCode == WSAEFAULT) && (Length > RNR_BUFFER_SIZE))
 179                 {
 180                     /* Allocate a new buffer */
 181                     NewResults = HeapAlloc(WsSockHeap, 0, Length);
 182                     if (NewResults)
 183                     {
 184                         /* Tell the caller his new buffer */
 185                         *Results = NewResults;
 186
 187                         /* Update the WSA Query's location */
 188                         WsaQuery = (PWSAQUERYSETA)NewResults;
 189
 190                         /* Loop again */
 191                         continue;
 192                     }
 193                     else
 194                     {
 195                         /* No memory to allocate the new buffer */
 196                         ErrorCode = WSA_NOT_ENOUGH_MEMORY;
 197                     }
 198                 }
 199             }
 200
 201             /* Finish the Query Request */
 202             WSALookupServiceEnd(RnRHandle);
 203
 204             /* Now set the Last Error */
 205             if(ErrorCode != ERROR_SUCCESS) SetLastError(ErrorCode);
 206
 207             /* Leave the loop */
 208             break;
 209         }
 210     }
 211
 212     /* Return the blob */
 213     return Blob;
 214 }
 215
 216 /*
 217  * @implemented
 218  */
 219 PHOSTENT
 220 WSAAPI
 221 gethostbyname(IN const char FAR * name)
 222 {
 223     PHOSTENT Hostent;
 224     LPBLOB Blob;
 225     INT ErrorCode;
 226     CHAR ResultsBuffer[RNR_BUFFER_SIZE];
 227     PCHAR Results = ResultsBuffer;
 228     CHAR szLocalName[MAX_HOSTNAME_LEN];
 229     PCHAR pszName;
 230     PWSPROCESS Process;
 231     PWSTHREAD Thread;
 232     DPRINT("gethostbyname: %s\n", name);
 233
 234     /* Enter prolog */
 235     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 236     {
 237         /* Leave now */
 238         SetLastError(ErrorCode);
 239         return NULL;
 240     }
 241
 242     /* Check if no name was given */
 243     if(!name || !*name)
 244     {
 245         /* This means we should do a local lookup first */
 246         if(gethostname(szLocalName, MAX_HOSTNAME_LEN) != NO_ERROR) return(NULL);
 247         pszName = szLocalName;
 248     }
 249     else
 250     {
 251         /* Use the name tha twas given to us */
 252         pszName = (PCHAR)name;
 253     }
 254
 255     /* Get the Hostname in a Blob Structure */
 256     Blob = getxyDataEnt(&Results,
 257                         RNR_BUFFER_SIZE,
 258                         pszName,
 259                         &HostAddrByNameGuid,
 260                         0);
 261
 262     /* Check if we didn't get a blob, or if we got an empty name */
 263     if (!(Blob) && (!(name) || !(*name)))
 264     {
 265         /* Try a new query */
 266         Blob = getxyDataEnt(&Results,
 267                             RNR_BUFFER_SIZE,
 268                             NULL,
 269                             &HostAddrByNameGuid,
 270                             0);
 271     }
 272
 273     /* Check if we got a blob */
 274     if(Blob)
 275     {
 276         /* Copy the blob to our buffer and convert it */
 277         Hostent = WsThreadBlobToHostent(Thread, Blob);
 278
 279         /* Unpack the hostent */
 280         if(Hostent) UnpackHostEnt(Hostent);
 281     }
 282     else
 283     {
 284         /* We failed, so zero it out */
 285         Hostent = NULL;
 286
 287         /* Normalize the error message */
 288         if(GetLastError() == WSASERVICE_NOT_FOUND)
 289         {
 290             SetLastError(WSAHOST_NOT_FOUND);
 291         }
 292     }
 293
 294     /* Check if we received a newly allocated buffer; free it. */
 295     if (Results != ResultsBuffer) HeapFree(WsSockHeap, 0, Results);
 296
 297     /* Notify RAS Auto-dial helper */
 298     if (Hostent) WSNoteSuccessfulHostentLookup(name, *Hostent->h_addr);
 299
 300     /* Return the hostent */
 301     return Hostent;
 302 }
 303
 304 /*
 305  * @implemented
 306  */
 307 PHOSTENT
 308 WSAAPI
 309 gethostbyaddr(IN const char FAR * addr,
 310               IN int len,
 311               IN int type)
 312 {
 313     CHAR AddressBuffer[100];
 314     PHOSTENT Hostent;
 315     LPBLOB Blob;
 316     CHAR ResultsBuffer[RNR_BUFFER_SIZE];
 317     PCHAR Results = ResultsBuffer;
 318     PWSPROCESS Process;
 319     PWSTHREAD Thread;
 320     INT ErrorCode;
 321     DPRINT("gethostbyaddr: %s\n", addr);
 322
 323     /* Enter prolog */
 324     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 325     {
 326         /* Leave now */
 327         SetLastError(ErrorCode);
 328         return NULL;
 329     }
 330
 331     /* Check for valid address pointer */
 332     if (!addr)
 333     {
 334         /* Fail */
 335         SetLastError(WSAEINVAL);
 336         return NULL;
 337     }
 338
 339     /* Check which type it is */
 340     if (type == AF_INET)
 341     {
 342         /* Use IPV4 Address to String */
 343         Local_Ip4AddresstoString(AddressBuffer, (PCHAR)addr);
 344     }
 345     else if (type == AF_INET6)
 346     {
 347         /* Use IPV6 Address to String */
 348         Local_Ip6AddresstoString(AddressBuffer, (PCHAR)addr);
 349     }
 350     else
 351     {
 352         /* Invalid address type; fail */
 353         SetLastError(WSAEINVAL);
 354         return NULL;
 355     }
 356
 357     /* Get the Hostname in a Blob Structure */
 358     Blob = getxyDataEnt(&Results,
 359                         RNR_BUFFER_SIZE,
 360                         AddressBuffer,
 361                         &AddressGuid,
 362                         0);
 363
 364     /* Check if we got a blob */
 365     if(Blob)
 366     {
 367         /* Copy the blob to our buffer and convert it */
 368         Hostent = WsThreadBlobToHostent(Thread, Blob);
 369
 370         /* Unpack the hostent */
 371         if(Hostent) UnpackHostEnt(Hostent);
 372     }
 373     else
 374     {
 375         /* We failed, so zero it out */
 376         Hostent = NULL;
 377
 378         /* Normalize the error message */
 379         if(GetLastError() == WSASERVICE_NOT_FOUND)
 380         {
 381             SetLastError(WSAHOST_NOT_FOUND);
 382         }
 383     }
 384
 385     /* Check if we received a newly allocated buffer; free it. */
 386     if (Results != ResultsBuffer) HeapFree(WsSockHeap, 0, Results);
 387
 388     /* Return the hostent */
 389     return Hostent;
 390 }
 391
 392 /*
 393  * @implemented
 394  */
 395 INT
 396 WSAAPI
 397 gethostname(OUT char FAR * name,
 398             IN INT namelen)
 399 {
 400     PCHAR Name = NULL;
 401     CHAR ResultsBuffer[RNR_BUFFER_SIZE];
 402     PCHAR Results = ResultsBuffer;
 403     DPRINT("gethostname: %p\n", name);
 404
 405     if (!name || namelen < 1)
 406     {
 407         SetLastError(WSAEFAULT);
 408         return SOCKET_ERROR;
 409     }
 410     /* Get the Hostname in a String */
 411     /* getxyDataEnt does not return blob for HostnameGuid */
 412     getxyDataEnt(&Results, RNR_BUFFER_SIZE, NULL, &HostnameGuid, &Name);
 413     if(Name)
 414     {
 415         /* Copy it */
 416         strncpy(name, Name, namelen-1);
 417     }
 418
 419     /* Check if we received a newly allocated buffer; free it. */
 420     if (Results != ResultsBuffer) HeapFree(WsSockHeap, 0, Results);
 421
 422     /* Return success */
 423     return ERROR_SUCCESS;
 424 }
 425
 426 /*
 427  * @implemented
 428  */
 429 PSERVENT
 430 WSAAPI
 431 getservbyport(IN int port,
 432               IN const char FAR * proto)
 433 {
 434     PSERVENT Servent;
 435     LPBLOB Blob;
 436     CHAR ResultsBuffer[RNR_BUFFER_SIZE];
 437     PCHAR Results = ResultsBuffer;
 438     PCHAR PortName;
 439     PWSPROCESS Process;
 440     PWSTHREAD Thread;
 441     INT ErrorCode;
 442     DPRINT("getservbyport: %s\n", proto);
 443
 444     /* Enter prolog */
 445     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 446     {
 447         /* Leave now */
 448         SetLastError(ErrorCode);
 449         return NULL;
 450     }
 451
 452     /* No protocol specified */
 453     if(!proto) proto = "";
 454
 455     /* Allocate memory for the port name */
 456     PortName = HeapAlloc(WsSockHeap, 0, strlen(proto) + 1 + 1 + 5);
 457     if (!PortName)
 458     {
 459         /* Fail */
 460         SetLastError(WSA_NOT_ENOUGH_MEMORY);
 461         return NULL;
 462     }
 463
 464     /* Put it into the right syntax */
 465     sprintf(PortName, "%d/%s", (ntohs(port) & 0xffff), proto);
 466
 467     /* Get the Service in a Blob */
 468     Blob = getxyDataEnt(&Results, RNR_BUFFER_SIZE, PortName, &IANAGuid, 0);
 469
 470     /* Free the string we sent */
 471     HeapFree(WsSockHeap, 0, PortName);
 472
 473     /* Check if we got a blob */
 474     if(Blob)
 475     {
 476         /* Copy the blob to our buffer and convert it */
 477         Servent = WsThreadBlobToServent(Thread, Blob);
 478
 479         /* Unpack the hostent */
 480         if(Servent) UnpackServEnt(Servent);
 481     }
 482     else
 483     {
 484         /* We failed, so zero it out */
 485         Servent = 0;
 486     }
 487
 488     /* Check if we received a newly allocated buffer; free it. */
 489     if (Results != ResultsBuffer) HeapFree(WsSockHeap, 0, Results);
 490
 491     /* Return the hostent */
 492     return Servent;
 493 }
 494
 495 /*
 496  * @implemented
 497  */
 498 PSERVENT
 499 WSAAPI
 500 getservbyname(IN const char FAR * name,
 501               IN const char FAR * proto)
 502 {
 503     PSERVENT Servent;
 504     LPBLOB Blob;
 505     CHAR ResultsBuffer[RNR_BUFFER_SIZE];
 506     PCHAR Results = ResultsBuffer;
 507     PCHAR PortName;
 508     PWSPROCESS Process;
 509     PWSTHREAD Thread;
 510     INT ErrorCode;
 511     DPRINT("getservbyname: %s\n", name);
 512
 513     /* Enter prolog */
 514     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 515     {
 516         /* Leave now */
 517         SetLastError(ErrorCode);
 518         return NULL;
 519     }
 520
 521     /* No protocol specified */
 522     if(!proto) proto = "";
 523
 524     /* Allocate buffer for it */
 525     PortName = HeapAlloc(WsSockHeap, 0, strlen(proto) + 1 + strlen(name) + 1);
 526     if (!PortName)
 527     {
 528         /* Fail */
 529         SetLastError(WSA_NOT_ENOUGH_MEMORY);
 530         return NULL;
 531     }
 532
 533     /* Put it into the right syntax */
 534     sprintf(PortName, "%s/%s", name, proto);
 535
 536     /* Get the Service in a Blob */
 537     Blob = getxyDataEnt(&Results, RNR_BUFFER_SIZE, PortName, &IANAGuid, 0);
 538
 539     /* Free the string we sent */
 540     HeapFree(WsSockHeap, 0, PortName);
 541
 542     /* Check if we got a blob */
 543     if(Blob)
 544     {
 545         /* Copy the blob to our buffer and convert it */
 546         Servent = WsThreadBlobToServent(Thread, Blob);
 547
 548         /* Unpack the hostent */
 549         if(Servent) UnpackServEnt(Servent);
 550     }
 551     else
 552     {
 553         /* We failed, so zero it out */
 554         Servent = 0;
 555     }
 556
 557     /* Check if we received a newly allocated buffer; free it. */
 558     if (Results != ResultsBuffer) HeapFree(WsSockHeap, 0, Results);
 559
 560     /* Return the hostent */
 561     return Servent;
 562 }
 563
 564 /*
 565  * @implemented
 566  */
 567 HANDLE
 568 WSAAPI
 569 WSAAsyncGetHostByAddr(IN HWND hWnd,
 570                       IN UINT wMsg,
 571                       IN CONST CHAR FAR *Address,
 572                       IN INT Length,
 573                       IN INT Type,
 574                       OUT CHAR FAR *Buffer,
 575                       IN INT BufferLength)
 576 {
 577     HANDLE TaskHandle;
 578     PWSPROCESS Process;
 579     PWSTHREAD Thread;
 580     PVOID AddressCopy;
 581     PWSASYNCBLOCK AsyncBlock;
 582     INT ErrorCode;
 583     DPRINT("WSAAsyncGetHostByAddr: %lx, %lx, %s\n", hWnd, wMsg, Address);
 584
 585     /* Enter prolog */
 586     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 587     {
 588         /* Leave now */
 589         SetLastError(ErrorCode);
 590         return NULL;
 591     }
 592
 593     /* Initialize the Async Thread */
 594     if (!WsAsyncCheckAndInitThread())
 595     {
 596         /* Fail */
 597         SetLastError(WSAENOBUFS);
 598         return NULL;
 599     }
 600
 601     /* Allocate an async block */
 602     if (!(AsyncBlock = WsAsyncAllocateBlock(Length)))
 603     {
 604         /* Fail */
 605         SetLastError(WSAENOBUFS);
 606         return NULL;
 607     }
 608
 609     /* Make a copy of the address */
 610     AddressCopy = AsyncBlock + 1;
 611     RtlMoveMemory(AddressCopy, Address, Length);
 612
 613     /* Initialize the Async Block */
 614     AsyncBlock->Operation = WsAsyncGetHostByAddr;
 615     AsyncBlock->GetHost.hWnd = hWnd;
 616     AsyncBlock->GetHost.wMsg = wMsg;
 617     AsyncBlock->GetHost.ByWhat = AddressCopy;
 618     AsyncBlock->GetHost.Length = Length;
 619     AsyncBlock->GetHost.Type = Type;
 620     AsyncBlock->GetHost.Buffer = Buffer;
 621     AsyncBlock->GetHost.BufferLength = BufferLength;
 622
 623     /* Save the task handle and queue the request */
 624     TaskHandle = AsyncBlock->TaskHandle;
 625     WsAsyncQueueRequest(AsyncBlock);
 626
 627     /* Return the task handle */
 628     return TaskHandle;
 629 }
 630
 631 /*
 632  * @implemented
 633  */
 634 HANDLE
 635 WSAAPI
 636 WSAAsyncGetHostByName(IN HWND hWnd,
 637                       IN UINT wMsg,
 638                       IN CONST CHAR FAR *Name,
 639                       OUT CHAR FAR *Buffer,
 640                       IN INT BufferLength)
 641 {
 642     HANDLE TaskHandle;
 643     PWSPROCESS Process;
 644     PWSTHREAD Thread;
 645     PWSASYNCBLOCK AsyncBlock;
 646     INT ErrorCode;
 647     PVOID NameCopy;
 648     DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %s\n", hWnd, wMsg, Name);
 649
 650     /* Enter prolog */
 651     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 652     {
 653         /* Leave now */
 654         SetLastError(ErrorCode);
 655         return NULL;
 656     }
 657
 658     /* Initialize the Async Thread */
 659     if (!WsAsyncCheckAndInitThread())
 660     {
 661         /* Fail */
 662         SetLastError(WSAENOBUFS);
 663         return NULL;
 664     }
 665
 666     /* Allocate an async block */
 667     if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
 668     {
 669         /* Fail */
 670         SetLastError(WSAENOBUFS);
 671         return NULL;
 672     }
 673
 674     /* Make a copy of the address */
 675     NameCopy = AsyncBlock + 1;
 676     strcpy(NameCopy, Name);
 677
 678     /* Initialize the Async Block */
 679     AsyncBlock->Operation = WsAsyncGetHostByName;
 680     AsyncBlock->GetHost.hWnd = hWnd;
 681     AsyncBlock->GetHost.wMsg = wMsg;
 682     AsyncBlock->GetHost.ByWhat = NameCopy;
 683     AsyncBlock->GetHost.Buffer = Buffer;
 684     AsyncBlock->GetHost.BufferLength = BufferLength;
 685
 686     /* Save the task handle and queue the request */
 687     TaskHandle = AsyncBlock->TaskHandle;
 688     WsAsyncQueueRequest(AsyncBlock);
 689
 690     /* Return the task handle */
 691     return TaskHandle;
 692 }
 693
 694 /*
 695  * @implemented
 696  */
 697 HANDLE
 698 WSAAPI
 699 WSAAsyncGetProtoByName(IN HWND hWnd,
 700                        IN UINT wMsg,
 701                        IN CONST CHAR FAR *Name,
 702                        OUT CHAR FAR *Buffer,
 703                        IN INT BufferLength)
 704 {
 705     HANDLE TaskHandle;
 706     PWSPROCESS Process;
 707     PWSTHREAD Thread;
 708     PWSASYNCBLOCK AsyncBlock;
 709     INT ErrorCode;
 710     PVOID NameCopy;
 711     DPRINT("WSAAsyncGetProtoByName: %lx, %lx, %s\n", hWnd, wMsg, Name);
 712
 713     /* Enter prolog */
 714     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 715     {
 716         /* Leave now */
 717         SetLastError(ErrorCode);
 718         return NULL;
 719     }
 720
 721     /* Initialize the Async Thread */
 722     if (!WsAsyncCheckAndInitThread())
 723     {
 724         /* Fail */
 725         SetLastError(WSAENOBUFS);
 726         return NULL;
 727     }
 728
 729     /* Allocate an async block */
 730     if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
 731     {
 732         /* Fail */
 733         SetLastError(WSAENOBUFS);
 734         return NULL;
 735     }
 736
 737     /* Make a copy of the address */
 738     NameCopy = AsyncBlock + 1;
 739     strcpy(NameCopy, Name);
 740
 741     /* Initialize the Async Block */
 742     AsyncBlock->Operation = WsAsyncGetProtoByName;
 743     AsyncBlock->GetProto.hWnd = hWnd;
 744     AsyncBlock->GetProto.wMsg = wMsg;
 745     AsyncBlock->GetProto.ByWhat = NameCopy;
 746     AsyncBlock->GetProto.Buffer = Buffer;
 747     AsyncBlock->GetProto.BufferLength = BufferLength;
 748
 749     /* Save the task handle and queue the request */
 750     TaskHandle = AsyncBlock->TaskHandle;
 751     WsAsyncQueueRequest(AsyncBlock);
 752
 753     /* Return the task handle */
 754     return TaskHandle;
 755 }
 756
 757 /*
 758  * @implemented
 759  */
 760 HANDLE
 761 WSAAPI
 762 WSAAsyncGetProtoByNumber(IN HWND hWnd,
 763                          IN UINT wMsg,
 764                          IN INT Number,
 765                          OUT CHAR FAR* Buffer,
 766                          IN INT BufferLength)
 767 {
 768     HANDLE TaskHandle;
 769     PWSPROCESS Process;
 770     PWSTHREAD Thread;
 771     PWSASYNCBLOCK AsyncBlock;
 772     INT ErrorCode;
 773     DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %lx\n", hWnd, wMsg, Number);
 774
 775     /* Enter prolog */
 776     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 777     {
 778         /* Leave now */
 779         SetLastError(ErrorCode);
 780         return NULL;
 781     }
 782
 783     /* Initialize the Async Thread */
 784     if (!WsAsyncCheckAndInitThread())
 785     {
 786         /* Fail */
 787         SetLastError(WSAENOBUFS);
 788         return NULL;
 789     }
 790
 791     /* Allocate an async block */
 792     if (!(AsyncBlock = WsAsyncAllocateBlock(0)))
 793     {
 794         /* Fail */
 795         SetLastError(WSAENOBUFS);
 796         return NULL;
 797     }
 798
 799     /* Initialize the Async Block */
 800     AsyncBlock->Operation = WsAsyncGetProtoByNumber;
 801     AsyncBlock->GetProto.hWnd = hWnd;
 802     AsyncBlock->GetProto.wMsg = wMsg;
 803     AsyncBlock->GetProto.ByWhat = UlongToPtr(Number);
 804     AsyncBlock->GetProto.Buffer = Buffer;
 805     AsyncBlock->GetProto.BufferLength = BufferLength;
 806
 807     /* Save the task handle and queue the request */
 808     TaskHandle = AsyncBlock->TaskHandle;
 809     WsAsyncQueueRequest(AsyncBlock);
 810
 811     /* Return the task handle */
 812     return TaskHandle;
 813 }
 814
 815 /*
 816  * @implemented
 817  */
 818 HANDLE
 819 WSAAPI
 820 WSAAsyncGetServByName(IN HWND hWnd,
 821                       IN UINT wMsg,
 822                       IN CONST CHAR FAR *Name,
 823                       IN CONST CHAR FAR *Protocol,
 824                       OUT CHAR FAR *Buffer,
 825                       IN INT BufferLength)
 826 {
 827     HANDLE TaskHandle;
 828     PWSPROCESS Process;
 829     PWSTHREAD Thread;
 830     PWSASYNCBLOCK AsyncBlock;
 831     INT ErrorCode;
 832     PVOID NameCopy;
 833     DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %s\n", hWnd, wMsg, Name);
 834
 835     /* Enter prolog */
 836     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 837     {
 838         /* Leave now */
 839         SetLastError(ErrorCode);
 840         return NULL;
 841     }
 842
 843     /* Initialize the Async Thread */
 844     if (!WsAsyncCheckAndInitThread())
 845     {
 846         /* Fail */
 847         SetLastError(WSAENOBUFS);
 848         return NULL;
 849     }
 850
 851     /* Allocate an async block */
 852     if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
 853     {
 854         /* Fail */
 855         SetLastError(WSAENOBUFS);
 856         return NULL;
 857     }
 858
 859     /* Make a copy of the address */
 860     NameCopy = AsyncBlock + 1;
 861     strcpy(NameCopy, Name);
 862
 863     /* Initialize the Async Block */
 864     AsyncBlock->Operation = WsAsyncGetProtoByName;
 865     AsyncBlock->GetServ.hWnd = hWnd;
 866     AsyncBlock->GetServ.wMsg = wMsg;
 867     AsyncBlock->GetServ.ByWhat = NameCopy;
 868     AsyncBlock->GetServ.Protocol = (PCHAR)Protocol;
 869     AsyncBlock->GetServ.Buffer = Buffer;
 870     AsyncBlock->GetServ.BufferLength = BufferLength;
 871
 872     /* Save the task handle and queue the request */
 873     TaskHandle = AsyncBlock->TaskHandle;
 874     WsAsyncQueueRequest(AsyncBlock);
 875
 876     /* Return the task handle */
 877     return TaskHandle;
 878 }
 879
 880 /*
 881  * @implemented
 882  */
 883 HANDLE
 884 WSAAPI
 885 WSAAsyncGetServByPort(IN HWND hWnd,
 886                       IN UINT wMsg,
 887                       IN INT Port,
 888                       IN CONST CHAR FAR *Protocol,
 889                       OUT CHAR FAR *Buffer,
 890                       IN INT BufferLength)
 891 {
 892     HANDLE TaskHandle;
 893     PWSPROCESS Process;
 894     PWSTHREAD Thread;
 895     PWSASYNCBLOCK AsyncBlock;
 896     INT ErrorCode;
 897     DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %lx\n", hWnd, wMsg, Port);
 898
 899     /* Enter prolog */
 900     if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
 901     {
 902         /* Leave now */
 903         SetLastError(ErrorCode);
 904         return NULL;
 905     }
 906
 907     /* Initialize the Async Thread */
 908     if (!WsAsyncCheckAndInitThread())
 909     {
 910         /* Fail */
 911         SetLastError(WSAENOBUFS);
 912         return NULL;
 913     }
 914
 915     /* Allocate an async block */
 916     if (!(AsyncBlock = WsAsyncAllocateBlock(0)))
 917     {
 918         /* Fail */
 919         SetLastError(WSAENOBUFS);
 920         return NULL;
 921     }
 922
 923     /* Initialize the Async Block */
 924     AsyncBlock->Operation = WsAsyncGetServByPort;
 925     AsyncBlock->GetServ.hWnd = hWnd;
 926     AsyncBlock->GetServ.wMsg = wMsg;
 927     AsyncBlock->GetServ.ByWhat = UlongToPtr(Port);
 928     AsyncBlock->GetServ.Protocol = (PCHAR)Protocol;
 929     AsyncBlock->GetServ.Buffer = Buffer;
 930     AsyncBlock->GetServ.BufferLength = BufferLength;
 931
 932     /* Save the task handle and queue the request */
 933     TaskHandle = AsyncBlock->TaskHandle;
 934     WsAsyncQueueRequest(AsyncBlock);
 935
 936     /* Return the task handle */
 937     return TaskHandle;
 938 }
 939
 940 /*
 941  * @implemented
 942  */
 943 INT
 944 WSAAPI
 945 WSACancelAsyncRequest(IN HANDLE hAsyncTaskHandle)
 946 {
 947     PWSPROCESS Process;
 948     PWSTHREAD Thread;
 949     INT ErrorCode;
 950     DPRINT("WSACancelAsyncRequest: %lx\n", hAsyncTaskHandle);
 951
 952     /* Enter prolog */
 953     if ((ErrorCode = WsApiProlog(&Process, &Thread)) == ERROR_SUCCESS)
 954     {
 955         /* Call the Async code */
 956         ErrorCode = WsAsyncCancelRequest(hAsyncTaskHandle);
 957
 958         /* Return */
 959         if (ErrorCode == ERROR_SUCCESS) return ERROR_SUCCESS;
 960     }
 961
 962     /* Fail */
 963     SetLastError(ErrorCode);
 964     return SOCKET_ERROR;
 965 }