Ros-diffs

ros-diffs@reactos.org

81390 discussions

[hpoussin] 22588: Update wincrypt.h header (sync with Wine)
by hpoussin＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: hpoussin Date: Sun Jun 25 00:59:20 2006 New Revision: 22588 URL: http://svn.reactos.org/svn/reactos?rev=22588&view=rev Log: Update wincrypt.h header (sync with Wine) Modified: trunk/reactos/include/winbase.h trunk/reactos/include/wincrypt.h Modified: trunk/reactos/include/winbase.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/winbase.h?rev=2258… ============================================================================== --- trunk/reactos/include/winbase.h (original) +++ trunk/reactos/include/winbase.h Sun Jun 25 00:59:20 2006 @@ -778,7 +778,7 @@ WORD wMinute; WORD wSecond; WORD wMilliseconds; -} SYSTEMTIME,*LPSYSTEMTIME; +} SYSTEMTIME,*LPSYSTEMTIME,*PSYSTEMTIME; typedef struct _WIN32_FILE_ATTRIBUTE_DATA { DWORD dwFileAttributes; FILETIME ftCreationTime; Modified: trunk/reactos/include/wincrypt.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/wincrypt.h?rev=225… ============================================================================== --- trunk/reactos/include/wincrypt.h (original) +++ trunk/reactos/include/wincrypt.h Sun Jun 25 00:59:20 2006 @@ -14,7 +14,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __WINE_WINCRYPT_H @@ -128,6 +128,29 @@ DWORD cUnusedBits; } CRYPT_BIT_BLOB, *PCRYPT_BIT_BLOB; +typedef struct _CRYPT_KEY_PROV_PARAM { + DWORD dwParam; + BYTE *pbData; + DWORD cbData; + DWORD dwFlags; +} CRYPT_KEY_PROV_PARAM, *PCRYPT_KEY_PROV_PARAM; + +typedef struct _CRYPT_KEY_PROV_INFO { + LPWSTR pwszContainerName; + LPWSTR pwszProvName; + DWORD dwProvType; + DWORD dwFlags; + DWORD cProvParam; + PCRYPT_KEY_PROV_PARAM rgProvParam; + DWORD dwKeySpec; +} CRYPT_KEY_PROV_INFO, *PCRYPT_KEY_PROV_INFO; + +typedef struct _CERT_KEY_CONTEXT { + DWORD cbSize; + HCRYPTPROV hCryptProv; + DWORD dwKeySpec; +} CERT_KEY_CONTEXT, *PCERT_KEY_CONTEXT; + typedef struct _CERT_PUBLIC_KEY_INFO { CRYPT_ALGORITHM_IDENTIFIER Algorithm; CRYPT_BIT_BLOB PublicKey; @@ -892,6 +915,89 @@ typedef BOOL (WINAPI *PFN_CRYPT_ENUM_OID_INFO)(PCCRYPT_OID_INFO pInfo, void *pvArg); + +typedef struct _CRYPT_SIGN_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgEncodingType; + PCCERT_CONTEXT pSigningCert; + CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm; + void * pvHashAuxInfo; + DWORD cMsgCert; + PCCERT_CONTEXT *rgpMsgCert; + DWORD cMsgCrl; + PCCRL_CONTEXT *rgpMsgCrl; + DWORD cAuthAttr; + PCRYPT_ATTRIBUTE rgAuthAttr; + DWORD cUnauthAttr; + PCRYPT_ATTRIBUTE rgUnauthAttr; + DWORD dwFlags; + DWORD dwInnerContentType; +#ifdef CRYPT_SIGN_MESSAGE_PARA_HAS_CMS_FIELDS + CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm; + void * pvHashEncryptionAuxInfo; +#endif +} CRYPT_SIGN_MESSAGE_PARA, *PCRYPT_SIGN_MESSAGE_PARA; + +#define CRYPT_MESSAGE_BARE_CONTENT_OUT_FLAG 0x00000001 +#define CRYPT_MESSAGE_ENCAPSULATED_CONTENT_OUT_FLAG 0x00000002 +#define CRYPT_MESSAGE_KEYID_SIGNER_FLAG 0x00000004 +#define CRYPT_MESSAGE_SILENT_KEYSET_FLAG 0x00000008 + +typedef PCCERT_CONTEXT (WINAPI *PFN_CRYPT_GET_SIGNER_CERTIFICATE)(void *pvArg, + DWORD dwCertEncodingType, PCERT_INFO pSignerId, HCERTSTORE hMsgCertStore); + +typedef struct _CRYPT_VERIFY_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgAndCertEncodingType; + HCRYPTPROV hCryptProv; + PFN_CRYPT_GET_SIGNER_CERTIFICATE pfnGetSignerCertificate; + void * pvGetArg; +} CRYPT_VERIFY_MESSAGE_PARA, *PCRYPT_VERIFY_MESSAGE_PARA; + +typedef struct _CRYPT_ENCRYPT_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgEncodingType; + HCRYPTPROV hCryptProv; + CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm; + void * pvEncryptionAuxInfo; + DWORD dwFlags; + DWORD dwInnerContentType; +} CRYPT_ENCRYPT_MESSAGE_PARA, *PCRYPT_ENCRYPT_MESSAGE_PARA; + +#define CRYPT_MESSAGE_KEYID_RECIPIENT_FLAG 0x00000004 + +typedef struct _CRYPT_DECRYPT_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgAndCertEncodingType; + DWORD cCertStore; + HCERTSTORE *rghCertStore; +#ifdef CRYPT_DECRYPT_MESSAGE_PARA_HAS_EXTRA_FIELDS + DWORD dwFlags; +#endif +} CRYPT_DECRYPT_MESSAGE_PARA, *PCRYPT_DECRYPT_MESSAGE_PARA; + +typedef struct _CRYPT_HASH_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgEncodingType; + HCRYPTPROV hCryptProv; + CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm; + void * pvHashAuxInfo; +} CRYPT_HASH_MESSAGE_PARA, *PCRYPT_HASH_MESSAGE_PARA; + +typedef struct _CRYPT_KEY_SIGN_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgAndCertEncodingType; + HCRYPTPROV hCryptProv; + DWORD dwKeySpec; + CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm; + void * pvHashAuxInfo; +} CRYPT_KEY_SIGN_MESSAGE_PARA, *PCRYPT_KEY_SIGN_MESSAGE_PARA; + +typedef struct _CRYPT_KEY_VERIFY_MESSAGE_PARA { + DWORD cbSize; + DWORD dwMsgEncodingType; + HCRYPTPROV hCryptProv; +} CRYPT_KEY_VERIFY_MESSAGE_PARA, *PCRYPT_KEY_VERIFY_MESSAGE_PARA; typedef struct _CRYPT_URL_ARRAY { DWORD cUrl; @@ -1916,6 +2022,22 @@ #define CERT_FIND_VALID_ENHKEY_USAGE_FLAG 0x20 #define CERT_FIND_VALID_CTL_USAGE_FLAG 0x20 +#define CRL_FIND_ANY 0 +#define CRL_FIND_ISSUED_BY 1 +#define CRL_FIND_EXISTING 2 +#define CRL_FIND_ISSUED_FOR 3 + +#define CRL_FIND_ISSUED_BY_AKI_FLAG 0x1 +#define CRL_FIND_ISSUED_BY_SIGNATURE_FLAG 0x2 +#define CRL_FIND_ISSUED_BY_DELTA_FLAG 0x4 +#define CRL_FIND_ISSUED_BY_BASE_FLAG 0x8 + +typedef struct _CRL_FIND_ISSUED_FOR_PARA +{ + PCCERT_CONTEXT pSubjectCert; + PCCERT_CONTEXT pIssuerCert; +} CRL_FIND_ISSUED_FOR_PARA, *PCRL_FIND_ISSUED_FOR_PARA; + /* PFN_CERT_STORE_PROV_WRITE_CERT dwFlags values */ #define CERT_STORE_PROV_WRITE_ADD_FLAG 0x1 @@ -1928,6 +2050,21 @@ (1 << CERT_STORE_CERTIFICATE_CONTEXT) #define CERT_STORE_CRL_CONTEXT_FLAG (1 << CERT_STORE_CRL_CONTEXT) #define CERT_STORE_CTL_CONTEXT_FLAG (1 << CERT_STORE_CTL_CONTEXT) + +/* CryptBinaryToString/CryptStringToBinary flags */ +#define CRYPT_STRING_BASE64HEADER 0x00000000 +#define CRYPT_STRING_BASE64 0x00000001 +#define CRYPT_STRING_BINARY 0x00000002 +#define CRYPT_STRING_BASE64REQUESTHEADER 0x00000003 +#define CRYPT_STRING_HEX 0x00000004 +#define CRYPT_STRING_HEXASCII 0x00000005 +#define CRYPT_STRING_BASE64_ANY 0x00000006 +#define CRYPT_STRING_ANY 0x00000007 +#define CRYPT_STRING_HEX_ANY 0x00000008 +#define CRYPT_STRING_BASE64X509CRLHEADER 0x00000009 +#define CRYPT_STRING_HEXADDR 0x0000000a +#define CRYPT_STRING_HEXASCIIADDR 0x0000000b +#define CRYPT_STRING_NOCR 0x80000000 /* OIDs */ #define szOID_RSA "1.2.840.113549" @@ -2366,6 +2503,15 @@ #define CRYPT_UNICODE_NAME_DECODE_DISABLE_IE4_UTF8_FLAG \ CERT_RDN_DISABLE_IE4_UTF8_FLAG +#define CERT_STORE_SIGNATURE_FLAG 0x00000001 +#define CERT_STORE_TIME_VALIDITY_FLAG 0x00000002 +#define CERT_STORE_REVOCATION_FLAG 0x00000004 +#define CERT_STORE_NO_CRL_FLAG 0x00010000 +#define CERT_STORE_NO_ISSUER_FLAG 0x00020000 + +#define CERT_STORE_BASE_CRL_FLAG 0x00000100 +#define CERT_STORE_DELTA_CRL_FLAG 0x00000200 + /* subject types for CryptVerifyCertificateSignatureEx */ #define CRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOB 1 #define CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT 2 @@ -2407,6 +2553,12 @@ #define CERT_NAME_ISSUER_FLAG 0x00000001 #define CERT_NAME_DISABLE_IE4_UTF8_FLAG 0x00010000 + +#define CERT_SET_KEY_PROV_HANDLE_PROP_ID 0x00000001 +#define CERT_SET_KEY_CONTEXT_PROP_ID 0x00000001 + +#define CERT_CREATE_SELFSIGN_NO_SIGN 1 +#define CERT_CREATE_SELFSIGN_NO_KEY_INFO 2 /* function declarations */ /* advapi32.dll */ @@ -2486,6 +2638,20 @@ LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize); VOID WINAPI CryptMemFree(LPVOID pv); +BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary, + DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString); +BOOL WINAPI CryptBinaryToStringW(const BYTE *pbBinary, + DWORD cbBinary, DWORD dwFlags, LPWSTR pszString, DWORD *pcchString); +#define CryptBinaryToString WINELIB_NAME_AW(CryptBinaryToString) + +BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString, + DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, + DWORD *pdwSkip, DWORD *pdwFlags); +BOOL WINAPI CryptStringToBinaryW(LPCWSTR pszString, + DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, + DWORD *pdwSkip, DWORD *pdwFlags); +#define CryptStringToBinary WINELIB_NAME_AW(CryptStringToBinary) + BOOL WINAPI CryptRegisterDefaultOIDFunction(DWORD,LPCSTR,DWORD,LPCWSTR); BOOL WINAPI CryptRegisterOIDFunction(DWORD,LPCSTR,LPCSTR,LPCWSTR,LPCSTR); BOOL WINAPI CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName, @@ -2655,6 +2821,15 @@ const BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags, DWORD dwContextTypeFlags, DWORD *pdwContentType, const void **ppvContext); +BOOL WINAPI CertCompareCertificate(DWORD dwCertEncodingType, + PCERT_INFO pCertId1, PCERT_INFO pCertId2); +BOOL WINAPI CertCompareCertificateName(DWORD dwCertEncodingType, + PCERT_NAME_BLOB pCertName1, PCERT_NAME_BLOB pCertName2); +BOOL WINAPI CertCompareIntegerBlob(PCRYPT_INTEGER_BLOB pInt1, + PCRYPT_INTEGER_BLOB pInt2); +BOOL WINAPI CertComparePublicKeyInfo(DWORD dwCertEncodingType, + PCERT_PUBLIC_KEY_INFO pPublicKey1, PCERT_PUBLIC_KEY_INFO pPublicKey2); + const void *CertCreateContext(DWORD dwContextType, DWORD dwEncodingType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCERT_CREATE_CONTEXT_PARA pCreatePara); @@ -2668,6 +2843,12 @@ PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded); +PCCERT_CONTEXT WINAPI CertCreateSelfSignCertificate(HCRYPTPROV hProv, + PCERT_NAME_BLOB pSubjectIssuerBlob, DWORD dwFlags, + PCRYPT_KEY_PROV_INFO pKeyProvInfo, + PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm, PSYSTEMTIME pStartTime, + PSYSTEMTIME pEndTime, PCERT_EXTENSIONS pExtensions); + BOOL WINAPI CertDeleteCertificateFromStore(PCCERT_CONTEXT pCertContext); BOOL WINAPI CertDeleteCRLFromStore(PCCRL_CONTEXT pCrlContext); @@ -2692,6 +2873,16 @@ PCCTL_CONTEXT WINAPI CertFindCTLInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCTL_CONTEXT pPrevCtlContext); + +PCCERT_CONTEXT WINAPI CertGetIssuerCertificateFromStore(HCERTSTORE hCertStore, + PCCERT_CONTEXT pSubjectContext, PCCERT_CONTEXT pPrevIssuerContext, + DWORD *pdwFlags); + +PCCERT_CONTEXT WINAPI CertGetSubjectCertificateFromStore(HCERTSTORE hCertStore, + DWORD dwCertEncodingType, PCERT_INFO pCertId); + +PCCRL_CONTEXT WINAPI CertGetCRLFromStore(HCERTSTORE hCertStore, + PCCERT_CONTEXT pIssuerContext, PCCRL_CONTEXT pPrevCrlContext, DWORD *pdwFlags); BOOL WINAPI CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement); @@ -2764,6 +2955,19 @@ CERT_EXTENSION rgExtensions[]); PCERT_RDN_ATTR WINAPI CertFindRDNAttr(LPCSTR pszObjId, PCERT_NAME_INFO pName); +BOOL WINAPI CertIsValidCRLForCertificate(PCCERT_CONTEXT pCert, + PCCRL_CONTEXT pCrl, DWORD dwFlags, void *pvReserved); +BOOL WINAPI CertFindCertificateInCRL(PCCERT_CONTEXT pCert, + PCCRL_CONTEXT pCrlContext, DWORD dwFlags, void *pvReserved, + PCRL_ENTRY *ppCrlEntry); +BOOL WINAPI CertVerifyCRLRevocation(DWORD dwCertEncodingType, + PCERT_INFO pCertId, DWORD cCrlInfo, PCRL_INFO rgpCrlInfo[]); + +BOOL WINAPI CertVerifySubjectCertificateContext(PCCERT_CONTEXT pSubject, + PCCERT_CONTEXT pIssuer, DWORD *pdwFlags); + +LONG WINAPI CertVerifyCRLTimeValidity(LPFILETIME pTimeToVerify, + PCRL_INFO pCrlInfo); LONG WINAPI CertVerifyTimeValidity(LPFILETIME pTimeToVerify, PCERT_INFO pCertInfo); @@ -2812,6 +3016,71 @@ LPCWSTR *ppszError); #define CertStrToName WINELIB_NAME_AW(CertStrToName) +BOOL WINAPI CryptSignMessage(PCRYPT_SIGN_MESSAGE_PARA pSignPara, + BOOL fDetachedSignature, DWORD cToBeSigned, const BYTE *rgpbToBeSigned[], + DWORD rgcbToBeSigned[], BYTE *pbSignedBlob, DWORD *pcbSignedBlob); +BOOL WINAPI CryptSignMessageWithKey(PCRYPT_KEY_SIGN_MESSAGE_PARA pSignPara, + const BYTE *pbToBeSigned, DWORD cbToBeSigned, BYTE *pbSignedBlob, + DWORD *pcbSignedBlob); + +BOOL WINAPI CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, + DWORD dwSignerIndex, const BYTE* pbSignedBlob, DWORD cbSignedBlob, + BYTE* pbDecoded, DWORD* pcbDecoded, PCCERT_CONTEXT* ppSignerCert); +BOOL WINAPI CryptVerifyMessageSignatureWithKey( + PCRYPT_KEY_VERIFY_MESSAGE_PARA pVerifyPara, + PCERT_PUBLIC_KEY_INFO pPublicKeyInfo, const BYTE *pbSignedBlob, + DWORD cbSignedBlob, BYTE *pbDecoded, DWORD *pcbDecoded); + +BOOL WINAPI CryptVerifyDetachedMessageSignature( + PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, + const BYTE *pbDetachedSignBlob, DWORD cbDetachedSignBlob, DWORD cToBeSigned, + const BYTE *rgpbToBeSigned[], DWORD rgcbToBeSigned[], + PCCERT_CONTEXT *ppSignerCert); +LONG WINAPI CryptGetMessageSignerCount(DWORD dwMsgEncodingType, + const BYTE *pbSignedBlob, DWORD cbSignedBlob); + +BOOL WINAPI CryptEncryptMessage(PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara, + DWORD cRecipientCert, PCCERT_CONTEXT rgpRecipientCert[], + const BYTE *pbToBeEncrypted, DWORD cbToBeEncrypted, BYTE *pbEncryptedBlob, + DWORD *pcbEncryptedBlob); +BOOL WINAPI CryptDecryptMessage(PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, + const BYTE *pbEncryptedBlob, DWORD cbEncryptedBlob, BYTE *pbDecrypted, + DWORD *pcbDecrypted, PCCERT_CONTEXT *ppXchgCert); + +BOOL WINAPI CryptSignAndEncryptMessage(PCRYPT_SIGN_MESSAGE_PARA pSignPara, + PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara, DWORD cRecipientCert, + PCCERT_CONTEXT rgpRecipientCert[], const BYTE *pbToBeSignedAndEncrypted, + DWORD cbToBeSignedAndEncrypted, BYTE *pbSignedAndEncryptedBlob, + DWORD *pcbSignedAndEncryptedBlob); +BOOL WINAPI CryptDecryptAndVerifyMessageSignature( + PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, + PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, + const BYTE *pbEncryptedBlob, DWORD cbEncryptedBlob, BYTE *pbDecrypted, + DWORD *pcbDecrypted, PCCERT_CONTEXT *ppXchgCert, PCCERT_CONTEXT *ppSignerCert); + +HCERTSTORE WINAPI CryptGetMessageCertificates(DWORD dwMsgAndCertEncodingType, + HCRYPTPROV hCryptProv, DWORD dwFlags, const BYTE *pbSignedBlob, + DWORD cbSignedBlob); + +BOOL WINAPI CryptDecodeMessage(DWORD dwMsgTypeFlags, + PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara, + PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, DWORD dwSignerIndex, + const BYTE *pbEncodedBlob, DWORD cbEncodedBlob, DWORD dwPrevInnerContentType, + DWORD *pdwMsgType, DWORD *pdwInnerContentType, BYTE *pbDecoded, + DWORD *pcbDecoded, PCCERT_CONTEXT *ppXchgCert, PCCERT_CONTEXT *ppSignerCert); + +BOOL WINAPI CryptHashMessage(PCRYPT_HASH_MESSAGE_PARA pHashPara, + BOOL fDetachedHash, DWORD cToBeHashed, const BYTE *rgpbToBeHashed[], + DWORD rgcbToBeHashed[], BYTE *pbHashedBlob, DWORD *pcbHashedBlob, + BYTE *pbComputedHash, DWORD *pcbComputedHash); +BOOL WINAPI CryptVerifyMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara, + BYTE *pbHashedBlob, DWORD cbHashedBlob, BYTE *pbToBeHashed, + DWORD *pcbToBeHashed, BYTE *pbComputedHash, DWORD *pcbComputedHash); +BOOL WINAPI CryptVerifyDetachedMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara, + BYTE *pbDetachedHashBlob, DWORD cbDetachedHashBlob, DWORD cToBeHashed, + const BYTE *rgpbToBeHashed[], DWORD rgcbToBeHashed[], BYTE *pbComputedHash, + DWORD *pcbComputedHash); + /* cryptnet.dll functions */ BOOL WINAPI CryptGetObjectUrl(LPCSTR pszUrlOid, LPVOID pvPara, DWORD dwFlags, PCRYPT_URL_ARRAY pUrlArray, DWORD *pcbUrlArray, PCRYPT_URL_INFO pUrlInfo,

