[DLLS] Fix 64 bit issues

dll/cpl/sysdm/hardprof.c

···
                               L"PreferenceOrder",
                               NULL,
                               NULL,
-                              (LPBYTE)pProfile->dwPreferenceOrder,
+                              (LPBYTE)&pProfile->dwPreferenceOrder,
                               &dwSize);
     if (lError == ERROR_SUCCESS)
     {

dll/directx/ksuser/ksuser.c

···
                      PHANDLE phHandle)
 {
     NTSTATUS Status;
-    ULONG Length;
-    ULONG TotalSize;
+    SIZE_T Length;
+    SIZE_T TotalSize;
     LPWSTR pStr;
     UNICODE_STRING ObjectName;
     OBJECT_ATTRIBUTES ObjectAttributes;

dll/directx/wine/d3dcompiler_43/utils.c

···
     return S_OK;
 }
 
-HRESULT dxbc_init(struct dxbc *dxbc, UINT size)
+HRESULT dxbc_init(struct dxbc *dxbc, DWORD size)
 {
     TRACE("dxbc %p, size %u.\n", dxbc, size);
 

dll/ntdll/ldr/ldrapi.c

···
 
     /* Validate the cookie */
     if ((Cookie & 0xF0000000) ||
-        ((Cookie >> 16) ^ ((ULONG)(NtCurrentTeb()->RealClientId.UniqueThread) & 0xFFF)))
+        ((Cookie >> 16) ^ (HandleToUlong(NtCurrentTeb()->RealClientId.UniqueThread) & 0xFFF)))
     {
         DPRINT1("LdrUnlockLoaderLock() called with an invalid cookie!\n");
 

dll/ntdll/ldr/ldrinit.c

···
     if (NT_SUCCESS(Status))
     {
         /* Write the key handle */
-        if (_InterlockedCompareExchange((LONG*)RootKeyLocation, (LONG)RootKey, 0) != 0)
+        if (InterlockedCompareExchangePointer(RootKeyLocation, RootKey, NULL) != NULL)
         {
             /* Someone already opened it, use it instead */
             NtClose(RootKey);
···
             NtQueryPerformanceCounter(&Counter, NULL);
 
             NewCookie = Counter.LowPart ^ Counter.HighPart;
-            NewCookie ^= (ULONG)NtCurrentTeb()->ClientId.UniqueProcess;
-            NewCookie ^= (ULONG)NtCurrentTeb()->ClientId.UniqueThread;
+            NewCookie ^= (ULONG_PTR)NtCurrentTeb()->ClientId.UniqueProcess;
+            NewCookie ^= (ULONG_PTR)NtCurrentTeb()->ClientId.UniqueThread;
 
             /* Loop like it's done in KeQueryTickCount(). We don't want to call it directly. */
             while (SharedUserData->SystemTime.High1Time != SharedUserData->SystemTime.High2Time)

dll/win32/browseui/parsecmdline.cpp

···
     if (*strField != L':')
         return NULL;
 
-    HANDLE hData = (HANDLE) StrToIntW(strField + 1);
+    HANDLE hData = IntToPtr(StrToIntW(strField + 1));
     PWSTR strSecond = StrChrW(strField + 1, L':');
 
     if (strSecond)
···
             PathStripToRootW(strDir);
             pInfo->pidlPath = ILCreateFromPathW(strDir);
         }
-        return (LONG) (pInfo->pidlPath);
+        return (LONG_PTR)(pInfo->pidlPath);
     }
 
     PCWSTR strNextArg = _FindFirstField(strFieldArray);

dll/win32/fltlib/fltlib.c

···
 {
     PFILTER_NAME FilterName;
     HANDLE hFltMgr;
-    DWORD StringLength;
-    DWORD BufferLength;
+    SIZE_T StringLength;
+    SIZE_T BufferLength;
     DWORD dwError;
 
     /* Get a handle to the filter manager */

dll/win32/fltlib/message.c

···
     UNICODE_STRING DeviceName;
     UNICODE_STRING PortName;
     HANDLE FileHandle;
-    ULONG PortNameSize;
-    ULONG BufferSize;
+    SIZE_T PortNameSize;
+    SIZE_T BufferSize;
     PCHAR Ptr;
     NTSTATUS Status;
     HRESULT hr;

dll/win32/iphlpapi/ifenum_reactos.c

···
     NTSTATUS status = STATUS_SUCCESS;
     DWORD returnSize;
 
-    WARN("TdiGetMibForIfEntity(tcpFile %x,entityId %x)\n",
-           (int)tcpFile, (int)ent->tei_instance);
+    WARN("TdiGetMibForIfEntity(tcpFile %p,entityId %p)\n",
+           tcpFile, ent->tei_instance);
 
     req.ID.toi_class                = INFO_CLASS_PROTOCOL;
     req.ID.toi_type                 = INFO_TYPE_PROVIDER;

dll/win32/kernel32/client/file/create.c

···
 			default:
 				Sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
 		}
-		return (HFILE) CreateFileA (lpFileName,
+		return (HFILE)(ULONG_PTR) CreateFileA (lpFileName,
 		                            GENERIC_READ | GENERIC_WRITE,
 		                            Sharing,
 		                            NULL,
···
 	if (Len == 0 || Len > OFS_MAXPATHNAME)
 	{
 		lpReOpenBuff->nErrCode = (WORD)GetLastError();
-		return (HFILE)INVALID_HANDLE_VALUE;
+		return HFILE_ERROR;
 	}
 
     if (uStyle & OF_DELETE)
···
 					   NULL,
 					   NULL))
 	{
-		return (HFILE)INVALID_HANDLE_VALUE;
+		return HFILE_ERROR;
 	}
 
 	// FILE_SHARE_READ
···
 	if (!NT_SUCCESS(errCode))
 	{
 		BaseSetLastNTError (errCode);
-		return (HFILE)INVALID_HANDLE_VALUE;
+		return HFILE_ERROR;
 	}
 
 	if (uStyle & OF_EXIST)
···
 		return (HFILE)1;
 	}
 
