ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added memory allocation inline functions (part 2).

This commit is contained in:
Mike McCormack 2005-09-20 11:59:14 +00:00 committed by Alexandre Julliard
parent 8dc28d5306
commit ee034ba4c2
14 changed files with 526 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
dlls/msi/action.c
View File

@ -399,7 +399,7 @@ static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row); MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start, static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
@ -448,7 +448,7 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
MSI_SetPropertyW(package, szAction, szInstall); MSI_SetPropertyW(package, szAction, szInstall);
package->script = HeapAlloc(GetProcessHeap(),0,sizeof(MSISCRIPT)); package->script = msi_alloc(sizeof(MSISCRIPT));
memset(package->script,0,sizeof(MSISCRIPT)); memset(package->script,0,sizeof(MSISCRIPT));
package->script->InWhatSequence = SEQUENCE_INSTALL; package->script->InWhatSequence = SEQUENCE_INSTALL;
@ -469,8 +469,8 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
} }
else else
{ {
HeapFree(GetProcessHeap(),0,path); msi_free(path);
path = HeapAlloc(GetProcessHeap(),0,MAX_PATH*sizeof(WCHAR)); path = msi_alloc(MAX_PATH*sizeof(WCHAR));
GetCurrentDirectoryW(MAX_PATH,path); GetCurrentDirectoryW(MAX_PATH,path);
strcatW(path,cszbs); strcatW(path,cszbs);
} }
@ -478,8 +478,8 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
check = msi_dup_property( package, cszSourceDir ); check = msi_dup_property( package, cszSourceDir );
if (!check) if (!check)
MSI_SetPropertyW(package, cszSourceDir, path); MSI_SetPropertyW(package, cszSourceDir, path);
HeapFree(GetProcessHeap(), 0, check); msi_free(check);
HeapFree(GetProcessHeap(), 0, path); msi_free(path);
} }
if (szCommandLine) if (szCommandLine)
@ -502,7 +502,7 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
while (*ptr == ' ') ptr++; while (*ptr == ' ') ptr++;
len = ptr2-ptr; len = ptr2-ptr;
prop = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR)); prop = msi_alloc((len+1)*sizeof(WCHAR));
memcpy(prop,ptr,len*sizeof(WCHAR)); memcpy(prop,ptr,len*sizeof(WCHAR));
prop[len]=0; prop[len]=0;
ptr2++; ptr2++;
@ -522,7 +522,7 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
ptr2++; ptr2++;
len -= 2; len -= 2;
} }
val = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR)); val = msi_alloc((len+1)*sizeof(WCHAR));
memcpy(val,ptr2,len*sizeof(WCHAR)); memcpy(val,ptr2,len*sizeof(WCHAR));
val[len] = 0; val[len] = 0;
@ -532,8 +532,8 @@ UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
debugstr_w(prop), debugstr_w(val)); debugstr_w(prop), debugstr_w(val));
MSI_SetPropertyW(package,prop,val); MSI_SetPropertyW(package,prop,val);
} }
HeapFree(GetProcessHeap(),0,val); msi_free(val);
HeapFree(GetProcessHeap(),0,prop); msi_free(prop);
} }
ptr++; ptr++;
} }
@ -937,7 +937,7 @@ static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
folder->State = 3; folder->State = 3;
HeapFree(GetProcessHeap(),0,full_path); msi_free(full_path);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -970,7 +970,7 @@ static MSICOMPONENT* load_component( MSIRECORD * row )
{ {
MSICOMPONENT *comp; MSICOMPONENT *comp;
comp = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSICOMPONENT) ); comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
if (!comp) if (!comp)
return comp; return comp;
@ -1003,7 +1003,7 @@ static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
{ {
ComponentList *cl; ComponentList *cl;
cl = HeapAlloc( GetProcessHeap(), 0, sizeof (*cl) ); cl = msi_alloc( sizeof (*cl) );
if ( !cl ) if ( !cl )
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
cl->component = comp; cl->component = comp;
@ -1083,7 +1083,7 @@ static UINT load_feature(MSIRECORD * row, LPVOID param)
/* fill in the data */ /* fill in the data */
feature = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (MSIFEATURE) ); feature = msi_alloc_zero( sizeof (MSIFEATURE) );
if (!feature) if (!feature)
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
@ -1133,7 +1133,7 @@ static UINT load_file(MSIRECORD *row, LPVOID param)
/* fill in the data */ /* fill in the data */
file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (MSIFILE) ); file = msi_alloc_zero( sizeof (MSIFILE) );
if (!file) if (!file)
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
@ -1248,11 +1248,11 @@ static UINT execute_script(MSIPACKAGE *package, UINT script )
ui_actionstart(package, action); ui_actionstart(package, action);
TRACE("Executing Action (%s)\n",debugstr_w(action)); TRACE("Executing Action (%s)\n",debugstr_w(action));
rc = ACTION_PerformAction(package, action, TRUE); rc = ACTION_PerformAction(package, action, TRUE);
HeapFree(GetProcessHeap(),0,package->script->Actions[script][i]); msi_free(package->script->Actions[script][i]);
if (rc != ERROR_SUCCESS) if (rc != ERROR_SUCCESS)
break; break;
} }
HeapFree(GetProcessHeap(),0,package->script->Actions[script]); msi_free(package->script->Actions[script]);
package->script->ActionCount[script] = 0; package->script->ActionCount[script] = 0;
package->script->Actions[script] = NULL; package->script->Actions[script] = NULL;
@ -1287,7 +1287,7 @@ static MSIFOLDER *load_folder( MSIPACKAGE *package, LPCWSTR dir )
TRACE("Working to load %s\n",debugstr_w(dir)); TRACE("Working to load %s\n",debugstr_w(dir));
folder = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (MSIFOLDER) ); folder = msi_alloc_zero( sizeof (MSIFOLDER) );
if (!folder) if (!folder)
return NULL; return NULL;
@ -1331,7 +1331,7 @@ static MSIFOLDER *load_folder( MSIPACKAGE *package, LPCWSTR dir )
if (targetdir) if (targetdir)
{ {
TRACE(" TargetDefault = %s\n",debugstr_w(targetdir)); TRACE(" TargetDefault = %s\n",debugstr_w(targetdir));
HeapFree(GetProcessHeap(),0, folder->TargetDefault); msi_free( folder->TargetDefault);
folder->TargetDefault = strdupW(targetdir); folder->TargetDefault = strdupW(targetdir);
} }
@ -1341,7 +1341,7 @@ static MSIFOLDER *load_folder( MSIPACKAGE *package, LPCWSTR dir )
folder->SourceDefault = strdupW(shortname); folder->SourceDefault = strdupW(shortname);
else if (targetdir) else if (targetdir)
folder->SourceDefault = strdupW(targetdir); folder->SourceDefault = strdupW(targetdir);
HeapFree(GetProcessHeap(), 0, ptargetdir); msi_free(ptargetdir);
TRACE(" SourceDefault = %s\n", debugstr_w( folder->SourceDefault )); TRACE(" SourceDefault = %s\n", debugstr_w( folder->SourceDefault ));
parent = MSI_RecordGetString(row,2); parent = MSI_RecordGetString(row,2);
@ -1448,7 +1448,7 @@ static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
} }
} }
} }
HeapFree(GetProcessHeap(),0,override); msi_free(override);
return TRUE; return TRUE;
} }
@ -1476,7 +1476,7 @@ static UINT SetFeatureStates(MSIPACKAGE *package)
if (level) if (level)
{ {
install_level = atoiW(level); install_level = atoiW(level);
HeapFree(GetProcessHeap(), 0, level); msi_free(level);
} }
else else
install_level = 1; install_level = 1;
@ -1627,7 +1627,7 @@ static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
load_folder(package,name); load_folder(package,name);
path = resolve_folder(package,name,FALSE,TRUE,NULL); path = resolve_folder(package,name,FALSE,TRUE,NULL);
TRACE("resolves to %s\n",debugstr_w(path)); TRACE("resolves to %s\n",debugstr_w(path));
HeapFree( GetProcessHeap(), 0, path); msi_free(path);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -1713,14 +1713,14 @@ static UINT ACTION_CostFinalize(MSIPACKAGE *package)
/* calculate target */ /* calculate target */
p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL); p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
HeapFree(GetProcessHeap(),0,file->TargetPath); msi_free(file->TargetPath);
TRACE("file %s is named %s\n", TRACE("file %s is named %s\n",
debugstr_w(file->File),debugstr_w(file->FileName)); debugstr_w(file->File),debugstr_w(file->FileName));
file->TargetPath = build_directory_name(2, p, file->FileName); file->TargetPath = build_directory_name(2, p, file->FileName);
HeapFree(GetProcessHeap(),0,p); msi_free(p);
TRACE("file %s resolves to %s\n", TRACE("file %s resolves to %s\n",
debugstr_w(file->File),debugstr_w(file->TargetPath)); debugstr_w(file->File),debugstr_w(file->TargetPath));
@ -1747,7 +1747,7 @@ static UINT ACTION_CostFinalize(MSIPACKAGE *package)
TRACE("Version comparison.. \n"); TRACE("Version comparison.. \n");
versize = GetFileVersionInfoSizeW(file->TargetPath,&handle); versize = GetFileVersionInfoSizeW(file->TargetPath,&handle);
version = HeapAlloc(GetProcessHeap(),0,versize); version = msi_alloc(versize);
GetFileVersionInfoW(file->TargetPath, 0, versize, version); GetFileVersionInfoW(file->TargetPath, 0, versize, version);
VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz); VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz);
@ -1768,7 +1768,7 @@ static UINT ACTION_CostFinalize(MSIPACKAGE *package)
} }
else else
file->State = 3; file->State = 3;
HeapFree(GetProcessHeap(),0,version); msi_free(version);
} }
else else
file->State = 3; file->State = 3;
@ -1803,7 +1803,7 @@ static UINT ACTION_CostFinalize(MSIPACKAGE *package)
level = msi_dup_property( package, szlevel ); level = msi_dup_property( package, szlevel );
if (!level) if (!level)
MSI_SetPropertyW(package,szlevel, szOne); MSI_SetPropertyW(package,szlevel, szOne);
HeapFree(GetProcessHeap(),0,level); msi_free(level);
ACTION_UpdateInstallStates(package); ACTION_UpdateInstallStates(package);
@ -1835,7 +1835,7 @@ static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
else else
*size = strlenW(ptr)/2; *size = strlenW(ptr)/2;
data = HeapAlloc(GetProcessHeap(),0,*size); data = msi_alloc(*size);
byte[0] = '0'; byte[0] = '0';
byte[1] = 'x'; byte[1] = 'x';
@ -1860,7 +1860,7 @@ static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
data[count] = (BYTE)strtol(byte,NULL,0); data[count] = (BYTE)strtol(byte,NULL,0);
count ++; count ++;
} }
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
TRACE("Data %li bytes(%i)\n",*size,count); TRACE("Data %li bytes(%i)\n",*size,count);
} }
@ -1873,7 +1873,7 @@ static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
*type=REG_DWORD; *type=REG_DWORD;
*size = sizeof(DWORD); *size = sizeof(DWORD);
data = HeapAlloc(GetProcessHeap(),0,*size); data = msi_alloc(*size);
p = deformated; p = deformated;
if (*p == '-') if (*p == '-')
p++; p++;
@ -1890,7 +1890,7 @@ static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
*(LPDWORD)data = d; *(LPDWORD)data = d;
TRACE("DWORD %li\n",*(LPDWORD)data); TRACE("DWORD %li\n",*(LPDWORD)data);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
} }
else else
@ -2003,7 +2003,7 @@ static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
root_key = HKEY_CURRENT_USER; root_key = HKEY_CURRENT_USER;
szRoot = szHCU; szRoot = szHCU;
} }
HeapFree(GetProcessHeap(),0,all_users); msi_free(all_users);
} }
break; break;
case 0: root_key = HKEY_CLASSES_ROOT; case 0: root_key = HKEY_CLASSES_ROOT;
@ -2029,18 +2029,18 @@ static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
deformat_string(package, key , &deformated); deformat_string(package, key , &deformated);
size = strlenW(deformated) + strlenW(szRoot) + 1; size = strlenW(deformated) + strlenW(szRoot) + 1;
uikey = HeapAlloc(GetProcessHeap(), 0, size*sizeof(WCHAR)); uikey = msi_alloc(size*sizeof(WCHAR));
strcpyW(uikey,szRoot); strcpyW(uikey,szRoot);
strcatW(uikey,deformated); strcatW(uikey,deformated);
if (RegCreateKeyW( root_key, deformated, &hkey)) if (RegCreateKeyW( root_key, deformated, &hkey))
{ {
ERR("Could not create key %s\n",debugstr_w(deformated)); ERR("Could not create key %s\n",debugstr_w(deformated));
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
HeapFree(GetProcessHeap(),0,uikey); msi_free(uikey);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
value = MSI_RecordGetString(row,5); value = MSI_RecordGetString(row,5);
if (value) if (value)
@ -2096,9 +2096,9 @@ static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
ui_actiondata(package,szWriteRegistryValues,uirow); ui_actiondata(package,szWriteRegistryValues,uirow);
msiobj_release( &uirow->hdr ); msiobj_release( &uirow->hdr );
HeapFree(GetProcessHeap(),0,value_data); msi_free(value_data);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
HeapFree(GetProcessHeap(),0,uikey); msi_free(uikey);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -2214,7 +2214,7 @@ static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
message = MSI_RecordGetString(row,2); message = MSI_RecordGetString(row,2);
deformat_string(package,message,&deformated); deformat_string(package,message,&deformated);
MessageBoxW(NULL,deformated,title,MB_OK); MessageBoxW(NULL,deformated,title,MB_OK);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }
@ -2276,15 +2276,15 @@ static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
if (deformated_name) if (deformated_name)
len+=strlenW(deformated_name); len+=strlenW(deformated_name);
buffer = HeapAlloc(GetProcessHeap(),0, len *sizeof(WCHAR)); buffer = msi_alloc( len *sizeof(WCHAR));
if (deformated_name) if (deformated_name)
sprintfW(buffer,fmt2,root,deformated,deformated_name); sprintfW(buffer,fmt2,root,deformated,deformated_name);
else else
sprintfW(buffer,fmt,root,deformated); sprintfW(buffer,fmt,root,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
HeapFree(GetProcessHeap(),0,deformated_name); msi_free(deformated_name);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
return buffer; return buffer;
@ -2567,7 +2567,7 @@ static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
tl_struct->path = strdupW(tl_struct->source); tl_struct->path = strdupW(tl_struct->source);
else else
{ {
tl_struct->path = HeapAlloc(GetProcessHeap(),0,sz); tl_struct->path = msi_alloc(sz);
sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName); sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
} }
@ -2575,7 +2575,7 @@ static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib); res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
if (!SUCCEEDED(res)) if (!SUCCEEDED(res))
{ {
HeapFree(GetProcessHeap(),0,tl_struct->path); msi_free(tl_struct->path);
tl_struct->path = NULL; tl_struct->path = NULL;
return TRUE; return TRUE;
@ -2588,7 +2588,7 @@ static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
return FALSE; return FALSE;
} }
HeapFree(GetProcessHeap(),0,tl_struct->path); msi_free(tl_struct->path);
tl_struct->path = NULL; tl_struct->path = NULL;
ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr); ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
@ -2633,7 +2633,7 @@ static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
LPWSTR guid; LPWSTR guid;
guid = load_dynamic_stringW(row,1); guid = load_dynamic_stringW(row,1);
CLSIDFromString(guid, &tl_struct.clsid); CLSIDFromString(guid, &tl_struct.clsid);
HeapFree(GetProcessHeap(),0,guid); msi_free(guid);
tl_struct.source = strdupW( file->TargetPath ); tl_struct.source = strdupW( file->TargetPath );
tl_struct.path = NULL; tl_struct.path = NULL;
@ -2651,7 +2651,7 @@ static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
if (helpid) if (helpid)
help = resolve_folder(package,helpid,FALSE,FALSE,NULL); help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help); res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
HeapFree(GetProcessHeap(),0,help); msi_free(help);
if (!SUCCEEDED(res)) if (!SUCCEEDED(res))
ERR("Failed to register type library %s\n", ERR("Failed to register type library %s\n",
@ -2664,14 +2664,14 @@ static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
} }
ITypeLib_Release(tl_struct.ptLib); ITypeLib_Release(tl_struct.ptLib);
HeapFree(GetProcessHeap(),0,tl_struct.path); msi_free(tl_struct.path);
} }
else else
ERR("Failed to load type library %s\n", ERR("Failed to load type library %s\n",
debugstr_w(tl_struct.source)); debugstr_w(tl_struct.source));
FreeLibrary(module); FreeLibrary(module);
HeapFree(GetProcessHeap(),0,tl_struct.source); msi_free(tl_struct.source);
} }
else else
ERR("Could not load file! %s\n", debugstr_w(file->TargetPath)); ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
@ -2764,7 +2764,7 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
if (!strchrW(filename,'.') || strcmpiW(strchrW(filename,'.'),szlnk)) if (!strchrW(filename,'.') || strcmpiW(strchrW(filename,'.'),szlnk))
strcatW(filename,szlnk); strcatW(filename,szlnk);
target_file = build_directory_name(2, target_folder, filename); target_file = build_directory_name(2, target_folder, filename);
HeapFree(GetProcessHeap(),0,target_folder); msi_free(target_folder);
buffer = MSI_RecordGetString(row,5); buffer = MSI_RecordGetString(row,5);
if (strchrW(buffer,'[')) if (strchrW(buffer,'['))
@ -2772,7 +2772,7 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
LPWSTR deformated; LPWSTR deformated;
deformat_string(package,buffer,&deformated); deformat_string(package,buffer,&deformated);
IShellLinkW_SetPath(sl,deformated); IShellLinkW_SetPath(sl,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
else else
{ {
@ -2780,7 +2780,7 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
FIXME("poorly handled shortcut format, advertised shortcut\n"); FIXME("poorly handled shortcut format, advertised shortcut\n");
keypath = strdupW( comp->FullKeypath ); keypath = strdupW( comp->FullKeypath );
IShellLinkW_SetPath(sl,keypath); IShellLinkW_SetPath(sl,keypath);
HeapFree(GetProcessHeap(),0,keypath); msi_free(keypath);
} }
if (!MSI_RecordIsNull(row,6)) if (!MSI_RecordIsNull(row,6))
@ -2789,7 +2789,7 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
buffer = MSI_RecordGetString(row,6); buffer = MSI_RecordGetString(row,6);
deformat_string(package,buffer,&deformated); deformat_string(package,buffer,&deformated);
IShellLinkW_SetArguments(sl,deformated); IShellLinkW_SetArguments(sl,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
if (!MSI_RecordIsNull(row,7)) if (!MSI_RecordIsNull(row,7))
@ -2812,7 +2812,7 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
index = MSI_RecordGetInteger(row,10); index = MSI_RecordGetInteger(row,10);
IShellLinkW_SetIconLocation(sl,Path,index); IShellLinkW_SetIconLocation(sl,Path,index);
HeapFree(GetProcessHeap(),0,Path); msi_free(Path);
} }
if (!MSI_RecordIsNull(row,11)) if (!MSI_RecordIsNull(row,11))
@ -2824,13 +2824,13 @@ static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
buffer = MSI_RecordGetString(row,12); buffer = MSI_RecordGetString(row,12);
Path = resolve_folder(package, buffer, FALSE, FALSE, NULL); Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
IShellLinkW_SetWorkingDirectory(sl,Path); IShellLinkW_SetWorkingDirectory(sl,Path);
HeapFree(GetProcessHeap(), 0, Path); msi_free(Path);
} }
TRACE("Writing shortcut to %s\n",debugstr_w(target_file)); TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
IPersistFile_Save(pf,target_file,FALSE); IPersistFile_Save(pf,target_file,FALSE);
HeapFree(GetProcessHeap(),0,target_file); msi_free(target_file);
IPersistFile_Release( pf ); IPersistFile_Release( pf );
IShellLinkW_Release( sl ); IShellLinkW_Release( sl );
@ -2896,7 +2896,7 @@ static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
if (the_file == INVALID_HANDLE_VALUE) if (the_file == INVALID_HANDLE_VALUE)
{ {
ERR("Unable to create file %s\n",debugstr_w(FilePath)); ERR("Unable to create file %s\n",debugstr_w(FilePath));
HeapFree(GetProcessHeap(),0,FilePath); msi_free(FilePath);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -2915,7 +2915,7 @@ static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
WriteFile(the_file,buffer,sz,&write,NULL); WriteFile(the_file,buffer,sz,&write,NULL);
} while (sz == 1024); } while (sz == 1024);
HeapFree(GetProcessHeap(),0,FilePath); msi_free(FilePath);
CloseHandle(the_file); CloseHandle(the_file);
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -2973,12 +2973,12 @@ static UINT ACTION_PublishProduct(MSIPACKAGE *package)
buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW ); buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer ); msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
buffer = msi_dup_property( package, szProductLanguage ); buffer = msi_dup_property( package, szProductLanguage );
langid = atoiW(buffer); langid = atoiW(buffer);
msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid ); msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
buffer = msi_dup_property( package, szARPProductIcon ); buffer = msi_dup_property( package, szARPProductIcon );
if (buffer) if (buffer)
@ -2987,7 +2987,7 @@ static UINT ACTION_PublishProduct(MSIPACKAGE *package)
build_icon_path(package,buffer,&path); build_icon_path(package,buffer,&path);
msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path ); msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
} }
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
buffer = msi_dup_property( package, szProductVersion ); buffer = msi_dup_property( package, szProductVersion );
if (buffer) if (buffer)
@ -2995,7 +2995,7 @@ static UINT ACTION_PublishProduct(MSIPACKAGE *package)
DWORD verdword = build_version_dword(buffer); DWORD verdword = build_version_dword(buffer);
msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword ); msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
} }
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
FIXME("Need to write more keys to the user registry\n"); FIXME("Need to write more keys to the user registry\n");
@ -3128,11 +3128,11 @@ static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
ui_actiondata(package,szWriteIniValues,uirow); ui_actiondata(package,szWriteIniValues,uirow);
msiobj_release( &uirow->hdr ); msiobj_release( &uirow->hdr );
cleanup: cleanup:
HeapFree(GetProcessHeap(),0,fullname); msi_free(fullname);
HeapFree(GetProcessHeap(),0,folder); msi_free(folder);
HeapFree(GetProcessHeap(),0,deformated_key); msi_free(deformated_key);
HeapFree(GetProcessHeap(),0,deformated_value); msi_free(deformated_value);
HeapFree(GetProcessHeap(),0,deformated_section); msi_free(deformated_section);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -3183,7 +3183,7 @@ static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2; len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
FullName = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR)); FullName = msi_alloc(len*sizeof(WCHAR));
strcpyW(FullName,ExeStr); strcpyW(FullName,ExeStr);
strcatW( FullName, file->TargetPath ); strcatW( FullName, file->TargetPath );
strcatW(FullName,close); strcatW(FullName,close);
@ -3195,7 +3195,7 @@ static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
if (brc) if (brc)
msi_dialog_check_messages(info.hProcess); msi_dialog_check_messages(info.hProcess);
HeapFree(GetProcessHeap(),0,FullName); msi_free(FullName);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -3260,7 +3260,7 @@ static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
if (feature->Feature_Parent) if (feature->Feature_Parent)
size += strlenW( feature->Feature_Parent )+2; size += strlenW( feature->Feature_Parent )+2;
data = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)); data = msi_alloc(size * sizeof(WCHAR));
data[0] = 0; data[0] = 0;
LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry ) LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
@ -3286,7 +3286,7 @@ static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
} }
msi_reg_set_val_str( hkey, feature->Feature, data ); msi_reg_set_val_str( hkey, feature->Feature, data );
HeapFree(GetProcessHeap(),0,data); msi_free(data);
size = 0; size = 0;
if (feature->Feature_Parent) if (feature->Feature_Parent)
@ -3299,14 +3299,14 @@ static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
else else
{ {
size += 2*sizeof(WCHAR); size += 2*sizeof(WCHAR);
data = HeapAlloc(GetProcessHeap(),0,size); data = msi_alloc(size);
data[0] = 0x6; data[0] = 0x6;
data[1] = 0; data[1] = 0;
if (feature->Feature_Parent) if (feature->Feature_Parent)
strcpyW( &data[1], feature->Feature_Parent ); strcpyW( &data[1], feature->Feature_Parent );
RegSetValueExW(hukey,feature->Feature,0,REG_SZ, RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
(LPBYTE)data,size); (LPBYTE)data,size);
HeapFree(GetProcessHeap(),0,data); msi_free(data);
} }
} }
@ -3404,7 +3404,7 @@ static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
{ {
buffer = msi_dup_property( package, szPropKeys[i] ); buffer = msi_dup_property( package, szPropKeys[i] );
msi_reg_set_val_str( hkey, szRegKeys[i], buffer ); msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
} }
msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 ); msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
@ -3446,21 +3446,21 @@ static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
size = deformat_string(package,modpath_fmt,&buffer); size = deformat_string(package,modpath_fmt,&buffer);
RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size); RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size); RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
FIXME("Write real Estimated Size when we have it\n"); FIXME("Write real Estimated Size when we have it\n");
msi_reg_set_val_dword( hkey, szEstimatedSize, 0 ); msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
GetLocalTime(&systime); GetLocalTime(&systime);
size = 9*sizeof(WCHAR); size = 9*sizeof(WCHAR);
buffer= HeapAlloc(GetProcessHeap(),0,size); buffer= msi_alloc(size);
sprintfW(buffer,date_fmt,systime.wYear,systime.wMonth,systime.wDay); sprintfW(buffer,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, buffer ); msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, buffer );
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
buffer = msi_dup_property( package, szProductLanguage ); buffer = msi_dup_property( package, szProductLanguage );
msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, atoiW(buffer) ); msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, atoiW(buffer) );
HeapFree(GetProcessHeap(),1,buffer); msi_free(buffer);
buffer = msi_dup_property( package, szProductVersion ); buffer = msi_dup_property( package, szProductVersion );
if (buffer) if (buffer)
@ -3471,7 +3471,7 @@ static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 ); msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF ); msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
} }
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
/* Handle Upgrade Codes */ /* Handle Upgrade Codes */
upgrade_code = msi_dup_property( package, szUpgradeCode ); upgrade_code = msi_dup_property( package, szUpgradeCode );
@ -3488,7 +3488,7 @@ static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
msi_reg_set_val_str( hkey2, squashed, NULL ); msi_reg_set_val_str( hkey2, squashed, NULL );
RegCloseKey(hkey2); RegCloseKey(hkey2);
HeapFree(GetProcessHeap(),0,upgrade_code); msi_free(upgrade_code);
} }
end: end:
@ -3605,7 +3605,7 @@ UINT ACTION_ResolveSource(MSIPACKAGE* package)
INSTALLPROPERTY_DISKPROMPTW,NULL,&size); INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
if (rc == ERROR_MORE_DATA) if (rc == ERROR_MORE_DATA)
{ {
prompt = HeapAlloc(GetProcessHeap(),0,size * sizeof(WCHAR)); prompt = msi_alloc(size * sizeof(WCHAR));
MsiSourceListGetInfoW(package->ProductCode, NULL, MsiSourceListGetInfoW(package->ProductCode, NULL,
MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT, MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
INSTALLPROPERTY_DISKPROMPTW,prompt,&size); INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
@ -3624,7 +3624,7 @@ UINT ACTION_ResolveSource(MSIPACKAGE* package)
} }
attrib = GetFileAttributesW(package->PackagePath); attrib = GetFileAttributesW(package->PackagePath);
} }
HeapFree(GetProcessHeap(),0,prompt); msi_free(prompt);
rc = ERROR_SUCCESS; rc = ERROR_SUCCESS;
} }
else else
@ -3671,11 +3671,11 @@ static UINT ACTION_RegisterUser(MSIPACKAGE *package)
{ {
buffer = msi_dup_property( package, szPropKeys[i] ); buffer = msi_dup_property( package, szPropKeys[i] );
msi_reg_set_val_str( hkey, szRegKeys[i], buffer ); msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
HeapFree( GetProcessHeap(), 0, buffer ); msi_free( buffer );
} }
end: end:
HeapFree(GetProcessHeap(),0,productid); msi_free(productid);
RegCloseKey(hkey); RegCloseKey(hkey);
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -3694,7 +3694,7 @@ static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
package->script->InWhatSequence |= SEQUENCE_EXEC; package->script->InWhatSequence |= SEQUENCE_EXEC;
rc = ACTION_ProcessExecSequence(package,FALSE); rc = ACTION_ProcessExecSequence(package,FALSE);
MSI_SetPropertyW(package,szUILevel,level); MSI_SetPropertyW(package,szUILevel,level);
HeapFree(GetProcessHeap(),0,level); msi_free(level);
return rc; return rc;
} }
@ -3805,19 +3805,18 @@ static LPWSTR load_ttfname_from(LPCWSTR filename)
ttRecord.uStringOffset + ttRecord.uStringOffset +
ttNTHeader.uStorageOffset, ttNTHeader.uStorageOffset,
NULL, FILE_BEGIN); NULL, FILE_BEGIN);
buf = HeapAlloc(GetProcessHeap(), 0, buf = msi_alloc( ttRecord.uStringLength + 1 + strlen(tt) );
ttRecord.uStringLength + 1 + strlen(tt));
memset(buf, 0, ttRecord.uStringLength + 1 + strlen(tt)); memset(buf, 0, ttRecord.uStringLength + 1 + strlen(tt));
ReadFile(handle, buf, ttRecord.uStringLength, NULL, NULL); ReadFile(handle, buf, ttRecord.uStringLength, NULL, NULL);
if (strlen(buf) > 0) if (strlen(buf) > 0)
{ {
strcat(buf,tt); strcat(buf,tt);
ret = strdupAtoW(buf); ret = strdupAtoW(buf);
HeapFree(GetProcessHeap(),0,buf); msi_free(buf);
break; break;
} }
HeapFree(GetProcessHeap(),0,buf); msi_free(buf);
SetFilePointer(handle,nPos, NULL, FILE_BEGIN); SetFilePointer(handle,nPos, NULL, FILE_BEGIN);
} }
} }
@ -3882,7 +3881,7 @@ static UINT ITERATE_RegisterFonts(MSIRECORD *row, LPVOID param)
msi_reg_set_val_str( hkey2, name, file->FileName ); msi_reg_set_val_str( hkey2, name, file->FileName );
} }
HeapFree(GetProcessHeap(),0,name); msi_free(name);
RegCloseKey(hkey1); RegCloseKey(hkey1);
RegCloseKey(hkey2); RegCloseKey(hkey2);
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -3957,7 +3956,7 @@ static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
sz+=3; sz+=3;
sz *= sizeof(WCHAR); sz *= sizeof(WCHAR);
output = HeapAlloc(GetProcessHeap(),0,sz); output = msi_alloc(sz);
memset(output,0,sz); memset(output,0,sz);
strcpyW(output,advertise); strcpyW(output,advertise);
@ -3968,7 +3967,7 @@ static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
end: end:
RegCloseKey(hkey); RegCloseKey(hkey);
HeapFree(GetProcessHeap(),0,output); msi_free(output);
return rc; return rc;
} }