1 0

[greatlrd] 22587: Copy trunk rev 22585 to new branches/powerpc
by greatlrd＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: greatlrd Date: Sun Jun 25 00:44:47 2006 New Revision: 22587 URL: http://svn.reactos.org/svn/reactos?rev=22587&view=rev Log: Copy trunk rev 22585 to new branches/powerpc Added: branches/powerpc/ - copied from r22586, trunk/

1 0

[greatlrd] 22586: arty did say it should be delete and then recreate it
by greatlrd＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: greatlrd Date: Sun Jun 25 00:42:49 2006 New Revision: 22586 URL: http://svn.reactos.org/svn/reactos?rev=22586&view=rev Log: arty did say it should be delete and then recreate it Removed: branches/powerpc/

1 0

[hpoussin] 22585: Fix MLLoadLibraryA/W prototypes
by hpoussin＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: hpoussin Date: Sun Jun 25 00:40:55 2006 New Revision: 22585 URL: http://svn.reactos.org/svn/reactos?rev=22585&view=rev Log: Fix MLLoadLibraryA/W prototypes Modified: trunk/reactos/dll/win32/shlwapi/ordinal.c trunk/reactos/dll/win32/shlwapi/url.c trunk/reactos/include/shlwapi.h Modified: trunk/reactos/dll/win32/shlwapi/ordinal.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shlwapi/ordinal.… ============================================================================== --- trunk/reactos/dll/win32/shlwapi/ordinal.c (original) +++ trunk/reactos/dll/win32/shlwapi/ordinal.c Sun Jun 25 00:40:55 2006 @@ -3419,7 +3419,7 @@ * Success: A handle to the loaded module * Failure: A NULL handle. */ -HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwFlags) +HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, BOOL bCrossCodePage) { /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for * each call here. @@ -3443,7 +3443,7 @@ LPSTR ptr; DWORD len; - FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwFlags); + FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, bCrossCodePage); len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path)); if (!len || len >= sizeof(mod_path)) return NULL; @@ -3461,13 +3461,13 @@ * * Unicode version of MLLoadLibraryA. */ -HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwFlags) +HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, BOOL bCrossCodePage) { WCHAR mod_path[2*MAX_PATH]; LPWSTR ptr; DWORD len; - FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwFlags); + FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, bCrossCodePage); len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR)); if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL; Modified: trunk/reactos/dll/win32/shlwapi/url.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shlwapi/url.c?re… ============================================================================== --- trunk/reactos/dll/win32/shlwapi/url.c (original) +++ trunk/reactos/dll/win32/shlwapi/url.c Sun Jun 25 00:40:55 2006 @@ -36,7 +36,6 @@ #include "shlwapi.h" #include "wine/debug.h" -HMODULE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,DWORD); BOOL WINAPI MLFreeLibrary(HMODULE); HRESULT WINAPI MLBuildResURLW(LPCWSTR,HMODULE,DWORD,LPCWSTR,LPWSTR,DWORD); Modified: trunk/reactos/include/shlwapi.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/shlwapi.h?rev=2258… ============================================================================== --- trunk/reactos/include/shlwapi.h (original) +++ trunk/reactos/include/shlwapi.h Sun Jun 25 00:40:55 2006 @@ -551,8 +551,8 @@ WINSHLWAPI int WINAPI wvnsprintfA(LPSTR,int,LPCSTR,va_list); WINSHLWAPI int WINAPI wvnsprintfW(LPWSTR,int,LPCWSTR,va_list); -HINSTANCE WINAPI MLLoadLibraryA(LPCSTR,HMODULE,DWORD); -HINSTANCE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,DWORD); +HINSTANCE WINAPI MLLoadLibraryA(LPCSTR,HMODULE,BOOL); +HINSTANCE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,BOOL); HRESULT WINAPI DllInstall(BOOL,LPCWSTR);

1 0

[frik85] 22584: RSDB: * add more options to the AJAX search script RosCMS: * add AJAX website content search script
by frik85＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: frik85 Date: Sun Jun 25 00:22:53 2006 New Revision: 22584 URL: http://svn.reactos.org/svn/reactos?rev=22584&view=rev Log: RSDB: * add more options to the AJAX search script RosCMS: * add AJAX website content search script Added: trunk/web/reactos.org/htdocs/roscms/search.php Modified: trunk/web/reactos.org/htdocs/support/search.js Added: trunk/web/reactos.org/htdocs/roscms/search.php URL: http://svn.reactos.org/svn/reactos/trunk/web/reactos.org/htdocs/roscms/sear… ============================================================================== --- trunk/web/reactos.org/htdocs/roscms/search.php (added) +++ trunk/web/reactos.org/htdocs/roscms/search.php Sun Jun 25 00:22:53 2006 @@ -1,0 +1,82 @@ +<?php + /* + RosCMS - Search Function + Copyright (C) 2005-2006 Klemens Friedl <frik85(a)reactos.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + + require_once("connect.db.php"); + + $RSDB_SET_search=""; // Search string + $RSDB_SET_search_lang=""; // Search language + if (array_key_exists("search", $_GET)) $RSDB_SET_search=htmlspecialchars($_GET["search"]); + if (array_key_exists("searchlang", $_GET)) $RSDB_SET_search_lang=htmlspecialchars($_GET["searchlang"]); + if ($RSDB_SET_search_lang == "en") { + $RSDB_SET_search_lang = "all"; + } + + $query_count_groups=mysql_query("SELECT COUNT(content_id) + FROM `content`, `pages` + WHERE content_active = '1' + AND + ( content_name LIKE '%" . mysql_real_escape_string($RSDB_SET_search) . "%' + OR content_text LIKE '%" . mysql_real_escape_string($RSDB_SET_search) . "%' + ) + AND content_name = page_name + AND page_active = '1' + AND content_lang = '". mysql_real_escape_string($RSDB_SET_search_lang) ."' + ORDER BY `page_name` ASC + LIMIT 0 , 20 ;"); + $result_count_groups = mysql_fetch_row($query_count_groups); + +header( 'Content-type: text/xml' ); +echo '<?xml version="1.0" encoding="UTF-8"?> +<root> +'; + + if (!$result_count_groups[0]) { + echo " #none#\n"; + } + else { + echo " ".$result_count_groups[0]."\n"; + } + +if ($RSDB_SET_search != "" || strlen($RSDB_SET_search) > 1) { + + $query_page = mysql_query("SELECT content.content_name, content.content_id, pages.page_title + FROM `content`, `pages` + WHERE content_active = '1' + AND + ( content_name LIKE '%" . mysql_real_escape_string($RSDB_SET_search) . "%' + OR content_text LIKE '%" . mysql_real_escape_string($RSDB_SET_search) . "%' + ) + AND content_name = page_name + AND page_active = '1' + AND content_lang = '". mysql_real_escape_string($RSDB_SET_search_lang) ."' + GROUP BY page_name, content_name + ORDER BY `content_id` DESC + LIMIT 0 , 15 ;"); + while($result_page = mysql_fetch_array($query_page)) { // Pages +?> + <dbentry> + <content id="<?php echo $result_page['page_title']; ?>"><?php echo $result_page['content_name']; ?></content> + </dbentry> +<? + } +} +?> +</root> Modified: trunk/web/reactos.org/htdocs/support/search.js URL: http://svn.reactos.org/svn/reactos/trunk/web/reactos.org/htdocs/support/sea… ============================================================================== --- trunk/web/reactos.org/htdocs/support/search.js (original) +++ trunk/web/reactos.org/htdocs/support/search.js Sun Jun 25 00:22:53 2006 @@ -11,8 +11,10 @@ var tWhere = ""; var tPicAnimation = ""; var tResults = ""; - var twebsite = "http://localhost/reactos.org/support/index.php"; - //var twebsite = "http://www.reactos.org/support/index.php"; + //var twebsite = "http://localhost/reactos.org/support/index.php"; + //var twebsite2 = "http://localhost/reactos.org/"; + var twebsite = "http://www.reactos.org/support/index.php"; + var twebsite2 = "http://www.reactos.org/"; function writeItemList_style_header() { @@ -58,6 +60,12 @@ return tempb; } + function write_rosweb_entry(itemname, itemid) { + var tempb = ""; + tempb += "<a href=\""+twebsite2+"?page=" + itemid + "\">• " + itemname + "</a>\n"; + return tempb; + } + function write_compsubmit_header() { var tempa = ""; @@ -137,32 +145,37 @@ if (asearch.length > 1) { document.getElementById(tResults).style.display = "block"; document.getElementById(tPicAnimation).style.display = "inline"; - if (asearch != "") { - setCursor('wait'); - if (http_request && (http_request.readyState == 2 || http_request.readyState == 3)) { - http_request.abort(); // stop running request - } - - if (tWhere == "comp") { - makeRequest(twebsite+'?page=dat&export=grplst&search='+asearch); - } - else if (tWhere == "vendor") { - //alert("vendor"); - makeRequest(twebsite+'?page=dat&export=vdrlst&search='+asearch); - } - } - } - else { + if (asearch != "") { + setCursor('wait'); + if (http_request && (http_request.readyState == 2 || http_request.readyState == 3)) { + http_request.abort(); // stop running request + } + + + if (tWhere == "comp") { + makeRequest(twebsite+'?page=dat&export=grplst&search='+asearch); + } + else if (tWhere == "vendor") { + //alert("vendor"); + makeRequest(twebsite+'?page=dat&export=vdrlst&search='+asearch); + } + else if (tWhere.substr(0, 6) == "roscms") { + //alert("vendor"); + makeRequest(twebsite2+'roscms/search.php?search='+asearch+'&searchlang='+tWhere.substr(7, 2)); + } + } + } + else { document.getElementById(tResults).style.display = "none"; document.getElementById(tPicAnimation).style.display = "none"; deleteItemList(); - } + } } function setCursor(mode) { - var pageBody = document.getElementsByTagName("body")[0]; - pageBody.style.cursor = mode; + var pageBody = document.getElementsByTagName("body")[0]; + pageBody.style.cursor = mode; } @@ -230,7 +243,10 @@ var vendo = http_request.responseXML.getElementsByTagName("vendor"); var vendurl = http_request.responseXML.getElementsByTagName("url"); } - + else if (tWhere.substr(0, 6) == "roscms") { + var webcontent = http_request.responseXML.getElementsByTagName("content"); + } + // Colors: var colorcur=""; var color1="#E2E2E2"; @@ -245,7 +261,10 @@ else if (tWhere == "vendor") { xmllength = vendo.length; } - + else if (tWhere.substr(0, 6) == "roscms") { + xmllength = webcontent.length; + } + // XML-Loop: for (var i = 0; i < xmllength; i++) { // Table colors: @@ -271,6 +290,10 @@ else if (tView == "submit_vendor") { lstData += write_vendorsubmit_entry(vendo[i].getAttributeNode("id").value, vendo[i].firstChild.data, vendurl[i].firstChild.data, colorcur); } + else if (tView == "rosweb") { + lstData += write_rosweb_entry(webcontent[i].getAttributeNode("id").value, webcontent[i].firstChild.data); + } + } // Table footer: @@ -307,6 +330,9 @@ } else if (tView == "submit_vendor") { document.getElementById(tResults).innerHTML = "Your search - " + tSearch + " - did not match any database entries.Choose a vendor from the <a href=\"javascript://\" onclick=\"SelectVendor()\">vendor list</a> or <a href=\"javascript://\" onclick=\"AddVendor()\">submit a new vendor</a> to the database."; + } + else if (tView == "rosweb") { + document.getElementById(tResults).innerHTML = "<center>no entries found</center>"; } }

1 0