-	return (HFILE)FileHandle;
+	return (HFILE)(ULONG_PTR)FileHandle;
 }
 
 /*

dll/win32/kernel32/client/file/lfile.c

···
 
     if (lBytes == 0)
     {
-        if (!SetEndOfFile((HANDLE) hFile))
+        if (!SetEndOfFile((HANDLE)(ULONG_PTR) hFile))
         {
             return HFILE_ERROR;
         }
···
         default:                  dwSharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
     }
 
-    return (HFILE) CreateFileA(lpPathName,
+    return (HFILE)(ULONG_PTR) CreateFileA(lpPathName,
                                dwAccess,
                                dwSharing,
                                NULL,

dll/win32/kernel32/client/thread.c

···
     ACTIVATION_CONTEXT_BASIC_INFORMATION ActCtxInfo;
     ULONG_PTR Cookie;
     ULONG ReturnLength;
+    SIZE_T ReturnSize;
     DPRINT("CreateRemoteThread: hProcess: %p dwStackSize: %lu lpStartAddress"
             ": %p lpParameter: %p, dwCreationFlags: %lx\n", hProcess,
             dwStackSize, lpStartAddress, lpParameter, dwCreationFlags);
···
                                                       ActivationContextBasicInformation,
                                                       &ActCtxInfo,
                                                       sizeof(ActCtxInfo),
-                                                      &ReturnLength);
+                                                      &ReturnSize);
         if (!NT_SUCCESS(Status))
         {
             /* Fail */

dll/win32/lsasrv/authpackage.c

