system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-07-21 12:34:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

mpr: Use CRT allocation functions.

Browse source
This commit is contained in:
Alex Henrie 2023-08-28 23:53:29 -06:00 committed by Alexandre Julliard
parent d89665847f
commit 61c5d2a0e3
3 changed files with 69 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
dlls/mpr/mpr_main.c
View file

@ -38,7 +38,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(mpr);
*/ */
LPVOID WINAPI MPR_Alloc( DWORD dwSize ) LPVOID WINAPI MPR_Alloc( DWORD dwSize )
{ {
return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize ); return calloc( 1, dwSize );
} }
/***************************************************************** /*****************************************************************
@ -46,10 +46,7 @@ LPVOID WINAPI MPR_Alloc( DWORD dwSize )
*/ */
LPVOID WINAPI MPR_ReAlloc( LPVOID lpSrc, DWORD dwSize ) LPVOID WINAPI MPR_ReAlloc( LPVOID lpSrc, DWORD dwSize )
{ {
if ( lpSrc ) return _recalloc( lpSrc, 1, dwSize );
return HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpSrc, dwSize );
else
return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize );
} }
/***************************************************************** /*****************************************************************
@ -57,10 +54,8 @@ LPVOID WINAPI MPR_ReAlloc( LPVOID lpSrc, DWORD dwSize )
*/ */
BOOL WINAPI MPR_Free( LPVOID lpMem ) BOOL WINAPI MPR_Free( LPVOID lpMem )
{ {
if ( lpMem ) free( lpMem );
return HeapFree( GetProcessHeap(), 0, lpMem ); return !!lpMem;
else
return FALSE;
} }
/***************************************************************** /*****************************************************************

12
dlls/mpr/pwcache.c
View file

@ -55,7 +55,7 @@ static LPSTR MPR_GetValueName( LPCSTR pbResource, WORD cbResource, BYTE nType )
LPSTR name; LPSTR name;
DWORD i; DWORD i;
name = HeapAlloc( GetProcessHeap(), 0, 6+cbResource*2 ); name = malloc( 6 + cbResource * 2 );
if( !name ) return NULL; if( !name ) return NULL;
sprintf( name, "X-%02X-", nType ); sprintf( name, "X-%02X-", nType );
@ -114,7 +114,7 @@ DWORD WINAPI WNetCachePassword(
r = WN_CANCEL; r = WN_CANCEL;
else else
r = WN_SUCCESS; r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname ); free( valname );
} }
else else
r = WN_OUT_OF_MEMORY; r = WN_OUT_OF_MEMORY;
@ -152,7 +152,7 @@ UINT WINAPI WNetRemoveCachedPassword(
r = WN_ACCESS_DENIED; r = WN_ACCESS_DENIED;
else else
r = WN_SUCCESS; r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname ); free( valname );
} }
else else
r = WN_OUT_OF_MEMORY; r = WN_OUT_OF_MEMORY;
@ -209,7 +209,7 @@ DWORD WINAPI WNetGetCachedPassword(
r = WN_CANCEL; r = WN_CANCEL;
else else
r = WN_SUCCESS; r = WN_SUCCESS;
HeapFree( GetProcessHeap(), 0, valname ); free( valname );
} }
else else
r = WN_OUT_OF_MEMORY; r = WN_OUT_OF_MEMORY;
@ -299,7 +299,7 @@ UINT WINAPI WNetEnumCachedPasswords(
/* read the value data */ /* read the value data */
size = offsetof( PASSWORD_CACHE_ENTRY, abResource[val_sz + data_sz] ); size = offsetof( PASSWORD_CACHE_ENTRY, abResource[val_sz + data_sz] );
entry = HeapAlloc( GetProcessHeap(), 0, size ); entry = malloc( size );
memcpy( entry->abResource, val, val_sz ); memcpy( entry->abResource, val, val_sz );
entry->cbEntry = size; entry->cbEntry = size;
entry->cbResource = val_sz; entry->cbResource = val_sz;
@ -311,7 +311,7 @@ UINT WINAPI WNetEnumCachedPasswords(
&entry->abResource[val_sz], &data_sz ); &entry->abResource[val_sz], &data_sz );
if( r == ERROR_SUCCESS ) if( r == ERROR_SUCCESS )
enumPasswordProc( entry, param ); enumPasswordProc( entry, param );
HeapFree( GetProcessHeap(), 0, entry ); free( entry );
} }
RegCloseKey( hkey ); RegCloseKey( hkey );