[ion] 22583: - Reformat heap.c to ROS standards - HeapCreate should mask out NT flags and tag allocations with CLASS 1. - Implemented HeapCreateTagsW, HeapExtend, HeapQueryTagW, HeapSummary, HeapUsage. - Stubbed RtlUsageHeap, RtlQueryTagHeap, RtlExtendHeap, RtlCreateTagHeap.
by ion＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: ion Date: Sat Jun 24 23:49:28 2006 New Revision: 22583 URL: http://svn.reactos.org/svn/reactos?rev=22583&view=rev Log: - Reformat heap.c to ROS standards - HeapCreate should mask out NT flags and tag allocations with CLASS 1. - Implemented HeapCreateTagsW, HeapExtend, HeapQueryTagW, HeapSummary, HeapUsage. - Stubbed RtlUsageHeap, RtlQueryTagHeap, RtlExtendHeap, RtlCreateTagHeap. Modified: trunk/reactos/dll/ntdll/def/ntdll.def trunk/reactos/dll/win32/kernel32/mem/heap.c trunk/reactos/include/ndk/rtlfuncs.h trunk/reactos/include/ndk/rtltypes.h trunk/reactos/lib/rtl/heap.c Modified: trunk/reactos/dll/ntdll/def/ntdll.def URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/ntdll/def/ntdll.def?re… ============================================================================== --- trunk/reactos/dll/ntdll/def/ntdll.def (original) +++ trunk/reactos/dll/ntdll/def/ntdll.def Sat Jun 24 23:49:28 2006 @@ -361,7 +361,7 @@ RtlCreateQueryDebugBuffer@8 RtlCreateRegistryKey@8 RtlCreateSecurityDescriptor@8 -;RtlCreateTagHeap +RtlCreateTagHeap@16 RtlCreateTimer@28 RtlCreateTimerQueue@4 RtlCreateUnicodeString@8 @@ -427,7 +427,7 @@ RtlEraseUnicodeString@4 RtlExitUserThread@4 RtlExpandEnvironmentStrings_U@16 -;RtlExtendHeap +RtlExtendHeap@16 RtlExtendedIntegerMultiply@12 RtlExtendedLargeIntegerDivide@16 RtlExtendedMagicDivide@20 @@ -595,7 +595,7 @@ ;RtlQueryProcessLockInformation RtlQueryRegistryValues@20 RtlQuerySecurityObject@20 -;RtlQueryTagHeap +RtlQueryTagHeap@20 RtlQueryTimeZoneInformation@4 RtlRaiseException@4 RtlRaiseStatus@4 @@ -682,7 +682,7 @@ RtlUpdateTimer@16 RtlUpperChar@4 RtlUpperString@8 -;RtlUsageHeap +RtlUsageHeap@12 @RtlUshortByteSwap@4 RtlValidAcl@4 RtlValidRelativeSecurityDescriptor@12 Modified: trunk/reactos/dll/win32/kernel32/mem/heap.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/mem/hea… ============================================================================== --- trunk/reactos/dll/win32/kernel32/mem/heap.c (original) +++ trunk/reactos/dll/win32/kernel32/mem/heap.c Sat Jun 24 23:49:28 2006 @@ -1,256 +1,266 @@ -/* $Id$ - * - * kernel/heap.c - * Copyright (C) 1996, Onno Hovers, All rights reserved - * - * This software is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * This software 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 - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this software; see the file COPYING.LIB. If - * not, write to the Free Software Foundation, Inc., 675 Mass Ave, - * Cambridge, MA 02139, USA. - * - * Win32 heap functions (HeapXXX). - * - */ - -/* - * Adapted for the ReactOS system libraries by David Welch (welch(a)mcmail.com) - * Put the type definitions of the heap in a seperate header. Boudewijn Dekker - */ +/* + * PROJECT: ReactOS Win32 Base API + * LICENSE: GPL - See COPYING in the top level directory + * FILE: dll/win32/kernel32/mem/heap.c + * PURPOSE: Heap Memory APIs (wrappers for RtlHeap*) + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ #include <k32.h> #define NDEBUG -#include "../include/debug.h" - -/********************************************************************* -* HeapCreate -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -HANDLE STDCALL HeapCreate(DWORD flags, DWORD dwInitialSize, DWORD dwMaximumSize) -{ - HANDLE hRet; - DPRINT("HeapCreate( 0x%lX, 0x%lX, 0x%lX )\n", flags, dwInitialSize, dwMaximumSize); - - hRet = RtlCreateHeap(flags, NULL, dwMaximumSize, dwInitialSize, NULL, NULL); - - if (!hRet) - SetLastError(ERROR_NOT_ENOUGH_MEMORY); - - return hRet; -} - -/********************************************************************* -* HeapDestroy -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -BOOL WINAPI HeapDestroy(HANDLE hheap) -{ - if (hheap == RtlGetProcessHeap()) - { - return FALSE; - } - - if (RtlDestroyHeap( hheap )==NULL) return TRUE; - SetLastError( ERROR_INVALID_HANDLE ); - return FALSE; -} - -/********************************************************************* -* GetProcessHeap -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -HANDLE WINAPI GetProcessHeap(VOID) -{ - DPRINT("GetProcessHeap()\n"); - return(RtlGetProcessHeap()); -} - -/******************************************************************** -* GetProcessHeaps -- KERNEL32 * -********************************************************************/ -/* - * @implemented - */ -DWORD WINAPI GetProcessHeaps(DWORD maxheaps, PHANDLE phandles) -{ - return(RtlGetProcessHeaps(maxheaps, phandles)); -} - -/********************************************************************* -* HeapLock -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -BOOL WINAPI HeapLock(HANDLE hheap) -{ - return(RtlLockHeap(hheap)); -} - -/********************************************************************* -* HeapUnlock -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -BOOL WINAPI HeapUnlock(HANDLE hheap) -{ - return(RtlUnlockHeap(hheap)); -} - -/********************************************************************* -* HeapCompact -- KERNEL32 * -* * -* NT uses this function to compact moveable blocks and other things * -* Here it does not compact, but it finds the largest free region * -*********************************************************************/ -/* - * @implemented - */ -SIZE_T WINAPI HeapCompact(HANDLE hheap, DWORD flags) -{ - return RtlCompactHeap(hheap, flags); -} - -/********************************************************************* -* HeapValidate -- KERNEL32 * -*********************************************************************/ -/* - * @implemented - */ -BOOL WINAPI HeapValidate(HANDLE hheap, DWORD flags, LPCVOID pmem) -{ - return(RtlValidateHeap(hheap, flags, (PVOID)pmem)); -} - +#include "debug.h" + +/* FUNCTIONS ***************************************************************/ + +/* + * @implemented + */ +HANDLE +WINAPI +HeapCreate(DWORD flOptions, + DWORD dwInitialSize, + DWORD dwMaximumSize) +{ + HANDLE hRet; + ULONG Flags; + + /* Remove non-Win32 flags and tag this allocation */ + Flags = (flOptions & (HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE)) | + HEAP_CLASS_1; + + /* Call RTL Heap */ + hRet = RtlCreateHeap(Flags, + NULL, + dwMaximumSize, + dwInitialSize, + NULL, + NULL); + + /* Set the last error if we failed, and return the pointer */ + if (!hRet) SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return hRet; +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapDestroy(HANDLE hHeap) +{ + /* Return TRUE if the heap was destroyed */ + if (!RtlDestroyHeap(hHeap)) return TRUE; + + /* Otherwise, we got the handle back, so fail */ + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; +} + +/* + * @implemented + */ +HANDLE +WINAPI +GetProcessHeap(VOID) +{ + /* Call the RTL API */ + return RtlGetProcessHeap(); +} + +/* + * @implemented + */ +DWORD +WINAPI +GetProcessHeaps(DWORD NumberOfHeaps, + PHANDLE ProcessHeaps) +{ + /* Call the RTL API */ + return RtlGetProcessHeaps(NumberOfHeaps, ProcessHeaps); +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapLock(HANDLE hHeap) +{ + /* Call the RTL API */ + return RtlLockHeap(hHeap); +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapUnlock(HANDLE hHeap) +{ + /* Call the RTL API */ + return RtlUnlockHeap(hHeap); +} + +/* + * @implemented + */ +SIZE_T +WINAPI +HeapCompact(HANDLE hHeap, DWORD dwFlags) +{ + /* Call the RTL API */ + return RtlCompactHeap(hHeap, dwFlags); +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapValidate(HANDLE hHeap, + DWORD dwFlags, + LPCVOID lpMem) +{ + /* Call the RTL API */ + return RtlValidateHeap(hHeap, dwFlags, (PVOID)lpMem); +} + +/* + * @implemented + */ +DWORD +WINAPI +HeapCreateTagsW(HANDLE hHeap, + DWORD dwFlags, + PWSTR lpTagName, + PWSTR lpTagSubName) +{ + /* Call the RTL API */ + return RtlCreateTagHeap(hHeap, + dwFlags, + lpTagName, + lpTagSubName); +} + +/* + * @implemented + */ +DWORD +WINAPI +HeapExtend(HANDLE hHeap, + DWORD dwFlags, + PVOID BaseAddress, + DWORD dwBytes) +{ + NTSTATUS Status; + + /* Call the RTL API */ + Status = RtlExtendHeap(hHeap, dwFlags, BaseAddress, dwBytes); + if (!NT_SUCCESS(Status)) + { + /* We failed */ + SetLastErrorByStatus(Status); + return FALSE; + } + + /* Return success */ + return TRUE; +} + +/* + * @implemented + */ +PWSTR +WINAPI +HeapQueryTagW(HANDLE hHeap, + DWORD dwFlags, + WORD wTagIndex, + BOOL bResetCounters, + PVOID lpTagInfo) +{ + /* Call the RTL API */ + return RtlQueryTagHeap(hHeap, + dwFlags, + wTagIndex, + bResetCounters, + lpTagInfo); +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapSummary(HANDLE hHeap, + DWORD dwFlags, + PVOID Summary) +{ + NTSTATUS Status; + RTL_HEAP_USAGE Usage; + + /* Fill in the length information */ + Usage.Length = sizeof(Usage); + + /* Call RTL */ + Status = RtlUsageHeap(hHeap, dwFlags, &Usage); + if (!NT_SUCCESS(Status)) + { + /* We failed */ + SetLastErrorByStatus(Status); + return FALSE; + } + + /* FIXME: Summary == Usage?! */ + RtlCopyMemory(Summary, &Usage, sizeof(Usage)); + return TRUE; +} + +/* + * @implemented + */ +BOOL +WINAPI +HeapUsage(HANDLE hHeap, + DWORD dwFlags, + DWORD Unknown, + DWORD Unknown2, + IN PVOID Usage) +{ + NTSTATUS Status; + + /* Call RTL */ + Status = RtlUsageHeap(hHeap, dwFlags, Usage); + if (!NT_SUCCESS(Status)) + { + /* We failed */ + SetLastErrorByStatus(Status); + return FALSE; + } + else if (Status == STATUS_MORE_ENTRIES) + { + /* There are still more entries to parse */ + return TRUE; + } + + /* Otherwise, we're completely done, so we return FALSE, but NO_ERROR */ + SetLastError(NO_ERROR); + return FALSE; +} /* * @unimplemented */ -DWORD +BOOL STDCALL -HeapCreateTagsW ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2, - DWORD Unknown3 - ) -{ - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - - -/* - * @unimplemented - */ -DWORD -STDCALL -HeapExtend ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2, - DWORD Unknown3 - ) -{ -#if 0 - NTSTATUS Status; - - Status = RtlExtendHeap(Unknown1, Unknown2, Unknown3, Unknown4); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - return TRUE; -#endif - - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - - -/* - * @unimplemented - */ -DWORD -STDCALL -HeapQueryTagW ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2, - DWORD Unknown3, - DWORD Unknown4 - ) -{ - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - - -/* - * @unimplemented - */ -DWORD -STDCALL -HeapSummary ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2 - ) -{ - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - - -/* - * @unimplemented - */ -DWORD -STDCALL -HeapUsage ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2, - DWORD Unknown3, - DWORD Unknown4 - ) -{ - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; -} - - -/* - * @unimplemented - */ -BOOL -STDCALL -HeapWalk ( - HANDLE hHeap, - LPPROCESS_HEAP_ENTRY lpEntry - ) -{ - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; -} - +HeapWalk(HANDLE hHeap, + LPPROCESS_HEAP_ENTRY lpEntry) +{ + /* Not implemented */ + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} /* EOF */ Modified: trunk/reactos/include/ndk/rtlfuncs.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/rtlfuncs.h?rev… ============================================================================== --- trunk/reactos/include/ndk/rtlfuncs.h (original) +++ trunk/reactos/include/ndk/rtlfuncs.h Sat Jun 24 23:49:28 2006 @@ -452,8 +452,8 @@ ULONG NTAPI RtlCompactHeap( - HANDLE heap, - ULONG flags + HANDLE Heap, + ULONG Flags ); NTSYSAPI @@ -471,7 +471,26 @@ NTSYSAPI HANDLE NTAPI -RtlDestroyHeap(HANDLE hheap); +RtlDestroyHeap( + IN HANDLE Heap +); + +NTSYSAPI +HANDLE +NTAPI +RtlDestroyHeap( + IN HANDLE Heap +); + +NTSYSAPI +ULONG +NTAPI +RtlExtendHeap( + IN HANDLE Heap, + IN ULONG Flags, + IN PVOID P, + IN ULONG Size +); NTSYSAPI BOOLEAN @@ -507,6 +526,17 @@ ); NTSYSAPI +PWSTR +NTAPI +RtlQueryTagHeap( + IN PVOID HeapHandle, + IN ULONG Flags, + IN USHORT TagIndex, + IN BOOLEAN ResetCounters, + OUT PRTL_HEAP_TAG_INFO HeapTagInfo +); + +NTSYSAPI PVOID NTAPI RtlReAllocateHeap( @@ -519,12 +549,25 @@ NTSYSAPI BOOLEAN NTAPI -RtlLockHeap(IN HANDLE Heap); - -NTSYSAPI -BOOLEAN -NTAPI -RtlUnlockHeap(IN HANDLE Heap); +RtlLockHeap( + IN HANDLE Heap +); + +NTSYSAPI +NTSTATUS +NTAPI +RtlUsageHeap( + IN HANDLE Heap, + IN ULONG Flags, + OUT PRTL_HEAP_USAGE Usage +); + +NTSYSAPI +BOOLEAN +NTAPI +RtlUnlockHeap( + IN HANDLE Heap +); BOOLEAN NTAPI @@ -550,7 +593,7 @@ RtlValidateHeap( HANDLE Heap, ULONG Flags, - PVOID pmem + PVOID P ); #define RtlGetProcessHeap() (NtCurrentPeb()->ProcessHeap) Modified: trunk/reactos/include/ndk/rtltypes.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ndk/rtltypes.h?rev… ============================================================================== --- trunk/reactos/include/ndk/rtltypes.h (original) +++ trunk/reactos/include/ndk/rtltypes.h Sat Jun 24 23:49:28 2006 @@ -779,6 +779,31 @@ ULONG TimeDateStamp; PVOID DefaultBase; } RTL_PROCESS_MODULE_INFORMATION_EX, *PRTL_PROCESS_MODULE_INFORMATION_EX; + +typedef struct _RTL_HEAP_TAG_INFO +{ + ULONG NumberOfAllocations; + ULONG NumberOfFrees; + ULONG BytesAllocated; +} RTL_HEAP_TAG_INFO, *PRTL_HEAP_TAG_INFO; + +typedef struct _RTL_HEAP_USAGE_ENTRY +{ + struct _RTL_HEAP_USAGE_ENTRY *Next; +} RTL_HEAP_USAGE_ENTRY, *PRTL_HEAP_USAGE_ENTRY; + +typedef struct _RTL_HEAP_USAGE +{ + ULONG Length; + ULONG BytesAllocated; + ULONG BytesCommitted; + ULONG BytesReserved; + ULONG BytesReservedMaximum; + PRTL_HEAP_USAGE_ENTRY Entries; + PRTL_HEAP_USAGE_ENTRY AddedEntries; + PRTL_HEAP_USAGE_ENTRY RemovedEntries; + UCHAR Reserved[32]; +} RTL_HEAP_USAGE, *PRTL_HEAP_USAGE; typedef struct _RTL_HEAP_INFORMATION { Modified: trunk/reactos/lib/rtl/heap.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/heap.c?rev=22583&r… ============================================================================== --- trunk/reactos/lib/rtl/heap.c (original) +++ trunk/reactos/lib/rtl/heap.c Sat Jun 24 23:49:28 2006 @@ -1897,4 +1897,55 @@ return TRUE; } +/* + * @unimplemented + */ +NTSTATUS +NTAPI +RtlUsageHeap(IN HANDLE Heap, + IN ULONG Flags, + OUT PRTL_HEAP_USAGE Usage) +{ + /* TODO */ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +PWSTR +NTAPI +RtlQueryTagHeap(IN PVOID HeapHandle, + IN ULONG Flags, + IN USHORT TagIndex, + IN BOOLEAN ResetCounters, + OUT PRTL_HEAP_TAG_INFO HeapTagInfo) +{ + /* TODO */ + UNIMPLEMENTED; + return NULL; +} + +ULONG +NTAPI +RtlExtendHeap(IN HANDLE Heap, + IN ULONG Flags, + IN PVOID P, + IN ULONG Size) +{ + /* TODO */ + UNIMPLEMENTED; + return 0; +} + +ULONG +NTAPI +RtlCreateTagHeap(IN HANDLE HeapHandle, + IN ULONG Flags, + IN PWSTR TagName, + IN PWSTR TagSubName) +{ + /* TODO */ + UNIMPLEMENTED; + return 0; +} + /* EOF */

1 0

