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 LPWSTR get_ini_field(LPWSTR buf, int field)
{
LPWSTR beg, end;
int i = 1;
if (field == 0)
return strdupW(buf);
beg = buf;
while ((end = strchrW(beg, ',')) && i < field)
{
beg = end + 1;
while (*beg && *beg == ' ')
beg++;
i++;
}
end = strchrW(beg, ',');
if (!end)
end = beg + lstrlenW(beg);
*end = '\0';
return strdupW(beg);
}
static HRESULT parse_culture(IAssemblyNameImpl *name, LPCWSTR culture)
{
static const WCHAR empty[] = {0};
if (lstrlenW(culture) == 2)
name->culture = strdupW(culture);
else
name->culture = strdupW(empty);
return S_OK;
}
static WCHAR *strstriW(const WCHAR *str, const WCHAR *sub)
{
LPWSTR strlower, sublower, r;
strlower = CharLowerW(strdupW(str));
sublower = CharLowerW(strdupW(sub));
r = strstrW(strlower, sublower);
if (r)
r = (LPWSTR)str + (r - strlower);
heap_free(strlower);
heap_free(sublower);
return r;
}
/******************************************************************************
* backend_load [internal]
*
* load and init a backend
*
* PARAMS
* name [I] Printprovider to use for the backend. NULL for the local print provider
*
* RETURNS
* Success: PTR to the backend
* Failure: NULL
*
*/
static backend_t * backend_load(LPWSTR dllname, LPWSTR name, LPWSTR regroot)
{
BOOL (WINAPI *pInitializePrintProvidor)(LPPRINTPROVIDOR, DWORD, LPWSTR);
DWORD id;
DWORD res;
TRACE("(%s, %s, %s)\n", debugstr_w(dllname), debugstr_w(name), debugstr_w(regroot));
EnterCriticalSection(&backend_cs);
id = used_backends;
backend[id] = heap_alloc_zero(sizeof(backend_t));
if (!backend[id]) {
LeaveCriticalSection(&backend_cs);
return NULL;
}
backend[id]->dllname = strdupW(dllname);
backend[id]->name = strdupW(name);
backend[id]->regroot = strdupW(regroot);
backend[id]->dll = LoadLibraryW(dllname);
if (backend[id]->dll) {
pInitializePrintProvidor = (void *) GetProcAddress(backend[id]->dll, "InitializePrintProvidor");
if (pInitializePrintProvidor) {
/* native localspl does not clear unused entries */
res = pInitializePrintProvidor((PRINTPROVIDOR *) backend[id], sizeof(PRINTPROVIDOR), regroot);
if (res) {
used_backends++;
backend[id]->index = used_backends;
LeaveCriticalSection(&backend_cs);
TRACE("--> backend #%d: %p (%s)\n", id, backend[id], debugstr_w(dllname));
return backend[id];
}
}
FreeLibrary(backend[id]->dll);
}
heap_free(backend[id]->dllname);
heap_free(backend[id]->name);
heap_free(backend[id]->regroot);
heap_free(backend[id]);
backend[id] = NULL;
LeaveCriticalSection(&backend_cs);
WARN("failed to init %s: %u\n", debugstr_w(dllname), GetLastError());
return NULL;
}
static LANGID *parse_languages( const WCHAR *languages, DWORD *num_ids )
{
UINT i, count = 1;
WCHAR *str = strdupW( languages ), *p, *q;
LANGID *ret;
if (!str) return NULL;
for (p = q = str; (q = strchrW( q, ',' )); q++) count++;
if (!(ret = msi_alloc( count * sizeof(LANGID) )))
{
msi_free( str );
return NULL;
}
i = 0;
while (*p)
{
q = strchrW( p, ',' );
if (q) *q = 0;
ret[i] = atoiW( p );
if (!q) break;
p = q + 1;
i++;
}
msi_free( str );
*num_ids = count;
return ret;
}
static UINT ACTION_AppSearchIni(MSIPACKAGE *package, LPWSTR *appValue,
MSISIGNATURE *sig)
{
static const WCHAR query[] = {
's','e','l','e','c','t',' ','*',' ',
'f','r','o','m',' ',
'I','n','i','L','o','c','a','t','o','r',' ',
'w','h','e','r','e',' ',
'S','i','g','n','a','t','u','r','e','_',' ','=',' ','\'','%','s','\'',0};
MSIRECORD *row;
LPWSTR fileName, section, key;
int field, type;
WCHAR buf[MAX_PATH];
TRACE("%s\n", debugstr_w(sig->Name));
*appValue = NULL;
row = MSI_QueryGetRecord( package->db, query, sig->Name );
if (!row)
{
TRACE("failed to query IniLocator for %s\n", debugstr_w(sig->Name));
return ERROR_SUCCESS;
}
fileName = msi_dup_record_field(row, 2);
section = msi_dup_record_field(row, 3);
key = msi_dup_record_field(row, 4);
field = MSI_RecordGetInteger(row, 5);
type = MSI_RecordGetInteger(row, 6);
if (field == MSI_NULL_INTEGER)
field = 0;
if (type == MSI_NULL_INTEGER)
type = 0;
GetPrivateProfileStringW(section, key, NULL, buf, MAX_PATH, fileName);
if (buf[0])
{
switch (type & 0x0f)
{
case msidbLocatorTypeDirectory:
FIXME("unimplemented for Directory (%s)\n", debugstr_w(buf));
break;
case msidbLocatorTypeFileName:
FIXME("unimplemented for File (%s)\n", debugstr_w(buf));
break;
case msidbLocatorTypeRawValue:
*appValue = strdupW(buf);
break;
}
}
msi_free(fileName);
msi_free(section);
msi_free(key);
msiobj_release(&row->hdr);
return ERROR_SUCCESS;
}
UINT MSI_RecordSetStringW( MSIRECORD *rec, UINT iField, LPCWSTR szValue )
{
LPWSTR str;
TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue));
if( iField > rec->count )
return ERROR_INVALID_FIELD;
MSI_FreeField( &rec->fields[iField] );
if( szValue && szValue[0] )
{
str = strdupW( szValue );
rec->fields[iField].type = MSIFIELD_WSTR;
rec->fields[iField].u.szwVal = str;
}
else
{
rec->fields[iField].type = MSIFIELD_NULL;
rec->fields[iField].u.szwVal = NULL;
}
return 0;
}
/**
* get_config_key: Retrieves a configuration value from the registry
*
* char *subkey : the name of the config section
* char *name : the name of the config value
* char *default : if the key isn't found, return this value instead
*
* Returns a buffer holding the value if successful, NULL if
* not. Caller is responsible for releasing the result.
*
*/
static WCHAR *get_config_key (HKEY root, const WCHAR *subkey, const WCHAR *name, const WCHAR *def)
{
LPWSTR buffer = NULL;
DWORD len;
HKEY hSubKey = NULL;
DWORD res;
WINE_TRACE("subkey=%s, name=%s, def=%s\n", wine_dbgstr_w(subkey),
wine_dbgstr_w(name), wine_dbgstr_w(def));
res = RegOpenKeyExW(root, subkey, 0, MAXIMUM_ALLOWED, &hSubKey);
if (res != ERROR_SUCCESS)
{
if (res == ERROR_FILE_NOT_FOUND)
{
WINE_TRACE("Section key not present - using default\n");
return def ? strdupW(def) : NULL;
}
else
{
WINE_ERR("RegOpenKey failed on wine config key (res=%d)\n", res);
}
goto end;
}
res = RegQueryValueExW(hSubKey, name, NULL, NULL, NULL, &len);
if (res == ERROR_FILE_NOT_FOUND)
{
WINE_TRACE("Value not present - using default\n");
buffer = def ? strdupW(def) : NULL;
goto end;
} else if (res != ERROR_SUCCESS)
{
WINE_ERR("Couldn't query value's length (res=%d)\n", res);
goto end;
}
buffer = HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR));
RegQueryValueExW(hSubKey, name, NULL, NULL, (LPBYTE) buffer, &len);
WINE_TRACE("buffer=%s\n", wine_dbgstr_w(buffer));
end:
RegCloseKey(hSubKey);
return buffer;
}
HRESULT IAssemblyName_SetPath(IAssemblyName *iface, LPCWSTR path)
{
IAssemblyNameImpl *name = unsafe_impl_from_IAssemblyName(iface);
name->path = strdupW(path);
if (!name->path)
return E_OUTOFMEMORY;
return S_OK;
}
/************************************************************************
* PSDRV_StartDoc
*/
INT PSDRV_StartDoc( PHYSDEV dev, const DOCINFOW *doc )
{
PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
DOC_INFO_1W di;
PRINTER_DEFAULTSW prn_def;
TRACE("(%p, %p) => %s, %s, %s\n", physDev, doc, debugstr_w(doc->lpszDocName),
debugstr_w(doc->lpszOutput), debugstr_w(doc->lpszDatatype));
if(physDev->job.id) {
FIXME("hJob != 0. Now what?\n");
return 0;
}
prn_def.pDatatype = NULL;
prn_def.pDevMode = &physDev->pi->Devmode->dmPublic;
prn_def.DesiredAccess = PRINTER_ACCESS_USE;
if (!OpenPrinterW( physDev->pi->friendly_name, &physDev->job.hprinter, &prn_def ))
{
WARN("OpenPrinter(%s, ...) failed: %d\n",
debugstr_w(physDev->pi->friendly_name), GetLastError());
return 0;
}
di.pDocName = (LPWSTR) doc->lpszDocName;
di.pDatatype = NULL;
if(doc->lpszOutput)
di.pOutputFile = (LPWSTR) doc->lpszOutput;
else if(physDev->job.output)
di.pOutputFile = physDev->job.output;
else
di.pOutputFile = NULL;
TRACE("using output: %s\n", debugstr_w(di.pOutputFile));
/* redirection located in HKCU\Software\Wine\Printing\Spooler
is done during winspool.drv,ScheduleJob */
physDev->job.id = StartDocPrinterW(physDev->job.hprinter, 1, (LPBYTE) &di);
if(!physDev->job.id) {
WARN("StartDocPrinter() failed: %d\n", GetLastError());
ClosePrinter(physDev->job.hprinter);
return 0;
}
physDev->job.banding = FALSE;
physDev->job.OutOfPage = TRUE;
physDev->job.PageNo = 0;
physDev->job.quiet = FALSE;
physDev->job.in_passthrough = FALSE;
physDev->job.had_passthrough_rect = FALSE;
physDev->job.doc_name = strdupW( doc->lpszDocName );
return physDev->job.id;
}
HRESULT assembly_create(ASSEMBLY **out, LPCWSTR file)
{
ASSEMBLY *assembly;
HRESULT hr;
*out = NULL;
assembly = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASSEMBLY));
if (!assembly)
return E_OUTOFMEMORY;
assembly->path = strdupW(file);
if (!assembly->path)
{
hr = E_OUTOFMEMORY;
goto failed;
}
assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (assembly->hfile == INVALID_HANDLE_VALUE)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto failed;
}
assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,
0, 0, NULL);
if (!assembly->hmap)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto failed;
}
assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);
if (!assembly->data)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto failed;
}
hr = parse_pe_header(assembly);
if (FAILED(hr)) goto failed;
hr = parse_clr_metadata(assembly);
if (FAILED(hr)) goto failed;
*out = assembly;
return S_OK;
failed:
assembly_release(assembly);
return hr;
}
static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list)
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,
LPCWSTR remoteName, LPCWSTR localName,
BackgroundCopyFileImpl **file)
{
BackgroundCopyFileImpl *This;
TRACE("(%s, %s, %p)\n", debugstr_w(remoteName), debugstr_w(localName), file);
This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
if (!This)
return E_OUTOFMEMORY;
This->info.RemoteName = strdupW(remoteName);
if (!This->info.RemoteName)
{
HeapFree(GetProcessHeap(), 0, This);
return E_OUTOFMEMORY;
}
This->info.LocalName = strdupW(localName);
if (!This->info.LocalName)
{
HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
HeapFree(GetProcessHeap(), 0, This);
return E_OUTOFMEMORY;
}
This->IBackgroundCopyFile2_iface.lpVtbl = &BackgroundCopyFile2Vtbl;
This->ref = 1;
This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
This->fileProgress.BytesTransferred = 0;
This->fileProgress.Completed = FALSE;
This->owner = owner;
This->read_size = 0;
This->tempFileName[0] = 0;
IBackgroundCopyJob3_AddRef(&owner->IBackgroundCopyJob3_iface);
*file = This;
return S_OK;
}
static UINT check_directory( MSIPACKAGE *package, const WCHAR *dir, WCHAR **appValue )
{
DWORD attr = msi_get_file_attributes( package, dir );
if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
{
TRACE("directory exists, returning %s\n", debugstr_w(dir));
*appValue = strdupW(dir);
}
return ERROR_SUCCESS;
}
static UINT ACTION_CheckDirectory(MSIPACKAGE *package, LPCWSTR dir,
LPWSTR *appValue)
{
DWORD attr = GetFileAttributesW(dir);
if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
{
TRACE("directory exists, returning %s\n", debugstr_w(dir));
*appValue = strdupW(dir);
}
return ERROR_SUCCESS;
}
static void add_device(IMMDevice *device, DevMap *devmap)
{
LPWSTR devid;
HRESULT hr;
hr = IMMDevice_GetId(device, &devid);
if(SUCCEEDED(hr))
{
devmap->devid = strdupW(devid);
devmap->name = get_device_name(device);
TRACE("Got device \"%s\", \"%ls\"\n", devmap->name, devmap->devid);
CoTaskMemFree(devid);
}
}
BOOL validate_service_config(struct service_entry *entry)
{
if (entry->config.dwServiceType & SERVICE_WIN32 && (entry->config.lpBinaryPathName == NULL || !entry->config.lpBinaryPathName[0]))
{
WINE_ERR("Service %s is Win32 but has no image path set\n", wine_dbgstr_w(entry->name));
return FALSE;
}
switch (entry->config.dwServiceType)
{
case SERVICE_KERNEL_DRIVER:
case SERVICE_FILE_SYSTEM_DRIVER:
case SERVICE_WIN32_OWN_PROCESS:
case SERVICE_WIN32_SHARE_PROCESS:
/* No problem */
break;
case SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS:
case SERVICE_WIN32_SHARE_PROCESS | SERVICE_INTERACTIVE_PROCESS:
/* These can be only run as LocalSystem */
if (entry->config.lpServiceStartName && strcmpiW(entry->config.lpServiceStartName, SZ_LOCAL_SYSTEM) != 0)
{
WINE_ERR("Service %s is interactive but has a start name\n", wine_dbgstr_w(entry->name));
return FALSE;
}
break;
default:
WINE_ERR("Service %s has an unknown service type (0x%x)\n", wine_dbgstr_w(entry->name), entry->config.dwServiceType);
return FALSE;
}
/* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */
if (entry->config.dwStartType > SERVICE_DISABLED)
{
WINE_ERR("Service %s has an unknown start type\n", wine_dbgstr_w(entry->name));
return FALSE;
}
/* SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services */
if (((entry->config.dwStartType == SERVICE_BOOT_START) || (entry->config.dwStartType == SERVICE_SYSTEM_START)) &&
((entry->config.dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (entry->config.dwServiceType & SERVICE_WIN32_SHARE_PROCESS)))
{
WINE_ERR("Service %s - SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services\n", wine_dbgstr_w(entry->name));
return FALSE;
}
if (entry->config.lpServiceStartName == NULL)
entry->config.lpServiceStartName = strdupW(SZ_LOCAL_SYSTEM);
return TRUE;
}
UINT MSI_RecordCopyField( MSIRECORD *in_rec, UINT in_n,
MSIRECORD *out_rec, UINT out_n )
{
UINT r = ERROR_SUCCESS;
msiobj_lock( &in_rec->hdr );
if ( in_n > in_rec->count || out_n > out_rec->count )
r = ERROR_FUNCTION_FAILED;
else if ( in_rec != out_rec || in_n != out_n )
{
LPWSTR str;
MSIFIELD *in, *out;
in = &in_rec->fields[in_n];
out = &out_rec->fields[out_n];
switch ( in->type )
{
case MSIFIELD_NULL:
break;
case MSIFIELD_INT:
out->u.iVal = in->u.iVal;
break;
case MSIFIELD_INTPTR:
out->u.pVal = in->u.pVal;
break;
case MSIFIELD_WSTR:
str = strdupW( in->u.szwVal );
if ( !str )
r = ERROR_OUTOFMEMORY;
else
out->u.szwVal = str;
break;
case MSIFIELD_STREAM:
IStream_AddRef( in->u.stream );
out->u.stream = in->u.stream;
break;
default:
ERR("invalid field type %d\n", in->type);
}
if (r == ERROR_SUCCESS)
out->type = in->type;
}
msiobj_unlock( &in_rec->hdr );
return r;
}
/***********************************************************************
* ldap_encode_sort_controlW (WLDAP32.@)
*
* Create a control for server sorted search results.
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* sortkey [I] Array of LDAPSortKey structures, each specifying an
* attribute to use as a sort key, a matching rule and
* the sort order (ascending or descending).
* critical [I] Tells the server this control is critical to the
* search operation.
* control [O] LDAPControl created.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* This function is obsolete. Use its equivalent
* ldap_create_sort_control instead.
*/
ULONG CDECL ldap_encode_sort_controlW( WLDAP32_LDAP *ld, PLDAPSortKeyW *sortkeys,
PLDAPControlW ret, BOOLEAN critical )
{
LDAPControlW *control;
ULONG result;
if ((result = ldap_create_sort_controlW( ld, sortkeys, critical, &control )) == WLDAP32_LDAP_SUCCESS)
{
ret->ldctl_oid = strdupW(control->ldctl_oid);
bv_val_dup( &control->ldctl_value, &ret->ldctl_value );
ret->ldctl_iscritical = control->ldctl_iscritical;
ldap_control_freeW( control );
}
return result;
}
static void get_descriptors(HWND hdlg, ps_struct_t *ps_struct)
{
FORMATETC fmtetc;
STGMEDIUM stg;
fmtetc.tymed = TYMED_HGLOBAL;
fmtetc.dwAspect = DVASPECT_CONTENT;
fmtetc.ptd = NULL;
fmtetc.lindex = -1;
fmtetc.cfFormat = cf_object_descriptor;
if(IDataObject_GetData(ps_struct->ps->lpSrcDataObj, &fmtetc, &stg) == S_OK)
{
OBJECTDESCRIPTOR *obj_desc = GlobalLock(stg.u.hGlobal);
if(obj_desc->dwSrcOfCopy)
ps_struct->source_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwSrcOfCopy));
if(obj_desc->dwFullUserTypeName)
ps_struct->type_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwFullUserTypeName));
OleRegGetUserType(&obj_desc->clsid, USERCLASSTYPE_APPNAME, &ps_struct->app_name);
/* Get the icon here. If dwDrawAspect & DVASCPECT_ICON call GetData(CF_METAFILEPICT), otherwise
native calls OleGetIconFromClass(obj_desc->clsid) */
GlobalUnlock(stg.u.hGlobal);
GlobalFree(stg.u.hGlobal);
}
else
{
/* Try to get some data using some of the other clipboard formats */
}
fmtetc.cfFormat = cf_link_src_descriptor;
if(IDataObject_GetData(ps_struct->ps->lpSrcDataObj, &fmtetc, &stg) == S_OK)
{
OBJECTDESCRIPTOR *obj_desc = GlobalLock(stg.u.hGlobal);
if(obj_desc->dwSrcOfCopy)
ps_struct->link_source_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwSrcOfCopy));
if(obj_desc->dwFullUserTypeName)
ps_struct->link_type_name = strdupW((WCHAR*)((char*)obj_desc + obj_desc->dwFullUserTypeName));
GlobalUnlock(stg.u.hGlobal);
GlobalFree(stg.u.hGlobal);
}
if(ps_struct->source_name == NULL && ps_struct->link_source_name == NULL)
{
WCHAR buf[200];
LoadStringW(OLEDLG_hInstance, IDS_PS_UNKNOWN_SRC, buf, sizeof(buf)/sizeof(WCHAR));
ps_struct->source_name = strdupW(buf);
}
if(ps_struct->type_name == NULL && ps_struct->link_type_name == NULL)
{
WCHAR buf[200];
LoadStringW(OLEDLG_hInstance, IDS_PS_UNKNOWN_TYPE, buf, sizeof(buf)/sizeof(WCHAR));
ps_struct->type_name = strdupW(buf);
}
}
DWORD service_create(LPCWSTR name, struct service_entry **entry)
{
*entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**entry));
if (!*entry)
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
(*entry)->name = strdupW(name);
if (!(*entry)->name)
{
HeapFree(GetProcessHeap(), 0, *entry);
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
}
(*entry)->control_pipe = INVALID_HANDLE_VALUE;
(*entry)->status.dwCurrentState = SERVICE_STOPPED;
(*entry)->status.dwWin32ExitCode = ERROR_SERVICE_NEVER_STARTED;
/* all other fields are zero */
return ERROR_SUCCESS;
}
static HRESULT WINAPI downloadcb_OnProgress(IBindStatusCallback *iface, ULONG progress,
ULONG progress_max, ULONG status, const WCHAR *status_text)
{
struct downloadcb *This = impl_from_IBindStatusCallback(iface);
HRESULT hr = S_OK;
TRACE("%p)->(%u %u %u %s)\n", This, progress, progress_max, status, debugstr_w(status_text));
switch(status)
{
case BINDSTATUS_BEGINDOWNLOADDATA:
if (!This->engine->thread.download_start)
This->engine->thread.download_start = GetTickCount64();
/* fall-through */
case BINDSTATUS_DOWNLOADINGDATA:
case BINDSTATUS_ENDDOWNLOADDATA:
This->engine->thread.downloaded_kb = This->dl_previous_kb + progress / 1024;
if (This->engine->callback)
{
hr = IInstallEngineCallback_OnComponentProgress(This->engine->callback,
This->id, INSTALLSTATUS_DOWNLOADING, This->display, NULL, progress / 1024, This->dl_size);
}
break;
case BINDSTATUS_CACHEFILENAMEAVAILABLE:
This->cache_file = strdupW(status_text);
if (!This->cache_file)
{
ERR("Failed to allocate memory for cache file\n");
hr = E_OUTOFMEMORY;
}
break;
case BINDSTATUS_CONNECTING:
case BINDSTATUS_SENDINGREQUEST:
case BINDSTATUS_MIMETYPEAVAILABLE:
case BINDSTATUS_FINDINGRESOURCE:
break;
default:
FIXME("Unsupported status %u\n", status);
}
return hr;
}
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);
}
static void add_device(IMMDevice *device, vector_DevMap *list)
{
LPWSTR devid;
HRESULT hr;
hr = IMMDevice_GetId(device, &devid);
if(SUCCEEDED(hr))
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
CoTaskMemFree(devid);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
}
UINT CREATE_CreateView( MSIDATABASE *db, MSIVIEW **view, LPWSTR table,
column_info *col_info, BOOL hold )
{
MSICREATEVIEW *cv = NULL;
UINT r;
column_info *col;
BOOL temp = TRUE;
TRACE("%p\n", cv );
r = check_columns( col_info );
if( r != ERROR_SUCCESS )
return r;
cv = msi_alloc_zero( sizeof *cv );
if( !cv )
return ERROR_FUNCTION_FAILED;
for( col = col_info; col; col = col->next )
{
if (!col->table)
col->table = strdupW(table);
if( !col->temporary )
temp = FALSE;
}
/* fill the structure */
cv->view.ops = &create_ops;
msiobj_addref( &db->hdr );
cv->db = db;
cv->name = table;
cv->col_info = col_info;
cv->bIsTemp = temp;
*view = (MSIVIEW*) cv;
return ERROR_SUCCESS;
}
BOOL add_drive(char letter, const char *targetpath, const char *device, const WCHAR *label,
DWORD serial, DWORD type)
{
int driveIndex = letter_to_index(letter);
if(drives[driveIndex].in_use)
return FALSE;
WINE_TRACE("letter == '%c', unixpath == %s, device == %s, label == %s, serial == %08x, type == %d\n",
letter, wine_dbgstr_a(targetpath), wine_dbgstr_a(device),
wine_dbgstr_w(label), serial, type);
drives[driveIndex].letter = toupper(letter);
drives[driveIndex].unixpath = targetpath ? strdupA(targetpath) : NULL;
drives[driveIndex].device = device ? strdupA(device) : NULL;
drives[driveIndex].label = label ? strdupW(label) : NULL;
drives[driveIndex].serial = serial;
drives[driveIndex].type = type;
drives[driveIndex].in_use = TRUE;
drives[driveIndex].modified = TRUE;
return TRUE;
}
/**
* Returns the contents of the value at path. If not in the settings
* list, it will be fetched from the registry - failing that, the
* default will be used.
*
* If already in the list, the contents as given there will be
* returned. You are expected to HeapFree the result.
*/
WCHAR *get_reg_keyW(HKEY root, const WCHAR *path, const WCHAR *name, const WCHAR *def)
{
struct list *cursor;
struct setting *s;
WCHAR *val;
WINE_TRACE("path=%s, name=%s, def=%s\n", wine_dbgstr_w(path),
wine_dbgstr_w(name), wine_dbgstr_w(def));
/* check if it's in the list */
LIST_FOR_EACH( cursor, settings )
{
s = LIST_ENTRY(cursor, struct setting, entry);
if (root != s->root) continue;
if (lstrcmpiW(path, s->path) != 0) continue;
if (!s->name) continue;
if (lstrcmpiW(name, s->name) != 0) continue;
WINE_TRACE("found %s:%s in settings list, returning %s\n",
wine_dbgstr_w(path), wine_dbgstr_w(name),
wine_dbgstr_w(s->value));
return s->value ? strdupW(s->value) : NULL;
}
static UINT ACTION_AppSearchComponents(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig)
{
static const WCHAR query[] = {
'S','E','L','E','C','T',' ','*',' ',
'F','R','O','M',' ',
'`','C','o','m','p','L','o','c','a','t','o','r','`',' ',
'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','_','`',' ','=',' ',
'\'','%','s','\'',0};
static const WCHAR sigquery[] = {
'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
'`','S','i','g','n','a','t','u','r','e','`',' ',
'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','`',' ','=',' ',
'\'','%','s','\'',0};
MSIRECORD *row, *rec;
LPCWSTR signature, guid;
BOOL sigpresent = TRUE;
BOOL isdir;
UINT type;
WCHAR path[MAX_PATH];
DWORD size = MAX_PATH;
LPWSTR ptr;
DWORD attr;
TRACE("%s\n", debugstr_w(sig->Name));
*appValue = NULL;
row = MSI_QueryGetRecord(package->db, query, sig->Name);
if (!row)
{
TRACE("failed to query CompLocator for %s\n", debugstr_w(sig->Name));
return ERROR_SUCCESS;
}
signature = MSI_RecordGetString(row, 1);
guid = MSI_RecordGetString(row, 2);
type = MSI_RecordGetInteger(row, 3);
rec = MSI_QueryGetRecord(package->db, sigquery, signature);
if (!rec)
sigpresent = FALSE;
*path = '\0';
MsiLocateComponentW(guid, path, &size);
if (!*path)
goto done;
attr = GetFileAttributesW(path);
if (attr == INVALID_FILE_ATTRIBUTES)
goto done;
isdir = (attr & FILE_ATTRIBUTE_DIRECTORY);
if (type != msidbLocatorTypeDirectory && sigpresent && !isdir)
{
*appValue = app_search_file(path, sig);
}
else if (!sigpresent && (type != msidbLocatorTypeDirectory || isdir))
{
if (type == msidbLocatorTypeFileName)
{
ptr = strrchrW(path, '\\');
*(ptr + 1) = '\0';
}
else
PathAddBackslashW(path);
*appValue = strdupW(path);
}
else if (sigpresent)
{
PathAddBackslashW(path);
lstrcatW(path, MSI_RecordGetString(rec, 2));
attr = GetFileAttributesW(path);
if (attr != INVALID_FILE_ATTRIBUTES &&
!(attr & FILE_ATTRIBUTE_DIRECTORY))
*appValue = strdupW(path);
}
done:
if (rec) msiobj_release(&rec->hdr);
msiobj_release(&row->hdr);
return ERROR_SUCCESS;
}
static LPWSTR app_search_file(LPWSTR path, MSISIGNATURE *sig)
{
VS_FIXEDFILEINFO *info;
DWORD attr, handle, size;
LPWSTR val = NULL;
LPBYTE buffer;
if (!sig->File)
{
PathRemoveFileSpecW(path);
PathAddBackslashW(path);
attr = GetFileAttributesW(path);
if (attr != INVALID_FILE_ATTRIBUTES &&
(attr & FILE_ATTRIBUTE_DIRECTORY))
return strdupW(path);
return NULL;
}
attr = GetFileAttributesW(path);
if (attr == INVALID_FILE_ATTRIBUTES ||
(attr & FILE_ATTRIBUTE_DIRECTORY))
return NULL;
size = GetFileVersionInfoSizeW(path, &handle);
if (!size)
return strdupW(path);
buffer = msi_alloc(size);
if (!buffer)
return NULL;
if (!GetFileVersionInfoW(path, 0, size, buffer))
goto done;
if (!VerQueryValueW(buffer, szBackSlash, (LPVOID)&info, &size) || !info)
goto done;
if (sig->MinVersionLS || sig->MinVersionMS)
{
if (info->dwFileVersionMS < sig->MinVersionMS)
goto done;
if (info->dwFileVersionMS == sig->MinVersionMS &&
info->dwFileVersionLS < sig->MinVersionLS)
goto done;
}
if (sig->MaxVersionLS || sig->MaxVersionMS)
{
if (info->dwFileVersionMS > sig->MaxVersionMS)
goto done;
if (info->dwFileVersionMS == sig->MaxVersionMS &&
info->dwFileVersionLS > sig->MaxVersionLS)
goto done;
}
val = strdupW(path);
done:
msi_free(buffer);
return val;
}
