/***************************************************************************
* get_basename
*
* Return the base name of a file name (i.e. remove the path components).
*/
static const WCHAR *get_basename( const WCHAR *name )
{
const WCHAR *ptr;
if (name[0] && name[1] == ':') name += 2; /* strip drive specification */
if ((ptr = strrchrW( name, '\\' ))) name = ptr + 1;
if ((ptr = strrchrW( name, '/' ))) name = ptr + 1;
return name;
}
HRESULT __cdecl SchRpcRegisterTask(const WCHAR *path, const WCHAR *xml, DWORD flags, const WCHAR *sddl,
DWORD task_logon_type, DWORD n_creds, const TASK_USER_CRED *creds,
WCHAR **actual_path, TASK_XML_ERROR_INFO **xml_error_info)
{
WCHAR *full_name, *relative_path;
DWORD disposition;
HRESULT hr;
WINE_TRACE("%s,%s,%#x,%s,%u,%u,%p,%p,%p\n", wine_dbgstr_w(path), wine_dbgstr_w(xml), flags,
wine_dbgstr_w(sddl), task_logon_type, n_creds, creds, actual_path, xml_error_info);
*actual_path = NULL;
*xml_error_info = NULL;
/* FIXME: assume that validation is performed on the client side */
if (flags & TASK_VALIDATE_ONLY) return S_OK;
full_name = get_full_name(path, &relative_path);
if (!full_name) return E_OUTOFMEMORY;
if (strchrW(path, '\\') || strchrW(path, '/'))
{
WCHAR *p = strrchrW(full_name, '/');
if (!p) p = strrchrW(full_name, '\\');
*p = 0;
hr = create_directory(full_name);
*p = '\\';
}
switch (flags & (TASK_CREATE | TASK_UPDATE))
{
default:
case TASK_CREATE:
disposition = CREATE_NEW;
break;
case TASK_UPDATE:
disposition = OPEN_EXISTING;
break;
case (TASK_CREATE | TASK_UPDATE):
disposition = OPEN_ALWAYS;
break;
}
hr = write_xml_utf8(full_name, disposition, xml);
if (hr == S_OK)
{
*actual_path = heap_strdupW(relative_path);
schedsvc_auto_start();
}
heap_free(full_name);
return hr;
}
/***********************************************************************
* FD31_StripEditControl [internal]
* Strip pathnames off the contents of the edit control.
*/
static void FD31_StripEditControl(HWND hwnd)
{
WCHAR temp[BUFFILE], *cp;
GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
cp = strrchrW(temp, '\\');
if (cp != NULL) {
strcpyW(temp, cp+1);
}
cp = strrchrW(temp, ':');
if (cp != NULL) {
strcpyW(temp, cp+1);
}
/* FIXME: shouldn't we do something with the result here? ;-) */
}
/***********************************************************************
* get_default_desktop
*
* Get the name of the desktop to use for this app if not specified explicitly.
*/
static const WCHAR *get_default_desktop(void)
{
static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0};
static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
static const WCHAR explorerW[] = {'\\','E','x','p','l','o','r','e','r',0};
static const WCHAR app_defaultsW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\',
'A','p','p','D','e','f','a','u','l','t','s',0};
static WCHAR buffer[MAX_PATH + sizeof(explorerW)/sizeof(WCHAR)];
WCHAR *p, *appname = buffer;
const WCHAR *ret = defaultW;
DWORD len;
HKEY tmpkey, appkey;
len = (GetModuleFileNameW( 0, buffer, MAX_PATH ));
if (!len || len >= MAX_PATH) return ret;
if ((p = strrchrW( appname, '/' ))) appname = p + 1;
if ((p = strrchrW( appname, '\\' ))) appname = p + 1;
p = appname + strlenW(appname);
strcpyW( p, explorerW );
/* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\Explorer */
if (!RegOpenKeyW( HKEY_CURRENT_USER, app_defaultsW, &tmpkey ))
{
if (RegOpenKeyW( tmpkey, appname, &appkey )) appkey = 0;
RegCloseKey( tmpkey );
if (appkey)
{
len = sizeof(buffer);
if (!RegQueryValueExW( appkey, desktopW, 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
RegCloseKey( appkey );
if (ret && strcmpiW( ret, defaultW )) return ret;
ret = defaultW;
}
}
memcpy( buffer, app_defaultsW, 13 * sizeof(WCHAR) ); /* copy only software\\wine */
strcpyW( buffer + 13, explorerW );
/* @@ Wine registry key: HKCU\Software\Wine\Explorer */
if (!RegOpenKeyW( HKEY_CURRENT_USER, buffer, &appkey ))
{
len = sizeof(buffer);
if (!RegQueryValueExW( appkey, desktopW, 0, NULL, (LPBYTE)buffer, &len )) ret = buffer;
RegCloseKey( appkey );
}
return ret;
}
static UINT msi_media_get_disk_info( MSIPACKAGE *package, struct media_info *mi )
{
MSIRECORD *row;
LPWSTR ptr;
static const WCHAR query[] =
{'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
'`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
'`','D','i','s','k','I','d','`',' ','=',' ','%','i',0};
row = MSI_QueryGetRecord(package->db, query, mi->disk_id);
if (!row)
{
TRACE("Unable to query row\n");
return ERROR_FUNCTION_FAILED;
}
mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));
mi->cabinet = strdupW(MSI_RecordGetString(row, 4));
mi->volume_label = strdupW(MSI_RecordGetString(row, 5));
if (!mi->first_volume)
mi->first_volume = strdupW(mi->volume_label);
ptr = strrchrW(mi->source, '\\') + 1;
lstrcpyW(ptr, mi->cabinet);
msiobj_release(&row->hdr);
return ERROR_SUCCESS;
}
static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
{
WshShortcut *This = impl_from_IWshShortcut(iface);
HRESULT hr;
WCHAR *ptr;
BSTR path;
INT icon;
TRACE("(%p)->(%s)\n", This, debugstr_w(IconPath));
/* scan for icon id */
ptr = strrchrW(IconPath, ',');
if (!ptr)
{
WARN("icon index not found\n");
return E_FAIL;
}
path = SysAllocStringLen(IconPath, ptr-IconPath);
/* skip spaces if any */
while (isspaceW(*++ptr))
;
icon = atoiW(ptr);
hr = IShellLinkW_SetIconLocation(This->link, path, icon);
SysFreeString(path);
return hr;
}
/*************************************************************************
* AddERExcludedApplicationW [FAULTREP.@]
*
* Adds an application to a list of applications for which fault reports
* shouldn't be generated
*
* PARAMS
* lpAppFileName [I] The filename of the application executable
*
* RETURNS
* TRUE on success, FALSE of failure
*
* NOTES
* Wine doesn't use this data but stores it in the registry (in the same place
* as Windows would) in case it will be useful in a future version
*
*/
BOOL WINAPI AddERExcludedApplicationW(LPCWSTR lpAppFileName)
{
WCHAR *bslash;
DWORD value = 1;
HKEY hkey;
LONG res;
TRACE("(%s)\n", wine_dbgstr_w(lpAppFileName));
bslash = strrchrW(lpAppFileName, '\\');
if (bslash != NULL)
lpAppFileName = bslash + 1;
if (*lpAppFileName == '\0')
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
res = RegCreateKeyW(HKEY_LOCAL_MACHINE, SZ_EXCLUSIONLIST_KEY, &hkey);
if (!res)
{
RegSetValueExW(hkey, lpAppFileName, 0, REG_DWORD, (LPBYTE)&value, sizeof(value));
RegCloseKey(hkey);
}
return !res;
}
static void test_getruntime(WCHAR *version)
{
static const WCHAR dotzero[] = {'.','0',0};
WCHAR *dot;
HRESULT hr;
ICLRRuntimeInfo *info;
DWORD count;
WCHAR buf[MAX_PATH];
hr = ICLRMetaHost_GetRuntime(metahost, NULL, &IID_ICLRRuntimeInfo, (void**)&info);
ok(hr == E_POINTER, "GetVersion failed, hr=%x\n", hr);
hr = ICLRMetaHost_GetRuntime(metahost, version, &IID_ICLRRuntimeInfo, (void**)&info);
ok(hr == S_OK, "GetVersion failed, hr=%x\n", hr);
if (hr != S_OK) return;
count = MAX_PATH;
hr = ICLRRuntimeInfo_GetVersionString(info, buf, &count);
ok(hr == S_OK, "GetVersionString returned %x\n", hr);
ok(count == lstrlenW(buf)+1, "GetVersionString returned count %u but string of length %u\n", count, lstrlenW(buf)+1);
ok(lstrcmpW(buf, version) == 0, "got unexpected version %s\n", wine_dbgstr_w(buf));
ICLRRuntimeInfo_Release(info);
/* Versions must match exactly. */
dot = strrchrW(version, '.');
lstrcpyW(dot, dotzero);
hr = ICLRMetaHost_GetRuntime(metahost, version, &IID_ICLRRuntimeInfo, (void**)&info);
ok(hr == CLR_E_SHIM_RUNTIME, "GetVersion failed, hr=%x\n", hr);
}
static HRESULT find_mime_from_url(const WCHAR *url, WCHAR **ret)
{
const WCHAR *ptr;
DWORD res, size;
WCHAR mime[64];
HKEY hkey;
static const WCHAR content_typeW[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
ptr = strrchrW(url, '.');
if(!ptr)
return E_FAIL;
res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey);
if(res != ERROR_SUCCESS)
return HRESULT_FROM_WIN32(res);
size = sizeof(mime);
res = RegQueryValueExW(hkey, content_typeW, NULL, NULL, (LPBYTE)mime, &size);
RegCloseKey(hkey);
if(res != ERROR_SUCCESS)
return HRESULT_FROM_WIN32(res);
TRACE("found MIME %s\n", debugstr_w(mime));
*ret = CoTaskMemAlloc(size);
memcpy(*ret, mime, size);
return S_OK;
}
/******************************************************************
* macho_load_module
*
* Loads a Mach-O module and stores it in process' module list.
* Also, find module real name and load address from
* the real loaded modules list in pcs address space.
*/
struct module* macho_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
{
struct macho_load ml;
TRACE("(%p/%p, %s, 0x%08lx)\n", pcs, pcs->handle, debugstr_w(name), addr);
ml.macho_info.flags = MACHO_INFO_MODULE;
ml.ret = FALSE;
if (pcs->dbg_hdr_addr) /* we're debugging a live target */
{
ml.pcs = pcs;
/* do only the lookup from the filename, not the path (as we lookup module
* name in the process' loaded module list)
*/
ml.name = strrchrW(name, '/');
if (!ml.name++) ml.name = name;
ml.ret = FALSE;
if (!macho_enum_modules_internal(pcs, NULL, macho_load_cb, &ml))
return NULL;
}
else if (addr)
{
ml.name = name;
ml.ret = macho_search_and_load_file(pcs, ml.name, addr, &ml.macho_info);
}
if (!ml.ret) return NULL;
assert(ml.macho_info.module);
return ml.macho_info.module;
}
/* try to load a pre-compiled fake dll */
static void *load_fake_dll( const WCHAR *name, SIZE_T *size )
{
const char *build_dir = wine_get_build_dir();
const char *path;
char *file, *ptr;
void *data = NULL;
unsigned int i, pos, len, namelen, maxlen = 0;
WCHAR *p;
int res = 0;
if ((p = strrchrW( name, '\\' ))) name = p + 1;
i = 0;
len = strlenW( name );
if (build_dir) maxlen = strlen(build_dir) + sizeof("/programs/") + len;
while ((path = wine_dll_enum_load_path( i++ ))) maxlen = max( maxlen, strlen(path) );
maxlen += sizeof("/fakedlls") + len + sizeof(".fake");
if (!(file = HeapAlloc( GetProcessHeap(), 0, maxlen ))) return NULL;
pos = maxlen - len - sizeof(".fake");
if (!dll_name_WtoA( file + pos, name, len )) goto done;
file[--pos] = '/';
if (build_dir)
{
strcpy( file + pos + len + 1, ".fake" );
/* try as a dll */
ptr = file + pos;
namelen = len + 1;
if (namelen > 4 && !memcmp( ptr + namelen - 4, ".dll", 4 )) namelen -= 4;
ptr = prepend( ptr, ptr, namelen );
ptr = prepend( ptr, "/dlls", sizeof("/dlls") - 1 );
ptr = prepend( ptr, build_dir, strlen(build_dir) );
if ((res = read_file( ptr, &data, size ))) goto done;
/* now as a program */
ptr = file + pos;
namelen = len + 1;
if (namelen > 4 && !memcmp( ptr + namelen - 4, ".exe", 4 )) namelen -= 4;
ptr = prepend( ptr, ptr, namelen );
ptr = prepend( ptr, "/programs", sizeof("/programs") - 1 );
ptr = prepend( ptr, build_dir, strlen(build_dir) );
if ((res = read_file( ptr, &data, size ))) goto done;
}
file[pos + len + 1] = 0;
for (i = 0; (path = wine_dll_enum_load_path( i )); i++)
{
ptr = prepend( file + pos, "/fakedlls", sizeof("/fakedlls") - 1 );
ptr = prepend( ptr, path, strlen(path) );
if ((res = read_file( ptr, &data, size ))) break;
}
done:
HeapFree( GetProcessHeap(), 0, file );
if (res == 1) return data;
return NULL;
}
/***********************************************************************
* FD31_Validate [internal]
* called on: click Ok button, Enter in edit, DoubleClick in file list
*/
static LRESULT FD31_Validate( PFD31_DATA lfs, LPWSTR path, UINT control, INT itemIndex,
BOOL internalUse )
{
LONG lRet;
HWND hWnd = lfs->hwnd;
OPENFILENAMEW ofnsav;
LPOPENFILENAMEW ofnW = lfs->ofnW;
WCHAR filename[BUFFILE];
ofnsav = *ofnW; /* for later restoring */
/* get current file name */
if (path)
lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
else
GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
TRACE("got filename = %s\n", debugstr_w(filename));
/* if we did not click in file list to get there */
if (control != lst1)
{
if (!FD31_TestPath( lfs, filename) )
return FALSE;
}
FD31_UpdateResult(lfs, filename);
if (internalUse)
{ /* called internally after a change in a combo */
if (lfs->hook)
{
FD31_CallWindowProc(lfs, lfs->lbselchstring, control,
MAKELONG(itemIndex,CD_LBSELCHANGE));
}
return TRUE;
}
FD31_UpdateFileTitle(lfs);
if (lfs->hook)
{
lRet = (BOOL)FD31_CallWindowProc(lfs, lfs->fileokstring,
0, lfs->lParam );
if (lRet)
{
*ofnW = ofnsav; /* restore old state */
return FALSE;
}
}
if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
{
if (ofnW->lpstrFile)
{
LPWSTR str = (LPWSTR)ofnW->lpstrFile;
LPWSTR ptr = strrchrW(str, '\\');
str[lstrlenW(str) + 1] = '\0';
*ptr = 0;
}
}
return TRUE;
}
static HRESULT install_file(install_ctx_t *ctx, const WCHAR *cache_file)
{
BSTR path;
HRESULT hres;
TRACE("%s\n", debugstr_w(cache_file));
ctx->cache_file = cache_file;
if(!install_warning(ctx)) {
TRACE("Installation cancelled\n");
return S_OK;
}
hres = IUri_GetPath(ctx->uri, &path);
if(SUCCEEDED(hres)) {
const WCHAR *ptr, *ptr2, *ext;
ptr = strrchrW(path, '/');
if(!ptr)
ptr = path;
else
ptr++;
ptr2 = strrchrW(ptr, '\\');
if(ptr2)
ptr = ptr2+1;
ctx->file_name = ptr;
ext = strrchrW(ptr, '.');
if(!ext)
ext = ptr;
if(!strcmpW(ext, cab_extW)) {
hres = install_cab_file(ctx);
}else {
FIXME("Unsupported extension %s\n", debugstr_w(ext));
hres = E_NOTIMPL;
}
SysFreeString(path);
}
return hres;
}
/* downloads a remote cabinet and extracts it if it exists */
static UINT msi_extract_remote_cabinet( MSIPACKAGE *package, struct media_info *mi )
{
FDICABINETINFO cabinfo;
WCHAR temppath[MAX_PATH];
WCHAR src[MAX_PATH];
LPSTR cabpath;
LPCWSTR file;
LPWSTR ptr;
HFDI hfdi;
ERF erf;
int hf;
/* the URL is the path prefix of the package URL and the filename
* of the file to download
*/
ptr = strrchrW(package->PackagePath, '/');
lstrcpynW(src, package->PackagePath, ptr - package->PackagePath + 2);
ptr = strrchrW(mi->source, '\\');
lstrcatW(src, ptr + 1);
file = msi_download_file( src, temppath );
lstrcpyW(mi->source, file);
/* check if the remote cabinet still exists, ignore if it doesn't */
hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read,
cabinet_write, cabinet_close, cabinet_seek, 0, &erf);
if (!hfdi)
{
ERR("FDICreate failed\n");
return ERROR_FUNCTION_FAILED;
}
cabpath = strdupWtoA(mi->source);
hf = cabinet_open(cabpath, _O_RDONLY, 0);
if (!FDIIsCabinet(hfdi, hf, &cabinfo))
{
WARN("Remote cabinet %s does not exist.\n", debugstr_w(mi->source));
msi_free(cabpath);
return ERROR_SUCCESS;
}
msi_free(cabpath);
return !extract_cabinet_file(package, mi->source, mi->last_path);
}
/* Assumes 'process_features_cs' is held. */
static HRESULT load_process_feature(INTERNETFEATURELIST feature)
{
DWORD res;
HKEY feature_control;
WCHAR module_name[MAX_PATH];
LPCWSTR process_name, feature_name;
HRESULT hres = S_FALSE;
BOOL check_hklm = FALSE;
BOOL enabled;
if (!GetModuleFileNameW(NULL, module_name, sizeof(module_name)/sizeof(WCHAR))) {
ERR("Failed to get module file name: %u\n", GetLastError());
return E_UNEXPECTED;
}
process_name = strrchrW(module_name, '\\');
if(!process_name) {
ERR("Invalid module file name: %s\n", debugstr_w(module_name));
return E_UNEXPECTED;
}
/* Skip past the '\\' in front of the filename. */
++process_name;
feature_name = process_feature_controls[feature].feature_name;
res = RegOpenKeyW(HKEY_CURRENT_USER, feature_control_keyW, &feature_control);
if(res == ERROR_SUCCESS) {
if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
hres = enabled ? S_OK : S_FALSE;
process_feature_controls[feature].enabled = enabled;
} else
/* We didn't find anything in HKCU, so check HKLM. */
check_hklm = TRUE;
RegCloseKey(feature_control);
}
if(check_hklm) {
res = RegOpenKeyW(HKEY_LOCAL_MACHINE, feature_control_keyW, &feature_control);
if(res == ERROR_SUCCESS) {
if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
hres = enabled ? S_OK : S_FALSE;
process_feature_controls[feature].enabled = enabled;
}
RegCloseKey(feature_control);
}
}
/* Don't bother checking the registry again for this feature. */
process_feature_controls[feature].check_registry = FALSE;
return hres;
}
static HRESULT WINAPI Host_get_ScriptName(IHost *iface, BSTR *out_ScriptName)
{
WCHAR *scriptName;
WINE_TRACE("(%p)\n", out_ScriptName);
scriptName = strrchrW(scriptFullName, '\\');
++scriptName;
if(!(*out_ScriptName = SysAllocString(scriptName)))
return E_OUTOFMEMORY;
return S_OK;
}
/***********************************************************************
* SetupQueryInfOriginalFileInformationW (SETUPAPI.@)
*/
BOOL WINAPI SetupQueryInfOriginalFileInformationW(
PSP_INF_INFORMATION InfInformation, UINT InfIndex,
PSP_ALTPLATFORM_INFO AlternativePlatformInfo,
PSP_ORIGINAL_FILE_INFO_W OriginalFileInfo)
{
LPCWSTR inf_name;
LPCWSTR inf_path;
HINF hinf;
static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
FIXME("(%p, %d, %p, %p): semi-stub\n", InfInformation, InfIndex,
AlternativePlatformInfo, OriginalFileInfo);
if (OriginalFileInfo->cbSize != sizeof(*OriginalFileInfo))
{
WARN("incorrect OriginalFileInfo->cbSize of %d\n", OriginalFileInfo->cbSize);
SetLastError(ERROR_INVALID_USER_BUFFER);
return FALSE;
}
inf_path = (LPWSTR)InfInformation->VersionData;
/* FIXME: we should get OriginalCatalogName from CatalogFile line in
* the original inf file and cache it, but that would require building a
* .pnf file. */
hinf = SetupOpenInfFileW(inf_path, NULL, INF_STYLE_WIN4, NULL);
if (hinf == INVALID_HANDLE_VALUE) return FALSE;
if (!SetupGetLineTextW(NULL, hinf, wszVersion, wszCatalogFile,
OriginalFileInfo->OriginalCatalogName,
sizeof(OriginalFileInfo->OriginalCatalogName)/sizeof(OriginalFileInfo->OriginalCatalogName[0]),
NULL))
{
OriginalFileInfo->OriginalCatalogName[0] = '\0';
}
SetupCloseInfFile(hinf);
/* FIXME: not quite correct as we just return the same file name as
* destination (copied) inf file, not the source (original) inf file.
* to fix it properly would require building a .pnf file */
/* file name is stored in VersionData field of InfInformation */
inf_name = strrchrW(inf_path, '\\');
if (inf_name) inf_name++;
else inf_name = inf_path;
strcpyW(OriginalFileInfo->OriginalInfName, inf_name);
return TRUE;
}
/***********************************************************************
* FindMimeFromData (URLMON.@)
*
* Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
*/
HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer,
DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags,
LPWSTR* ppwzMimeOut, DWORD dwReserved)
{
TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize,
debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved);
if(dwMimeFlags)
WARN("dwMimeFlags=%08x\n", dwMimeFlags);
if(dwReserved)
WARN("dwReserved=%d\n", dwReserved);
/* pBC seams to not be used */
if(!ppwzMimeOut || (!pwzUrl && !pBuffer))
return E_INVALIDARG;
if(pwzMimeProposed || pBuffer)
return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, ppwzMimeOut);
if(pwzUrl) {
HKEY hkey;
DWORD res, size;
LPCWSTR ptr;
WCHAR mime[64];
static const WCHAR wszContentType[] =
{'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
ptr = strrchrW(pwzUrl, '.');
if(!ptr)
return E_FAIL;
res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey);
if(res != ERROR_SUCCESS)
return HRESULT_FROM_WIN32(res);
size = sizeof(mime);
res = RegQueryValueExW(hkey, wszContentType, NULL, NULL, (LPBYTE)mime, &size);
RegCloseKey(hkey);
if(res != ERROR_SUCCESS)
return HRESULT_FROM_WIN32(res);
*ppwzMimeOut = CoTaskMemAlloc(size);
memcpy(*ppwzMimeOut, mime, size);
return S_OK;
}
return E_FAIL;
}
/******************************************************************
* macho_search_and_load_file
*
* Lookup a file in standard Mach-O locations, and if found, load it
*/
static BOOL macho_search_and_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_addr,
struct macho_info* macho_info)
{
BOOL ret = FALSE;
struct module* module;
static WCHAR S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'};
const WCHAR* p;
TRACE("(%p/%p, %s, 0x%08lx, %p)\n", pcs, pcs->handle, debugstr_w(filename), load_addr,
macho_info);
if (filename == NULL || *filename == '\0') return FALSE;
if ((module = module_is_already_loaded(pcs, filename)))
{
macho_info->module = module;
module->format_info[DFI_MACHO]->u.macho_info->in_use = 1;
return module->module.SymType;
}
if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */
/* If has no directories, try LD_LIBRARY_PATH first. */
if (!strchrW(filename, '/'))
{
ret = macho_load_file_from_path(pcs, filename, load_addr,
getenv("PATH"), macho_info);
}
/* Try DYLD_LIBRARY_PATH, with just the filename (no directories). */
if (!ret)
{
if ((p = strrchrW(filename, '/'))) p++;
else p = filename;
ret = macho_load_file_from_path(pcs, p, load_addr,
getenv("DYLD_LIBRARY_PATH"), macho_info);
}
/* Try the path as given. */
if (!ret)
ret = macho_load_file(pcs, filename, load_addr, macho_info);
/* Try DYLD_FALLBACK_LIBRARY_PATH, with just the filename (no directories). */
if (!ret)
{
ret = macho_load_file_from_path(pcs, p, load_addr,
getenv("DYLD_FALLBACK_LIBRARY_PATH"), macho_info);
}
if (!ret && !strchrW(filename, '/'))
ret = macho_load_file_from_dll_path(pcs, filename, load_addr, macho_info);
return ret;
}
static BOOL create_full_path(LPCWSTR path)
{
LPWSTR new_path;
BOOL ret = TRUE;
int len;
new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
if (!new_path)
return FALSE;
strcpyW(new_path, path);
while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
new_path[len - 1] = 0;
while (!CreateDirectoryW(new_path, NULL))
{
LPWSTR slash;
DWORD last_error = GetLastError();
if(last_error == ERROR_ALREADY_EXISTS)
break;
if(last_error != ERROR_PATH_NOT_FOUND)
{
ret = FALSE;
break;
}
if(!(slash = strrchrW(new_path, '\\')))
{
ret = FALSE;
break;
}
len = slash - new_path;
new_path[len] = 0;
if(!create_full_path(new_path))
{
ret = FALSE;
break;
}
new_path[len] = '\\';
}
HeapFree(GetProcessHeap(), 0, new_path);
return ret;
}
/* determines the proper working directory for the INF file */
static HRESULT get_working_dir(ADVInfo *info, LPCWSTR inf_filename, LPCWSTR working_dir)
{
WCHAR path[MAX_PATH];
LPCWSTR ptr;
DWORD len;
static const WCHAR backslash[] = {'\\',0};
static const WCHAR inf_dir[] = {'\\','I','N','F',0};
if ((ptr = strrchrW(inf_filename, '\\')))
{
len = ptr - inf_filename + 1;
ptr = inf_filename;
}
else if (working_dir && *working_dir)
{
len = lstrlenW(working_dir) + 1;
ptr = working_dir;
}
else
{
GetCurrentDirectoryW(MAX_PATH, path);
lstrcatW(path, backslash);
lstrcatW(path, inf_filename);
/* check if the INF file is in the current directory */
if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
{
GetCurrentDirectoryW(MAX_PATH, path);
}
else
{
/* default to the windows\inf directory if all else fails */
GetWindowsDirectoryW(path, MAX_PATH);
lstrcatW(path, inf_dir);
}
len = lstrlenW(path) + 1;
ptr = path;
}
info->working_dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if (!info->working_dir)
return E_OUTOFMEMORY;
lstrcpynW(info->working_dir, ptr, len);
return S_OK;
}
/***********************************************************************
* create_fake_dll
*/
BOOL create_fake_dll( const WCHAR *name, const WCHAR *source )
{
HANDLE h;
BOOL ret;
SIZE_T size;
const WCHAR *filename;
void *buffer;
if (!(filename = strrchrW( name, '\\' ))) filename = name;
else filename++;
/* check for empty name which means to only create the directory */
if (!filename[0])
{
create_directories( name );
return TRUE;
}
if (filename[0] == '*' && !filename[1]) return create_wildcard_dlls( name );
add_handled_dll( filename );
if (!(h = create_dest_file( name ))) return TRUE; /* not a fake dll */
if (h == INVALID_HANDLE_VALUE) return FALSE;
if (source[0] == '-' && !source[1])
{
/* '-' source means delete the file */
TRACE( "deleting %s\n", debugstr_w(name) );
ret = FALSE;
}
else if ((buffer = load_fake_dll( source, &size )))
{
DWORD written;
ret = (WriteFile( h, buffer, size, &written, NULL ) && written == size);
if (ret) register_fake_dll( name, buffer, size );
else ERR( "failed to write to %s (error=%u)\n", debugstr_w(name), GetLastError() );
}
else
{
WARN( "fake dll %s not found for %s\n", debugstr_w(source), debugstr_w(name) );
ret = build_fake_dll( h, name );
}
CloseHandle( h );
if (!ret) DeleteFileW( name );
return ret;
}
static HRESULT WINAPI Host_get_Path(IHost *iface, BSTR *out_Path)
{
WCHAR path[MAX_PATH];
int howMany;
WCHAR *pos;
WINE_TRACE("(%p)\n", out_Path);
if(GetModuleFileNameW(NULL, path, sizeof(path)/sizeof(WCHAR)) == 0)
return E_FAIL;
pos = strrchrW(path, '\\');
howMany = pos - path;
if(!(*out_Path = SysAllocStringLen(path, howMany)))
return E_OUTOFMEMORY;
return S_OK;
}
/***********************************************************************
* extract_cabinet_file
*
* Extract files from a cab file.
*/
static BOOL extract_cabinet_file(MSIPACKAGE* package, struct media_info *mi)
{
LPSTR cabinet, cab_path = NULL;
LPWSTR ptr;
HFDI hfdi;
ERF erf;
BOOL ret = FALSE;
CabData data;
TRACE("Extracting %s\n", debugstr_w(mi->source));
hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read,
cabinet_write, cabinet_close, cabinet_seek, 0, &erf);
if (!hfdi)
{
ERR("FDICreate failed\n");
return FALSE;
}
ptr = strrchrW(mi->source, '\\') + 1;
cabinet = strdupWtoA(ptr);
if (!cabinet)
goto done;
cab_path = strdupWtoA(mi->source);
if (!cab_path)
goto done;
cab_path[ptr - mi->source] = '\0';
data.package = package;
data.mi = mi;
ret = FDICopy(hfdi, cabinet, cab_path, 0, cabinet_notify, NULL, &data);
if (!ret)
ERR("FDICopy failed\n");
done:
FDIDestroy(hfdi);
msi_free(cabinet);
msi_free(cab_path);
if (ret)
mi->is_extracted = TRUE;
return ret;
}
/***********************************************************************
* LaunchINFSectionExW (ADVPACK.@)
*
* Installs an INF section with BACKUP/ROLLBACK capabilities.
*
* PARAMS
* hWnd [I] Handle to parent window, NULL for desktop.
* hInst [I] Instance of the process.
* cmdline [I] Contains parameters in the order INF,section,CAB,flags,reboot.
* show [I] How the window should be shown.
*
* RETURNS
* Success: ADV_SUCCESS.
* Failure: ADV_FAILURE.
*
* NOTES
* INF - Filename of the INF to launch.
* section - INF section to install.
* flags - see advpub.h.
* reboot - smart reboot behavior
* 'A' Always reboot.
* 'I' Reboot if needed (default).
* 'N' No reboot.
*
* BUGS
* Doesn't handle the reboot flag.
*/
HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
{
LPWSTR cmdline_copy, cmdline_ptr;
LPWSTR flags, ptr;
CABINFOW cabinfo;
HRESULT hr;
TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
if (!cmdline)
return ADV_FAILURE;
cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
cmdline_ptr = cmdline_copy;
lstrcpyW(cmdline_copy, cmdline);
cabinfo.pszInf = get_parameter(&cmdline_ptr, ',', TRUE);
cabinfo.pszSection = get_parameter(&cmdline_ptr, ',', TRUE);
cabinfo.pszCab = get_parameter(&cmdline_ptr, ',', TRUE);
*cabinfo.szSrcPath = '\0';
flags = get_parameter(&cmdline_ptr, ',', TRUE);
if (flags)
cabinfo.dwFlags = atolW(flags);
if (!is_full_path(cabinfo.pszCab) && !is_full_path(cabinfo.pszInf))
{
HeapFree(GetProcessHeap(), 0, cmdline_copy);
return E_INVALIDARG;
}
/* get the source path from the cab filename */
if (cabinfo.pszCab && *cabinfo.pszCab)
{
if (!is_full_path(cabinfo.pszCab))
lstrcpyW(cabinfo.szSrcPath, cabinfo.pszInf);
else
lstrcpyW(cabinfo.szSrcPath, cabinfo.pszCab);
ptr = strrchrW(cabinfo.szSrcPath, '\\');
*(++ptr) = '\0';
}
hr = ExecuteCabW(hWnd, &cabinfo, NULL);
HeapFree(GetProcessHeap(), 0, cmdline_copy);
return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
}
static HRESULT WINAPI ITSProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
{
ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
LPCWSTR base_end, ptr;
DWORD rel_len;
static const WCHAR separator[] = {':',':',0};
TRACE("(%p)->(%s %s %08x %p %d %p %d)\n", This, debugstr_w(pwzBaseUrl),
debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
pcchResult, dwReserved);
base_end = strstrW(pwzBaseUrl, separator);
if(!base_end)
return 0x80041001;
base_end += 2;
if(!skip_schema(pwzBaseUrl))
return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
if(strchrW(pwzRelativeUrl, ':'))
return STG_E_INVALIDNAME;
if(pwzRelativeUrl[0] == '#') {
base_end += strlenW(base_end);
}else if(pwzRelativeUrl[0] != '/') {
ptr = strrchrW(base_end, '/');
if(ptr)
base_end = ptr+1;
else
base_end += strlenW(base_end);
}
rel_len = strlenW(pwzRelativeUrl)+1;
*pcchResult = rel_len + (base_end-pwzBaseUrl);
if(*pcchResult > cchResult)
return E_OUTOFMEMORY;
memcpy(pwzResult, pwzBaseUrl, (base_end-pwzBaseUrl)*sizeof(WCHAR));
strcpyW(pwzResult + (base_end-pwzBaseUrl), pwzRelativeUrl);
return S_OK;
}
/******************************************************************************
* This function receives the currently read entry and performs the
* corresponding action.
* isUnicode affects parsing of REG_MULTI_SZ values
*/
static void processRegEntry(WCHAR* stdInput, BOOL isUnicode)
{
/*
* We encountered the end of the file, make sure we
* close the opened key and exit
*/
if (stdInput == NULL) {
closeKey();
return;
}
if ( stdInput[0] == '[') /* We are reading a new key */
{
WCHAR* keyEnd;
closeKey(); /* Close the previous key */
/* Get rid of the square brackets */
stdInput++;
keyEnd = strrchrW(stdInput, ']');
if (keyEnd)
*keyEnd='\0';
/* delete the key if we encounter '-' at the start of reg key */
if ( stdInput[0] == '-')
{
delete_registry_key(stdInput + 1);
} else if ( openKeyW(stdInput) != ERROR_SUCCESS )
{
char* stdInputA = GetMultiByteString(stdInput);
fprintf(stderr,"%s: setValue failed to open key %s\n",
getAppName(), stdInputA);
HeapFree(GetProcessHeap(), 0, stdInputA);
}
} else if( currentKeyHandle &&
(( stdInput[0] == '@') || /* reading a default @=data pair */
( stdInput[0] == '\"'))) /* reading a new value=data pair */
{
processSetValue(stdInput, isUnicode);
} else
{
/* Since we are assuming that the file format is valid we must be
* reading a blank line which indicates the end of this key processing
*/
closeKey();
}
}
static WCHAR *get_parent_dir(WCHAR* path)
{
WCHAR *last_slash;
WCHAR *result;
int len;
last_slash = strrchrW( path, '\\' );
if (last_slash == NULL)
len = 1;
else
len = last_slash - path + 1;
result = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
CopyMemory(result, path, (len-1)*sizeof(WCHAR));
result[len-1] = '\0';
return result;
}
static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
{
MSIRECORD *uirow;
LPWSTR uipath, p;
/* the UI chunk */
uirow = MSI_CreateRecord( 9 );
MSI_RecordSetStringW( uirow, 1, f->FileName );
uipath = strdupW( f->TargetPath );
p = strrchrW(uipath,'\\');
if (p)
p[1]=0;
MSI_RecordSetStringW( uirow, 9, uipath);
MSI_RecordSetInteger( uirow, 6, f->FileSize );
ui_actiondata( package, action, uirow);
msiobj_release( &uirow->hdr );
msi_free( uipath );
ui_progress( package, 2, f->FileSize, 0, 0);
}
/******************************************************************
* macho_load_cb
*
* Callback for macho_load_module, used to walk the list of loaded
* modules.
*/
static BOOL macho_load_cb(const WCHAR* name, unsigned long addr, void* user)
{
struct macho_load* ml = user;
const WCHAR* p;
TRACE("(%s, 0x%08lx, %p)\n", debugstr_w(name), addr, user);
/* memcmp is needed for matches when bufstr contains also version information
* ml->name: libc.so, name: libc.so.6.0
*/
p = strrchrW(name, '/');
if (!p++) p = name;
if (!memcmp(p, ml->name, lstrlenW(ml->name) * sizeof(WCHAR)))
{
ml->ret = macho_search_and_load_file(ml->pcs, name, addr, &ml->macho_info);
return FALSE;
}
return TRUE;
}