43
dlls/msi/appsearch.c
View File

@ -124,14 +124,14 @@ static UINT ACTION_AppSearchGetSignature(MSIPACKAGE *package, MSISIGNATURE *sig,
{ {
ACTION_VerStrToInteger(minVersion, &sig->MinVersionMS, ACTION_VerStrToInteger(minVersion, &sig->MinVersionMS,
&sig->MinVersionLS); &sig->MinVersionLS);
HeapFree(GetProcessHeap(), 0, minVersion); msi_free( minVersion);
} }
maxVersion = load_dynamic_stringW(row,4); maxVersion = load_dynamic_stringW(row,4);
if (maxVersion) if (maxVersion)
{ {
ACTION_VerStrToInteger(maxVersion, &sig->MaxVersionMS, ACTION_VerStrToInteger(maxVersion, &sig->MaxVersionMS,
&sig->MaxVersionLS); &sig->MaxVersionLS);
HeapFree(GetProcessHeap(), 0, maxVersion); msi_free( maxVersion);
} }
sig->MinSize = MSI_RecordGetInteger(row,5); sig->MinSize = MSI_RecordGetInteger(row,5);
if (sig->MinSize == MSI_NULL_INTEGER) if (sig->MinSize == MSI_NULL_INTEGER)
@ -325,7 +325,7 @@ static UINT ACTION_AppSearchReg(MSIPACKAGE *package, BOOL *appFound,
/* FIXME: sanity-check sz before allocating (is there an upper-limit /* FIXME: sanity-check sz before allocating (is there an upper-limit
* on the value of a property?) * on the value of a property?)
*/ */
value = HeapAlloc(GetProcessHeap(), 0, sz); value = msi_alloc( sz);
rc = RegQueryValueExW(key, valueName, NULL, &regType, value, &sz); rc = RegQueryValueExW(key, valueName, NULL, &regType, value, &sz);
if (rc) if (rc)
{ {
@ -347,14 +347,13 @@ static UINT ACTION_AppSearchReg(MSIPACKAGE *package, BOOL *appFound,
if (*(LPWSTR)value == '#') if (*(LPWSTR)value == '#')
{ {
/* escape leading pound with another */ /* escape leading pound with another */
propertyValue = HeapAlloc(GetProcessHeap(), 0, propertyValue = msi_alloc( sz + sizeof(WCHAR));
sz + sizeof(WCHAR));
propertyValue[0] = '#'; propertyValue[0] = '#';
strcpyW(propertyValue + 1, (LPWSTR)value); strcpyW(propertyValue + 1, (LPWSTR)value);
} }
else else
{ {
propertyValue = HeapAlloc(GetProcessHeap(), 0, sz); propertyValue = msi_alloc( sz);
strcpyW(propertyValue, (LPWSTR)value); strcpyW(propertyValue, (LPWSTR)value);
} }
break; break;
@ -362,20 +361,17 @@ static UINT ACTION_AppSearchReg(MSIPACKAGE *package, BOOL *appFound,
/* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign /* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign
* char if needed * char if needed
*/ */
propertyValue = HeapAlloc(GetProcessHeap(), 0, propertyValue = msi_alloc( 10 * sizeof(WCHAR));
10 * sizeof(WCHAR));
sprintfW(propertyValue, dwordFmt, *(DWORD *)value); sprintfW(propertyValue, dwordFmt, *(DWORD *)value);
break; break;
case REG_EXPAND_SZ: case REG_EXPAND_SZ:
/* space for extra #% characters in front */ /* space for extra #% characters in front */
propertyValue = HeapAlloc(GetProcessHeap(), 0, propertyValue = msi_alloc( sz + 2 * sizeof(WCHAR));
sz + 2 * sizeof(WCHAR));
sprintfW(propertyValue, expandSzFmt, (LPWSTR)value); sprintfW(propertyValue, expandSzFmt, (LPWSTR)value);
break; break;
case REG_BINARY: case REG_BINARY:
/* 3 == length of "#x<nibble>" */ /* 3 == length of "#x<nibble>" */
propertyValue = HeapAlloc(GetProcessHeap(), 0, propertyValue = msi_alloc( (sz * 3 + 1) * sizeof(WCHAR));
(sz * 3 + 1) * sizeof(WCHAR));
for (i = 0; i < sz; i++) for (i = 0; i < sz; i++)
sprintfW(propertyValue + i * 3, binFmt, value[i]); sprintfW(propertyValue + i * 3, binFmt, value[i]);
break; break;
@ -390,12 +386,12 @@ static UINT ACTION_AppSearchReg(MSIPACKAGE *package, BOOL *appFound,
*appFound = TRUE; *appFound = TRUE;
end: end:
HeapFree(GetProcessHeap(), 0, propertyValue); msi_free( propertyValue);
HeapFree(GetProcessHeap(), 0, value); msi_free( value);
RegCloseKey(key); RegCloseKey(key);
HeapFree(GetProcessHeap(), 0, keyPath); msi_free( keyPath);
HeapFree(GetProcessHeap(), 0, valueName); msi_free( valueName);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
MSI_ViewClose(view); MSI_ViewClose(view);
@ -449,7 +445,7 @@ static UINT ACTION_AppSearchIni(MSIPACKAGE *package, BOOL *appFound,
fileName = load_dynamic_stringW(row,2); fileName = load_dynamic_stringW(row,2);
FIXME("AppSearch unimplemented for IniLocator (ini file name %s)\n", FIXME("AppSearch unimplemented for IniLocator (ini file name %s)\n",
debugstr_w(fileName)); debugstr_w(fileName));
HeapFree(GetProcessHeap(), 0, fileName); msi_free( fileName);
end: end:
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
@ -549,7 +545,7 @@ static UINT ACTION_FileVersionMatches(MSISIGNATURE *sig, LPCWSTR filePath,
if (size) if (size)
{ {
LPVOID buf = HeapAlloc(GetProcessHeap(), 0, size); LPVOID buf = msi_alloc( size);
if (buf) if (buf)
{ {
@ -592,7 +588,7 @@ static UINT ACTION_FileVersionMatches(MSISIGNATURE *sig, LPCWSTR filePath,
else else
*matches = TRUE; *matches = TRUE;
} }
HeapFree(GetProcessHeap(), 0, buf); msi_free( buf);
} }
else else
rc = ERROR_OUTOFMEMORY; rc = ERROR_OUTOFMEMORY;
@ -671,8 +667,7 @@ static UINT ACTION_RecurseSearchDirectory(MSIPACKAGE *package, BOOL *appFound,
* here. Add two because we might need to add a backslash if the dir name * here. Add two because we might need to add a backslash if the dir name
* isn't backslash-terminated. * isn't backslash-terminated.
*/ */
buf = HeapAlloc(GetProcessHeap(), 0, buf = msi_alloc( (dirLen + max(fileLen, lstrlenW(starDotStarW)) + 2) * sizeof(WCHAR));
(dirLen + max(fileLen, lstrlenW(starDotStarW)) + 2) * sizeof(WCHAR));
if (buf) if (buf)
{ {
/* a depth of 0 implies we should search dir, so go ahead and search */ /* a depth of 0 implies we should search dir, so go ahead and search */
@ -726,7 +721,7 @@ static UINT ACTION_RecurseSearchDirectory(MSIPACKAGE *package, BOOL *appFound,
FindClose(hFind); FindClose(hFind);
} }
} }
HeapFree(GetProcessHeap(), 0, buf); msi_free(buf);
} }
else else
rc = ERROR_OUTOFMEMORY; rc = ERROR_OUTOFMEMORY;
@ -965,8 +960,8 @@ UINT ACTION_AppSearch(MSIPACKAGE *package)
} }
} }
} }
HeapFree(GetProcessHeap(), 0, sig.File); msi_free( sig.File);
HeapFree(GetProcessHeap(), 0, sig.Languages); msi_free( sig.Languages);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
} }

75
dlls/msi/classes.c
View File

