Ros-diffs February 2005

ros-diffs@reactos.org

23 participants
411 discussions

by gvg＠svn.reactos.com

Vendor drop Added: vendor/wine/dlls/advapi32/ Added: vendor/wine/dlls/advapi32/crypt.c Added: vendor/wine/dlls/advapi32/crypt_des.c Added: vendor/wine/dlls/advapi32/crypt_lmhash.c Added: vendor/wine/dlls/advapi32/crypt_md4.c Added: vendor/wine/dlls/advapi32/crypt_md5.c Added: vendor/wine/dlls/advapi32/crypt_sha.c _____ Added: vendor/wine/dlls/advapi32/crypt.c --- vendor/wine/dlls/advapi32/crypt.c 2005-02-20 11:11:20 UTC (rev 13675) +++ vendor/wine/dlls/advapi32/crypt.c 2005-02-20 11:19:28 UTC (rev 13676) @@ -0,0 +1,1954 @@ +/* + * Copyright 1999 Ian Schmidt + * Copyright 2001 Travis Michielsen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/********************************************************************** * + * + * TODO: + * - Reference counting + * - Thread-safing + * - Signature checking + */ + +#include <time.h> +#include <stdlib.h> +#include <stdio.h> + +#include "crypt.h" +#include "winnls.h" +#include "winreg.h" +#include "wine/debug.h" +#include "winternl.h" +#include "ntstatus.h" + +WINE_DEFAULT_DEBUG_CHANNEL(crypt); + +HWND crypt_hWindow = 0; + +#define CRYPT_ReturnLastError(err) {SetLastError(err); return FALSE;} + +#define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size)) +#define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer)) + +static inline PSTR CRYPT_GetProvKeyName(PCSTR pProvName) +{ + PCSTR KEYSTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider\\"; + PSTR keyname; + + keyname = CRYPT_Alloc(strlen(KEYSTR) + strlen(pProvName) +1); + if (keyname) + { + strcpy(keyname, KEYSTR); + strcpy(keyname + strlen(KEYSTR), pProvName); + } else + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return keyname; +} + +static inline PSTR CRYPT_GetTypeKeyName(DWORD dwType, BOOL user) +{ + PCSTR MACHINESTR = "Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX"; + PCSTR USERSTR = "Software\\Microsoft\\Cryptography\\Provider Type XXX"; + PSTR keyname; + PSTR ptr; + + keyname = CRYPT_Alloc( (user ? strlen(USERSTR) : strlen(MACHINESTR)) +1); + if (keyname) + { + user ? strcpy(keyname, USERSTR) : strcpy(keyname, MACHINESTR); + ptr = keyname + strlen(keyname); + *(--ptr) = (dwType % 10) + '0'; + *(--ptr) = ((dwType / 10) % 10) + '0'; + *(--ptr) = (dwType / 100) + '0'; + } else + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return keyname; +} + +/* CRYPT_UnicodeTOANSI + * wstr - unicode string + * str - pointer to ANSI string + * strsize - size of buffer pointed to by str or -1 if we have to do the allocation + * + * returns TRUE if unsuccessfull, FALSE otherwise. + * if wstr is NULL, returns TRUE and sets str to NULL! Value of str should be checked after call + */ +static inline BOOL CRYPT_UnicodeToANSI(LPCWSTR wstr, LPSTR* str, int strsize) +{ + int count; + + if (!wstr) + { + *str = NULL; + return TRUE; + } + count = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL); + if (strsize == -1) + *str = CRYPT_Alloc(count * sizeof(CHAR)); + else + count = min( count, strsize ); + if (*str) + { + WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, count, NULL, NULL); + return TRUE; + } + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return FALSE; +} + +/* CRYPT_ANSITOUnicode + * str - ANSI string + * wstr - pointer to unicode string + * wstrsize - size of buffer pointed to by wstr or -1 if we have to do the allocation + */ +static inline BOOL CRYPT_ANSIToUnicode(LPCSTR str, LPWSTR* wstr, int wstrsize) +{ + int wcount; + + if (!str) + { + *wstr = NULL; + return TRUE; + } + wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); + if (wstrsize == -1) + *wstr = CRYPT_Alloc(wcount * sizeof(WCHAR)); + else + wcount = min( wcount, wstrsize/sizeof(WCHAR) ); + if (*wstr) + { + MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount); + return TRUE; + } + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return FALSE; +} + +/* These next 2 functions are used by the VTableProvStruc structure */ +static BOOL CALLBACK CRYPT_VerifyImage(LPCSTR lpszImage, BYTE* pData) +{ + if (!lpszImage || !pData) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + FIXME("(%s, %p): not verifying image\n", lpszImage, pData); + + return TRUE; +} + +static BOOL CALLBACK CRYPT_ReturnhWnd(HWND *phWnd) +{ + if (!phWnd) + return FALSE; + *phWnd = crypt_hWindow; + return TRUE; +} + +#define CRYPT_GetProvFunc(name) \ + if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error +#define CRYPT_GetProvFuncOpt(name) \ + provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name) +PCRYPTPROV CRYPT_LoadProvider(PSTR pImage) +{ + PCRYPTPROV provider; + DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY; + + if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error; + if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error; + if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error; + if ( !(provider->hModule = LoadLibraryA(pImage)) ) + { + errorcode = (GetLastError() == ERROR_FILE_NOT_FOUND) ? NTE_PROV_DLL_NOT_FOUND : NTE_PROVIDER_DLL_FAIL; + FIXME("Failed to load dll %s\n", debugstr_a(pImage)); + goto error; + } + provider->refcount = 1; + + errorcode = NTE_PROVIDER_DLL_FAIL; + CRYPT_GetProvFunc(CPAcquireContext); + CRYPT_GetProvFunc(CPCreateHash); + CRYPT_GetProvFunc(CPDecrypt); + CRYPT_GetProvFunc(CPDeriveKey); + CRYPT_GetProvFunc(CPDestroyHash); + CRYPT_GetProvFunc(CPDestroyKey); + CRYPT_GetProvFuncOpt(CPDuplicateHash); + CRYPT_GetProvFuncOpt(CPDuplicateKey); + CRYPT_GetProvFunc(CPEncrypt); + CRYPT_GetProvFunc(CPExportKey); + CRYPT_GetProvFunc(CPGenKey); + CRYPT_GetProvFunc(CPGenRandom); + CRYPT_GetProvFunc(CPGetHashParam); + CRYPT_GetProvFunc(CPGetKeyParam); + CRYPT_GetProvFunc(CPGetProvParam); + CRYPT_GetProvFunc(CPGetUserKey); + CRYPT_GetProvFunc(CPHashData); + CRYPT_GetProvFunc(CPHashSessionKey); + CRYPT_GetProvFunc(CPImportKey); + CRYPT_GetProvFunc(CPReleaseContext); + CRYPT_GetProvFunc(CPSetHashParam); + CRYPT_GetProvFunc(CPSetKeyParam); + CRYPT_GetProvFunc(CPSetProvParam); + CRYPT_GetProvFunc(CPSignHash); + CRYPT_GetProvFunc(CPVerifySignature); + + /* FIXME: Not sure what the pbContextInfo field is for. + * Does it need memory allocation? + */ + provider->pVTable->Version = 3; + provider->pVTable->pFuncVerifyImage = (FARPROC)CRYPT_VerifyImage; + provider->pVTable->pFuncReturnhWnd = (FARPROC)CRYPT_ReturnhWnd; + provider->pVTable->dwProvType = 0; + provider->pVTable->pbContextInfo = NULL; + provider->pVTable->cbContextInfo = 0; + provider->pVTable->pszProvName = NULL; + return provider; + +error: + SetLastError(errorcode); + if (provider) + { + if (provider->hModule) + FreeLibrary(provider->hModule); + CRYPT_Free(provider->pVTable); + CRYPT_Free(provider->pFuncs); + CRYPT_Free(provider); + } + return NULL; +} +#undef CRYPT_GetProvFunc +#undef CRYPT_GetProvFuncOpt + + +/********************************************************************** ******** + * CryptAcquireContextA (ADVAPI32.@) + * Acquire a crypto provider context handle. + * + * PARAMS + * phProv: Pointer to HCRYPTPROV for the output. + * pszContainer: Key Container Name + * pszProvider: Cryptographic Service Provider Name + * dwProvType: Crypto provider type to get a handle. + * dwFlags: flags for the operation + * + * RETURNS TRUE on success, FALSE on failure. + */ +BOOL WINAPI CryptAcquireContextA (HCRYPTPROV *phProv, LPCSTR pszContainer, + LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags) +{ + PCRYPTPROV pProv = NULL; + HKEY key; + PSTR imagepath = NULL, keyname = NULL, provname = NULL, temp = NULL; + BYTE* signature; + DWORD keytype, type, len; + ULONG r; + + TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, pszContainer, + pszProvider, dwProvType, dwFlags); + + if (dwProvType < 1 || dwProvType > MAXPROVTYPES) + { + SetLastError(NTE_BAD_PROV_TYPE); + return FALSE; + } + + if (!phProv) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + if (!pszProvider || !*pszProvider) + { + /* No CSP name specified so try the user default CSP first + * then try the machine default CSP + */ + if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, TRUE)) ) { + TRACE("No provider registered for crypto provider type %ld.\n", dwProvType); + SetLastError(NTE_PROV_TYPE_NOT_DEF); + return FALSE; + } + if (RegOpenKeyA(HKEY_CURRENT_USER, keyname, &key)) + { + CRYPT_Free(keyname); + if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, FALSE)) ) { + TRACE("No type registered for crypto provider type %ld.\n", dwProvType); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_NOT_DEF); + goto error; + } + if (RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key)) { + TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_a(keyname)); + CRYPT_Free(keyname); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_NOT_DEF); + goto error; + } + } + CRYPT_Free(keyname); + r = RegQueryValueExA(key, "Name", NULL, &keytype, NULL, &len); + if( r != ERROR_SUCCESS || !len || keytype != REG_SZ) + { + TRACE("error %ld reading size of 'Name' from registry\n", r ); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + if(!(provname = CRYPT_Alloc(len))) + { + RegCloseKey(key); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + r = RegQueryValueExA(key, "Name", NULL, NULL, provname, &len); + if( r != ERROR_SUCCESS ) + { + TRACE("error %ld reading 'Name' from registry\n", r ); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + RegCloseKey(key); + } else { + if ( !(provname = CRYPT_Alloc(strlen(pszProvider) +1)) ) + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + strcpy(provname, pszProvider); + } + + keyname = CRYPT_GetProvKeyName(provname); + r = RegOpenKeyA(HKEY_LOCAL_MACHINE, keyname, &key); + CRYPT_Free(keyname); + if (r != ERROR_SUCCESS) + { + SetLastError(NTE_KEYSET_NOT_DEF); + goto error; + } + len = sizeof(DWORD); + r = RegQueryValueExA(key, "Type", NULL, NULL, (BYTE*)&type, &len); + if (r != ERROR_SUCCESS) + { + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + if (type != dwProvType) + { + TRACE("Crypto provider has wrong type (%ld vs expected %ld).\n", type, dwProvType); + SetLastError(NTE_PROV_TYPE_NO_MATCH); + goto error; + } + + r = RegQueryValueExA(key, "Image Path", NULL, &keytype, NULL, &len); + if ( r != ERROR_SUCCESS || keytype != REG_SZ) + { + TRACE("error %ld reading size of 'Image Path' from registry\n", r ); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + if (!(temp = CRYPT_Alloc(len))) + { + RegCloseKey(key); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + r = RegQueryValueExA(key, "Image Path", NULL, NULL, temp, &len); + if( r != ERROR_SUCCESS ) + { + TRACE("error %ld reading 'Image Path' from registry\n", r ); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + + r = RegQueryValueExA(key, "Signature", NULL, &keytype, NULL, &len); + if ( r == ERROR_SUCCESS && keytype == REG_BINARY ) + { + if (!(signature = CRYPT_Alloc(len))) + { + RegCloseKey(key); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + r = RegQueryValueExA(key, "Signature", NULL, NULL, signature, &len); + if ( r != ERROR_SUCCESS ) + { + TRACE("error %ld reading 'Signature'\n", r ); + CRYPT_Free(signature); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + } + else + { + r = RegQueryValueExA(key, "SigInFile", NULL, &keytype, NULL, &len); + if (r != ERROR_SUCCESS) + { + TRACE("error %ld reading size of 'SigInFile'\n", r ); + RegCloseKey(key); + SetLastError(NTE_PROV_TYPE_ENTRY_BAD); + goto error; + } + else + { + /* FIXME: The presence of the SigInFile value indicates the + * provider's signature is in its resources, so need to read it. + * But since CRYPT_VerifyImage is stubbed, provide any old thing + * for now. + */ + if (!(signature = CRYPT_Alloc(1))) + { + RegCloseKey(key); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + } + } + RegCloseKey(key); + len = ExpandEnvironmentStringsA(temp, NULL, 0); + if ( !(imagepath = CRYPT_Alloc(len)) ) + { + CRYPT_Free(signature); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto error; + } + if (!ExpandEnvironmentStringsA(temp, imagepath, len)) + { + CRYPT_Free(signature); + /* ExpandEnvironmentStrings will call SetLastError */ + goto error; + } + + if (!CRYPT_VerifyImage(imagepath, signature)) + { + CRYPT_Free(signature); + SetLastError(NTE_SIGNATURE_FILE_BAD); + goto error; + } + pProv = CRYPT_LoadProvider(imagepath); + CRYPT_Free(signature); + if (!pProv) { + /* CRYPT_LoadProvider calls SetLastError */ + goto error; + } + pProv->pVTable->dwProvType = dwProvType; + pProv->pVTable->pszProvName = provname; + if (pProv->pFuncs->pCPAcquireContext(&pProv->hPrivate, (CHAR*)pszContainer, dwFlags, pProv->pVTable)) + { + /* MSDN: When this flag is set, the value returned in phProv is undefined, + * and thus, the CryptReleaseContext function need not be called afterwards. + * Therefore, we must clean up everything now. + */ + if (dwFlags & CRYPT_DELETEKEYSET) + { + FreeLibrary(pProv->hModule); + CRYPT_Free(provname); + CRYPT_Free(pProv->pFuncs); + CRYPT_Free(pProv); + } else { + *phProv = (HCRYPTPROV)pProv; + } + CRYPT_Free(temp); + CRYPT_Free(imagepath); + return TRUE; + } + /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */ +error: + if (pProv) + { + if (pProv->hModule) + FreeLibrary(pProv->hModule); + if (pProv->pVTable) + CRYPT_Free(pProv->pVTable); + if (pProv->pFuncs) + CRYPT_Free(pProv->pFuncs); + CRYPT_Free(pProv); + } + if (provname) + CRYPT_Free(provname); + if (temp) + CRYPT_Free(temp); + if (imagepath) + CRYPT_Free(imagepath); + return FALSE; +} + +/********************************************************************** ******** + * CryptAcquireContextW (ADVAPI32.@) + * + * see CryptAcquireContextA + */ +BOOL WINAPI CryptAcquireContextW (HCRYPTPROV *phProv, LPCWSTR pszContainer, + LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags) +{ + PSTR pProvider = NULL, pContainer = NULL; + BOOL ret = FALSE; + + TRACE("(%p, %s, %s, %ld, %08lx)\n", phProv, debugstr_w(pszContainer), + debugstr_w(pszProvider), dwProvType, dwFlags); + + if ( !CRYPT_UnicodeToANSI(pszContainer, &pContainer, -1) ) + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + if ( !CRYPT_UnicodeToANSI(pszProvider, &pProvider, -1) ) + { + CRYPT_Free(pContainer); + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + } + + ret = CryptAcquireContextA(phProv, pContainer, pProvider, dwProvType, dwFlags); + + if (pContainer) + CRYPT_Free(pContainer); + if (pProvider) + CRYPT_Free(pProvider); + + return ret; +} + +/********************************************************************** ******** + * CryptContextAddRef (ADVAPI32.@) + * + * Increases reference count of a cryptographic service provider handle + * by one. + * + * PARAMS + * hProv [I] Handle to the CSP whose reference is being incremented. + * pdwReserved [IN] Reserved for future use and must be NULL. + * dwFlags [I] Reserved for future use and must be NULL. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptContextAddRef (HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags) +{ + PCRYPTPROV pProv = (PCRYPTPROV)hProv; + + TRACE("(0x%lx, %p, %08lx)\n", hProv, pdwReserved, dwFlags); + + if (!pProv) + { + SetLastError(NTE_BAD_UID); + return FALSE; + } + + pProv->refcount++; + return TRUE; +} + +/********************************************************************** ******** + * CryptReleaseContext (ADVAPI32.@) + * + * Releases the handle of a CSP. Reference count is decreased. + * + * PARAMS + * hProv [I] Handle of a CSP. + * dwFlags [I] Reserved for future use and must be NULL. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags) +{ + PCRYPTPROV pProv = (PCRYPTPROV)hProv; + BOOL ret = TRUE; + + TRACE("(0x%lx, %08ld)\n", hProv, dwFlags); + + if (!pProv) + { + SetLastError(NTE_BAD_UID); + return FALSE; + } + + pProv->refcount--; + if (pProv->refcount <= 0) + { + ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags); + FreeLibrary(pProv->hModule); +#if 0 + CRYPT_Free(pProv->pVTable->pContextInfo); +#endif + CRYPT_Free(pProv->pVTable->pszProvName); + CRYPT_Free(pProv->pVTable); + CRYPT_Free(pProv->pFuncs); + CRYPT_Free(pProv); + } + return ret; +} + +/********************************************************************** ******** + * CryptGenRandom (ADVAPI32.@) + * + * Fills a buffer with cryptographically random bytes. + * + * PARAMS + * hProv [I] Handle of a CSP. + * dwLen [I] Number of bytes to generate. + * pbBuffer [I/O] Buffer to contain random bytes. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + * + * NOTES + * pdBuffer must be at least dwLen bytes long. + */ +BOOL WINAPI CryptGenRandom (HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) +{ + PCRYPTPROV prov = (PCRYPTPROV)hProv; + + TRACE("(0x%lx, %ld, %p)\n", hProv, dwLen, pbBuffer); + + if (!hProv) + CRYPT_ReturnLastError(ERROR_INVALID_HANDLE); + + return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer); +} + +/********************************************************************** ******** + * CryptCreateHash (ADVAPI32.@) + * + * Initiates the hashing of a stream of data. + * + * PARAMS + * hProv [I] Handle of a CSP. + * Algid [I] Identifies the hash algorithm to use. + * hKey [I] Key for the hash (if required). + * dwFlags [I] Reserved for future use and must be NULL. + * phHash [O] Address of the future handle to the new hash object. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + * + * NOTES + * If the algorithm is a keyed hash, hKey is the key. + */ +BOOL WINAPI CryptCreateHash (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, + DWORD dwFlags, HCRYPTHASH *phHash) +{ + PCRYPTPROV prov = (PCRYPTPROV)hProv; + PCRYPTKEY key = (PCRYPTKEY)hKey; + PCRYPTHASH hash; + + TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash); + + if (!prov) + CRYPT_ReturnLastError(ERROR_INVALID_HANDLE); + if (!phHash) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + if (dwFlags) + CRYPT_ReturnLastError(NTE_BAD_FLAGS); + if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) ) + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + + hash->pProvider = prov; + + if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid, + key ? key->hPrivate : 0, 0, &hash->hPrivate)) + { + *phHash = (HCRYPTHASH)hash; + return TRUE; + } + + /* CSP error! */ + CRYPT_Free(hash); + *phHash = 0; + return FALSE; +} + +/********************************************************************** ******** + * CryptDecrypt (ADVAPI32.@) + * + * Decrypts data encrypted by CryptEncrypt. + * + * PARAMS + * hKey [I] Handle to the decryption key. + * hHash [I] Handle to a hash object. + * Final [I] TRUE if this is the last section to be decrypted. + * dwFlags [I] Reserved for future use. Can be CRYPT_OAEP. + * pbData [I/O] Buffer that holds the encrypted data. Holds decrypted + * data on return + * pdwDataLen [I/O] Length of pbData before and after the call. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, + DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen) +{ + PCRYPTPROV prov; + PCRYPTKEY key = (PCRYPTKEY)hKey; + PCRYPTHASH hash = (PCRYPTHASH)hHash; + + TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen); + + if (!key || !pbData || !pdwDataLen) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + + prov = key->pProvider; + return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0, + Final, dwFlags, pbData, pdwDataLen); +} + +/********************************************************************** ******** + * CryptDeriveKey (ADVAPI32.@) + * + * Generates session keys derived from a base data value. + * + * PARAMS + * hProv [I] Handle to a CSP. + * Algid [I] Identifies the symmetric encryption algorithm to use. + * hBaseData [I] Handle to a hash object. + * dwFlags [I] Type of key to generate. + * phKey [I/O] Address of the newly generated key. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, + DWORD dwFlags, HCRYPTKEY *phKey) +{ + PCRYPTPROV prov = (PCRYPTPROV)hProv; + PCRYPTHASH hash = (PCRYPTHASH)hBaseData; + PCRYPTKEY key; + + TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08lx, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey); + + if (!prov || !hash) + CRYPT_ReturnLastError(ERROR_INVALID_HANDLE); + if (!phKey) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) ) + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + + key->pProvider = prov; + if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate)) + { + *phKey = (HCRYPTKEY)key; + return TRUE; + } + + /* CSP error! */ + CRYPT_Free(key); + *phKey = 0; + return FALSE; +} + +/********************************************************************** ******** + * CryptDestroyHash (ADVAPI32.@) + * + * Destroys the hash object referenced by hHash. + * + * PARAMS + * hHash [I] Handle of the hash object to be destroyed. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDestroyHash (HCRYPTHASH hHash) +{ + PCRYPTHASH hash = (PCRYPTHASH)hHash; + PCRYPTPROV prov; + BOOL ret; + + TRACE("(0x%lx)\n", hHash); + + if (!hash) + CRYPT_ReturnLastError(ERROR_INVALID_HANDLE); + + prov = hash->pProvider; + ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate); + CRYPT_Free(hash); + return ret; +} + +/********************************************************************** ******** + * CryptDestroyKey (ADVAPI32.@) + * + * Releases the handle referenced by hKey. + * + * PARAMS + * hKey [I] Handle of the key to be destroyed. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDestroyKey (HCRYPTKEY hKey) +{ + PCRYPTKEY key = (PCRYPTKEY)hKey; + PCRYPTPROV prov; + BOOL ret; + + TRACE("(0x%lx)\n", hKey); + + if (!key) + CRYPT_ReturnLastError(ERROR_INVALID_HANDLE); + + prov = key->pProvider; + ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate); + CRYPT_Free(key); + return ret; +} + +/********************************************************************** ******** + * CryptDuplicateHash (ADVAPI32.@) + * + * Duplicates a hash. + * + * PARAMS + * hHash [I] Handle to the hash to be copied. + * pdwReserved [I] Reserved for future use and must be zero. + * dwFlags [I] Reserved for future use and must be zero. + * phHash [O] Address of the handle to receive the copy. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDuplicateHash (HCRYPTHASH hHash, DWORD *pdwReserved, + DWORD dwFlags, HCRYPTHASH *phHash) +{ + PCRYPTPROV prov; + PCRYPTHASH orghash, newhash; + + TRACE("(0x%lx, %p, %08ld, %p)\n", hHash, pdwReserved, dwFlags, phHash); + + orghash = (PCRYPTHASH)hHash; + if (!orghash || pdwReserved || !phHash) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + + prov = orghash->pProvider; + if (!prov->pFuncs->pCPDuplicateHash) + CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED); + + if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) ) + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + + newhash->pProvider = prov; + if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate)) + { + *phHash = (HCRYPTHASH)newhash; + return TRUE; + } + CRYPT_Free(newhash); + return FALSE; +} + +/********************************************************************** ******** + * CryptDuplicateKey (ADVAPI32.@) + * + * Duplicate a key and the key's state. + * + * PARAMS + * hKey [I] Handle of the key to copy. + * pdwReserved [I] Reserved for future use and must be NULL. + * dwFlags [I] Reserved for future use and must be zero. + * phKey [I] Address of the handle to the duplicated key. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ +BOOL WINAPI CryptDuplicateKey (HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey) +{ + PCRYPTPROV prov; + PCRYPTKEY orgkey, newkey; + + TRACE("(0x%lx, %p, %08ld, %p)\n", hKey, pdwReserved, dwFlags, phKey); + + orgkey = (PCRYPTKEY)hKey; + if (!orgkey || pdwReserved || !phKey) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + + prov = orgkey->pProvider; + if (!prov->pFuncs->pCPDuplicateKey) + CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED); + + if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) ) + CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY); + + newkey->pProvider = prov; + if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate)) + { + *phKey = (HCRYPTKEY)newkey; + return TRUE; + } + CRYPT_Free(newkey); + return FALSE; +} + +/********************************************************************** ******** + * CryptEncrypt (ADVAPI32.@) + * + * Encrypts data. + * + * PARAMS + * hKey [I] Handle to the enryption key. + * hHash [I] Handle to a hash object. + * Final [I] TRUE if this is the last section to encrypt. + * dwFlags [I] Can be CRYPT_OAEP. + * pbData [I/O] Data to be encrypted. Contains encrypted data after call. + * pdwDataLen [I/O] Length of the data to encrypt. Contains the length of the + * encrypted data after call. + * dwBufLen [I] Length of the input pbData buffer. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + * + * NOTES + * If pbData is NULL, CryptEncrypt determines stores the number of bytes + * required for the returned data in pdwDataLen. + */ +BOOL WINAPI CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, + DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen) +{ + PCRYPTPROV prov; + PCRYPTKEY key = (PCRYPTKEY)hKey; + PCRYPTHASH hash = (PCRYPTHASH)hHash; + + TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen); + + if (!key || !pdwDataLen) + CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + + prov = key->pProvider; + return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0, + Final, dwFlags, pbData, pdwDataLen, dwBufLen); +} + +/********************************************************************** ******** + * CryptEnumProvidersW (ADVAPI32.@) + * + * Returns the next availabe CSP. + * + * PARAMS + * dwIndex [I] Index of the next provider to be enumerated. + * pdwReserved [I] Reserved for future use and must be NULL. + * dwFlags [I] Reserved for future use and must be zero. + * pdwProvType [O] DWORD designating the type of the provider. + * pszProvName [O] Buffer that receives data from the provider. + * pcbProvName [I/O] Specifies the size of pszProvName. Contains the number + * of bytes stored in the buffer on return. + * + * RETURNS + * Success: TRUE + * Failure: FALSE + * + * NOTES + * If pszProvName is NULL, CryptEnumProvidersW sets the size of the name + * for memory allocation purposes. + */ +BOOL WINAPI CryptEnumProvidersW (DWORD dwIndex, DWORD *pdwReserved, + DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName) +{ + HKEY hKey; + + static const WCHAR providerW[] = { + 'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'C','r','y','p','t','o','g','r','a','p','h','y','\\', + 'D','e','f','a','u','l','t','s','\\', + 'P','r','o','v','i','d','e','r',0 + }; + + static const WCHAR typeW[] = {'T','y','p','e',0}; + + TRACE("(%ld, %p, %ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags, + pdwProvType, pszProvName, pcbProvName); + + if (pdwReserved || !pcbProvName) CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER); + if (dwFlags) CRYPT_ReturnLastError(NTE_BAD_FLAGS); + + if (RegOpenKeyW(HKEY_LOCAL_MACHINE, providerW, &hKey)) + CRYPT_ReturnLastError(NTE_FAIL); + + if (!pszProvName) + { + DWORD numkeys; + WCHAR *provNameW; [truncated at 1000 lines; 2100 more skipped]