[ion] 22582: - Fixup Local* Heap implementation so that calls which have different semantics don't call the Global APIs (ie: LocalAlloc/LocalReAlloc and LocalFlags). The rest can be shared beteween them. Also fix some prototypes. - Rename all the defintions to BASE_HEAP instead of GLOBAL_HEAP, since they apply just as well to the Local Heap.
by ion＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: ion Date: Sat Jun 24 23:00:07 2006 New Revision: 22582 URL: http://svn.reactos.org/svn/reactos?rev=22582&view=rev Log: - Fixup Local* Heap implementation so that calls which have different semantics don't call the Global APIs (ie: LocalAlloc/LocalReAlloc and LocalFlags). The rest can be shared beteween them. Also fix some prototypes. - Rename all the defintions to BASE_HEAP instead of GLOBAL_HEAP, since they apply just as well to the Local Heap. Modified: trunk/reactos/dll/win32/kernel32/include/baseheap.h trunk/reactos/dll/win32/kernel32/mem/global.c trunk/reactos/dll/win32/kernel32/mem/local.c trunk/reactos/dll/win32/kernel32/misc/dllmain.c trunk/reactos/include/winbase.h Modified: trunk/reactos/dll/win32/kernel32/include/baseheap.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/include… ============================================================================== --- trunk/reactos/dll/win32/kernel32/include/baseheap.h (original) +++ trunk/reactos/dll/win32/kernel32/include/baseheap.h Sat Jun 24 23:00:07 2006 @@ -36,7 +36,7 @@ // // The Handle Table // -extern RTL_HANDLE_TABLE BaseGlobalHandleTable; +extern RTL_HANDLE_TABLE BaseHeapHandleTable; // // Tracing Support @@ -62,13 +62,15 @@ #define BASE_TRACE_DEALLOC(x) \ BH_PRINT("[BASE_HEAP] %s : Freeing %p\n", \ __FUNCTION__, x) - +#define BASE_TRACE_FAILURE() \ + BH_PRINT("[BASE_HEAP] %s : Failing %d\n", \ + __FUNCTION__, __LINE__) // // The handle structure for global heap handles. // Notice that it nicely overlays with RTL_HANDLE_ENTRY. // KEEP IT THAT WAY! ;-) // -typedef struct _GLOBAL_HEAP_HANDLE_ENTRY +typedef struct _BASE_HEAP_HANDLE_ENTRY { USHORT Flags; USHORT LockCount; @@ -77,45 +79,45 @@ PVOID Object; ULONG OldSize; }; -} GLOBAL_HEAP_HANDLE_ENTRY, *PGLOBAL_HEAP_HANDLE_ENTRY; +} BASE_HEAP_HANDLE_ENTRY, *PBASE_HEAP_HANDLE_ENTRY; // // Handle entry flags // Note that 0x0001 is the shared/generic RTL_HANDLE_VALID // -#define GLOBAL_HEAP_ENTRY_FLAG_MOVABLE 0x0002 -#define GLOBAL_HEAP_ENTRY_FLAG_REUSABLE 0x0004 -#define GLOBAL_HEAP_ENTRY_FLAG_REUSE 0x0008 -#define GLOBAL_HEAP_ENTRY_FLAG_DDESHARE 0x0010 +#define BASE_HEAP_ENTRY_FLAG_MOVABLE 0x0002 +#define BASE_HEAP_ENTRY_FLAG_REUSABLE 0x0004 +#define BASE_HEAP_ENTRY_FLAG_REUSE 0x0008 +#define BASE_HEAP_ENTRY_FLAG_DDESHARE 0x0010 // // Easy way to check if the global handle is actually an entry in our table // -#define GLOBAL_HEAP_IS_HANDLE_ENTRY \ - (ULONG_PTR)FIELD_OFFSET(GLOBAL_HEAP_HANDLE_ENTRY, Object) +#define BASE_HEAP_IS_HANDLE_ENTRY \ + (ULONG_PTR)FIELD_OFFSET(BASE_HEAP_HANDLE_ENTRY, Object) // // Tags for the entire heap allocation for this global memory. // They are set part of the User Flags of the RTL Heap. // -#define GLOBAL_HEAP_FLAG_MOVABLE HEAP_SETTABLE_USER_FLAG1 -#define GLOBAL_HEAP_FLAG_DDESHARE HEAP_SETTABLE_USER_FLAG2 +#define BASE_HEAP_FLAG_MOVABLE HEAP_SETTABLE_USER_FLAG1 +#define BASE_HEAP_FLAG_DDESHARE HEAP_SETTABLE_USER_FLAG2 // // Internal Handle Functions // -#define GlobalAllocEntry() \ - (PGLOBAL_HEAP_HANDLE_ENTRY)RtlAllocateHandle(&BaseGlobalHandleTable, NULL) +#define BaseHeapAllocEntry() \ + (PBASE_HEAP_HANDLE_ENTRY)RtlAllocateHandle(&BaseHeapHandleTable, NULL) -#define GlobalGetEntry(h) \ - (PGLOBAL_HEAP_HANDLE_ENTRY) \ +#define BaseHeapGetEntry(h) \ + (PBASE_HEAP_HANDLE_ENTRY) \ CONTAINING_RECORD(h, \ - GLOBAL_HEAP_HANDLE_ENTRY, \ + BASE_HEAP_HANDLE_ENTRY, \ Object); -#define GlobalValidateEntry(he) \ - RtlIsValidHandle(&BaseGlobalHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he) +#define BaseHeapValidateEntry(he) \ + RtlIsValidHandle(&BaseHeapHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he) -#define GlobalFreeEntry(he) \ - RtlFreeHandle(&BaseGlobalHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he); +#define BaseHeapFreeEntry(he) \ + RtlFreeHandle(&BaseHeapHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he); Modified: trunk/reactos/dll/win32/kernel32/mem/global.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/mem/glo… ============================================================================== --- trunk/reactos/dll/win32/kernel32/mem/global.c (original) +++ trunk/reactos/dll/win32/kernel32/mem/global.c Sat Jun 24 23:00:07 2006 @@ -13,14 +13,10 @@ #define NDEBUG #include "debug.h" -#define BASE_TRACE_FAILURE() \ - DbgPrint("[BASE_HEAP] %s : Failing %d\n", \ - __FUNCTION__, __LINE__) - /* TYPES *********************************************************************/ extern SYSTEM_BASIC_INFORMATION BaseCachedSysInfo; -RTL_HANDLE_TABLE BaseGlobalHandleTable; +RTL_HANDLE_TABLE BaseHeapHandleTable; /* FUNCTIONS ***************************************************************/ @@ -35,7 +31,7 @@ ULONG Flags = 0; PVOID Ptr = NULL; HANDLE hMemory; - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; BASE_TRACE_ALLOC(dwBytes, uFlags); ASSERT(hProcessHeap); @@ -55,7 +51,7 @@ if (!(uFlags & GMEM_MOVEABLE)) { /* Check if this is DDESHARE (deprecated) */ - if (uFlags & GMEM_DDESHARE) Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + if (uFlags & GMEM_DDESHARE) Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE; /* Allocate heap for it */ Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); @@ -72,10 +68,10 @@ */ Flags |= HEAP_NO_SERIALIZE | HEAP_SETTABLE_USER_VALUE | - GLOBAL_HEAP_FLAG_MOVABLE; + BASE_HEAP_FLAG_MOVABLE; /* Allocate the handle */ - HandleEntry = GlobalAllocEntry(); + HandleEntry = BaseHeapAllocEntry(); if (!HandleEntry) { /* Fail */ @@ -96,7 +92,7 @@ { /* We failed, manually set the allocate flag and free the handle */ HandleEntry->Flags = RTL_HANDLE_VALID; - GlobalFreeEntry(HandleEntry); + BaseHeapFreeEntry(HandleEntry); /* For the cleanup case */ HandleEntry = NULL; @@ -121,28 +117,28 @@ if (!Ptr) { /* We don't have a valid pointer, but so reuse this handle */ - HandleEntry->Flags = GLOBAL_HEAP_ENTRY_FLAG_REUSE; + HandleEntry->Flags = BASE_HEAP_ENTRY_FLAG_REUSE; } /* Check if the handle is discardable */ if (uFlags & GMEM_DISCARDABLE) { /* Save it in the handle entry */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE; } /* Check if the handle is moveable */ if (uFlags & GMEM_MOVEABLE) { /* Save it in the handle entry */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_MOVABLE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_MOVABLE; } /* Check if the handle is DDE Shared */ if (uFlags & GMEM_DDESHARE) { /* Save it in the handle entry */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE; } /* Set the pointer */ @@ -182,7 +178,7 @@ NTAPI GlobalFlags(HGLOBAL hMem) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; HANDLE Handle = NULL; ULONG Flags = 0; UINT uFlags = GMEM_INVALID_HANDLE; @@ -191,7 +187,7 @@ RtlLockHeap(hProcessHeap); /* Check if this is a simple RTL Heap Managed block */ - if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) { /* Then we'll query RTL Heap */ RtlGetUserInfoHeap(hProcessHeap, Flags, hMem, &Handle, &Flags); @@ -202,7 +198,7 @@ * said that this heap isn't movable, which means something we're * really not a handle-based heap. */ - if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE)) { /* Then set the flags to 0 */ uFlags = 0; @@ -215,34 +211,34 @@ } /* Check if the handle is actually an entry in our table */ - if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY) { /* Then get the entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure it's a valid handle */ - if (GlobalValidateEntry(HandleEntry)) + if (BaseHeapValidateEntry(HandleEntry)) { /* Get the lock count first */ uFlags = HandleEntry->LockCount & GMEM_LOCKCOUNT; /* Now check if it's discarded */ - if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_REUSABLE) + if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSABLE) { /* Set the Win32 Flag */ uFlags |= GMEM_DISCARDED; } /* Check if it's movable */ - if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_MOVABLE) + if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_MOVABLE) { /* Set the Win32 Flag */ uFlags |= GMEM_MOVEABLE; } /* Check if it's DDE Shared */ - if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_DDESHARE) + if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_DDESHARE) { /* Set the Win32 Flag */ uFlags |= GMEM_DDESHARE; @@ -265,12 +261,12 @@ NTAPI GlobalFree(HGLOBAL hMem) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; LPVOID Ptr; BASE_TRACE_DEALLOC(hMem); /* Check if this was a simple allocated heap entry */ - if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) { /* Free it with the RTL Heap Manager */ if (RtlFreeHeap(hProcessHeap, 0, hMem)) @@ -291,14 +287,14 @@ RtlLockHeap(hProcessHeap); /* Make sure that this is an entry in our handle database */ - if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY) { /* Get the entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure the handle is valid */ - if (!GlobalValidateEntry(HandleEntry)) + if (!BaseHeapValidateEntry(HandleEntry)) { /* It's not, fail */ SetLastError(ERROR_INVALID_HANDLE); @@ -310,7 +306,7 @@ Ptr = HandleEntry->Object; /* Free this handle */ - GlobalFreeEntry(HandleEntry); + BaseHeapFreeEntry(HandleEntry); /* If the pointer is 0, then we don't have a handle either */ if (!Ptr) hMem = NULL; @@ -361,7 +357,7 @@ * Check if RTL Heap didn't find a handle for us or said that * this heap isn't movable. */ - if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE)) { /* We're actually handle-based, so the pointer is a handle */ Handle = (HANDLE)pMem; @@ -379,11 +375,11 @@ NTAPI GlobalLock(HGLOBAL hMem) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; LPVOID Ptr; /* Check if this was a simple allocated heap entry */ - if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) { /* Then simply return the pointer */ return hMem; @@ -393,11 +389,11 @@ RtlLockHeap(hProcessHeap); /* Get the handle entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure it's valid */ - if (!GlobalValidateEntry(HandleEntry)) + if (!BaseHeapValidateEntry(HandleEntry)) { /* It's not, fail */ BASE_TRACE_FAILURE(); @@ -435,7 +431,7 @@ DWORD dwBytes, UINT uFlags) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; HANDLE Handle; LPVOID Ptr; ULONG Flags = 0; @@ -449,17 +445,16 @@ /* Lock the heap and disable built-in locking in the RTL Heap funcitons */ RtlLockHeap(hProcessHeap); Flags |= HEAP_NO_SERIALIZE; - DPRINT1("hmem: %p Flags: %lx\n", hMem, uFlags); /* Check if this is a simple handle-based block */ - if (((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + if (((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) { /* Get the entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure the handle is valid */ - if (!GlobalValidateEntry(HandleEntry)) + if (!BaseHeapValidateEntry(HandleEntry)) { /* Fail */ BASE_TRACE_FAILURE(); @@ -472,12 +467,12 @@ if (uFlags & GMEM_DISCARDABLE) { /* Then set the flag */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE; } else { /* Otherwise, remove the flag */ - HandleEntry->Flags &= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + HandleEntry->Flags &= BASE_HEAP_ENTRY_FLAG_REUSABLE; } } else @@ -498,7 +493,7 @@ /* Free the handle */ HandleEntry->Object = NULL; - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE; /* Get the object pointer */ hMem = &HandleEntry->Object; @@ -513,7 +508,7 @@ else { /* Otherwise, we're allocating, so set the new flags needed */ - Flags |= HEAP_SETTABLE_USER_VALUE | GLOBAL_HEAP_FLAG_MOVABLE; + Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE; if (!Ptr) { /* We don't have a base, so allocate one */ @@ -554,7 +549,7 @@ { /* Write it in the handle entry and mark it in use */ HandleEntry->Object = Ptr; - HandleEntry->Flags &= ~GLOBAL_HEAP_ENTRY_FLAG_REUSE; + HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSE; } else { @@ -584,16 +579,16 @@ * Check if the handle matches the pointer or if the moveable flag * isn't there, which is what we expect since it currenly isn't. */ - if (Handle == hMem || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + if (Handle == hMem || !(Flags & BASE_HEAP_FLAG_MOVABLE)) { /* Allocate a handle for it */ - HandleEntry = GlobalAllocEntry(); + HandleEntry = BaseHeapAllocEntry(); /* Calculate the size of the current heap */ dwBytes = RtlSizeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem); /* Set the movable flag */ - Flags |= HEAP_SETTABLE_USER_VALUE | GLOBAL_HEAP_FLAG_MOVABLE; + Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE; /* Now allocate the actual heap for it */ HandleEntry->Object = RtlAllocateHeap(hProcessHeap, @@ -607,7 +602,7 @@ * free the handle */ HandleEntry->Flags = RTL_HANDLE_VALID; - GlobalFreeEntry(HandleEntry); + BaseHeapFreeEntry(HandleEntry); /* For the cleanup case */ BASE_TRACE_FAILURE(); @@ -626,20 +621,20 @@ /* Initialize the count and default flags */ HandleEntry->LockCount = 0; HandleEntry->Flags = RTL_HANDLE_VALID | - GLOBAL_HEAP_ENTRY_FLAG_MOVABLE; + BASE_HEAP_ENTRY_FLAG_MOVABLE; /* Check if it's also discardable */ if (uFlags & GMEM_DISCARDABLE) { /* Set the internal flag */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE; } /* Check if it's also DDE Shared */ if (uFlags & GMEM_DDESHARE) { /* Set the internal flag */ - HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE; } /* Allocation succeeded, so save our entry */ @@ -678,7 +673,7 @@ NTAPI GlobalSize(HGLOBAL hMem) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; PVOID Handle = NULL; ULONG Flags = 0; SIZE_T dwSize = MAXULONG_PTR; @@ -687,7 +682,7 @@ RtlLockHeap(hProcessHeap); /* Check if this is a simple RTL Heap Managed block */ - if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) { /* Then we'll query RTL Heap */ RtlGetUserInfoHeap(hProcessHeap, Flags, hMem, &Handle, &Flags); @@ -697,7 +692,7 @@ * Check if RTL Heap didn't give us a handle or said that this heap * isn't movable. */ - if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE)) { /* This implies we're not a handle heap, so use the generic call */ dwSize = RtlSizeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem); @@ -710,20 +705,20 @@ } /* Make sure that this is an entry in our handle database */ - if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY) { /* Get the entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure the handle is valid */ - if (!GlobalValidateEntry(HandleEntry)) + if (!BaseHeapValidateEntry(HandleEntry)) { /* Fail */ BASE_TRACE_FAILURE(); SetLastError(ERROR_INVALID_HANDLE); } - else if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_REUSE) + else if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSE) { /* We've reused this block, but we've saved the size for you */ dwSize = HandleEntry->OldSize; @@ -769,21 +764,21 @@ NTAPI GlobalUnlock(HGLOBAL hMem) { - PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; BOOL RetVal = TRUE; /* Check if this was a simple allocated heap entry */ - if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) return RetVal; + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) return RetVal; /* Otherwise, lock the heap */ RtlLockHeap(hProcessHeap); /* Get the handle entry */ - HandleEntry = GlobalGetEntry(hMem); + HandleEntry = BaseHeapGetEntry(hMem); BASE_TRACE_HANDLE(HandleEntry, hMem); /* Make sure it's valid */ - if (!GlobalValidateEntry(HandleEntry)) + if (!BaseHeapValidateEntry(HandleEntry)) { /* It's not, fail */ BASE_TRACE_FAILURE(); Modified: trunk/reactos/dll/win32/kernel32/mem/local.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/mem/loc… ============================================================================== --- trunk/reactos/dll/win32/kernel32/mem/local.c (original) +++ trunk/reactos/dll/win32/kernel32/mem/local.c Sat Jun 24 23:00:07 2006 @@ -1,134 +1,450 @@ -/* $Id$ - * - * COPYRIGHT: See COPYING in the top level directory - * Copyright (C) 1996, Onno Hovers, All rights reserved - * PROJECT: ReactOS system libraries - * FILE: lib/kernel32/mem/local.c - * PURPOSE: Manages the local heap - * PROGRAMER: Onno Hovers (original wfc version) - * David Welch (adapted for ReactOS) - * UPDATE HISTORY: - * 9/4/98: Adapted from the wfc project - */ - - -/* NOTES - * - * The local heap is the same as the global heap for win32 and both are only - * required for legacy apps - * - */ - -/* INCLUDES ****************************************************************/ +/* + * PROJECT: ReactOS Win32 Base API + * LICENSE: GPL - See COPYING in the top level directory + * FILE: dll/win32/kernel32/mem/local.c + * PURPOSE: Local Memory APIs (sits on top of Heap*) + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ #include <k32.h> #define NDEBUG -#include "../include/debug.h" +#include "debug.h" + +/* TYPES *********************************************************************/ + +extern SYSTEM_BASIC_INFORMATION BaseCachedSysInfo; /* FUNCTIONS ***************************************************************/ - -/* - * @implemented - */ -HLOCAL STDCALL +/* + * @implemented + */ +HLOCAL +NTAPI LocalAlloc(UINT uFlags, - SIZE_T uBytes) -{ - return (HLOCAL)GlobalAlloc(uFlags, uBytes); -} - - -/* - * @implemented - */ -SIZE_T STDCALL -LocalCompact(UINT uMinFree) -{ - return RtlCompactHeap(hProcessHeap, 0); -} - - -/* - * @implemented - */ -UINT STDCALL + SIZE_T dwBytes) +{ + ULONG Flags = 0; + PVOID Ptr = NULL; + HANDLE hMemory; + PBASE_HEAP_HANDLE_ENTRY HandleEntry; + BASE_TRACE_ALLOC(dwBytes, uFlags); + ASSERT(hProcessHeap); + + /* Make sure the flags are valid */ + if (uFlags & ~LMEM_VALID_FLAGS) + { + /* They aren't, fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } + + /* Convert ZEROINIT */ + if (uFlags & LMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY; + + /* Check if we're not movable, which means pointer-based heap */ + if (!(uFlags & LMEM_MOVEABLE)) + { + /* Allocate heap for it */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_ALLOC2(Ptr); + return Ptr; + } + + /* This is heap based, so lock it in first */ + RtlLockHeap(hProcessHeap); + + /* + * Disable locking, enable custom flags, and write the + * movable flag (deprecated) + */ + Flags |= HEAP_NO_SERIALIZE | + HEAP_SETTABLE_USER_VALUE | + BASE_HEAP_FLAG_MOVABLE; + + /* Allocate the handle */ + HandleEntry = BaseHeapAllocEntry(); + if (!HandleEntry) + { + /* Fail */ + hMemory = NULL; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + BASE_TRACE_FAILURE(); + goto Quickie; + } + + /* Get the object and make sure we have size */ + hMemory = &HandleEntry->Object; + if (dwBytes) + { + /* Allocate the actual memory for it */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_PTR(HandleEntry, Ptr); + if (!Ptr) + { + /* We failed, manually set the allocate flag and free the handle */ + HandleEntry->Flags = RTL_HANDLE_VALID; + BaseHeapFreeEntry(HandleEntry); + + /* For the cleanup case */ + HandleEntry = NULL; + } + else + { + /* All worked well, save our heap entry */ + RtlSetUserValueHeap(hProcessHeap, HEAP_NO_SERIALIZE, Ptr, hMemory); + } + } + +Quickie: + /* Cleanup! First unlock the heap */ + RtlUnlockHeap(hProcessHeap); + + /* Check if a handle was allocated */ + if (HandleEntry) + { + /* Set the pointer and allocated flag */ + HandleEntry->Object = Ptr; + HandleEntry->Flags = RTL_HANDLE_VALID; + if (!Ptr) + { + /* We don't have a valid pointer, but so reuse this handle */ + HandleEntry->Flags = BASE_HEAP_ENTRY_FLAG_REUSE; + } + + /* Check if the handle is discardable */ + if (uFlags & GMEM_DISCARDABLE) + { + /* Save it in the handle entry */ + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE; + } + + /* Check if the handle is moveable */ + if (uFlags & GMEM_MOVEABLE) + { + /* Save it in the handle entry */ + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_MOVABLE; + } + + /* Set the pointer */ + Ptr = hMemory; + } + + /* Return the pointer */ + return Ptr; +} + +/* + * @implemented + */ +SIZE_T +NTAPI +LocalCompact(UINT dwMinFree) +{ + /* Call the RTL Heap Manager */ + return RtlCompactHeap(hProcessHeap, 0); +} + +/* + * @implemented + */ +UINT +NTAPI LocalFlags(HLOCAL hMem) { - return GlobalFlags((HGLOBAL)hMem); -} - - -/* - * @implemented - */ -HLOCAL STDCALL + PBASE_HEAP_HANDLE_ENTRY HandleEntry; + HANDLE Handle = NULL; + ULONG Flags = 0; + UINT uFlags = LMEM_INVALID_HANDLE; + + /* Start by locking the heap */ + RtlLockHeap(hProcessHeap); + + /* Check if this is a simple RTL Heap Managed block */ + if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) + { + /* Then we'll query RTL Heap */ + RtlGetUserInfoHeap(hProcessHeap, Flags, hMem, &Handle, &Flags); + BASE_TRACE_PTR(Handle, hMem); + + /* + * Check if RTL Heap didn't find a handle associated with us or + * said that this heap isn't movable, which means something we're + * really not a handle-based heap. + */ + if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE)) + { + /* Then set the flags to 0 */ + uFlags = 0; + } + else + { + /* Otherwise we're handle-based, so get the internal handle */ + hMem = Handle; + } + } + + /* Check if the handle is actually an entry in our table */ + if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY) + { + /* Then get the entry */ + HandleEntry = BaseHeapGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure it's a valid handle */ + if (BaseHeapValidateEntry(HandleEntry)) + { + /* Get the lock count first */ + uFlags = HandleEntry->LockCount & LMEM_LOCKCOUNT; + + /* Now check if it's discarded */ + if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSABLE) + { + /* Set the Win32 Flag */ + uFlags |= LMEM_DISCARDED; + } + + /* Check if it's movable */ + if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_MOVABLE) + { + /* Set the Win32 Flag */ + uFlags |= LMEM_DISCARDABLE; + } + } + } + + /* Check if by now, we still haven't gotten any useful flags */ + if (uFlags == LMEM_INVALID_HANDLE) SetLastError(ERROR_INVALID_HANDLE); + + /* All done! Unlock heap and return Win32 Flags */ + RtlUnlockHeap(hProcessHeap); + return uFlags; +} + +/* + * @implemented + */ +HLOCAL +NTAPI LocalFree(HLOCAL hMem) { - return (HLOCAL)GlobalFree((HGLOBAL)hMem); -} - - -/* - * @implemented - */ -HLOCAL STDCALL + /* This is identical to a Global Free */ + return GlobalFree(hMem); +} + +/* + * @implemented + */ +HLOCAL +NTAPI LocalHandle(LPCVOID pMem) { - return (HLOCAL)GlobalHandle(pMem); -} - - -/* - * @implemented - */ -LPVOID STDCALL + /* This is identical to a Global Handle */ + return GlobalHandle(pMem); +} + +/* + * @implemented + */ +LPVOID +NTAPI LocalLock(HLOCAL hMem) { - return GlobalLock((HGLOBAL)hMem); -} - - -/* - * @implemented - */ -HLOCAL STDCALL + /* This is the same as a GlobalLock, assuming these never change */ + ASSERT(LMEM_LOCKCOUNT == GMEM_LOCKCOUNT); + return GlobalLock(hMem); +} + +HLOCAL +NTAPI LocalReAlloc(HLOCAL hMem, - SIZE_T uBytes, - UINT uFlags) -{ - return (HLOCAL)GlobalReAlloc((HGLOBAL)hMem, uBytes, uFlags); -} - - -/* - * @implemented - */ -SIZE_T STDCALL -LocalShrink(HLOCAL hMem, UINT cbNewSize) -{ - return RtlCompactHeap(hProcessHeap, 0); -} - - -/* - * @implemented - */ -UINT STDCALL + SIZE_T dwBytes, + UINT uFlags) +{ + PBASE_HEAP_HANDLE_ENTRY HandleEntry; + LPVOID Ptr; + ULONG Flags = 0; + + /* Convert ZEROINIT */ + if (uFlags & LMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY; + + /* If this wasn't a movable heap, then we MUST re-alloc in place */ + if (!(uFlags & LMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY; + + /* Lock the heap and disable built-in locking in the RTL Heap funcitons */ + RtlLockHeap(hProcessHeap); + Flags |= HEAP_NO_SERIALIZE; + + /* Check if this is a simple handle-based block */ + if (((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) + { + /* Get the entry */ + HandleEntry = BaseHeapGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure the handle is valid */ + if (!BaseHeapValidateEntry(HandleEntry)) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + hMem = NULL; + } + else if (uFlags & LMEM_MODIFY) + { + /* User is changing flags... check if the memory was discardable */ + if (uFlags & LMEM_DISCARDABLE) + { + /* Then set the flag */ + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE; + } + else + { + /* Otherwise, remove the flag */ + HandleEntry->Flags &= BASE_HEAP_ENTRY_FLAG_REUSABLE; + } + } + else + { + /* Otherwise, get the object and check if we have no size */ + Ptr = HandleEntry->Object; + if (!dwBytes) + { + /* Clear the handle and check for a pointer */ + hMem = NULL; + if (Ptr) + { + /* Make sure the handle isn't locked */ + if ((uFlags & LMEM_MOVEABLE) & !(HandleEntry->LockCount)) + { + /* Free the current heap */ + RtlFreeHeap(hProcessHeap, Flags, Ptr); + + /* Free the handle */ + HandleEntry->Object = NULL; + HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE; + + /* Get the object pointer */ + hMem = &HandleEntry->Object; + } + } + else + { + /* Otherwise just return the object pointer */ + hMem = &HandleEntry->Object; + } + } + else + { + /* Otherwise, we're allocating, so set the new flags needed */ + Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE; + if (!Ptr) + { + /* We don't have a base, so allocate one */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_ALLOC2(Ptr); + if (Ptr) + { + /* Allocation succeeded, so save our entry */ + RtlSetUserValueHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + Ptr, + hMem); + } + } + else + { + /* + * If it's not movable or currently locked, we MUST allocate + * in-place! + */ + if (!(uFlags & LMEM_MOVEABLE) && (HandleEntry->LockCount)) + { + /* Set the flag */ + Flags |= HEAP_REALLOC_IN_PLACE_ONLY; + } + else + { + /* Otherwise clear the flag if we set it previously */ + Flags &= ~HEAP_REALLOC_IN_PLACE_ONLY; + } + + /* And do the re-allocation */ + Ptr = RtlReAllocateHeap(hProcessHeap, Flags, Ptr, dwBytes); + } + + /* Make sure we have a pointer by now */ + if (Ptr) + { + /* Write it in the handle entry and mark it in use */ + HandleEntry->Object = Ptr; + HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSE; + } + else + { + /* Otherwise we failed */ + hMem = NULL; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + } + } + } + } + else if (!(uFlags & LMEM_MODIFY)) + { + /* Otherwise, this is a simple RTL Managed Heap, so just call it */ + hMem = RtlReAllocateHeap(hProcessHeap, + Flags | HEAP_NO_SERIALIZE, + hMem, + dwBytes); + if (!hMem) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + } + } + + /* All done, unlock the heap and return the pointer */ + RtlUnlockHeap(hProcessHeap); + return hMem; +} + +/* + * @implemented + */ +SIZE_T +STDCALL +LocalShrink(HLOCAL hMem, + UINT cbNewSize) +{ + /* Call RTL */ + return RtlCompactHeap(hProcessHeap, 0); +} + +/* + * @implemented + */ +SIZE_T +NTAPI LocalSize(HLOCAL hMem) { - return GlobalSize((HGLOBAL)hMem); -} - - -/* - * @implemented - */ -BOOL STDCALL + /* This is the same as a Global Size */ + return GlobalSize(hMem); +} + +/* + * @implemented + */ +BOOL +NTAPI LocalUnlock(HLOCAL hMem) { - return GlobalUnlock((HGLOBAL)hMem); + /* This is the same as a Global Unlock */ + return GlobalUnlock(hMem); } /* EOF */ Modified: trunk/reactos/dll/win32/kernel32/misc/dllmain.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/misc/dl… ============================================================================== --- trunk/reactos/dll/win32/kernel32/misc/dllmain.c (original) +++ trunk/reactos/dll/win32/kernel32/misc/dllmain.c Sat Jun 24 23:00:07 2006 @@ -340,8 +340,8 @@ hProcessHeap = RtlGetProcessHeap(); RtlInitializeHandleTable(0xFFFF, - sizeof(GLOBAL_HEAP_HANDLE_ENTRY), - &BaseGlobalHandleTable); + sizeof(BASE_HEAP_HANDLE_ENTRY), + &BaseHeapHandleTable); hCurrentModule = hDll; DPRINT("Heap: %p\n", hProcessHeap); Modified: trunk/reactos/include/winbase.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/winbase.h?rev=2258… ============================================================================== --- trunk/reactos/include/winbase.h (original) +++ trunk/reactos/include/winbase.h Sat Jun 24 23:00:07 2006 @@ -327,6 +327,7 @@ #define LMEM_MODIFY 128 #define LMEM_INVALID_HANDLE 32768 #define LMEM_LOCKCOUNT 255 +#define LMEM_VALID_FLAGS 0x0F72 #define LPTR 64 #define LHND 66 #define NONZEROLHND 2 @@ -1698,7 +1699,7 @@ PVOID WINAPI LocalLock(HLOCAL); HLOCAL WINAPI LocalReAlloc(HLOCAL,SIZE_T,UINT); SIZE_T WINAPI LocalShrink(HLOCAL,UINT); /* Obsolete: Has no effect. */ -UINT WINAPI LocalSize(HLOCAL); +SIZE_T WINAPI LocalSize(HLOCAL); BOOL WINAPI LocalUnlock(HLOCAL); BOOL WINAPI LockFile(HANDLE,DWORD,DWORD,DWORD,DWORD); BOOL WINAPI LockFileEx(HANDLE,DWORD,DWORD,DWORD,DWORD,LPOVERLAPPED);

