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; }