19 years, 10 months

[gvg] 13675: Wine-20050211 vendor import

by gvg＠svn.reactos.com

Wine-20050211 vendor import Added: trunk/reactos/subsys/system/msiexec/ Added: trunk/reactos/subsys/system/msiexec/Makefile _____ Copied: trunk/reactos/subsys/system/msiexec (from rev 13674, vendor/wine/programs/msiexec/current) Property changes on: trunk/reactos/subsys/system/msiexec ___________________________________________________________________ Name: svn:ignore + *.coff *.map *.exe *.a *.d _____ Added: trunk/reactos/subsys/system/msiexec/Makefile --- vendor/wine/programs/msiexec/current/Makefile 2005-02-20 11:08:39 UTC (rev 13674) +++ trunk/reactos/subsys/system/msiexec/Makefile 2005-02-20 11:11:20 UTC (rev 13675) @@ -0,0 +1,36 @@ +# + +PATH_TO_TOP = ../../.. + +TARGET_TYPE = program + +TARGET_APPTYPE = windows + +TARGET_NAME = msiexec + +TARGET_CFLAGS = -I$(PATH_TO_TOP)/include/wine -D_WIN32_IE=0x0501 -D_WIN32_WINNT=0x0501 -D__USE_W32API + +TARGET_OBJECTS = msiexec.o + +TARGET_SDKLIBS = wine.a \ + ntdll.a \ + kernel32.a \ + user32.a \ + advapi32.a \ + ole32.a \ + wine_uuid.a \ + msi.a + +TARGET_RC_SRCS = version.rc + +TARGET_RC_BINSRC = + +TARGET_RC_BINARIES = + +default: all +DEP_OBJECTS = $(TARGET_OBJECTS) +include $(PATH_TO_TOP)/rules.mak + +include $(TOOLS_PATH)/helper.mk + +include $(TOOLS_PATH)/depend.mk Property changes on: trunk/reactos/subsys/system/msiexec/Makefile ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native

