xref: /reactos/dll/win32/mswsock/nsplookup.c (revision c2c66aff) 
1 #include "precomp.h"
2 
3 #include <stdlib.h>
4 #include <ws2spi.h>
5 #include <nspapi.h>
6 #include <windef.h>
7 #include <winuser.h>
8 #include <windns.h>
9 #include <guiddef.h>
10 #include <svcguid.h>
11 #include <iptypes.h>
12 #include <strsafe.h>
13 #include <winreg.h>
14 
15 #include "mswhelper.h"
16 
17 #define NDEBUG
18 #include <debug.h>
19 
20 #define NSP_CALLID_DNS 0x0001
21 #define NSP_CALLID_HOSTNAME 0x0002
22 #define NSP_CALLID_HOSTBYNAME 0x0003
23 #define NSP_CALLID_SERVICEBYNAME 0x0004
24 
25 #ifndef BUFSIZ
26 #define BUFSIZ 1024
27 #endif // BUFSIZ
28 #ifndef WS2_INTERNAL_MAX_ALIAS
29 #define WS2_INTERNAL_MAX_ALIAS 512
30 #endif // WS2_INTERNAL_MAX_ALIAS
31 
32 //#define IP_LOCALHOST 0x0100007F
33 
34 //#define NSP_REDIRECT
35 
36 typedef struct {
37   WCHAR* hostnameW;
38   DWORD addr4;
39   WCHAR* servnameW;
40   WCHAR* servprotoW;
41   CHAR** servaliasesA; /* array */
42   WORD servport;
43 } WSHOSTINFOINTERN, *PWSHOSTINFOINTERN;
44 
45 typedef struct {
46   GUID providerId; /* Provider-ID */
47   DWORD dwControlFlags; /* dwControlFlags (WSALookupServiceBegin) */
48   DWORD CallID; /* List for LookupServiceNext-Calls */
49   DWORD CallIDCounter; /* call-count of the current CallID. */
50   WCHAR* hostnameW; /* hostbyname */
51 #ifdef NSP_REDIRECT
52   HANDLE rdrLookup;
53   NSP_ROUTINE rdrproc;
54 #endif
55 } WSHANDLEINTERN, *PWSHANDLEINTERN;
56 
57 static const GUID guid_NULL = {0};
58 static const GUID guid_HOSTNAME = SVCID_HOSTNAME;
59 static const GUID guid_INET_HOSTADDRBYINETSTRING = SVCID_INET_HOSTADDRBYINETSTRING;
60 static const GUID guid_INET_HOSTADDRBYNAME = SVCID_INET_HOSTADDRBYNAME;
61 static const GUID guid_INET_SERVICEBYNAME = SVCID_INET_SERVICEBYNAME;
62 
63 /* GUIDs - maybe they should be loaded from registry? */
64 /* Namespace: 32 */
65 static const GUID guid_mswsock_TcpIp = {/*Data1:*/ 0x22059D40,
66                                         /*Data2:*/ 0x7E9E,
67                                         /*Data3:*/ 0x11CF,
68                                         /*Data4:*/ {0xAE, 0x5A, 0x00, 0xAA, 0x00, 0xA7, 0x11, 0x2B}};
69 
70 /* {6642243A-3BA8-4AA6-BAA5-2E0BD71FDD83} */
71 /* Namespace: 15 */
72 static const GUID guid_mswsock_NLA = {/*Data1:*/ 0x6642243A,
73                                       /*Data2:*/ 0x3BA8,
74                                       /*Data3:*/ 0x4AA6,
75                                       /*Data4:*/ {0xBA, 0xA5, 0x2E, 0x0B, 0xD7, 0x1F, 0xDD, 0x83}};
76 
77 #ifdef NSP_REDIRECT
78 
79 typedef INT
80 (CALLBACK *lpRdrNSPStartup)(
81   LPGUID lpProviderId,
82   LPNSP_ROUTINE lpRout);
83 
84 const rdrLib = "mswsock.dll-original";
85 lpRdrNSPStartup rdrNSPStartup;
86 HANDLE hLib;
87 NSP_ROUTINE rdrproc_tcpip;
88 NSP_ROUTINE rdrproc_nla;
89 
90 #endif /* NSP_REDIRECT */
91 
92 /* Forwards */
93 INT
94 WINAPI
95 mswNSPStartup(
96   LPGUID lpProviderId,
97   LPNSP_ROUTINE lpRout);
98 
99 INT
100 NSP_LookupServiceBeginW(
101   PWSHANDLEINTERN data,
102   CHAR* hostnameA,
103   WCHAR* hostnameW,
104   DWORD CallID);
105 
106 INT
107 NSP_LookupServiceNextW(
108   _In_ PWSHANDLEINTERN data,
109   _In_ DWORD dwControlFlags,
110   _Inout_ LPWSAQUERYSETW lpRes,
111   _Inout_ LPDWORD lpResLen);
112 
113 INT
114 NSP_GetHostNameHeapAllocW(
115   _Out_ WCHAR** hostname);
116 
117 INT
118 NSP_GetHostByNameHeapAllocW(
119   _In_ PWSHANDLEINTERN data,
120   _In_ DWORD dwControlFlags,
121   _Out_ PWSHOSTINFOINTERN hostinfo);
122 
123 INT
124 NSP_GetServiceByNameHeapAllocW(
125   _In_ PWSHANDLEINTERN data,
126   _In_ DWORD dwControlFlags,
127   _Out_ PWSHOSTINFOINTERN hostinfo);
128 
129 /* Implementations - Internal */
130 
131 INT
132 WSAAPI
133 mwsNSPCleanUp(_In_ LPGUID lpProviderId)
134 {
135     //WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
136     //return ERROR_CALL_NOT_IMPLEMENTED;
137     return ERROR_SUCCESS;
138 }
139 
140 INT
141 mwsNSPInit(VOID)
142 {
143     return ERROR_SUCCESS;
144 }
145 
146 INT
147 WSAAPI
148 mwsNSPLookupServiceBegin(_In_ LPGUID lpProviderId,
149                          _In_ LPWSAQUERYSETW lpqsRestrictions,
150                          _In_ LPWSASERVICECLASSINFOW lpServiceClassInfo,
151                          _In_ DWORD dwControlFlags,
152                          _Out_ LPHANDLE lphLookup)
153 {
154     PWSHANDLEINTERN pLook;
155     int wsaErr;
156 
157     if (IsEqualGUID(lpProviderId, &guid_mswsock_TcpIp))
158     {
159         //OK
160     }
161     else if (IsEqualGUID(lpProviderId, &guid_mswsock_NLA))
162     {
163         WSASetLastError(WSASERVICE_NOT_FOUND);
164         return SOCKET_ERROR;
165     }
166     else
167     {
168         return ERROR_CALL_NOT_IMPLEMENTED;
169     }
170 
171     /* allocate internal structure */
172     pLook = HeapAlloc(GetProcessHeap(), 0, sizeof(WSHANDLEINTERN));
173     if (!pLook)
174     {
175         WSASetLastError(WSAEFAULT);
176         return SOCKET_ERROR;
177     }
178 
179     *lphLookup = (HANDLE)pLook;
180 
181     RtlZeroMemory(pLook, sizeof(*pLook));
182 
183     /* Anyway the ControlFlags "should" be needed
184        in NSPLookupServiceNext. (see doku) But
185        thats not the fact ATM. */
186     pLook->dwControlFlags = dwControlFlags;
187     pLook->providerId = *lpProviderId;
188 
189 #ifdef NSP_REDIRECT
190 
191     if (IsEqualGUID(lpProviderId, &guid_mswsock_TcpIp))
192     {
193         pLook->rdrproc = rdrproc_tcpip;
194     }
195     else if (IsEqualGUID(lpProviderId, &guid_mswsock_NLA))
196     {
197         pLook->rdrproc = rdrproc_nla;
198     }
199     else
200     {
201         return ERROR_CALL_NOT_IMPLEMENTED;
202     }
203 
204     if (pLook->rdrproc.NSPLookupServiceBegin(lpProviderId,
205                                              lpqsRestrictions,
206                                              lpServiceClassInfo,
207                                              dwControlFlags,
208                                              &pLook->rdrLookup) == NO_ERROR)
209     {
210         wsaErr = NO_ERROR;
211     }
212     else
213     {
214         wsaErr = WSAGetLastError();
215     }
216 
217     /*
218     if (res)
219         res = WSAGetLastError();
220     */
221 
222 #else /* NSP_REDIRECT */
223 
224     wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
225     if (IsEqualGUID(lpqsRestrictions->lpServiceClassId, &guid_NULL))
226     {
227         wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
228     }
229     else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId, &guid_HOSTNAME))
230     {
231         wsaErr = NSP_LookupServiceBeginW(pLook,
232                                          NULL,
233                                          NULL,
234                                          NSP_CALLID_HOSTNAME);
235     }
236     else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
237                          &guid_INET_HOSTADDRBYNAME))
238     {
239        wsaErr = NSP_LookupServiceBeginW(pLook,
240                                         NULL,
241                                         lpqsRestrictions->lpszServiceInstanceName,
242                                         NSP_CALLID_HOSTBYNAME);
243     }
244     else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
245                          &guid_INET_SERVICEBYNAME))
246     {
247        wsaErr = NSP_LookupServiceBeginW(pLook,
248                                         NULL,
249                                         lpqsRestrictions->lpszServiceInstanceName,
250                                         NSP_CALLID_SERVICEBYNAME);
251     }
252     else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
253                          &guid_INET_HOSTADDRBYINETSTRING))
254     {
255         wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
256     }
257 
258 #endif /* NSP_REDIRECT */
259 
260     if (wsaErr != NO_ERROR)
261     {
262         WSASetLastError(wsaErr);
263         return SOCKET_ERROR;
264     }
265     return NO_ERROR;
266 }
267 
268 INT
269 WSAAPI
270 mwsNSPLookupServiceNext(_In_ HANDLE hLookup,
271                         _In_ DWORD dwControlFlags,
272                         _Inout_ LPDWORD lpdwBufferLength,
273                         //_Out_writes_bytes_to_(*lpdwBufferLength, *lpdwBufferLength)
274                         LPWSAQUERYSETW lpqsResults)
275 {
276     PWSHANDLEINTERN pLook = hLookup;
277     int wsaErr = 0;
278 
279 #ifdef NSP_REDIRECT
280 
281     INT res = pLook->rdrproc.NSPLookupServiceNext(pLook->rdrLookup,
282                                                   dwControlFlags,
283                                                   lpdwBufferLength,
284                                                   lpqsResults);
285     wsaErr = WSAGetLastError();
286     if (res != ERROR_SUCCESS)
287     {
288         wsaErr = WSAGetLastError();
289 
290         if (wsaErr == 0)
291             wsaErr = 0xFFFFFFFF;
292     }
293 
294 #else /* NSP_REDIRECT */
295 
296     if ((lpdwBufferLength == NULL) || (*lpdwBufferLength == 0))
297     {
298         wsaErr = WSA_NOT_ENOUGH_MEMORY;
299         goto End;
300     }
301 
302     RtlZeroMemory(lpqsResults, *lpdwBufferLength);
303     lpqsResults->dwSize = sizeof(*lpqsResults);
304 
305     wsaErr = NSP_LookupServiceNextW(pLook,
306                                     dwControlFlags,
307                                     lpqsResults,
308                                     lpdwBufferLength);
309 
310 
311 #endif /* NSP_REDIRECT */
312 
313 End:
314     if (wsaErr != 0)
315     {
316         WSASetLastError(wsaErr);
317         return SOCKET_ERROR;
318     }
319     return NO_ERROR;
320 }
321 
322 INT
323 WSAAPI
324 mwsNSPIoCtl(_In_ HANDLE hLookup,
325             _In_ DWORD dwControlCode,
326             _In_reads_bytes_(cbInBuffer) LPVOID lpvInBuffer,
327             _In_ DWORD cbInBuffer,
328             _Out_writes_bytes_to_(cbOutBuffer, *lpcbBytesReturned) LPVOID lpvOutBuffer,
329             _In_ DWORD cbOutBuffer,
330             _Out_ LPDWORD lpcbBytesReturned,
331             _In_opt_ LPWSACOMPLETION lpCompletion,
332             _In_ LPWSATHREADID lpThreadId)
333 {
334     WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
335     return ERROR_CALL_NOT_IMPLEMENTED;
336 }
337 
338 INT
339 WSAAPI
340 mwsNSPLookupServiceEnd(_In_ HANDLE hLookup)
341 {
342     PWSHANDLEINTERN pLook;
343     HANDLE hHeap;
344     INT res;
345 
346     res = NO_ERROR;
347     pLook = (PWSHANDLEINTERN)hLookup;
348     hHeap = GetProcessHeap();
349 
350 #ifdef NSP_REDIRECT
351     res = pLook->rdrproc.NSPLookupServiceEnd(pLook->rdrLookup);
352 #endif
353 
354     if (pLook->hostnameW != NULL)
355         HeapFree(hHeap, 0, pLook->hostnameW);
356 
357     HeapFree(hHeap, 0, pLook);
358     return res;
359 }
360 
361 INT
362 WSAAPI
363 mwsNSPSetService(_In_ LPGUID lpProviderId,
364                  _In_ LPWSASERVICECLASSINFOW lpServiceClassInfo,
365                  _In_ LPWSAQUERYSETW lpqsRegInfo,
366                  _In_ WSAESETSERVICEOP essOperation,
367                  _In_ DWORD dwControlFlags)
368 {
369     WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
370     return ERROR_CALL_NOT_IMPLEMENTED;
371 }
372 
373 INT
374 WSAAPI
375 mwsNSPInstallServiceClass(_In_ LPGUID lpProviderId,
376                           _In_ LPWSASERVICECLASSINFOW lpServiceClassInfo)
377 {
378     WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
379     return ERROR_CALL_NOT_IMPLEMENTED;
380 }
381 
382 INT
383 WSAAPI
384 mwsNSPRemoveServiceClass(_In_ LPGUID lpProviderId,
385                          _In_ LPGUID lpServiceClassId)
386 {
387     WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
388     return ERROR_CALL_NOT_IMPLEMENTED;
389 }
390 
391 INT
392 WSAAPI
393 mwsNSPGetServiceClassInfo(_In_ LPGUID lpProviderId,
394                           _In_ LPDWORD lpdwBufSize,
395                           _In_ LPWSASERVICECLASSINFOW lpServiceClassInfo)
396 {
397     WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
398     return ERROR_CALL_NOT_IMPLEMENTED;
399 }
400 
401 /*
402     hostnameA / hostnameW
403     * only used by HOSTBYNAME
404     * only one should be set
405 
406 */
407 INT
408 NSP_LookupServiceBeginW(PWSHANDLEINTERN data,
409                         CHAR* hostnameA,
410                         WCHAR* hostnameW,
411                         DWORD CallID)
412 {
413     HANDLE hHeap;
414 
415     if (data->CallID != 0)
416         return WSAEFAULT;
417 
418     data->CallID = CallID;
419 
420     if ((CallID == NSP_CALLID_HOSTBYNAME) ||
421         (CallID == NSP_CALLID_SERVICEBYNAME))
422     {
423         hHeap = GetProcessHeap();
424 
425         if (data->hostnameW != NULL)
426             HeapFree(hHeap, 0, data->hostnameW);
427 
428         if (hostnameA != NULL)
429         {
430             data->hostnameW = StrA2WHeapAlloc(hHeap, hostnameA);
431         }
432         else
433         {
434             data->hostnameW = StrCpyHeapAllocW(hHeap, hostnameW);
435         }
436     }
437 
438     WSASetLastError(0);
439 
440     return ERROR_SUCCESS;
441 }
442 
443 INT
444 NSP_GetHostNameHeapAllocW(_Out_ WCHAR** hostname)
445 {
446     WCHAR* name;
447     HANDLE hHeap = GetProcessHeap();
448     DWORD bufCharLen = MAX_COMPUTERNAME_LENGTH + 1;
449     DWORD bufByteLen = bufCharLen * sizeof(WCHAR);
450 
451     name = HeapAlloc(hHeap, 0, bufByteLen);
452 
453     if (!GetComputerNameExW(ComputerNameDnsHostname,
454                             name,
455                             &bufCharLen))
456     {
457         HeapFree(hHeap, 0, name);
458         WSASetLastError(WSAEFAULT);
459         return SOCKET_ERROR;
460     }
461 
462     *hostname = name;
463     return ERROR_SUCCESS;
464 }
465 
466 INT
467 NSP_GetHostByNameHeapAllocW(_In_ PWSHANDLEINTERN data,
468                             _In_ DWORD dwControlFlags,
469                             _Out_ PWSHOSTINFOINTERN hostinfo)
470 {
471     HANDLE hHeap = GetProcessHeap();
472     DNS_STATUS dns_status = { 0 };
473     /* include/WinDNS.h -- look up DNS_RECORD on MSDN */
474     PDNS_RECORDW dp;
475     PDNS_RECORDW curr;
476     INT result = ERROR_SUCCESS;
477     DWORD dwQueryFlags = DNS_QUERY_STANDARD;
478     PWCHAR Aliases[WS2_INTERNAL_MAX_ALIAS] = { 0 };
479     int AliasIndex = 0;
480 
481     /* needed to be cleaned up if != NULL */
482     dp = NULL;
483 
484     if (data->hostnameW == NULL)
485     {
486         result = ERROR_INVALID_PARAMETER;
487         goto cleanup;
488     }
489 
490     if ((data->dwControlFlags & LUP_DEEP) == 0)
491     {
492         dwQueryFlags |= DNS_QUERY_NO_RECURSION;
493     }
494 
495     /* DNS_TYPE_A: include/WinDNS.h */
496     /* DnsQuery -- lib/dnsapi/dnsapi/query.c */
497     dns_status = DnsQuery_W(data->hostnameW,
498                             DNS_TYPE_A,
499                             dwQueryFlags,
500                             NULL /* extra dns servers */,
501                             &dp,
502                             NULL);
503     if (dns_status == ERROR_INVALID_NAME)
504     {
505         WSASetLastError(WSAEFAULT);
506         result = ERROR_INVALID_PARAMETER;
507         goto cleanup;
508     }
509 
510     if ((dns_status != 0) || (dp == NULL))
511     {
512         result = WSAHOST_NOT_FOUND;
513         goto cleanup;
514     }
515 
516     //ASSERT(dp->wType == DNS_TYPE_A);
517     //ASSERT(dp->wDataLength == sizeof(DNS_A_DATA));
518     curr = dp;
519     while ((curr->pNext != NULL) || (curr->wType != DNS_TYPE_A))
520     {
521         if (curr->wType == DNS_TYPE_CNAME)
522         {
523             Aliases[AliasIndex++] = curr->Data.Cname.pNameHost;
524         }
525         curr = curr->pNext;
526     }
527 
528     if (curr->wType != DNS_TYPE_A)
529     {
530         result = WSASERVICE_NOT_FOUND;
531         goto cleanup;
532     }
533     hostinfo->hostnameW = StrCpyHeapAllocW(hHeap, curr->pName);
534     hostinfo->addr4 = curr->Data.A.IpAddress;
535     if (AliasIndex)
536     {
537         hostinfo->servaliasesA = StrAryCpyHeapAllocWToA(hHeap, (WCHAR**)&Aliases);
538     }
539     result = ERROR_SUCCESS;
540 
541 cleanup:
542     if (dp != NULL)
543         DnsRecordListFree(dp, DnsFreeRecordList);
544 
545     return result;
546 }
547 
548 #define SKIPWS(ptr, act) \
549 {while(*ptr && isspace(*ptr)) ptr++; if(!*ptr) act;}
550 
551 #define SKIPANDMARKSTR(ptr, act) \
552 {while(*ptr && !isspace(*ptr)) ptr++; \
553  if(!*ptr) {act;} else { *ptr = 0; ptr++; }}
554 
555 static
556 BOOL
557 DecodeServEntFromString(IN PCHAR ServiceString,
558                         OUT PCHAR *ServiceName,
559                         OUT PCHAR *PortNumberStr,
560                         OUT PCHAR *ProtocolStr,
561                         IN PCHAR *Aliases,
562                         IN DWORD MaxAlias)
563 {
564     UINT NAliases = 0;
565 
566     //WS_DbgPrint(MAX_TRACE, ("Parsing service ent [%s]\n", ServiceString));
567 
568     SKIPWS(ServiceString, return FALSE);
569     *ServiceName = ServiceString;
570     SKIPANDMARKSTR(ServiceString, return FALSE);
571     SKIPWS(ServiceString, return FALSE);
572     *PortNumberStr = ServiceString;
573     SKIPANDMARKSTR(ServiceString, ;);
574 
575     while (*ServiceString && NAliases < MaxAlias - 1)
576     {
577         SKIPWS(ServiceString, break);
578         if (*ServiceString)
579         {
580             SKIPWS(ServiceString, ;);
581             if (strlen(ServiceString))
582             {
583                 //WS_DbgPrint(MAX_TRACE, ("Alias: %s\n", ServiceString));
584                 *Aliases++ = ServiceString;
585                 NAliases++;
586             }
587             SKIPANDMARKSTR(ServiceString, ;);
588         }
589     }
590     *Aliases = NULL;
591 
592     *ProtocolStr = strchr(*PortNumberStr, '/');
593 
594     if (!*ProtocolStr)
595         return FALSE;
596 
597     **ProtocolStr = 0;
598     (*ProtocolStr)++;
599 
600     //WS_DbgPrint(MAX_TRACE, ("Parsing done: %s %s %s %d\n",
601     //           *ServiceName, *ProtocolStr, *PortNumberStr,
602     //            NAliases));
603 
604     return TRUE;
605 }
606 
607 HANDLE
608 WSAAPI
609 OpenNetworkDatabase(_In_ LPCWSTR Name)
610 {
611     PWSTR ExpandedPath;
612     PWSTR DatabasePath;
613     INT ErrorCode;
614     HKEY DatabaseKey;
615     DWORD RegType;
616     DWORD RegSize = 0;
617     size_t StringLength;
618     HANDLE ret;
619 
620     ExpandedPath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH*sizeof(WCHAR));
621     if (!ExpandedPath)
622         return INVALID_HANDLE_VALUE;
623 
624     /* Open the database path key */
625     ErrorCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
626                              L"System\\CurrentControlSet\\Services\\Tcpip\\Parameters",
627                              0,
628                              KEY_READ,
629                              &DatabaseKey);
630     if (ErrorCode == NO_ERROR)
631     {
632         /* Read the actual path */
633         ErrorCode = RegQueryValueEx(DatabaseKey,
634                                     L"DatabasePath",
635                                     NULL,
636                                     &RegType,
637                                     NULL,
638                                     &RegSize);
639 
640         DatabasePath = HeapAlloc(GetProcessHeap(), 0, RegSize);
641         if (!DatabasePath)
642         {
643             HeapFree(GetProcessHeap(), 0, ExpandedPath);
644             return INVALID_HANDLE_VALUE;
645         }
646 
647         /* Read the actual path */
648         ErrorCode = RegQueryValueEx(DatabaseKey,
649                                     L"DatabasePath",
650                                     NULL,
651                                     &RegType,
652                                     (LPBYTE)DatabasePath,
653                                     &RegSize);
654 
655         /* Close the key */
656         RegCloseKey(DatabaseKey);
657 
658         /* Expand the name */
659         ExpandEnvironmentStrings(DatabasePath, ExpandedPath, MAX_PATH);
660 
661         HeapFree(GetProcessHeap(), 0, DatabasePath);
662     }
663     else
664     {
665         /* Use defalt path */
666         GetSystemDirectory(ExpandedPath, MAX_PATH);
667         StringCchLength(ExpandedPath, MAX_PATH, &StringLength);
668         if (ExpandedPath[StringLength - 1] != L'\\')
669         {
670             /* It isn't, so add it ourselves */
671             StringCchCat(ExpandedPath, MAX_PATH, L"\\");
672         }
673         StringCchCat(ExpandedPath, MAX_PATH, L"DRIVERS\\ETC\\");
674     }
675 
676     /* Make sure that the path is backslash-terminated */
677     StringCchLength(ExpandedPath, MAX_PATH, &StringLength);
678     if (ExpandedPath[StringLength - 1] != L'\\')
679     {
680         /* It isn't, so add it ourselves */
681         StringCchCat(ExpandedPath, MAX_PATH, L"\\");
682     }
683 
684     /* Add the database name */
685     StringCchCat(ExpandedPath, MAX_PATH, Name);
686 
687     /* Return a handle to the file */
688     ret = CreateFile(ExpandedPath,
689                       FILE_READ_DATA,
690                       FILE_SHARE_READ,
691                       NULL,
692                       OPEN_EXISTING,
693                       FILE_ATTRIBUTE_NORMAL,
694                       NULL);
695 
696     HeapFree(GetProcessHeap(), 0, ExpandedPath);
697     return ret;
698 }
699 
700 INT
701 NSP_GetServiceByNameHeapAllocW(_In_ PWSHANDLEINTERN data,
702                                _In_ DWORD dwControlFlags,
703                                _Out_ PWSHOSTINFOINTERN hostinfo)
704 {
705     BOOL Found = FALSE;
706     HANDLE ServicesFile;
707     CHAR ServiceDBData[BUFSIZ * sizeof(WCHAR)] = {0};
708     PCHAR ThisLine = 0, NextLine = 0, ServiceName = 0, PortNumberStr = 0,
709     ProtocolStr = 0, Comment = 0, EndValid;
710     PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS] = {0};
711     PCHAR* AliasPtr;
712     UINT i = 0;
713     DWORD ReadSize = 0;
714     HANDLE hHeap;
715     PCHAR nameA = NULL;
716     PCHAR nameServiceA = NULL;
717     PCHAR nameProtoA = NULL;
718     INT res = WSANO_RECOVERY;
719 
720     if (!data->hostnameW)
721     {
722         res = WSANO_RECOVERY;
723         goto End;
724     }
725 
726     hHeap = GetProcessHeap();
727     nameA = StrW2AHeapAlloc(hHeap, data->hostnameW);
728 
729     /* nameA has the form <service-name>/<protocol>
730        we split these now */
731     nameProtoA = strchr(nameA, '/');
732     if (nameProtoA == NULL)
733     {
734         res = WSANO_RECOVERY;
735         goto End;
736     }
737 
738     nameProtoA++;
739     i = (DWORD)(nameProtoA - nameA - 1);
740     nameServiceA = (PCHAR)HeapAlloc(hHeap, 0, i + 1);
741     StringCbCopyA(nameServiceA, i + 1, nameA);
742     nameServiceA[i] = '\0';
743 
744     ServicesFile = OpenNetworkDatabase(L"services");
745     if (ServicesFile == INVALID_HANDLE_VALUE)
746     {
747         return WSANO_RECOVERY;
748     }
749 
750     /* Scan the services file ...
751     *
752     * We will be share the buffer on the lines. If the line does not fit in
753     * the buffer, then moving it to the beginning of the buffer and read
754     * the remnants of line from file.
755     */
756 
757     /* Initial Read */
758     ReadFile(ServicesFile,
759              ServiceDBData,
760              sizeof( ServiceDBData ) - 1,
761              &ReadSize,
762              NULL);
763 
764     ThisLine = NextLine = ServiceDBData;
765     EndValid = ServiceDBData + ReadSize;
766     ServiceDBData[sizeof(ServiceDBData) - 1] = '\0';
767 
768     while (ReadSize)
769     {
770         for (; *NextLine != '\r' && *NextLine != '\n'; NextLine++)
771         {
772             if (NextLine == EndValid)
773             {
774                 int LineLen = NextLine - ThisLine;
775 
776                 if (ThisLine == ServiceDBData)
777                 {
778                     //WS_DbgPrint(MIN_TRACE,("Line too long"));
779                     return WSANO_RECOVERY;
780                 }
781 
782                 memmove(ServiceDBData, ThisLine, LineLen);
783 
784                 ReadFile(ServicesFile,
785                          ServiceDBData + LineLen,
786                          sizeof( ServiceDBData )-1 - LineLen,
787                          &ReadSize,
788                          NULL);
789 
790                 EndValid = ServiceDBData + LineLen + ReadSize;
791                 NextLine = ServiceDBData + LineLen;
792                 ThisLine = ServiceDBData;
793 
794                 if (!ReadSize) break;
795             }
796         }
797 
798         *NextLine = '\0';
799         Comment = strchr(ThisLine, '#');
800 
801         if (Comment)
802             *Comment = '\0'; /* Terminate at comment start */
803 
804         if (DecodeServEntFromString(ThisLine,
805                                     &ServiceName,
806                                     &PortNumberStr,
807                                     &ProtocolStr,
808                                     Aliases,
809                                     WS2_INTERNAL_MAX_ALIAS) &&
810             (strlen(nameProtoA) == 0 || strcmp(ProtocolStr, nameProtoA) == 0))
811         {
812             Found = (strcmp(ServiceName, nameServiceA) == 0 || strcmp(PortNumberStr, nameServiceA) == 0);
813             AliasPtr = Aliases;
814             while ((!Found) && (*AliasPtr != NULL))
815             {
816                 Found = (strcmp(*AliasPtr, nameServiceA) == 0);
817                 AliasPtr++;
818             }
819             if (Found)
820                 break;
821         }
822         NextLine++;
823         ThisLine = NextLine;
824     }
825 
826     /* This we'll do no matter what */
827     CloseHandle(ServicesFile);
828 
829     if (!Found)
830     {
831         return WSANO_DATA;
832     }
833 
834     hostinfo->addr4 = 0;
835     hostinfo->servnameW = StrA2WHeapAlloc(hHeap, ServiceName);
836     hostinfo->servprotoW = StrA2WHeapAlloc(hHeap, ProtocolStr);
837     hostinfo->servaliasesA = StrAryCpyHeapAllocA(hHeap, (char**)&Aliases);
838     hostinfo->servport = atoi(PortNumberStr);
839 
840     res = NO_ERROR;
841 
842 End:
843     if (nameA != NULL)
844         HeapFree(hHeap, 0, nameA);
845 
846     if (nameServiceA != NULL)
847         HeapFree(hHeap, 0, nameServiceA);
848 
849     return res;
850 }
851 
852 INT
853 NSP_LookupServiceNextW(_In_ PWSHANDLEINTERN data,
854                        _In_ DWORD dwControlFlags,
855                        _Inout_ LPWSAQUERYSETW lpRes,
856                        _Inout_ LPDWORD lpResLen)
857 {
858     MSW_BUFFER buf;
859     WSHOSTINFOINTERN hostinfo;
860     INT result;
861     HANDLE hHeap = GetProcessHeap();
862     WCHAR* ServiceInstanceNameW = NULL;
863     /* cleanup-vars */
864     CHAR* ServiceInstanceNameA = NULL;
865     CHAR* ServiceProtocolNameA = NULL;
866 
867     RtlZeroMemory(&hostinfo, sizeof(hostinfo));
868 
869     /* init and build result-buffer */
870     mswBufferInit(&buf, (BYTE*)lpRes, *lpResLen);
871     mswBufferIncUsed(&buf, sizeof(*lpRes));
872 
873     /* QueryDataSet-Size without "blob-data"-size! */
874     lpRes->dwSize = sizeof(*lpRes);
875     lpRes->dwNameSpace = NS_DNS;
876 
877     if ((data->CallID == NSP_CALLID_HOSTNAME) ||
878         (data->CallID == NSP_CALLID_HOSTBYNAME) ||
879         (data->CallID == NSP_CALLID_SERVICEBYNAME))
880     {
881         if (data->CallIDCounter >= 1)
882         {
883             result = WSAENOMORE;
884             goto End;
885         }
886     }
887     else
888     {
889         result = WSANO_RECOVERY;
890         goto End;
891     }
892     data->CallIDCounter++;
893 
894     if (data->CallID == NSP_CALLID_HOSTNAME)
895     {
896         result = NSP_GetHostNameHeapAllocW(&hostinfo.hostnameW);
897 
898         if (result != ERROR_SUCCESS)
899             goto End;
900 
901         hostinfo.addr4 = 0;
902     }
903     else if (data->CallID == NSP_CALLID_HOSTBYNAME)
904     {
905         result = NSP_GetHostByNameHeapAllocW(data,
906                                              dwControlFlags,
907                                              &hostinfo);
908         if (result != ERROR_SUCCESS)
909             goto End;
910     }
911     else
912     {
913         ASSERT(data->CallID == NSP_CALLID_SERVICEBYNAME);
914         result = NSP_GetServiceByNameHeapAllocW(data,
915                                                 dwControlFlags,
916                                                 &hostinfo);
917         if (result != ERROR_SUCCESS)
918             goto End;
919     }
920 
921     if (((LUP_RETURN_BLOB & data->dwControlFlags) != 0) ||
922         ((LUP_RETURN_NAME & data->dwControlFlags) != 0))
923     {
924         if (data->CallID == NSP_CALLID_HOSTNAME || data->CallID == NSP_CALLID_HOSTBYNAME)
925         {
926             ServiceInstanceNameW = hostinfo.hostnameW;
927             ServiceInstanceNameA = StrW2AHeapAlloc(hHeap, ServiceInstanceNameW);
928             if (ServiceInstanceNameA == NULL)
929             {
930                 result = WSAEFAULT;
931                 goto End;
932 
933             }
934         }
935         if (data->CallID == NSP_CALLID_SERVICEBYNAME)
936         {
937             ServiceInstanceNameW = hostinfo.servnameW;
938             ServiceInstanceNameA = StrW2AHeapAlloc(hHeap, ServiceInstanceNameW);
939             if (ServiceInstanceNameA == NULL)
940             {
941                 result = WSAEFAULT;
942                 goto End;
943 
944             }
945             ServiceProtocolNameA = StrW2AHeapAlloc(hHeap, hostinfo.servprotoW);
946             if (ServiceProtocolNameA == NULL)
947             {
948                 result = WSAEFAULT;
949                 goto End;
950 
951             }
952         }
953     }
954 
955     if ((LUP_RETURN_ADDR & data->dwControlFlags) != 0)
956     {
957         if (!mswBufferAppendAddr_AddrInfoW(&buf, lpRes, hostinfo.addr4))
958         {
959             *lpResLen = buf.bytesUsed;
960             result = WSAEFAULT;
961             goto End;
962         }
963     }
964 
965     if ((LUP_RETURN_BLOB & data->dwControlFlags) != 0)
966     {
967         if (data->CallID == NSP_CALLID_HOSTBYNAME)
968         {
969             /* Write data for PBLOB (hostent) */
970             if (!mswBufferAppendBlob_Hostent(&buf,
971                                              lpRes,
972                                              (LUP_RETURN_ALIASES & data->dwControlFlags) != 0 ? hostinfo.servaliasesA : NULL,
973                                              ServiceInstanceNameA,
974                                              hostinfo.addr4))
975             {
976                 *lpResLen = buf.bytesUsed;
977                 result = WSAEFAULT;
978                 goto End;
979             }
980         }
981         else if (data->CallID == NSP_CALLID_SERVICEBYNAME)
982         {
983             /* Write data for PBLOB (servent) */
984             if (!mswBufferAppendBlob_Servent(&buf,
985                                              lpRes,
986                                              ServiceInstanceNameA,/* ServiceName */
987                                              (LUP_RETURN_ALIASES & data->dwControlFlags) != 0 ? hostinfo.servaliasesA : NULL,
988                                              ServiceProtocolNameA,
989                                              hostinfo.servport))
990             {
991                 *lpResLen = buf.bytesUsed;
992                 result = WSAEFAULT;
993                 goto End;
994             }
995         }
996         else
997         {
998             result = WSANO_RECOVERY;
999             goto End;
1000         }
1001     }
1002 
1003     if ((LUP_RETURN_NAME & data->dwControlFlags) != 0)
1004     {
1005         /* HostByName sets the ServiceInstanceName to a
1006            (UNICODE)copy of hostent.h_name */
1007         lpRes->lpszServiceInstanceName = (LPWSTR)mswBufferEndPtr(&buf);
1008         if (!mswBufferAppendStrW(&buf, ServiceInstanceNameW))
1009         {
1010             lpRes->lpszServiceInstanceName = NULL;
1011             *lpResLen = buf.bytesUsed;
1012             result = WSAEFAULT;
1013             goto End;
1014         }
1015     }
1016 
1017     *lpResLen = buf.bytesUsed;
1018 
1019     result = ERROR_SUCCESS;
1020 End:
1021     /* cleanup */
1022     if (ServiceInstanceNameA != NULL)
1023         HeapFree(hHeap, 0, ServiceInstanceNameA);
1024 
1025     if (ServiceProtocolNameA != NULL)
1026         HeapFree(hHeap, 0, ServiceProtocolNameA);
1027 
1028     if (hostinfo.hostnameW != NULL)
1029         HeapFree(hHeap, 0, hostinfo.hostnameW);
1030 
1031     if (hostinfo.servnameW != NULL)
1032         HeapFree(hHeap, 0, hostinfo.servnameW);
1033 
1034     if (hostinfo.servprotoW != NULL)
1035         HeapFree(hHeap, 0, hostinfo.servprotoW);
1036 
1037     return result;
1038 }
1039 
1040 /* Implementations - Exports */
1041 /*
1042  * @implemented
1043  */
1044 int
1045 WINAPI
1046 NSPStartup(_In_ LPGUID lpProviderId,
1047            _Out_ LPNSP_ROUTINE lpRout)
1048 {
1049     INT ret;
1050 
1051     if ((lpRout == NULL) ||
1052         (lpRout->cbSize != sizeof(NSP_ROUTINE)))
1053     {
1054         WSASetLastError(ERROR_INVALID_PARAMETER);
1055         return ERROR_INVALID_PARAMETER;
1056     }
1057 
1058     mwsNSPInit();
1059 
1060     /* set own Provider GUID - maybe we need
1061        here to set the original mswsock-GUID?! */
1062 
1063     /* Win2k3 returns
1064        - Version 1.1
1065        - no NSPIoctl
1066        - sets cbSize to 44! */
1067     lpRout->dwMajorVersion = 1;
1068     lpRout->dwMinorVersion = 1;
1069     lpRout->cbSize = sizeof(*lpRout) - sizeof(lpRout->NSPIoctl);
1070     lpRout->NSPCleanup = &mwsNSPCleanUp;
1071     lpRout->NSPLookupServiceBegin = &mwsNSPLookupServiceBegin;
1072     lpRout->NSPLookupServiceNext = &mwsNSPLookupServiceNext;
1073     lpRout->NSPLookupServiceEnd = &mwsNSPLookupServiceEnd;
1074     lpRout->NSPSetService = &mwsNSPSetService;
1075     lpRout->NSPInstallServiceClass = &mwsNSPInstallServiceClass;
1076     lpRout->NSPRemoveServiceClass = &mwsNSPRemoveServiceClass;
1077     lpRout->NSPGetServiceClassInfo = &mwsNSPGetServiceClassInfo;
1078     lpRout->NSPIoctl = NULL;// &mwsNSPIoCtl;
1079 
1080     ret = NO_ERROR;
1081 
1082     return ret;
1083 }
1084