@ -61,7 +61,7 @@ static MSIAPPID *load_appid( MSIPACKAGE* package, MSIRECORD *row )
/* fill in the data */ /* fill in the data */
appid = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSIAPPID) ); appid = msi_alloc_zero( sizeof(MSIAPPID) );
if (!appid) if (!appid)
return NULL; return NULL;
@ -125,7 +125,7 @@ static MSIPROGID *load_progid( MSIPACKAGE* package, MSIRECORD *row )
/* fill in the data */ /* fill in the data */
progid = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSIPROGID) ); progid = msi_alloc_zero( sizeof(MSIPROGID) );
if (!progid) if (!progid)
return NULL; return NULL;
@ -155,14 +155,12 @@ static MSIPROGID *load_progid( MSIPACKAGE* package, MSIRECORD *row )
build_icon_path(package,FileName,&FilePath); build_icon_path(package,FileName,&FilePath);
progid->IconPath = progid->IconPath = msi_alloc( (strlenW(FilePath)+10)* sizeof(WCHAR) );
HeapAlloc(GetProcessHeap(),0,(strlenW(FilePath)+10)*
sizeof(WCHAR));
sprintfW(progid->IconPath,fmt,FilePath,icon_index); sprintfW(progid->IconPath,fmt,FilePath,icon_index);
HeapFree(GetProcessHeap(),0,FilePath); msi_free(FilePath);
HeapFree(GetProcessHeap(),0,FileName); msi_free(FileName);
} }
else else
{ {
@ -231,7 +229,7 @@ static MSICLASS *load_class( MSIPACKAGE* package, MSIRECORD *row )
/* fill in the data */ /* fill in the data */
cls = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSICLASS) ); cls = msi_alloc_zero( sizeof(MSICLASS) );
if (!cls) if (!cls)
return NULL; return NULL;
@ -264,14 +262,12 @@ static MSICLASS *load_class( MSIPACKAGE* package, MSIRECORD *row )
build_icon_path(package,FileName,&FilePath); build_icon_path(package,FileName,&FilePath);
cls->IconPath = cls->IconPath = msi_alloc( (strlenW(FilePath)+5)* sizeof(WCHAR) );
HeapAlloc(GetProcessHeap(),0,(strlenW(FilePath)+5)*
sizeof(WCHAR));
sprintfW(cls->IconPath,fmt,FilePath,icon_index); sprintfW(cls->IconPath,fmt,FilePath,icon_index);
HeapFree(GetProcessHeap(),0,FilePath); msi_free(FilePath);
HeapFree(GetProcessHeap(),0,FileName); msi_free(FileName);
} }
else else
{ {
@ -367,7 +363,7 @@ static MSIMIME *load_mime( MSIPACKAGE* package, MSIRECORD *row )
/* fill in the data */ /* fill in the data */
mt = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSIMIME) ); mt = msi_alloc_zero( sizeof(MSIMIME) );
if (!mt) if (!mt)
return mt; return mt;
@ -425,7 +421,7 @@ static MSIEXTENSION *load_extension( MSIPACKAGE* package, MSIRECORD *row )
/* fill in the data */ /* fill in the data */
ext = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSIEXTENSION) ); ext = msi_alloc_zero( sizeof(MSIEXTENSION) );
if (!ext) if (!ext)
return NULL; return NULL;
@ -506,7 +502,7 @@ static UINT iterate_load_verb(MSIRECORD *row, LPVOID param)
/* fill in the data */ /* fill in the data */
verb = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSIVERB) ); verb = msi_alloc_zero( sizeof(MSIVERB) );
if (!verb) if (!verb)
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
@ -919,7 +915,7 @@ UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
size += sizeof(WCHAR); size += sizeof(WCHAR);
} }
argument = HeapAlloc(GetProcessHeap(), 0, size + sizeof(WCHAR)); argument = msi_alloc( size + sizeof(WCHAR));
GetShortPathNameW( file->TargetPath, argument, sz ); GetShortPathNameW( file->TargetPath, argument, sz );
if (cls->Argument) if (cls->Argument)
@ -939,7 +935,7 @@ UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
size += sizeof(WCHAR); size += sizeof(WCHAR);
} }
argument = HeapAlloc(GetProcessHeap(), 0, size + sizeof(WCHAR)); argument = msi_alloc( size + sizeof(WCHAR));
strcpyW( argument, file->TargetPath ); strcpyW( argument, file->TargetPath );
if (cls->Argument) if (cls->Argument)
@ -952,7 +948,7 @@ UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
if (argument) if (argument)
{ {
msi_reg_set_val_str( hkey3, NULL, argument ); msi_reg_set_val_str( hkey3, NULL, argument );
HeapFree(GetProcessHeap(),0,argument); msi_free(argument);
} }
RegCloseKey(hkey3); RegCloseKey(hkey3);
@ -1022,12 +1018,11 @@ UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
ptr2 = strchrW(ptr,';'); ptr2 = strchrW(ptr,';');
if (ptr2) if (ptr2)
*ptr2 = 0; *ptr2 = 0;
keyname = HeapAlloc(GetProcessHeap(),0,(strlenW(szFileType_fmt)+ keyname = msi_alloc( (strlenW(szFileType_fmt) + strlenW(cls->clsid) + 4) * sizeof(WCHAR));
strlenW(cls->clsid) + 4) * sizeof(WCHAR));
sprintfW( keyname, szFileType_fmt, cls->clsid, index ); sprintfW( keyname, szFileType_fmt, cls->clsid, index );
msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr ); msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr );
HeapFree(GetProcessHeap(), 0, keyname); msi_free(keyname);
if (ptr2) if (ptr2)
ptr = ptr2+1; ptr = ptr2+1;
@ -1188,14 +1183,14 @@ static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
size += strlenW(verb->Argument); size += strlenW(verb->Argument);
size += 4; size += 4;
command = HeapAlloc(GetProcessHeap(),0, size * sizeof (WCHAR)); command = msi_alloc(size * sizeof (WCHAR));
if (verb->Argument) if (verb->Argument)
sprintfW(command, fmt, component->FullKeypath, verb->Argument); sprintfW(command, fmt, component->FullKeypath, verb->Argument);
else else
sprintfW(command, fmt2, component->FullKeypath); sprintfW(command, fmt2, component->FullKeypath);
msi_reg_set_val_str( key, NULL, command ); msi_reg_set_val_str( key, NULL, command );
HeapFree(GetProcessHeap(),0,command); msi_free(command);
advertise = create_component_advertise_string(package, component, advertise = create_component_advertise_string(package, component,
extension->Feature->Feature); extension->Feature->Feature);
@ -1206,7 +1201,7 @@ static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
size += strlenW(verb->Argument); size += strlenW(verb->Argument);
size += 4; size += 4;
command = HeapAlloc(GetProcessHeap(),0, size * sizeof (WCHAR)); command = msi_alloc(size * sizeof (WCHAR));
memset(command,0,size*sizeof(WCHAR)); memset(command,0,size*sizeof(WCHAR));
strcpyW(command,advertise); strcpyW(command,advertise);
@ -1220,15 +1215,15 @@ static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
msi_reg_set_val_multi_str( key, szCommand, command ); msi_reg_set_val_multi_str( key, szCommand, command );
RegCloseKey(key); RegCloseKey(key);
HeapFree(GetProcessHeap(),0,keyname); msi_free(keyname);
HeapFree(GetProcessHeap(),0,advertise); msi_free(advertise);
HeapFree(GetProcessHeap(),0,command); msi_free(command);
if (verb->Command) if (verb->Command)
{ {
keyname = build_directory_name(3, progid, szShell, verb->Verb); keyname = build_directory_name(3, progid, szShell, verb->Verb);
msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Command ); msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Command );
HeapFree(GetProcessHeap(),0,keyname); msi_free(keyname);
} }
if (verb->Sequence != MSI_NULL_INTEGER) if (verb->Sequence != MSI_NULL_INTEGER)
@ -1238,7 +1233,7 @@ static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
*Sequence = verb->Sequence; *Sequence = verb->Sequence;
keyname = build_directory_name(2, progid, szShell); keyname = build_directory_name(2, progid, szShell);
msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Verb ); msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Verb );
HeapFree(GetProcessHeap(),0,keyname); msi_free(keyname);
} }
} }
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -1299,13 +1294,12 @@ UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
mark_mime_for_install(ext->Mime); mark_mime_for_install(ext->Mime);
extension = HeapAlloc( GetProcessHeap(), 0, extension = msi_alloc( (lstrlenW( ext->Extension ) + 2)*sizeof(WCHAR) );
(lstrlenW( ext->Extension ) + 2)*sizeof(WCHAR) );
extension[0] = '.'; extension[0] = '.';
lstrcpyW(extension+1,ext->Extension); lstrcpyW(extension+1,ext->Extension);
RegCreateKeyW(HKEY_CLASSES_ROOT,extension,&hkey); RegCreateKeyW(HKEY_CLASSES_ROOT,extension,&hkey);
HeapFree( GetProcessHeap(), 0, extension ); msi_free( extension );
if (ext->Mime) if (ext->Mime)
msi_reg_set_val_str( hkey, szContentType, ext->Mime->ContentType ); msi_reg_set_val_str( hkey, szContentType, ext->Mime->ContentType );
@ -1327,15 +1321,14 @@ UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
msi_reg_set_val_str( hkey, NULL, progid ); msi_reg_set_val_str( hkey, NULL, progid );
newkey = HeapAlloc(GetProcessHeap(),0, newkey = msi_alloc( (strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR));
(strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR));
strcpyW(newkey,progid); strcpyW(newkey,progid);
strcatW(newkey,szSN); strcatW(newkey,szSN);
RegCreateKeyW(hkey,newkey,&hkey2); RegCreateKeyW(hkey,newkey,&hkey2);
RegCloseKey(hkey2); RegCloseKey(hkey2);
HeapFree(GetProcessHeap(),0,newkey); msi_free(newkey);
/* do all the verbs */ /* do all the verbs */
LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry ) LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry )
@ -1396,18 +1389,16 @@ UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package)
mime = mt->ContentType; mime = mt->ContentType;
exten = mt->Extension->Extension; exten = mt->Extension->Extension;
extension = HeapAlloc( GetProcessHeap(), 0, extension = msi_alloc( (lstrlenW( exten ) + 2)*sizeof(WCHAR) );
(lstrlenW( exten ) + 2)*sizeof(WCHAR) );
extension[0] = '.'; extension[0] = '.';
lstrcpyW(extension+1,exten); lstrcpyW(extension+1,exten);
key = HeapAlloc(GetProcessHeap(),0,(strlenW(mime)+strlenW(fmt)+1) * key = msi_alloc( (strlenW(mime)+strlenW(fmt)+1) * sizeof(WCHAR) );
sizeof(WCHAR));
sprintfW(key,fmt,mime); sprintfW(key,fmt,mime);
msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szExten, extension ); msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szExten, extension );
HeapFree(GetProcessHeap(),0,extension); msi_free(extension);
HeapFree(GetProcessHeap(),0,key); msi_free(key);
if (mt->clsid) if (mt->clsid)
FIXME("Handle non null for field 3\n"); FIXME("Handle non null for field 3\n");

28
dlls/msi/cond.y
View File

@ -412,7 +412,7 @@ symbol_i:
MSI_GetComponentStateW(cond->package, $2, &install, &action ); MSI_GetComponentStateW(cond->package, $2, &install, &action );
$$ = action; $$ = action;
HeapFree( GetProcessHeap(), 0, $2 ); msi_free( $2 );
} }
| COND_QUESTION identifier | COND_QUESTION identifier
{ {
@ -421,7 +421,7 @@ symbol_i:
MSI_GetComponentStateW(cond->package, $2, &install, &action ); MSI_GetComponentStateW(cond->package, $2, &install, &action );
$$ = install; $$ = install;
HeapFree( GetProcessHeap(), 0, $2 ); msi_free( $2 );
} }
| COND_AMPER identifier | COND_AMPER identifier
{ {
@ -430,7 +430,7 @@ symbol_i:
MSI_GetFeatureStateW(cond->package, $2, &install, &action ); MSI_GetFeatureStateW(cond->package, $2, &install, &action );
$$ = action; $$ = action;
HeapFree( GetProcessHeap(), 0, $2 ); msi_free( $2 );
} }
| COND_EXCLAM identifier | COND_EXCLAM identifier
{ {
@ -439,7 +439,7 @@ symbol_i:
MSI_GetFeatureStateW(cond->package, $2, &install, &action ); MSI_GetFeatureStateW(cond->package, $2, &install, &action );
$$ = install; $$ = install;
HeapFree( GetProcessHeap(), 0, $2 ); msi_free( $2 );
} }
; ;
@ -453,30 +453,30 @@ symbol_s:
MSI_GetPropertyW(cond->package, $1, NULL, &sz); MSI_GetPropertyW(cond->package, $1, NULL, &sz);
if (sz == 0) if (sz == 0)
{ {
$$ = HeapAlloc( GetProcessHeap(), 0 ,sizeof(WCHAR)); $$ = msi_alloc( sizeof(WCHAR));
$$[0] = 0; $$[0] = 0;
} }
else else
{ {
sz ++; sz ++;
$$ = HeapAlloc( GetProcessHeap(), 0, sz*sizeof (WCHAR) ); $$ = msi_alloc( sz*sizeof (WCHAR) );
/* Lookup the identifier */ /* Lookup the identifier */
MSI_GetPropertyW(cond->package,$1,$$,&sz); MSI_GetPropertyW(cond->package,$1,$$,&sz);
} }
HeapFree( GetProcessHeap(), 0, $1 ); msi_free( $1 );
} }
| COND_PERCENT identifier | COND_PERCENT identifier
{ {
UINT len = GetEnvironmentVariableW( $2, NULL, 0 ); UINT len = GetEnvironmentVariableW( $2, NULL, 0 );
if( len++ ) if( len++ )
{ {
$$ = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) ); $$ = msi_alloc( len*sizeof (WCHAR) );
if( $$ ) if( $$ )
GetEnvironmentVariableW( $2, $$, len ); GetEnvironmentVariableW( $2, $$, len );
} }
HeapFree( GetProcessHeap(), 0, $2 ); msi_free( $2 );
} }
; ;
@ -496,7 +496,7 @@ integer:
if( !szNum ) if( !szNum )
YYABORT; YYABORT;
$$ = atoiW( szNum ); $$ = atoiW( szNum );
HeapFree( GetProcessHeap(), 0, szNum ); msi_free( szNum );
} }
; ;
@ -698,7 +698,7 @@ static LPWSTR COND_GetString( struct cond_str *str )
{ {
LPWSTR ret; LPWSTR ret;
ret = HeapAlloc( GetProcessHeap(), 0, (str->len+1) * sizeof (WCHAR) ); ret = msi_alloc( (str->len+1) * sizeof (WCHAR) );
if( ret ) if( ret )
{ {
memcpy( ret, str->data, str->len * sizeof(WCHAR)); memcpy( ret, str->data, str->len * sizeof(WCHAR));
@ -712,7 +712,7 @@ static LPWSTR COND_GetLiteral( struct cond_str *str )
{ {
LPWSTR ret; LPWSTR ret;
ret = HeapAlloc( GetProcessHeap(), 0, (str->len-1) * sizeof (WCHAR) ); ret = msi_alloc( (str->len-1) * sizeof (WCHAR) );
if( ret ) if( ret )
{ {
memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) ); memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
@ -771,13 +771,13 @@ MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szConditio
if( szCondition ) if( szCondition )
{ {
UINT len = MultiByteToWideChar( CP_ACP, 0, szCondition, -1, NULL, 0 ); UINT len = MultiByteToWideChar( CP_ACP, 0, szCondition, -1, NULL, 0 );
szwCond = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) ); szwCond = msi_alloc( len * sizeof (WCHAR) );
MultiByteToWideChar( CP_ACP, 0, szCondition, -1, szwCond, len ); MultiByteToWideChar( CP_ACP, 0, szCondition, -1, szwCond, len );
} }
r = MsiEvaluateConditionW( hInstall, szwCond ); r = MsiEvaluateConditionW( hInstall, szwCond );
HeapFree( GetProcessHeap(), 0, szwCond ); msi_free( szwCond );
return r; return r;
} }

60
dlls/msi/custom.c
View File

@ -154,8 +154,8 @@ UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
{ {
FIXME("Rollback only action... rollbacks not supported yet\n"); FIXME("Rollback only action... rollbacks not supported yet\n");
schedule_action(package, ROLLBACK_SCRIPT, action); schedule_action(package, ROLLBACK_SCRIPT, action);
HeapFree(GetProcessHeap(),0,source); msi_free(source);
HeapFree(GetProcessHeap(),0,target); msi_free(target);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -172,8 +172,8 @@ UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
schedule_action(package, INSTALL_SCRIPT, action); schedule_action(package, INSTALL_SCRIPT, action);
} }
HeapFree(GetProcessHeap(),0,source); msi_free(source);
HeapFree(GetProcessHeap(),0,target); msi_free(target);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -189,7 +189,7 @@ UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
MSI_SetPropertyW(package,szActionData,actiondata); MSI_SetPropertyW(package,szActionData,actiondata);
else else
MSI_SetPropertyW(package,szActionData,szBlank); MSI_SetPropertyW(package,szActionData,szBlank);
HeapFree(GetProcessHeap(),0,actiondata); msi_free(actiondata);
} }
} }
else if (!check_execution_scheduling_options(package,action,type)) else if (!check_execution_scheduling_options(package,action,type))
@ -218,12 +218,12 @@ UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
case 35: /* Directory set with formatted text. */ case 35: /* Directory set with formatted text. */
deformat_string(package,target,&deformated); deformat_string(package,target,&deformated);
MSI_SetTargetPathW(package, source, deformated); MSI_SetTargetPathW(package, source, deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
break; break;
case 51: /* Property set with formatted text. */ case 51: /* Property set with formatted text. */
deformat_string(package,target,&deformated); deformat_string(package,target,&deformated);
rc = MSI_SetPropertyW(package,source,deformated); rc = MSI_SetPropertyW(package,source,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
break; break;
default: default:
FIXME("UNHANDLED ACTION TYPE %i (%s %s)\n", FIXME("UNHANDLED ACTION TYPE %i (%s %s)\n",
@ -231,8 +231,8 @@ UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
debugstr_w(target)); debugstr_w(target));
} }
HeapFree(GetProcessHeap(),0,source); msi_free(source);
HeapFree(GetProcessHeap(),0,target); msi_free(target);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
return rc; return rc;
} }
@ -304,7 +304,7 @@ static void file_running_action(MSIPACKAGE* package, HANDLE Handle,
{ {
MSIRUNNINGACTION *action; MSIRUNNINGACTION *action;
action = HeapAlloc( GetProcessHeap(), 0, sizeof(MSIRUNNINGACTION) ); action = msi_alloc( sizeof(MSIRUNNINGACTION) );
action->handle = Handle; action->handle = Handle;
action->process = process; action->process = process;
@ -443,15 +443,15 @@ static DWORD WINAPI ACTION_CallDllFunction(thread_struct *stuff)
else else
ERR("Cannot load functon\n"); ERR("Cannot load functon\n");
HeapFree(GetProcessHeap(),0,proc); msi_free(proc);
FreeLibrary(hModule); FreeLibrary(hModule);
} }
else else
ERR("Unable to load library\n"); ERR("Unable to load library\n");
msiobj_release( &stuff->package->hdr ); msiobj_release( &stuff->package->hdr );
HeapFree(GetProcessHeap(),0,stuff->source); msi_free(stuff->source);
HeapFree(GetProcessHeap(),0,stuff->target); msi_free(stuff->target);
HeapFree(GetProcessHeap(), 0, stuff); msi_free(stuff);
return rc; return rc;
} }
@ -493,7 +493,7 @@ static UINT HANDLE_CustomType1(MSIPACKAGE *package, LPCWSTR source,
strcatW(tmp_file,dot); strcatW(tmp_file,dot);
} }
info = HeapAlloc( GetProcessHeap(), 0, sizeof(*info) ); info = msi_alloc( sizeof(*info) );
msiobj_addref( &package->hdr ); msiobj_addref( &package->hdr );
info->package = package; info->package = package;
info->target = strdupW(target); info->target = strdupW(target);
@ -536,7 +536,7 @@ static UINT HANDLE_CustomType2(MSIPACKAGE *package, LPCWSTR source,
if (deformated) if (deformated)
len += strlenW(deformated); len += strlenW(deformated);
cmd = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*len); cmd = msi_alloc(sizeof(WCHAR)*len);
strcpyW(cmd,tmp_file); strcpyW(cmd,tmp_file);
if (deformated) if (deformated)
@ -544,7 +544,7 @@ static UINT HANDLE_CustomType2(MSIPACKAGE *package, LPCWSTR source,
strcatW(cmd,spc); strcatW(cmd,spc);
strcatW(cmd,deformated); strcatW(cmd,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
TRACE("executing exe %s \n",debugstr_w(cmd)); TRACE("executing exe %s \n",debugstr_w(cmd));
@ -552,7 +552,7 @@ static UINT HANDLE_CustomType2(MSIPACKAGE *package, LPCWSTR source,
rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL, rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
c_collen, &si, &info); c_collen, &si, &info);
HeapFree(GetProcessHeap(),0,cmd); msi_free(cmd);
if ( !rc ) if ( !rc )
{ {
@ -597,7 +597,7 @@ static UINT HANDLE_CustomType18(MSIPACKAGE *package, LPCWSTR source,
len += strlenW(deformated); len += strlenW(deformated);
len += 2; len += 2;
cmd = HeapAlloc(GetProcessHeap(),0,len * sizeof(WCHAR)); cmd = msi_alloc(len * sizeof(WCHAR));
lstrcpyW( cmd, file->TargetPath); lstrcpyW( cmd, file->TargetPath);
if (deformated) if (deformated)
@ -605,7 +605,7 @@ static UINT HANDLE_CustomType18(MSIPACKAGE *package, LPCWSTR source,
strcatW(cmd, spc); strcatW(cmd, spc);
strcatW(cmd, deformated); strcatW(cmd, deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
TRACE("executing exe %s \n",debugstr_w(cmd)); TRACE("executing exe %s \n",debugstr_w(cmd));
@ -613,7 +613,7 @@ static UINT HANDLE_CustomType18(MSIPACKAGE *package, LPCWSTR source,
rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL, rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
c_collen, &si, &info); c_collen, &si, &info);
HeapFree(GetProcessHeap(),0,cmd); msi_free(cmd);
if ( !rc ) if ( !rc )
{ {
@ -652,7 +652,7 @@ static UINT HANDLE_CustomType19(MSIPACKAGE *package, LPCWSTR source,
else else
MessageBoxW( NULL, deformated, NULL, MB_OK ); MessageBoxW( NULL, deformated, NULL, MB_OK );
HeapFree( GetProcessHeap(), 0, deformated ); msi_free( deformated );
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }
@ -681,7 +681,7 @@ static UINT HANDLE_CustomType50(MSIPACKAGE *package, LPCWSTR source,
if (deformated) if (deformated)
len += strlenW(deformated); len += strlenW(deformated);
cmd = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*len); cmd = msi_alloc(sizeof(WCHAR)*len);
strcpyW(cmd,prop); strcpyW(cmd,prop);
if (deformated) if (deformated)
@ -689,16 +689,16 @@ static UINT HANDLE_CustomType50(MSIPACKAGE *package, LPCWSTR source,
strcatW(cmd,spc); strcatW(cmd,spc);
strcatW(cmd,deformated); strcatW(cmd,deformated);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
} }
HeapFree(GetProcessHeap(),0,prop); msi_free(prop);
TRACE("executing exe %s \n",debugstr_w(cmd)); TRACE("executing exe %s \n",debugstr_w(cmd));
rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL, rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
c_collen, &si, &info); c_collen, &si, &info);
HeapFree(GetProcessHeap(),0,cmd); msi_free(cmd);
if ( !rc ) if ( !rc )
{ {
@ -726,7 +726,7 @@ static UINT HANDLE_CustomType34(MSIPACKAGE *package, LPCWSTR source,
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
SetCurrentDirectoryW(filename); SetCurrentDirectoryW(filename);
HeapFree(GetProcessHeap(),0,filename); msi_free(filename);
deformat_string(package,target,&deformated); deformat_string(package,target,&deformated);
@ -737,7 +737,7 @@ static UINT HANDLE_CustomType34(MSIPACKAGE *package, LPCWSTR source,
rc = CreateProcessW(NULL, deformated, NULL, NULL, FALSE, 0, NULL, rc = CreateProcessW(NULL, deformated, NULL, NULL, FALSE, 0, NULL,
c_collen, &si, &info); c_collen, &si, &info);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
if ( !rc ) if ( !rc )
{ {
@ -777,7 +777,7 @@ void ACTION_FinishCustomActions(MSIPACKAGE* package)
} }
CloseHandle( action->handle ); CloseHandle( action->handle );
HeapFree( GetProcessHeap(), 0, action->name ); msi_free( action->name );
HeapFree( GetProcessHeap(), 0, action ); msi_free( action );
} }
} }

16
dlls/msi/database.c
View File

@ -93,7 +93,7 @@ UINT MSI_OpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIDATABASE **pdb)
/* UINT len = lstrlenW( szPerist ) + 1; */ /* UINT len = lstrlenW( szPerist ) + 1; */
FIXME("don't support persist files yet\b"); FIXME("don't support persist files yet\b");
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
/* szMode = HeapAlloc( GetProcessHeap(), 0, len * sizeof (DWORD) ); */ /* szMode = msi_alloc( len * sizeof (DWORD) ); */
} }
else if( szPersist == MSIDBOPEN_READONLY ) else if( szPersist == MSIDBOPEN_READONLY )
{ {
@ -220,8 +220,8 @@ UINT WINAPI MsiOpenDatabaseA(LPCSTR szDBPath, LPCSTR szPersist, MSIHANDLE *phDB)
end: end:
if( HIWORD(szPersist) ) if( HIWORD(szPersist) )
HeapFree( GetProcessHeap(), 0, szwPersist ); msi_free( szwPersist );
HeapFree( GetProcessHeap(), 0, szwDBPath ); msi_free( szwDBPath );
return r; return r;
} }
@ -276,8 +276,8 @@ UINT WINAPI MsiDatabaseImportA( MSIHANDLE handle,
r = MsiDatabaseImportW( handle, path, file ); r = MsiDatabaseImportW( handle, path, file );
end: end:
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
HeapFree( GetProcessHeap(), 0, file ); msi_free( file );
return r; return r;
} }
@ -344,9 +344,9 @@ UINT WINAPI MsiDatabaseExportA( MSIHANDLE handle, LPCSTR szTable,
r = MsiDatabaseExportW( handle, table, path, file ); r = MsiDatabaseExportW( handle, table, path, file );
end: end:
HeapFree( GetProcessHeap(), 0, table ); msi_free( table );
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
HeapFree( GetProcessHeap(), 0, file ); msi_free( file );
return r; return r;
} }

