#include "mswhelper.h"
-#define NDEBUG
-#include <debug.h>
+#include <wine/debug.h>
+WINE_DEFAULT_DEBUG_CHANNEL(mswsock);
#define NSP_CALLID_DNS 0x0001
#define NSP_CALLID_HOSTNAME 0x0002
PWSHANDLEINTERN pLook;
int wsaErr;
+ TRACE("mwsNSPLookupServiceBegin %p %p %p %lx %p\n", lpProviderId, lpqsRestrictions, lpServiceClassInfo, dwControlFlags, lphLookup);
if (IsEqualGUID(lpProviderId, &guid_mswsock_TcpIp))
{
//OK
+ TRACE("TCPIP query\n");
}
else if (IsEqualGUID(lpProviderId, &guid_mswsock_NLA))
{
+ ERR("NLA queries are not supported yet\n");
WSASetLastError(WSASERVICE_NOT_FOUND);
return SOCKET_ERROR;
}
else
{
+ ERR("Unsupported GUID\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
pLook = HeapAlloc(GetProcessHeap(), 0, sizeof(WSHANDLEINTERN));
if (!pLook)
{
+ ERR("Error allocating %d for handle\n", sizeof(WSHANDLEINTERN));
WSASetLastError(WSAEFAULT);
return SOCKET_ERROR;
}
wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
if (IsEqualGUID(lpqsRestrictions->lpServiceClassId, &guid_NULL))
{
+ ERR("NULL GUID service class is not implemented yet\n");
wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
}
else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId, &guid_HOSTNAME))
{
+ TRACE("HOSTNAME GUID\n");
wsaErr = NSP_LookupServiceBeginW(pLook,
NULL,
NULL,
else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
&guid_INET_HOSTADDRBYNAME))
{
- wsaErr = NSP_LookupServiceBeginW(pLook,
- NULL,
- lpqsRestrictions->lpszServiceInstanceName,
- NSP_CALLID_HOSTBYNAME);
+ TRACE("INET_HOSTADDRBYNAME GUID\n");
+ wsaErr = NSP_LookupServiceBeginW(pLook,
+ NULL,
+ lpqsRestrictions->lpszServiceInstanceName,
+ NSP_CALLID_HOSTBYNAME);
}
else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
&guid_INET_SERVICEBYNAME))
{
- wsaErr = NSP_LookupServiceBeginW(pLook,
- NULL,
- lpqsRestrictions->lpszServiceInstanceName,
- NSP_CALLID_SERVICEBYNAME);
+ TRACE("INET_SERVICEBYNAME\n");
+ wsaErr = NSP_LookupServiceBeginW(pLook,
+ NULL,
+ lpqsRestrictions->lpszServiceInstanceName,
+ NSP_CALLID_SERVICEBYNAME);
}
else if (IsEqualGUID(lpqsRestrictions->lpServiceClassId,
&guid_INET_HOSTADDRBYINETSTRING))
{
+ ERR("INET_HOSTADDRBYINETSTRING GUID service class is not implemented yet\n");
wsaErr = ERROR_CALL_NOT_IMPLEMENTED;
}
if (wsaErr != NO_ERROR)
{
+ ERR("mwsNSPLookupServiceBegin wsaErr = %d\n", wsaErr);
WSASetLastError(wsaErr);
return SOCKET_ERROR;
}
PWSHANDLEINTERN pLook = hLookup;
int wsaErr = 0;
+ TRACE("mwsNSPLookupServiceNext %p %lx %p %p\n", pLook, dwControlFlags, lpdwBufferLength, lpqsResults);
#ifdef NSP_REDIRECT
INT res = pLook->rdrproc.NSPLookupServiceNext(pLook->rdrLookup,
End:
if (wsaErr != 0)
{
+ ERR("mwsNSPLookupServiceNext wsaErr = %d\n", wsaErr);
WSASetLastError(wsaErr);
return SOCKET_ERROR;
}
_In_opt_ LPWSACOMPLETION lpCompletion,
_In_ LPWSATHREADID lpThreadId)
{
- WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ ERR("mwsNSPIoCtl not implemented %p %lx %p %ld %p %ld %p %p %p\n", hLookup, dwControlCode, lpvInBuffer, cbInBuffer, lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, lpCompletion, lpThreadId);
+ WSASetLastError(WSAEOPNOTSUPP);
return ERROR_CALL_NOT_IMPLEMENTED;
}
WSAAPI
mwsNSPLookupServiceEnd(_In_ HANDLE hLookup)
{
- PWSHANDLEINTERN pLook;
- HANDLE hHeap;
- INT res;
-
- res = NO_ERROR;
- pLook = (PWSHANDLEINTERN)hLookup;
- hHeap = GetProcessHeap();
+ PWSHANDLEINTERN pLook = (PWSHANDLEINTERN)hLookup;
+ HANDLE hHeap = GetProcessHeap();
+ INT res = NO_ERROR;
+ TRACE("mwsNSPLookupServiceEnd %p\n", pLook);
#ifdef NSP_REDIRECT
res = pLook->rdrproc.NSPLookupServiceEnd(pLook->rdrLookup);
#endif
_In_ WSAESETSERVICEOP essOperation,
_In_ DWORD dwControlFlags)
{
- WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ ERR("mwsNSPSetService not implemented %p %p %p %d %lx %ld %p %p %p\n", lpProviderId, lpServiceClassInfo, lpqsRegInfo, essOperation, dwControlFlags);
+ WSASetLastError(WSAEOPNOTSUPP);
return ERROR_CALL_NOT_IMPLEMENTED;
}
mwsNSPInstallServiceClass(_In_ LPGUID lpProviderId,
_In_ LPWSASERVICECLASSINFOW lpServiceClassInfo)
{
- WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ ERR("mwsNSPInstallServiceClass not implemented %p %p\n", lpProviderId, lpServiceClassInfo);
+ WSASetLastError(WSAEOPNOTSUPP);
return ERROR_CALL_NOT_IMPLEMENTED;
}
mwsNSPRemoveServiceClass(_In_ LPGUID lpProviderId,
_In_ LPGUID lpServiceClassId)
{
- WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ ERR("mwsNSPRemoveServiceClass not implemented %p %p\n", lpProviderId, lpServiceClassId);
+ WSASetLastError(WSAEOPNOTSUPP);
return ERROR_CALL_NOT_IMPLEMENTED;
}
_In_ LPDWORD lpdwBufSize,
_In_ LPWSASERVICECLASSINFOW lpServiceClassInfo)
{
- WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ ERR("mwsNSPGetServiceClassInfo not implemented %p %p %p\n", lpProviderId, lpdwBufSize, lpServiceClassInfo);
+ WSASetLastError(WSAEOPNOTSUPP);
return ERROR_CALL_NOT_IMPLEMENTED;
}
{
HANDLE hHeap;
+ TRACE("NSP_LookupServiceBeginW %p %p %p %lx\n", data, hostnameA, hostnameW, CallID);
if (data->CallID != 0)
return WSAEFAULT;
data->hostnameW = StrCpyHeapAllocW(hHeap, hostnameW);
}
}
-
- WSASetLastError(0);
+ else
+ {
+ ERR("NSP_LookupServiceBeginW unsupported CallID\n");
+ WSASetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return ERROR_CALL_NOT_IMPLEMENTED;
+ }
return ERROR_SUCCESS;
}
{
WCHAR* name;
HANDLE hHeap = GetProcessHeap();
- DWORD bufCharLen = MAX_COMPUTERNAME_LENGTH + 1;
- DWORD bufByteLen = bufCharLen * sizeof(WCHAR);
-
- name = HeapAlloc(hHeap, 0, bufByteLen);
+ DWORD bufCharLen = 0;
+ TRACE("NSP_GetHostNameHeapAllocW %p\n", hostname);
+ /* FIXME Use DnsGetHostName_W when available */
+ GetComputerNameExW(ComputerNameDnsHostname, NULL, &bufCharLen);
+ if (!bufCharLen)
+ {
+ ERR("NSP_GetHostNameHeapAllocW zero size for computername returned\n");
+ WSASetLastError(WSAEFAULT);
+ return SOCKET_ERROR;
+ }
+ name = HeapAlloc(hHeap, 0, bufCharLen*sizeof(WCHAR));
if (!GetComputerNameExW(ComputerNameDnsHostname,
name,
&bufCharLen))
{
+ ERR("NSP_GetHostNameHeapAllocW error obtaining computername %lx\n", GetLastError());
HeapFree(hHeap, 0, name);
WSASetLastError(WSAEFAULT);
return SOCKET_ERROR;
PWCHAR Aliases[WS2_INTERNAL_MAX_ALIAS] = { 0 };
int AliasIndex = 0;
+ TRACE("NSP_GetHostByNameHeapAllocW %p %lx %p\n", data, dwControlFlags, hostinfo);
/* needed to be cleaned up if != NULL */
dp = NULL;
- if (data->hostnameW == NULL)
+ if (!data->hostnameW)
{
result = ERROR_INVALID_PARAMETER;
goto cleanup;
if ((data->dwControlFlags & LUP_DEEP) == 0)
{
+ TRACE("NSP_GetHostByNameHeapAllocW LUP_DEEP is not specified. Disabling recursion\n");
dwQueryFlags |= DNS_QUERY_NO_RECURSION;
}
NULL);
if (dns_status == ERROR_INVALID_NAME)
{
+ ERR("NSP_GetHostByNameHeapAllocW invalid name\n");
WSASetLastError(WSAEFAULT);
result = ERROR_INVALID_PARAMETER;
goto cleanup;
if ((dns_status != 0) || (dp == NULL))
{
+ ERR("NSP_GetHostByNameHeapAllocW not found %lx %p\n", dns_status, dp);
result = WSAHOST_NOT_FOUND;
goto cleanup;
}
{
if (curr->wType == DNS_TYPE_CNAME)
{
+ TRACE("NSP_GetHostByNameHeapAllocW found alias %ws\n", curr->Data.Cname.pNameHost);
Aliases[AliasIndex++] = curr->Data.Cname.pNameHost;
}
curr = curr->pNext;
if (curr->wType != DNS_TYPE_A)
{
+ ERR("NSP_GetHostByNameHeapAllocW last record is not of type A %d\n", curr->wType);
result = WSASERVICE_NOT_FOUND;
goto cleanup;
}
DWORD RegType;
DWORD RegSize = 0;
size_t StringLength;
- HANDLE ret;
+ HANDLE Handle;
+ TRACE("OpenNetworkDatabase %p\n", Name);
ExpandedPath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH*sizeof(WCHAR));
if (!ExpandedPath)
return INVALID_HANDLE_VALUE;
&DatabaseKey);
if (ErrorCode == NO_ERROR)
{
+ TRACE("OpenNetworkDatabase registry key for network database exist\n");
/* Read the actual path */
ErrorCode = RegQueryValueEx(DatabaseKey,
L"DatabasePath",
NULL,
&RegSize);
+ if (!RegSize)
+ {
+ ERR("OpenNetworkDatabase RegQueryValueEx failed to return size for DatabasePath %lx\n", ErrorCode);
+ RegCloseKey(DatabaseKey);
+ HeapFree(GetProcessHeap(), 0, ExpandedPath);
+ return INVALID_HANDLE_VALUE;
+ }
DatabasePath = HeapAlloc(GetProcessHeap(), 0, RegSize);
if (!DatabasePath)
{
+ ERR("OpenNetworkDatabase could not allocate %d for DatabasePath\n", RegSize);
+ RegCloseKey(DatabaseKey);
HeapFree(GetProcessHeap(), 0, ExpandedPath);
return INVALID_HANDLE_VALUE;
}
/* Close the key */
RegCloseKey(DatabaseKey);
+ if (ErrorCode)
+ {
+ ERR("OpenNetworkDatabase RegQueryValueEx failed to return value for DatabasePath %lx\n", ErrorCode);
+ HeapFree(GetProcessHeap(), 0, DatabasePath);
+ HeapFree(GetProcessHeap(), 0, ExpandedPath);
+ return INVALID_HANDLE_VALUE;
+ }
+
/* Expand the name */
ExpandEnvironmentStrings(DatabasePath, ExpandedPath, MAX_PATH);
}
else
{
+ TRACE("OpenNetworkDatabase registry key for network database doesn't exist\n");
/* Use defalt path */
GetSystemDirectory(ExpandedPath, MAX_PATH);
StringCchLength(ExpandedPath, MAX_PATH, &StringLength);
StringCchCat(ExpandedPath, MAX_PATH, Name);
/* Return a handle to the file */
- ret = CreateFile(ExpandedPath,
- FILE_READ_DATA,
- FILE_SHARE_READ,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL);
+ Handle = CreateFile(ExpandedPath,
+ FILE_READ_DATA,
+ FILE_SHARE_READ,
+ NULL,
+ OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL,
+ NULL);
HeapFree(GetProcessHeap(), 0, ExpandedPath);
- return ret;
+ return Handle;
}
INT
{
BOOL Found = FALSE;
HANDLE ServicesFile;
- CHAR ServiceDBData[BUFSIZ * sizeof(WCHAR)] = {0};
+ CHAR ServiceDBData[BUFSIZ * sizeof(WCHAR)] = { 0 };
PCHAR ThisLine = 0, NextLine = 0, ServiceName = 0, PortNumberStr = 0,
ProtocolStr = 0, Comment = 0, EndValid;
- PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS] = {0};
+ PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS] = { 0 };
PCHAR* AliasPtr;
UINT i = 0;
DWORD ReadSize = 0;
PCHAR nameProtoA = NULL;
INT res = WSANO_RECOVERY;
+ TRACE("NSP_GetServiceByNameHeapAllocW %p %lx %p\n", data, dwControlFlags, hostinfo);
if (!data->hostnameW)
{
+ ERR("NSP_GetServiceByNameHeapAllocW service name not provided\n");
res = WSANO_RECOVERY;
goto End;
}
nameProtoA = strchr(nameA, '/');
if (nameProtoA == NULL)
{
+ ERR("NSP_GetServiceByNameHeapAllocW invalid service name %s\n", nameA);
res = WSANO_RECOVERY;
goto End;
}
ServicesFile = OpenNetworkDatabase(L"services");
if (ServicesFile == INVALID_HANDLE_VALUE)
{
+ ERR("NSP_GetServiceByNameHeapAllocW unable to open services file\n");
return WSANO_RECOVERY;
}
*/
/* Initial Read */
- ReadFile(ServicesFile,
- ServiceDBData,
- sizeof( ServiceDBData ) - 1,
- &ReadSize,
- NULL);
+ if (!ReadFile(ServicesFile,
+ ServiceDBData,
+ sizeof( ServiceDBData ) - 1,
+ &ReadSize,
+ NULL))
+ {
+ ERR("NSP_GetServiceByNameHeapAllocW can't read services file %lx\n", GetLastError());
+ CloseHandle(ServicesFile);
+ return WSANO_RECOVERY;
+ }
ThisLine = NextLine = ServiceDBData;
EndValid = ServiceDBData + ReadSize;
if (ThisLine == ServiceDBData)
{
- //WS_DbgPrint(MIN_TRACE,("Line too long"));
+ ERR("NSP_GetServiceByNameHeapAllocW line too long\n");
+ CloseHandle(ServicesFile);
return WSANO_RECOVERY;
}
memmove(ServiceDBData, ThisLine, LineLen);
- ReadFile(ServicesFile,
- ServiceDBData + LineLen,
- sizeof( ServiceDBData )-1 - LineLen,
- &ReadSize,
- NULL);
+ if (!ReadFile(ServicesFile,
+ ServiceDBData + LineLen,
+ sizeof( ServiceDBData )-1 - LineLen,
+ &ReadSize,
+ NULL))
+ {
+ break;
+ }
EndValid = ServiceDBData + LineLen + ReadSize;
NextLine = ServiceDBData + LineLen;
if (!Found)
{
+ ERR("NSP_GetServiceByNameHeapAllocW service not found\n");
return WSANO_DATA;
}
res = NO_ERROR;
End:
- if (nameA != NULL)
+ if (nameA)
HeapFree(hHeap, 0, nameA);
- if (nameServiceA != NULL)
+ if (nameServiceA)
HeapFree(hHeap, 0, nameServiceA);
return res;
CHAR* ServiceInstanceNameA = NULL;
CHAR* ServiceProtocolNameA = NULL;
+ TRACE("NSP_LookupServiceNextW %p %lx %p %p\n", data, dwControlFlags, lpRes, lpResLen);
+ if (!data || (dwControlFlags & (~(DWORD)LUP_FLUSHPREVIOUS)) != 0 || !lpRes || !lpResLen || *lpResLen == 0)
+ return WSAEINVAL;
RtlZeroMemory(&hostinfo, sizeof(hostinfo));
/* init and build result-buffer */
(data->CallID == NSP_CALLID_HOSTBYNAME) ||
(data->CallID == NSP_CALLID_SERVICEBYNAME))
{
+ /* FIXME remember what was returned and continue from there */
if (data->CallIDCounter >= 1)
{
- result = WSAENOMORE;
+ ERR("NSP_LookupServiceNextW LUP_FLUSHPREVIOUS and more than one call not supported yet\n", data, dwControlFlags, lpRes, lpResLen);
+ result = WSA_E_NO_MORE;
goto End;
}
}
else
{
- result = WSANO_RECOVERY;
+ ERR("NSP_LookupServiceNextW unsupported CallID %lx\n", data->CallID);
+ result = WSAEOPNOTSUPP;
goto End;
}
data->CallIDCounter++;
}
else
{
- ASSERT(data->CallID == NSP_CALLID_SERVICEBYNAME);
+ //ASSERT(data->CallID == NSP_CALLID_SERVICEBYNAME);
result = NSP_GetServiceByNameHeapAllocW(data,
dwControlFlags,
&hostinfo);
{
ServiceInstanceNameW = hostinfo.hostnameW;
ServiceInstanceNameA = StrW2AHeapAlloc(hHeap, ServiceInstanceNameW);
- if (ServiceInstanceNameA == NULL)
+ if (!ServiceInstanceNameA)
{
- result = WSAEFAULT;
+ ERR("NSP_LookupServiceNextW not enough memory\n");
+ result = WSA_NOT_ENOUGH_MEMORY;
goto End;
-
}
}
if (data->CallID == NSP_CALLID_SERVICEBYNAME)
{
ServiceInstanceNameW = hostinfo.servnameW;
ServiceInstanceNameA = StrW2AHeapAlloc(hHeap, ServiceInstanceNameW);
- if (ServiceInstanceNameA == NULL)
+ if (!ServiceInstanceNameA)
{
- result = WSAEFAULT;
+ ERR("NSP_LookupServiceNextW not enough memory\n");
+ result = WSA_NOT_ENOUGH_MEMORY;
goto End;
-
}
ServiceProtocolNameA = StrW2AHeapAlloc(hHeap, hostinfo.servprotoW);
- if (ServiceProtocolNameA == NULL)
+ if (!ServiceProtocolNameA)
{
- result = WSAEFAULT;
+ ERR("NSP_LookupServiceNextW not enough memory\n");
+ result = WSA_NOT_ENOUGH_MEMORY;
goto End;
-
}
}
}
{
if (!mswBufferAppendAddr_AddrInfoW(&buf, lpRes, hostinfo.addr4))
{
+ ERR("NSP_LookupServiceNextW provided buffer is too small\n");
*lpResLen = buf.bytesUsed;
result = WSAEFAULT;
goto End;
ServiceInstanceNameA,
hostinfo.addr4))
{
+ ERR("NSP_LookupServiceNextW provided buffer is too small\n");
*lpResLen = buf.bytesUsed;
result = WSAEFAULT;
goto End;
ServiceProtocolNameA,
hostinfo.servport))
{
+ ERR("NSP_LookupServiceNextW provided buffer is too small\n");
*lpResLen = buf.bytesUsed;
result = WSAEFAULT;
goto End;
}
else
{
- result = WSANO_RECOVERY;
+ ERR("NSP_LookupServiceNextW LUP_RETURN_BLOB is supported only for NSP_CALLID_HOSTBYNAME and NSP_CALLID_SERVICEBYNAME\n");
+ result = WSAEINVAL;
goto End;
}
}
lpRes->lpszServiceInstanceName = (LPWSTR)mswBufferEndPtr(&buf);
if (!mswBufferAppendStrW(&buf, ServiceInstanceNameW))
{
+ ERR("NSP_LookupServiceNextW provided buffer is too small\n");
lpRes->lpszServiceInstanceName = NULL;
*lpResLen = buf.bytesUsed;
result = WSAEFAULT;
if (hostinfo.servprotoW != NULL)
HeapFree(hHeap, 0, hostinfo.servprotoW);
+ TRACE("NSP_LookupServiceNextW returns %d needed bytes %ld\n", result, buf.bytesUsed);
return result;
}
{
INT ret;
- if ((lpRout == NULL) ||
- (lpRout->cbSize != sizeof(NSP_ROUTINE)))
+ TRACE("NSPStartup %p %p\n", lpProviderId, lpRout);
+ if (!lpRout || (lpRout->cbSize != sizeof(NSP_ROUTINE)))
{
- WSASetLastError(ERROR_INVALID_PARAMETER);
+ ERR("NSPStartup invalid parameter\n");
+ WSASetLastError(WSAEINVAL);
return ERROR_INVALID_PARAMETER;
}
projects / reactos.git / blobdiff