···
                          OUT PVOID *ClientBaseAddress)
 {
     PLSAP_LOGON_CONTEXT LogonContext;
-    ULONG Length;
+    SIZE_T Length;
 
     *ClientBaseAddress = NULL;
 
···
                      IN PVOID ClientBaseAddress)
 {
     PLSAP_LOGON_CONTEXT LogonContext;
-    ULONG Length;
+    SIZE_T Length;
 
     if (ClientBaseAddress == NULL)
         return STATUS_SUCCESS;

dll/win32/lsasrv/session.c

···
     PLIST_ENTRY SessionEntry;
     PLSAP_LOGON_SESSION CurrentSession;
     PLUID SessionList;
-    ULONG i, Length, MemSize;
+    ULONG i, Length;
+    SIZE_T MemSize;
     PVOID ClientBaseAddress = NULL;
     NTSTATUS Status;
 
···
     PLSAP_LOGON_SESSION Session;
     PSECURITY_LOGON_SESSION_DATA LocalSessionData;
     PVOID ClientBaseAddress = NULL;
-    ULONG TotalLength, MemSize, SidLength = 0;
+    ULONG TotalLength, SidLength = 0;
+    SIZE_T MemSize;
     PUCHAR Ptr;
     NTSTATUS Status;
 

dll/win32/msafd/misc/dllmain.c

···
     if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags3 != 0 && lpProtocolInfo->dwServiceFlags4 != 0)
     {
         /* Duplpicating socket from different process */
-        if ((HANDLE)lpProtocolInfo->dwServiceFlags3 == INVALID_HANDLE_VALUE)
+        if (UlongToPtr(lpProtocolInfo->dwServiceFlags3) == INVALID_HANDLE_VALUE)
         {
             Status = WSAEINVAL;
             goto error;
         }
-        if ((HANDLE)lpProtocolInfo->dwServiceFlags4 == INVALID_HANDLE_VALUE)
+        if (UlongToPtr(lpProtocolInfo->dwServiceFlags4) == INVALID_HANDLE_VALUE)
         {
             Status = WSAEINVAL;
             goto error;
         }
-        SharedData = MapViewOfFile((HANDLE)lpProtocolInfo->dwServiceFlags3,
+        SharedData = MapViewOfFile(UlongToPtr(lpProtocolInfo->dwServiceFlags3),
                                    FILE_MAP_ALL_ACCESS,
                                    0,
                                    0,
···
     if (SharedData)
     {
         Socket->SharedData = SharedData;
-        Socket->SharedDataHandle = (HANDLE)lpProtocolInfo->dwServiceFlags3;
-        Sock = (HANDLE)lpProtocolInfo->dwServiceFlags4;
+        Socket->SharedDataHandle = UlongToHandle(lpProtocolInfo->dwServiceFlags3);
+        Sock = UlongToHandle(lpProtocolInfo->dwServiceFlags4);
         Socket->Handle = (SOCKET)lpProtocolInfo->dwServiceFlags4;
     }
     else
···
     if( SharedData )
     {
         UnmapViewOfFile(SharedData);
-        NtClose((HANDLE)lpProtocolInfo->dwServiceFlags3);
+        NtClose(UlongToHandle(lpProtocolInfo->dwServiceFlags3));
     }
     else
     {
···
     lpProtocolInfo->iAddressFamily = Socket->SharedData->AddressFamily;
     lpProtocolInfo->iProtocol = Socket->SharedData->Protocol;
     lpProtocolInfo->iSocketType = Socket->SharedData->SocketType;
-    lpProtocolInfo->dwServiceFlags3 = (DWORD)hDuplicatedSharedData;
-    lpProtocolInfo->dwServiceFlags4 = (DWORD)hDuplicatedHandle;
+    lpProtocolInfo->dwServiceFlags3 = HandleToUlong(hDuplicatedSharedData);
+    lpProtocolInfo->dwServiceFlags4 = HandleToUlong(hDuplicatedHandle);
 
     if( lpErrno )
         *lpErrno = NO_ERROR;
···
 
     /* Set up Address in TDI Format */
     BindData->Address.TAAddressCount = 1;
-    BindData->Address.Address[0].AddressLength = SocketAddressLength - sizeof(SocketAddress->sa_family);
+    BindData->Address.Address[0].AddressLength = (USHORT)(SocketAddressLength - sizeof(SocketAddress->sa_family));
     BindData->Address.Address[0].AddressType = SocketAddress->sa_family;
     RtlCopyMemory (BindData->Address.Address[0].Address,
                    SocketAddress->sa_data,
···
     return (DWORD)((Time.ll - u1970.ll) / 10000000ULL);
 }
 
+_Must_inspect_result_
 SOCKET
 WSPAPI
-WSPAccept(SOCKET Handle,
-          struct sockaddr *SocketAddress,
-          int *SocketAddressLength,
-          LPCONDITIONPROC lpfnCondition,
-          DWORD dwCallbackData,
-          LPINT lpErrno)
+WSPAccept(
+    _In_ SOCKET Handle,
+    _Out_writes_bytes_to_opt_(*addrlen, *addrlen) struct sockaddr FAR *SocketAddress,
+    _Inout_opt_ LPINT SocketAddressLength,
+    _In_opt_ LPCONDITIONPROC lpfnCondition,
+    _In_opt_ DWORD_PTR dwCallbackData,
+    _Out_ LPINT lpErrno)
 {
     IO_STATUS_BLOCK             IOSB;
     PAFD_RECEIVED_ACCEPT_DATA   ListenReceiveData;
···
  * RETURNS:
  *     Status of operation
  */
-INT
+_Must_inspect_result_
+int
 WSPAPI
-WSPStartup(IN  WORD wVersionRequested,
-           OUT LPWSPDATA lpWSPData,
-           IN  LPWSAPROTOCOL_INFOW lpProtocolInfo,
-           IN  WSPUPCALLTABLE UpcallTable,
-           OUT LPWSPPROC_TABLE lpProcTable)
-
+WSPStartup(
+    _In_ WORD wVersionRequested,
+    _In_ LPWSPDATA lpWSPData,
+    _In_ LPWSAPROTOCOL_INFOW lpProtocolInfo,
+    _In_ WSPUPCALLTABLE UpcallTable,
+    _Out_ LPWSPPROC_TABLE lpProcTable)
 {
     NTSTATUS Status;
 
···
                    IN OUT LPDWORD lpdwAddressStringLength,
                    OUT LPINT lpErrno)
 {
-    DWORD size;
+    SIZE_T size;
     WCHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
     WCHAR *p;
 

dll/win32/msafd/msafd.h

···
     PSOCKET_INFORMATION lpSocket;
 } AFDAPCCONTEXT, *PAFDAPCCONTEXT;
 
+_Must_inspect_result_
 SOCKET
 WSPAPI
 WSPAccept(
-    IN      SOCKET s,
-    OUT     LPSOCKADDR addr,
-    IN OUT  LPINT addrlen,
-    IN      LPCONDITIONPROC lpfnCondition,
-    IN      DWORD dwCallbackData,
-    OUT     LPINT lpErrno);
+    _In_ SOCKET s,
+    _Out_writes_bytes_to_opt_(*addrlen, *addrlen) struct sockaddr FAR * addr,
+    _Inout_opt_ LPINT addrlen,
+    _In_opt_ LPCONDITIONPROC lpfnCondition,
+    _In_opt_ DWORD_PTR dwCallbackData,
+    _Out_ LPINT lpErrno);
 
 INT
 WSPAPI

dll/win32/msgina/shutdown.c

···
     }
 }
 
-static BOOL
+static INT_PTR
 CALLBACK
 ShutdownDialogProc(
     HWND hDlg,

dll/win32/mswsock/mswhelper.c

···
 {
     DWORD lstItemCount;
     DWORD lstByteSize;
-    DWORD lstDataPos;
+    DWORD_PTR lstDataPos;
     DWORD i1;
     UINT_PTR *ptrSrcLstPos;
 
···
 
     /* calculate position for the data of the first item */
     lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
-                 (DWORD)mswBufferEndPtr(mswBuf);
+                 (DWORD_PTR)mswBufferEndPtr(mswBuf);
     /* add ptrofs */
     lstDataPos += ptrofs;
 
···
     DWORD lstItemLen[MAX_ARRAY_SIZE];
     DWORD lstItemCount;
     DWORD lstByteSize;
-    DWORD lstDataPos;
+    DWORD_PTR lstDataPos;
     DWORD lstDataSize;
     DWORD i1;
     UINT_PTR *ptrSrcLstPos;
···
 
     /* calculate position for the data of the first item */
     lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
-                 (DWORD)mswBufferEndPtr(mswBuf);
+                 (DWORD_PTR)mswBufferEndPtr(mswBuf);
 
     /* add ptrofs */
     lstDataPos += ptrofs;
···
     {
         if (!mswBufferAppendStrLstA(mswBuf,
                                     (void**)hostAliasesA,
-                                    -(DWORD)bytesOfs))
+                                    -(LONG_PTR)bytesOfs))
             return FALSE;
     }
     else
···
 
     phe->h_addr_list = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
-    if (!mswBufferAppendLst(mswBuf, lst, 4, -(DWORD)bytesOfs))
+    if (!mswBufferAppendLst(mswBuf, lst, 4, -(LONG_PTR)bytesOfs))
         return FALSE;
 
     /* name */
···
     {
         if (!mswBufferAppendStrLstA(mswBuf,
                                     (void**)serviceAliasesA,
-                                    -(DWORD)bytesOfs))
+                                    -(LONG_PTR)bytesOfs))
             return FALSE;
     }
     else