93
dlls/msi/dialog.c
View File

@ -197,7 +197,7 @@ static LPWSTR msi_dialog_get_style( LPWSTR *text )
return ret; return ret;
len = q - p; len = q - p;
ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) ); ret = msi_alloc( len*sizeof(WCHAR) );
if( !ret ) if( !ret )
return ret; return ret;
memcpy( ret, p, len*sizeof(WCHAR) ); memcpy( ret, p, len*sizeof(WCHAR) );
@ -216,8 +216,7 @@ static UINT msi_dialog_add_font( MSIRECORD *rec, LPVOID param )
/* create a font and add it to the list */ /* create a font and add it to the list */
name = MSI_RecordGetString( rec, 1 ); name = MSI_RecordGetString( rec, 1 );
font = HeapAlloc( GetProcessHeap(), 0, font = msi_alloc( sizeof *font + strlenW( name )*sizeof (WCHAR) );
sizeof *font + strlenW( name )*sizeof (WCHAR) );
strcpyW( font->name, name ); strcpyW( font->name, name );
font->next = dialog->font_list; font->next = dialog->font_list;
dialog->font_list = font; dialog->font_list = font;
@ -305,8 +304,7 @@ static msi_control *msi_dialog_create_window( msi_dialog *dialog,
style |= WS_CHILD; style |= WS_CHILD;
control = HeapAlloc( GetProcessHeap(), 0, control = msi_alloc( sizeof *control + strlenW(name)*sizeof(WCHAR) );
sizeof *control + strlenW(name)*sizeof(WCHAR) );
strcpyW( control->name, name ); strcpyW( control->name, name );
list_add_head( &dialog->controls, &control->entry ); list_add_head( &dialog->controls, &control->entry );
control->handler = NULL; control->handler = NULL;
@ -342,8 +340,8 @@ static msi_control *msi_dialog_create_window( msi_dialog *dialog,
msi_dialog_set_font( dialog, control->hwnd, msi_dialog_set_font( dialog, control->hwnd,
font ? font : dialog->default_font ); font ? font : dialog->default_font );
HeapFree( GetProcessHeap(), 0, font ); msi_free( font );
HeapFree( GetProcessHeap(), 0, title ); msi_free( title );
return control; return control;
} }
@ -371,13 +369,13 @@ static LPWSTR msi_create_tmp_path(void)
if( !r ) if( !r )
return path; return path;
len = lstrlenW( tmp ) + 20; len = lstrlenW( tmp ) + 20;
path = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) ); path = msi_alloc( len * sizeof (WCHAR) );
if( path ) if( path )
{ {
r = GetTempFileNameW( tmp, prefix, 0, path ); r = GetTempFileNameW( tmp, prefix, 0, path );
if (!r) if (!r)
{ {
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
path = NULL; path = NULL;
} }
} }
@ -411,7 +409,7 @@ static HANDLE msi_load_image( MSIDATABASE *db, LPCWSTR name, UINT type,
msiobj_release( &rec->hdr ); msiobj_release( &rec->hdr );
} }
HeapFree( GetProcessHeap(), 0, tmp ); msi_free( tmp );
return himage; return himage;
} }
@ -546,7 +544,7 @@ MSIText_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
msi_text_on_settext( hWnd ); msi_text_on_settext( hWnd );
break; break;
case WM_NCDESTROY: case WM_NCDESTROY:
HeapFree( GetProcessHeap(), 0, info ); msi_free( info );
RemovePropW( hWnd, szButtonData ); RemovePropW( hWnd, szButtonData );
break; break;
} }
@ -565,7 +563,7 @@ static UINT msi_dialog_text_control( msi_dialog *dialog, MSIRECORD *rec )
if( !control ) if( !control )
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
info = HeapAlloc( GetProcessHeap(), 0, sizeof *info ); info = msi_alloc( sizeof *info );
if( !info ) if( !info )
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -604,7 +602,7 @@ static UINT msi_dialog_button_control( msi_dialog *dialog, MSIRECORD *rec )
control->hIcon = msi_load_icon( dialog->package->db, text, attributes ); control->hIcon = msi_load_icon( dialog->package->db, text, attributes );
if( attributes & msidbControlAttributesIcon ) if( attributes & msidbControlAttributesIcon )
SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM) control->hIcon ); SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM) control->hIcon );
HeapFree( GetProcessHeap(), 0, text ); msi_free( text );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -633,7 +631,7 @@ static LPWSTR msi_get_checkbox_value( msi_dialog *dialog, LPCWSTR prop )
deformat_string( dialog->package, val, &ret ); deformat_string( dialog->package, val, &ret );
if( ret && !ret[0] ) if( ret && !ret[0] )
{ {
HeapFree( GetProcessHeap(), 0, ret ); msi_free( ret );
ret = NULL; ret = NULL;
} }
} }
@ -644,7 +642,7 @@ static LPWSTR msi_get_checkbox_value( msi_dialog *dialog, LPCWSTR prop )
ret = msi_dup_property( dialog->package, prop ); ret = msi_dup_property( dialog->package, prop );
if( ret && !ret[0] ) if( ret && !ret[0] )
{ {
HeapFree( GetProcessHeap(), 0, ret ); msi_free( ret );
ret = NULL; ret = NULL;
} }
@ -738,7 +736,7 @@ static UINT msi_dialog_scrolltext_control( msi_dialog *dialog, MSIRECORD *rec )
SendMessageW( control->hwnd, EM_STREAMIN, SF_RTF, (LPARAM) &es ); SendMessageW( control->hwnd, EM_STREAMIN, SF_RTF, (LPARAM) &es );
HeapFree( GetProcessHeap(), 0, info.string ); msi_free( info.string );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -774,7 +772,7 @@ static UINT msi_dialog_bitmap_control( msi_dialog *dialog, MSIRECORD *rec )
else else
ERR("Failed to load bitmap %s\n", debugstr_w(text)); ERR("Failed to load bitmap %s\n", debugstr_w(text));
HeapFree( GetProcessHeap(), 0, text ); msi_free( text );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -797,7 +795,7 @@ static UINT msi_dialog_icon_control( msi_dialog *dialog, MSIRECORD *rec )
SendMessageW( control->hwnd, STM_SETICON, (WPARAM) control->hIcon, 0 ); SendMessageW( control->hwnd, STM_SETICON, (WPARAM) control->hIcon, 0 );
else else
ERR("Failed to load bitmap %s\n", debugstr_w(text)); ERR("Failed to load bitmap %s\n", debugstr_w(text));
HeapFree( GetProcessHeap(), 0, text ); msi_free( text );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -824,7 +822,7 @@ static UINT msi_dialog_edit_control( msi_dialog *dialog, MSIRECORD *rec )
control->property = strdupW( prop ); control->property = strdupW( prop );
val = msi_dup_property( dialog->package, control->property ); val = msi_dup_property( dialog->package, control->property );
SetWindowTextW( control->hwnd, val ); SetWindowTextW( control->hwnd, val );
HeapFree( GetProcessHeap(), 0, val ); msi_free( val );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -856,7 +854,7 @@ static void msi_mask_control_change( struct msi_maskedit_info *info )
LPWSTR val; LPWSTR val;
UINT i, n, r; UINT i, n, r;
val = HeapAlloc( GetProcessHeap(), 0, (info->num_chars+1)*sizeof(WCHAR) ); val = msi_alloc( (info->num_chars+1)*sizeof(WCHAR) );
for( i=0, n=0; i<info->num_groups; i++ ) for( i=0, n=0; i<info->num_groups; i++ )
{ {
if( (info->group[i].len + n) > info->num_chars ) if( (info->group[i].len + n) > info->num_chars )
@ -880,7 +878,7 @@ static void msi_mask_control_change( struct msi_maskedit_info *info )
MSI_SetPropertyW( info->dialog->package, info->prop, val ); MSI_SetPropertyW( info->dialog->package, info->prop, val );
msi_dialog_evaluate_control_conditions( info->dialog ); msi_dialog_evaluate_control_conditions( info->dialog );
} }
HeapFree( GetProcessHeap(), 0, val ); msi_free( val );
} }
/* now move to the next control if necessary */ /* now move to the next control if necessary */
@ -927,8 +925,8 @@ MSIMaskedEdit_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
} }
break; break;
case WM_NCDESTROY: case WM_NCDESTROY:
HeapFree( GetProcessHeap(), 0, info->prop ); msi_free( info->prop );
HeapFree( GetProcessHeap(), 0, info ); msi_free( info );
RemovePropW( hWnd, szButtonData ); RemovePropW( hWnd, szButtonData );
break; break;
} }
@ -951,7 +949,7 @@ msi_maskedit_set_text( struct msi_maskedit_info *info, LPCWSTR text )
LPWSTR chunk = strdupW( p ); LPWSTR chunk = strdupW( p );
chunk[ info->group[i].len ] = 0; chunk[ info->group[i].len ] = 0;
SetWindowTextW( info->group[i].hwnd, chunk ); SetWindowTextW( info->group[i].hwnd, chunk );
HeapFree( GetProcessHeap(), 0, chunk ); msi_free( chunk );
} }
else else
{ {
@ -977,7 +975,7 @@ static struct msi_maskedit_info * msi_dialog_parse_groups( LPCWSTR mask )
if( !p ) if( !p )
return info; return info;
info = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *info ); info = msi_alloc_zero( sizeof *info );
if( !info ) if( !info )
return info; return info;
@ -1112,15 +1110,15 @@ static UINT msi_dialog_maskedit_control( msi_dialog *dialog, MSIRECORD *rec )
if( val ) if( val )
{ {
msi_maskedit_set_text( info, val ); msi_maskedit_set_text( info, val );
HeapFree( GetProcessHeap(), 0, val ); msi_free( val );
} }
} }
end: end:
if( ret != ERROR_SUCCESS ) if( ret != ERROR_SUCCESS )
HeapFree( GetProcessHeap(), 0, info ); msi_free( info );
HeapFree( GetProcessHeap(), 0, title ); msi_free( title );
HeapFree( GetProcessHeap(), 0, mask ); msi_free( mask );
return ret; return ret;
} }
@ -1477,7 +1475,7 @@ static LRESULT msi_dialog_oncreate( HWND hwnd, LPCREATESTRUCTW cs )
title = msi_get_deformatted_field( dialog->package, rec, 7 ); title = msi_get_deformatted_field( dialog->package, rec, 7 );
SetWindowTextW( hwnd, title ); SetWindowTextW( hwnd, title );
HeapFree( GetProcessHeap(), 0, title ); msi_free( title );
SetWindowPos( hwnd, 0, 0, 0, size.cx, size.cy, SetWindowPos( hwnd, 0, 0, 0, size.cx, size.cy,
SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW ); SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW );
@ -1504,8 +1502,8 @@ static UINT msi_dialog_send_event( msi_dialog *dialog, LPCWSTR event, LPCWSTR ar
dialog->event_handler( dialog->package, event_fmt, arg_fmt, dialog ); dialog->event_handler( dialog->package, event_fmt, arg_fmt, dialog );
HeapFree( GetProcessHeap(), 0, event_fmt ); msi_free( event_fmt );
HeapFree( GetProcessHeap(), 0, arg_fmt ); msi_free( arg_fmt );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -1517,7 +1515,7 @@ static UINT msi_dialog_set_property( msi_dialog *dialog, LPCWSTR event, LPCWSTR
UINT len; UINT len;
len = strlenW(event); len = strlenW(event);
prop = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR)); prop = msi_alloc( len*sizeof(WCHAR));
strcpyW( prop, &event[1] ); strcpyW( prop, &event[1] );
p = strchrW( prop, ']' ); p = strchrW( prop, ']' );
if( p && p[1] == 0 ) if( p && p[1] == 0 )
@ -1529,7 +1527,7 @@ static UINT msi_dialog_set_property( msi_dialog *dialog, LPCWSTR event, LPCWSTR
} }
else else
ERR("Badly formatted property string - what happens?\n"); ERR("Badly formatted property string - what happens?\n");
HeapFree( GetProcessHeap(), 0, prop ); msi_free( prop );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -1660,19 +1658,19 @@ static UINT msi_dialog_edit_handler( msi_dialog *dialog,
debugstr_w(control->property)); debugstr_w(control->property));
sz = 0x20; sz = 0x20;
buf = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) ); buf = msi_alloc( sz*sizeof(WCHAR) );
while( buf ) while( buf )
{ {
r = GetWindowTextW( control->hwnd, buf, sz ); r = GetWindowTextW( control->hwnd, buf, sz );
if( r < (sz-1) ) if( r < (sz-1) )
break; break;
sz *= 2; sz *= 2;
buf = HeapReAlloc( GetProcessHeap(), 0, buf, sz*sizeof(WCHAR) ); buf = msi_realloc( buf, sz*sizeof(WCHAR) );
} }
MSI_SetPropertyW( dialog->package, control->property, buf ); MSI_SetPropertyW( dialog->package, control->property, buf );
HeapFree( GetProcessHeap(), 0, buf ); msi_free( buf );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -1799,8 +1797,7 @@ msi_dialog *msi_dialog_create( MSIPACKAGE* package, LPCWSTR szDialogName,
TRACE("%p %s\n", package, debugstr_w(szDialogName)); TRACE("%p %s\n", package, debugstr_w(szDialogName));
/* allocate the structure for the dialog to use */ /* allocate the structure for the dialog to use */
dialog = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dialog = msi_alloc_zero( sizeof *dialog + sizeof(WCHAR)*strlenW(szDialogName) );
sizeof *dialog + sizeof(WCHAR)*strlenW(szDialogName) );
if( !dialog ) if( !dialog )
return NULL; return NULL;
strcpyW( dialog->name, szDialogName ); strcpyW( dialog->name, szDialogName );
@ -1815,7 +1812,7 @@ msi_dialog *msi_dialog_create( MSIPACKAGE* package, LPCWSTR szDialogName,
if( !rec ) if( !rec )
{ {
msiobj_release( &package->hdr ); msiobj_release( &package->hdr );
HeapFree( GetProcessHeap(), 0, dialog ); msi_free( dialog );
return NULL; return NULL;
} }
dialog->attributes = MSI_RecordGetInteger( rec, 6 ); dialog->attributes = MSI_RecordGetInteger( rec, 6 );
@ -1940,14 +1937,14 @@ void msi_dialog_destroy( msi_dialog *dialog )
msi_control, entry ); msi_control, entry );
list_remove( &t->entry ); list_remove( &t->entry );
/* leave dialog->hwnd - destroying parent destroys child windows */ /* leave dialog->hwnd - destroying parent destroys child windows */
HeapFree( GetProcessHeap(), 0, t->property ); msi_free( t->property );
HeapFree( GetProcessHeap(), 0, t->value ); msi_free( t->value );
if( t->hBitmap ) if( t->hBitmap )
DeleteObject( t->hBitmap ); DeleteObject( t->hBitmap );
if( t->hIcon ) if( t->hIcon )
DestroyIcon( t->hIcon ); DestroyIcon( t->hIcon );
HeapFree( GetProcessHeap(), 0, t->tabnext ); msi_free( t->tabnext );
HeapFree( GetProcessHeap(), 0, t ); msi_free( t );
if (t->hDll) if (t->hDll)
FreeLibrary( t->hDll ); FreeLibrary( t->hDll );
} }
@ -1958,13 +1955,13 @@ void msi_dialog_destroy( msi_dialog *dialog )
msi_font *t = dialog->font_list; msi_font *t = dialog->font_list;
dialog->font_list = t->next; dialog->font_list = t->next;
DeleteObject( t->hfont ); DeleteObject( t->hfont );
HeapFree( GetProcessHeap(), 0, t ); msi_free( t );
} }
HeapFree( GetProcessHeap(), 0, dialog->default_font ); msi_free( dialog->default_font );
msiobj_release( &dialog->package->hdr ); msiobj_release( &dialog->package->hdr );
dialog->package = NULL; dialog->package = NULL;
HeapFree( GetProcessHeap(), 0, dialog ); msi_free( dialog );
} }
BOOL msi_dialog_register_class( void ) BOOL msi_dialog_register_class( void )