1 0

[hpoussin] 22581: Fix prototype of WritePwrScheme. Prototypes shouldn't have LPTSTR in their parameter list!
by hpoussin＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: hpoussin Date: Sat Jun 24 22:47:50 2006 New Revision: 22581 URL: http://svn.reactos.org/svn/reactos?rev=22581&view=rev Log: Fix prototype of WritePwrScheme. Prototypes shouldn't have LPTSTR in their parameter list! Modified: trunk/reactos/include/powrprof.h Modified: trunk/reactos/include/powrprof.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/powrprof.h?rev=225… ============================================================================== --- trunk/reactos/include/powrprof.h (original) +++ trunk/reactos/include/powrprof.h Sat Jun 24 22:47:50 2006 @@ -90,7 +90,7 @@ USER_POWER_POLICY user; MACHINE_POWER_POLICY mach; } POWER_POLICY, *PPOWER_POLICY; -typedef BOOLEAN (CALLBACK* PWRSCHEMESENUMPROC)(UINT, DWORD, LPTSTR, DWORD, LPTSTR, PPOWER_POLICY, LPARAM); +typedef BOOLEAN (CALLBACK* PWRSCHEMESENUMPROC)(UINT, DWORD, LPWSTR, DWORD, LPWSTR, PPOWER_POLICY, LPARAM); typedef BOOLEAN (CALLBACK* PFNNTINITIATEPWRACTION)(POWER_ACTION, SYSTEM_POWER_STATE, ULONG, BOOLEAN); NTSTATUS WINAPI CallNtPowerInformation(POWER_INFORMATION_LEVEL, PVOID, ULONG, PVOID, ULONG); BOOLEAN WINAPI CanUserWritePwrScheme(VOID); @@ -112,7 +112,7 @@ BOOLEAN WINAPI WriteGlobalPwrPolicy(PGLOBAL_POWER_POLICY); BOOLEAN WINAPI WriteProcessorPwrScheme(UINT, PMACHINE_PROCESSOR_POWER_POLICY); BOOLEAN WINAPI ValidatePowerPolicies(PGLOBAL_POWER_POLICY, PPOWER_POLICY); -BOOLEAN WINAPI WritePwrScheme(PUINT, LPTSTR, LPTSTR, PPOWER_POLICY); +BOOLEAN WINAPI WritePwrScheme(PUINT, LPWSTR, LPWSTR, PPOWER_POLICY); #endif /* RC_INVOKED */

1 0

[hpoussin] 22580: Fix definition of NtGdiAlphaBlend
by hpoussin＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: hpoussin Date: Sat Jun 24 22:26:28 2006 New Revision: 22580 URL: http://svn.reactos.org/svn/reactos?rev=22580&view=rev Log: Fix definition of NtGdiAlphaBlend Modified: trunk/reactos/include/ntgdi.h trunk/reactos/subsystems/win32/win32k/objects/bitmaps.c Modified: trunk/reactos/include/ntgdi.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/ntgdi.h?rev=22580&… ============================================================================== --- trunk/reactos/include/ntgdi.h (original) +++ trunk/reactos/include/ntgdi.h Sat Jun 24 22:26:28 2006 @@ -1097,8 +1097,7 @@ IN LONG SrcY, IN LONG SrcCx, IN LONG SrcCy, - IN BLENDFUNCTION BlendFunction, - IN HANDLE hcmXform + IN BLENDFUNCTION BlendFunction ); W32KAPI Modified: trunk/reactos/subsystems/win32/win32k/objects/bitmaps.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/ob… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/objects/bitmaps.c (original) +++ trunk/reactos/subsystems/win32/win32k/objects/bitmaps.c Sat Jun 24 22:26:28 2006 @@ -1341,8 +1341,7 @@ LONG YOriginSrc, LONG WidthSrc, LONG HeightSrc, - BLENDFUNCTION BlendFunc, - IN HANDLE hcmXform) + BLENDFUNCTION BlendFunc) { PDC DCDest = NULL; PDC DCSrc = NULL; @@ -1352,7 +1351,7 @@ XLATEOBJ *XlateObj; BLENDOBJ BlendObj; HPALETTE SourcePalette = 0, DestPalette = 0; - BlendObj.BlendFunction = BlendFunc; + BlendObj.BlendFunction = BlendFunc; DCDest = DC_LockDc(hDCDest); if (NULL == DCDest)