···
 StrCpyHeapAllocW(_In_opt_ HANDLE hHeap,
                  _In_ WCHAR* wStr)
 {
-    int chLen;
-    int bLen;
+    size_t chLen;
+    size_t bLen;
     WCHAR* resW;
 
     if (wStr == NULL)
···
 StrCpyHeapAllocA(_In_opt_ HANDLE hHeap,
                  _In_ char* aStr)
 {
-    int chLen;
-    int bLen;
+    size_t chLen;
+    size_t bLen;
     char* resA;
 
     if (aStr == NULL)
···
     char** aDstPtr;
     char* aDstNextStr;
     DWORD aStrByteLen[MAX_ARRAY_SIZE];
-    int bLen;
-    int bItmLen;
+    size_t bLen;
+    size_t bItmLen;
     int aCount;
     int i1;
     char** resA;
···
         *aDstPtr = aDstNextStr;
         RtlCopyMemory(*aDstPtr, *aSrcPtr, bItmLen);
 
-        aDstNextStr = (char*)((DWORD)aDstNextStr + (DWORD)bItmLen);
+        aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
         aDstPtr++;
         aSrcPtr++;
     }
···
         RtlCopyMemory(*aDstPtr, aStr, bItmLen);
         HeapFree(hHeap, 0, aStr);
 
-        aDstNextStr = (char*)((DWORD)aDstNextStr + (DWORD)bItmLen);
+        aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
         aDstPtr++;
         wSrcPtr++;
     }