62
dlls/msi/files.c
View File

@ -72,7 +72,7 @@ static UINT create_component_directory( MSIPACKAGE* package, MSICOMPONENT *comp
create_full_pathW(install_path); create_full_pathW(install_path);
folder->State = 2; folder->State = 2;
} }
HeapFree(GetProcessHeap(), 0, install_path); msi_free(install_path);
return rc; return rc;
} }
@ -115,7 +115,7 @@ static UINT writeout_cabinet_stream(MSIPACKAGE *package, LPCWSTR stream_name,
CloseHandle(the_file); CloseHandle(the_file);
TRACE("wrote %li bytes to %s\n",write,debugstr_w(source)); TRACE("wrote %li bytes to %s\n",write,debugstr_w(source));
end: end:
HeapFree(GetProcessHeap(),0,data); msi_free(data);
return rc; return rc;
} }
@ -129,12 +129,12 @@ typedef struct
static void * cabinet_alloc(ULONG cb) static void * cabinet_alloc(ULONG cb)
{ {
return HeapAlloc(GetProcessHeap(), 0, cb); return msi_alloc(cb);
} }
static void cabinet_free(void *pv) static void cabinet_free(void *pv)
{ {
HeapFree(GetProcessHeap(), 0, pv); msi_free(pv);
} }
static INT_PTR cabinet_open(char *pszFile, int oflag, int pmode) static INT_PTR cabinet_open(char *pszFile, int oflag, int pmode)
@ -218,14 +218,14 @@ static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
if (!f) if (!f)
{ {
ERR("Unknown File in Cabinent (%s)\n",debugstr_w(given_file)); ERR("Unknown File in Cabinent (%s)\n",debugstr_w(given_file));
HeapFree(GetProcessHeap(),0,given_file); msi_free(given_file);
return 0; return 0;
} }
if (!((f->State == 1 || f->State == 2))) if (!((f->State == 1 || f->State == 2)))
{ {
TRACE("Skipping extraction of %s\n",debugstr_w(given_file)); TRACE("Skipping extraction of %s\n",debugstr_w(given_file));
HeapFree(GetProcessHeap(),0,given_file); msi_free(given_file);
return 0; return 0;
} }
@ -238,7 +238,7 @@ static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
/* track this file so it can be deleted if not installed */ /* track this file so it can be deleted if not installed */
trackpath=strdupAtoW(file); trackpath=strdupAtoW(file);
tracknametmp=strdupAtoW(strrchr(file,'\\')+1); tracknametmp=strdupAtoW(strrchr(file,'\\')+1);
trackname = HeapAlloc(GetProcessHeap(),0,(strlenW(tracknametmp) + trackname = msi_alloc((strlenW(tracknametmp) +
strlenW(tmpprefix)+1) * sizeof(WCHAR)); strlenW(tmpprefix)+1) * sizeof(WCHAR));
strcpyW(trackname,tmpprefix); strcpyW(trackname,tmpprefix);
@ -246,9 +246,9 @@ static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
track_tempfile(data->package, trackname, trackpath); track_tempfile(data->package, trackname, trackpath);
HeapFree(GetProcessHeap(),0,trackpath); msi_free(trackpath);
HeapFree(GetProcessHeap(),0,trackname); msi_free(trackname);
HeapFree(GetProcessHeap(),0,tracknametmp); msi_free(tracknametmp);
/* the UI chunk */ /* the UI chunk */
uirow=MSI_CreateRecord(9); uirow=MSI_CreateRecord(9);
@ -259,7 +259,7 @@ static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
MSI_RecordSetInteger( uirow, 6, f->FileSize ); MSI_RecordSetInteger( uirow, 6, f->FileSize );
ui_actiondata(data->package,szInstallFiles,uirow); ui_actiondata(data->package,szInstallFiles,uirow);
msiobj_release( &uirow->hdr ); msiobj_release( &uirow->hdr );
HeapFree(GetProcessHeap(),0,uipath); msi_free(uipath);
ui_progress( data->package, 2, f->FileSize, 0, 0); ui_progress( data->package, 2, f->FileSize, 0, 0);
@ -324,7 +324,7 @@ static BOOL extract_cabinet_file(MSIPACKAGE* package, LPCWSTR source,
if (!(cab_path = strdupWtoA( path ))) if (!(cab_path = strdupWtoA( path )))
{ {
FDIDestroy(hfdi); FDIDestroy(hfdi);
HeapFree(GetProcessHeap(), 0, cabinet); msi_free(cabinet);
return FALSE; return FALSE;
} }
@ -338,8 +338,8 @@ static BOOL extract_cabinet_file(MSIPACKAGE* package, LPCWSTR source,
FDIDestroy(hfdi); FDIDestroy(hfdi);
HeapFree(GetProcessHeap(), 0, cabinet); msi_free(cabinet);
HeapFree(GetProcessHeap(), 0, cab_path); msi_free(cab_path);
return ret; return ret;
} }
@ -352,7 +352,7 @@ static VOID set_file_source(MSIPACKAGE* package, MSIFILE* file, MSICOMPONENT*
LPWSTR p; LPWSTR p;
p = resolve_folder(package, comp->Directory, TRUE, FALSE, NULL); p = resolve_folder(package, comp->Directory, TRUE, FALSE, NULL);
file->SourcePath = build_directory_name(2, p, file->ShortName); file->SourcePath = build_directory_name(2, p, file->ShortName);
HeapFree(GetProcessHeap(),0,p); msi_free(p);
} }
else else
file->SourcePath = build_directory_name(2, path, file->File); file->SourcePath = build_directory_name(2, path, file->File);
@ -419,15 +419,15 @@ static UINT ready_volume(MSIPACKAGE* package, LPCWSTR path, LPWSTR last_volume,
prompt = MSI_RecordGetString(row,3); prompt = MSI_RecordGetString(row,3);
msg = generate_error_string(package, 1302, 1, prompt); msg = generate_error_string(package, 1302, 1, prompt);
rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL); rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
HeapFree(GetProcessHeap(),0,volume); msi_free(volume);
HeapFree(GetProcessHeap(),0,msg); msi_free(msg);
if (rc == IDOK) if (rc == IDOK)
ok = check_for_sourcefile(path); ok = check_for_sourcefile(path);
else else
return ERROR_INSTALL_USEREXIT; return ERROR_INSTALL_USEREXIT;
} }
HeapFree(GetProcessHeap(),0,last_volume); msi_free(last_volume);
last_volume = strdupW(volume); last_volume = strdupW(volume);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -457,8 +457,8 @@ static UINT ready_media_for_file(MSIPACKAGE *package, MSIFILE *file,
/* cleanup signal */ /* cleanup signal */
if (!package) if (!package)
{ {
HeapFree(GetProcessHeap(),0,last_path); msi_free(last_path);
HeapFree(GetProcessHeap(),0,last_volume); msi_free(last_volume);
last_sequence = 0; last_sequence = 0;
last_path = NULL; last_path = NULL;
last_volume = NULL; last_volume = NULL;
@ -488,7 +488,7 @@ static UINT ready_media_for_file(MSIPACKAGE *package, MSIFILE *file,
volume = MSI_RecordGetString(row, 5); volume = MSI_RecordGetString(row, 5);
prompt = MSI_RecordGetString(row, 3); prompt = MSI_RecordGetString(row, 3);
HeapFree(GetProcessHeap(),0,last_path); msi_free(last_path);
last_path = NULL; last_path = NULL;
if (file->Attributes & msidbFileAttributesNoncompressed) if (file->Attributes & msidbFileAttributesNoncompressed)
@ -540,12 +540,12 @@ static UINT ready_media_for_file(MSIPACKAGE *package, MSIFILE *file,
MSICODE_PRODUCT|MSISOURCETYPE_NETWORK, MSICODE_PRODUCT|MSISOURCETYPE_NETWORK,
INSTALLPROPERTY_LASTUSEDSOURCEW, path); INSTALLPROPERTY_LASTUSEDSOURCEW, path);
HeapFree(GetProcessHeap(),0,path); msi_free(path);
} }
else else
{ {
sz = MAX_PATH; sz = MAX_PATH;
last_path = HeapAlloc(GetProcessHeap(),0,MAX_PATH*sizeof(WCHAR)); last_path = msi_alloc(MAX_PATH*sizeof(WCHAR));
if (MSI_GetPropertyW(package, cszSourceDir, source, &sz)) if (MSI_GetPropertyW(package, cszSourceDir, source, &sz))
{ {
ERR("No Source dir defined \n"); ERR("No Source dir defined \n");
@ -581,7 +581,7 @@ static UINT ready_media_for_file(MSIPACKAGE *package, MSIFILE *file,
else else
{ {
sz = MAX_PATH; sz = MAX_PATH;
last_path = HeapAlloc(GetProcessHeap(),0,MAX_PATH*sizeof(WCHAR)); last_path = msi_alloc(MAX_PATH*sizeof(WCHAR));
MSI_GetPropertyW(package,cszSourceDir,source,&sz); MSI_GetPropertyW(package,cszSourceDir,source,&sz);
strcpyW(last_path,source); strcpyW(last_path,source);
rc = ready_volume(package, last_path, last_volume, row, &type); rc = ready_volume(package, last_path, last_volume, row, &type);
@ -699,10 +699,10 @@ UINT ACTION_InstallFiles(MSIPACKAGE *package)
} }
p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL); p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
HeapFree(GetProcessHeap(),0,file->TargetPath); msi_free(file->TargetPath);
file->TargetPath = build_directory_name(2, p, file->FileName); file->TargetPath = build_directory_name(2, p, file->FileName);
HeapFree(GetProcessHeap(),0,p); msi_free(p);
} }
} }
@ -808,7 +808,7 @@ static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
if (rc != ERROR_SUCCESS) if (rc != ERROR_SUCCESS)
{ {
ERR("Original file unknown %s\n",debugstr_w(file_key)); ERR("Original file unknown %s\n",debugstr_w(file_key));
HeapFree(GetProcessHeap(),0,file_source); msi_free(file_source);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -841,7 +841,7 @@ static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
if (!dest_path) if (!dest_path)
{ {
FIXME("Unable to get destination folder, try AppSearch properties\n"); FIXME("Unable to get destination folder, try AppSearch properties\n");
HeapFree(GetProcessHeap(),0,file_source); msi_free(file_source);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
} }
@ -862,9 +862,9 @@ static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
FIXME("We should track these duplicate files as well\n"); FIXME("We should track these duplicate files as well\n");
HeapFree(GetProcessHeap(),0,dest_path); msi_free(dest_path);
HeapFree(GetProcessHeap(),0,dest); msi_free(dest);
HeapFree(GetProcessHeap(),0,file_source); msi_free(file_source);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }

56
dlls/msi/format.c
View File

@ -56,7 +56,7 @@ static LPWSTR build_default_format(MSIRECORD* record)
count = MSI_RecordGetFieldCount(record); count = MSI_RecordGetFieldCount(record);
rc = HeapAlloc(GetProcessHeap(),0,(11*count)*sizeof(WCHAR)); rc = msi_alloc((11*count)*sizeof(WCHAR));
rc[0] = 0; rc[0] = 0;
for (i = 1; i <= count; i++) for (i = 1; i <= count; i++)
{ {
@ -124,7 +124,7 @@ static LPWSTR deformat_file(MSIPACKAGE* package, LPCWSTR key, DWORD* sz,
{ {
*sz = (size-1) * sizeof (WCHAR); *sz = (size-1) * sizeof (WCHAR);
size ++; size ++;
value = HeapAlloc(GetProcessHeap(),0,size * sizeof(WCHAR)); value = msi_alloc(size * sizeof(WCHAR));
GetShortPathNameW( file->TargetPath, value, size ); GetShortPathNameW( file->TargetPath, value, size );
} }
else else
@ -150,7 +150,7 @@ static LPWSTR deformat_environment(MSIPACKAGE* package, LPCWSTR key,
if (sz > 0) if (sz > 0)
{ {
sz++; sz++;
value = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR)); value = msi_alloc(sz * sizeof(WCHAR));
GetEnvironmentVariableW(&key[1],value,sz); GetEnvironmentVariableW(&key[1],value,sz);
*chunk = (strlenW(value)) * sizeof(WCHAR); *chunk = (strlenW(value)) * sizeof(WCHAR);
} }
@ -168,7 +168,7 @@ static LPWSTR deformat_NULL(DWORD* chunk)
{ {
LPWSTR value; LPWSTR value;
value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2); value = msi_alloc(sizeof(WCHAR)*2);
value[0] = 0; value[0] = 0;
*chunk = sizeof(WCHAR); *chunk = sizeof(WCHAR);
return value; return value;
@ -178,7 +178,7 @@ static LPWSTR deformat_escape(LPCWSTR key, DWORD* chunk)
{ {
LPWSTR value; LPWSTR value;
value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2); value = msi_alloc(sizeof(WCHAR)*2);
value[0] = key[0]; value[0] = key[0];
*chunk = sizeof(WCHAR); *chunk = sizeof(WCHAR);
@ -260,7 +260,7 @@ static BOOL find_next_group(LPCWSTR source, DWORD len_remaining,
*mark2 = &(*mark)[i]; *mark2 = &(*mark)[i];
i = *mark2 - *mark; i = *mark2 - *mark;
*group = HeapAlloc(GetProcessHeap(),0,i*sizeof(WCHAR)); *group = msi_alloc(i*sizeof(WCHAR));
i -= 1; i -= 1;
memcpy(*group,&(*mark)[1],i*sizeof(WCHAR)); memcpy(*group,&(*mark)[1],i*sizeof(WCHAR));
@ -306,7 +306,7 @@ static BOOL find_next_outermost_key(LPCWSTR source, DWORD len_remaining,
*mark2 = &(*mark)[i-1]; *mark2 = &(*mark)[i-1];
i = *mark2 - *mark; i = *mark2 - *mark;
*key = HeapAlloc(GetProcessHeap(),0,i*sizeof(WCHAR)); *key = msi_alloc(i*sizeof(WCHAR));
/* do not have the [] in the key */ /* do not have the [] in the key */
i -= 1; i -= 1;
memcpy(*key,&(*mark)[1],i*sizeof(WCHAR)); memcpy(*key,&(*mark)[1],i*sizeof(WCHAR));
@ -319,7 +319,7 @@ static BOOL find_next_outermost_key(LPCWSTR source, DWORD len_remaining,
static LPWSTR deformat_group(MSIPACKAGE* package, LPWSTR group, DWORD len, static LPWSTR deformat_group(MSIPACKAGE* package, LPWSTR group, DWORD len,
MSIRECORD* record, DWORD* size) MSIRECORD* record, DWORD* size)
{ {
LPWSTR value; LPWSTR value = NULL;
LPCWSTR mark, mark2; LPCWSTR mark, mark2;
LPWSTR key; LPWSTR key;
BOOL nested; BOOL nested;
@ -337,14 +337,14 @@ static LPWSTR deformat_group(MSIPACKAGE* package, LPWSTR group, DWORD len,
if (!find_next_outermost_key(group, len, &key, &mark, &mark2, &nested)) if (!find_next_outermost_key(group, len, &key, &mark, &mark2, &nested))
{ {
*size = (len+2)*sizeof(WCHAR); *size = (len+2)*sizeof(WCHAR);
value = HeapAlloc(GetProcessHeap(),0,*size); value = msi_alloc(*size);
sprintfW(value,fmt,group); sprintfW(value,fmt,group);
/* do not return size of the null at the end */ /* do not return size of the null at the end */
*size = (len+1)*sizeof(WCHAR); *size = (len+1)*sizeof(WCHAR);
return value; return value;
} }
HeapFree(GetProcessHeap(),0,key); msi_free(key);
failcount = 0; failcount = 0;
sz = deformat_string_internal(package, group, &value, strlenW(group), sz = deformat_string_internal(package, group, &value, strlenW(group),
record, &failcount); record, &failcount);
@ -357,11 +357,11 @@ static LPWSTR deformat_group(MSIPACKAGE* package, LPWSTR group, DWORD len,
{ {
LPWSTR v2; LPWSTR v2;
v2 = HeapAlloc(GetProcessHeap(),0,(sz+2)*sizeof(WCHAR)); v2 = msi_alloc((sz+2)*sizeof(WCHAR));
v2[0] = '{'; v2[0] = '{';
memcpy(&v2[1],value,sz*sizeof(WCHAR)); memcpy(&v2[1],value,sz*sizeof(WCHAR));
v2[sz+1]='}'; v2[sz+1]='}';
HeapFree(GetProcessHeap(),0,value); msi_free(value);
*size = (sz+2)*sizeof(WCHAR); *size = (sz+2)*sizeof(WCHAR);
return v2; return v2;
@ -407,7 +407,7 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
(scanW(ptr,'{',len) && !scanW(ptr,'}',len))) (scanW(ptr,'{',len) && !scanW(ptr,'}',len)))
{ {
/* not formatted */ /* not formatted */
*data = HeapAlloc(GetProcessHeap(),0,(len*sizeof(WCHAR))); *data = msi_alloc((len*sizeof(WCHAR)));
memcpy(*data,ptr,len*sizeof(WCHAR)); memcpy(*data,ptr,len*sizeof(WCHAR));
TRACE("Returning %s\n",debugstr_wn(*data,len)); TRACE("Returning %s\n",debugstr_wn(*data,len));
return len; return len;
@ -437,9 +437,9 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
chunk = (len - (progress - ptr)) * sizeof(WCHAR); chunk = (len - (progress - ptr)) * sizeof(WCHAR);
TRACE("after chunk is %li + %li\n",size,chunk); TRACE("after chunk is %li + %li\n",size,chunk);
if (size) if (size)
nd2 = HeapReAlloc(GetProcessHeap(),0,newdata,(size+chunk)); nd2 = msi_realloc(newdata,(size+chunk));
else else
nd2 = HeapAlloc(GetProcessHeap(),0,chunk); nd2 = msi_alloc(chunk);
newdata = nd2; newdata = nd2;
memcpy(&newdata[size],progress,chunk); memcpy(&newdata[size],progress,chunk);
@ -455,9 +455,9 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
TRACE("%i (%i) characters before marker\n",cnt,(mark-progress)); TRACE("%i (%i) characters before marker\n",cnt,(mark-progress));
size += cnt * sizeof(WCHAR); size += cnt * sizeof(WCHAR);
if (!old_size) if (!old_size)
tgt = HeapAlloc(GetProcessHeap(),0,size); tgt = msi_alloc(size);
else else
tgt = HeapReAlloc(GetProcessHeap(),0,newdata,size); tgt = msi_realloc(newdata,size);
newdata = tgt; newdata = tgt;
memcpy(&newdata[old_size],progress,(cnt * sizeof(WCHAR))); memcpy(&newdata[old_size],progress,(cnt * sizeof(WCHAR)));
} }
@ -470,7 +470,7 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
deformat_string_internal(package, key, &value, strlenW(key)+1, deformat_string_internal(package, key, &value, strlenW(key)+1,
record, failcount); record, failcount);
HeapFree(GetProcessHeap(),0,key); msi_free(key);
key = value; key = value;
} }
@ -494,7 +494,7 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
{ {
DWORD keylen = strlenW(key); DWORD keylen = strlenW(key);
chunk = (keylen + 2)*sizeof(WCHAR); chunk = (keylen + 2)*sizeof(WCHAR);
value = HeapAlloc(GetProcessHeap(),0,chunk); value = msi_alloc(chunk);
value[0] = '['; value[0] = '[';
memcpy(&value[1],key,keylen*sizeof(WCHAR)); memcpy(&value[1],key,keylen*sizeof(WCHAR));
value[1+keylen] = ']'; value[1+keylen] = ']';
@ -532,7 +532,7 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
else else
{ {
static const WCHAR fmt[] = {'[','%','s',']',0}; static const WCHAR fmt[] = {'[','%','s',']',0};
value = HeapAlloc(GetProcessHeap(),0,10); value = msi_alloc(10);
sprintfW(value,fmt,key); sprintfW(value,fmt,key);
chunk = strlenW(value)*sizeof(WCHAR); chunk = strlenW(value)*sizeof(WCHAR);
} }
@ -542,7 +542,7 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
} }
} }
HeapFree(GetProcessHeap(),0,key); msi_free(key);
if (value!=NULL) if (value!=NULL)
{ {
@ -550,13 +550,13 @@ static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
TRACE("value %s, chunk %li size %li\n",debugstr_w((LPWSTR)value), TRACE("value %s, chunk %li size %li\n",debugstr_w((LPWSTR)value),
chunk, size); chunk, size);
if (size) if (size)
nd2= HeapReAlloc(GetProcessHeap(),0,newdata,(size + chunk)); nd2= msi_realloc(newdata,(size + chunk));
else else
nd2= HeapAlloc(GetProcessHeap(),0,chunk); nd2= msi_alloc(chunk);
newdata = nd2; newdata = nd2;
memcpy(&newdata[size],value,chunk); memcpy(&newdata[size],value,chunk);
size+=chunk; size+=chunk;
HeapFree(GetProcessHeap(),0,value); msi_free(value);
} }
else if (failcount && *failcount >=0 ) else if (failcount && *failcount >=0 )
(*failcount)++; (*failcount)++;
@ -614,8 +614,8 @@ UINT MSI_FormatRecordW( MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
*size = len; *size = len;
HeapFree(GetProcessHeap(),0,rec); msi_free(rec);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
return rc; return rc;
} }
@ -658,8 +658,8 @@ UINT MSI_FormatRecordA( MSIPACKAGE* package, MSIRECORD* record, LPSTR buffer,
*size = lenA; *size = lenA;
HeapFree(GetProcessHeap(),0,rec); msi_free(rec);
HeapFree(GetProcessHeap(),0,deformated); msi_free(deformated);
return rc; return rc;
} }

185
dlls/msi/helpers.c
View File

@ -104,8 +104,8 @@ UINT build_icon_path(MSIPACKAGE *package, LPCWSTR icon_name,
*FilePath = build_directory_name(2, dest, icon_name); *FilePath = build_directory_name(2, dest, icon_name);
HeapFree(GetProcessHeap(),0,SystemFolder); msi_free(SystemFolder);
HeapFree(GetProcessHeap(),0,dest); msi_free(dest);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -124,18 +124,18 @@ WCHAR *load_dynamic_stringW(MSIRECORD *row, INT index)
/* having an empty string is different than NULL */ /* having an empty string is different than NULL */
if (sz == 0) if (sz == 0)
{ {
ret = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)); ret = msi_alloc(sizeof(WCHAR));
ret[0] = 0; ret[0] = 0;
return ret; return ret;
} }
sz ++; sz ++;
ret = HeapAlloc(GetProcessHeap(),0,sz * sizeof (WCHAR)); ret = msi_alloc(sz * sizeof (WCHAR));
rc = MSI_RecordGetStringW(row,index,ret,&sz); rc = MSI_RecordGetStringW(row,index,ret,&sz);
if (rc!=ERROR_SUCCESS) if (rc!=ERROR_SUCCESS)
{ {
ERR("Unable to load dynamic string\n"); ERR("Unable to load dynamic string\n");
HeapFree(GetProcessHeap(), 0, ret); msi_free(ret);
ret = NULL; ret = NULL;
} }
return ret; return ret;
@ -152,11 +152,11 @@ LPWSTR msi_dup_property(MSIPACKAGE *package, LPCWSTR prop)
return NULL; return NULL;
sz++; sz++;
str = HeapAlloc(GetProcessHeap(),0,sz*sizeof(WCHAR)); str = msi_alloc(sz*sizeof(WCHAR));
r = MSI_GetPropertyW(package, prop, str, &sz); r = MSI_GetPropertyW(package, prop, str, &sz);
if (r != ERROR_SUCCESS) if (r != ERROR_SUCCESS)
{ {
HeapFree(GetProcessHeap(),0,str); msi_free(str);
str = NULL; str = NULL;
} }
return str; return str;
@ -215,7 +215,7 @@ int track_tempfile( MSIPACKAGE *package, LPCWSTR name, LPCWSTR path )
} }
} }
temp = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (MSITEMPFILE) ); temp = msi_alloc_zero( sizeof (MSITEMPFILE) );
if (!temp) if (!temp)
return -1; return -1;
@ -271,7 +271,7 @@ LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name, BOOL source,
path = build_directory_name(2, check_path, NULL); path = build_directory_name(2, check_path, NULL);
if (strcmpiW(path,check_path)!=0) if (strcmpiW(path,check_path)!=0)
MSI_SetPropertyW(package,cszTargetDir,path); MSI_SetPropertyW(package,cszTargetDir,path);
HeapFree(GetProcessHeap(),0,check_path); msi_free(check_path);
} }
else else
{ {
@ -347,7 +347,7 @@ LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name, BOOL source,
TRACE(" (source)resolved into %s\n",debugstr_w(path)); TRACE(" (source)resolved into %s\n",debugstr_w(path));
f->ResolvedSource = strdupW( path ); f->ResolvedSource = strdupW( path );
} }
HeapFree(GetProcessHeap(),0,p); msi_free(p);
} }
return path; return path;
} }
@ -365,7 +365,7 @@ DWORD deformat_string(MSIPACKAGE *package, LPCWSTR ptr, WCHAR** data )
if (size >= 0) if (size >= 0)
{ {
size++; size++;
*data = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR)); *data = msi_alloc(size*sizeof(WCHAR));
if (size > 1) if (size > 1)
MSI_FormatRecordW(package,rec,*data,&size); MSI_FormatRecordW(package,rec,*data,&size);
else else
@ -394,11 +394,10 @@ UINT schedule_action(MSIPACKAGE *package, UINT script, LPCWSTR action)
count = package->script->ActionCount[script]; count = package->script->ActionCount[script];
package->script->ActionCount[script]++; package->script->ActionCount[script]++;
if (count != 0) if (count != 0)
newbuf = HeapReAlloc(GetProcessHeap(),0, newbuf = msi_realloc( package->script->Actions[script],
package->script->Actions[script],
package->script->ActionCount[script]* sizeof(LPWSTR)); package->script->ActionCount[script]* sizeof(LPWSTR));
else else
newbuf = HeapAlloc(GetProcessHeap(),0, sizeof(LPWSTR)); newbuf = msi_alloc( sizeof(LPWSTR));
newbuf[count] = strdupW(action); newbuf[count] = strdupW(action);
package->script->Actions[script] = newbuf; package->script->Actions[script] = newbuf;
@ -417,9 +416,9 @@ static void remove_tracked_tempfiles(MSIPACKAGE* package)
list_remove( &temp->entry ); list_remove( &temp->entry );
TRACE("deleting temp file %s\n", debugstr_w( temp->Path )); TRACE("deleting temp file %s\n", debugstr_w( temp->Path ));
DeleteFileW( temp->Path ); DeleteFileW( temp->Path );
HeapFree( GetProcessHeap(), 0, temp->File ); msi_free( temp->File );
HeapFree( GetProcessHeap(), 0, temp->Path ); msi_free( temp->Path );
HeapFree( GetProcessHeap(), 0, temp ); msi_free( temp );
} }
} }
@ -431,14 +430,14 @@ static void free_feature( MSIFEATURE *feature )
{ {
ComponentList *cl = LIST_ENTRY( item, ComponentList, entry ); ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
list_remove( &cl->entry ); list_remove( &cl->entry );
HeapFree( GetProcessHeap(), 0, cl ); msi_free( cl );
} }
HeapFree( GetProcessHeap(), 0, feature->Feature ); msi_free( feature->Feature );
HeapFree( GetProcessHeap(), 0, feature->Feature_Parent ); msi_free( feature->Feature_Parent );
HeapFree( GetProcessHeap(), 0, feature->Directory ); msi_free( feature->Directory );
HeapFree( GetProcessHeap(), 0, feature->Description ); msi_free( feature->Description );
HeapFree( GetProcessHeap(), 0, feature->Title ); msi_free( feature->Title );
HeapFree( GetProcessHeap(), 0, feature ); msi_free( feature );
} }
void free_extension( MSIEXTENSION *ext ) void free_extension( MSIEXTENSION *ext )
@ -450,15 +449,15 @@ void free_extension( MSIEXTENSION *ext )
MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry ); MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
list_remove( &verb->entry ); list_remove( &verb->entry );
HeapFree( GetProcessHeap(), 0, verb->Verb ); msi_free( verb->Verb );
HeapFree( GetProcessHeap(), 0, verb->Command ); msi_free( verb->Command );
HeapFree( GetProcessHeap(), 0, verb->Argument ); msi_free( verb->Argument );
HeapFree( GetProcessHeap(), 0, verb ); msi_free( verb );
} }
HeapFree( GetProcessHeap(), 0, ext->Extension ); msi_free( ext->Extension );
HeapFree( GetProcessHeap(), 0, ext->ProgIDText ); msi_free( ext->ProgIDText );
HeapFree( GetProcessHeap(), 0, ext ); msi_free( ext );
} }
/* Called when the package is being closed */ /* Called when the package is being closed */
@ -483,12 +482,12 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry ); MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
list_remove( &folder->entry ); list_remove( &folder->entry );
HeapFree( GetProcessHeap(), 0, folder->Directory ); msi_free( folder->Directory );
HeapFree( GetProcessHeap(), 0, folder->TargetDefault ); msi_free( folder->TargetDefault );
HeapFree( GetProcessHeap(), 0, folder->SourceDefault ); msi_free( folder->SourceDefault );
HeapFree( GetProcessHeap(), 0, folder->ResolvedTarget ); msi_free( folder->ResolvedTarget );
HeapFree( GetProcessHeap(), 0, folder->ResolvedSource ); msi_free( folder->ResolvedSource );
HeapFree( GetProcessHeap(), 0, folder->Property ); msi_free( folder->Property );
} }
LIST_FOR_EACH_SAFE( item, cursor, &package->components ) LIST_FOR_EACH_SAFE( item, cursor, &package->components )
@ -496,13 +495,13 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry ); MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
list_remove( &comp->entry ); list_remove( &comp->entry );
HeapFree( GetProcessHeap(), 0, comp->Component ); msi_free( comp->Component );
HeapFree( GetProcessHeap(), 0, comp->ComponentId ); msi_free( comp->ComponentId );
HeapFree( GetProcessHeap(), 0, comp->Directory ); msi_free( comp->Directory );
HeapFree( GetProcessHeap(), 0, comp->Condition ); msi_free( comp->Condition );
HeapFree( GetProcessHeap(), 0, comp->KeyPath ); msi_free( comp->KeyPath );
HeapFree( GetProcessHeap(), 0, comp->FullKeypath ); msi_free( comp->FullKeypath );
HeapFree( GetProcessHeap(), 0, comp ); msi_free( comp );
} }
LIST_FOR_EACH_SAFE( item, cursor, &package->files ) LIST_FOR_EACH_SAFE( item, cursor, &package->files )
@ -510,14 +509,14 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry ); MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
list_remove( &file->entry ); list_remove( &file->entry );
HeapFree( GetProcessHeap(), 0, file->File ); msi_free( file->File );
HeapFree( GetProcessHeap(), 0, file->FileName ); msi_free( file->FileName );
HeapFree( GetProcessHeap(), 0, file->ShortName ); msi_free( file->ShortName );
HeapFree( GetProcessHeap(), 0, file->Version ); msi_free( file->Version );
HeapFree( GetProcessHeap(), 0, file->Language ); msi_free( file->Language );
HeapFree( GetProcessHeap(), 0, file->SourcePath ); msi_free( file->SourcePath );
HeapFree( GetProcessHeap(), 0, file->TargetPath ); msi_free( file->TargetPath );
HeapFree( GetProcessHeap(), 0, file ); msi_free( file );
} }
/* clean up extension, progid, class and verb structures */ /* clean up extension, progid, class and verb structures */
@ -526,16 +525,16 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry ); MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
list_remove( &cls->entry ); list_remove( &cls->entry );
HeapFree( GetProcessHeap(), 0, cls->clsid ); msi_free( cls->clsid );
HeapFree( GetProcessHeap(), 0, cls->Context ); msi_free( cls->Context );
HeapFree( GetProcessHeap(), 0, cls->Description ); msi_free( cls->Description );
HeapFree( GetProcessHeap(), 0, cls->FileTypeMask ); msi_free( cls->FileTypeMask );
HeapFree( GetProcessHeap(), 0, cls->IconPath ); msi_free( cls->IconPath );
HeapFree( GetProcessHeap(), 0, cls->DefInprocHandler ); msi_free( cls->DefInprocHandler );
HeapFree( GetProcessHeap(), 0, cls->DefInprocHandler32 ); msi_free( cls->DefInprocHandler32 );
HeapFree( GetProcessHeap(), 0, cls->Argument ); msi_free( cls->Argument );
HeapFree( GetProcessHeap(), 0, cls->ProgIDText ); msi_free( cls->ProgIDText );
HeapFree( GetProcessHeap(), 0, cls ); msi_free( cls );
} }
LIST_FOR_EACH_SAFE( item, cursor, &package->extensions ) LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
@ -551,10 +550,10 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry ); MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
list_remove( &progid->entry ); list_remove( &progid->entry );
HeapFree( GetProcessHeap(), 0, progid->ProgID ); msi_free( progid->ProgID );
HeapFree( GetProcessHeap(), 0, progid->Description ); msi_free( progid->Description );
HeapFree( GetProcessHeap(), 0, progid->IconPath ); msi_free( progid->IconPath );
HeapFree( GetProcessHeap(), 0, progid ); msi_free( progid );
} }
LIST_FOR_EACH_SAFE( item, cursor, &package->mimes ) LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
@ -562,9 +561,9 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry ); MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
list_remove( &mt->entry ); list_remove( &mt->entry );
HeapFree( GetProcessHeap(), 0, mt->clsid ); msi_free( mt->clsid );
HeapFree( GetProcessHeap(), 0, mt->ContentType ); msi_free( mt->ContentType );
HeapFree( GetProcessHeap(), 0, mt ); msi_free( mt );
} }
LIST_FOR_EACH_SAFE( item, cursor, &package->appids ) LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
@ -572,12 +571,12 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry ); MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
list_remove( &appid->entry ); list_remove( &appid->entry );
HeapFree( GetProcessHeap(), 0, appid->AppID ); msi_free( appid->AppID );
HeapFree( GetProcessHeap(), 0, appid->RemoteServerName ); msi_free( appid->RemoteServerName );
HeapFree( GetProcessHeap(), 0, appid->LocalServer ); msi_free( appid->LocalServer );
HeapFree( GetProcessHeap(), 0, appid->ServiceParameters ); msi_free( appid->ServiceParameters );
HeapFree( GetProcessHeap(), 0, appid->DllSurrogate ); msi_free( appid->DllSurrogate );
HeapFree( GetProcessHeap(), 0, appid ); msi_free( appid );
} }
if (package->script) if (package->script)
@ -586,21 +585,21 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
{ {
int j; int j;
for (j = 0; j < package->script->ActionCount[i]; j++) for (j = 0; j < package->script->ActionCount[i]; j++)
HeapFree(GetProcessHeap(),0,package->script->Actions[i][j]); msi_free(package->script->Actions[i][j]);
HeapFree(GetProcessHeap(),0,package->script->Actions[i]); msi_free(package->script->Actions[i]);
} }
for (i = 0; i < package->script->UniqueActionsCount; i++) for (i = 0; i < package->script->UniqueActionsCount; i++)
HeapFree(GetProcessHeap(),0,package->script->UniqueActions[i]); msi_free(package->script->UniqueActions[i]);
HeapFree(GetProcessHeap(),0,package->script->UniqueActions); msi_free(package->script->UniqueActions);
HeapFree(GetProcessHeap(),0,package->script); msi_free(package->script);
} }
HeapFree(GetProcessHeap(),0,package->PackagePath); msi_free(package->PackagePath);
HeapFree(GetProcessHeap(),0,package->msiFilePath); msi_free(package->msiFilePath);
HeapFree(GetProcessHeap(),0,package->ProductCode); msi_free(package->ProductCode);
/* cleanup control event subscriptions */ /* cleanup control event subscriptions */
ControlEvent_CleanupSubscriptions(package); ControlEvent_CleanupSubscriptions(package);
@ -641,7 +640,7 @@ LPWSTR build_directory_name(DWORD count, ...)
} }
va_end(va); va_end(va);
dir = HeapAlloc(GetProcessHeap(), 0, sz*sizeof(WCHAR)); dir = msi_alloc(sz*sizeof(WCHAR));
dir[0]=0; dir[0]=0;
va_start(va,count); va_start(va,count);
@ -670,8 +669,7 @@ BOOL create_full_pathW(const WCHAR *path)
int len; int len;
WCHAR *new_path; WCHAR *new_path;
new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * new_path = msi_alloc( (strlenW(path) + 1) * sizeof(WCHAR));
sizeof(WCHAR));
strcpyW(new_path, path); strcpyW(new_path, path);
@ -707,7 +705,7 @@ BOOL create_full_pathW(const WCHAR *path)
new_path[len] = '\\'; new_path[len] = '\\';
} }
HeapFree(GetProcessHeap(), 0, new_path); msi_free(new_path);
return ret; return ret;
} }
@ -752,10 +750,10 @@ void ui_actiondata(MSIPACKAGE *package, LPCWSTR action, MSIRECORD * record)
} }
/* update the cached actionformat */ /* update the cached actionformat */
HeapFree(GetProcessHeap(),0,package->ActionFormat); msi_free(package->ActionFormat);
package->ActionFormat = load_dynamic_stringW(row,3); package->ActionFormat = load_dynamic_stringW(row,3);
HeapFree(GetProcessHeap(),0,package->LastAction); msi_free(package->LastAction);
package->LastAction = strdupW(action); package->LastAction = strdupW(action);
msiobj_release(&row->hdr); msiobj_release(&row->hdr);
@ -857,7 +855,7 @@ LPWSTR create_component_advertise_string(MSIPACKAGE* package,
sz+=3; sz+=3;
sz *= sizeof(WCHAR); sz *= sizeof(WCHAR);
output = HeapAlloc(GetProcessHeap(),0,sz); output = msi_alloc(sz);
memset(output,0,sz); memset(output,0,sz);
if (component) if (component)
@ -945,11 +943,10 @@ UINT register_unique_action(MSIPACKAGE *package, LPCWSTR action)
count = package->script->UniqueActionsCount; count = package->script->UniqueActionsCount;
package->script->UniqueActionsCount++; package->script->UniqueActionsCount++;
if (count != 0) if (count != 0)
newbuf = HeapReAlloc(GetProcessHeap(),0, newbuf = msi_realloc( package->script->UniqueActions,
package->script->UniqueActions,
package->script->UniqueActionsCount* sizeof(LPWSTR)); package->script->UniqueActionsCount* sizeof(LPWSTR));
else else
newbuf = HeapAlloc(GetProcessHeap(),0, sizeof(LPWSTR)); newbuf = msi_alloc( sizeof(LPWSTR));
newbuf[count] = strdupW(action); newbuf[count] = strdupW(action);
package->script->UniqueActions = newbuf; package->script->UniqueActions = newbuf;
@ -1006,7 +1003,7 @@ WCHAR* generate_error_string(MSIPACKAGE *package, UINT error, DWORD count, ... )
if (size >= 0) if (size >= 0)
{ {
size++; size++;
data = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR)); data = msi_alloc(size*sizeof(WCHAR));
if (size > 1) if (size > 1)
MSI_FormatRecordW(package,rec,data,&size); MSI_FormatRecordW(package,rec,data,&size);
else else

38
dlls/msi/install.c
View File

@ -50,7 +50,7 @@ UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction )
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
ret = MsiDoActionW( hInstall, szwAction ); ret = MsiDoActionW( hInstall, szwAction );
HeapFree( GetProcessHeap(), 0, szwAction ); msi_free( szwAction );
return ret; return ret;
} }
@ -148,7 +148,7 @@ UINT WINAPI MSI_GetTargetPath( MSIHANDLE hInstall, LPCWSTR szFolder,
return ERROR_DIRECTORY; return ERROR_DIRECTORY;
r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf ); r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf );
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
return r; return r;
} }
@ -173,7 +173,7 @@ UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
r = MSI_GetTargetPath( hInstall, szwFolder, &path, pcchPathBuf ); r = MSI_GetTargetPath( hInstall, szwFolder, &path, pcchPathBuf );
HeapFree( GetProcessHeap(), 0, szwFolder ); msi_free( szwFolder );
return r; return r;
} }
@ -227,7 +227,7 @@ static UINT MSI_GetSourcePath( MSIHANDLE hInstall, LPCWSTR szFolder,
return ERROR_DIRECTORY; return ERROR_DIRECTORY;
r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf ); r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf );
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
return r; return r;
} }
@ -248,7 +248,7 @@ UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder,
folder = strdupAtoW( szFolder ); folder = strdupAtoW( szFolder );
r = MSI_GetSourcePath( hInstall, folder, &str, pcchPathBuf ); r = MSI_GetSourcePath( hInstall, folder, &str, pcchPathBuf );
HeapFree( GetProcessHeap(), 0, folder ); msi_free( folder );
return r; return r;
} }
@ -291,14 +291,14 @@ UINT WINAPI MsiSetTargetPathA(MSIHANDLE hInstall, LPCSTR szFolder,
szwFolderPath = strdupAtoW(szFolderPath); szwFolderPath = strdupAtoW(szFolderPath);
if (!szwFolderPath) if (!szwFolderPath)
{ {
HeapFree(GetProcessHeap(),0,szwFolder); msi_free(szwFolder);
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }
rc = MsiSetTargetPathW(hInstall, szwFolder, szwFolderPath); rc = MsiSetTargetPathW(hInstall, szwFolder, szwFolderPath);
HeapFree(GetProcessHeap(),0,szwFolder); msi_free(szwFolder);
HeapFree(GetProcessHeap(),0,szwFolderPath); msi_free(szwFolderPath);
return rc; return rc;
} }
@ -343,7 +343,7 @@ UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
RemoveDirectoryW(szFolderPath); RemoveDirectoryW(szFolderPath);
} }
HeapFree(GetProcessHeap(),0,folder->Property); msi_free(folder->Property);
folder->Property = build_directory_name(2, szFolderPath, NULL); folder->Property = build_directory_name(2, szFolderPath, NULL);
if (lstrcmpiW(path, folder->Property) == 0) if (lstrcmpiW(path, folder->Property) == 0)
@ -352,10 +352,10 @@ UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
* Resolved Target has not really changed, so just * Resolved Target has not really changed, so just
* set this folder and do not recalculate everything. * set this folder and do not recalculate everything.
*/ */
HeapFree(GetProcessHeap(),0,folder->ResolvedTarget); msi_free(folder->ResolvedTarget);
folder->ResolvedTarget = NULL; folder->ResolvedTarget = NULL;
path2 = resolve_folder(package,szFolder,FALSE,TRUE,NULL); path2 = resolve_folder(package,szFolder,FALSE,TRUE,NULL);
HeapFree(GetProcessHeap(),0,path2); msi_free(path2);
} }
else else
{ {
@ -363,17 +363,17 @@ UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry ) LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry )
{ {
HeapFree( GetProcessHeap(),0,f->ResolvedTarget); msi_free(f->ResolvedTarget);
f->ResolvedTarget=NULL; f->ResolvedTarget=NULL;
} }
LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry ) LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry )
{ {
path2 = resolve_folder(package, f->Directory, FALSE, TRUE, NULL); path2 = resolve_folder(package, f->Directory, FALSE, TRUE, NULL);
HeapFree(GetProcessHeap(),0,path2); msi_free(path2);
} }
} }
HeapFree(GetProcessHeap(),0,path); msi_free(path);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -454,7 +454,7 @@ UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
rc = MsiSetFeatureStateW(hInstall,szwFeature, iState); rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
HeapFree(GetProcessHeap(),0,szwFeature); msi_free(szwFeature);
return rc; return rc;
} }
@ -526,7 +526,7 @@ UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPSTR szFeature,
rc = MsiGetFeatureStateW(hInstall,szwFeature,piInstalled, piAction); rc = MsiGetFeatureStateW(hInstall,szwFeature,piInstalled, piAction);
HeapFree( GetProcessHeap(), 0 , szwFeature); msi_free( szwFeature);
return rc; return rc;
} }
@ -582,7 +582,7 @@ UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
rc = MsiSetComponentStateW(hInstall, szwComponent, iState); rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
HeapFree(GetProcessHeap(), 0, szwComponent); msi_free(szwComponent);
return rc; return rc;
} }
@ -600,7 +600,7 @@ UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPSTR szComponent,
rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction); rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
HeapFree( GetProcessHeap(), 0 , szwComponent); msi_free( szwComponent);
return rc; return rc;
} }
@ -699,7 +699,7 @@ LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall)
buffer = msi_dup_property( package, szProductLanguage ); buffer = msi_dup_property( package, szProductLanguage );
langid = atoiW(buffer); langid = atoiW(buffer);
HeapFree(GetProcessHeap(),0,buffer); msi_free(buffer);
msiobj_release (&package->hdr); msiobj_release (&package->hdr);
return langid; return langid;
} }

