ReactOS 0.4.15-dev-8413-gc1c91f2
getxbyxx.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS WinSock 2 API
4 * FILE: dll/win32/ws2_32/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
19
20/* FUNCTIONS *****************************************************************/
21
22VOID
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
45VOID
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
59VOID
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
73VOID
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
86VOID
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
101LPBLOB
102WSAAPI
105 IN LPSTR Name,
108{
109 PWSAQUERYSETA WsaQuery = (PWSAQUERYSETA)*Results;
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
130 dwControlFlags |= LUP_RETURN_BLOB;
131
132 /* Send the Query Request to find a Service */
134 dwControlFlags,
135 &RnRHandle);
136
138 {
139 while (TRUE)
140 {
141 /* Service was found, send the real query */
143 0,
144 &NewLength,
145 WsaQuery);
146
147 /* Return the information requested */
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 */
161 {
162 /* Return the name anyways */
163 if (NewName) *NewName = WsaQuery->lpszServiceInstanceName;
164 }
165 else
166 {
167 /* We don't have a blob, sorry */
169 }
170 }
171 }
172 else
173 {
174 /* WSALookupServiceEnd will set its own error, so save ours */
176
177 /* Check if we failed because of missing buffer space */
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 */
197 }
198 }
199 }
200
201 /* Finish the Query Request */
202 WSALookupServiceEnd(RnRHandle);
203
204 /* Now set the Last Error */
206
207 /* Leave the loop */
208 break;
209 }
210 }
211
212 /* Return the blob */
213 return Blob;
214}
215
216/*
217 * @implemented
218 */
220WSAAPI
222{
223 PHOSTENT Hostent;
224 LPBLOB Blob;
226 CHAR ResultsBuffer[RNR_BUFFER_SIZE];
227 PCHAR Results = ResultsBuffer;
228 CHAR szLocalName[MAX_HOSTNAME_LEN];
229 PCHAR pszName;
232 DPRINT("gethostbyname: %s\n", name);
233
234 /* Enter prolog */
236 {
237 /* Leave now */
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,
258 pszName,
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,
268 NULL,
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 */
289 {
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 */
308WSAAPI
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;
321 DPRINT("gethostbyaddr: %s\n", addr);
322
323 /* Enter prolog */
325 {
326 /* Leave now */
328 return NULL;
329 }
330
331 /* Check for valid address pointer */
332 if (!addr)
333 {
334 /* Fail */
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 */
354 return NULL;
355 }
356
357 /* Get the Hostname in a Blob Structure */
358 Blob = getxyDataEnt(&Results,
360 AddressBuffer,
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 */
380 {
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 */
395INT
396WSAAPI
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 {
408 return SOCKET_ERROR;
409 }
410 /* Get the Hostname in a String */
411 /* getxyDataEnt does not return blob for HostnameGuid */
413 if (Name)
414 {
415 /* Copy it */
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 */
430WSAAPI
432 IN const char FAR * proto)
433{
434 PSERVENT Servent;
435 LPBLOB Blob;
436 CHAR ResultsBuffer[RNR_BUFFER_SIZE];
437 PCHAR Results = ResultsBuffer;
442 DPRINT("getservbyport: %s\n", proto);
443
444 /* Enter prolog */
446 {
447 /* Leave now */
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 */
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 */
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 */
499WSAAPI
501 IN const char FAR * proto)
502{
503 PSERVENT Servent;
504 LPBLOB Blob;
505 CHAR ResultsBuffer[RNR_BUFFER_SIZE];
506 PCHAR Results = ResultsBuffer;
511 DPRINT("getservbyname: %s\n", name);
512
513 /* Enter prolog */
515 {
516 /* Leave now */
518 return NULL;
519 }
520
521 /* No protocol specified */
522 if (!proto) proto = "";
523
524 /* Allocate buffer for it */
526 if (!PortName)
527 {
528 /* Fail */
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 */
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 */
567HANDLE
568WSAAPI
570 IN UINT wMsg,
572 IN INT Length,
573 IN INT Type,
576{
577 HANDLE TaskHandle;
580 PVOID AddressCopy;
581 PWSASYNCBLOCK AsyncBlock;
583 DPRINT("WSAAsyncGetHostByAddr: %lx, %lx, %s\n", hWnd, wMsg, Address);
584
585 /* Enter prolog */
587 {
588 /* Leave now */
590 return NULL;
591 }
592
593 /* Initialize the Async Thread */
595 {
596 /* Fail */
598 return NULL;
599 }
600
601 /* Allocate an async block */
602 if (!(AsyncBlock = WsAsyncAllocateBlock(Length)))
603 {
604 /* Fail */
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 */
634HANDLE
635WSAAPI
637 IN UINT wMsg,
641{
642 HANDLE TaskHandle;
645 PWSASYNCBLOCK AsyncBlock;
647 PVOID NameCopy;
648 DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %s\n", hWnd, wMsg, Name);
649
650 /* Enter prolog */
652 {
653 /* Leave now */
655 return NULL;
656 }
657
658 /* Initialize the Async Thread */
660 {
661 /* Fail */
663 return NULL;
664 }
665
666 /* Allocate an async block */
667 if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
668 {
669 /* Fail */
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 */
697HANDLE
698WSAAPI
700 IN UINT wMsg,
704{
705 HANDLE TaskHandle;
708 PWSASYNCBLOCK AsyncBlock;
710 PVOID NameCopy;
711 DPRINT("WSAAsyncGetProtoByName: %lx, %lx, %s\n", hWnd, wMsg, Name);
712
713 /* Enter prolog */
715 {
716 /* Leave now */
718 return NULL;
719 }
720
721 /* Initialize the Async Thread */
723 {
724 /* Fail */
726 return NULL;
727 }
728
729 /* Allocate an async block */
730 if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
731 {
732 /* Fail */
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 */
760HANDLE
761WSAAPI
763 IN UINT wMsg,
764 IN INT Number,
767{
768 HANDLE TaskHandle;
771 PWSASYNCBLOCK AsyncBlock;
773 DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %lx\n", hWnd, wMsg, Number);
774
775 /* Enter prolog */
777 {
778 /* Leave now */
780 return NULL;
781 }
782
783 /* Initialize the Async Thread */
785 {
786 /* Fail */
788 return NULL;
789 }
790
791 /* Allocate an async block */
792 if (!(AsyncBlock = WsAsyncAllocateBlock(0)))
793 {
794 /* Fail */
796 return NULL;
797 }
798
799 /* Initialize the Async Block */
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 */
818HANDLE
819WSAAPI
821 IN UINT wMsg,
826{
827 HANDLE TaskHandle;
830 PWSASYNCBLOCK AsyncBlock;
832 PVOID NameCopy;
833 DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %s\n", hWnd, wMsg, Name);
834
835 /* Enter prolog */
837 {
838 /* Leave now */
840 return NULL;
841 }
842
843 /* Initialize the Async Thread */
845 {
846 /* Fail */
848 return NULL;
849 }
850
851 /* Allocate an async block */
852 if (!(AsyncBlock = WsAsyncAllocateBlock(strlen(Name) + sizeof(CHAR))))
853 {
854 /* Fail */
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 */
883HANDLE
884WSAAPI
886 IN UINT wMsg,
887 IN INT Port,
891{
892 HANDLE TaskHandle;
895 PWSASYNCBLOCK AsyncBlock;
897 DPRINT("WSAAsyncGetProtoByNumber: %lx, %lx, %lx\n", hWnd, wMsg, Port);
898
899 /* Enter prolog */
901 {
902 /* Leave now */
904 return NULL;
905 }
906
907 /* Initialize the Async Thread */
909 {
910 /* Fail */
912 return NULL;
913 }
914
915 /* Allocate an async block */
916 if (!(AsyncBlock = WsAsyncAllocateBlock(0)))
917 {
918 /* Fail */
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 */
943INT
944WSAAPI
946{
950 DPRINT("WSACancelAsyncRequest: %lx\n", hAsyncTaskHandle);
951
952 /* Enter prolog */
954 {
955 /* Call the Async code */
956 ErrorCode = WsAsyncCancelRequest(hAsyncTaskHandle);
957
958 /* Return */
960 }
961
962 /* Fail */
964 return SOCKET_ERROR;
965}
static USHORT USHORT * NewLength
static UNICODE_STRING PortName
Type
Definition: Type.h:7
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
struct NameRec_ * Name
Definition: cdprocs.h:460
HWND hWnd
Definition: settings.c:17
Definition: bufpool.h:45
#define NO_ERROR
Definition: dderror.h:5
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define SetLastError(x)
Definition: compat.h:752
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define FAR
Definition: zlib.h:34
USHORT port
Definition: uri.c:228
#define IPPROTO_TCP
Definition: ip.h:196
#define IPPROTO_UDP
Definition: ip.h:197
#define AF_INET
Definition: tcpip.h:117
#define UlongToPtr(u)
Definition: config.h:106
#define ULONG_PTR
Definition: config.h:101
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
HANDLE WSAAPI WSAAsyncGetHostByName(IN HWND hWnd, IN UINT wMsg, IN CONST CHAR FAR *Name, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:636
HANDLE WSAAPI WSAAsyncGetServByName(IN HWND hWnd, IN UINT wMsg, IN CONST CHAR FAR *Name, IN CONST CHAR FAR *Protocol, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:820
PSERVENT WSAAPI getservbyport(IN int port, IN const char FAR *proto)
Definition: getxbyxx.c:431
HANDLE WSAAPI WSAAsyncGetProtoByName(IN HWND hWnd, IN UINT wMsg, IN CONST CHAR FAR *Name, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:699
PHOSTENT WSAAPI gethostbyname(IN const char FAR *name)
Definition: getxbyxx.c:221
PSERVENT WSAAPI getservbyname(IN const char FAR *name, IN const char FAR *proto)
Definition: getxbyxx.c:500
INT WSAAPI WSACancelAsyncRequest(IN HANDLE hAsyncTaskHandle)
Definition: getxbyxx.c:945
INT WSAAPI gethostname(OUT char FAR *name, IN INT namelen)
Definition: getxbyxx.c:397
VOID WSAAPI FixList(PCHAR **List, ULONG_PTR Base)
Definition: getxbyxx.c:24
AFPROTOCOLS afp[2]
Definition: getxbyxx.c:18
VOID WSAAPI UnpackServEnt(PSERVENT Servent)
Definition: getxbyxx.c:47
HANDLE WSAAPI WSAAsyncGetServByPort(IN HWND hWnd, IN UINT wMsg, IN INT Port, IN CONST CHAR FAR *Protocol, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:885
VOID WSAAPI UnpackHostEnt(PHOSTENT Hostent)
Definition: getxbyxx.c:61
HANDLE WSAAPI WSAAsyncGetProtoByNumber(IN HWND hWnd, IN UINT wMsg, IN INT Number, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:762
LPBLOB WSAAPI getxyDataEnt(IN OUT PCHAR *Results, IN DWORD Length, IN LPSTR Name, IN LPCGUID Type, IN LPSTR *NewName)
Definition: getxbyxx.c:103
VOID WSAAPI Local_Ip4AddresstoString(IN PCHAR AddressBuffer, IN PCHAR Address)
Definition: getxbyxx.c:75
HANDLE WSAAPI WSAAsyncGetHostByAddr(IN HWND hWnd, IN UINT wMsg, IN CONST CHAR FAR *Address, IN INT Length, IN INT Type, OUT CHAR FAR *Buffer, IN INT BufferLength)
Definition: getxbyxx.c:569
PHOSTENT WSAAPI gethostbyaddr(IN const char FAR *addr, IN int len, IN int type)
Definition: getxbyxx.c:309
VOID WSAAPI Local_Ip6AddresstoString(IN PCHAR AddressBuffer, IN PCHAR Address)
Definition: getxbyxx.c:88
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint namelen
Definition: glext.h:7232
GLenum const GLvoid * addr
Definition: glext.h:9621
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
CPPORT Port[4]
Definition: headless.c:35
#define MAX_HOSTNAME_LEN
Definition: iptypes.h:30
#define PCHAR
Definition: match.c:90
#define ntohs(x)
Definition: module.h:210
#define sprintf(buf, format,...)
Definition: sprintf.c:55
unsigned int UINT
Definition: ndis.h:50
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2451
const GUID DECLSPEC_SELECTANY HostAddrByNameGuid
Definition: nsp_dns.h:19
const GUID DECLSPEC_SELECTANY HostnameGuid
Definition: nsp_dns.h:17
#define RNR_BUFFER_SIZE
Definition: nsp_dns.h:25
const GUID DECLSPEC_SELECTANY IANAGuid
Definition: nsp_dns.h:20
const GUID DECLSPEC_SELECTANY AddressGuid
Definition: nsp_dns.h:18
#define NS_ALL
Definition: nspapi.h:8
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:207
#define CONST
Definition: pedump.c:81
static WCHAR Address[46]
Definition: ping.c:68
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
GUID * LPGUID
Definition: guiddef.h:81
INT WSAAPI WSALookupServiceEnd(IN HANDLE hLookup)
Definition: rnr.c:202
INT WSAAPI WSALookupServiceNextA(IN HANDLE hLookup, IN DWORD dwControlFlags, IN OUT LPDWORD lpdwBufferLength, OUT LPWSAQUERYSETA lpqsResults)
Definition: rnr.c:444
INT WSAAPI WSALookupServiceBeginA(IN LPWSAQUERYSETA lpqsRestrictions, IN DWORD dwControlFlags, OUT LPHANDLE lphLookup)
Definition: rnr.c:245
#define DPRINT
Definition: sndvol32.h:73
Definition: nspapi.h:57
LPGUID lpServiceClassId
Definition: winsock2.h:804
LPBLOB lpBlob
Definition: winsock2.h:816
DWORD dwSize
Definition: winsock2.h:802
DWORD dwNumberOfProtocols
Definition: winsock2.h:810
DWORD dwNameSpace
Definition: winsock2.h:807
LPSTR lpszServiceInstanceName
Definition: winsock2.h:803
struct _WSASYNCBLOCK::@602::@605 GetProto
WSASYNCOPS Operation
Definition: ws2_32p.h:28
HANDLE TaskHandle
Definition: ws2_32p.h:27
struct _WSASYNCBLOCK::@602::@604 GetHost
struct _WSASYNCBLOCK::@602::@606 GetServ
char * h_name
Definition: winsock.h:134
char ** h_aliases
Definition: winsock.h:135
char ** h_addr_list
Definition: winsock.h:138
Definition: name.c:39
char * s_name
Definition: winsock.h:159
char * s_proto
Definition: winsock.h:166
char ** s_aliases
Definition: winsock.h:160
int32_t INT
Definition: typedefs.h:58
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
#define OUT
Definition: typedefs.h:40
char * PCHAR
Definition: typedefs.h:51
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define WSAEINVAL
Definition: winerror.h:1946
#define WSAHOST_NOT_FOUND
Definition: winerror.h:2000
#define WSAENOBUFS
Definition: winerror.h:1968
#define WSANO_DATA
Definition: winerror.h:2003
#define WSASERVICE_NOT_FOUND
Definition: winerror.h:1995
#define WSAEFAULT
Definition: winerror.h:1945
struct _WSAQuerySetA * PWSAQUERYSETA
#define LUP_RETURN_BLOB
Definition: winsock2.h:519
#define LUP_RETURN_NAME
Definition: winsock2.h:514
#define WSA_NOT_ENOUGH_MEMORY
Definition: winsock2.h:620
#define WSAAPI
Definition: winsock2.h:605
VOID WINAPI WSNoteSuccessfulHostentLookup(IN CONST CHAR FAR *Name, IN CONST ULONG Address)
Definition: winsock.c:119
#define SOCKET_ERROR
Definition: winsock.h:333
#define AF_INET6
Definition: winsock.h:369
@ WsAsyncGetProtoByName
Definition: ws2_32p.h:17
@ WsAsyncGetServByPort
Definition: ws2_32p.h:20
@ WsAsyncGetHostByAddr
Definition: ws2_32p.h:15
@ WsAsyncGetHostByName
Definition: ws2_32p.h:16
@ WsAsyncGetProtoByNumber
Definition: ws2_32p.h:18
VOID WSAAPI WsAsyncQueueRequest(IN PWSASYNCBLOCK AsyncBlock)
Definition: async.c:919
PWSASYNCBLOCK WSAAPI WsAsyncAllocateBlock(IN SIZE_T ExtraLength)
Definition: async.c:439
PSERVENT WSAAPI WsThreadBlobToServent(IN PWSTHREAD Thread, IN LPBLOB Blob)
Definition: dthread.c:349
PHOSTENT WSAAPI WsThreadBlobToHostent(IN PWSTHREAD Thread, IN LPBLOB Blob)
Definition: dthread.c:316
HANDLE WsSockHeap
Definition: dllmain.c:21
INT WSAAPI WsApiProlog(OUT PWSPROCESS *Process, OUT PWSTHREAD *Thread)
Definition: wsautil.c:91
INT WSAAPI WsAsyncCancelRequest(IN HANDLE TaskHandle)
Definition: async.c:936
BOOL WSAAPI WsAsyncCheckAndInitThread(VOID)
Definition: async.c:832
char * LPSTR
Definition: xmlstorage.h:182
char CHAR
Definition: xmlstorage.h:175
_In_ PUNICODE_STRING NewName
Definition: zwfuncs.h:1203