124
dlls/mpr/wnet.c
View file

@ -154,11 +154,11 @@ static void _tryLoadProvider(PCWSTR provider)
RegQueryValueExW(hKey, L"Name", NULL, NULL, NULL, &size); RegQueryValueExW(hKey, L"Name", NULL, NULL, NULL, &size);
if (size) if (size)
{ {
name = HeapAlloc(GetProcessHeap(), 0, size); name = malloc(size);
if (RegQueryValueExW(hKey, L"Name", NULL, &type, (BYTE *)name, &size) != ERROR_SUCCESS if (RegQueryValueExW(hKey, L"Name", NULL, &type, (BYTE *)name, &size) != ERROR_SUCCESS
|| type != REG_SZ) || type != REG_SZ)
{ {
HeapFree(GetProcessHeap(), 0, name); free(name);
name = NULL; name = NULL;
} }
} }
@ -225,7 +225,7 @@ static void _tryLoadProvider(PCWSTR provider)
{ {
WARN("Provider %s didn't export NPGetCaps\n", WARN("Provider %s didn't export NPGetCaps\n",
debugstr_w(provider)); debugstr_w(provider));
HeapFree(GetProcessHeap(), 0, name); free(name);
FreeLibrary(hLib); FreeLibrary(hLib);
} }
@ -235,7 +235,7 @@ static void _tryLoadProvider(PCWSTR provider)
{ {
WARN("Couldn't load library %s for provider %s\n", WARN("Couldn't load library %s for provider %s\n",
debugstr_w(providerPath), debugstr_w(provider)); debugstr_w(providerPath), debugstr_w(provider));
HeapFree(GetProcessHeap(), 0, name); free(name);
} }
} }
else else
@ -265,7 +265,7 @@ void wnetInit(HINSTANCE hInstDll)
RegQueryValueExW(hKey, L"ProviderOrder", NULL, NULL, NULL, &size); RegQueryValueExW(hKey, L"ProviderOrder", NULL, NULL, NULL, &size);
if (size) if (size)
{ {
PWSTR providers = HeapAlloc(GetProcessHeap(), 0, size); WCHAR *providers = malloc(size);
if (providers) if (providers)
{ {
@ -289,8 +289,7 @@ void wnetInit(HINSTANCE hInstDll)
} }
} }
providerTable = providerTable =
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, calloc(1, sizeof(WNetProviderTable)
sizeof(WNetProviderTable)
+ (numToAllocate - 1) * sizeof(WNetProvider)); + (numToAllocate - 1) * sizeof(WNetProvider));
if (providerTable) if (providerTable)
{ {
@ -300,9 +299,8 @@ void wnetInit(HINSTANCE hInstDll)
entireNetworkLen = LoadStringW(hInstDll, entireNetworkLen = LoadStringW(hInstDll,
IDS_ENTIRENETWORK, (LPWSTR)&stringresource, 0); IDS_ENTIRENETWORK, (LPWSTR)&stringresource, 0);
providerTable->entireNetwork = HeapAlloc( providerTable->entireNetwork = malloc(
GetProcessHeap(), 0, (entireNetworkLen + 1) * (entireNetworkLen + 1) * sizeof(WCHAR));
sizeof(WCHAR));
if (providerTable->entireNetwork) if (providerTable->entireNetwork)
{ {
memcpy(providerTable->entireNetwork, stringresource, entireNetworkLen*sizeof(WCHAR)); memcpy(providerTable->entireNetwork, stringresource, entireNetworkLen*sizeof(WCHAR));
@ -319,7 +317,7 @@ void wnetInit(HINSTANCE hInstDll)
} }
} }
} }
HeapFree(GetProcessHeap(), 0, providers); free(providers);
} }
} }
RegCloseKey(hKey); RegCloseKey(hKey);
@ -334,11 +332,11 @@ void wnetFree(void)
for (i = 0; i < providerTable->numProviders; i++) for (i = 0; i < providerTable->numProviders; i++)
{ {
HeapFree(GetProcessHeap(), 0, providerTable->table[i].name); free(providerTable->table[i].name);
FreeModule(providerTable->table[i].hLib); FreeModule(providerTable->table[i].hLib);
} }
HeapFree(GetProcessHeap(), 0, providerTable->entireNetwork); free(providerTable->entireNetwork);
HeapFree(GetProcessHeap(), 0, providerTable); free(providerTable);
providerTable = NULL; providerTable = NULL;
} }
} }
@ -369,7 +367,7 @@ static LPNETRESOURCEW _copyNetResourceForEnumW(LPNETRESOURCEW lpNet)
if (lpNet) if (lpNet)
{ {
ret = HeapAlloc(GetProcessHeap(), 0, sizeof(NETRESOURCEW)); ret = malloc(sizeof(NETRESOURCEW));
if (ret) if (ret)
{ {
size_t len; size_t len;
@ -379,7 +377,7 @@ static LPNETRESOURCEW _copyNetResourceForEnumW(LPNETRESOURCEW lpNet)
if (lpNet->lpRemoteName) if (lpNet->lpRemoteName)
{ {
len = lstrlenW(lpNet->lpRemoteName) + 1; len = lstrlenW(lpNet->lpRemoteName) + 1;
ret->lpRemoteName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); ret->lpRemoteName = malloc(len * sizeof(WCHAR));
if (ret->lpRemoteName) if (ret->lpRemoteName)
lstrcpyW(ret->lpRemoteName, lpNet->lpRemoteName); lstrcpyW(ret->lpRemoteName, lpNet->lpRemoteName);
} }
@ -394,16 +392,15 @@ static void _freeEnumNetResource(LPNETRESOURCEW lpNet)
{ {
if (lpNet) if (lpNet)
{ {
HeapFree(GetProcessHeap(), 0, lpNet->lpRemoteName); free(lpNet->lpRemoteName);
HeapFree(GetProcessHeap(), 0, lpNet); free(lpNet);
} }
} }
static PWNetEnumerator _createGlobalEnumeratorW(DWORD dwScope, DWORD dwType, static PWNetEnumerator _createGlobalEnumeratorW(DWORD dwScope, DWORD dwType,
DWORD dwUsage, LPNETRESOURCEW lpNet) DWORD dwUsage, LPNETRESOURCEW lpNet)
{ {
PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), WNetEnumerator *ret = calloc(1, sizeof(WNetEnumerator));
HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
if (ret) if (ret)
{ {
@ -425,7 +422,7 @@ static PWNetEnumerator _createProviderEnumerator(DWORD dwScope, DWORD dwType,
ret = NULL; ret = NULL;
else else
{ {
ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator)); ret = calloc(1, sizeof(WNetEnumerator));
if (ret) if (ret)
{ {
ret->enumType = WNET_ENUMERATOR_TYPE_PROVIDER; ret->enumType = WNET_ENUMERATOR_TYPE_PROVIDER;
@ -442,8 +439,7 @@ static PWNetEnumerator _createProviderEnumerator(DWORD dwScope, DWORD dwType,
static PWNetEnumerator _createContextEnumerator(DWORD dwScope, DWORD dwType, static PWNetEnumerator _createContextEnumerator(DWORD dwScope, DWORD dwType,
DWORD dwUsage) DWORD dwUsage)
{ {
PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), WNetEnumerator *ret = calloc(1, sizeof(WNetEnumerator));
HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
if (ret) if (ret)
{ {
@ -458,17 +454,17 @@ static PWNetEnumerator _createContextEnumerator(DWORD dwScope, DWORD dwType,
static PWNetEnumerator _createConnectedEnumerator(DWORD dwScope, DWORD dwType, static PWNetEnumerator _createConnectedEnumerator(DWORD dwScope, DWORD dwType,
DWORD dwUsage) DWORD dwUsage)
{ {
PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator)); WNetEnumerator *ret = calloc(1, sizeof(WNetEnumerator));
if (ret) if (ret)
{ {
ret->enumType = WNET_ENUMERATOR_TYPE_CONNECTED; ret->enumType = WNET_ENUMERATOR_TYPE_CONNECTED;
ret->dwScope = dwScope; ret->dwScope = dwScope;
ret->dwType = dwType; ret->dwType = dwType;
ret->dwUsage = dwUsage; ret->dwUsage = dwUsage;
ret->specific.handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HANDLE) * providerTable->numProviders); ret->specific.handles = calloc(providerTable->numProviders, sizeof(HANDLE));
if (!ret->specific.handles) if (!ret->specific.handles)
{ {
HeapFree(GetProcessHeap(), 0, ret); free(ret);
ret = NULL; ret = NULL;
} }
} }
@ -478,7 +474,7 @@ static PWNetEnumerator _createConnectedEnumerator(DWORD dwScope, DWORD dwType,
static PWNetEnumerator _createRememberedEnumerator(DWORD dwScope, DWORD dwType, static PWNetEnumerator _createRememberedEnumerator(DWORD dwScope, DWORD dwType,
HKEY remembered) HKEY remembered)
{ {
PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator)); WNetEnumerator *ret = calloc(1, sizeof(WNetEnumerator));
if (ret) if (ret)
{ {
ret->enumType = WNET_ENUMERATOR_TYPE_REMEMBERED; ret->enumType = WNET_ENUMERATOR_TYPE_REMEMBERED;
@ -691,8 +687,7 @@ DWORD WINAPI WNetOpenEnumA( DWORD dwScope, DWORD dwType, DWORD dwUsage,
ret = _thunkNetResourceArrayAToW(lpNet, &count, buf, &size); ret = _thunkNetResourceArrayAToW(lpNet, &count, buf, &size);
if (ret == WN_MORE_DATA) if (ret == WN_MORE_DATA)
{ {
lpNetWide = HeapAlloc(GetProcessHeap(), 0, lpNetWide = malloc(size);
size);
if (lpNetWide) if (lpNetWide)
{ {
ret = _thunkNetResourceArrayAToW(lpNet, &count, lpNetWide, ret = _thunkNetResourceArrayAToW(lpNet, &count, lpNetWide,
@ -708,7 +703,7 @@ DWORD WINAPI WNetOpenEnumA( DWORD dwScope, DWORD dwType, DWORD dwUsage,
ret = WNetOpenEnumW(dwScope, dwType, dwUsage, lpNetWide, ret = WNetOpenEnumW(dwScope, dwType, dwUsage, lpNetWide,
lphEnum); lphEnum);
if (allocated) if (allocated)
HeapFree(GetProcessHeap(), 0, lpNetWide); free(lpNetWide);
} }
else else
ret = WNetOpenEnumW(dwScope, dwType, dwUsage, NULL, lphEnum); ret = WNetOpenEnumW(dwScope, dwType, dwUsage, NULL, lphEnum);
@ -909,7 +904,7 @@ DWORD WINAPI WNetEnumResourceA( HANDLE hEnum, LPDWORD lpcCount,
else else
{ {
DWORD localCount = *lpcCount, localSize = *lpBufferSize; DWORD localCount = *lpcCount, localSize = *lpBufferSize;
LPVOID localBuffer = HeapAlloc(GetProcessHeap(), 0, localSize); void *localBuffer = malloc(localSize);
if (localBuffer) if (localBuffer)
{ {
@ -927,7 +922,7 @@ DWORD WINAPI WNetEnumResourceA( HANDLE hEnum, LPDWORD lpcCount,
lpBuffer, lpBufferSize); lpBuffer, lpBufferSize);
*lpcCount = localCount; *lpcCount = localCount;
} }
HeapFree(GetProcessHeap(), 0, localBuffer); free(localBuffer);
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;
@ -1292,7 +1287,7 @@ static DWORD _enumerateConnectedW(PWNetEnumerator enumerator, DWORD* user_count,
handles = enumerator->specific.handles; handles = enumerator->specific.handles;
left = *user_size; left = *user_size;
size = *user_size; size = *user_size;
buffer = HeapAlloc(GetProcessHeap(), 0, *user_size); buffer = malloc(*user_size);
if (!buffer) if (!buffer)
return WN_NO_NETWORK; return WN_NO_NETWORK;
@ -1371,7 +1366,7 @@ static DWORD _enumerateConnectedW(PWNetEnumerator enumerator, DWORD* user_count,
if (ret != WN_MORE_DATA && ret != WN_NO_MORE_ENTRIES) if (ret != WN_MORE_DATA && ret != WN_NO_MORE_ENTRIES)
ret = WN_SUCCESS; ret = WN_SUCCESS;
HeapFree(GetProcessHeap(), 0, buffer); free(buffer);
TRACE("Returning %ld\n", ret); TRACE("Returning %ld\n", ret);
return ret; return ret;
@ -1384,7 +1379,7 @@ static WCHAR *get_reg_str(HKEY hkey, const WCHAR *value, DWORD *len)
if (!RegQueryValueExW(hkey, value, NULL, &type, NULL, len) && type == REG_SZ) if (!RegQueryValueExW(hkey, value, NULL, &type, NULL, len) && type == REG_SZ)
{ {
if (!(ret = HeapAlloc(GetProcessHeap(), 0, *len))) return NULL; if (!(ret = malloc(*len))) return NULL;
RegQueryValueExW(hkey, value, 0, 0, (BYTE *)ret, len); RegQueryValueExW(hkey, value, 0, 0, (BYTE *)ret, len);
} }
@ -1482,7 +1477,7 @@ static DWORD _enumeratorRememberedW(PWNetEnumerator enumerator, DWORD* user_coun
else else
ret = WN_MORE_DATA; ret = WN_MORE_DATA;
HeapFree(GetProcessHeap(), 0, registry_string); free(registry_string);
} }
registry_size = 0; registry_size = 0;
@ -1501,7 +1496,7 @@ static DWORD _enumeratorRememberedW(PWNetEnumerator enumerator, DWORD* user_coun
else else
ret = WN_MORE_DATA; ret = WN_MORE_DATA;
HeapFree(GetProcessHeap(), 0, registry_string); free(registry_string);
} }
RegCloseKey(connection); RegCloseKey(connection);
@ -1626,7 +1621,7 @@ DWORD WINAPI WNetCloseEnum( HANDLE hEnum )
if (providerTable->table[index].dwEnumScopes && handles[index]) if (providerTable->table[index].dwEnumScopes && handles[index])
providerTable->table[index].closeEnum(handles[index]); providerTable->table[index].closeEnum(handles[index]);
} }
HeapFree(GetProcessHeap(), 0, handles); free(handles);
ret = WN_SUCCESS; ret = WN_SUCCESS;
break; break;
case WNET_ENUMERATOR_TYPE_REMEMBERED: case WNET_ENUMERATOR_TYPE_REMEMBERED:
@ -1637,7 +1632,7 @@ DWORD WINAPI WNetCloseEnum( HANDLE hEnum )
WARN("bogus enumerator type!\n"); WARN("bogus enumerator type!\n");
ret = WN_BAD_HANDLE; ret = WN_BAD_HANDLE;
} }
HeapFree(GetProcessHeap(), 0, hEnum); free(hEnum);
} }
else else
ret = WN_BAD_HANDLE; ret = WN_BAD_HANDLE;
@ -1669,12 +1664,12 @@ DWORD WINAPI WNetGetResourceInformationA( LPNETRESOURCEA lpNetResource,
DWORD size = 1024, count = 1; DWORD size = 1024, count = 1;
DWORD len; DWORD len;
lpNetResourceW = HeapAlloc(GetProcessHeap(), 0, size); lpNetResourceW = malloc(size);
ret = _thunkNetResourceArrayAToW(lpNetResource, &count, lpNetResourceW, &size); ret = _thunkNetResourceArrayAToW(lpNetResource, &count, lpNetResourceW, &size);
if (ret == WN_MORE_DATA) if (ret == WN_MORE_DATA)
{ {
HeapFree(GetProcessHeap(), 0, lpNetResourceW); free(lpNetResourceW);
lpNetResourceW = HeapAlloc(GetProcessHeap(), 0, size); lpNetResourceW = malloc(size);
if (lpNetResourceW) if (lpNetResourceW)
ret = _thunkNetResourceArrayAToW(lpNetResource, ret = _thunkNetResourceArrayAToW(lpNetResource,
&count, lpNetResourceW, &size); &count, lpNetResourceW, &size);
@ -1686,15 +1681,15 @@ DWORD WINAPI WNetGetResourceInformationA( LPNETRESOURCEA lpNetResource,
LPWSTR lpSystemW = NULL; LPWSTR lpSystemW = NULL;
NETRESOURCEW *lpBufferW; NETRESOURCEW *lpBufferW;
size = 1024; size = 1024;
lpBufferW = HeapAlloc(GetProcessHeap(), 0, size); lpBufferW = malloc(size);
if (lpBufferW) if (lpBufferW)
{ {
ret = WNetGetResourceInformationW(lpNetResourceW, ret = WNetGetResourceInformationW(lpNetResourceW,
lpBufferW, &size, &lpSystemW); lpBufferW, &size, &lpSystemW);
if (ret == WN_MORE_DATA) if (ret == WN_MORE_DATA)
{ {
HeapFree(GetProcessHeap(), 0, lpBufferW); free(lpBufferW);
lpBufferW = HeapAlloc(GetProcessHeap(), 0, size); lpBufferW = malloc(size);
if (lpBufferW) if (lpBufferW)
ret = WNetGetResourceInformationW(lpNetResourceW, ret = WNetGetResourceInformationW(lpNetResourceW,
lpBufferW, &size, &lpSystemW); lpBufferW, &size, &lpSystemW);
@ -1725,13 +1720,13 @@ DWORD WINAPI WNetGetResourceInformationA( LPNETRESOURCEA lpNetResource,
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;
HeapFree(GetProcessHeap(), 0, lpBufferW); free(lpBufferW);
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;
HeapFree(GetProcessHeap(), 0, lpSystemW); free(lpSystemW);
} }
HeapFree(GetProcessHeap(), 0, lpNetResourceW); free(lpNetResourceW);
} }
else else
ret = WN_NO_NETWORK; ret = WN_NO_NETWORK;
@ -2149,7 +2144,7 @@ static LPWSTR strdupAtoW( LPCSTR str )
if (!str) return NULL; if (!str) return NULL;
len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); ret = malloc( len * sizeof(WCHAR) );
if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len ); if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
return ret; return ret;
} }
@ -2168,10 +2163,10 @@ static void netresource_a_to_w( NETRESOURCEA *resourceA, NETRESOURCEW *resourceW
static void free_netresourceW( NETRESOURCEW *resource ) static void free_netresourceW( NETRESOURCEW *resource )
{ {
HeapFree(GetProcessHeap(), 0, resource->lpLocalName); free(resource->lpLocalName);
HeapFree(GetProcessHeap(), 0, resource->lpRemoteName); free(resource->lpRemoteName);
HeapFree(GetProcessHeap(), 0, resource->lpComment); free(resource->lpComment);
HeapFree(GetProcessHeap(), 0, resource->lpProvider); free(resource->lpProvider);
} }
/***************************************************************** /*****************************************************************
@ -2205,8 +2200,8 @@ DWORD WINAPI WNetUseConnectionA( HWND hwndOwner, NETRESOURCEA *resource,
ret = wnet_use_connection(&ctxt); ret = wnet_use_connection(&ctxt);
free_netresourceW(&resourceW); free_netresourceW(&resourceW);
HeapFree(GetProcessHeap(), 0, ctxt.password); free(ctxt.password);
HeapFree(GetProcessHeap(), 0, ctxt.userid); free(ctxt.userid);
return ret; return ret;
} }
@ -2238,7 +2233,7 @@ DWORD WINAPI WNetCancelConnection2A( LPCSTR lpName, DWORD dwFlags, BOOL fForce )
return ERROR_NOT_CONNECTED; return ERROR_NOT_CONNECTED;
ret = WNetCancelConnection2W(name, dwFlags, fForce); ret = WNetCancelConnection2W(name, dwFlags, fForce);
HeapFree(GetProcessHeap(), 0, name); free(name);
return ret; return ret;
} }
@ -2337,7 +2332,7 @@ DWORD WINAPI WNetGetConnectionA( LPCSTR lpLocalName,
if (len) if (len)
{ {
PWSTR wideLocalName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); WCHAR *wideLocalName = malloc(len * sizeof(WCHAR));
if (wideLocalName) if (wideLocalName)
{ {
@ -2368,8 +2363,7 @@ DWORD WINAPI WNetGetConnectionA( LPCSTR lpLocalName,
} }
else if (ret == WN_MORE_DATA) else if (ret == WN_MORE_DATA)
{ {
PWSTR wideRemote = HeapAlloc(GetProcessHeap(), 0, WCHAR *wideRemote = malloc(wideRemoteSize * sizeof(WCHAR));
wideRemoteSize * sizeof(WCHAR));
if (wideRemote) if (wideRemote)
{ {
@ -2389,12 +2383,12 @@ DWORD WINAPI WNetGetConnectionA( LPCSTR lpLocalName,
ret = WN_MORE_DATA; ret = WN_MORE_DATA;
} }
} }
HeapFree(GetProcessHeap(), 0, wideRemote); free(wideRemote);
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;
} }
HeapFree(GetProcessHeap(), 0, wideLocalName); free(wideLocalName);
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;
@ -2646,7 +2640,7 @@ DWORD WINAPI WNetClearConnections ( HWND owner )
} }
size = 0x1000; size = 0x1000;
resources = HeapAlloc(GetProcessHeap(), 0, size); resources = malloc(size);
if (!resources) if (!resources)
{ {
WNetCloseEnum(connected); WNetCloseEnum(connected);
@ -2676,7 +2670,7 @@ DWORD WINAPI WNetClearConnections ( HWND owner )
break; break;
} }
HeapFree(GetProcessHeap(), 0, resources); free(resources);
WNetCloseEnum(connected); WNetCloseEnum(connected);
return ret; return ret;
@ -2830,14 +2824,14 @@ DWORD WINAPI WNetGetNetworkInformationA( LPCSTR lpProvider,
len = MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, NULL, 0); len = MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, NULL, 0);
if (len) if (len)
{ {
LPWSTR wideProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); WCHAR *wideProvider = malloc(len * sizeof(WCHAR));
if (wideProvider) if (wideProvider)
{ {
MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, wideProvider, MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, wideProvider,
len); len);
ret = WNetGetNetworkInformationW(wideProvider, lpNetInfoStruct); ret = WNetGetNetworkInformationW(wideProvider, lpNetInfoStruct);
HeapFree(GetProcessHeap(), 0, wideProvider); free(wideProvider);
} }
else else
ret = WN_OUT_OF_MEMORY; ret = WN_OUT_OF_MEMORY;