102
dlls/msi/msi.c
View File

@ -76,7 +76,7 @@ UINT WINAPI MsiOpenProductA(LPCSTR szProduct, MSIHANDLE *phProduct)
r = MsiOpenProductW( szwProd, phProduct ); r = MsiOpenProductW( szwProd, phProduct );
HeapFree( GetProcessHeap(), 0, szwProd ); msi_free( szwProd );
return r; return r;
} }
@ -108,7 +108,7 @@ UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
} }
/* now alloc and fetch the path of the database to open */ /* now alloc and fetch the path of the database to open */
path = HeapAlloc( GetProcessHeap(), 0, count ); path = msi_alloc( count );
if( !path ) if( !path )
goto end; goto end;
@ -123,7 +123,7 @@ UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
r = MsiOpenPackageW( path, phProduct ); r = MsiOpenPackageW( path, phProduct );
end: end:
HeapFree( GetProcessHeap(), 0, path ); msi_free( path );
if( hKeyProduct ) if( hKeyProduct )
RegCloseKey( hKeyProduct ); RegCloseKey( hKeyProduct );
@ -188,8 +188,8 @@ UINT WINAPI MsiInstallProductA(LPCSTR szPackagePath, LPCSTR szCommandLine)
r = MsiInstallProductW( szwPath, szwCommand ); r = MsiInstallProductW( szwPath, szwCommand );
end: end:
HeapFree( GetProcessHeap(), 0, szwPath ); msi_free( szwPath );
HeapFree( GetProcessHeap(), 0, szwCommand ); msi_free( szwCommand );
return r; return r;
} }
@ -322,7 +322,7 @@ UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
if (szCommandLine) if (szCommandLine)
sz += lstrlenW(szCommandLine); sz += lstrlenW(szCommandLine);
commandline = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR)); commandline = msi_alloc(sz * sizeof(WCHAR));
if (szCommandLine) if (szCommandLine)
lstrcpyW(commandline,szCommandLine); lstrcpyW(commandline,szCommandLine);
@ -336,7 +336,7 @@ UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
msiobj_release( &package->hdr ); msiobj_release( &package->hdr );
HeapFree(GetProcessHeap(),0,commandline); msi_free(commandline);
end: end:
if (handle != -1) if (handle != -1)
MsiCloseHandle(handle); MsiCloseHandle(handle);
@ -368,8 +368,8 @@ UINT WINAPI MsiConfigureProductExA(LPCSTR szProduct, int iInstallLevel,
r = MsiConfigureProductExW( szwProduct, iInstallLevel, eInstallState, r = MsiConfigureProductExW( szwProduct, iInstallLevel, eInstallState,
szwCommandLine ); szwCommandLine );
end: end:
HeapFree( GetProcessHeap(), 0, szwProduct ); msi_free( szwProduct );
HeapFree( GetProcessHeap(), 0, szwCommandLine); msi_free( szwCommandLine);
return r; return r;
} }
@ -390,7 +390,7 @@ UINT WINAPI MsiConfigureProductA(LPCSTR szProduct, int iInstallLevel,
} }
r = MsiConfigureProductW( szwProduct, iInstallLevel, eInstallState ); r = MsiConfigureProductW( szwProduct, iInstallLevel, eInstallState );
HeapFree( GetProcessHeap(), 0, szwProduct ); msi_free( szwProduct );
return r; return r;
} }
@ -423,7 +423,7 @@ UINT WINAPI MsiGetProductCodeA(LPCSTR szComponent, LPSTR szBuffer)
if( ERROR_SUCCESS == r ) if( ERROR_SUCCESS == r )
WideCharToMultiByte(CP_ACP, 0, szwBuffer, -1, szBuffer, GUID_SIZE, NULL, NULL); WideCharToMultiByte(CP_ACP, 0, szwBuffer, -1, szBuffer, GUID_SIZE, NULL, NULL);
HeapFree( GetProcessHeap(), 0, szwComponent ); msi_free( szwComponent );
return r; return r;
} }
@ -490,7 +490,7 @@ UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
if( szBuffer ) if( szBuffer )
{ {
szwBuffer = HeapAlloc( GetProcessHeap(), 0, (*pcchValueBuf) * sizeof(WCHAR) ); szwBuffer = msi_alloc( (*pcchValueBuf) * sizeof(WCHAR) );
pcchwValueBuf = *pcchValueBuf; pcchwValueBuf = *pcchValueBuf;
if( !szwBuffer ) if( !szwBuffer )
goto end; goto end;
@ -509,9 +509,9 @@ UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
} }
end: end:
HeapFree( GetProcessHeap(), 0, szwProduct ); msi_free( szwProduct );
HeapFree( GetProcessHeap(), 0, szwAttribute ); msi_free( szwAttribute );
HeapFree( GetProcessHeap(), 0, szwBuffer ); msi_free( szwBuffer );
return r; return r;
} }
@ -624,7 +624,7 @@ UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
r = MsiEnableLogW( dwLogMode, szwLogFile, attributes ); r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
HeapFree( GetProcessHeap(), 0, szwLogFile ); msi_free( szwLogFile );
return r; return r;
} }
@ -659,7 +659,7 @@ INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
r = MsiQueryProductStateW( szwProduct ); r = MsiQueryProductStateW( szwProduct );
HeapFree( GetProcessHeap(), 0, szwProduct ); msi_free( szwProduct );
return r; return r;
} }
@ -821,7 +821,7 @@ LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
LANGID r; LANGID r;
DWORD len; DWORD len;
bufW = HeapAlloc(GetProcessHeap(), 0, nBufferMax*sizeof(WCHAR)); bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang); r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
if( r ) if( r )
{ {
@ -832,7 +832,7 @@ LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
else else
r = 0; r = 0;
} }
HeapFree(GetProcessHeap(), 0, bufW); msi_free(bufW);
return r; return r;
} }
@ -948,7 +948,7 @@ UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
r = MsiVerifyPackageW( szPack ); r = MsiVerifyPackageW( szPack );
HeapFree( GetProcessHeap(), 0, szPack ); msi_free( szPack );
return r; return r;
} }
@ -985,14 +985,14 @@ INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
szwComponent = strdupAtoW( szComponent ); szwComponent = strdupAtoW( szComponent );
if( !szwComponent ) if( !szwComponent )
{ {
HeapFree( GetProcessHeap(), 0, szwProduct); msi_free( szwProduct);
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
} }
if( pcchBuf && *pcchBuf > 0 ) if( pcchBuf && *pcchBuf > 0 )
{ {
lpwPathBuf = HeapAlloc( GetProcessHeap(), 0, *pcchBuf * sizeof(WCHAR)); lpwPathBuf = msi_alloc( *pcchBuf * sizeof(WCHAR));
incoming_len = *pcchBuf; incoming_len = *pcchBuf;
} }
else else
@ -1003,14 +1003,14 @@ INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
rc = MsiGetComponentPathW(szwProduct, szwComponent, lpwPathBuf, pcchBuf); rc = MsiGetComponentPathW(szwProduct, szwComponent, lpwPathBuf, pcchBuf);
HeapFree( GetProcessHeap(), 0, szwProduct); msi_free( szwProduct);
HeapFree( GetProcessHeap(), 0, szwComponent); msi_free( szwComponent);
if (lpwPathBuf) if (lpwPathBuf)
{ {
if (rc != INSTALLSTATE_UNKNOWN) if (rc != INSTALLSTATE_UNKNOWN)
WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, incoming_len, WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, incoming_len,
lpPathBuf, incoming_len, NULL, NULL); lpPathBuf, incoming_len, NULL, NULL);
HeapFree( GetProcessHeap(), 0, lpwPathBuf); msi_free( lpwPathBuf);
} }
return rc; return rc;
@ -1053,7 +1053,7 @@ INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
goto end; goto end;
sz += sizeof(WCHAR); sz += sizeof(WCHAR);
path = HeapAlloc( GetProcessHeap(), 0, sz ); path = msi_alloc( sz );
if( !path ) if( !path )
goto end; goto end;
@ -1087,7 +1087,7 @@ INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
} }
end: end:
HeapFree(GetProcessHeap(), 0, path ); msi_free(path );
RegCloseKey(hkey); RegCloseKey(hkey);
return rrc; return rrc;
} }
@ -1113,15 +1113,15 @@ INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
szwFeature = strdupAtoW( szFeature ); szwFeature = strdupAtoW( szFeature );
if( !szwFeature) if( !szwFeature)
{ {
HeapFree( GetProcessHeap(), 0, szwProduct); msi_free( szwProduct);
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
} }
rc = MsiQueryFeatureStateW(szwProduct, szwFeature); rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
HeapFree( GetProcessHeap(), 0, szwProduct); msi_free( szwProduct);
HeapFree( GetProcessHeap(), 0, szwFeature); msi_free( szwFeature);
return rc; return rc;
} }
@ -1172,14 +1172,14 @@ UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf ) if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
{ {
lpwVersionBuff = HeapAlloc(GetProcessHeap(), 0, *pcchVersionBuf*sizeof(WCHAR)); lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
if( !lpwVersionBuff ) if( !lpwVersionBuff )
goto end; goto end;
} }
if( lpLangBuf && pcchLangBuf && *pcchLangBuf ) if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
{ {
lpwLangBuff = HeapAlloc(GetProcessHeap(), 0, *pcchVersionBuf*sizeof(WCHAR)); lpwLangBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
if( !lpwLangBuff ) if( !lpwLangBuff )
goto end; goto end;
} }
@ -1195,9 +1195,9 @@ UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
lpLangBuf, *pcchLangBuf, NULL, NULL); lpLangBuf, *pcchLangBuf, NULL, NULL);
end: end:
HeapFree(GetProcessHeap(), 0, szwFilePath); msi_free(szwFilePath);
HeapFree(GetProcessHeap(), 0, lpwVersionBuff); msi_free(lpwVersionBuff);
HeapFree(GetProcessHeap(), 0, lpwLangBuff); msi_free(lpwLangBuff);
return ret; return ret;
} }
@ -1227,7 +1227,7 @@ UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
if( !dwVerLen ) if( !dwVerLen )
return GetLastError(); return GetLastError();
lpVer = HeapAlloc(GetProcessHeap(), 0, dwVerLen); lpVer = msi_alloc(dwVerLen);
if( !lpVer ) if( !lpVer )
{ {
ret = ERROR_OUTOFMEMORY; ret = ERROR_OUTOFMEMORY;
@ -1268,7 +1268,7 @@ UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
} }
end: end:
HeapFree(GetProcessHeap(), 0, lpVer); msi_free(lpVer);
return ret; return ret;
} }
@ -1478,12 +1478,12 @@ UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
return ERROR_INDEX_ABSENT; return ERROR_INDEX_ABSENT;
} }
info = HeapAlloc(GetProcessHeap(),0,sz); info = msi_alloc(sz);
rc = RegQueryValueExW( hkey, szQualifier, NULL, NULL, (LPBYTE)info, &sz); rc = RegQueryValueExW( hkey, szQualifier, NULL, NULL, (LPBYTE)info, &sz);
if (rc != ERROR_SUCCESS) if (rc != ERROR_SUCCESS)
{ {
RegCloseKey(hkey); RegCloseKey(hkey);
HeapFree(GetProcessHeap(),0,info); msi_free(info);
return ERROR_INDEX_ABSENT; return ERROR_INDEX_ABSENT;
} }
@ -1494,7 +1494,7 @@ UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
else else
{ {
RegCloseKey(hkey); RegCloseKey(hkey);
HeapFree(GetProcessHeap(),0,info); msi_free(info);
return ERROR_INDEX_ABSENT; return ERROR_INDEX_ABSENT;
} }
@ -1512,9 +1512,9 @@ UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
rc = MsiGetComponentPathW(szProduct, component, lpPathBuf, pcchPathBuf); rc = MsiGetComponentPathW(szProduct, component, lpPathBuf, pcchPathBuf);
RegCloseKey(hkey); RegCloseKey(hkey);
HeapFree(GetProcessHeap(),0,info); msi_free(info);
HeapFree(GetProcessHeap(),0,product); msi_free(product);
HeapFree(GetProcessHeap(),0,component); msi_free(component);
if (rc == INSTALLSTATE_LOCAL) if (rc == INSTALLSTATE_LOCAL)
return ERROR_SUCCESS; return ERROR_SUCCESS;
@ -1550,19 +1550,19 @@ UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
szwComponent= strdupAtoW( szComponent); szwComponent= strdupAtoW( szComponent);
szwQualifier= strdupAtoW( szQualifier); szwQualifier= strdupAtoW( szQualifier);
lpwPathBuf = HeapAlloc(GetProcessHeap(),0,*pcchPathBuf * sizeof(WCHAR)); lpwPathBuf = msi_alloc(*pcchPathBuf * sizeof(WCHAR));
pcchwPathBuf = *pcchPathBuf; pcchwPathBuf = *pcchPathBuf;
rc = MsiProvideQualifiedComponentW(szwComponent, szwQualifier, rc = MsiProvideQualifiedComponentW(szwComponent, szwQualifier,
dwInstallMode, lpwPathBuf, &pcchwPathBuf); dwInstallMode, lpwPathBuf, &pcchwPathBuf);
HeapFree(GetProcessHeap(),0,szwComponent); msi_free(szwComponent);
HeapFree(GetProcessHeap(),0,szwQualifier); msi_free(szwQualifier);
*pcchPathBuf = WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, pcchwPathBuf, *pcchPathBuf = WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, pcchwPathBuf,
lpPathBuf, *pcchPathBuf, NULL, NULL); lpPathBuf, *pcchPathBuf, NULL, NULL);
HeapFree(GetProcessHeap(),0,lpwPathBuf); msi_free(lpwPathBuf);
return rc; return rc;
} }
@ -1828,7 +1828,7 @@ UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
sz += lstrlenW(fmt); sz += lstrlenW(fmt);
sz += lstrlenW(szFeature); sz += lstrlenW(szFeature);
commandline = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR)); commandline = msi_alloc(sz * sizeof(WCHAR));
sprintfW(commandline,fmt,szFeature); sprintfW(commandline,fmt,szFeature);
lstrcatW(commandline,szInstalled); lstrcatW(commandline,szInstalled);
@ -1837,7 +1837,7 @@ UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
msiobj_release( &package->hdr ); msiobj_release( &package->hdr );
HeapFree(GetProcessHeap(),0,commandline); msi_free(commandline);
end: end:
if (handle != -1) if (handle != -1)
MsiCloseHandle(handle); MsiCloseHandle(handle);
@ -1860,8 +1860,8 @@ UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode); rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
HeapFree(GetProcessHeap(),0,wszProduct); msi_free(wszProduct);
HeapFree(GetProcessHeap(),0,wszFeature); msi_free(wszFeature);
return rc; return rc;
} }