19 years, 10 months

[gvg] 13674: Set eol-style

by gvg＠svn.reactos.com

Set eol-style Modified: vendor/wine/programs/msiexec/current/version.rc _____ Modified: vendor/wine/programs/msiexec/current/version.rc --- vendor/wine/programs/msiexec/current/version.rc 2005-02-20 11:07:59 UTC (rev 13673) +++ vendor/wine/programs/msiexec/current/version.rc 2005-02-20 11:08:39 UTC (rev 13674) @@ -1,27 +1,27 @@ -/* - * Copyright (c) 2004 Mike McCormack - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#define WINE_FILEDESCRIPTION_STR "Wine Installer" -#define WINE_FILENAME_STR "msiexec.exe" -#define WINE_FILEVERSION 2,0,2600,1183 -#define WINE_FILEVERSION_STR "2.0.2600.1183" -#define WINE_PRODUCTVERSION 2,0,2600,1183 -#define WINE_PRODUCTVERSION_STR "2.0.2600.1183" -#define WINE_PRODUCTNAME_STR "Wine Installer" - -#include "wine/wine_common_ver.rc" +/* + * Copyright (c) 2004 Mike McCormack + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine Installer" +#define WINE_FILENAME_STR "msiexec.exe" +#define WINE_FILEVERSION 2,0,2600,1183 +#define WINE_FILEVERSION_STR "2.0.2600.1183" +#define WINE_PRODUCTVERSION 2,0,2600,1183 +#define WINE_PRODUCTVERSION_STR "2.0.2600.1183" +#define WINE_PRODUCTNAME_STR "Wine Installer" + +#include "wine/wine_common_ver.rc" Property changes on: vendor/wine/programs/msiexec/current/version.rc ___________________________________________________________________ Name: svn:eol-style + native

19 years, 10 months

[gvg] 13673: Prepare for vendor import

by gvg＠svn.reactos.com

Prepare for vendor import Deleted: trunk/reactos/subsys/system/msiexec/

19 years, 10 months

[gvg] 13672: Vendor drop

by gvg＠svn.reactos.com

Vendor drop Added: vendor/wine/programs/ Added: vendor/wine/programs/msiexec/ Added: vendor/wine/programs/msiexec/current/ Added: vendor/wine/programs/msiexec/current/Makefile.in Added: vendor/wine/programs/msiexec/current/msiexec.c Added: vendor/wine/programs/msiexec/current/msiexec.h Added: vendor/wine/programs/msiexec/current/version.rc _____ Added: vendor/wine/programs/msiexec/current/Makefile.in --- vendor/wine/programs/msiexec/current/Makefile.in 2005-02-20 11:03:14 UTC (rev 13671) +++ vendor/wine/programs/msiexec/current/Makefile.in 2005-02-20 11:05:08 UTC (rev 13672) @@ -0,0 +1,16 @@ +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = msiexec.exe +APPMODE = -mconsole +IMPORTS = msi ole32 advapi32 user32 kernel32 + +C_SRCS = \ + msiexec.c + +RC_SRCS = version.rc + +@MAKE_PROG_RULES@ + +### Dependencies: Property changes on: vendor/wine/programs/msiexec/current/Makefile.in ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____ Added: vendor/wine/programs/msiexec/current/msiexec.c --- vendor/wine/programs/msiexec/current/msiexec.c 2005-02-20 11:03:14 UTC (rev 13671) +++ vendor/wine/programs/msiexec/current/msiexec.c 2005-02-20 11:05:08 UTC (rev 13672) @@ -0,0 +1,912 @@ +/* + * msiexec.exe implementation + * + * Copyright 2004 Vincent BÚron + * Copyright 2005 Mike McCormack + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <windows.h> +#include <msi.h> +#include <objbase.h> +#include <stdio.h> + +#include "msiexec.h" + +#include "wine/debug.h" +#include "wine/unicode.h" + +WINE_DEFAULT_DEBUG_CHANNEL(msiexec); + +struct string_list +{ + struct string_list *next; + WCHAR str[1]; +}; + +static const char UsageStr[] = +"Usage:\n" +" Install a product:\n" +" msiexec {package|productcode} [property]\n" +" msiexec /i {package|productcode} [property]\n" +" msiexec /a package [property]\n" +" Repair an installation:\n" +" msiexec /f[p|o|e|d|c|a|u|m|s|v] {package|productcode}\n" +" Uninstall a product:\n" +" msiexec /x {package|productcode} [property]\n" +" Advertise a product:\n" +" msiexec /j[u|m] package [/t transform] [/g languageid]\n" +" msiexec {u|m} package [/t transform] [/g languageid]\n" +" Apply a patch:\n" +" msiexec /p patchpackage [property]\n" +" msiexec /p patchpackage /a package [property]\n" +" Modifiers for above operations:\n" +" msiexec /l[*][i|w|e|a|r|u|c|m|o|p|v|][+|!] logfile\n" +" msiexec /q{|n|b|r|f|n+|b+|b-}\n" +" Register a module:\n" +" msiexec /y module\n" +" Unregister a module:\n" +" msiexec /z module\n" +" Display usage and copyright:\n" +" msiexec {/h|/?}\n" +"NOTE: Product code on commandline unimplemented as of yet\n" +"\n" +"Copyright 2004 Vincent BÚron\n"; + +static const WCHAR ActionAdmin[] = { + 'A','C','T','I','O','N','=','A','D','M','I','N',' ',0 }; +static const WCHAR RemoveAll[] = { + 'R','E','M','O','V','E','=','A','L','L',' ',0 }; + +static const WCHAR InstallRunOnce[] = { + 'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'W','i','n','d','o','w','s','\\', + 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', + 'I','n','s','t','a','l','l','e','r','\\', + 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0}; + +static void ShowUsage(int ExitCode) +{ + printf(UsageStr); + ExitProcess(ExitCode); +} + +static BOOL IsProductCode(LPWSTR str) +{ + GUID ProductCode; + + if(lstrlenW(str) != 38) + return FALSE; + return ( (CLSIDFromString(str, &ProductCode) == NOERROR) ); + +} + +static VOID StringListAppend(struct string_list **list, LPCWSTR str) +{ + struct string_list *entry; + DWORD size; + + size = sizeof *entry + lstrlenW(str) * sizeof (WCHAR); + entry = HeapAlloc(GetProcessHeap(), 0, size); + if(!entry) + { + WINE_ERR("Out of memory!\n"); + ExitProcess(1); + } + lstrcpyW(entry->str, str); + entry->next = NULL; + + /* + * Ignoring o(n^2) time complexity to add n strings for simplicity, + * add the string to the end of the list to preserve the order. + */ + while( *list ) + list = &(*list)->next; + *list = entry; +} + +static LPWSTR build_properties(struct string_list *property_list) +{ + struct string_list *list; + LPWSTR ret, p, value; + DWORD len; + BOOL needs_quote; + + if(!property_list) + return NULL; + + /* count the space we need */ + len = 1; + for(list = property_list; list; list = list->next) + len += lstrlenW(list->str) + 3; + + ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) ); + + /* add a space before each string, and quote the value */ + p = ret; + for(list = property_list; list; list = list->next) + { + value = strchrW(list->str,'='); + if(!value) + continue; + len = value - list->str; + *p++ = ' '; + strncpyW(p, list->str, len); + p += len; + *p++ = '='; + + /* check if the value contains spaces and maybe quote it */ + value++; + needs_quote = strchrW(value,' ') ? 1 : 0; + if(needs_quote) + *p++ = '"'; + len = lstrlenW(value); + strncpyW(p, value, len); + p += len; + if(needs_quote) + *p++ = '"'; + } + *p = 0; + + WINE_TRACE("properties -> %s\n", wine_dbgstr_w(ret) ); + + return ret; +} + +static LPWSTR build_transforms(struct string_list *transform_list) +{ + struct string_list *list; + LPWSTR ret, p; + DWORD len; + + /* count the space we need */ + len = 1; + for(list = transform_list; list; list = list->next) + len += lstrlenW(list->str) + 1; + + ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) ); + + /* add all the transforms with a semicolon between each one */ + p = ret; + for(list = transform_list; list; list = list->next) + { + len = lstrlenW(list->str); + lstrcpynW(p, list->str, len ); + p += len; + if(list->next) + *p++ = ';'; + } + *p = 0; + + return ret; +} + +static DWORD msi_atou(LPCWSTR str) +{ + DWORD ret = 0; + while(*str >= '0' && *str <= '9') + { + ret *= 10; + ret += (*str - '0'); + str++; + } + return 0; +} + +static LPWSTR msi_strdup(LPCWSTR str) +{ + DWORD len = lstrlenW(str)+1; + LPWSTR ret = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len); + lstrcpyW(ret, str); + return ret; +} + +/* str1 is the same as str2, ignoring case */ +static BOOL msi_strequal(LPCWSTR str1, LPCSTR str2) +{ + DWORD len, ret; + LPWSTR strW; + + len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0); + if( !len ) + return TRUE; + if( lstrlenW(str1) != (len-1) ) + return TRUE; + strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len); + MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len); + ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len, strW, len); + HeapFree(GetProcessHeap(), 0, strW); + return (ret != CSTR_EQUAL); +} + +/* str2 is at the beginning of str1, ignoring case */ +static BOOL msi_strprefix(LPCWSTR str1, LPCSTR str2) +{ + DWORD len, ret; + LPWSTR strW; + + len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0); + if( !len ) + return TRUE; + if( lstrlenW(str1) < (len-1) ) + return TRUE; + strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len); + MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len); + ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len-1, strW, len-1); + HeapFree(GetProcessHeap(), 0, strW); + return (ret != CSTR_EQUAL); +} + +static VOID *LoadProc(LPCWSTR DllName, LPCSTR ProcName, HMODULE* DllHandle) +{ + VOID* (*proc)(void); + + *DllHandle = LoadLibraryExW(DllName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); + if(!*DllHandle) + { + fprintf(stderr, "Unable to load dll %s\n", wine_dbgstr_w(DllName)); + ExitProcess(1); + } + proc = (VOID *) GetProcAddress(*DllHandle, ProcName); + if(!proc) + { + fprintf(stderr, "Dll %s does not implement function %s\n", + wine_dbgstr_w(DllName), ProcName); + FreeLibrary(*DllHandle); + ExitProcess(1); + } + + return proc; +} + +static DWORD DllRegisterServer(LPCWSTR DllName) +{ + HRESULT hr; + DLLREGISTERSERVER pfDllRegisterServer = NULL; + HMODULE DllHandle = NULL; + + pfDllRegisterServer = LoadProc(DllName, "DllRegisterServer", &DllHandle); + + hr = pfDllRegisterServer(); + if(FAILED(hr)) + { + fprintf(stderr, "Failed to register dll %s\n", wine_dbgstr_w(DllName)); + return 1; + } + printf("Successfully registered dll %s\n", wine_dbgstr_w(DllName)); + if(DllHandle) + FreeLibrary(DllHandle); + return 0; +} + +static DWORD DllUnregisterServer(LPCWSTR DllName) +{ + HRESULT hr; + DLLUNREGISTERSERVER pfDllUnregisterServer = NULL; + HMODULE DllHandle = NULL; + + pfDllUnregisterServer = LoadProc(DllName, "DllUnregisterServer", &DllHandle); + + hr = pfDllUnregisterServer(); + if(FAILED(hr)) + { + fprintf(stderr, "Failed to unregister dll %s\n", wine_dbgstr_w(DllName)); + return 1; + } + printf("Successfully unregistered dll %s\n", wine_dbgstr_w(DllName)); + if(DllHandle) + FreeLibrary(DllHandle); + return 0; +} + +/* + * state machine to break up the command line properly + */ + +enum chomp_state +{ + cs_whitespace, + cs_token, + cs_quote +}; + +static int chomp( WCHAR *str ) +{ + enum chomp_state state = cs_whitespace; + WCHAR *p, *out; + int count = 0, ignore; + + for( p = str, out = str; *p; p++ ) + { + ignore = 1; + switch( state ) + { + case cs_whitespace: + switch( *p ) + { + case ' ': + break; + case '"': + state = cs_quote; + count++; + break; + default: + count++; + ignore = 0; + state = cs_token; + } + break; + + case cs_token: + switch( *p ) + { + case '"': + state = cs_quote; + break; + case ' ': + state = cs_whitespace; + *out++ = 0; + break; + default: + ignore = 0; + } + break; + + case cs_quote: + switch( *p ) + { + case '"': + state = cs_token; + break; + default: + ignore = 0; + } + break; + } + if( !ignore ) + *out++ = *p; + } + + *out = 0; + + return count; +} + +void process_args( WCHAR *cmdline, int *pargc, WCHAR ***pargv ) +{ + WCHAR **argv, *p = msi_strdup(cmdline); + int i, n; + + n = chomp( p ); + argv = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR*)*(n+1)); + for( i=0; i<n; i++ ) + { + argv[i] = p; + p += lstrlenW(p) + 1; + } + argv[i] = NULL; + + *pargc = n; + *pargv = argv; +} + +BOOL process_args_from_reg( LPWSTR ident, int *pargc, WCHAR ***pargv ) +{ + LONG r; + HKEY hkey = 0, hkeyArgs = 0; + DWORD sz = 0, type = 0; + LPWSTR buf = NULL; + BOOL ret = FALSE; + + r = RegOpenKeyW(HKEY_LOCAL_MACHINE, InstallRunOnce, &hkey); + if(r != ERROR_SUCCESS) + return FALSE; + r = RegQueryValueExW(hkey, ident, 0, &type, 0, &sz); + if(r == ERROR_SUCCESS && type == REG_SZ) + { + buf = HeapAlloc(GetProcessHeap(), 0, sz); + r = RegQueryValueExW(hkey, ident, 0, &type, (LPBYTE)buf, &sz); + if( r == ERROR_SUCCESS ) + { + process_args(buf, pargc, pargv); + ret = TRUE; + } + } + RegCloseKey(hkeyArgs); + return ret; +} + +int main(int argc, char **argv) +{ + int i; + BOOL FunctionInstall = FALSE; + BOOL FunctionInstallAdmin = FALSE; + BOOL FunctionRepair = FALSE; + BOOL FunctionAdvertise = FALSE; + BOOL FunctionPatch = FALSE; + BOOL FunctionDllRegisterServer = FALSE; + BOOL FunctionDllUnregisterServer = FALSE; + BOOL FunctionRegServer = FALSE; + BOOL FunctionUnregServer = FALSE; + BOOL FunctionUnknown = FALSE; + + LPWSTR PackageName = NULL; + LPWSTR Properties = NULL; + struct string_list *property_list = NULL; + + DWORD RepairMode = 0; + + DWORD AdvertiseMode = 0; + LPWSTR Transforms = NULL; + struct string_list *transform_list = NULL; + LANGID Language = 0; + + DWORD LogMode = 0; + LPWSTR LogFileName = NULL; + DWORD LogAttributes = 0; + + LPWSTR PatchFileName = NULL; + INSTALLTYPE InstallType = INSTALLTYPE_DEFAULT; + + INSTALLUILEVEL InstallUILevel = INSTALLUILEVEL_FULL; + + LPWSTR DllName = NULL; + DWORD ReturnCode; + LPWSTR *argvW = NULL; + + /* overwrite the command line */ + process_args( GetCommandLineW(), &argc, &argvW ); + + /* + * If the args begin with /@ IDENT then we need to load the real + * command line out of the RunOnceEntries key in the registry. + * We do that before starting to process the real commandline, + * then overwrite the commandline again. + */ + if(!msi_strequal(argvW[1], "/@")) + { + if(!process_args_from_reg( argvW[2], &argc, &argvW )) + return 1; + } + + for(i = 1; i < argc; i++) + { + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + + if (!msi_strequal(argvW[i], "/regserver")) + { + FunctionRegServer = TRUE; + } + else if (!msi_strequal(argvW[i], "/unregserver") || !msi_strequal(argvW[i], "/unregister")) + { + FunctionUnregServer = TRUE; + } + else if(!msi_strprefix(argvW[i], "/i")) + { + LPWSTR argvWi = argvW[i]; + FunctionInstall = TRUE; + if(lstrlenW(argvWi) > 2) + argvWi += 2; + else + { + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + argvWi = argvW[i]; + } + PackageName = argvWi; + } + else if(!msi_strequal(argvW[i], "/a")) + { + FunctionInstall = TRUE; + FunctionInstallAdmin = TRUE; + InstallType = INSTALLTYPE_NETWORK_IMAGE; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + StringListAppend(&property_list, ActionAdmin); + } + else if(!msi_strprefix(argvW[i], "/f")) + { + int j; + int len = lstrlenW(argvW[i]); + FunctionRepair = TRUE; + for(j = 2; j < len; j++) + { + switch(argvW[i][j]) + { + case 'P': + case 'p': + RepairMode |= REINSTALLMODE_FILEMISSING; + break; + case 'O': + case 'o': + RepairMode |= REINSTALLMODE_FILEOLDERVERSION; + break; + case 'E': + case 'e': + RepairMode |= REINSTALLMODE_FILEEQUALVERSION; + break; + case 'D': + case 'd': + RepairMode |= REINSTALLMODE_FILEEXACT; + break; + case 'C': + case 'c': + RepairMode |= REINSTALLMODE_FILEVERIFY; + break; + case 'A': + case 'a': + RepairMode |= REINSTALLMODE_FILEREPLACE; + break; + case 'U': + case 'u': + RepairMode |= REINSTALLMODE_USERDATA; + break; + case 'M': + case 'm': + RepairMode |= REINSTALLMODE_MACHINEDATA; + break; + case 'S': + case 's': + RepairMode |= REINSTALLMODE_SHORTCUT; + break; + case 'V': + case 'v': + RepairMode |= REINSTALLMODE_PACKAGE; + break; + default: + fprintf(stderr, "Unknown option \"%c\" in Repair mode\n", argvW[i][j]); + break; + } + } + if(len == 2) + { + RepairMode = REINSTALLMODE_FILEMISSING | + REINSTALLMODE_FILEEQUALVERSION | + REINSTALLMODE_FILEVERIFY | + REINSTALLMODE_MACHINEDATA | + REINSTALLMODE_SHORTCUT; + } + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "/x")) + { + FunctionInstall = TRUE; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + StringListAppend(&property_list, RemoveAll); + } + else if(!msi_strprefix(argvW[i], "/j")) + { + int j; + int len = lstrlenW(argvW[i]); + FunctionAdvertise = TRUE; + for(j = 2; j < len; j++) + { + switch(argvW[i][j]) + { + case 'U': + case 'u': + AdvertiseMode = ADVERTISEFLAGS_USERASSIGN; + break; + case 'M': + case 'm': + AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN; + break; + default: + fprintf(stderr, "Unknown option \"%c\" in Advertise mode\n", argvW[i][j]); + break; + } + } + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "u")) + { + FunctionAdvertise = TRUE; + AdvertiseMode = ADVERTISEFLAGS_USERASSIGN; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "m")) + { + FunctionAdvertise = TRUE; + AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PackageName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "/t")) + { + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + StringListAppend(&transform_list, argvW[i]); + } + else if(!msi_strprefix(argvW[i], "TRANSFORMS=")) + { + StringListAppend(&transform_list, argvW[i]+11); + } + else if(!msi_strequal(argvW[i], "/g")) + { + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + Language = msi_atou(argvW[i]); + } + else if(!msi_strprefix(argvW[i], "/l")) + { + int j; + int len = lstrlenW(argvW[i]); + for(j = 2; j < len; j++) + { + switch(argvW[i][j]) + { + case 'I': + case 'i': + LogMode |= INSTALLLOGMODE_INFO; + break; + case 'W': + case 'w': + LogMode |= INSTALLLOGMODE_WARNING; + break; + case 'E': + case 'e': + LogMode |= INSTALLLOGMODE_ERROR; + break; + case 'A': + case 'a': + LogMode |= INSTALLLOGMODE_ACTIONSTART; + break; + case 'R': + case 'r': + LogMode |= INSTALLLOGMODE_ACTIONDATA; + break; + case 'U': + case 'u': + LogMode |= INSTALLLOGMODE_USER; + break; + case 'C': + case 'c': + LogMode |= INSTALLLOGMODE_COMMONDATA; + break; + case 'M': + case 'm': + LogMode |= INSTALLLOGMODE_FATALEXIT; + break; + case 'O': + case 'o': + LogMode |= INSTALLLOGMODE_OUTOFDISKSPACE; + break; + case 'P': + case 'p': + LogMode |= INSTALLLOGMODE_PROPERTYDUMP; + break; + case 'V': + case 'v': + LogMode |= INSTALLLOGMODE_VERBOSE; + break; + case '*': + LogMode = INSTALLLOGMODE_FATALEXIT | + INSTALLLOGMODE_ERROR | + INSTALLLOGMODE_WARNING | + INSTALLLOGMODE_USER | + INSTALLLOGMODE_INFO | + INSTALLLOGMODE_RESOLVESOURCE | + INSTALLLOGMODE_OUTOFDISKSPACE | + INSTALLLOGMODE_ACTIONSTART | + INSTALLLOGMODE_ACTIONDATA | + INSTALLLOGMODE_COMMONDATA | + INSTALLLOGMODE_PROPERTYDUMP | + INSTALLLOGMODE_PROGRESS | + INSTALLLOGMODE_INITIALIZE | + INSTALLLOGMODE_TERMINATE | + INSTALLLOGMODE_SHOWDIALOG; + break; + case '+': + LogAttributes |= INSTALLLOGATTRIBUTES_APPEND; + break; + case '!': + LogAttributes |= INSTALLLOGATTRIBUTES_FLUSHEACHLINE; + break; + default: + break; + } + } + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + LogFileName = argvW[i]; + if(MsiEnableLogW(LogMode, LogFileName, LogAttributes) != ERROR_SUCCESS) + { + fprintf(stderr, "Logging in %s (0x%08lx, %lu) failed\n", + wine_dbgstr_w(LogFileName), LogMode, LogAttributes); + ExitProcess(1); + } + } + else if(!msi_strequal(argvW[i], "/p")) + { + FunctionPatch = TRUE; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + PatchFileName = argvW[i]; + } + else if(!msi_strprefix(argvW[i], "/q")) + { + if(lstrlenW(argvW[i]) == 2 || !msi_strequal(argvW[i]+2, "n")) + { + InstallUILevel = INSTALLUILEVEL_NONE; + } + else if(!msi_strequal(argvW[i]+2, "b")) + { + InstallUILevel = INSTALLUILEVEL_BASIC; + } + else if(!msi_strequal(argvW[i]+2, "r")) + { + InstallUILevel = INSTALLUILEVEL_REDUCED; + } + else if(!msi_strequal(argvW[i]+2, "f")) + { + InstallUILevel = INSTALLUILEVEL_FULL|INSTALLUILEVEL_ENDDIALOG; + } + else if(!msi_strequal(argvW[i]+2, "n+")) + { + InstallUILevel = INSTALLUILEVEL_NONE|INSTALLUILEVEL_ENDDIALOG; + } + else if(!msi_strequal(argvW[i]+2, "b+")) + { + InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_ENDDIALOG; + } + else if(!msi_strequal(argvW[i]+2, "b-")) + { + InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_PROGRESSONLY; + } + else if(!msi_strequal(argvW[i]+2, "b+!")) + { + InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_ENDDIALOG; + WINE_FIXME("Unknown modifier: !\n"); + } + else + { + fprintf(stderr, "Unknown option \"%s\" for UI level\n", + wine_dbgstr_w(argvW[i]+2)); + } + } + else if(!msi_strequal(argvW[i], "/y")) + { + FunctionDllRegisterServer = TRUE; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + DllName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "/z")) + { + FunctionDllUnregisterServer = TRUE; + i++; + if(i >= argc) + ShowUsage(1); + WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i])); + DllName = argvW[i]; + } + else if(!msi_strequal(argvW[i], "/h") || !msi_strequal(argvW[i], "/?")) + { + ShowUsage(0); + } + else if(!msi_strequal(argvW[i], "/m")) + { + FunctionUnknown = TRUE; + WINE_FIXME("Unknown parameter /m\n"); + } + else if(!msi_strequal(argvW[i], "/D")) + { + FunctionUnknown = TRUE; + WINE_FIXME("Unknown parameter /D\n"); + } + else if(strchrW(argvW[i], '=')) + { + StringListAppend(&property_list, argvW[i]); + } + else + { + FunctionInstall = TRUE; + PackageName = argvW[i]; + } + } + + /* start the GUI */ + MsiSetInternalUI(InstallUILevel, NULL); + + Properties = build_properties( property_list ); + Transforms = build_transforms( transform_list ); + + if(FunctionInstallAdmin && FunctionPatch) + FunctionInstall = FALSE; + + ReturnCode = 1; + if(FunctionInstall) + { + if(IsProductCode(PackageName)) + ReturnCode = MsiConfigureProductExW(PackageName, 0, INSTALLSTATE_DEFAULT, Properties); + else + ReturnCode = MsiInstallProductW(PackageName, Properties); + } + else if(FunctionRepair) + { + if(IsProductCode(PackageName)) + WINE_FIXME("Product code treatment not implemented yet\n"); + else + ReturnCode = MsiReinstallProductW(PackageName, RepairMode); + } + else if(FunctionAdvertise) + { + ReturnCode = MsiAdvertiseProductW(PackageName, (LPWSTR) AdvertiseMode, Transforms, Language); + } + else if(FunctionPatch) + { + ReturnCode = MsiApplyPatchW(PatchFileName, PackageName, InstallType, Properties); + } + else if(FunctionDllRegisterServer) + { + ReturnCode = DllRegisterServer(DllName); + } + else if(FunctionDllUnregisterServer) + { + ReturnCode = DllUnregisterServer(DllName); + } + else if (FunctionRegServer) + { + WINE_FIXME( "/regserver not implemented yet, ignoring\n" ); + } + else if (FunctionUnregServer) + { + WINE_FIXME( "/unregserver not implemented yet, ignoring\n" ); + } + else if (FunctionUnknown) + { + WINE_FIXME( "Unknown function, ignoring\n" ); + } + else + ShowUsage(1); + + return ReturnCode; +} Property changes on: vendor/wine/programs/msiexec/current/msiexec.c ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____ Added: vendor/wine/programs/msiexec/current/msiexec.h --- vendor/wine/programs/msiexec/current/msiexec.h 2005-02-20 11:03:14 UTC (rev 13671) +++ vendor/wine/programs/msiexec/current/msiexec.h 2005-02-20 11:05:08 UTC (rev 13672) @@ -0,0 +1,22 @@ +/* + * Msiexec (msiexec.h) + * + * Copyright 2004 Vincent BÚron + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +typedef HRESULT (*DLLREGISTERSERVER)(void); +typedef HRESULT (*DLLUNREGISTERSERVER)(void); Property changes on: vendor/wine/programs/msiexec/current/msiexec.h ___________________________________________________________________ Name: svn:keywords + Author Date Id Revision Name: svn:eol-style + native _____ Added: vendor/wine/programs/msiexec/current/version.rc --- vendor/wine/programs/msiexec/current/version.rc 2005-02-20 11:03:14 UTC (rev 13671) +++ vendor/wine/programs/msiexec/current/version.rc 2005-02-20 11:05:08 UTC (rev 13672) @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2004 Mike McCormack + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. [truncated at 1000 lines; 15 more skipped]

19 years, 10 months

[gvg] 13671: Sync to Wine-20050211

by gvg＠svn.reactos.com

Sync to Wine-20050211 Eric Pouech <pouech-eric(a)wanadoo.fr> - rewrite MCI interfaces as Unicode interface (as it should be) - made some winmm APIs rely on the Unicode version for the core implementation (instead of Ansi flavor) Klemens Friedl <klemens_friedl(a)gmx.net> Henning Gerhardt <henning.gerhardt(a)web.de> - Spelling fixes. Modified: trunk/reactos/lib/winmm/Makefile.in Modified: trunk/reactos/lib/winmm/driver.c Modified: trunk/reactos/lib/winmm/mci.c Modified: trunk/reactos/lib/winmm/message16.c Modified: trunk/reactos/lib/winmm/mmio.c Modified: trunk/reactos/lib/winmm/mmsystem.c Modified: trunk/reactos/lib/winmm/mmsystem.spec Modified: trunk/reactos/lib/winmm/winemm.h Modified: trunk/reactos/lib/winmm/winmm.c Modified: trunk/reactos/lib/winmm/winmm.spec Modified: trunk/reactos/lib/winmm/winmm_De.rc Modified: trunk/reactos/lib/winmm/winmm_res.rc _____ Modified: trunk/reactos/lib/winmm/Makefile.in --- trunk/reactos/lib/winmm/Makefile.in 2005-02-20 10:48:44 UTC (rev 13670) +++ trunk/reactos/lib/winmm/Makefile.in 2005-02-20 11:03:14 UTC (rev 13671) @@ -5,6 +5,7 @@ VPATH = @srcdir@ MODULE = winmm.dll IMPORTS = user32 advapi32 kernel32 ntdll +EXTRALIBS = $(LIBUNICODE) C_SRCS = \ driver.c \ _____ Modified: trunk/reactos/lib/winmm/driver.c --- trunk/reactos/lib/winmm/driver.c 2005-02-20 10:48:44 UTC (rev 13670) +++ trunk/reactos/lib/winmm/driver.c 2005-02-20 11:03:14 UTC (rev 13671) @@ -1,5 +1,3 @@ -/* -*- tab-width: 8; c-basic-offset: 4 -*- */ - /* * WINE Drivers functions * @@ -33,15 +31,16 @@ #include "mmddk.h" #include "winemm.h" #include "wine/debug.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(driver); -#define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion" - static LPWINE_DRIVER lpDrvItemList /* = NULL */; +static const WCHAR HKLM_BASE[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t ','\\', + 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0 }; WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */; -LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */; +LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM) /* = NULL */; LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */; LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */; @@ -207,16 +206,19 @@ * DRIVER_GetLibName [internal] * */ -BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz) +BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz) { HKEY hKey, hSecKey; DWORD bufLen, lRet; + static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0}; + WCHAR wsznull = '\0'; - lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey); + lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey); if (lRet == ERROR_SUCCESS) { - lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey); + lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey); if (lRet == ERROR_SUCCESS) { - lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf, &bufLen); + bufLen = sz; + lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen); RegCloseKey( hSecKey ); } RegCloseKey( hKey ); @@ -224,7 +226,7 @@ if (lRet == ERROR_SUCCESS) return TRUE; /* default to system.ini if we can't find it in the registry, * to support native installations where system.ini is still used */ - return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI"); + return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz, wszSystemIni); } /*********************************************************************** *** @@ -232,16 +234,16 @@ * * Tries to load a 32 bit driver whose DLL's (module) name is fn */ -LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2) +LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2) { LPWINE_DRIVER lpDrv = NULL; HMODULE hModule = 0; - LPSTR ptr; + LPWSTR ptr; LPCSTR cause = 0; - TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2); + TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2); - if ((ptr = strchr(fn, ' ')) != NULL) { + if ((ptr = strchrW(fn, ' ')) != NULL) { *ptr++ = '\0'; while (*ptr == ' ') ptr++; if (*ptr == '\0') ptr = NULL; @@ -250,7 +252,7 @@ lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER)); if (lpDrv == NULL) {cause = "OOM"; goto exit;} - if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;} + if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;} lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc"); if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;} @@ -290,7 +292,7 @@ exit: FreeLibrary(hModule); HeapFree(GetProcessHeap(), 0, lpDrv); - TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause); + TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause); return NULL; } @@ -301,23 +303,59 @@ * (0,1,DRV_ENABLE,0 ,0) * (0,1,DRV_OPEN ,buf[256],0) */ -HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2) +HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam) { + INT len; + LPWSTR dn = NULL; + LPWSTR sn = NULL; + HDRVR ret; + + if (lpDriverName) + { + len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 ); + dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (!dn) return 0; + MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len ); + } + + if (lpSectionName) + { + len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 ); + sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (!sn) return 0; + MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len ); + } + + ret = OpenDriver(dn, sn, lParam); + + if (dn) HeapFree(GetProcessHeap(), 0, dn); + if (sn) HeapFree(GetProcessHeap(), 0, sn); + return ret; +} + +/********************************************************************** **** + * OpenDriver [WINMM.@] + * DrvOpen [WINMM.@] + */ +HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam) +{ LPWINE_DRIVER lpDrv = NULL; - char libName[128]; - LPCSTR lsn = lpSectionName; + WCHAR libName[128]; + LPCWSTR lsn = lpSectionName; - TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2); + TRACE("(%s, %s, 0x%08lx);\n", + debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam); if (lsn == NULL) { - lstrcpynA(libName, lpDriverName, sizeof(libName)); + static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0}; + lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR)); - if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2))) + if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam))) goto the_end; - lsn = "Drivers32"; + lsn = wszDrivers32; } if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) && - (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2))) + (lpDrv = DRIVER_TryOpenDriver32(libName, lParam))) goto the_end; /* now we will try a 16 bit driver (and add all the glue to make it work... which @@ -326,12 +364,13 @@ */ WINMM_CheckForMMSystem(); if (pFnOpenDriver16 && - (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam2))) + (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam))) { - if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end; + if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end; HeapFree(GetProcessHeap(), 0, lpDrv); } - TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName)); + TRACE("Failed to open driver %s from system.ini file, section %s\n", + debugstr_w(lpDriverName), debugstr_w(lpSectionName)); return 0; the_end: @@ -340,40 +379,6 @@ } /*********************************************************************** *** - * OpenDriver [WINMM.@] - * DrvOpen [WINMM.@] - */ -HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam) -{ - INT len; - LPSTR dn = NULL; - LPSTR sn = NULL; - HDRVR ret; - - if (lpDriverName) - { - len = WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, NULL, 0, NULL, NULL ); - dn = HeapAlloc( GetProcessHeap(), 0, len ); - if (!dn) return 0; - WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, dn, len, NULL, NULL ); - } - - if (lpSectionName) - { - len = WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, NULL, 0, NULL, NULL ); - sn = HeapAlloc( GetProcessHeap(), 0, len ); - if (!sn) return 0; - WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, sn, len, NULL, NULL ); - } - - ret = OpenDriverA(dn, sn, lParam); - - HeapFree(GetProcessHeap(), 0, dn); - HeapFree(GetProcessHeap(), 0, sn); - return ret; -} - -/********************************************************************** **** * CloseDriver [WINMM.@] * DrvClose [WINMM.@] */ _____ Modified: trunk/reactos/lib/winmm/mci.c --- trunk/reactos/lib/winmm/mci.c 2005-02-20 10:48:44 UTC (rev 13670) +++ trunk/reactos/lib/winmm/mci.c 2005-02-20 11:03:14 UTC (rev 13671) @@ -31,8 +31,17 @@ * - use a default registry setting to replace the [mci] section in * configuration file (layout of info in registry should be compatible * with all Windows' version - which use different layouts of course) + * - implement automatic open + * + only works on string interface, on regular devices (don't work on all + * nor custom devices) + * - command table handling isn't thread safe */ +/* to be cross checked: + * - heapalloc for *sizeof(WCHAR) when needed + * - size of string in WCHAR or bytes? (#chars for MCI_INFO, #bytes for MCI_SYSINFO) + */ + #include "config.h" #include "wine/port.h" @@ -49,34 +58,41 @@ #include "winuser.h" #include "winnls.h" #include "winreg.h" +#include "wownt32.h" #include "digitalv.h" #include "winemm.h" #include "wine/debug.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(mci); -WINMM_MapType (*pFnMciMapMsg16To32A) (WORD,WORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD) /* = NULL */; -WINMM_MapType (*pFnMciMapMsg32ATo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD) /* = NULL */; +WINMM_MapType (*pFnMciMapMsg16To32W) (WORD,WORD,DWORD*) /* = NULL */; +WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD) /* = NULL */; +WINMM_MapType (*pFnMciMapMsg32WTo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */; +WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD) /* = NULL */; /* First MCI valid device ID (0 means error) */ #define MCI_MAGIC 0x0001 /* MCI settings */ -#define HKLM_MCI "Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI" +static const WCHAR wszHklmMci [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t ','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',' \\','M','C','I',0}; +static const WCHAR wszNull [] = {0}; +static const WCHAR wszAll [] = {'A','L','L',0}; +static const WCHAR wszMci [] = {'M','C','I',0}; +static const WCHAR wszOpen [] = {'o','p','e','n',0}; +static const WCHAR wszSystemIni[] = {'s','y','s','t','e','m','.','i','n','i',0}; /* dup a string and uppercase it */ -inline static LPSTR str_dup_upper( LPCSTR str ) +inline static LPWSTR str_dup_upper( LPCWSTR str ) { - INT len = strlen(str) + 1; - LPSTR p = HeapAlloc( GetProcessHeap(), 0, len ); + INT len = (strlenW(str) + 1) * sizeof(WCHAR); + LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len ); if (p) { memcpy( p, str, len ); - CharUpperA( p ); + CharUpperW( p ); } return p; } @@ -100,7 +116,7 @@ /*********************************************************************** *** * MCI_GetDriverFromString [internal] */ -UINT MCI_GetDriverFromString(LPCSTR lpstrName) +UINT MCI_GetDriverFromString(LPCWSTR lpstrName) { LPWINE_MCIDRIVER wmd; UINT ret = 0; @@ -108,20 +124,20 @@ if (!lpstrName) return 0; - if (!lstrcmpiA(lpstrName, "ALL")) + if (!strcmpiW(lpstrName, wszAll)) return MCI_ALL_DEVICE_ID; EnterCriticalSection(&WINMM_IData->cs); for (wmd = WINMM_IData->lpMciDrvs; wmd; wmd = wmd->lpNext) { - if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) { + if (wmd->lpstrElementName && strcmpW(wmd->lpstrElementName, lpstrName) == 0) { ret = wmd->wDeviceID; break; } - if (wmd->lpstrDeviceType && strcasecmp(wmd->lpstrDeviceType, lpstrName) == 0) { + if (wmd->lpstrDeviceType && strcmpiW(wmd->lpstrDeviceType, lpstrName) == 0) { ret = wmd->wDeviceID; break; } - if (wmd->lpstrAlias && strcasecmp(wmd->lpstrAlias, lpstrName) == 0) { + if (wmd->lpstrAlias && strcmpiW(wmd->lpstrAlias, lpstrName) == 0) { ret = wmd->wDeviceID; break; } @@ -134,13 +150,26 @@ /*********************************************************************** *** * MCI_MessageToString [internal] */ -const char* MCI_MessageToString(UINT16 wMsg) +const char* MCI_MessageToString(UINT wMsg) { static char buffer[100]; #define CASE(s) case (s): return #s switch (wMsg) { + CASE(DRV_LOAD); + CASE(DRV_ENABLE); + CASE(DRV_OPEN); + CASE(DRV_CLOSE); + CASE(DRV_DISABLE); + CASE(DRV_FREE); + CASE(DRV_CONFIGURE); + CASE(DRV_QUERYCONFIGURE); + CASE(DRV_INSTALL); + CASE(DRV_REMOVE); + CASE(DRV_EXITSESSION); + CASE(DRV_EXITAPPLICATION); + CASE(DRV_POWER); CASE(MCI_BREAK); CASE(MCI_CLOSE); CASE(MCI_CLOSE_DRIVER); @@ -193,23 +222,350 @@ } } +LPWSTR MCI_strdupAtoW( LPCSTR str ) +{ + LPWSTR ret; + INT len; + + if (!str) return NULL; + len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); + ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len ); + return ret; +} + +LPSTR MCI_strdupWtoA( LPCWSTR str ) +{ + LPSTR ret; + INT len; + + if (!str) return NULL; + len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL ); + ret = HeapAlloc( GetProcessHeap(), 0, len ); + if (ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL ); + return ret; +} + +static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2) +{ + if (msg < DRV_RESERVED) return 0; + + switch (msg) + { + case MCI_CLOSE: + case MCI_CONFIGURE: + case MCI_PLAY: + case MCI_SEEK: + case MCI_STOP: + case MCI_PAUSE: + case MCI_GETDEVCAPS: + case MCI_SPIN: + case MCI_SET: + case MCI_STEP: + case MCI_RECORD: + case MCI_BREAK: + case MCI_SOUND: + case MCI_STATUS: + case MCI_CUE: + case MCI_REALIZE: + case MCI_PUT: + case MCI_WHERE: + case MCI_FREEZE: + case MCI_UNFREEZE: + case MCI_CUT: + case MCI_COPY: + case MCI_PASTE: + case MCI_UPDATE: + case MCI_RESUME: + case MCI_DELETE: + return 0; + + case MCI_OPEN: + { + MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA*)*dwParam2; + MCI_OPEN_PARMSW *mci_openW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR) + sizeof(*mci_openW) + 2 * sizeof(DWORD)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_openW = (MCI_OPEN_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_openW->dwCallback = mci_openA->dwCallback; + + if (dwParam1 & MCI_OPEN_TYPE) + { + if (dwParam1 & MCI_OPEN_TYPE_ID) + mci_openW->lpstrDeviceType = (LPWSTR)mci_openA->lpstrDeviceType; + else + mci_openW->lpstrDeviceType = MCI_strdupAtoW(mci_openA->lpstrDeviceType); + } + if (dwParam1 & MCI_OPEN_ELEMENT) + { + if (dwParam1 & MCI_OPEN_ELEMENT_ID) + mci_openW->lpstrElementName = (LPWSTR)mci_openA->lpstrElementName; + else + mci_openW->lpstrElementName = MCI_strdupAtoW(mci_openA->lpstrElementName); + } + if (dwParam1 & MCI_OPEN_ALIAS) + mci_openW->lpstrAlias = MCI_strdupAtoW(mci_openA->lpstrAlias); + /* FIXME: this is only needed for specific types of MCI devices, and + * may cause a segfault if the two DWORD:s don't exist at the end of + * mci_openA + */ + memcpy(mci_openW + 1, mci_openA + 1, 2 * sizeof(DWORD)); + } + return 1; + + case MCI_WINDOW: + if (dwParam1 & MCI_ANIM_WINDOW_TEXT) + { + MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)*dwParam2; + MCI_ANIM_WINDOW_PARMSW *mci_windowW; + + mci_windowW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW)); + if (!mci_windowW) return -1; + + *dwParam2 = (DWORD_PTR)mci_windowW; + + mci_windowW->lpstrText = MCI_strdupAtoW(mci_windowA->lpstrText); + + if (dwParam1 & MCI_NOTIFY) + mci_windowW->dwCallback = mci_windowA->dwCallback; + if (dwParam1 & MCI_ANIM_WINDOW_HWND) + mci_windowW->hWnd = mci_windowA->hWnd; + if (dwParam1 & MCI_ANIM_WINDOW_STATE) + mci_windowW->nCmdShow = mci_windowA->nCmdShow; + + return 1; + } + return 0; + + case MCI_SYSINFO: + { + MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*dwParam2; + MCI_SYSINFO_PARMSW *mci_sysinfoW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW) + sizeof(DWORD_PTR)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_sysinfoW = (MCI_SYSINFO_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_sysinfoW->dwCallback = mci_sysinfoA->dwCallback; + + mci_sysinfoW->dwRetSize = mci_sysinfoA->dwRetSize; + mci_sysinfoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW->dwRetSize); + mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber; + mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType; + return 1; + } + case MCI_INFO: + { + MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*dwParam2; + MCI_INFO_PARMSW *mci_infoW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW) + sizeof(DWORD_PTR)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_infoW = (MCI_INFO_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_infoW->dwCallback = mci_infoA->dwCallback; + + mci_infoW->dwRetSize = mci_infoA->dwRetSize * sizeof(WCHAR); /* it's not the same as SYSINFO !!! */ + mci_infoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_infoW->dwRetSize); + return 1; + } + case MCI_SAVE: + { + MCI_SAVE_PARMSA *mci_saveA = (MCI_SAVE_PARMSA *)*dwParam2; + MCI_SAVE_PARMSW *mci_saveW; + + mci_saveW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_saveW)); + if (!mci_saveW) return -1; + + *dwParam2 = (DWORD_PTR)mci_saveW; + if (dwParam1 & MCI_NOTIFY) + mci_saveW->dwCallback = mci_saveA->dwCallback; + mci_saveW->lpfilename = MCI_strdupAtoW(mci_saveA->lpfilename); + return 1; + } + case MCI_LOAD: + { + MCI_LOAD_PARMSA *mci_loadA = (MCI_LOAD_PARMSA *)*dwParam2; + MCI_LOAD_PARMSW *mci_loadW; + + mci_loadW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW)); + if (!mci_loadW) return -1; + + *dwParam2 = (DWORD_PTR)mci_loadW; + if (dwParam1 & MCI_NOTIFY) + mci_loadW->dwCallback = mci_loadA->dwCallback; + mci_loadW->lpfilename = MCI_strdupAtoW(mci_loadA->lpfilename); + return 1; + } + + case MCI_ESCAPE: + { + MCI_VD_ESCAPE_PARMSA *mci_vd_escapeA = (MCI_VD_ESCAPE_PARMSA *)*dwParam2; + MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW; + + mci_vd_escapeW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW)); + if (!mci_vd_escapeW) return -1; + + *dwParam2 = (DWORD_PTR)mci_vd_escapeW; + if (dwParam1 & MCI_NOTIFY) + mci_vd_escapeW->dwCallback = mci_vd_escapeA->dwCallback; + mci_vd_escapeW->lpstrCommand = MCI_strdupAtoW(mci_vd_escapeA->lpstrCommand); + return 1; + } + default: + FIXME("Message %s needs translation\n", MCI_MessageToString(msg)); + return -1; + } +} + +static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, + DWORD result) +{ + switch (msg) + { + case MCI_OPEN: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)*ptr; + MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)(ptr + 1); + + mci_openA->wDeviceID = mci_openW->wDeviceID; + + if (dwParam1 & MCI_OPEN_TYPE) + { + if (!(dwParam1 & MCI_OPEN_TYPE_ID)) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrDeviceType); + } + if (dwParam1 & MCI_OPEN_ELEMENT) + { + if (!(dwParam1 & MCI_OPEN_ELEMENT_ID)) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrElementName); + } + if (dwParam1 & MCI_OPEN_ALIAS) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrAlias); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_WINDOW: + if (dwParam1 & MCI_ANIM_WINDOW_TEXT) + { + MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_windowW->lpstrText); + HeapFree(GetProcessHeap(), 0, mci_windowW); + } + break; + + case MCI_SYSINFO: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*ptr; + MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)(ptr + 1); + + if (!result) + { + mci_sysinfoA->dwNumber = mci_sysinfoW->dwNumber; + mci_sysinfoA->wDeviceType = mci_sysinfoW->wDeviceType; + if (dwParam1 & MCI_SYSINFO_QUANTITY) + *(DWORD*)mci_sysinfoA->lpstrReturn = *(DWORD*)mci_sysinfoW->lpstrReturn; + else + WideCharToMultiByte(CP_ACP, 0, + mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize, + mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize, + NULL, NULL); + } + + HeapFree(GetProcessHeap(), 0, mci_sysinfoW->lpstrReturn); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_INFO: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*ptr; + MCI_INFO_PARMSW *mci_infoW = (MCI_INFO_PARMSW *)(ptr + 1); + + if (!result) + { + WideCharToMultiByte(CP_ACP, 0, + mci_infoW->lpstrReturn, mci_infoW->dwRetSize / sizeof(WCHAR), + mci_infoA->lpstrReturn, mci_infoA->dwRetSize, + NULL, NULL); + } + + HeapFree(GetProcessHeap(), 0, mci_infoW->lpstrReturn); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_SAVE: + { + MCI_SAVE_PARMSW *mci_saveW = (MCI_SAVE_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_saveW->lpfilename); + HeapFree(GetProcessHeap(), 0, mci_saveW); + } + break; + case MCI_LOAD: + { + MCI_LOAD_PARMSW *mci_loadW = (MCI_LOAD_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_loadW->lpfilename); + HeapFree(GetProcessHeap(), 0, mci_loadW); + } + break; + case MCI_ESCAPE: + { + MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW = (MCI_VD_ESCAPE_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW->lpstrCommand); + HeapFree(GetProcessHeap(), 0, mci_vd_escapeW); + } + break; + + default: + FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg)); + break; + } + + return result; +} + /*********************************************************************** *** * MCI_GetDevTypeFromFileName [internal] */ -static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len) +static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len) { - LPSTR tmp; + LPCWSTR tmp; HKEY hKey; - - if ((tmp = strrchr(fileName, '.'))) { - if (RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\MCI Extensions", + static const WCHAR keyW[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t ','\\', + 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',' \\', + 'M','C','I',' ','E','x','t','e','n','s','i','o','n','s',0}; + if ((tmp = strrchrW(fileName, '.'))) { + if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, keyW, 0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { DWORD dwLen = len; - LONG lRet = RegQueryValueExA( hKey, tmp + 1, 0, 0, buf, &dwLen ); + LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen ); RegCloseKey( hKey ); if (lRet == ERROR_SUCCESS) return 0; } - TRACE("No ...\\MCI Extensions entry for '%s' found.\n", tmp); + TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp)); } return MCIERR_EXTENSION_NOT_FOUND; } @@ -219,9 +575,9 @@ typedef struct tagWINE_MCICMDTABLE { UINT uDevType; - LPCSTR lpTable; + const BYTE* lpTable; UINT nVerbs; /* number of verbs in command table */ - LPCSTR* aVerbs; /* array of verbs to speed up the verb look up process */ + LPCWSTR* aVerbs; /* array of verbs to speed up the verb look up process */ } WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE; static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE]; @@ -231,7 +587,8 @@ */ static BOOL MCI_IsCommandTableValid(UINT uTbl) { - LPCSTR lmem, str; + const BYTE* lmem; + LPCWSTR str; DWORD flg; WORD eid; int idx = 0; @@ -245,28 +602,26 @@ lmem = S_MciCmdTable[uTbl].lpTable; do { - do { - str = lmem; - lmem += strlen(lmem) + 1; - flg = *(const DWORD*)lmem; - eid = *(const WORD*)(lmem + sizeof(DWORD)); - lmem += sizeof(DWORD) + sizeof(WORD); - idx ++; - /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */ - switch (eid) { - case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */ - case MCI_STRING: if (inCst) return FALSE; break; - case MCI_INTEGER: if (!*str) return FALSE; break; - case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break; - case MCI_RETURN: if (*str || idx != 1) return FALSE; break; - case MCI_FLAG: if (!*str) return FALSE; break; - case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break; - case MCI_RECT: if (!*str || inCst) return FALSE; break; - case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break; - case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break; - default: return FALSE; - } - } while (eid != MCI_END_COMMAND_LIST); + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); + flg = *(const DWORD*)lmem; + eid = *(const WORD*)(lmem + sizeof(DWORD)); + lmem += sizeof(DWORD) + sizeof(WORD); + idx ++; + /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */ + switch (eid) { + case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */ + case MCI_STRING: if (inCst) return FALSE; break; + case MCI_INTEGER: if (!*str) return FALSE; break; + case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break; + case MCI_RETURN: if (*str || idx != 1) return FALSE; break; + case MCI_FLAG: if (!*str) return FALSE; break; + case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break; + case MCI_RECT: if (!*str || inCst) return FALSE; break; + case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break; + case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break; + default: return FALSE; + } } while (eid != MCI_END_COMMAND_LIST); return TRUE; } @@ -276,8 +631,8 @@ */ static BOOL MCI_DumpCommandTable(UINT uTbl) { - LPCSTR lmem; - LPCSTR str; + const BYTE* lmem; + LPCWSTR str; DWORD flg; WORD eid; @@ -289,14 +644,14 @@ lmem = S_MciCmdTable[uTbl].lpTable; do { do { - str = lmem; - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); flg = *(const DWORD*)lmem; eid = *(const WORD*)(lmem + sizeof(DWORD)); - TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); + /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */ lmem += sizeof(DWORD) + sizeof(WORD); } while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST); - TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); + /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */ } while (eid != MCI_END_COMMAND_LIST); return TRUE; } @@ -308,8 +663,8 @@ static UINT MCI_GetCommandTable(UINT uDevType) { UINT uTbl; - char buf[32]; - LPCSTR str = NULL; + WCHAR buf[32]; + LPCWSTR str = NULL; /* first look up existing for existing devType */ for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) { @@ -319,15 +674,16 @@ /* well try to load id */ if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) { - if (LoadStringA(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf))) { + if (LoadStringW(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { str = buf; } } else if (uDevType == 0) { - str = "CORE"; + static const WCHAR wszCore[] = {'C','O','R','E',0}; + str = wszCore; } uTbl = MCI_NO_COMMAND_TABLE; if (str) { - HRSRC hRsrc = FindResourceA(WINMM_IData->hWinMM32Instance, str, (LPCSTR)RT_RCDATA); + HRSRC hRsrc = FindResourceW(WINMM_IData->hWinMM32Instance, str, (LPCWSTR)RT_RCDATA); HANDLE hMem = 0; if (hRsrc) hMem = LoadResource(WINMM_IData->hWinMM32Instance, hRsrc); @@ -335,7 +691,7 @@ uTbl = MCI_SetCommandTable(LockResource(hMem), uDevType); } else { WARN("No command table found in resource %p[%s]\n", - WINMM_IData->hWinMM32Instance, str); + WINMM_IData->hWinMM32Instance, debugstr_w(str)); } } TRACE("=> %d\n", uTbl); @@ -359,10 +715,11 @@ bInitDone = TRUE; MCI_GetCommandTable(0); } - + TRACE("(%p, %u)\n", table, uDevType); for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) { if (!S_MciCmdTable[uTbl].lpTable) { - LPCSTR lmem, str; + const BYTE* lmem; + LPCWSTR str; WORD eid; WORD count; @@ -378,21 +735,22 @@ lmem = S_MciCmdTable[uTbl].lpTable; count = 0; do { - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); eid = *(const WORD*)(lmem + sizeof(DWORD)); lmem += sizeof(DWORD) + sizeof(WORD); if (eid == MCI_COMMAND_HEAD) count++; } while (eid != MCI_END_COMMAND_LIST); - S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR)); + S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCWSTR)); S_MciCmdTable[uTbl].nVerbs = count; lmem = S_MciCmdTable[uTbl].lpTable; count = 0; do { - str = lmem; - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); eid = *(const WORD*)(lmem + sizeof(DWORD)); lmem += sizeof(DWORD) + sizeof(WORD); if (eid == MCI_COMMAND_HEAD) @@ -409,11 +767,12 @@ /*********************************************************************** *** * MCI_DeleteCommandTable [internal] */ -static BOOL MCI_DeleteCommandTable(UINT uTbl) +BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete) { if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable) return FALSE; + if (delete) HeapFree(GetProcessHeap(), 0, (void*)S_MciCmdTable[uTbl].lpTable); S_MciCmdTable[uTbl].lpTable = NULL; HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs); S_MciCmdTable[uTbl].aVerbs = 0; @@ -455,33 +814,33 @@ /*********************************************************************** *** * MCI_OpenMciDriver [internal] */ -static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCSTR drvTyp, LPARAM lp) +static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, LPARAM lp) { - char libName[128]; + WCHAR libName[128]; - if (!DRIVER_GetLibName(drvTyp, "mci", libName, sizeof(libName))) + if (!DRIVER_GetLibName(drvTyp, wszMci, libName, sizeof(libName))) return FALSE; wmd->bIs32 = 0xFFFF; /* First load driver */ if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) { wmd->bIs32 = TRUE; - } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32ATo16) { + } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32WTo16) { WINMM_MapType res; - switch (res = pFnMciMapMsg32ATo16(0, DRV_OPEN, 0, &lp)) { + switch (res = pFnMciMapMsg32WTo16(0, DRV_OPEN, 0, &lp)) { case WINMM_MAP_MSGERROR: TRACE("Not handled yet (DRV_OPEN)\n"); break; case WINMM_MAP_NOMEM: - TRACE("Problem mapping msg=DRV_OPEN from 32a to 16\n"); + TRACE("Problem mapping msg=DRV_OPEN from 32W to 16\n"); break; case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - if ((wmd->hDriver = OpenDriverA(drvTyp, "mci", lp))) + if ((wmd->hDriver = OpenDriver(drvTyp, wszMci, lp))) wmd->bIs32 = FALSE; if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg32ATo16(0, DRV_OPEN, 0, lp); + pFnMciUnMapMsg32WTo16(0, DRV_OPEN, 0, lp); break; } } @@ -491,11 +850,11 @@ /*********************************************************************** *** * MCI_LoadMciDriver [internal] */ -static DWORD MCI_LoadMciDriver(LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) +static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) { - LPSTR strDevTyp = str_dup_upper(_strDevTyp); + LPWSTR strDevTyp = str_dup_upper(_strDevTyp); LPWINE_MCIDRIVER wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd)); - MCI_OPEN_DRIVER_PARMSA modp; + MCI_OPEN_DRIVER_PARMSW modp; DWORD dwRet = 0; if (!wmd || !strDevTyp) { @@ -530,13 +889,13 @@ /* silence warning if all is used... some bogus program use commands like * 'open all'... */ - if (strcasecmp(strDevTyp, "all") == 0) { + if (strcmpiW(strDevTyp, wszAll) == 0) { dwRet = MCIERR_CANNOT_USE_ALL; } else { FIXME("Couldn't load driver for type %s.\n" "If you don't have a windows installation accessible from Wine,\n" "you perhaps forgot to create a [mci] section in system.ini\n", - strDevTyp); + debugstr_w(strDevTyp)); dwRet = MCIERR_DEVICE_NOT_INSTALLED; [truncated at 1000 lines; 5412 more skipped]

19 years, 10 months

[gvg] 13670: Need to W->A convert the ReactOS version string too

by gvg＠svn.reactos.com

Need to W->A convert the ReactOS version string too Modified: trunk/reactos/lib/kernel32/misc/env.c _____ Modified: trunk/reactos/lib/kernel32/misc/env.c --- trunk/reactos/lib/kernel32/misc/env.c 2005-02-20 10:43:00 UTC (rev 13669) +++ trunk/reactos/lib/kernel32/misc/env.c 2005-02-20 10:48:44 UTC (rev 13670) @@ -336,6 +336,7 @@ lpVersionInformation->dwBuildNumber = viw.dwBuildNumber; lpVersionInformation->dwPlatformId = viw.dwPlatformId; + /* convert the win version string */ RtlInitUnicodeString(&CSDVersionW, viw.szCSDVersion); CSDVersionA.Length = 0; @@ -343,6 +344,16 @@ CSDVersionA.Buffer = lpVersionInformation->szCSDVersion; RtlUnicodeStringToAnsiString(&CSDVersionA, &CSDVersionW, FALSE); + + /* convert the ReactOS version string */ + CSDVersionW.Buffer = viw.szCSDVersion + CSDVersionW.Length / sizeof(WCHAR) + 1; + CSDVersionW.MaximumLength = sizeof(viw.szCSDVersion) - (CSDVersionW.Length + sizeof(WCHAR)); + CSDVersionW.Length = wcslen(CSDVersionW.Buffer) * sizeof(WCHAR); + CSDVersionA.Buffer = lpVersionInformation->szCSDVersion + CSDVersionA.Length + 1; + CSDVersionA.MaximumLength = sizeof(lpVersionInformation->szCSDVersion) - (CSDVersionA.Length + 1); + CSDVersionA.Length = 0; + + RtlUnicodeStringToAnsiString(&CSDVersionA, &CSDVersionW, FALSE); /* copy back the extended fields */ if(viw.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXW))

19 years, 10 months

[mf] 13669: handle new expat 1.95.8 error codes

by mf＠svn.reactos.com

handle new expat 1.95.8 error codes Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp _____ Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp --- trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp 2005-02-20 10:36:35 UTC (rev 13668) +++ trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp 2005-02-20 10:43:00 UTC (rev 13669) @@ -426,13 +426,18 @@ case XML_ERROR_UNBOUND_PREFIX: return "XML_ERROR_UNBOUND_PREFIX"; // EXPAT version >= 1.95.8 #if XML_MAJOR_VERSION>1 || (XML_MAJOR_VERSION==1 && XML_MINOR_VERSION>95) || (XML_MAJOR_VERSION==1 && XML_MINOR_VERSION==95 && XML_MICRO_VERSION>7) + case XML_ERROR_UNDECLARING_PREFIX: return "XML_ERROR_UNDECLARING_PREFIX"; + case XML_ERROR_INCOMPLETE_PE: return "XML_ERROR_INCOMPLETE_PE"; + case XML_ERROR_XML_DECL: return "XML_ERROR_XML_DECL"; + case XML_ERROR_TEXT_DECL: return "XML_ERROR_TEXT_DECL"; + case XML_ERROR_PUBLICID: return "XML_ERROR_PUBLICID"; case XML_ERROR_SUSPENDED: return "XML_ERROR_SUSPENDED"; case XML_ERROR_NOT_SUSPENDED: return "XML_ERROR_NOT_SUSPENDED"; case XML_ERROR_ABORTED: return "XML_ERROR_ABORTED"; case XML_ERROR_FINISHED: return "XML_ERROR_FINISHED"; case XML_ERROR_SUSPEND_PE: return "XML_ERROR_SUSPEND_PE"; -#endif -#if XML_MAJOR_VERSION>=2 +//#endif +//#if XML_MAJOR_VERSION>=2 /* Added in 2.0. */ case XML_ERROR_RESERVED_PREFIX_XML: return "XML_ERROR_RESERVED_PREFIX_XML"; case XML_ERROR_RESERVED_PREFIX_XMLNS: return "XML_ERROR_RESERVED_PREFIX_XMLNS";

19 years, 10 months

[mf] 13668: fix XBEL write routine

by mf＠svn.reactos.com

fix XBEL write routine Modified: trunk/reactos/subsys/system/explorer/taskbar/favorites.cpp _____ Modified: trunk/reactos/subsys/system/explorer/taskbar/favorites.cpp --- trunk/reactos/subsys/system/explorer/taskbar/favorites.cpp 2005-02-20 10:21:20 UTC (rev 13667) +++ trunk/reactos/subsys/system/explorer/taskbar/favorites.cpp 2005-02-20 10:36:35 UTC (rev 13668) @@ -455,9 +455,11 @@ super::write(pos); pos.back(); - xbel.write(path, XMLNode::FORMAT_SMART, XMLHeader("1.0", "UTF-8", "<!DOCTYPE xbel" + xbel._header._doctype = "<!DOCTYPE xbel" " PUBLIC \"+//IDN python.org//DTD XML Bookmark Exchange Language 1.0//EN//XML\"\n" - " \"http://www.python.org/topics/xml/dtds/xbel-1.0.dtd\">")); + " \"http://www.python.org/topics/xml/dtds/xbel-1.0.dtd\">"; + + xbel.write(path); } /// import Internet Explorer bookmarks from Favorites folder

19 years, 10 months

[mf] 13667: update Expat and XMLStorage files

by mf＠svn.reactos.com

update Expat and XMLStorage files Modified: trunk/reactos/subsys/system/explorer/shell/webchild.h Added: trunk/reactos/subsys/system/explorer/utility/expat.h Added: trunk/reactos/subsys/system/explorer/utility/expat_external.h Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.h _____ Modified: trunk/reactos/subsys/system/explorer/shell/webchild.h --- trunk/reactos/subsys/system/explorer/shell/webchild.h 2005-02-20 10:21:19 UTC (rev 13666) +++ trunk/reactos/subsys/system/explorer/shell/webchild.h 2005-02-20 10:21:20 UTC (rev 13667) @@ -347,7 +347,7 @@ *lprcClipRect = rect; assert(lpFrameInfo->cb>=sizeof(OLEINPLACEFRAMEINFO)); - lpFrameInfo->fMDIApp = FALSE; + lpFrameInfo->fMDIApp = FALSE; //@@ lpFrameInfo->hwndFrame = 0; lpFrameInfo->haccel = 0; lpFrameInfo->cAccelEntries = 0; _____ Copied: trunk/reactos/subsys/system/explorer/utility/expat.h (from rev 13664, trunk/reactos/lib/expat/lib/expat.h) _____ Copied: trunk/reactos/subsys/system/explorer/utility/expat_external.h (from rev 13664, trunk/reactos/lib/expat/lib/expat_external.h) _____ Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp --- trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp 2005-02-20 10:21:19 UTC (rev 13666) +++ trunk/reactos/subsys/system/explorer/utility/xmlstorage.cpp 2005-02-20 10:21:20 UTC (rev 13667) @@ -432,6 +432,12 @@ case XML_ERROR_FINISHED: return "XML_ERROR_FINISHED"; case XML_ERROR_SUSPEND_PE: return "XML_ERROR_SUSPEND_PE"; #endif +#if XML_MAJOR_VERSION>=2 + /* Added in 2.0. */ + case XML_ERROR_RESERVED_PREFIX_XML: return "XML_ERROR_RESERVED_PREFIX_XML"; + case XML_ERROR_RESERVED_PREFIX_XMLNS: return "XML_ERROR_RESERVED_PREFIX_XMLNS"; + case XML_ERROR_RESERVED_NAMESPACE_URI: return "XML_ERROR_RESERVED_NAMESPACE_URI"; +#endif } std::ostringstream out; _____ Modified: trunk/reactos/subsys/system/explorer/utility/xmlstorage.h --- trunk/reactos/subsys/system/explorer/utility/xmlstorage.h 2005-02-20 10:21:19 UTC (rev 13666) +++ trunk/reactos/subsys/system/explorer/utility/xmlstorage.h 2005-02-20 10:21:20 UTC (rev 13667) @@ -612,6 +612,23 @@ return out; } +protected: + Children _children; + AttributeMap _attributes; + + std::string _leading; + std::string _content; + std::string _end_leading; + std::string _trailing; + + XMLNode* get_first_child() const + { + if (!_children.empty()) + return _children.front(); + else + return NULL; + } + XMLNode* find(const XS_String& name, int n=0) const { for(Children::const_iterator it=_children.begin(); it!=_children.end(); ++it) @@ -670,23 +687,6 @@ /// relative XPath create function XMLNode* create_relative(const char* path); -protected: - Children _children; - AttributeMap _attributes; - - std::string _leading; - std::string _content; - std::string _end_leading; - std::string _trailing; - - XMLNode* get_first_child() const - { - if (!_children.empty()) - return _children.front(); - else - return NULL; - } - void write_worker(std::ostream& out, int indent) const; void pretty_write_worker(std::ostream& out, int indent) const; void smart_write_worker(std::ostream& out, int indent) const; @@ -1533,6 +1533,8 @@ return out.str(); } + std::string get_instructions() const {return _instructions;} + XML_Error get_error_code() {return XML_GetErrorCode(_parser);} std::string get_error_string() const; @@ -1541,6 +1543,7 @@ XML_Parser _parser; std::string _xml_version; std::string _encoding; + std::string _instructions; std::string _content; enum {TAG_NONE, TAG_START, TAG_END} _last_tag; @@ -1592,11 +1595,14 @@ if (!_doctype.empty()) out << _doctype << '\n'; + if (!_additional.empty()) + out << _additional << '\n'; } std::string _version; std::string _encoding; std::string _doctype; + std::string _additional; }; @@ -1640,6 +1646,8 @@ { XML_Status status = reader.read(); + _header._additional = reader.get_instructions(); + if (status == XML_STATUS_ERROR) { std::ostringstream out; @@ -1656,6 +1664,8 @@ { XML_Status status = reader.read(); + _header._additional = reader.get_instructions(); + if (status == XML_STATUS_ERROR) { std::ostringstream out; @@ -1669,9 +1679,9 @@ } /// write XML stream preserving previous white space and comments - std::ostream& write(std::ostream& out, WRITE_MODE mode=FORMAT_SMART, const XMLHeader& header=XMLHeader()) const + std::ostream& write(std::ostream& out, WRITE_MODE mode=FORMAT_SMART) const { - header.print(out); + _header.print(out); if (!_children.empty()) _children.front()->write(out); @@ -1685,11 +1695,11 @@ return write(out, FORMAT_PRETTY); } - void write(LPCTSTR path, WRITE_MODE mode=FORMAT_SMART, const XMLHeader& header=XMLHeader()) const + void write(LPCTSTR path, WRITE_MODE mode=FORMAT_SMART) const { tofstream out(path); - write(out, mode, header); + write(out, mode); } void write_formating(LPCTSTR path) const @@ -1699,6 +1709,7 @@ write_formating(out); } + XMLHeader _header; XML_Error _last_error; std::string _last_error_msg; };

19 years, 10 months

← Newer
1
...
9
10
11
12
13
14
15
...
42
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs February 2005