dll/win32/psapi/psapi.c

···
              */
             if (Count < cb / sizeof(DWORD))
             {
-                lpidProcess[Count] = (DWORD)ProcInfo->UniqueProcessId;
+                lpidProcess[Count] = HandleToUlong(ProcInfo->UniqueProcessId);
                 Count++;
             }
 
···
                    DWORD nSize)
 {
     DWORD Len;
-    DWORD OutSize;
+    SIZE_T OutSize;
     NTSTATUS Status;
     struct
     {

dll/win32/shimgvw/shimgvw.c

···
     GUID rawFormat;
     UINT num;
     UINT size;
-    UINT sizeRemain;
+    size_t sizeRemain;
     UINT j;
     WCHAR *c;
 

dll/win32/uxtheme/nonclient.c

···
         SendMessageTimeout(pcontext->hWnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (PDWORD_PTR)&hIcon);
 
     if (!hIcon)
-        hIcon = (HICON)GetClassLong(pcontext->hWnd, GCL_HICONSM);
+        hIcon = (HICON)GetClassLongPtr(pcontext->hWnd, GCLP_HICONSM);
 
     if (!hIcon)
-        hIcon = (HICON)GetClassLong(pcontext->hWnd, GCL_HICON);
+        hIcon = (HICON)GetClassLongPtr(pcontext->hWnd, GCLP_HICON);
 
     // See also win32ss/user/ntuser/nonclient.c!NC_IconForWindow
     if (!hIcon && !(pcontext->wi.dwExStyle & WS_EX_DLGMODALFRAME))

dll/win32/wshtcpip/iflist.c

···
         *idCount = (outBufLenNeeded / sizeof(TDIEntityID));
         *ppEntities = (TDIEntityID*)outBuf;
 
-        DPRINT("TcpFile %lx\n", (DWORD)TcpFile);
+        DPRINT("TcpFile %p\n", TcpFile);
 
         DPRINT("idCount %lx\n", *idCount);// 0x24;
 
···
         goto cleanup;
     }
 
-    DPRINT("TcpFile %lx\n",(DWORD)TcpFile);
+    DPRINT("TcpFile %p\n", TcpFile);
 
     if (!AllocAndGetEntityArray(TcpFile,hHeap,&outEntityID,&outIDCount))
     {

win32ss/gdi/gdi32/include/gdi32p.h

···
 #define UMPDEV_SUPPORT_ESCAPE 0x0004
 typedef struct _UMPDEV
 {
-    DWORD_PTR           Sig;            // Init with PDEV_UMPD_ID
+    DWORD_PTR       Sig;            // Init with PDEV_UMPD_ID
     struct _UMPDEV *pumpdNext;
     PDRIVER_INFO_5W pdi5Info;
     HMODULE         hModule;