24
dlls/msi/msiquery.c
View File

@ -49,7 +49,7 @@ static void MSI_CloseView( MSIOBJECTHDR *arg )
LIST_FOR_EACH_SAFE( ptr, t, &query->mem ) LIST_FOR_EACH_SAFE( ptr, t, &query->mem )
{ {
HeapFree( GetProcessHeap(), 0, ptr ); msi_free( ptr );
} }
} }
@ -71,7 +71,7 @@ UINT VIEW_find_column( MSIVIEW *table, LPCWSTR name, UINT *n )
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
return r; return r;
x = lstrcmpW( name, col_name ); x = lstrcmpW( name, col_name );
HeapFree( GetProcessHeap(), 0, col_name ); msi_free( col_name );
if( !x ) if( !x )
{ {
*n = i; *n = i;
@ -101,7 +101,7 @@ UINT WINAPI MsiDatabaseOpenViewA(MSIHANDLE hdb,
r = MsiDatabaseOpenViewW( hdb, szwQuery, phView); r = MsiDatabaseOpenViewW( hdb, szwQuery, phView);
HeapFree( GetProcessHeap(), 0, szwQuery ); msi_free( szwQuery );
return r; return r;
} }
@ -149,18 +149,18 @@ UINT MSI_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... )
for (;;) for (;;)
{ {
va_list va; va_list va;
query = HeapAlloc( GetProcessHeap(), 0, size*sizeof(WCHAR) ); query = msi_alloc( size*sizeof(WCHAR) );
va_start(va, fmt); va_start(va, fmt);
res = vsnprintfW(query, size, fmt, va); res = vsnprintfW(query, size, fmt, va);
va_end(va); va_end(va);
if (res == -1) size *= 2; if (res == -1) size *= 2;
else if (res >= size) size = res + 1; else if (res >= size) size = res + 1;
else break; else break;
HeapFree( GetProcessHeap(), 0, query ); msi_free( query );
} }
/* perform the query */ /* perform the query */
r = MSI_DatabaseOpenViewW(db, query, view); r = MSI_DatabaseOpenViewW(db, query, view);
HeapFree(GetProcessHeap(), 0, query); msi_free(query);
return r; return r;
} }
@ -213,18 +213,18 @@ MSIRECORD *MSI_QueryGetRecord( MSIDATABASE *db, LPCWSTR fmt, ... )
for (;;) for (;;)
{ {
va_list va; va_list va;
query = HeapAlloc( GetProcessHeap(), 0, size*sizeof(WCHAR) ); query = msi_alloc( size*sizeof(WCHAR) );
va_start(va, fmt); va_start(va, fmt);
res = vsnprintfW(query, size, fmt, va); res = vsnprintfW(query, size, fmt, va);
va_end(va); va_end(va);
if (res == -1) size *= 2; if (res == -1) size *= 2;
else if (res >= size) size = res + 1; else if (res >= size) size = res + 1;
else break; else break;
HeapFree( GetProcessHeap(), 0, query ); msi_free( query );
} }
/* perform the query */ /* perform the query */
r = MSI_DatabaseOpenViewW(db, query, &view); r = MSI_DatabaseOpenViewW(db, query, &view);
HeapFree(GetProcessHeap(), 0, query); msi_free(query);
if( r == ERROR_SUCCESS ) if( r == ERROR_SUCCESS )
{ {
@ -315,7 +315,7 @@ UINT MSI_ViewFetch(MSIQUERY *query, MSIRECORD **prec)
sval = MSI_makestring( query->db, ival ); sval = MSI_makestring( query->db, ival );
MSI_RecordSetStringW( rec, i, sval ); MSI_RecordSetStringW( rec, i, sval );
HeapFree( GetProcessHeap(), 0, sval ); msi_free( sval );
} }
else else
{ {
@ -492,7 +492,7 @@ UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hR
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
continue; continue;
MSI_RecordSetStringW( rec, i+1, name ); MSI_RecordSetStringW( rec, i+1, name );
HeapFree( GetProcessHeap(), 0, name ); msi_free( name );
} }
*hRec = alloc_msihandle( &rec->hdr ); *hRec = alloc_msihandle( &rec->hdr );
@ -765,7 +765,7 @@ UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec ); r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec );
HeapFree( GetProcessHeap(), 0, szwTable ); msi_free( szwTable );
return r; return r;
} }