1 0

[ion] 22579: - Rewrote Base Heap implementation nearly from scratch, currently only for Global Heap (Local Heap is as broken as before, since it still calls the Global Heap APIs). For detailed implementation notes, see baseheap.h - Main changes include using the RtlHandle package instead of duplicating an internal implementation, as well as using the RtlHeap* APIs that allow for setting User Flags/Values for associating Base Heap Flags/Handles with the actual RTL-managed block. - Regression-test
by ion＠svn.reactos.org 24 Jun '06

24 Jun '06

Author: ion Date: Sat Jun 24 22:11:57 2006 New Revision: 22579 URL: http://svn.reactos.org/svn/reactos?rev=22579&view=rev Log: - Rewrote Base Heap implementation nearly from scratch, currently only for Global Heap (Local Heap is as broken as before, since it still calls the Global Heap APIs). For detailed implementation notes, see baseheap.h - Main changes include using the RtlHandle package instead of duplicating an internal implementation, as well as using the RtlHeap* APIs that allow for setting User Flags/Values for associating Base Heap Flags/Handles with the actual RTL-managed block. - Regression-tested with WINE tests and basic ROS apps. Added: trunk/reactos/dll/win32/kernel32/include/baseheap.h Modified: trunk/reactos/dll/win32/kernel32/include/kernel32.h trunk/reactos/dll/win32/kernel32/mem/global.c trunk/reactos/dll/win32/kernel32/misc/dllmain.c Added: trunk/reactos/dll/win32/kernel32/include/baseheap.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/include… ============================================================================== --- trunk/reactos/dll/win32/kernel32/include/baseheap.h (added) +++ trunk/reactos/dll/win32/kernel32/include/baseheap.h Sat Jun 24 22:11:57 2006 @@ -1,0 +1,121 @@ +/* + * PROJECT: ReactOS Win32 Base API + * LICENSE: GPL - See COPYING in the top level directory + * FILE: dll/win32/kernel32/include/baseheap.h + * PURPOSE: Base Heap Structures + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +// +// Some important implementation notes. +// +// Firstly, the Global* APIs in Win32 are largely similar to the Local* APIs, +// but there are a number of small differences (for example, there is no such +// thing as DDE/Shared Local memory, and the re-allocation semantics are also +// simpler, because you cannot force a move). +// +// Note something VERY IMPORTANT: This implementation *depends* on the fact +// that all heap pointers are, at the very least, 8 byte aligned, and that heap +// handles are actually pointers inside our HandleEntry->Object, which happens +// to be at offset 0x4, which means testing with bit 3 tells us if the handle +// is a pointer or a real "handle". On 64-bit, heap pointers should be 16-byte +// aligned, and our offset should be 0x8, so the trick works anyways, but using +// the 4th bit. +// +// Apart from MSDN, a wonderful source of information about how this works is +// available on Raymond's blog, in a 4-parter series starting at: +// http://blogs.msdn.com/oldnewthing/archive/2004/11/04/252258.aspx. +// +// Finally, as Raymond points out, be aware that some applications depend on +// the way this implementation was done, since global memory handles are a +// straight-forward overlay on top of the RTL Handle implementation, and rogue +// applications can easily do the conversion manually without calling the right +// API for it (such as GlobalLock). +// + +// +// The Handle Table +// +extern RTL_HANDLE_TABLE BaseGlobalHandleTable; + +// +// Tracing Support +// Define _BASE_HANDLE_TRACE for Traces +// +#ifdef _BASE_HANDLE_TRACE_ +#define BH_PRINT DbgPrint +#else +#define BH_PRINT DPRINT +#endif +#define BASE_TRACE_ALLOC(x, y) \ + BH_PRINT("[BASE_HEAP] %s : Allocating %lx bytes with flags: %lx\n", \ + __FUNCTION__, x, y) +#define BASE_TRACE_ALLOC2(x) \ + BH_PRINT("[BASE_HEAP] %s : Allocated %p\n", \ + __FUNCTION__, x) +#define BASE_TRACE_PTR(x, y) \ + BH_PRINT("[BASE_HEAP] %s : Using handle: %lx for pointer: %p\n", \ + __FUNCTION__, x, y) +#define BASE_TRACE_HANDLE(x, y) \ + BH_PRINT("[BASE_HEAP] %s : Using handle: %lx for block: %p\n", \ + __FUNCTION__, x, y) +#define BASE_TRACE_DEALLOC(x) \ + BH_PRINT("[BASE_HEAP] %s : Freeing %p\n", \ + __FUNCTION__, x) + +// +// The handle structure for global heap handles. +// Notice that it nicely overlays with RTL_HANDLE_ENTRY. +// KEEP IT THAT WAY! ;-) +// +typedef struct _GLOBAL_HEAP_HANDLE_ENTRY +{ + USHORT Flags; + USHORT LockCount; + union + { + PVOID Object; + ULONG OldSize; + }; +} GLOBAL_HEAP_HANDLE_ENTRY, *PGLOBAL_HEAP_HANDLE_ENTRY; + +// +// Handle entry flags +// Note that 0x0001 is the shared/generic RTL_HANDLE_VALID +// +#define GLOBAL_HEAP_ENTRY_FLAG_MOVABLE 0x0002 +#define GLOBAL_HEAP_ENTRY_FLAG_REUSABLE 0x0004 +#define GLOBAL_HEAP_ENTRY_FLAG_REUSE 0x0008 +#define GLOBAL_HEAP_ENTRY_FLAG_DDESHARE 0x0010 + +// +// Easy way to check if the global handle is actually an entry in our table +// +#define GLOBAL_HEAP_IS_HANDLE_ENTRY \ + (ULONG_PTR)FIELD_OFFSET(GLOBAL_HEAP_HANDLE_ENTRY, Object) + +// +// Tags for the entire heap allocation for this global memory. +// They are set part of the User Flags of the RTL Heap. +// +#define GLOBAL_HEAP_FLAG_MOVABLE HEAP_SETTABLE_USER_FLAG1 +#define GLOBAL_HEAP_FLAG_DDESHARE HEAP_SETTABLE_USER_FLAG2 + +// +// Internal Handle Functions +// +#define GlobalAllocEntry() \ + (PGLOBAL_HEAP_HANDLE_ENTRY)RtlAllocateHandle(&BaseGlobalHandleTable, NULL) + +#define GlobalGetEntry(h) \ + (PGLOBAL_HEAP_HANDLE_ENTRY) \ + CONTAINING_RECORD(h, \ + GLOBAL_HEAP_HANDLE_ENTRY, \ + Object); + +#define GlobalValidateEntry(he) \ + RtlIsValidHandle(&BaseGlobalHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he) + +#define GlobalFreeEntry(he) \ + RtlFreeHandle(&BaseGlobalHandleTable, (PRTL_HANDLE_TABLE_ENTRY)he); + Modified: trunk/reactos/dll/win32/kernel32/include/kernel32.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/include… ============================================================================== --- trunk/reactos/dll/win32/kernel32/include/kernel32.h (original) +++ trunk/reactos/dll/win32/kernel32/include/kernel32.h Sat Jun 24 22:11:57 2006 @@ -1,5 +1,7 @@ #ifndef _KERNEL32_INCLUDE_KERNEL32_H #define _KERNEL32_INCLUDE_KERNEL32_H + +#include "baseheap.h" #define BINARY_UNKNOWN (0) #define BINARY_PE_EXE32 (1) Modified: trunk/reactos/dll/win32/kernel32/mem/global.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/mem/glo… ============================================================================== --- trunk/reactos/dll/win32/kernel32/mem/global.c (original) +++ trunk/reactos/dll/win32/kernel32/mem/global.c Sat Jun 24 22:11:57 2006 @@ -1,740 +1,931 @@ -/* $Id$ - * - * Win32 Global/Local heap functions (GlobalXXX, LocalXXX). - * These functions included in Win32 for compatibility with 16 bit Windows - * Especially the moveable blocks and handles are oldish. - * But the ability to directly allocate memory with GPTR and LPTR is widely - * used. - * - * Updated to support movable memory with algorithms taken from wine. - */ +/* + * PROJECT: ReactOS Win32 Base API + * LICENSE: GPL - See COPYING in the top level directory + * FILE: dll/win32/kernel32/mem/global.c + * PURPOSE: Global Memory APIs (sits on top of Heap*) + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ #include <k32.h> #define NDEBUG -#include "../include/debug.h" - -#ifdef _GNUC_ -#define STRUCT_PACK __attribute__((packed)) -#else -#define STRUCT_PACK -#endif - -#define MAGIC_GLOBAL_USED 0x5342BEEF -#define GLOBAL_LOCK_MAX 0xFF - -/*Wine found that some applications complain if memory isn't 8 byte aligned. -* We make use of that experience here. -*/ -#define HANDLE_SIZE 8 /*sizeof(HANDLE) *2 */ - - -typedef struct __GLOBAL_LOCAL_HANDLE -{ - DWORD Magic; - LPVOID Pointer; STRUCT_PACK - BYTE Flags; - BYTE LockCount; -} GLOBAL_HANDLE, LOCAL_HANDLE, *PGLOBAL_HANDLE, *PLOCAL_HANDLE; - -#define HANDLE_TO_INTERN(h) ((PGLOBAL_HANDLE)(((char *)(h))-4)) -#define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer)) -#define POINTER_TO_HANDLE(p) (*(PHANDLE)((ULONG_PTR)p - HANDLE_SIZE)) -#define ISHANDLE(h) ((((ULONG)(h)) & 0x4)!=0) -#define ISPOINTER(h) ((((ULONG)(h)) & 0x4)==0) - - -static void DbgPrintStruct(PGLOBAL_HANDLE h) -{ - DPRINT("Magic: 0x%X\n", h->Magic); - DPRINT("Pointer: 0x%X\n", h->Pointer); - DPRINT("Flags: 0x%X\n", h->Flags); - DPRINT("LockCount: 0x%X\n", h->LockCount); -} - - +#include "debug.h" + +#define BASE_TRACE_FAILURE() \ + DbgPrint("[BASE_HEAP] %s : Failing %d\n", \ + __FUNCTION__, __LINE__) + +/* TYPES *********************************************************************/ + +extern SYSTEM_BASIC_INFORMATION BaseCachedSysInfo; +RTL_HANDLE_TABLE BaseGlobalHandleTable; /* FUNCTIONS ***************************************************************/ /* * @implemented */ -HGLOBAL STDCALL +HGLOBAL +NTAPI GlobalAlloc(UINT uFlags, DWORD dwBytes) { - - PGLOBAL_HANDLE phandle = 0; - PVOID palloc = 0; - UINT heap_flags = 0; - - if (uFlags & GMEM_ZEROINIT) - { - heap_flags = HEAP_ZERO_MEMORY; - } - - DPRINT("GlobalAlloc( 0x%X, 0x%lX )\n", uFlags, dwBytes); - - //Changed hProcessHeap to GetProcessHeap() - if ((uFlags & GMEM_MOVEABLE)==0) /* POINTER */ - { - palloc = RtlAllocateHeap(GetProcessHeap(), heap_flags, dwBytes); - if (! ISPOINTER(palloc)) - { - DPRINT1("GlobalAlloced pointer which is not 8-byte aligned\n"); - RtlFreeHeap(GetProcessHeap(), 0, palloc); + ULONG Flags = 0; + PVOID Ptr = NULL; + HANDLE hMemory; + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + BASE_TRACE_ALLOC(dwBytes, uFlags); + ASSERT(hProcessHeap); + + /* Make sure the flags are valid */ + if (uFlags & ~GMEM_VALID_FLAGS) + { + /* They aren't, fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } + + /* Convert ZEROINIT */ + if (uFlags & GMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY; + + /* Check if we're not movable, which means pointer-based heap */ + if (!(uFlags & GMEM_MOVEABLE)) + { + /* Check if this is DDESHARE (deprecated) */ + if (uFlags & GMEM_DDESHARE) Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + + /* Allocate heap for it */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_ALLOC2(Ptr); + return Ptr; + } + + /* This is heap based, so lock it in first */ + RtlLockHeap(hProcessHeap); + + /* + * Disable locking, enable custom flags, and write the + * movable flag (deprecated) + */ + Flags |= HEAP_NO_SERIALIZE | + HEAP_SETTABLE_USER_VALUE | + GLOBAL_HEAP_FLAG_MOVABLE; + + /* Allocate the handle */ + HandleEntry = GlobalAllocEntry(); + if (!HandleEntry) + { + /* Fail */ + hMemory = NULL; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + BASE_TRACE_FAILURE(); + goto Quickie; + } + + /* Get the object and make sure we have size */ + hMemory = &HandleEntry->Object; + if (dwBytes) + { + /* Allocate the actual memory for it */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_PTR(HandleEntry, Ptr); + if (!Ptr) + { + /* We failed, manually set the allocate flag and free the handle */ + HandleEntry->Flags = RTL_HANDLE_VALID; + GlobalFreeEntry(HandleEntry); + + /* For the cleanup case */ + HandleEntry = NULL; + } + else + { + /* All worked well, save our heap entry */ + RtlSetUserValueHeap(hProcessHeap, HEAP_NO_SERIALIZE, Ptr, hMemory); + } + } + +Quickie: + /* Cleanup! First unlock the heap */ + RtlUnlockHeap(hProcessHeap); + + /* Check if a handle was allocated */ + if (HandleEntry) + { + /* Set the pointer and allocated flag */ + HandleEntry->Object = Ptr; + HandleEntry->Flags = RTL_HANDLE_VALID; + if (!Ptr) + { + /* We don't have a valid pointer, but so reuse this handle */ + HandleEntry->Flags = GLOBAL_HEAP_ENTRY_FLAG_REUSE; + } + + /* Check if the handle is discardable */ + if (uFlags & GMEM_DISCARDABLE) + { + /* Save it in the handle entry */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + } + + /* Check if the handle is moveable */ + if (uFlags & GMEM_MOVEABLE) + { + /* Save it in the handle entry */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_MOVABLE; + } + + /* Check if the handle is DDE Shared */ + if (uFlags & GMEM_DDESHARE) + { + /* Save it in the handle entry */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + } + + /* Set the pointer */ + Ptr = hMemory; + } + + /* Return the pointer */ + return Ptr; +} + +/* + * @implemented + */ +SIZE_T +NTAPI +GlobalCompact(DWORD dwMinFree) +{ + /* Call the RTL Heap Manager */ + return RtlCompactHeap(hProcessHeap, 0); +} + +/* + * @implemented + */ +VOID +NTAPI +GlobalFix(HGLOBAL hMem) +{ + /* Lock the memory if it the handle is valid */ + if (INVALID_HANDLE_VALUE != hMem) GlobalLock(hMem); +} + +/* + * @implemented + */ +UINT +NTAPI +GlobalFlags(HGLOBAL hMem) +{ + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + HANDLE Handle = NULL; + ULONG Flags = 0; + UINT uFlags = GMEM_INVALID_HANDLE; + + /* Start by locking the heap */ + RtlLockHeap(hProcessHeap); + + /* Check if this is a simple RTL Heap Managed block */ + if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + { + /* Then we'll query RTL Heap */ + RtlGetUserInfoHeap(hProcessHeap, Flags, hMem, &Handle, &Flags); + BASE_TRACE_PTR(Handle, hMem); + + /* + * Check if RTL Heap didn't find a handle associated with us or + * said that this heap isn't movable, which means something we're + * really not a handle-based heap. + */ + if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + { + /* Then set the flags to 0 */ + uFlags = 0; + } + else + { + /* Otherwise we're handle-based, so get the internal handle */ + hMem = Handle; + } + } + + /* Check if the handle is actually an entry in our table */ + if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + { + /* Then get the entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure it's a valid handle */ + if (GlobalValidateEntry(HandleEntry)) + { + /* Get the lock count first */ + uFlags = HandleEntry->LockCount & GMEM_LOCKCOUNT; + + /* Now check if it's discarded */ + if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_REUSABLE) + { + /* Set the Win32 Flag */ + uFlags |= GMEM_DISCARDED; + } + + /* Check if it's movable */ + if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_MOVABLE) + { + /* Set the Win32 Flag */ + uFlags |= GMEM_MOVEABLE; + } + + /* Check if it's DDE Shared */ + if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_DDESHARE) + { + /* Set the Win32 Flag */ + uFlags |= GMEM_DDESHARE; + } + } + } + + /* Check if by now, we still haven't gotten any useful flags */ + if (uFlags == GMEM_INVALID_HANDLE) SetLastError(ERROR_INVALID_HANDLE); + + /* All done! Unlock heap and return Win32 Flags */ + RtlUnlockHeap(hProcessHeap); + return uFlags; +} + +/* + * @implemented + */ +HGLOBAL +NTAPI +GlobalFree(HGLOBAL hMem) +{ + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + LPVOID Ptr; + BASE_TRACE_DEALLOC(hMem); + + /* Check if this was a simple allocated heap entry */ + if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + { + /* Free it with the RTL Heap Manager */ + if (RtlFreeHeap(hProcessHeap, 0, hMem)) + { + /* Return NULL since there's no handle */ return NULL; } - return (HGLOBAL) palloc; - } - else /* HANDLE */ - { - HeapLock(hProcessHeap); - - phandle = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(GLOBAL_HANDLE)); - if (phandle) - { - phandle->Magic = MAGIC_GLOBAL_USED; - phandle->Flags = uFlags >> 8; - phandle->LockCount = 0; - phandle->Pointer = 0; - - if (dwBytes) + else + { + /* Otherwise fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + return hMem; + } + } + + /* It's a handle probably, so lock the heap */ + RtlLockHeap(hProcessHeap); + + /* Make sure that this is an entry in our handle database */ + if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + { + /* Get the entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure the handle is valid */ + if (!GlobalValidateEntry(HandleEntry)) + { + /* It's not, fail */ + SetLastError(ERROR_INVALID_HANDLE); + Ptr = NULL; + } + else + { + /* It's valid, so get the pointer */ + Ptr = HandleEntry->Object; + + /* Free this handle */ + GlobalFreeEntry(HandleEntry); + + /* If the pointer is 0, then we don't have a handle either */ + if (!Ptr) hMem = NULL; + } + } + else + { + /* Otherwise, reuse the handle as a pointer */ + BASE_TRACE_FAILURE(); + Ptr = hMem; + } + + /* Check if we got here with a valid heap pointer */ + if (Ptr) + { + /* Free it */ + RtlFreeHeap(hProcessHeap, HEAP_NO_SERIALIZE, Ptr); + hMem = NULL; + } + + /* We're done, so unlock the heap and return the handle */ + RtlUnlockHeap(hProcessHeap); + return hMem; +} + +/* + * @implemented + */ +HGLOBAL +NTAPI +GlobalHandle(LPCVOID pMem) +{ + HANDLE Handle = NULL; + ULONG Flags; + + /* Lock the heap */ + RtlLockHeap(hProcessHeap); + + /* Query RTL Heap */ + RtlGetUserInfoHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + (PVOID)pMem, + &Handle, + &Flags); + BASE_TRACE_PTR(Handle, pMem); + + /* + * Check if RTL Heap didn't find a handle for us or said that + * this heap isn't movable. + */ + if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + { + /* We're actually handle-based, so the pointer is a handle */ + Handle = (HANDLE)pMem; + } + + /* All done, unlock the heap and return the handle */ + RtlUnlockHeap(hProcessHeap); + return Handle; +} + +/* + * @implemented + */ +LPVOID +NTAPI +GlobalLock(HGLOBAL hMem) +{ + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + LPVOID Ptr; + + /* Check if this was a simple allocated heap entry */ + if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + { + /* Then simply return the pointer */ + return hMem; + } + + /* Otherwise, lock the heap */ + RtlLockHeap(hProcessHeap); + + /* Get the handle entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure it's valid */ + if (!GlobalValidateEntry(HandleEntry)) + { + /* It's not, fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + Ptr = NULL; + } + else + { + /* Otherwise, get the pointer */ + Ptr = HandleEntry->Object; + if (Ptr) + { + /* Increase the lock count, unless we've went too far */ + if (HandleEntry->LockCount++ == GMEM_LOCKCOUNT) { - palloc = RtlAllocateHeap(GetProcessHeap(), heap_flags, dwBytes + HANDLE_SIZE); - if (palloc) + /* In which case we simply unlock once */ + HandleEntry->LockCount--; + } + } + else + { + /* The handle is still there but the memory was already freed */ + SetLastError(ERROR_DISCARDED); + } + } + + /* All done. Unlock the heap and return the pointer */ + RtlUnlockHeap(hProcessHeap); + return Ptr; +} + +HGLOBAL +NTAPI +GlobalReAlloc(HGLOBAL hMem, + DWORD dwBytes, + UINT uFlags) +{ + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + HANDLE Handle; + LPVOID Ptr; + ULONG Flags = 0; + + /* Convert ZEROINIT */ + if (uFlags & GMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY; + + /* If this wasn't a movable heap, then we MUST re-alloc in place */ + if (!(uFlags & GMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY; + + /* Lock the heap and disable built-in locking in the RTL Heap funcitons */ + RtlLockHeap(hProcessHeap); + Flags |= HEAP_NO_SERIALIZE; + DPRINT1("hmem: %p Flags: %lx\n", hMem, uFlags); + + /* Check if this is a simple handle-based block */ + if (((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + { + /* Get the entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure the handle is valid */ + if (!GlobalValidateEntry(HandleEntry)) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + hMem = NULL; + } + else if (uFlags & GMEM_MODIFY) + { + /* User is changing flags... check if the memory was discardable */ + if (uFlags & GMEM_DISCARDABLE) + { + /* Then set the flag */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + } + else + { + /* Otherwise, remove the flag */ + HandleEntry->Flags &= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + } + } + else + { + /* Otherwise, get the object and check if we have no size */ + Ptr = HandleEntry->Object; + if (!dwBytes) + { + /* Clear the handle and check for a pointer */ + hMem = NULL; + if (Ptr) { - *(PHANDLE)palloc = INTERN_TO_HANDLE(phandle); - phandle->Pointer = (PVOID)((ULONG_PTR)palloc + HANDLE_SIZE); + /* Make sure the handle isn't locked */ + if ((uFlags & GMEM_MOVEABLE) & !(HandleEntry->LockCount)) + { + /* Free the current heap */ + RtlFreeHeap(hProcessHeap, Flags, Ptr); + + /* Free the handle */ + HandleEntry->Object = NULL; + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSE; + + /* Get the object pointer */ + hMem = &HandleEntry->Object; + } } - else /*failed to allocate the memory block*/ + else { - RtlFreeHeap(GetProcessHeap(), 0, phandle); - phandle = 0; + /* Otherwise just return the object pointer */ + hMem = &HandleEntry->Object; } } else { - DPRINT("Allocated a 0 size movable block.\n"); - DbgPrintStruct(phandle); - DPRINT("Address of the struct: 0x%X\n", phandle); - DPRINT("Address of pointer: 0x%X\n", &(phandle->Pointer)); - } - } - HeapUnlock(hProcessHeap); - - if (phandle) - { - if (ISPOINTER(INTERN_TO_HANDLE(phandle))) - { - DPRINT1("GlobalAlloced handle which is 8-byte aligned but shouldn't be\n"); - RtlFreeHeap(GetProcessHeap(), 0, palloc); - RtlFreeHeap(GetProcessHeap(), 0, phandle); - return NULL; - } - return INTERN_TO_HANDLE(phandle); - } - else - return (HGLOBAL)0; - } -} - - -/* - * @implemented - */ -SIZE_T STDCALL -GlobalCompact(DWORD dwMinFree) -{ - return RtlCompactHeap(hProcessHeap, 0); -} - - -/* - * @implemented - */ -VOID STDCALL -GlobalFix(HGLOBAL hMem) -{ - if (INVALID_HANDLE_VALUE != hMem) - GlobalLock(hMem); -} - -/* - * @implemented - */ -UINT STDCALL -GlobalFlags(HGLOBAL hMem) -{ - DWORD retval; - PGLOBAL_HANDLE phandle; - - DPRINT("GlobalFlags( 0x%lX )\n", (ULONG)hMem); - - if(!ISHANDLE(hMem)) - { - DPRINT("GlobalFlags: Fixed memory.\n"); - retval = 0; - } - else - { - HeapLock(GetProcessHeap()); - - phandle = HANDLE_TO_INTERN(hMem); - - /*DbgPrintStruct(phandle);*/ - - if (MAGIC_GLOBAL_USED == phandle->Magic) - { - /*DbgPrint("GlobalFlags: Magic number ok\n"); - **DbgPrint("GlobalFlags: pointer is 0x%X\n", phandle->Pointer); - */ - retval = phandle->LockCount + (phandle->Flags << 8); - if (0 == phandle->Pointer) - { - retval = retval | GMEM_DISCARDED; - } - } - else - { - DPRINT1("GlobalSize: invalid handle\n"); - retval = 0; - } - HeapUnlock(GetProcessHeap()); - } - return retval; -} - - -/* - * @implemented - */ -HGLOBAL STDCALL -GlobalFree(HGLOBAL hMem) -{ - PGLOBAL_HANDLE phandle; - HGLOBAL hreturned; - - DPRINT("GlobalFree( 0x%lX )\n", (ULONG)hMem); - - hreturned = 0; - if (ISPOINTER(hMem)) /* POINTER */ - { - if(!RtlFreeHeap(GetProcessHeap(), 0, (PVOID)hMem)) - hMem = 0; - } - else /* HANDLE */ - { - HeapLock(GetProcessHeap()); - - phandle = HANDLE_TO_INTERN(hMem); - - if(MAGIC_GLOBAL_USED == phandle->Magic) - { - /* WIN98 does not make this test. That is you can free a */ - /* block you have not unlocked. Go figure!! */ - if(phandle->LockCount!=0) - { - DPRINT1("Warning! GlobalFree(0x%X) Freeing a handle to a locked object.\n", hMem); - SetLastError(ERROR_INVALID_HANDLE); - } - - if(phandle->Pointer) - if (!RtlFreeHeap(GetProcessHeap(), 0, (PVOID)((ULONG_PTR)phandle->Pointer - HANDLE_SIZE))) - hreturned = hMem; - - if (!RtlFreeHeap(GetProcessHeap(), 0, phandle)) - hreturned = hMem; - } - HeapUnlock(GetProcessHeap()); - - hMem = 0; - } - return hreturned; -} - - -/* - * @implemented - */ -HGLOBAL STDCALL -GlobalHandle(LPCVOID pMem) -{ - HGLOBAL handle = 0; - PGLOBAL_HANDLE test = 0; - LPCVOID pointer_test = 0; - - DPRINT("GlobalHandle( 0x%lX )\n", (ULONG)pMem); - if (0 == pMem) /*Invalid argument */ - { - SetLastError(ERROR_INVALID_PARAMETER); - DPRINT1("Error: 0 handle.\n"); - return 0; - } - - HeapLock(GetProcessHeap()); - /* Now test to see if this pointer is associated with a handle. - * This is done by calling RtlValidateHeap() and seeing if it fails. - */ - if (RtlValidateHeap(GetProcessHeap(), 0, (char *)pMem)) /*FIXED*/ - { - handle = (HGLOBAL)pMem; - return handle; - } - else /*MOVABLE*/ - { - handle = POINTER_TO_HANDLE(pMem); - } - - - /* Test to see if this memory is valid*/ - test = HANDLE_TO_INTERN(handle); - if (!IsBadReadPtr(test, sizeof(GLOBAL_HANDLE))) - { - if (MAGIC_GLOBAL_USED == test->Magic) - { - pointer_test = test->Pointer; - if (!RtlValidateHeap(GetProcessHeap(), 0, ((char *)pointer_test) - HANDLE_SIZE) || - !RtlValidateHeap(GetProcessHeap(), 0, test)) - { - SetLastError(ERROR_INVALID_HANDLE); - handle = 0; - } - } - } - else - { - DPRINT1("GlobalHandle: Bad read pointer.\n"); - SetLastError(ERROR_INVALID_HANDLE); - handle = 0; - } - - HeapUnlock(GetProcessHeap()); - - return handle; -} - - -/* - * @implemented - */ -LPVOID STDCALL -GlobalLock(HGLOBAL hMem) -{ - PGLOBAL_HANDLE phandle; - LPVOID palloc; - - DPRINT("GlobalLock( 0x%lX )\n", (ULONG)hMem); - - if (ISPOINTER(hMem)) - return (LPVOID) hMem; - - HeapLock(GetProcessHeap()); - - phandle = HANDLE_TO_INTERN(hMem); - - if(MAGIC_GLOBAL_USED == phandle->Magic) - { - if(GLOBAL_LOCK_MAX > phandle->LockCount) - { - phandle->LockCount++; - } - palloc = phandle->Pointer; - } - else - { - DPRINT("GlobalLock: invalid handle\n"); - palloc = (LPVOID) hMem; - } - - HeapUnlock(GetProcessHeap()); - - return palloc; -} - -/* - * @implemented - */ -BOOL -STDCALL -GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer) -{ - SYSTEM_BASIC_INFORMATION SysBasicInfo; - SYSTEM_PERFORMANCE_INFORMATION SysPerfInfo; - ULONG UserMemory; - NTSTATUS Status; - - DPRINT("GlobalMemoryStatusEx\n"); - - if (lpBuffer->dwLength != sizeof(MEMORYSTATUSEX)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - - Status = ZwQuerySystemInformation(SystemBasicInformation, - &SysBasicInfo, - sizeof(SysBasicInfo), - NULL); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - - Status = ZwQuerySystemInformation(SystemPerformanceInformation, - &SysPerfInfo, - sizeof(SysPerfInfo), - NULL); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - - Status = ZwQuerySystemInformation(SystemFullMemoryInformation, - &UserMemory, - sizeof(ULONG), - NULL); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - -/* - * Load percentage 0 thru 100. 0 is good and 100 is bad. - * - * Um = allocated memory / physical memory - * Um = 177 MB / 256 MB = 69.1% - * - * Mult allocated memory by 100 to move decimal point up. - */ - lpBuffer->dwMemoryLoad = (SysBasicInfo.NumberOfPhysicalPages - - SysPerfInfo.AvailablePages) * 100 / - SysBasicInfo.NumberOfPhysicalPages; - - DPRINT1("Memory Load: %d%%\n",lpBuffer->dwMemoryLoad ); - - lpBuffer->ullTotalPhys = SysBasicInfo.NumberOfPhysicalPages * - SysBasicInfo.PageSize; - lpBuffer->ullAvailPhys = SysPerfInfo.AvailablePages * - SysBasicInfo.PageSize; - - DPRINT("%d\n",SysPerfInfo.AvailablePages ); - DPRINT("%d\n",lpBuffer->ullAvailPhys ); - - lpBuffer->ullTotalPageFile = SysPerfInfo.CommitLimit * - SysBasicInfo.PageSize; - - DPRINT("%d\n",lpBuffer->ullTotalPageFile ); - - lpBuffer->ullAvailPageFile = ((SysPerfInfo.CommitLimit - - SysPerfInfo.CommittedPages) * - SysBasicInfo.PageSize); - -/* VM available to the calling processes, User Mem? */ - lpBuffer->ullTotalVirtual = SysBasicInfo.MaximumUserModeAddress - - SysBasicInfo.MinimumUserModeAddress; - - lpBuffer->ullAvailVirtual = (lpBuffer->ullTotalVirtual - - (UserMemory * - SysBasicInfo.PageSize)); - - DPRINT("%d\n",lpBuffer->ullAvailVirtual ); - DPRINT("%d\n",UserMemory); - DPRINT("%d\n",SysBasicInfo.PageSize); - -/* lol! Memory from beyond! */ - lpBuffer->ullAvailExtendedVirtual = 0; - return TRUE; -} - -/* - * @implemented - */ -VOID STDCALL -GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer) -{ - MEMORYSTATUSEX lpBufferEx; -#if 0 - if (lpBuffer->dwLength != sizeof(MEMORYSTATUS)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return; - } -#endif - lpBufferEx.dwLength = sizeof(MEMORYSTATUSEX); - - if (GlobalMemoryStatusEx(&lpBufferEx)) - { - - lpBuffer->dwLength = sizeof(MEMORYSTATUS); - - lpBuffer->dwMemoryLoad = lpBufferEx.dwMemoryLoad; - lpBuffer->dwTotalPhys = lpBufferEx.ullTotalPhys; - lpBuffer->dwAvailPhys = lpBufferEx.ullAvailPhys; - lpBuffer->dwTotalPageFile = lpBufferEx.ullTotalPageFile; - lpBuffer->dwAvailPageFile = lpBufferEx.ullAvailPageFile; - lpBuffer->dwTotalVirtual = lpBufferEx.ullTotalVirtual; - lpBuffer->dwAvailVirtual = lpBufferEx.ullAvailVirtual; - } -} - - -HGLOBAL STDCALL -GlobalReAlloc(HGLOBAL hMem, - DWORD dwBytes, - UINT uFlags) -{ - - LPVOID palloc = 0; - HGLOBAL hnew = 0; - PGLOBAL_HANDLE phandle = 0; - ULONG heap_flags = 0; - - DPRINT("GlobalReAlloc( 0x%lX, 0x%lX, 0x%X )\n", (ULONG)hMem, dwBytes, uFlags); - - if (uFlags & GMEM_ZEROINIT) - { - heap_flags = HEAP_ZERO_MEMORY; - } - - HeapLock(GetProcessHeap()); - - if(uFlags & GMEM_MODIFY) /* modify flags */ - { - if( ISPOINTER(hMem) && (uFlags & GMEM_MOVEABLE)) - { - /* make a fixed block moveable - * actually only NT is able to do this. And it's soo simple - */ - if (0 == hMem) - { - SetLastError( ERROR_NOACCESS ); - hnew = 0; - } - else - { - dwBytes = RtlSizeHeap(GetProcessHeap(), 0, (LPVOID) hMem); - hnew = GlobalAlloc( uFlags, dwBytes); - palloc = GlobalLock(hnew); - memcpy(palloc, (LPVOID) hMem, dwBytes); - GlobalUnlock(hnew); - RtlFreeHeap(GetProcessHeap(),0,hMem); - } - } - else if(ISPOINTER(hMem) && (uFlags & GMEM_DISCARDABLE)) - { - /* change the flags to make our block "discardable" */ - phandle = HANDLE_TO_INTERN(hMem); - phandle->Flags = phandle->Flags | (GMEM_DISCARDABLE >> 8); - hnew = hMem; - } - else - { - SetLastError(ERROR_INVALID_PARAMETER); - hnew = 0; - } - } - else - { - if(ISPOINTER(hMem)) - { - if (!(uFlags & GMEM_MOVEABLE)) - { - heap_flags |= HEAP_REALLOC_IN_PLACE_ONLY; - } - - /* reallocate fixed memory */ - hnew = (HANDLE)RtlReAllocateHeap(GetProcessHeap(), heap_flags, (LPVOID) hMem, dwBytes); - } - else - { - /* reallocate a moveable block */ - phandle= HANDLE_TO_INTERN(hMem); - hnew = hMem; - - if (0 != dwBytes) - { - if(phandle->Pointer) - { - - if (phandle->LockCount && !(uFlags & GMEM_MOVEABLE)) - { - /* Locked memory cant normally move but the MEM_MOVEABLE flag - * override this behaviour. But in this case that flag was not passed. - */ - heap_flags |= HEAP_REALLOC_IN_PLACE_ONLY; - } - - palloc = RtlReAllocateHeap(GetProcessHeap(), heap_flags, - (PVOID)((ULONG_PTR)phandle->Pointer - HANDLE_SIZE), - dwBytes + HANDLE_SIZE); - if (0 == palloc) - { - hnew = 0; - } - else - { - *(PHANDLE)palloc = hMem; - phandle->Pointer = (PVOID)((ULONG_PTR)palloc + HANDLE_SIZE); - } - } - else - { - palloc = RtlAllocateHeap(GetProcessHeap(), heap_flags, dwBytes + HANDLE_SIZE); - if (0 == palloc) - { - hnew = 0; - } - else - { - *(PHANDLE)palloc = hMem; - phandle->Pointer = (PVOID)((ULONG_PTR)palloc + HANDLE_SIZE); - } - } - } - else - { - if(phandle->Pointer) + /* Otherwise, we're allocating, so set the new flags needed */ + Flags |= HEAP_SETTABLE_USER_VALUE | GLOBAL_HEAP_FLAG_MOVABLE; + if (!Ptr) { - RtlFreeHeap(GetProcessHeap(), 0, (PVOID)((ULONG_PTR)phandle->Pointer - HANDLE_SIZE)); - phandle->Pointer = 0; + /* We don't have a base, so allocate one */ + Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes); + BASE_TRACE_ALLOC2(Ptr); + if (Ptr) + { + /* Allocation succeeded, so save our entry */ + RtlSetUserValueHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + Ptr, + hMem); + } + } + else + { + /* + * If it's not movable or currently locked, we MUST allocate + * in-place! + */ + if (!(uFlags & GMEM_MOVEABLE) && (HandleEntry->LockCount)) + { + /* Set the flag */ + Flags |= HEAP_REALLOC_IN_PLACE_ONLY; + } + else + { + /* Otherwise clear the flag if we set it previously */ + Flags &= ~HEAP_REALLOC_IN_PLACE_ONLY; + } + + /* And do the re-allocation */ + Ptr = RtlReAllocateHeap(hProcessHeap, Flags, Ptr, dwBytes); + } + + /* Make sure we have a pointer by now */ + if (Ptr) + { + /* Write it in the handle entry and mark it in use */ + HandleEntry->Object = Ptr; + HandleEntry->Flags &= ~GLOBAL_HEAP_ENTRY_FLAG_REUSE; + } + else + { + /* Otherwise we failed */ + hMem = NULL; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); } } } } - - HeapUnlock(GetProcessHeap()); - - return hnew; -} - - -DWORD STDCALL -GlobalSize(HGLOBAL hMem) -{ - SIZE_T retval = 0; - PGLOBAL_HANDLE phandle = 0; - - DPRINT("GlobalSize( 0x%lX )\n", (ULONG)hMem); - - if(ISPOINTER(hMem)) /*FIXED*/ - { - retval = RtlSizeHeap(GetProcessHeap(), 0, hMem); - } - else /*MOVEABLE*/ - { - HeapLock(GetProcessHeap()); - - phandle = HANDLE_TO_INTERN(hMem); - - if (MAGIC_GLOBAL_USED == phandle->Magic) - { - if (0 != phandle->Pointer)/*NOT DISCARDED*/ + else if (uFlags & GMEM_MODIFY) + { + /* This is not a handle-based heap and the caller wants it to be one */ + if (uFlags & GMEM_MOVEABLE) + { + /* Get information on its current state */ + Handle = hMem; + DPRINT1("h h %lx %lx\n", Handle, hMem); + RtlGetUserInfoHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + hMem, + &Handle, + &Flags); + DPRINT1("h h %lx %lx\n", Handle, hMem); + + /* + * Check if the handle matches the pointer or if the moveable flag + * isn't there, which is what we expect since it currenly isn't. + */ + if (Handle == hMem || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) { - retval = RtlSizeHeap(GetProcessHeap(), 0, (PVOID)((ULONG_PTR)phandle->Pointer - HANDLE_SIZE)); - - if (retval == (SIZE_T)-1) /*RtlSizeHeap failed*/ + /* Allocate a handle for it */ + HandleEntry = GlobalAllocEntry(); + + /* Calculate the size of the current heap */ + dwBytes = RtlSizeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem); + + /* Set the movable flag */ + Flags |= HEAP_SETTABLE_USER_VALUE | GLOBAL_HEAP_FLAG_MOVABLE; + + /* Now allocate the actual heap for it */ + HandleEntry->Object = RtlAllocateHeap(hProcessHeap, + Flags, + dwBytes); + BASE_TRACE_PTR(HandleEntry->Object, HandleEntry); + if (!HandleEntry->Object) { /* - **TODO: RtlSizeHeap does not set last error. - ** We should choose an error value to set as - ** the last error. Which One? - */ - DPRINT("GlobalSize: RtlSizeHeap failed.\n"); - retval = 0; + * We failed, manually set the allocate flag and + * free the handle + */ + HandleEntry->Flags = RTL_HANDLE_VALID; + GlobalFreeEntry(HandleEntry); + + /* For the cleanup case */ + BASE_TRACE_FAILURE(); + HandleEntry = NULL; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); } - else /*Everything is ok*/ + else { - retval = retval - HANDLE_SIZE; + /* Otherwise, copy the current heap and free the old one */ + RtlMoveMemory(HandleEntry->Object, hMem, dwBytes); + RtlFreeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem); + + /* Select the heap pointer */ + hMem = (HANDLE)&HandleEntry->Object; + + /* Initialize the count and default flags */ + HandleEntry->LockCount = 0; + HandleEntry->Flags = RTL_HANDLE_VALID | + GLOBAL_HEAP_ENTRY_FLAG_MOVABLE; + + /* Check if it's also discardable */ + if (uFlags & GMEM_DISCARDABLE) + { + /* Set the internal flag */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_REUSABLE; + } + + /* Check if it's also DDE Shared */ + if (uFlags & GMEM_DDESHARE) + { + /* Set the internal flag */ + HandleEntry->Flags |= GLOBAL_HEAP_ENTRY_FLAG_DDESHARE; + } + + /* Allocation succeeded, so save our entry */ + RtlSetUserValueHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + HandleEntry->Object, + hMem); } } } + } + else + { + /* Otherwise, this is a simple RTL Managed Heap, so just call it */ + hMem = RtlReAllocateHeap(hProcessHeap, + Flags | HEAP_NO_SERIALIZE, + hMem, + dwBytes); + if (!hMem) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + } + } + + /* All done, unlock the heap and return the pointer */ + RtlUnlockHeap(hProcessHeap); + return hMem; +} + +/* + * @implemented + */ +DWORD +NTAPI +GlobalSize(HGLOBAL hMem) +{ + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + PVOID Handle = NULL; + ULONG Flags = 0; + SIZE_T dwSize = MAXULONG_PTR; + + /* Lock the heap */ + RtlLockHeap(hProcessHeap); + + /* Check if this is a simple RTL Heap Managed block */ + if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) + { + /* Then we'll query RTL Heap */ + RtlGetUserInfoHeap(hProcessHeap, Flags, hMem, &Handle, &Flags); + BASE_TRACE_PTR(Handle, hMem); + + /* + * Check if RTL Heap didn't give us a handle or said that this heap + * isn't movable. + */ + if (!(Handle) || !(Flags & GLOBAL_HEAP_FLAG_MOVABLE)) + { + /* This implies we're not a handle heap, so use the generic call */ + dwSize = RtlSizeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem); + } else { - DPRINT("GlobalSize: invalid handle\n"); - } - HeapUnlock(GetProcessHeap()); - } - return retval; -} - - -/* - * @implemented - */ -VOID STDCALL + /* Otherwise we're a handle heap, so get the internal handle */ + hMem = Handle; + } + } + + /* Make sure that this is an entry in our handle database */ + if ((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY) + { + /* Get the entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure the handle is valid */ + if (!GlobalValidateEntry(HandleEntry)) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + } + else if (HandleEntry->Flags & GLOBAL_HEAP_ENTRY_FLAG_REUSE) + { + /* We've reused this block, but we've saved the size for you */ + dwSize = HandleEntry->OldSize; + } + else + { + /* Otherwise, query RTL about it */ + dwSize = RtlSizeHeap(hProcessHeap, + HEAP_NO_SERIALIZE, + HandleEntry->Object); + } + } + + /* Check if by now, we still haven't gotten any useful size */ + if (dwSize == MAXULONG_PTR) + { + /* Fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + dwSize = 0; + } + + /* All done! Unlock heap and return the size */ + RtlUnlockHeap(hProcessHeap); + return dwSize; +} + +/* + * @implemented + */ +VOID +NTAPI GlobalUnfix(HGLOBAL hMem) { - if (hMem != INVALID_HANDLE_VALUE) - GlobalUnlock(hMem); -} - - -/* - * @implemented - */ -BOOL STDCALL + /* If the handle is valid, unlock it */ + if (hMem != INVALID_HANDLE_VALUE) GlobalUnlock(hMem); +} + +/* + * @implemented + */ +BOOL +NTAPI GlobalUnlock(HGLOBAL hMem) { - - PGLOBAL_HANDLE phandle; - BOOL locked = FALSE; - - DPRINT("GlobalUnlock( 0x%lX )\n", (ULONG)hMem); - - if(ISPOINTER(hMem)) - { - SetLastError(ERROR_NOT_LOCKED); - return FALSE; - } - - HeapLock(GetProcessHeap()); - - phandle = HANDLE_TO_INTERN(hMem); - if(MAGIC_GLOBAL_USED == phandle->Magic) - { - if (0 >= phandle->LockCount) - { - locked = FALSE; - SetLastError(ERROR_NOT_LOCKED); - } - else if (GLOBAL_LOCK_MAX > phandle->LockCount) - { - phandle->LockCount--; - locked = (0 != phandle->LockCount) ? TRUE : FALSE; - SetLastError(NO_ERROR); - } - } - else - { - DPRINT("GlobalUnlock: invalid handle\n"); - locked = FALSE; - } - HeapUnlock(GetProcessHeap()); - return locked; -} - - -/* - * @implemented - */ -BOOL STDCALL + PGLOBAL_HEAP_HANDLE_ENTRY HandleEntry; + BOOL RetVal = TRUE; + + /* Check if this was a simple allocated heap entry */ + if (!((ULONG_PTR)hMem & GLOBAL_HEAP_IS_HANDLE_ENTRY)) return RetVal; + + /* Otherwise, lock the heap */ + RtlLockHeap(hProcessHeap); + + /* Get the handle entry */ + HandleEntry = GlobalGetEntry(hMem); + BASE_TRACE_HANDLE(HandleEntry, hMem); + + /* Make sure it's valid */ + if (!GlobalValidateEntry(HandleEntry)) + { + /* It's not, fail */ + BASE_TRACE_FAILURE(); + SetLastError(ERROR_INVALID_HANDLE); + } + else + { + /* Otherwise, decrement lock count, unless we're already at 0*/ + if (!HandleEntry->LockCount--) + { + /* In which case we simply lock it back and fail */ + HandleEntry->LockCount++; + SetLastError(ERROR_NOT_LOCKED); + RetVal = FALSE; + } + else if (!HandleEntry->LockCount) + { + /* Nothing to unlock */ + SetLastError(NO_ERROR); + RetVal = FALSE; + } + } + + /* All done. Unlock the heap and return the pointer */ + RtlUnlockHeap(hProcessHeap); + return RetVal; +} + +/* + * @implemented + */ +BOOL +NTAPI GlobalUnWire(HGLOBAL hMem) { - return GlobalUnlock(hMem); -} - - -/* - * @implemented - */ -LPVOID STDCALL + /* This is simply an unlock */ + return GlobalUnlock(hMem); +} + +/* + * @implemented + */ +LPVOID +NTAPI GlobalWire(HGLOBAL hMem) { - return GlobalLock(hMem); + /* This is just a lock */ + return GlobalLock(hMem); +} + +/* + * @implemented + */ +BOOL +NTAPI +GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer) +{ + SYSTEM_PERFORMANCE_INFORMATION PerformanceInfo; + VM_COUNTERS VmCounters; + QUOTA_LIMITS QuotaLimits; + ULONGLONG PageFile, PhysicalMemory; + + /* Query performance information */ + NtQuerySystemInformation(SystemPerformanceInformation, + &PerformanceInfo, + sizeof(PerformanceInfo), + NULL); + + /* Calculate memory load */ + lpBuffer->dwMemoryLoad = ((DWORD)(BaseCachedSysInfo.NumberOfPhysicalPages - + PerformanceInfo.AvailablePages) * 100) / + BaseCachedSysInfo.NumberOfPhysicalPages; + + /* Save physical memory */ + PhysicalMemory = BaseCachedSysInfo.NumberOfPhysicalPages * + BaseCachedSysInfo.PageSize; + lpBuffer->ullTotalPhys = PhysicalMemory; + + /* Now save available physical memory */ + PhysicalMemory = PerformanceInfo.AvailablePages * + BaseCachedSysInfo.PageSize; + lpBuffer->ullAvailPhys = PhysicalMemory; + + /* Query VM and Quota Limits */ + NtQueryInformationProcess(NtCurrentProcess(), + ProcessQuotaLimits, + &QuotaLimits, + sizeof(QUOTA_LIMITS), + NULL); + NtQueryInformationProcess(NtCurrentProcess(), + ProcessVmCounters, + &VmCounters, + sizeof(VM_COUNTERS), + NULL); + + /* Save the commit limit */ + lpBuffer->ullTotalPageFile = min(QuotaLimits.PagefileLimit, + PerformanceInfo.CommitLimit); + + /* Calculate how many pages are left */ + PageFile = PerformanceInfo.CommitLimit - PerformanceInfo.CommittedPages; + + /* Save the total */ + lpBuffer->ullAvailPageFile = min(PageFile, + QuotaLimits.PagefileLimit - + VmCounters.PagefileUsage); + lpBuffer->ullAvailPageFile *= BaseCachedSysInfo.PageSize; + + /* Now calculate the total virtual space */ + lpBuffer->ullTotalVirtual = (BaseCachedSysInfo.MaximumUserModeAddress - + BaseCachedSysInfo.MinimumUserModeAddress) + 1; + + /* And finally the avilable virtual space */ + lpBuffer->ullAvailVirtual = lpBuffer->ullTotalVirtual - + VmCounters.VirtualSize; + lpBuffer->ullAvailExtendedVirtual = 0; + return TRUE; +} + +/* + * @implemented + */ +VOID +NTAPI +GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer) +{ + MEMORYSTATUSEX lpBufferEx; + + /* Call the extended function */ + lpBufferEx.dwLength = sizeof(MEMORYSTATUSEX); + if (GlobalMemoryStatusEx(&lpBufferEx)) + { + /* Reset the right size and fill out the information */ + lpBuffer->dwLength = sizeof(MEMORYSTATUS); + lpBuffer->dwMemoryLoad = lpBufferEx.dwMemoryLoad; + lpBuffer->dwTotalPhys = lpBufferEx.ullTotalPhys; + lpBuffer->dwAvailPhys = lpBufferEx.ullAvailPhys; + lpBuffer->dwTotalPageFile = lpBufferEx.ullTotalPageFile; + lpBuffer->dwAvailPageFile = lpBufferEx.ullAvailPageFile; + lpBuffer->dwTotalVirtual = lpBufferEx.ullTotalVirtual; + lpBuffer->dwAvailVirtual = lpBufferEx.ullAvailVirtual; + } } /* EOF */ Modified: trunk/reactos/dll/win32/kernel32/misc/dllmain.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/misc/dl… ============================================================================== --- trunk/reactos/dll/win32/kernel32/misc/dllmain.c (original) +++ trunk/reactos/dll/win32/kernel32/misc/dllmain.c Sat Jun 24 22:11:57 2006 @@ -339,6 +339,9 @@ } hProcessHeap = RtlGetProcessHeap(); + RtlInitializeHandleTable(0xFFFF, + sizeof(GLOBAL_HEAP_HANDLE_ENTRY), + &BaseGlobalHandleTable); hCurrentModule = hDll; DPRINT("Heap: %p\n", hProcessHeap);

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs