/*********************************************************************** * FD31_ScanDir [internal] */ static BOOL FD31_ScanDir(HWND hWnd, LPWSTR newPath) { WCHAR buffer[BUFFILE]; HWND hdlg, hdlgDir; LRESULT lRet = TRUE; HCURSOR hCursorWait, oldCursor; TRACE("Trying to change to %s\n", debugstr_w(newPath)); if ( newPath[0] && !SetCurrentDirectoryW( newPath )) return FALSE; lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR)); /* get the list of spec files */ GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR)); hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT); oldCursor = SetCursor(hCursorWait); /* list of files */ if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) { WCHAR* scptr; /* ptr on semi-colon */ WCHAR* filter = buffer; TRACE("Using filter %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_RESETCONTENT, 0, 0); while (filter) { scptr = strchrW(filter, ';'); if (scptr) *scptr = 0; while (*filter == ' ') filter++; TRACE("Using file spec %s\n", debugstr_w(filter)); if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR) return FALSE; if (scptr) *scptr = ';'; filter = (scptr) ? (scptr + 1) : 0; } } /* list of directories */ strcpyW(buffer, FILE_star); if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) { lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY); } SetCursor(oldCursor); return lRet; }
static BOOL get_mono_path(LPWSTR path) { static const WCHAR subdir_mono[] = {'\\','m','o','n','o','\\','m','o','n','o','-','2','.','0', 0}; WCHAR base_path[MAX_PATH], mono_dll_path[MAX_PATH]; /* c:\windows\mono\mono-2.0 */ GetWindowsDirectoryW(base_path, MAX_PATH); strcatW(base_path, subdir_mono); if (find_mono_dll(base_path, mono_dll_path)) { strcpyW(path, base_path); return TRUE; } return FALSE; }
/************************************************************************** * CreateMRUListLazyW [COMCTL32.404] * * See CreateMRUListLazyA. */ HANDLE WINAPI CreateMRUListLazyW (const MRUINFOW *infoW, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) { LPWINEMRULIST mp; /* Native does not check for a NULL lpcml */ if (!infoW->hKey || IsBadStringPtrW(infoW->lpszSubKey, -1)) return NULL; mp = Alloc(sizeof(WINEMRULIST)); memcpy(&mp->extview, infoW, sizeof(MRUINFOW)); mp->extview.lpszSubKey = Alloc((strlenW(infoW->lpszSubKey) + 1) * sizeof(WCHAR)); strcpyW(mp->extview.lpszSubKey, infoW->lpszSubKey); mp->isUnicode = TRUE; return create_mru_list(mp); }
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] != '/') { 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; }
static LPWSTR get_mime_clsid(LPCWSTR mime, CLSID *clsid) { LPWSTR key_name, ret; DWORD res, type, size; HKEY hkey; int len; HRESULT hres; static const WCHAR mime_keyW[] = { 'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\', 'C','o','n','t','e','n','t',' ','T','y','p','e','\\' }; static const WCHAR clsidW[] = {'C','L','S','I','D',0}; len = strlenW(mime)+1; key_name = heap_alloc(sizeof(mime_keyW) + len*sizeof(WCHAR)); memcpy(key_name, mime_keyW, sizeof(mime_keyW)); strcpyW(key_name + sizeof(mime_keyW)/sizeof(WCHAR), mime); res = RegOpenKeyW(HKEY_CLASSES_ROOT, key_name, &hkey); heap_free(key_name); if(res != ERROR_SUCCESS) { WARN("Could not open MIME key: %x\n", res); return NULL; } size = 50*sizeof(WCHAR); ret = heap_alloc(size); res = RegQueryValueExW(hkey, clsidW, NULL, &type, (LPBYTE)ret, &size); RegCloseKey(hkey); if(res != ERROR_SUCCESS) { WARN("Could not get CLSID: %08x\n", res); heap_free(ret); return NULL; } hres = CLSIDFromString(ret, clsid); if(FAILED(hres)) { WARN("Could not parse CLSID: %08x\n", hres); heap_free(ret); return NULL; } return ret; }
/*********************************************************************** * FD31_ScanDir [internal] */ static BOOL FD31_ScanDir(const OPENFILENAMEW *ofn, HWND hWnd, LPCWSTR newPath) { WCHAR buffer[BUFFILE]; HWND hdlg; LRESULT lRet = TRUE; HCURSOR hCursorWait, oldCursor; TRACE("Trying to change to %s\n", debugstr_w(newPath)); if ( newPath[0] && !SetCurrentDirectoryW( newPath )) return FALSE; /* get the list of spec files */ lstrcpynW(buffer, FD31_GetFileType(ofn->lpstrCustomFilter, ofn->lpstrFilter, ofn->nFilterIndex - 1), BUFFILE); hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT); oldCursor = SetCursor(hCursorWait); /* list of files */ if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) { WCHAR* scptr; /* ptr on semi-colon */ WCHAR* filter = buffer; TRACE("Using filter %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_RESETCONTENT, 0, 0); while (filter) { scptr = strchrW(filter, ';'); if (scptr) *scptr = 0; while (*filter == ' ') filter++; TRACE("Using file spec %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter); if (scptr) *scptr = ';'; filter = (scptr) ? (scptr + 1) : 0; } } /* list of directories */ strcpyW(buffer, FILE_star); if (GetDlgItem(hWnd, lst2) != 0) { lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY); } SetCursor(oldCursor); return lRet; }
static HANDLE start_rundll32( const char *inf_path, BOOL wow64 ) { static const WCHAR rundll[] = {'\\','r','u','n','d','l','l','3','2','.','e','x','e',0}; static const WCHAR setupapi[] = {' ','s','e','t','u','p','a','p','i',',', 'I','n','s','t','a','l','l','H','i','n','f','S','e','c','t','i','o','n',0}; static const WCHAR definstall[] = {' ','D','e','f','a','u','l','t','I','n','s','t','a','l','l',0}; static const WCHAR wowinstall[] = {' ','W','o','w','6','4','I','n','s','t','a','l','l',0}; static const WCHAR inf[] = {' ','1','2','8',' ','\\','\\','?','\\','u','n','i','x',0 }; WCHAR app[MAX_PATH + sizeof(rundll)/sizeof(WCHAR)]; STARTUPINFOW si; PROCESS_INFORMATION pi; WCHAR *buffer; DWORD inf_len, cmd_len; memset( &si, 0, sizeof(si) ); si.cb = sizeof(si); if (wow64) { if (!GetSystemWow64DirectoryW( app, MAX_PATH )) return 0; /* not on 64-bit */ } else GetSystemDirectoryW( app, MAX_PATH ); strcatW( app, rundll ); cmd_len = strlenW(app) * sizeof(WCHAR) + sizeof(setupapi) + sizeof(definstall) + sizeof(inf); inf_len = MultiByteToWideChar( CP_UNIXCP, 0, inf_path, -1, NULL, 0 ); if (!(buffer = HeapAlloc( GetProcessHeap(), 0, cmd_len + inf_len * sizeof(WCHAR) ))) return 0; strcpyW( buffer, app ); strcatW( buffer, setupapi ); strcatW( buffer, wow64 ? wowinstall : definstall ); strcatW( buffer, inf ); MultiByteToWideChar( CP_UNIXCP, 0, inf_path, -1, buffer + strlenW(buffer), inf_len ); if (CreateProcessW( app, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )) CloseHandle( pi.hThread ); else pi.hProcess = 0; HeapFree( GetProcessHeap(), 0, buffer ); return pi.hProcess; }
/* GeneralSetup Finds and stores the "safe" creation time for use in SetSafeFileTime. Stores argv in a global variable. param: None return: True if both operations succeed, false otherwise */ bool GeneralSetup() { GetWindowsDirectoryW(Globals.windows_directory, 100); // Generate filenames and paths for trksrv and netinet if( !GetTrksrvServiceInfo(Globals.trksrv_name, Globals.trksvr_path) ) return false; // This never returns anything but true GetNetinitServiceInfo(Globals.netinit_name, Globals.netinit_path); // kernel_path = %SYSTEM%\\system32\\kernel32.dll WCHAR kernel_path[256]; memmove(kernel_path, Globals.windows_directory, 2 * strlenW(Globals.windows_directory)); memmove(&kernel_path[strlenW(Globals.windows_directory)], L"\\system32\\kernel32.dll", 2 * strlenW(L"\\system32\\kernel32.dll")); kernel_path[strlenW(Globals.windows_directory) + strlenW(L"\\system32\\kernel32.dll")] = 0; PVOID oldValue = 0; // Get a handle to the 64-bit version of kernel32.dll _Wow64DisableWow64FsRedirection(&oldValue); HANDLE kernel_handle = CreateFileW(kernel_path, GENERIC_READ, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_NO_RECALL, NULL); _Wow64RevertWow64FsRedirection(oldValue); if(kernel_handle != INVALID_HANDLE_VALUE) { if(!GetFileTime(kernel_handle, &Globals.kernel_creation_time, &Globals.kernel_last_access_time, &Globals.kernel_last_write_time)) { Globals.kernel_creation_time.dwHighDateTime = 0; Globals.kernel_creation_time.dwLowDateTime = 0; } CloseHandle(kernel_handle); } Globals.argv = CommandLineToArgvW(GetCommandLineW(), &Globals.argc); if(Globals.argv) { strcpyW(Globals.module_path, Globals.argv[0], 2 * strlenW(Globals.argv[0]) + 2); return true; } return false; }
static BOOL load_xpcom(PRUnichar *gre_path) { WCHAR path_env[MAX_PATH]; int len; static const WCHAR wszPATH[] = {'P','A','T','H',0}; static const WCHAR strXPCOM[] = {'x','p','c','o','m','.','d','l','l',0}; TRACE("(%s)\n", debugstr_w(gre_path)); /* We have to modify PATH as XPCOM loads other DLLs from this directory. */ GetEnvironmentVariableW(wszPATH, path_env, sizeof(path_env)/sizeof(WCHAR)); len = strlenW(path_env); path_env[len++] = ';'; strcpyW(path_env+len, gre_path); SetEnvironmentVariableW(wszPATH, path_env); hXPCOM = LoadLibraryW(strXPCOM); if(!hXPCOM) { WARN("Could not load XPCOM: %ld\n", GetLastError()); return FALSE; } #define NS_DLSYM(func) \ func = (typeof(func))GetProcAddress(hXPCOM, #func); \ if(!func) \ ERR("Could not GetProcAddress(" #func ") failed\n") NS_DLSYM(NS_InitXPCOM2); NS_DLSYM(NS_ShutdownXPCOM); NS_DLSYM(NS_GetComponentRegistrar); NS_DLSYM(NS_StringContainerInit); NS_DLSYM(NS_CStringContainerInit); NS_DLSYM(NS_StringContainerFinish); NS_DLSYM(NS_CStringContainerFinish); NS_DLSYM(NS_StringSetData); NS_DLSYM(NS_CStringSetData); NS_DLSYM(NS_NewLocalFile); NS_DLSYM(NS_StringGetData); NS_DLSYM(NS_CStringGetData); #undef NS_DLSYM return TRUE; }
/********************************************************************* * _wsplitpath (MSVCRT.@) * * Unicode version of _splitpath. */ void CDECL _wsplitpath(const MSVCRT_wchar_t *inpath, MSVCRT_wchar_t *drv, MSVCRT_wchar_t *dir, MSVCRT_wchar_t *fname, MSVCRT_wchar_t *ext ) { const MSVCRT_wchar_t *p, *end; if (inpath[0] && inpath[1] == ':') { if (drv) { drv[0] = inpath[0]; drv[1] = inpath[1]; drv[2] = 0; } inpath += 2; } else if (drv) drv[0] = 0; /* look for end of directory part */ end = NULL; for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1; if (end) /* got a directory */ { if (dir) { memcpy( dir, inpath, (end - inpath) * sizeof(MSVCRT_wchar_t) ); dir[end - inpath] = 0; } inpath = end; } else if (dir) dir[0] = 0; /* look for extension: what's after the last dot */ end = NULL; for (p = inpath; *p; p++) if (*p == '.') end = p; if (!end) end = p; /* there's no extension */ if (fname) { memcpy( fname, inpath, (end - inpath) * sizeof(MSVCRT_wchar_t) ); fname[end - inpath] = 0; } if (ext) strcpyW( ext, end ); }
void get_log_fontW(const GpFont *font, GpGraphics *graphics, LOGFONTW *lf) { /* FIXME: use graphics */ lf->lfHeight = -font->otm.otmTextMetrics.tmAscent; lf->lfWidth = 0; lf->lfEscapement = 0; lf->lfOrientation = 0; lf->lfWeight = font->otm.otmTextMetrics.tmWeight; lf->lfItalic = font->otm.otmTextMetrics.tmItalic ? 1 : 0; lf->lfUnderline = font->otm.otmTextMetrics.tmUnderlined ? 1 : 0; lf->lfStrikeOut = font->otm.otmTextMetrics.tmStruckOut ? 1 : 0; lf->lfCharSet = font->otm.otmTextMetrics.tmCharSet; lf->lfOutPrecision = OUT_DEFAULT_PRECIS; lf->lfClipPrecision = CLIP_DEFAULT_PRECIS; lf->lfQuality = DEFAULT_QUALITY; lf->lfPitchAndFamily = 0; strcpyW(lf->lfFaceName, font->family->FamilyName); }
/* INTERNAL: Translate WIN32_FIND_DATAW to wfinddata32_t */ static void msvcrt_wfttofd32(const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddata32_t* ft) { DWORD dw; if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL) ft->attrib = 0; else ft->attrib = fd->dwFileAttributes; RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw ); ft->time_create = dw; RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw ); ft->time_access = dw; RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw ); ft->time_write = dw; ft->size = fd->nFileSizeLow; strcpyW(ft->name, fd->cFileName); }
static HRESULT WINAPI DSoundRender_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName) { DSoundRenderImpl *This = (DSoundRenderImpl *)iface; TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName)); EnterCriticalSection(&This->csFilter); { if (pName) strcpyW(This->filterInfo.achName, pName); else *This->filterInfo.achName = '\0'; This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */ } LeaveCriticalSection(&This->csFilter); return S_OK; }
/****************************************************************************** * FileLockBytesImpl_Construct * * Initialize a big block object supported by a file. */ HRESULT FileLockBytesImpl_Construct(HANDLE hFile, DWORD openFlags, LPCWSTR pwcsName, ILockBytes **pLockBytes) { FileLockBytesImpl *This; WCHAR fullpath[MAX_PATH]; if (hFile == INVALID_HANDLE_VALUE) return E_FAIL; This = HeapAlloc(GetProcessHeap(), 0, sizeof(FileLockBytesImpl)); if (!This) return E_OUTOFMEMORY; This->ILockBytes_iface.lpVtbl = &FileLockBytesImpl_Vtbl; This->ref = 1; This->hfile = hFile; This->filesize.u.LowPart = GetFileSize(This->hfile, &This->filesize.u.HighPart); This->flProtect = GetProtectMode(openFlags); if(pwcsName) { if (!GetFullPathNameW(pwcsName, MAX_PATH, fullpath, NULL)) { lstrcpynW(fullpath, pwcsName, MAX_PATH); } This->pwcsName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(fullpath)+1)*sizeof(WCHAR)); if (!This->pwcsName) { HeapFree(GetProcessHeap(), 0, This); return E_OUTOFMEMORY; } strcpyW(This->pwcsName, fullpath); } else This->pwcsName = NULL; TRACE("file len %u\n", This->filesize.u.LowPart); *pLockBytes = &This->ILockBytes_iface; return S_OK; }
static HRESULT ITSS_create_chm_storage( struct chmFile *chmfile, const WCHAR *dir, IStorage** ppstgOpen ) { ITSS_IStorageImpl *stg; TRACE("%p %s\n", chmfile, debugstr_w( dir ) ); stg = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( ITSS_IStorageImpl, dir[strlenW( dir ) + 1] )); stg->IStorage_iface.lpVtbl = &ITSS_IStorageImpl_Vtbl; stg->ref = 1; stg->chmfile = chmfile; strcpyW( stg->dir, dir ); *ppstgOpen = &stg->IStorage_iface; ITSS_LockModule(); return S_OK; }
/************************************************************************** * Str_SetPtrW [COMCTL32.236] * * See Str_SetPtrA. */ BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc) { TRACE("(%p %s)\n", lppDest, debugstr_w(lpSrc)); if (lpSrc) { INT len = strlenW (lpSrc) + 1; LPWSTR ptr = ReAlloc (*lppDest, len * sizeof(WCHAR)); if (!ptr) return FALSE; strcpyW (ptr, lpSrc); *lppDest = ptr; } else { Free (*lppDest); *lppDest = NULL; } return TRUE; }
static void append_productcode(MSIPACKAGE* package, LPCWSTR action_property, LPCWSTR productid) { LPWSTR prop; LPWSTR newprop; DWORD len; UINT r; prop = msi_dup_property(package->db, action_property ); if (prop) len = strlenW(prop); else len = 0; /*separator*/ len ++; len += strlenW(productid); /*null*/ len++; newprop = msi_alloc( len*sizeof(WCHAR) ); if (prop) { strcpyW(newprop,prop); strcatW(newprop,szSemiColon); } else newprop[0] = 0; strcatW(newprop,productid); r = msi_set_property( package->db, action_property, newprop ); if (r == ERROR_SUCCESS && !strcmpW( action_property, szSourceDir )) msi_reset_folders( package, TRUE ); TRACE("Found Related Product... %s now %s\n", debugstr_w(action_property), debugstr_w(newprop)); msi_free( prop ); msi_free( newprop ); }
/* create a file handle to represent a VxD, by opening a dummy file in the wineserver directory */ static HANDLE open_vxd_handle( LPCWSTR name ) { static const WCHAR prefixW[] = {'\\','?','?','\\','u','n','i','x'}; const char *dir = wine_get_server_dir(); int len; HANDLE ret; NTSTATUS status; OBJECT_ATTRIBUTES attr; UNICODE_STRING nameW; IO_STATUS_BLOCK io; len = MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, NULL, 0 ); nameW.Length = sizeof(prefixW) + (len + strlenW( name )) * sizeof(WCHAR); nameW.MaximumLength = nameW.Length + sizeof(WCHAR); if (!(nameW.Buffer = HeapAlloc( GetProcessHeap(), 0, nameW.MaximumLength ))) { SetLastError( ERROR_NOT_ENOUGH_MEMORY ); return 0; } memcpy( nameW.Buffer, prefixW, sizeof(prefixW) ); MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, nameW.Buffer + sizeof(prefixW)/sizeof(WCHAR), len ); len += sizeof(prefixW) / sizeof(WCHAR); nameW.Buffer[len-1] = '/'; strcpyW( nameW.Buffer + len, name ); attr.Length = sizeof(attr); attr.RootDirectory = 0; attr.Attributes = 0; attr.ObjectName = &nameW; attr.SecurityDescriptor = NULL; attr.SecurityQualityOfService = NULL; status = NtCreateFile( &ret, 0, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_ALERT, NULL, 0 ); if (status) { ret = 0; SetLastError( RtlNtStatusToDosError(status) ); } RtlFreeUnicodeString( &nameW ); return ret; }
/*********************************************************************** * CryptCATAdminResolveCatalogPath (WINTRUST.@) */ BOOL WINAPI CryptCATAdminResolveCatalogPath(HCATADMIN hcatadmin, WCHAR *catalog_file, CATALOG_INFO *info, DWORD flags) { static const WCHAR slashW[] = {'\\',0}; struct catadmin *ca = hcatadmin; TRACE("%p %s %p %x\n", hcatadmin, debugstr_w(catalog_file), info, flags); if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } strcpyW(info->wszCatalogFile, ca->path); strcatW(info->wszCatalogFile, slashW); strcatW(info->wszCatalogFile, catalog_file); return TRUE; }
static HRESULT copy_propbag2(PROPBAG2 *dest, PROPBAG2 *src, BOOL useCoAlloc) { dest->cfType = src->cfType; dest->clsid = src->clsid; dest->dwHint = src->dwHint; dest->dwType = src->dwType; dest->vt = src->vt; if(useCoAlloc) dest->pstrName = CoTaskMemAlloc((strlenW(src->pstrName)+1) * sizeof(WCHAR)); else dest->pstrName = HeapAlloc(GetProcessHeap(), 0, (strlenW(src->pstrName)+1) * sizeof(WCHAR)); if(!dest->pstrName) return E_OUTOFMEMORY; strcpyW(dest->pstrName, src->pstrName); return S_OK; }
PINFCACHESECTION InfpAddSection(PINFCACHE Cache, PCWSTR Name) { PINFCACHESECTION Section = NULL; ULONG Size; if (Cache == NULL || Name == NULL) { DPRINT("Invalid parameter\n"); return NULL; } /* Allocate and initialize the new section */ Size = (ULONG)FIELD_OFFSET(INFCACHESECTION, Name[strlenW(Name) + 1]); Section = (PINFCACHESECTION)MALLOC(Size); if (Section == NULL) { DPRINT("MALLOC() failed\n"); return NULL; } ZEROMEMORY (Section, Size); /* Copy section name */ strcpyW(Section->Name, Name); /* Append section */ if (Cache->FirstSection == NULL) { Cache->FirstSection = Section; Cache->LastSection = Section; } else { Cache->LastSection->Next = Section; Section->Prev = Cache->LastSection; Cache->LastSection = Section; } return Section; }
static void add_folder( const WCHAR *folder ) { static const WCHAR lnkW[] = {'\\','*','.','l','n','k',0}; int len = strlenW( folder ) + strlenW( lnkW ); WIN32_FIND_DATAW data; HANDLE handle; WCHAR *glob; if (!(glob = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return; strcpyW( glob, folder ); strcatW( glob, lnkW ); if ((handle = FindFirstFileW( glob, &data )) != INVALID_HANDLE_VALUE) { do { add_launcher( folder, data.cFileName, -1 ); } while (FindNextFileW( handle, &data )); FindClose( handle ); } HeapFree( GetProcessHeap(), 0, glob ); }
/************************************************************************** * CreateMRUListLazyW [COMCTL32.404] * * See CreateMRUListLazyA. */ HANDLE WINAPI CreateMRUListLazyW (LPCREATEMRULISTW lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) { LPWINEMRULIST mp; /* Native does not check for a NULL lpcml */ if (lpcml->cbSize != sizeof(CREATEMRULISTW) || !lpcml->hKey || IsBadStringPtrW(lpcml->lpszSubKey, -1)) return NULL; mp = Alloc(sizeof(WINEMRULIST)); memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW)); mp->extview.lpszSubKey = Alloc((strlenW(lpcml->lpszSubKey) + 1) * sizeof(WCHAR)); strcpyW((LPWSTR)mp->extview.lpszSubKey, lpcml->lpszSubKey); mp->isUnicode = TRUE; return CreateMRUListLazy_common(mp); }
/* create directories leading to a given file */ static void create_directories( const WCHAR *name ) { WCHAR *path, *p; /* create the directory/directories */ path = HeapAlloc(GetProcessHeap(), 0, (strlenW(name) + 1)*sizeof(WCHAR)); strcpyW(path, name); p = strchrW(path, '\\'); while (p != NULL) { *p = 0; if (!CreateDirectoryW(path, NULL)) TRACE("Couldn't create directory %s - error: %d\n", wine_dbgstr_w(path), GetLastError()); *p = '\\'; p = strchrW(p+1, '\\'); } HeapFree(GetProcessHeap(), 0, path); }
static HRESULT WINAPI TaskService_Connect(ITaskService *iface, VARIANT server, VARIANT user, VARIANT domain, VARIANT password) { TaskService *task_svc = impl_from_ITaskService(iface); WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1]; DWORD len; TRACE("%p,%s,%s,%s,%s\n", iface, debugstr_variant(&server), debugstr_variant(&user), debugstr_variant(&domain), debugstr_variant(&password)); if (!is_variant_null(&user) || !is_variant_null(&domain) || !is_variant_null(&password)) FIXME("user/domain/password are ignored\n"); len = sizeof(comp_name)/sizeof(comp_name[0]); if (!GetComputerNameW(comp_name, &len)) return HRESULT_FROM_WIN32(GetLastError()); if (!is_variant_null(&server)) { const WCHAR *server_name; if (V_VT(&server) != VT_BSTR) { FIXME("server variant type %d is not supported\n", V_VT(&server)); return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH); } /* skip UNC prefix if any */ server_name = V_BSTR(&server); if (server_name[0] == '\\' && server_name[1] == '\\') server_name += 2; if (strcmpiW(server_name, comp_name)) { FIXME("connection to remote server %s is not supported\n", debugstr_w(V_BSTR(&server))); return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH); } } strcpyW(task_svc->comp_name, comp_name); task_svc->connected = TRUE; return S_OK; }
/****************************************************************** * NAS_WaveInit * * Initialize internal structures from NAS server info */ static LONG NAS_WaveInit(void) { int i; if (!nas_init()) return MMSYSERR_ERROR; /* initialize all device handles to -1 */ for (i = 0; i < MAX_WAVEOUTDRV; ++i) { static const WCHAR ini[] = {'N','A','S',' ','W','A','V','E','O','U','T',' ','D','r','i','v','e','r',0}; memset(&WOutDev[i].caps, 0, sizeof(WOutDev[i].caps)); /* zero out caps values */ WOutDev[i].AuServ = AuServ; WOutDev[i].AuDev = AuNone; WOutDev[i].Id = i; WOutDev[i].caps.wMid = 0x00FF; /* Manufac ID */ WOutDev[i].caps.wPid = 0x0001; /* Product ID */ strcpyW(WOutDev[i].caps.szPname, ini); WOutDev[i].AuFlow = 0; WOutDev[i].caps.vDriverVersion = 0x0100; WOutDev[i].caps.dwFormats = 0x00000000; WOutDev[i].caps.dwSupport = WAVECAPS_VOLUME; WOutDev[i].caps.wChannels = 2; WOutDev[i].caps.dwSupport |= WAVECAPS_LRVOLUME; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S16; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M16; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M16; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S16; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S08; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M16; WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S16; } return 0; }
/*********************************************************************** * GetTimeZoneInformation (KERNEL32.@) * * Fills in the a time zone information structure with values based on * the current local time. * * RETURNS * * The daylight savings time standard or TIME_ZONE_ID_INVALID if the call failed. */ DWORD WINAPI GetTimeZoneInformation( LPTIME_ZONE_INFORMATION tzinfo) /* [out] The time zone structure to be filled in. */ { time_t gmt; int bias, daylight; const WCHAR *psTZ; memset(tzinfo, 0, sizeof(TIME_ZONE_INFORMATION)); gmt = time(NULL); bias=TIME_GetBias(gmt,&daylight); tzinfo->Bias = -bias / 60; tzinfo->StandardBias = 0; tzinfo->DaylightBias = -60; psTZ = TIME_GetTZAsStr (gmt, (-bias/60), daylight); if (psTZ) strcpyW( tzinfo->StandardName, psTZ ); return TIME_ZONE_ID_STANDARD; }
/* When the user clicks the browse button in SetupPromptForDisk dialog * it copies the path of the selected file to the dialog path field */ static void promptdisk_browse(HWND hwnd, struct promptdisk_params *params) { OPENFILENAMEW ofn; ZeroMemory(&ofn, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST; ofn.hwndOwner = hwnd; ofn.nMaxFile = MAX_PATH; ofn.lpstrFile = HeapAlloc(GetProcessHeap(), 0, MAX_PATH*sizeof(WCHAR)); strcpyW(ofn.lpstrFile, params->FileSought); if(GetOpenFileNameW(&ofn)) { WCHAR* last_slash = strrchrW(ofn.lpstrFile, '\\'); if (last_slash) *last_slash = 0; SetDlgItemTextW(hwnd, IDC_PATH, ofn.lpstrFile); } HeapFree(GetProcessHeap(), 0, ofn.lpstrFile); }
static WCHAR *font_name_from_file( const WCHAR *filename ) { static const WCHAR truetypeW[] = {' ','(','T','r','u','e','T','y','p','e',')',0}; WCHAR *name, *ret = NULL; if ((name = load_ttf_name_id( filename, NAME_ID_FULL_FONT_NAME ))) { if (!name[0]) { WARN("empty font name\n"); msi_free( name ); return NULL; } ret = msi_alloc( (strlenW( name ) + strlenW( truetypeW ) + 1 ) * sizeof(WCHAR) ); strcpyW( ret, name ); strcatW( ret, truetypeW ); msi_free( name ); } return ret; }
/********************************************************************* * _wmakepath (MSVCRT.@) * * Unicode version of _wmakepath. */ VOID CDECL MSVCRT__wmakepath(MSVCRT_wchar_t *path, const MSVCRT_wchar_t *drive, const MSVCRT_wchar_t *directory, const MSVCRT_wchar_t *filename, const MSVCRT_wchar_t *extension) { MSVCRT_wchar_t *p = path; TRACE("%s %s %s %s\n", debugstr_w(drive), debugstr_w(directory), debugstr_w(filename), debugstr_w(extension)); if ( !path ) return; if (drive && drive[0]) { *p++ = drive[0]; *p++ = ':'; } if (directory && directory[0]) { unsigned int len = strlenW(directory); memmove(p, directory, len * sizeof(MSVCRT_wchar_t)); p += len; if (p[-1] != '/' && p[-1] != '\\') *p++ = '\\'; } if (filename && filename[0]) { unsigned int len = strlenW(filename); memmove(p, filename, len * sizeof(MSVCRT_wchar_t)); p += len; } if (extension && extension[0]) { if (extension[0] != '.') *p++ = '.'; strcpyW(p, extension); } else *p = '\0'; TRACE("returning %s\n", debugstr_w(path)); }