106
dlls/msi/table.c
View File

@ -96,7 +96,7 @@ static LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
if( !bTable ) if( !bTable )
count = lstrlenW( in )+2; count = lstrlenW( in )+2;
out = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) ); out = msi_alloc( count*sizeof(WCHAR) );
p = out; p = out;
if( bTable ) if( bTable )
@ -130,7 +130,7 @@ static LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
*p++ = ch; *p++ = ch;
} }
ERR("Failed to encode stream name (%s)\n",debugstr_w(in)); ERR("Failed to encode stream name (%s)\n",debugstr_w(in));
HeapFree( GetProcessHeap(), 0, out ); msi_free( out );
return NULL; return NULL;
} }
@ -218,7 +218,7 @@ static UINT read_stream_data( IStorage *stg, LPCWSTR stname,
r = IStorage_OpenStream(stg, encname, NULL, r = IStorage_OpenStream(stg, encname, NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm); STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
HeapFree( GetProcessHeap(), 0, encname ); msi_free( encname );
if( FAILED( r ) ) if( FAILED( r ) )
{ {
WARN("open stream failed r = %08lx - empty table?\n",r); WARN("open stream failed r = %08lx - empty table?\n",r);
@ -239,7 +239,7 @@ static UINT read_stream_data( IStorage *stg, LPCWSTR stname,
} }
sz = stat.cbSize.QuadPart; sz = stat.cbSize.QuadPart;
data = HeapAlloc( GetProcessHeap(), 0, sz ); data = msi_alloc( sz );
if( !data ) if( !data )
{ {
WARN("couldn't allocate memory r=%08lx!\n",r); WARN("couldn't allocate memory r=%08lx!\n",r);
@ -250,7 +250,7 @@ static UINT read_stream_data( IStorage *stg, LPCWSTR stname,
r = IStream_Read(stm, data, sz, &count ); r = IStream_Read(stm, data, sz, &count );
if( FAILED( r ) || ( count != sz ) ) if( FAILED( r ) || ( count != sz ) )
{ {
HeapFree( GetProcessHeap(), 0, data ); msi_free( data );
WARN("read stream failed r = %08lx!\n",r); WARN("read stream failed r = %08lx!\n",r);
goto end; goto end;
} }
@ -276,7 +276,7 @@ UINT db_get_raw_stream( MSIDATABASE *db, LPCWSTR stname, IStream **stm )
r = IStorage_OpenStream(db->storage, encname, NULL, r = IStorage_OpenStream(db->storage, encname, NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm); STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm);
HeapFree( GetProcessHeap(), 0, encname ); msi_free( encname );
if( FAILED( r ) ) if( FAILED( r ) )
{ {
WARN("open stream failed r = %08lx - empty table?\n",r); WARN("open stream failed r = %08lx - empty table?\n",r);
@ -313,7 +313,7 @@ UINT read_raw_stream_data( MSIDATABASE *db, LPCWSTR stname,
} }
sz = stat.cbSize.QuadPart; sz = stat.cbSize.QuadPart;
data = HeapAlloc( GetProcessHeap(), 0, sz ); data = msi_alloc( sz );
if( !data ) if( !data )
{ {
WARN("couldn't allocate memory r=%08lx!\n",r); WARN("couldn't allocate memory r=%08lx!\n",r);
@ -324,7 +324,7 @@ UINT read_raw_stream_data( MSIDATABASE *db, LPCWSTR stname,
r = IStream_Read(stm, data, sz, &count ); r = IStream_Read(stm, data, sz, &count );
if( FAILED( r ) || ( count != sz ) ) if( FAILED( r ) || ( count != sz ) )
{ {
HeapFree( GetProcessHeap(), 0, data ); msi_free( data );
WARN("read stream failed r = %08lx!\n",r); WARN("read stream failed r = %08lx!\n",r);
goto end; goto end;
} }
@ -358,7 +358,7 @@ static UINT write_stream_data( IStorage *stg, LPCWSTR stname,
r = IStorage_CreateStream( stg, encname, r = IStorage_CreateStream( stg, encname,
STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm); STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
} }
HeapFree( GetProcessHeap(), 0, encname ); msi_free( encname );
if( FAILED( r ) ) if( FAILED( r ) )
{ {
WARN("open stream failed r = %08lx\n",r); WARN("open stream failed r = %08lx\n",r);
@ -400,9 +400,9 @@ static void free_table( MSITABLE *table )
{ {
int i; int i;
for( i=0; i<table->row_count; i++ ) for( i=0; i<table->row_count; i++ )
HeapFree( GetProcessHeap(), 0, table->data[i] ); msi_free( table->data[i] );
HeapFree( GetProcessHeap(), 0, table->data ); msi_free( table->data );
HeapFree( GetProcessHeap(), 0, table ); msi_free( table );
} }
static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **ptable) static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **ptable)
@ -415,15 +415,14 @@ static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **p
TRACE("%s\n",debugstr_w(name)); TRACE("%s\n",debugstr_w(name));
/* nonexistent tables should be interpreted as empty tables */ /* nonexistent tables should be interpreted as empty tables */
t = HeapAlloc( GetProcessHeap(), 0, t = msi_alloc( sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
if( !t ) if( !t )
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
r = table_get_column_info( db, name, &cols, &num_cols ); r = table_get_column_info( db, name, &cols, &num_cols );
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
{ {
HeapFree( GetProcessHeap(), 0, t ); msi_free( t );
return r; return r;
} }
last_col = &cols[num_cols-1]; last_col = &cols[num_cols-1];
@ -449,8 +448,7 @@ static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **p
} }
t->row_count = rawsize / row_size; t->row_count = rawsize / row_size;
t->data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, t->data = msi_alloc_zero( t->row_count * sizeof (USHORT*) );
t->row_count * sizeof (USHORT*) );
if( !t->data ) if( !t->data )
{ {
r = ERROR_NOT_ENOUGH_MEMORY; r = ERROR_NOT_ENOUGH_MEMORY;
@ -461,7 +459,7 @@ static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **p
TRACE("Transposing data from %d columns\n", t->row_count ); TRACE("Transposing data from %d columns\n", t->row_count );
for( i=0; i<t->row_count; i++ ) for( i=0; i<t->row_count; i++ )
{ {
t->data[i] = HeapAlloc( GetProcessHeap(), 0, row_size ); t->data[i] = msi_alloc( row_size );
if( !t->data[i] ) if( !t->data[i] )
{ {
r = ERROR_NOT_ENOUGH_MEMORY; r = ERROR_NOT_ENOUGH_MEMORY;
@ -489,14 +487,14 @@ static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **p
} }
} }
HeapFree( GetProcessHeap(), 0, cols ); msi_free( cols );
HeapFree( GetProcessHeap(), 0, rawdata ); msi_free( rawdata );
return ERROR_SUCCESS; return ERROR_SUCCESS;
err: err:
HeapFree( GetProcessHeap(), 0, cols ); msi_free( cols );
HeapFree( GetProcessHeap(), 0, rawdata ); msi_free( rawdata );
free_table( t ); free_table( t );
return r; return r;
} }
@ -536,8 +534,8 @@ void free_cached_tables( MSIDATABASE *db )
if ( --t->ref_count ) if ( --t->ref_count )
ERR("table ref count not zero for %s\n", debugstr_w(t->name)); ERR("table ref count not zero for %s\n", debugstr_w(t->name));
remove_table( db, t ); remove_table( db, t );
HeapFree( GetProcessHeap(), 0, t->data ); msi_free( t->data );
HeapFree( GetProcessHeap(), 0, t ); msi_free( t );
} }
} }
@ -574,14 +572,14 @@ static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name, MSICOLUMNINFO
TRACE("Table %s found\n", debugstr_w(name) ); TRACE("Table %s found\n", debugstr_w(name) );
columns = HeapAlloc( GetProcessHeap(), 0, column_count*sizeof (MSICOLUMNINFO)); columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO));
if( !columns ) if( !columns )
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
r = get_tablecolumns( db, name, columns, &column_count ); r = get_tablecolumns( db, name, columns, &column_count );
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
{ {
HeapFree( GetProcessHeap(), 0, columns ); msi_free( columns );
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }
@ -632,7 +630,7 @@ static UINT save_table( MSIDATABASE *db, MSITABLE *t )
row_size = last_col->offset + bytes_per_column( last_col ); row_size = last_col->offset + bytes_per_column( last_col );
rawsize = t->row_count * row_size; rawsize = t->row_count * row_size;
rawdata = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, rawsize ); rawdata = msi_alloc_zero( rawsize );
if( !rawdata ) if( !rawdata )
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
@ -652,7 +650,7 @@ static UINT save_table( MSIDATABASE *db, MSITABLE *t )
TRACE("writing %d bytes\n", rawsize); TRACE("writing %d bytes\n", rawsize);
r = write_stream_data( db->storage, t->name, rawdata, rawsize ); r = write_stream_data( db->storage, t->name, rawdata, rawsize );
HeapFree( GetProcessHeap(), 0, rawdata ); msi_free( rawdata );
return r; return r;
} }
@ -674,7 +672,7 @@ HRESULT init_string_table( IStorage *stg )
/* create the StringPool stream... add the zero string to it*/ /* create the StringPool stream... add the zero string to it*/
r = IStorage_CreateStream( stg, encname, r = IStorage_CreateStream( stg, encname,
STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm); STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
HeapFree( GetProcessHeap(), 0, encname ); msi_free( encname );
if( r ) if( r )
{ {
TRACE("Failed\n"); TRACE("Failed\n");
@ -694,7 +692,7 @@ HRESULT init_string_table( IStorage *stg )
encname = encode_streamname(TRUE, szStringData ); encname = encode_streamname(TRUE, szStringData );
r = IStorage_CreateStream( stg, encname, r = IStorage_CreateStream( stg, encname,
STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm); STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
HeapFree( GetProcessHeap(), 0, encname ); msi_free( encname );
if( r ) if( r )
{ {
TRACE("Failed\n"); TRACE("Failed\n");
@ -769,8 +767,8 @@ string_table *load_string_table( IStorage *stg )
TRACE("Loaded %ld strings\n", count); TRACE("Loaded %ld strings\n", count);
end: end:
HeapFree( GetProcessHeap(), 0, pool ); msi_free( pool );
HeapFree( GetProcessHeap(), 0, data ); msi_free( data );
return st; return st;
} }
@ -792,13 +790,13 @@ static UINT save_string_table( MSIDATABASE *db )
datasize = msi_string_totalsize( db->strings, &count ); datasize = msi_string_totalsize( db->strings, &count );
poolsize = count*2*sizeof(USHORT); poolsize = count*2*sizeof(USHORT);
pool = HeapAlloc( GetProcessHeap(), 0, poolsize ); pool = msi_alloc( poolsize );
if( ! pool ) if( ! pool )
{ {
WARN("Failed to alloc pool %d bytes\n", poolsize ); WARN("Failed to alloc pool %d bytes\n", poolsize );
goto err; goto err;
} }
data = HeapAlloc( GetProcessHeap(), 0, datasize ); data = msi_alloc( datasize );
if( ! data ) if( ! data )
{ {
WARN("Failed to alloc data %d bytes\n", poolsize ); WARN("Failed to alloc data %d bytes\n", poolsize );
@ -850,8 +848,8 @@ static UINT save_string_table( MSIDATABASE *db )
ret = ERROR_SUCCESS; ret = ERROR_SUCCESS;
err: err:
HeapFree( GetProcessHeap(), 0, data ); msi_free( data );
HeapFree( GetProcessHeap(), 0, pool ); msi_free( pool );
return ret; return ret;
} }
@ -920,13 +918,13 @@ LPWSTR MSI_makestring( MSIDATABASE *db, UINT stringid)
r = msi_id2stringW( db->strings, stringid, NULL, &sz ); r = msi_id2stringW( db->strings, stringid, NULL, &sz );
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
return NULL; return NULL;
str = HeapAlloc( GetProcessHeap(), 0, sz*sizeof (WCHAR)); str = msi_alloc( sz*sizeof (WCHAR));
if( !str ) if( !str )
return str; return str;
r = msi_id2stringW( db->strings, stringid, str, &sz ); r = msi_id2stringW( db->strings, stringid, str, &sz );
if( r == ERROR_SUCCESS ) if( r == ERROR_SUCCESS )
return str; return str;
HeapFree( GetProcessHeap(), 0, str ); msi_free( str );
return NULL; return NULL;
} }
@ -1140,7 +1138,7 @@ static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, ISt
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
len = lstrlenW( tv->name ) + 2 + lstrlenW( sval ); len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
full_name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) ); full_name = msi_alloc( len*sizeof(WCHAR) );
lstrcpyW( full_name, tv->name ); lstrcpyW( full_name, tv->name );
lstrcatW( full_name, szDot ); lstrcatW( full_name, szDot );
lstrcatW( full_name, sval ); lstrcatW( full_name, sval );
@ -1148,8 +1146,8 @@ static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, ISt
r = db_get_raw_stream( tv->db, full_name, stm ); r = db_get_raw_stream( tv->db, full_name, stm );
if( r ) if( r )
ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r); ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
HeapFree( GetProcessHeap(), 0, full_name ); msi_free( full_name );
HeapFree( GetProcessHeap(), 0, sval ); msi_free( sval );
return r; return r;
} }
@ -1202,18 +1200,18 @@ static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num )
if( !tv->table ) if( !tv->table )
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
row = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, tv->row_size ); row = msi_alloc_zero( tv->row_size );
if( !row ) if( !row )
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
sz = (tv->table->row_count + 1) * sizeof (UINT*); sz = (tv->table->row_count + 1) * sizeof (UINT*);
if( tv->table->data ) if( tv->table->data )
p = HeapReAlloc( GetProcessHeap(), 0, tv->table->data, sz ); p = msi_realloc( tv->table->data, sz );
else else
p = HeapAlloc( GetProcessHeap(), 0, sz ); p = msi_alloc( sz );
if( !p ) if( !p )
{ {
HeapFree( GetProcessHeap(), 0, row ); msi_free( row );
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
} }
@ -1478,14 +1476,14 @@ static UINT TABLE_delete( struct tagMSIVIEW *view )
UINT i; UINT i;
for( i=0; i<tv->num_cols; i++) for( i=0; i<tv->num_cols; i++)
{ {
HeapFree( GetProcessHeap(), 0, tv->columns[i].colname ); msi_free( tv->columns[i].colname );
HeapFree( GetProcessHeap(), 0, tv->columns[i].tablename ); msi_free( tv->columns[i].tablename );
} }
HeapFree( GetProcessHeap(), 0, tv->columns ); msi_free( tv->columns );
} }
tv->columns = NULL; tv->columns = NULL;
HeapFree( GetProcessHeap(), 0, tv ); msi_free( tv );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -1526,22 +1524,22 @@ UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
TRACE("Table found\n"); TRACE("Table found\n");
sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ; sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
tv = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sz ); tv = msi_alloc_zero( sz );
if( !tv ) if( !tv )
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
columns = HeapAlloc( GetProcessHeap(), 0, column_count*sizeof (MSICOLUMNINFO)); columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO));
if( !columns ) if( !columns )
{ {
HeapFree( GetProcessHeap(), 0, tv ); msi_free( tv );
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }
r = get_tablecolumns( db, name, columns, &column_count ); r = get_tablecolumns( db, name, columns, &column_count );
if( r != ERROR_SUCCESS ) if( r != ERROR_SUCCESS )
{ {
HeapFree( GetProcessHeap(), 0, columns ); msi_free( columns );
HeapFree( GetProcessHeap(), 0, tv ); msi_free( tv );
return ERROR_FUNCTION_FAILED; return ERROR_FUNCTION_FAILED;
} }