Ros-diffs October 2009

ros-diffs@reactos.org

26 participants
641 discussions

[fireball] 43649: - Fix dgorbachev's copypasta.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 16:46:02 2009 New Revision: 43649 URL: http://svn.reactos.org/svn/reactos?rev=43649&view=rev Log: - Fix dgorbachev's copypasta. Modified: trunk/reactos/lib/atl/atlbase.h Modified: trunk/reactos/lib/atl/atlbase.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlbase.h?rev=4364… ============================================================================== --- trunk/reactos/lib/atl/atlbase.h [iso-8859-1] (original) +++ trunk/reactos/lib/atl/atlbase.h [iso-8859-1] Tue Oct 20 16:46:02 2009 @@ -248,9 +248,9 @@ { return ( ((unsigned long *)&rguid1)[0] == ((unsigned long *)&rguid2)[0] && - ((unsigned long *)&rguid1)[1] == ((unsigned long *)&rguid1)[1] && - ((unsigned long *)&rguid1)[2] == ((unsigned long *)&rguid1)[2] && - ((unsigned long *)&rguid1)[3] == ((unsigned long *)&rguid1)[3]); + ((unsigned long *)&rguid1)[1] == ((unsigned long *)&rguid2)[1] && + ((unsigned long *)&rguid1)[2] == ((unsigned long *)&rguid2)[2] && + ((unsigned long *)&rguid1)[3] == ((unsigned long *)&rguid2)[3]); } class CComMultiThreadModelNoCS

1 0

[gadamopoulos] 43648: Fix two user32 resource tests
by gadamopoulos＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: gadamopoulos Date: Tue Oct 20 16:42:08 2009 New Revision: 43648 URL: http://svn.reactos.org/svn/reactos?rev=43648&view=rev Log: Fix two user32 resource tests Modified: trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c Modified: trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/nt… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c [iso-8859-1] (original) +++ trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c [iso-8859-1] Tue Oct 20 16:42:08 2009 @@ -384,6 +384,15 @@ { Accel->Table[Index].key = Entries[Index].key; } + else + { + RtlMultiByteToUnicodeN(&Accel->Table[Index].key, + sizeof(WCHAR), + NULL, + (PCSTR)&Entries[Index].key, + sizeof(CHAR)); + } + Accel->Table[Index].cmd = Entries[Index].cmd; }

1 0

[dgorbachev] 43647: Fix build.
by dgorbachev＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: dgorbachev Date: Tue Oct 20 16:33:31 2009 New Revision: 43647 URL: http://svn.reactos.org/svn/reactos?rev=43647&view=rev Log: Fix build. Modified: trunk/reactos/lib/atl/atlbase.h Modified: trunk/reactos/lib/atl/atlbase.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlbase.h?rev=4364… ============================================================================== --- trunk/reactos/lib/atl/atlbase.h [iso-8859-1] (original) +++ trunk/reactos/lib/atl/atlbase.h [iso-8859-1] Tue Oct 20 16:33:31 2009 @@ -244,6 +244,15 @@ ((unsigned long *)&rguid1)[3] == 0x46000000); } +inline BOOL WINAPI InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2) +{ + return ( + ((unsigned long *)&rguid1)[0] == ((unsigned long *)&rguid2)[0] && + ((unsigned long *)&rguid1)[1] == ((unsigned long *)&rguid1)[1] && + ((unsigned long *)&rguid1)[2] == ((unsigned long *)&rguid1)[2] && + ((unsigned long *)&rguid1)[3] == ((unsigned long *)&rguid1)[3]); +} + class CComMultiThreadModelNoCS { public:

1 0

[fireball] 43646: [fastfat_new] - Implement root directory open operation. - Add OpenCount counter to FCB.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 14:51:13 2009 New Revision: 43646 URL: http://svn.reactos.org/svn/reactos?rev=43646&view=rev Log: [fastfat_new] - Implement root directory open operation. - Add OpenCount counter to FCB. Modified: trunk/reactos/drivers/filesystems/fastfat_new/create.c trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h Modified: trunk/reactos/drivers/filesystems/fastfat_new/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] Tue Oct 20 14:51:13 2009 @@ -23,10 +23,64 @@ IN ULONG CreateDisposition) { IO_STATUS_BLOCK Iosb; - - DPRINT1("Opening root directory\n"); - - Iosb.Status = STATUS_NOT_IMPLEMENTED; + PFCB Dcb; + NTSTATUS Status; + PCCB Ccb; + + /* Reference our DCB */ + Dcb = Vcb->RootDcb; + + DPRINT("Opening root directory\n"); + + /* Exclusively lock this DCB */ + (VOID)FatAcquireExclusiveFcb(IrpContext, Dcb); + + do + { + /* Validate parameters */ + if (CreateDisposition != FILE_OPEN && + CreateDisposition != FILE_OPEN_IF) + { + Iosb.Status = STATUS_ACCESS_DENIED; + break; + } + + // TODO: Check file access + + /* Is it a first time open? */ + if (Dcb->OpenCount == 0) + { + /* Set share access */ + IoSetShareAccess(*DesiredAccess, + ShareAccess, + FileObject, + &Dcb->ShareAccess); + } + else + { + /* Check share access */ + Status = IoCheckShareAccess(*DesiredAccess, + ShareAccess, + FileObject, + &Dcb->ShareAccess, + TRUE); + } + + /* Set file object pointers */ + Ccb = FatCreateCcb(IrpContext); + FatSetFileObject(FileObject, UserDirectoryOpen, Dcb, Ccb); + + /* Increment counters */ + Dcb->OpenCount++; + Vcb->OpenFileCount++; + + /* Set success statuses */ + Iosb.Status = STATUS_SUCCESS; + Iosb.Information = FILE_OPENED; + } while (FALSE); + + /* Release the DCB lock */ + FatReleaseFcb(IrpContext, Dcb); return Iosb; } Modified: trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h [iso-8859-1] Tue Oct 20 14:51:13 2009 @@ -305,6 +305,8 @@ ULONG OutstandingAsyncWrites; /* The outstanding async writes sync event */ PKEVENT OutstandingAsyncEvent; + /* Counters */ + ULONG OpenCount; union { struct

1 0

[ahill] 43645: [atlnew] - Initial checkin of minimal atl library - To prevent conflicts with wine atl dll, this library is named atlnew
by ahill＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: ahill Date: Tue Oct 20 14:26:51 2009 New Revision: 43645 URL: http://svn.reactos.org/svn/reactos?rev=43645&view=rev Log: [atlnew] - Initial checkin of minimal atl library - To prevent conflicts with wine atl dll, this library is named atlnew Added: trunk/reactos/lib/atl/ trunk/reactos/lib/atl/atl.rbuild (with props) trunk/reactos/lib/atl/atlbase.cpp (with props) trunk/reactos/lib/atl/atlbase.h (with props) trunk/reactos/lib/atl/atlcom.h (with props) trunk/reactos/lib/atl/atlcore.cpp (with props) trunk/reactos/lib/atl/atlcore.h (with props) trunk/reactos/lib/atl/atlwin.h (with props) trunk/reactos/lib/atl/statreg.h (with props) Modified: trunk/reactos/lib/lib.rbuild Added: trunk/reactos/lib/atl/atl.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atl.rbuild?rev=436… ============================================================================== --- trunk/reactos/lib/atl/atl.rbuild (added) +++ trunk/reactos/lib/atl/atl.rbuild [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,10 @@ +<?xml version="1.0"?> +<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd"> +<module name="atlnew" type="staticlibrary"> + <include base="atlnew">.</include> + <define name="UNICODE" /> + <define name="_UNICODE" /> + <define name="ROS_Headers" /> + <file>atlbase.cpp</file> + <file>atlcore.cpp</file> +</module> Propchange: trunk/reactos/lib/atl/atl.rbuild ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlbase.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlbase.cpp?rev=43… ============================================================================== --- trunk/reactos/lib/atl/atlbase.cpp (added) +++ trunk/reactos/lib/atl/atlbase.cpp [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,33 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <windows.h> +#include <tchar.h> +#include <ocidl.h> +#include "atlbase.h" + +namespace ATL +{ + +CAtlBaseModule _AtlBaseModule; +CAtlWinModule _AtlWinModule = CAtlWinModule(); +CAtlComModule _AtlComModule; + +}; // namespace ATL Propchange: trunk/reactos/lib/atl/atlbase.cpp ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlbase.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlbase.h?rev=4364… ============================================================================== --- trunk/reactos/lib/atl/atlbase.h (added) +++ trunk/reactos/lib/atl/atlbase.h [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,965 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _atlbase_h +#define _atlbase_h + +#include "atlcore.h" +#include "statreg.h" + +#ifdef _MSC_VER +// It is common to use this in ATL constructors. They only store this for later use, so the usage is safe. +#pragma warning(disable:4355) +#endif + +#ifndef _ATL_PACKING +#define _ATL_PACKING 8 +#endif + +#ifndef _ATL_FREE_THREADED +#ifndef _ATL_APARTMENT_THREADED +#ifndef _ATL_SINGLE_THREADED +#define _ATL_FREE_THREADED +#endif +#endif +#endif + +#ifndef ATLTRY +#define ATLTRY(x) x; +#endif + +#ifdef _ATL_DISABLE_NO_VTABLE +#define ATL_NO_VTABLE +#else +#define ATL_NO_VTABLE __declspec(novtable) +#endif + +#define offsetofclass(base, derived) (reinterpret_cast<DWORD_PTR>(static_cast<base *>(reinterpret_cast<derived *>(_ATL_PACKING))) - _ATL_PACKING) + +extern "C" IMAGE_DOS_HEADER __ImageBase; + +namespace ATL +{ + +class CAtlModule; +class CComModule; +class CAtlComModule; +__declspec(selectany) CAtlModule *_pAtlModule = NULL; +__declspec(selectany) CComModule *_pModule = NULL; +extern CAtlComModule _AtlComModule; + +typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void *pv, REFIID riid, LPVOID *ppv); +typedef LPCTSTR (WINAPI _ATL_DESCRIPTIONFUNC)(); +typedef const struct _ATL_CATMAP_ENTRY * (_ATL_CATMAPFUNC)(); + +struct _ATL_OBJMAP_ENTRY30 +{ + const CLSID *pclsid; + HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister); + _ATL_CREATORFUNC *pfnGetClassObject; + _ATL_CREATORFUNC *pfnCreateInstance; + IUnknown *pCF; + DWORD dwRegister; + _ATL_DESCRIPTIONFUNC *pfnGetObjectDescription; + _ATL_CATMAPFUNC *pfnGetCategoryMap; + void (WINAPI *pfnObjectMain)(bool bStarting); + + HRESULT WINAPI RevokeClassObject() + { + if (dwRegister == 0) + return S_OK; + return CoRevokeClassObject(dwRegister); + } + + HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags) + { + IUnknown *p; + HRESULT hResult; + + p = NULL; + if (pfnGetClassObject == NULL) + return S_OK; + + hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p)); + if (SUCCEEDED(hResult)) + hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister); + + if (p != NULL) + p->Release(); + + return hResult; + } +}; + +typedef _ATL_OBJMAP_ENTRY30 _ATL_OBJMAP_ENTRY; + +typedef void (__stdcall _ATL_TERMFUNC)(DWORD_PTR dw); + +struct _ATL_TERMFUNC_ELEM +{ + _ATL_TERMFUNC *pFunc; + DWORD_PTR dw; + _ATL_TERMFUNC_ELEM *pNext; +}; + +struct _ATL_MODULE70 +{ + UINT cbSize; + LONG m_nLockCnt; + _ATL_TERMFUNC_ELEM *m_pTermFuncs; + CComCriticalSection m_csStaticDataInitAndTypeInfo; +}; +typedef _ATL_MODULE70 _ATL_MODULE; + +typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void *pv, REFIID riid, LPVOID *ppv, DWORD_PTR dw); + +#define _ATL_SIMPLEMAPENTRY ((ATL::_ATL_CREATORARGFUNC *)1) + +struct _ATL_INTMAP_ENTRY +{ + const IID *piid; + DWORD_PTR dw; + _ATL_CREATORARGFUNC *pFunc; +}; + +struct _AtlCreateWndData +{ + void *m_pThis; + DWORD m_dwThreadID; + _AtlCreateWndData *m_pNext; +}; + +struct _ATL_COM_MODULE70 +{ + UINT cbSize; + HINSTANCE m_hInstTypeLib; + _ATL_OBJMAP_ENTRY **m_ppAutoObjMapFirst; + _ATL_OBJMAP_ENTRY **m_ppAutoObjMapLast; + CComCriticalSection m_csObjMap; +}; +typedef _ATL_COM_MODULE70 _ATL_COM_MODULE; + +struct _ATL_WIN_MODULE70 +{ + UINT cbSize; + CComCriticalSection m_csWindowCreate; + _AtlCreateWndData *m_pCreateWndList; +#ifdef NOTYET + CSimpleArray<ATOM> m_rgWindowClassAtoms; +#endif +}; +typedef _ATL_WIN_MODULE70 _ATL_WIN_MODULE; + +struct _ATL_REGMAP_ENTRY +{ + LPCOLESTR szKey; + LPCOLESTR szData; +}; + +HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule); +HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst); +HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject); +void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject); +void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule); +HRESULT __stdcall AtlComModuleGetClassObject(_ATL_COM_MODULE *pComModule, REFCLSID rclsid, REFIID riid, LPVOID *ppv); + +template<class TLock> +class CComCritSecLock +{ +private: + bool m_bLocked; + TLock &m_cs; +public: + CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs) + { + HRESULT hResult; + + m_bLocked = false; + if (bInitialLock) + { + hResult = Lock(); + if (FAILED(hResult)) + { + ATLASSERT(false); + } + } + } + + ~CComCritSecLock() + { + if (m_bLocked) + Unlock(); + } + + HRESULT Lock() + { + HRESULT hResult; + + ATLASSERT(!m_bLocked); + hResult = m_cs.Lock(); + if (FAILED(hResult)) + return hResult; + m_bLocked = true; + + return S_OK; + } + + void Unlock() + { + HRESULT hResult; + + ATLASSERT(m_bLocked); + hResult = m_cs.Unlock(); + if (FAILED(hResult)) + { + ATLASSERT(false); + } + m_bLocked = false; + } +}; + +inline BOOL WINAPI InlineIsEqualUnknown(REFGUID rguid1) +{ + return ( + ((unsigned long *)&rguid1)[0] == 0 && + ((unsigned long *)&rguid1)[1] == 0 && + ((unsigned long *)&rguid1)[2] == 0x000000C0 && + ((unsigned long *)&rguid1)[3] == 0x46000000); +} + +class CComMultiThreadModelNoCS +{ +public: + typedef CComFakeCriticalSection AutoCriticalSection; + typedef CComFakeCriticalSection CriticalSection; + typedef CComMultiThreadModelNoCS ThreadModelNoCS; + typedef CComFakeCriticalSection AutoDeleteCriticalSection; + + static ULONG WINAPI Increment(LPLONG p) + { + return InterlockedIncrement(p); + } + + static ULONG WINAPI Decrement(LPLONG p) + { + return InterlockedDecrement(p); + } +}; + +class CComMultiThreadModel +{ +public: + typedef CComAutoCriticalSection AutoCriticalSection; + typedef CComCriticalSection CriticalSection; + typedef CComMultiThreadModelNoCS ThreadModelNoCS; + typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection; + + static ULONG WINAPI Increment(LPLONG p) + { + return InterlockedIncrement(p); + } + + static ULONG WINAPI Decrement(LPLONG p) + { + return InterlockedDecrement(p); + } +}; + +class CComSingleThreadModel +{ +public: + typedef CComFakeCriticalSection AutoCriticalSection; + typedef CComFakeCriticalSection CriticalSection; + typedef CComSingleThreadModel ThreadModelNoCS; + typedef CComFakeCriticalSection AutoDeleteCriticalSection; + + static ULONG WINAPI Increment(LPLONG p) + { + return ++*p; + } + + static ULONG WINAPI Decrement(LPLONG p) + { + return --*p; + } +}; + +#if defined(_ATL_FREE_THREADED) + + typedef CComMultiThreadModel CComObjectThreadModel; + typedef CComMultiThreadModel CComGlobalsThreadModel; + +#elif defined(_ATL_APARTMENT_THREADED) + + typedef CComSingleThreadModel CComObjectThreadModel; + typedef CComMultiThreadModel CComGlobalsThreadModel; + +#elif defined(_ATL_SINGLE_THREADED) + + typedef CComSingleThreadModel CComObjectThreadModel; + typedef CComSingleThreadModel CComGlobalsThreadModel; + +#else +#error No threading model +#endif + +class CAtlModule : public _ATL_MODULE +{ +public: + CAtlModule() + { + ATLASSERT(_pAtlModule == NULL); + _pAtlModule = this; + cbSize = sizeof(_ATL_MODULE); + m_nLockCnt = 0; + } + + virtual LONG GetLockCount() + { + return m_nLockCnt; + } + + virtual LONG Lock() + { + return CComGlobalsThreadModel::Increment(&m_nLockCnt); + } + + virtual LONG Unlock() + { + return CComGlobalsThreadModel::Decrement(&m_nLockCnt); + } + + virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0; + + HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL) + { + CRegObject registrar; + TCHAR modulePath[MAX_PATH]; + HRESULT hResult; + + hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries); + if (FAILED(hResult)) + return hResult; + + if (bRegister != FALSE) + hResult = registrar.ResourceRegisterSz(modulePath, lpszRes, _T("REGISTRY")); + else + hResult = registrar.ResourceUnregisterSz(modulePath, lpszRes, _T("REGISTRY")); + + return hResult; + } + + HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL) + { + CRegObject registrar; + TCHAR modulePath[MAX_PATH]; + HRESULT hResult; + + hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries); + if (FAILED(hResult)) + return hResult; + + if (bRegister != FALSE) + hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY")); + else + hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY")); + + return hResult; + } + +private: + HRESULT CommonInitRegistrar(CRegObject &registrar, TCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries) + { + HINSTANCE hInstance; + DWORD dwFLen; + HRESULT hResult; + + hInstance = _AtlBaseModule.GetModuleInstance(); + dwFLen = GetModuleFileName(hInstance, modulePath, modulePathCount); + if (dwFLen == modulePathCount) + return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); + else if (dwFLen == 0) + return HRESULT_FROM_WIN32(GetLastError()); + + if (pMapEntries != NULL) + { + while (pMapEntries->szKey != NULL) + { + ATLASSERT(pMapEntries->szData != NULL); + hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData); + if (FAILED(hResult)) + return hResult; + pMapEntries++; + } + } + + hResult = AddCommonRGSReplacements(&registrar); + if (FAILED(hResult)) + return hResult; + + hResult = registrar.AddReplacement(_T("Module"), modulePath); + if (FAILED(hResult)) + return hResult; + + hResult = registrar.AddReplacement(_T("Module_Raw"), modulePath); + if (FAILED(hResult)) + return hResult; + + return S_OK; + } +}; + +template <class T> +class CAtlModuleT : public CAtlModule +{ +public: + + virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar) + { + return pRegistrar->AddReplacement(L"APPID", T::GetAppId()); + } + + static LPCOLESTR GetAppId() + { + return L""; + } +}; + +class CAtlComModule : public _ATL_COM_MODULE +{ +public: + CAtlComModule() + { + m_hInstTypeLib = reinterpret_cast<HINSTANCE>(&__ImageBase); + m_ppAutoObjMapFirst = NULL; + m_ppAutoObjMapLast = NULL; + if (FAILED(m_csObjMap.Init())) + { + ATLASSERT(0); + CAtlBaseModule::m_bInitFailed = true; + return; + } + cbSize = sizeof(_ATL_COM_MODULE); + } + + ~CAtlComModule() + { + Term(); + } + + void Term() + { + if (cbSize != 0) + { + ATLASSERT(m_ppAutoObjMapFirst == NULL); + ATLASSERT(m_ppAutoObjMapLast == NULL); + m_csObjMap.Term(); + cbSize = 0; + } + } +}; + +template <class T> +class CAtlDllModuleT : public CAtlModuleT<T> +{ +public: + CAtlDllModuleT() + { + } + + HRESULT DllCanUnloadNow() + { + T *pThis; + + pThis = static_cast<T *>(this); + if (pThis->GetLockCount() == 0) + return S_OK; + return S_FALSE; + } + + HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) + { + T *pThis; + + pThis = static_cast<T *>(this); + return pThis->GetClassObject(rclsid, riid, ppv); + } + + HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE) + { + T *pThis; + HRESULT hResult; + + pThis = static_cast<T *>(this); + hResult = pThis->RegisterServer(bRegTypeLib); + return hResult; + } + + HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE) + { + T *pThis; + HRESULT hResult; + + pThis = static_cast<T *>(this); + hResult = pThis->UnregisterServer(bUnRegTypeLib); + return hResult; + } + + HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) + { + return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv); + } +}; + +class CComModule : public CAtlModuleT<CComModule> +{ +public: + _ATL_OBJMAP_ENTRY *m_pObjMap; +public: + CComModule() + { + ATLASSERT(_pModule == NULL); + _pModule = this; + } + + ~CComModule() + { + _pModule = NULL; + } + + HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) + { + _ATL_OBJMAP_ENTRY *objectMapEntry; + HRESULT hResult; + + ATLASSERT(ppv != NULL); + if (ppv == NULL) + return E_POINTER; + hResult = S_OK; + if (m_pObjMap != NULL) + { + objectMapEntry = m_pObjMap; + while (objectMapEntry->pclsid != NULL) + { + if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE) + { + if (objectMapEntry->pCF == NULL) + { + CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true); + + if (objectMapEntry->pCF == NULL) + hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF)); + } + if (objectMapEntry->pCF != NULL) + hResult = objectMapEntry->pCF->QueryInterface(riid, ppv); + break; + } + objectMapEntry++; + } + } + return hResult; + } + + HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL) + { + _ATL_OBJMAP_ENTRY *objectMapEntry; + HRESULT hResult; + + hResult = S_OK; + objectMapEntry = m_pObjMap; + if (objectMapEntry != NULL) + { + while (objectMapEntry->pclsid != NULL) + { + if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE) + { + hResult = objectMapEntry->pfnUpdateRegistry(TRUE); + if (FAILED(hResult)) + break; + } + objectMapEntry++; + } + } + return hResult; + } + + HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL) + { + _ATL_OBJMAP_ENTRY *objectMapEntry; + HRESULT hResult; + + hResult = S_OK; + objectMapEntry = m_pObjMap; + if (objectMapEntry != NULL) + { + while (objectMapEntry->pclsid != NULL) + { + if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE) + { + hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister + if (FAILED(hResult)) + break; + } + objectMapEntry++; + } + } + return hResult; + } + + HRESULT DllCanUnloadNow() + { + if (GetLockCount() == 0) + return S_OK; + return S_FALSE; + } + + HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) + { + return GetClassObject(rclsid, riid, ppv); + } + + HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE) + { + return RegisterServer(bRegTypeLib); + } + + HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE) + { + return UnregisterServer(bUnRegTypeLib); + } + +}; + +class CAtlWinModule : public _ATL_WIN_MODULE +{ +public: + CAtlWinModule() + { + HRESULT hResult; + + hResult = AtlWinModuleInit(this); + if (FAILED(hResult)) + { + CAtlBaseModule::m_bInitFailed = true; + ATLASSERT(0); + } + } + + ~CAtlWinModule() + { + Term(); + } + + void Term() + { + AtlWinModuleTerm(this, _AtlBaseModule.GetModuleInstance()); + } + + void AddCreateWndData(_AtlCreateWndData *pData, void *pObject) + { + AtlWinModuleAddCreateWndData(this, pData, pObject); + } + + void *ExtractCreateWndData() + { + return AtlWinModuleExtractCreateWndData(this); + } +}; + +extern CAtlWinModule _AtlWinModule; + +template<class T> +class CComPtr +{ +public: + T *p; +public: + CComPtr() + { + p = NULL; + } + + CComPtr(T *lp) + { + p = lp; + if (p != NULL) + p->AddRef(); + } + + CComPtr(const CComPtr<T> &lp) + { + p = lp.p; + if (p != NULL) + p->AddRef(); + } + + ~CComPtr() + { + if (p != NULL) + p->Release(); + } + + T *operator = (T *lp) + { + if (p != NULL) + p->Release(); + p = lp; + if (p != NULL) + p->AddRef(); + return *this; + } + + T *operator = (const CComPtr<T> &lp) + { + if (p != NULL) + p->Release(); + p = lp.p; + if (p != NULL) + p->AddRef(); + return *this; + } + + void Release() + { + if (p != NULL) + { + p->Release(); + p = NULL; + } + } + + void Attach(T *lp) + { + if (p != NULL) + p->Release(); + p = lp; + } + + T *Detach() + { + T *saveP; + + saveP = p; + p = NULL; + return saveP; + } + + T **operator & () + { + ATLASSERT(p == NULL); + return &p; + } + + operator T * () + { + return p; + } + + T *operator -> () + { + ATLASSERT(p != NULL); + return p; + } +}; + +class CComBSTR +{ +public: + BSTR m_str; +public: + CComBSTR(LPCOLESTR pSrc) + { + if (pSrc == NULL) + m_str = NULL; + else + m_str = ::SysAllocString(pSrc); + } + ~CComBSTR() + { + ::SysFreeString(m_str); + m_str = NULL; + } +}; + +class CComVariant : public tagVARIANT +{ +public: + CComVariant() + { + ::VariantInit(this); + } + + ~CComVariant() + { + Clear(); + } + + HRESULT Clear() + { + return ::VariantClear(this); + } +}; + +inline HRESULT __stdcall AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID &iid, LPDWORD pdw) +{ + CComPtr<IConnectionPointContainer> container; + CComPtr<IConnectionPoint> connectionPoint; + HRESULT hResult; + + if (pUnkCP == NULL) + return E_INVALIDARG; + hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container); + if (FAILED(hResult)) + return hResult; + hResult = container->FindConnectionPoint(iid, &connectionPoint); + if (FAILED(hResult)) + return hResult; + return connectionPoint->Advise(pUnk, pdw); +} + +inline HRESULT __stdcall AtlUnadvise(IUnknown *pUnkCP, const IID &iid, DWORD dw) +{ + CComPtr<IConnectionPointContainer> container; + CComPtr<IConnectionPoint> connectionPoint; + HRESULT hResult; + + if (pUnkCP == NULL) + return E_INVALIDARG; + hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container); + if (FAILED(hResult)) + return hResult; + hResult = container->FindConnectionPoint(iid, &connectionPoint); + if (FAILED(hResult)) + return hResult; + return connectionPoint->Unadvise(dw); +} + +inline HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject) +{ + int i; + IUnknown *resultInterface; + HRESULT hResult; + + ATLASSERT(pThis != NULL && pEntries != NULL); + if (pThis == NULL || pEntries == NULL) + return E_INVALIDARG; + ATLASSERT(ppvObject != NULL); + if (ppvObject == NULL) + return E_POINTER; + + if (InlineIsEqualUnknown(iid)) + { + resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw); + *ppvObject = resultInterface; + resultInterface->AddRef(); + return S_OK; + } + + i = 0; + while (pEntries[i].pFunc != 0) + { + if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid)) + { + if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1)) + { + ATLASSERT(pEntries[i].piid != NULL); + resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw); + *ppvObject = resultInterface; + resultInterface->AddRef(); + return S_OK; + } + else + { + hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0); + if (hResult == S_OK || (FAILED(hResult) && pEntries[i].piid != NULL)) + return hResult; + } + break; + } + i++; + } + *ppvObject = NULL; + return E_NOINTERFACE; +} + +inline HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule) +{ + if (pWinModule == NULL) + return E_INVALIDARG; + pWinModule->m_pCreateWndList = NULL; + return pWinModule->m_csWindowCreate.Init(); +} + +inline HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst) +{ + if (pWinModule == NULL) + return E_INVALIDARG; + pWinModule->m_csWindowCreate.Term(); + return S_OK; +} + +inline void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject) +{ + CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true); + + ATLASSERT(pWinModule != NULL); + ATLASSERT(pObject != NULL); + + pData->m_pThis = pObject; + pData->m_dwThreadID = ::GetCurrentThreadId(); + pData->m_pNext = pWinModule->m_pCreateWndList; + pWinModule->m_pCreateWndList = pData; +} + +inline void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule) +{ + CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true); + void *result; + _AtlCreateWndData *currentEntry; + _AtlCreateWndData **previousLink; + DWORD threadID; + + ATLASSERT(pWinModule != NULL); + + result = NULL; + threadID = GetCurrentThreadId(); + currentEntry = pWinModule->m_pCreateWndList; + previousLink = &pWinModule->m_pCreateWndList; + while (currentEntry != NULL) + { + if (currentEntry->m_dwThreadID == threadID) + { + *previousLink = currentEntry->m_pNext; + result = currentEntry->m_pThis; + break; + } + previousLink = &currentEntry->m_pNext; + currentEntry = currentEntry->m_pNext; + } + return result; +} + +}; // namespace ATL + +#ifndef _ATL_NO_AUTOMATIC_NAMESPACE +using namespace ATL; +#endif //!_ATL_NO_AUTOMATIC_NAMESPACE + +#endif // _atlbase_h Propchange: trunk/reactos/lib/atl/atlbase.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlcom.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlcom.h?rev=43645… ============================================================================== --- trunk/reactos/lib/atl/atlcom.h (added) +++ trunk/reactos/lib/atl/atlcom.h [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,1133 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _atlcom_h +#define _atlcom_h + +namespace ATL +{ + +template <class Base, const IID *piid, class T, class Copy, class ThreadModel = CComObjectThreadModel> +class CComEnum; + +#define DECLARE_CLASSFACTORY_EX(cf) typedef ATL::CComCreator<ATL::CComObjectCached<cf> > _ClassFactoryCreatorClass; +#define DECLARE_CLASSFACTORY() DECLARE_CLASSFACTORY_EX(ATL::CComClassFactory) + +class CComObjectRootBase +{ +public: + long m_dwRef; +public: + CComObjectRootBase() + { + m_dwRef = 0; + } + + ~CComObjectRootBase() + { + } + + void SetVoid(void *) + { + } + + HRESULT _AtlFinalConstruct() + { + return S_OK; + } + + HRESULT FinalConstruct() + { + return S_OK; + } + + void InternalFinalConstructAddRef() + { + } + + void InternalFinalConstructRelease() + { + } + + void FinalRelease() + { + } + + static void WINAPI ObjectMain(bool) + { + } + + static const struct _ATL_CATMAP_ENTRY *GetCategoryMap() + { + return NULL; + } + + static HRESULT WINAPI InternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject) + { + return AtlInternalQueryInterface(pThis, pEntries, iid, ppvObject); + } + +}; + +template <class ThreadModel> +class CComObjectRootEx : public CComObjectRootBase +{ +private: + typename ThreadModel::AutoDeleteCriticalSection m_critsec; +public: + ~CComObjectRootEx() + { + } + + ULONG InternalAddRef() + { + ATLASSERT(m_dwRef >= 0); + return ThreadModel::Increment(reinterpret_cast<int *>(&m_dwRef)); + } + + ULONG InternalRelease() + { + ATLASSERT(m_dwRef > 0); + return ThreadModel::Decrement(reinterpret_cast<int *>(&m_dwRef)); + } + + void Lock() + { + m_critsec.Lock(); + } + + void Unlock() + { + m_critsec.Unlock(); + } + + HRESULT _AtlInitialConstruct() + { + return m_critsec.Init(); + } +}; + +template <class Base> +class CComObject : public Base +{ +public: + CComObject(void * = NULL) + { + _pAtlModule->Lock(); + } + + virtual ~CComObject() + { + CComObject<Base> *pThis; + + pThis = reinterpret_cast<CComObject<Base> *>(this); + pThis->FinalRelease(); + _pAtlModule->Unlock(); + } + + STDMETHOD_(ULONG, AddRef)() + { + CComObject<Base> *pThis; + + pThis = reinterpret_cast<CComObject<Base> *>(this); + return pThis->InternalAddRef(); + } + + STDMETHOD_(ULONG, Release)() + { + CComObject<Base> *pThis; + ULONG l; + + pThis = reinterpret_cast<CComObject<Base> *>(this); + l = pThis->InternalRelease(); + if (l == 0) + delete this; + return l; + } + + STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject) + { + CComObject<Base> *pThis; + + pThis = reinterpret_cast<CComObject<Base> *>(this); + return pThis->_InternalQueryInterface(iid, ppvObject); + } + + static HRESULT WINAPI CreateInstance(CComObject<Base> **pp) + { + CComObject<Base> *newInstance; + HRESULT hResult; + + ATLASSERT(pp != NULL); + if (pp == NULL) + return E_POINTER; + + hResult = E_OUTOFMEMORY; + newInstance = NULL; + ATLTRY(newInstance = new CComObject<Base>()) + if (newInstance != NULL) + { + newInstance->SetVoid(NULL); + newInstance->InternalFinalConstructAddRef(); + hResult = newInstance->_AtlInitialConstruct(); + if (SUCCEEDED(hResult)) + hResult = newInstance->FinalConstruct(); + if (SUCCEEDED(hResult)) + hResult = newInstance->_AtlFinalConstruct(); + newInstance->InternalFinalConstructRelease(); + if (hResult != S_OK) + { + delete newInstance; + newInstance = NULL; + } + } + *pp = newInstance; + return hResult; + } + + +}; + +template <HRESULT hResult> +class CComFailCreator +{ +public: + static HRESULT WINAPI CreateInstance(void *, REFIID, LPVOID *ppv) + { + ATLASSERT(ppv != NULL); + if (ppv == NULL) + return E_POINTER; + *ppv = NULL; + + return hResult; + } +}; + +template <class T1> +class CComCreator +{ +public: + static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv) + { + T1 *newInstance; + HRESULT hResult; + + ATLASSERT(ppv != NULL); + if (ppv == NULL) + return E_POINTER; + *ppv = NULL; + + hResult = E_OUTOFMEMORY; + newInstance = NULL; + ATLTRY(newInstance = new T1()) + if (newInstance != NULL) + { + newInstance->SetVoid(pv); + newInstance->InternalFinalConstructAddRef(); + hResult = newInstance->_AtlInitialConstruct(); + if (SUCCEEDED(hResult)) + hResult = newInstance->FinalConstruct(); + if (SUCCEEDED(hResult)) + hResult = newInstance->_AtlFinalConstruct(); + newInstance->InternalFinalConstructRelease(); + if (SUCCEEDED(hResult)) + hResult = newInstance->QueryInterface(riid, ppv); + if (FAILED(hResult)) + { + delete newInstance; + newInstance = NULL; + } + } + return hResult; + } +}; + +template <class T1, class T2> +class CComCreator2 +{ +public: + static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv) + { + ATLASSERT(ppv != NULL && ppv != NULL); + + if (pv == NULL) + return T1::CreateInstance(NULL, riid, ppv); + else + return T2::CreateInstance(pv, riid, ppv); + } +}; + +template <class Base> +class CComObjectCached : public Base +{ +public: + CComObjectCached(void * = NULL) + { + } + + STDMETHOD_(ULONG, AddRef)() + { + CComObjectCached<Base> *pThis; + ULONG newRefCount; + + pThis = reinterpret_cast<CComObjectCached<Base>*>(this); + newRefCount = pThis->InternalAddRef(); + if (newRefCount == 2) + _pAtlModule->Lock(); + return newRefCount; + } + + STDMETHOD_(ULONG, Release)() + { + CComObjectCached<Base> *pThis; + ULONG newRefCount; + + pThis = reinterpret_cast<CComObjectCached<Base>*>(this); + newRefCount = pThis->InternalRelease(); + if (newRefCount == 0) + delete this; + else if (newRefCount == 1) + _pAtlModule->Unlock(); + return newRefCount; + } + + STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject) + { + CComObjectCached<Base> *pThis; + + pThis = reinterpret_cast<CComObjectCached<Base>*>(this); + return pThis->_InternalQueryInterface(iid, ppvObject); + } +}; + +#define BEGIN_COM_MAP(x) \ +public: \ + typedef x _ComMapClass; \ + HRESULT _InternalQueryInterface(REFIID iid, void **ppvObject) \ + { \ + return InternalQueryInterface(this, _GetEntries(), iid, ppvObject); \ + } \ + const static ATL::_ATL_INTMAP_ENTRY *WINAPI _GetEntries() \ + { \ + static const ATL::_ATL_INTMAP_ENTRY _entries[] = { + +#define END_COM_MAP() \ + {NULL, 0, 0} \ + }; \ + return _entries; \ + } \ + virtual ULONG STDMETHODCALLTYPE AddRef() = 0; \ + virtual ULONG STDMETHODCALLTYPE Release() = 0; \ + STDMETHOD(QueryInterface)(REFIID, void **) = 0; + +#define COM_INTERFACE_ENTRY_IID(iid, x) \ + {&iid, offsetofclass(x, _ComMapClass), _ATL_SIMPLEMAPENTRY}, + +#define COM_INTERFACE_ENTRY2_IID(iid, x, x2) \ + {&iid, \ + reinterpret_cast<DWORD_PTR>(static_cast<x *>(static_cast<x2 *>(reinterpret_cast<_ComMapClass *>(_ATL_PACKING)))) - _ATL_PACKING, \ + _ATL_SIMPLEMAPENTRY}, + +#define COM_INTERFACE_ENTRY_BREAK(x) \ + {&_ATL_IIDOF(x), \ + NULL, \ + _Break}, // Break is a function that issues int 3. + +#define COM_INTERFACE_ENTRY_NOINTERFACE(x) \ + {&_ATL_IIDOF(x), \ + NULL, \ + _NoInterface}, // NoInterface returns E_NOINTERFACE. + +#define COM_INTERFACE_ENTRY_FUNC(iid, dw, func) \ + {&iid, \ + dw, \ + func}, + +#define COM_INTERFACE_ENTRY_FUNC_BLIND(dw, func) \ + {NULL, \ + dw, \ + func}, + +#define COM_INTERFACE_ENTRY_CHAIN(classname) \ + {NULL, \ + reinterpret_cast<DWORD>(&_CComChainData<classname, _ComMapClass>::data), \ + _Chain}, + +#define DECLARE_REGISTRY_RESOURCEID(x)\ + static HRESULT WINAPI UpdateRegistry(BOOL bRegister)\ + {\ + return ATL::_pAtlModule->UpdateRegistryFromResource(x, bRegister); \ + } + +#define DECLARE_NOT_AGGREGATABLE(x) \ +public: \ + typedef ATL::CComCreator2<ATL::CComCreator<ATL::CComObject<x> >, ATL::CComFailCreator<CLASS_E_NOAGGREGATION> > _CreatorClass; + +#define DECLARE_AGGREGATABLE(x) \ +public: \ + typedef CComCreator2<CComCreator<CComObject<x> >, CComCreator<CComAggObject<x> > > _CreatorClass; + +#define DECLARE_ONLY_AGGREGATABLE(x) \ +public: \ + typedef CComCreator2<CComFailCreator<E_FAIL>, CComCreator<CComAggObject<x> > > _CreatorClass; + +#define DECLARE_POLY_AGGREGATABLE(x) \ +public: \ + typedef CComCreator<CComPolyObject<x> > _CreatorClass; + +#define DECLARE_GET_CONTROLLING_UNKNOWN() \ +public: \ + virtual IUnknown *GetControllingUnknown() \ + { \ + return GetUnknown(); \ + } + +#define DECLARE_PROTECT_FINAL_CONSTRUCT() \ + void InternalFinalConstructAddRef() \ + { \ + InternalAddRef(); \ + } \ + void InternalFinalConstructRelease() \ + { \ + InternalRelease(); \ + } + +#define BEGIN_OBJECT_MAP(x) static ATL::_ATL_OBJMAP_ENTRY x[] = { + +#define END_OBJECT_MAP() {NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL}}; + +#define OBJECT_ENTRY(clsid, class) \ +{ \ + &clsid, \ + class::UpdateRegistry, \ + class::_ClassFactoryCreatorClass::CreateInstance, \ + class::_CreatorClass::CreateInstance, \ + NULL, \ + 0, \ + class::GetObjectDescription, \ + class::GetCategoryMap, \ + class::ObjectMain }, + +class CComClassFactory : + public IClassFactory, + public CComObjectRootEx<CComGlobalsThreadModel> +{ +public: + _ATL_CREATORFUNC *m_pfnCreateInstance; +public: + STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void **ppvObj) + { + HRESULT hResult; + + ATLASSERT(m_pfnCreateInstance != NULL); + + if (ppvObj == NULL) + return E_POINTER; + *ppvObj = NULL; + + if (pUnkOuter != NULL && InlineIsEqualUnknown(riid) == FALSE) + hResult = CLASS_E_NOAGGREGATION; + else + hResult = m_pfnCreateInstance(pUnkOuter, riid, ppvObj); + return hResult; + } + + STDMETHOD(LockServer)(BOOL fLock) + { + if (fLock) + _pAtlModule->Lock(); + else + _pAtlModule->Unlock(); + return S_OK; + } + + void SetVoid(void *pv) + { + m_pfnCreateInstance = (_ATL_CREATORFUNC *)pv; + } + + BEGIN_COM_MAP(CComClassFactory) + COM_INTERFACE_ENTRY_IID(IID_IClassFactory, IClassFactory) + END_COM_MAP() +}; + +template <class T, const CLSID *pclsid = &CLSID_NULL> +class CComCoClass +{ +public: + DECLARE_CLASSFACTORY() + + static LPCTSTR WINAPI GetObjectDescription() + { + return NULL; + } +}; + +template <class T> +class _Copy +{ +public: + static HRESULT copy(T *pTo, const T *pFrom) + { + memcpy(pTo, pFrom, sizeof(T)); + return S_OK; + } + + static void init(T *) + { + } + + static void destroy(T *) + { + } +}; + +template<> +class _Copy<CONNECTDATA> +{ +public: + static HRESULT copy(CONNECTDATA *pTo, const CONNECTDATA *pFrom) + { + *pTo = *pFrom; + if (pTo->pUnk) + pTo->pUnk->AddRef(); + return S_OK; + } + + static void init(CONNECTDATA *) + { + } + + static void destroy(CONNECTDATA *p) + { + if (p->pUnk) + p->pUnk->Release(); + } +}; + +template <class T> +class _CopyInterface +{ +public: + static HRESULT copy(T **pTo, T **pFrom) + { + *pTo = *pFrom; + if (*pTo) + (*pTo)->AddRef(); + return S_OK; + } + + static void init(T **) + { + } + + static void destroy(T **p) + { + if (*p) + (*p)->Release(); + } +}; + +enum CComEnumFlags +{ + AtlFlagNoCopy = 0, + AtlFlagTakeOwnership = 2, // BitOwn + AtlFlagCopy = 3 // BitOwn | BitCopy +}; + +template <class Base, const IID *piid, class T, class Copy> +class CComEnumImpl : public Base +{ +private: + typedef CComObject<CComEnum<Base, piid, T, Copy> > enumeratorClass; +public: + CComPtr<IUnknown> m_spUnk; + DWORD m_dwFlags; + T *m_begin; + T *m_end; + T *m_iter; +public: + CComEnumImpl() + { + m_dwFlags = 0; + m_begin = NULL; + m_end = NULL; + m_iter = NULL; + } + + virtual ~CComEnumImpl() + { + T *x; + + if ((m_dwFlags & BitOwn) != 0) + { + for (x = m_begin; x != m_end; x++) + Copy::destroy(x); + delete [] m_begin; + } + } + + HRESULT Init(T *begin, T *end, IUnknown *pUnk, CComEnumFlags flags = AtlFlagNoCopy) + { + T *newBuffer; + T *sourcePtr; + T *destPtr; + T *cleanupPtr; + HRESULT hResult; + + if (flags == AtlFlagCopy) + { + ATLTRY(newBuffer = new T[end - begin]) + if (newBuffer == NULL) + return E_OUTOFMEMORY; + destPtr = newBuffer; + for (sourcePtr = begin; sourcePtr != end; sourcePtr++) + { + Copy::init(destPtr); + hResult = Copy::copy(destPtr, sourcePtr); + if (FAILED(hResult)) + { + cleanupPtr = m_begin; + while (cleanupPtr < destPtr) + Copy::destroy(cleanupPtr++); + delete [] newBuffer; + return hResult; + } + destPtr++; + } + m_begin = newBuffer; + m_end = m_begin + (end - begin); + } + else + { + m_begin = begin; + m_end = end; + } + m_spUnk = pUnk; + m_dwFlags = flags; + m_iter = m_begin; + return S_OK; + } + + STDMETHOD(Next)(ULONG celt, T *rgelt, ULONG *pceltFetched) + { + ULONG numAvailable; + ULONG numToFetch; + T *rgeltTemp; + HRESULT hResult; + + if (pceltFetched != NULL) + *pceltFetched = 0; + if (celt == 0) + return E_INVALIDARG; + if (rgelt == NULL || (celt != 1 && pceltFetched == NULL)) + return E_POINTER; + if (m_begin == NULL || m_end == NULL || m_iter == NULL) + return E_FAIL; + + numAvailable = static_cast<ULONG>(m_end - m_iter); + if (celt < numAvailable) + numToFetch = celt; + else + numToFetch = numAvailable; + if (pceltFetched != NULL) + *pceltFetched = numToFetch; + rgeltTemp = rgelt; + while (numToFetch != 0) + { + hResult = Copy::copy(rgeltTemp, m_iter); + if (FAILED(hResult)) + { + while (rgelt < rgeltTemp) + Copy::destroy(rgelt++); + if (pceltFetched != NULL) + *pceltFetched = 0; + return hResult; + } + rgeltTemp++; + m_iter++; + numToFetch--; + } + if (numAvailable < celt) + return S_FALSE; + return S_OK; + } + + STDMETHOD(Skip)(ULONG celt) + { + ULONG numAvailable; + ULONG numToSkip; + + if (celt == 0) + return E_INVALIDARG; + + numAvailable = static_cast<ULONG>(m_end - m_iter); + if (celt < numAvailable) + numToSkip = celt; + else + numToSkip = numAvailable; + m_iter += numToSkip; + if (numAvailable < celt) + return S_FALSE; + return S_OK; + } + + STDMETHOD(Reset)() + { + m_iter = m_begin; + return S_OK; + } + + STDMETHOD(Clone)(Base **ppEnum) + { + enumeratorClass *newInstance; + HRESULT hResult; + + hResult = E_POINTER; + if (ppEnum != NULL) + { + *ppEnum = NULL; + hResult = enumeratorClass::CreateInstance(&newInstance); + if (SUCCEEDED(hResult)) + { + hResult = newInstance->Init(m_begin, m_end, (m_dwFlags & BitOwn) ? this : m_spUnk); + if (SUCCEEDED(hResult)) + { + newInstance->m_iter = m_iter; + hResult = newInstance->_InternalQueryInterface(*piid, (void **)ppEnum); + } + if (FAILED(hResult)) + delete newInstance; + } + } + return hResult; + } + +protected: + enum FlagBits + { + BitCopy = 1, + BitOwn = 2 + }; +}; + +template <class Base, const IID *piid, class T, class Copy, class ThreadModel> +class CComEnum : + public CComEnumImpl<Base, piid, T, Copy>, + public CComObjectRootEx<ThreadModel> +{ +public: + typedef CComEnum<Base, piid, T, Copy > _CComEnum; + typedef CComEnumImpl<Base, piid, T, Copy > _CComEnumBase; + + BEGIN_COM_MAP(_CComEnum) + COM_INTERFACE_ENTRY_IID(*piid, _CComEnumBase) + END_COM_MAP() +}; + +#ifndef _DEFAULT_VECTORLENGTH +#define _DEFAULT_VECTORLENGTH 4 +#endif + +class CComDynamicUnkArray +{ +public: + int m_nSize; + IUnknown **m_ppUnk; +public: + CComDynamicUnkArray() + { + m_nSize = 0; + m_ppUnk = NULL; + } + + ~CComDynamicUnkArray() + { + free(m_ppUnk); + } + + IUnknown **begin() + { + return m_ppUnk; + } + + IUnknown **end() + { + return &m_ppUnk[m_nSize]; + } + + IUnknown *GetAt(int nIndex) + { + ATLASSERT(nIndex >= 0 && nIndex < m_nSize); + if (nIndex >= 0 && nIndex < m_nSize) + return m_ppUnk[nIndex]; + else + return NULL; + } + + IUnknown *WINAPI GetUnknown(DWORD dwCookie) + { + ATLASSERT(dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize)); + if (dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize)) + return GetAt(dwCookie - 1); + else + return NULL; + } + + DWORD WINAPI GetCookie(IUnknown **ppFind) + { + IUnknown **x; + DWORD curCookie; + + ATLASSERT(ppFind != NULL && *ppFind != NULL); + if (ppFind != NULL && *ppFind != NULL) + { + curCookie = 1; + for (x = begin(); x < end(); x++) + { + if (*x == *ppFind) + return curCookie; + curCookie++; + } + } + return 0; + } + + DWORD Add(IUnknown *pUnk) + { + IUnknown **x; + IUnknown **newArray; + int newSize; + DWORD curCookie; + + ATLASSERT(pUnk != NULL); + if (m_nSize == 0) + { + newSize = _DEFAULT_VECTORLENGTH * sizeof(IUnknown *); + ATLTRY(newArray = reinterpret_cast<IUnknown **>(malloc(newSize))); + if (newArray == NULL) + return 0; + memset(newArray, 0, newSize); + m_ppUnk = newArray; + m_nSize = _DEFAULT_VECTORLENGTH; + } + curCookie = 1; + for (x = begin(); x < end(); x++) + { + if (*x == NULL) + { + *x = pUnk; + return curCookie; + } + curCookie++; + } + newSize = m_nSize * 2; + newArray = reinterpret_cast<IUnknown **>(realloc(m_ppUnk, newSize * sizeof(IUnknown *))); + if (newArray == NULL) + return 0; + memset(&m_ppUnk[m_nSize], 0, (newSize - m_nSize) * sizeof(IUnknown *)); + m_ppUnk = newArray; + m_nSize = newSize; + m_ppUnk[m_nSize] = pUnk; + return m_nSize + 1; + } + + BOOL Remove(DWORD dwCookie) + { + DWORD index; + + index = dwCookie - 1; + ATLASSERT(index < dwCookie && index < static_cast<DWORD>(m_nSize)); + if (index < dwCookie && index < static_cast<DWORD>(m_nSize) && m_ppUnk[index] != NULL) + { + m_ppUnk[index] = NULL; + return TRUE; + } + return FALSE; + } + +}; + +struct _ATL_CONNMAP_ENTRY +{ + DWORD_PTR dwOffset; +}; + +template <const IID *piid> +class _ICPLocator +{ +public: + STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject) = 0; + virtual ULONG STDMETHODCALLTYPE AddRef() = 0; + virtual ULONG STDMETHODCALLTYPE Release() = 0; +}; + +template<class T, const IID *piid, class CDV = CComDynamicUnkArray> +class IConnectionPointImpl : public _ICPLocator<piid> +{ + typedef CComEnum<IEnumConnections, &IID_IEnumConnections, CONNECTDATA, _Copy<CONNECTDATA> > CComEnumConnections; +public: + CDV m_vec; +public: + ~IConnectionPointImpl() + { + IUnknown **x; + + for (x = m_vec.begin(); x < m_vec.end(); x++) + if (*x != NULL) + (*x)->Release(); + } + + STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject) + { + IConnectionPointImpl<T, piid, CDV> *pThis; + + pThis = reinterpret_cast<IConnectionPointImpl<T, piid, CDV>*>(this); + + ATLASSERT(ppvObject != NULL); + if (ppvObject == NULL) + return E_POINTER; + + if (InlineIsEqualGUID(riid, IID_IConnectionPoint) || InlineIsEqualUnknown(riid)) + { + *ppvObject = this; + pThis->AddRef(); + return S_OK; + } + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + } + + STDMETHOD(GetConnectionInterface)(IID *piid2) + { + if (piid2 == NULL) + return E_POINTER; + *piid2 = *piid; + return S_OK; + } + + STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer **ppCPC) + { + T *pThis; + + pThis = static_cast<T *>(this); + return pThis->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void **>(ppCPC)); + } + + STDMETHOD(Advise)(IUnknown *pUnkSink, DWORD *pdwCookie) + { + IUnknown *adviseTarget; + IID interfaceID; + HRESULT hResult; + + if (pdwCookie != NULL) + *pdwCookie = 0; + if (pUnkSink == NULL || pdwCookie == NULL) + return E_POINTER; + GetConnectionInterface(&interfaceID); // can't fail + hResult = pUnkSink->QueryInterface(interfaceID, reinterpret_cast<void **>(&adviseTarget)); + if (SUCCEEDED(hResult)) + { + *pdwCookie = m_vec.Add(adviseTarget); + if (*pdwCookie != 0) + hResult = S_OK; + else + { + adviseTarget->Release(); + hResult = CONNECT_E_ADVISELIMIT; + } + } + else if (hResult == E_NOINTERFACE) + hResult = CONNECT_E_CANNOTCONNECT; + return hResult; + } + + STDMETHOD(Unadvise)(DWORD dwCookie) + { + IUnknown *adviseTarget; + HRESULT hResult; + + adviseTarget = m_vec.GetUnknown(dwCookie); + if (m_vec.Remove(dwCookie)) + { + if (adviseTarget != NULL) + adviseTarget->Release(); + hResult = S_OK; + } + else + hResult = CONNECT_E_NOCONNECTION; + return hResult; + } + + STDMETHOD(EnumConnections)(IEnumConnections **ppEnum) + { + CComObject<CComEnumConnections> *newEnumerator; + CONNECTDATA *itemBuffer; + CONNECTDATA *itemBufferEnd; + IUnknown **x; + HRESULT hResult; + + ATLASSERT(ppEnum != NULL); + if (ppEnum == NULL) + return E_POINTER; + *ppEnum = NULL; + + ATLTRY(itemBuffer = new CONNECTDATA[m_vec.end() - m_vec.begin()]) + if (itemBuffer == NULL) + return E_OUTOFMEMORY; + itemBufferEnd = itemBuffer; + for (x = m_vec.begin(); x < m_vec.end(); x++) + { + if (*x != NULL) + { + (*x)->AddRef(); + itemBufferEnd->pUnk = *x; + itemBufferEnd->dwCookie = m_vec.GetCookie(x); + itemBufferEnd++; + } + } + ATLTRY(newEnumerator = new CComObject<CComEnumConnections>) + if (newEnumerator == NULL) + return E_OUTOFMEMORY; + newEnumerator->Init(itemBuffer, itemBufferEnd, NULL, AtlFlagTakeOwnership); // can't fail + hResult = newEnumerator->_InternalQueryInterface(IID_IEnumConnections, (void **)ppEnum); + if (FAILED(hResult)) + delete newEnumerator; + return hResult; + } +}; + +template <class T> +class IConnectionPointContainerImpl : public IConnectionPointContainer +{ + typedef const _ATL_CONNMAP_ENTRY * (*handlerFunctionType)(int *); + typedef CComEnum<IEnumConnectionPoints, &IID_IEnumConnectionPoints, IConnectionPoint *, _CopyInterface<IConnectionPoint> > + CComEnumConnectionPoints; + +public: + STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints **ppEnum) + { + const _ATL_CONNMAP_ENTRY *entryPtr; + int connectionPointCount; + IConnectionPoint **itemBuffer; + int destIndex; + handlerFunctionType handlerFunction; + CComEnumConnectionPoints *newEnumerator; + HRESULT hResult; + + ATLASSERT(ppEnum != NULL); + if (ppEnum == NULL) + return E_POINTER; + *ppEnum = NULL; + + entryPtr = T::GetConnMap(&connectionPointCount); + ATLTRY(itemBuffer = new IConnectionPoint * [connectionPointCount]) + if (itemBuffer == NULL) + return E_OUTOFMEMORY; + + destIndex = 0; + while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1)) + { + if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2)) + { + entryPtr++; + handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset); + entryPtr = handlerFunction(NULL); + } + else + { + itemBuffer[destIndex++] = reinterpret_cast<IConnectionPoint *>((char *)this + entryPtr->dwOffset); + entryPtr++; + } + } + + ATLTRY(newEnumerator = new CComObject<CComEnumConnectionPoints>) + if (newEnumerator == NULL) + { + delete [] itemBuffer; + return E_OUTOFMEMORY; + } + + newEnumerator->Init(&itemBuffer[0], &itemBuffer[destIndex], NULL, AtlFlagTakeOwnership); // can't fail + hResult = newEnumerator->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum); + if (FAILED(hResult)) + delete newEnumerator; + return hResult; + } + + STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint **ppCP) + { + IID interfaceID; + const _ATL_CONNMAP_ENTRY *entryPtr; + handlerFunctionType handlerFunction; + IConnectionPoint *connectionPoint; + HRESULT hResult; + + if (ppCP == NULL) + return E_POINTER; + *ppCP = NULL; + hResult = CONNECT_E_NOCONNECTION; + entryPtr = T::GetConnMap(NULL); + while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1)) + { + if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2)) + { + entryPtr++; + handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset); + entryPtr = handlerFunction(NULL); + } + else + { + connectionPoint = reinterpret_cast<IConnectionPoint *>(reinterpret_cast<char *>(this) + entryPtr->dwOffset); + if (SUCCEEDED(connectionPoint->GetConnectionInterface(&interfaceID)) && InlineIsEqualGUID(riid, interfaceID)) + { + *ppCP = connectionPoint; + connectionPoint->AddRef(); + hResult = S_OK; + break; + } + entryPtr++; + } + } + return hResult; + } +}; + +#define BEGIN_CONNECTION_POINT_MAP(x) \ + typedef x _atl_conn_classtype; \ + static const ATL::_ATL_CONNMAP_ENTRY *GetConnMap(int *pnEntries) { \ + static const ATL::_ATL_CONNMAP_ENTRY _entries[] = { + +#define END_CONNECTION_POINT_MAP() \ + {(DWORD_PTR)-1} }; \ + if (pnEntries) \ + *pnEntries = sizeof(_entries) / sizeof(ATL::_ATL_CONNMAP_ENTRY) - 1; \ + return _entries;} + +#define CONNECTION_POINT_ENTRY(iid) \ + {offsetofclass(ATL::_ICPLocator<&iid>, _atl_conn_classtype) - \ + offsetofclass(ATL::IConnectionPointContainerImpl<_atl_conn_classtype>, _atl_conn_classtype)}, + +}; // namespace ATL + +#endif // _atlcom_h Propchange: trunk/reactos/lib/atl/atlcom.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlcore.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlcore.cpp?rev=43… ============================================================================== --- trunk/reactos/lib/atl/atlcore.cpp (added) +++ trunk/reactos/lib/atl/atlcore.cpp [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,30 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <windows.h> +#include <ocidl.h> +#include "atlcore.h" + +namespace ATL +{ + +bool CAtlBaseModule::m_bInitFailed = false; + +}; // namespace ATL Propchange: trunk/reactos/lib/atl/atlcore.cpp ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlcore.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlcore.h?rev=4364… ============================================================================== --- trunk/reactos/lib/atl/atlcore.h (added) +++ trunk/reactos/lib/atl/atlcore.h [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,199 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _atlcore_h +#define _atlcore_h + +#include <malloc.h> +#include <olectl.h> +#include <ocidl.h> + +#include <crtdbg.h> + +#ifndef ATLASSERT +#define ATLASSERT(expr) _ASSERTE(expr) +#endif // ATLASSERT + +namespace ATL +{ + +class CComCriticalSection +{ +public: + CRITICAL_SECTION m_sec; +public: + CComCriticalSection() + { + memset(&m_sec, 0, sizeof(CRITICAL_SECTION)); + } + + ~CComCriticalSection() + { + } + + HRESULT Lock() + { + EnterCriticalSection(&m_sec); + return S_OK; + } + + HRESULT Unlock() + { + LeaveCriticalSection(&m_sec); + return S_OK; + } + + HRESULT Init() + { + InitializeCriticalSection(&m_sec); + return S_OK; + } + + HRESULT Term() + { + DeleteCriticalSection(&m_sec); + return S_OK; + } +}; + +class CComFakeCriticalSection +{ +public: + HRESULT Lock() + { + return S_OK; + } + + HRESULT Unlock() + { + return S_OK; + } + + HRESULT Init() + { + return S_OK; + } + + HRESULT Term() + { + return S_OK; + } +}; + +class CComAutoCriticalSection : public CComCriticalSection +{ +public: + CComAutoCriticalSection() + { + HRESULT hResult; + + hResult = CComCriticalSection::Init(); + ATLASSERT(SUCCEEDED(hResult)); + } + ~CComAutoCriticalSection() + { + CComCriticalSection::Term(); + } +}; + +class CComSafeDeleteCriticalSection : public CComCriticalSection +{ +private: + bool m_bInitialized; +public: + CComSafeDeleteCriticalSection() + { + m_bInitialized = false; + } + + ~CComSafeDeleteCriticalSection() + { + Term(); + } + + HRESULT Lock() + { + ATLASSERT(m_bInitialized); + return CComCriticalSection::Lock(); + } + + HRESULT Init() + { + HRESULT hResult; + + ATLASSERT(!m_bInitialized); + hResult = CComCriticalSection::Init(); + if (SUCCEEDED(hResult)) + m_bInitialized = true; + return hResult; + } + + HRESULT Term() + { + if (!m_bInitialized) + return S_OK; + m_bInitialized = false; + return CComCriticalSection::Term(); + } +}; + +class CComAutoDeleteCriticalSection : public CComSafeDeleteCriticalSection +{ +private: + // CComAutoDeleteCriticalSection::Term should never be called + HRESULT Term(); +}; + +struct _ATL_BASE_MODULE70 +{ + UINT cbSize; + HINSTANCE m_hInst; + HINSTANCE m_hInstResource; + bool m_bNT5orWin98; + DWORD dwAtlBuildVer; + GUID *pguidVer; + CRITICAL_SECTION m_csResource; +#ifdef NOTYET + CSimpleArray<HINSTANCE> m_rgResourceInstance; +#endif +}; +typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE; + +class CAtlBaseModule : public _ATL_BASE_MODULE +{ +public : + static bool m_bInitFailed; +public: + HINSTANCE GetModuleInstance() + { + return m_hInst; + } + + HINSTANCE GetResourceInstance() + { + return m_hInstResource; + } +}; + +extern CAtlBaseModule _AtlBaseModule; + +}; // namespace ATL + +#endif // _atlcore_h Propchange: trunk/reactos/lib/atl/atlcore.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/atlwin.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/atlwin.h?rev=43645… ============================================================================== --- trunk/reactos/lib/atl/atlwin.h (added) +++ trunk/reactos/lib/atl/atlwin.h [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,751 @@ +/* + * ReactOS ATL + * + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _atlin_h +#define _atlwin_h + +#ifdef __GNUC__ +#define GCCU(x) x __attribute__((unused)) +#define Unused(x) +#else +#define GCCU(x) +#define Unused(x) (x); +#endif // __GNUC__ + +#ifdef SetWindowLongPtr +#undef SetWindowLongPtr +inline LONG_PTR SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong) +{ + return SetWindowLong(hWnd, nIndex, (LONG)dwNewLong); +} +#endif + +#ifdef GetWindowLongPtr +#undef GetWindowLongPtr +inline LONG_PTR GetWindowLongPtr(HWND hWnd, int nIndex) +{ + return (LONG_PTR)GetWindowLong(hWnd, nIndex); +} +#endif + +namespace ATL +{ + +struct _ATL_WNDCLASSINFOW; +typedef _ATL_WNDCLASSINFOW CWndClassInfo; + +template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0> +class CWinTraits +{ +public: + static DWORD GetWndStyle(DWORD dwStyle) + { + if (dwStyle == 0) + return t_dwStyle; + return dwStyle; + } + + static DWORD GetWndExStyle(DWORD dwExStyle) + { + if (dwExStyle == 0) + return t_dwExStyle; + return dwExStyle; + } +}; + +typedef CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0> CControlWinTraits; +typedef CWinTraits<WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE> CFrameWinTraits; +typedef CWinTraits<WS_OVERLAPPEDWINDOW | WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_MDICHILD> CMDIChildWinTraits; + +template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0, class TWinTraits = CControlWinTraits> +class CWinTraitsOR +{ +public: + static DWORD GetWndStyle(DWORD dwStyle) + { + return dwStyle | t_dwStyle | TWinTraits::GetWndStyle(dwStyle); + } + + static DWORD GetWndExStyle(DWORD dwExStyle) + { + return dwExStyle | t_dwExStyle | TWinTraits::GetWndExStyle(dwExStyle); + } +}; + +class _U_MENUorID +{ +public: + HMENU m_hMenu; +public: + _U_MENUorID(HMENU hMenu) + { + m_hMenu = hMenu; + } + + _U_MENUorID(UINT nID) + { + m_hMenu = (HMENU)(UINT_PTR)nID; + } +}; + +class _U_RECT +{ +public: + LPRECT m_lpRect; +public: + _U_RECT(LPRECT lpRect) + { + m_lpRect = lpRect; + } + + _U_RECT(RECT &rc) + { + m_lpRect = &rc; + } +}; + +struct _ATL_MSG : public MSG +{ +public: + BOOL bHandled; +public: + _ATL_MSG(HWND hWnd, UINT uMsg, WPARAM wParamIn, LPARAM lParamIn, BOOL bHandledIn = TRUE) + { + hwnd = hWnd; + message = uMsg; + wParam = wParamIn; + lParam = lParamIn; + time = 0; + pt.x = 0; + pt.y = 0; + bHandled = bHandledIn; + } +}; + +#if defined(_M_IX86) + +#pragma pack(push,1) +struct thunkCode +{ + DWORD m_mov; + DWORD m_this; + BYTE m_jmp; + DWORD m_relproc; +}; +#pragma pack(pop) + +class CWndProcThunk +{ +public: + thunkCode m_thunk; + _AtlCreateWndData cd; +public: + BOOL Init(WNDPROC proc, void *pThis) + { + m_thunk.m_mov = 0x042444C7; + m_thunk.m_this = PtrToUlong(pThis); + m_thunk.m_jmp = 0xe9; + m_thunk.m_relproc = DWORD(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(this) + sizeof(thunkCode))); + return TRUE; + } + + WNDPROC GetWNDPROC() + { + return reinterpret_cast<WNDPROC>(&m_thunk); + } +}; + +#else +#error Only X86 supported +#endif + +class CMessageMap +{ +public: + virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult, DWORD dwMsgMapID) = 0; +}; + +class CWindow +{ +public: + HWND m_hWnd; + static RECT rcDefault; +public: + CWindow(HWND hWnd = NULL) + { + m_hWnd = hWnd; + } + + operator HWND() const + { + return m_hWnd; + } + + static LPCTSTR GetWndClassName() + { + return NULL; + } + + HDC BeginPaint(LPPAINTSTRUCT lpPaint) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::BeginPaint(m_hWnd, lpPaint); + } + + BOOL DestroyWindow() + { + ATLASSERT(::IsWindow(m_hWnd)); + + if (!::DestroyWindow(m_hWnd)) + return FALSE; + + m_hWnd = NULL; + return TRUE; + } + + void EndPaint(LPPAINTSTRUCT lpPaint) + { + ATLASSERT(::IsWindow(m_hWnd)); + ::EndPaint(m_hWnd, lpPaint); + } + + BOOL GetClientRect(LPRECT lpRect) const + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::GetClientRect(m_hWnd, lpRect); + } + + CWindow GetParent() const + { + ATLASSERT(::IsWindow(m_hWnd)); + return CWindow(::GetParent(m_hWnd)); + } + + BOOL Invalidate(BOOL bErase = TRUE) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::InvalidateRect(m_hWnd, NULL, bErase); + } + + BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::InvalidateRect(m_hWnd, lpRect, bErase); + } + + BOOL IsWindow() const + { + return ::IsWindow(m_hWnd); + } + + BOOL KillTimer(UINT_PTR nIDEvent) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::KillTimer(m_hWnd, nIDEvent); + } + + BOOL LockWindowUpdate(BOOL bLock = TRUE) + { + ATLASSERT(::IsWindow(m_hWnd)); + if (bLock) + return ::LockWindowUpdate(m_hWnd); + return ::LockWindowUpdate(NULL); + } + + BOOL ScreenToClient(LPPOINT lpPoint) const + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::ScreenToClient(m_hWnd, lpPoint); + } + + LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SendMessage(m_hWnd, message, wParam, lParam); + } + + static LRESULT SendMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) + { + ATLASSERT(::IsWindow(hWnd)); + return ::SendMessage(hWnd, message, wParam, lParam); + } + + HWND SetCapture() + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SetCapture(m_hWnd); + } + + HWND SetFocus() + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SetFocus(m_hWnd); + } + + UINT_PTR SetTimer(UINT_PTR nIDEvent, UINT nElapse, void (CALLBACK *lpfnTimer)(HWND, UINT, UINT_PTR, DWORD) = NULL) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SetTimer(m_hWnd, nIDEvent, nElapse, reinterpret_cast<TIMERPROC>(lpfnTimer)); + } + + BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, nFlags); + } + + BOOL SetWindowText(LPCTSTR lpszString) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::SetWindowText(m_hWnd, lpszString); + } + + BOOL ShowWindow(int nCmdShow) + { + ATLASSERT(::IsWindow(m_hWnd)); + return ::ShowWindow(m_hWnd, nCmdShow); + } + +}; + +_declspec(selectany) RECT CWindow::rcDefault = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 }; + +template <class TBase = CWindow, class TWinTraits = CControlWinTraits> +class CWindowImplBaseT : public TBase, public CMessageMap +{ +public: + enum { WINSTATE_DESTROYED = 0x00000001 }; + DWORD m_dwState; + const _ATL_MSG *m_pCurrentMsg; + CWndProcThunk m_thunk; + WNDPROC m_pfnSuperWindowProc; +public: + CWindowImplBaseT() + { + m_dwState = 0; + m_pCurrentMsg = NULL; + m_pfnSuperWindowProc = ::DefWindowProc; + } + + virtual void OnFinalMessage(HWND /* hWnd */) + { + } + + BOOL SubclassWindow(HWND hWnd) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis; + WNDPROC newWindowProc; + WNDPROC oldWindowProc; + BOOL result; + + ATLASSERT(m_hWnd == NULL); + ATLASSERT(::IsWindow(hWnd)); + + pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this); + + result = m_thunk.Init(GetWindowProc(), this); + if (result == FALSE) + return FALSE; + newWindowProc = m_thunk.GetWNDPROC(); + oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc))); + if (oldWindowProc == NULL) + return FALSE; + m_pfnSuperWindowProc = oldWindowProc; + pThis->m_hWnd = hWnd; + return TRUE; + } + + virtual WNDPROC GetWindowProc() + { + return WindowProc; + } + + static DWORD GetWndStyle(DWORD dwStyle) + { + return TWinTraits::GetWndStyle(dwStyle); + } + + static DWORD GetWndExStyle(DWORD dwExStyle) + { + return TWinTraits::GetWndExStyle(dwExStyle); + } + + LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis; + + pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this); + return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam); + } + + static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis; + WNDPROC newWindowProc; + WNDPROC GCCU(pOldProc); + + pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(_AtlWinModule.ExtractCreateWndData()); + ATLASSERT(pThis != NULL); + if (pThis == NULL) + return 0; + pThis->m_thunk.Init(pThis->GetWindowProc(), pThis); + newWindowProc = pThis->m_thunk.GetWNDPROC(); + pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc))); + Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass + pThis->m_hWnd = hWnd; + return newWindowProc(hWnd, uMsg, wParam, lParam); + } + + static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis = reinterpret_cast<CWindowImplBaseT< TBase, TWinTraits> *>(hWnd); + _ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam); + LRESULT lResult; + const _ATL_MSG *previousMessage; + BOOL handled; + LONG_PTR saveWindowProc; + + ATLASSERT(pThis != NULL && (pThis->m_dwState & WINSTATE_DESTROYED) == 0 && pThis->m_hWnd != NULL); + if (pThis == NULL || (pThis->m_dwState & WINSTATE_DESTROYED) != 0 || pThis->m_hWnd == NULL) + return 0; + + hWnd = pThis->m_hWnd; + previousMessage = pThis->m_pCurrentMsg; + pThis->m_pCurrentMsg = &msg; + + handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0); + ATLASSERT(pThis->m_pCurrentMsg == &msg); + + if (handled == FALSE) + { + if (uMsg == WM_NCDESTROY) + { + saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC); + lResult = pThis->DefWindowProc(uMsg, wParam, lParam); + if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC)) + ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc)); + pThis->m_dwState |= WINSTATE_DESTROYED; + } + else + lResult = pThis->DefWindowProc(uMsg, wParam, lParam); + } + ATLASSERT(pThis->m_pCurrentMsg == &msg); + pThis->m_pCurrentMsg = previousMessage; + if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0) + { + pThis->m_dwState &= ~WINSTATE_DESTROYED; + pThis->m_hWnd = NULL; + pThis->OnFinalMessage(hWnd); + } + return lResult; + } + + HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle, + _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam) + { + HWND hWnd; + + ATLASSERT(m_hWnd == NULL); + ATLASSERT(atom != 0); + if (atom == 0) + return NULL; + if (m_thunk.Init(NULL, NULL) == FALSE) + { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + _AtlWinModule.AddCreateWndData(&m_thunk.cd, this); + if (MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD) != 0) + MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this; + if (rect.m_lpRect == NULL) + rect.m_lpRect = &TBase::rcDefault; + hWnd = ::CreateWindowEx(dwExStyle, reinterpret_cast<LPCWSTR>(MAKEINTATOM(atom)), szWindowName, dwStyle, rect.m_lpRect->left, + rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left, rect.m_lpRect->bottom - rect.m_lpRect->top, + hWndParent, MenuOrID.m_hMenu, _AtlBaseModule.GetModuleInstance(), lpCreateParam); + + ATLASSERT(m_hWnd == hWnd); + + return hWnd; + } +}; + +template <class T, class TBase = CWindow, class TWinTraits = CControlWinTraits> +class CWindowImpl : public CWindowImplBaseT<TBase, TWinTraits> +{ +public: + static LPCTSTR GetWndCaption() + { + return NULL; + } + + HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, + DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis; + ATOM atom; + + ATLASSERT(m_hWnd == NULL); + pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this); + + if (T::GetWndClassInfo().m_lpszOrigName == NULL) + T::GetWndClassInfo().m_lpszOrigName = pThis->GetWndClassName(); + atom = T::GetWndClassInfo().Register(&pThis->m_pfnSuperWindowProc); + + if (szWindowName == NULL) + szWindowName = T::GetWndCaption(); + dwStyle = T::GetWndStyle(dwStyle); + dwExStyle = T::GetWndExStyle(dwExStyle); + + return CWindowImplBaseT<TBase, TWinTraits>::Create(hWndParent, rect, szWindowName, dwStyle, + dwExStyle, MenuOrID, atom, lpCreateParam); + } +}; + +template <class TBase = CWindow, class TWinTraits = CControlWinTraits> +class CContainedWindowT : public TBase +{ +public: + CWndProcThunk m_thunk; + LPCTSTR m_lpszClassName; + WNDPROC m_pfnSuperWindowProc; + CMessageMap *m_pObject; + DWORD m_dwMsgMapID; + const _ATL_MSG *m_pCurrentMsg; +public: + CContainedWindowT(CMessageMap *pObject, DWORD dwMsgMapID = 0) + { + m_lpszClassName = TBase::GetWndClassName(); + m_pfnSuperWindowProc = ::DefWindowProc; + m_pObject = pObject; + m_dwMsgMapID = dwMsgMapID; + m_pCurrentMsg = NULL; + } + + CContainedWindowT(LPTSTR lpszClassName, CMessageMap *pObject, DWORD dwMsgMapID = 0) + { + m_lpszClassName = lpszClassName; + m_pfnSuperWindowProc = ::DefWindowProc; + m_pObject = pObject; + m_dwMsgMapID = dwMsgMapID; + m_pCurrentMsg = NULL; + } + + LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CWindowImplBaseT<TBase, TWinTraits> *pThis; + + pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this); + return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam); + } + + BOOL SubclassWindow(HWND hWnd) + { + CContainedWindowT<TBase> *pThis; + WNDPROC newWindowProc; + WNDPROC oldWindowProc; + BOOL result; + + ATLASSERT(m_hWnd == NULL); + ATLASSERT(::IsWindow(hWnd)); + + pThis = reinterpret_cast<CContainedWindowT<TBase> *>(this); + + result = m_thunk.Init(WindowProc, pThis); + if (result == FALSE) + return FALSE; + newWindowProc = m_thunk.GetWNDPROC(); + oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc))); + if (oldWindowProc == NULL) + return FALSE; + m_pfnSuperWindowProc = oldWindowProc; + pThis->m_hWnd = hWnd; + return TRUE; + } + + static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CContainedWindowT<TBase> *pThis; + WNDPROC newWindowProc; + WNDPROC GCCU(pOldProc); + + pThis = reinterpret_cast<CContainedWindowT<TBase> *>(_AtlWinModule.ExtractCreateWndData()); + ATLASSERT(pThis != NULL); + if (pThis == NULL) + return 0; + pThis->m_thunk.Init(WindowProc, pThis); + newWindowProc = pThis->m_thunk.GetWNDPROC(); + pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc))); + Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass + pThis->m_hWnd = hWnd; + return newWindowProc(hWnd, uMsg, wParam, lParam); + } + + static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) + { + CContainedWindowT<TBase> *pThis = reinterpret_cast<CContainedWindowT<TBase> *>(hWnd); + _ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam); + LRESULT lResult; + const _ATL_MSG *previousMessage; + BOOL handled; + LONG_PTR saveWindowProc; + + ATLASSERT(pThis != NULL && pThis->m_hWnd != NULL && pThis->m_pObject != NULL); + if (pThis == NULL || pThis->m_hWnd == NULL || pThis->m_pObject == NULL) + return 0; + + hWnd = pThis->m_hWnd; + previousMessage = pThis->m_pCurrentMsg; + pThis->m_pCurrentMsg = &msg; + + handled = pThis->m_pObject->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, pThis->m_dwMsgMapID); + ATLASSERT(pThis->m_pCurrentMsg == &msg); + + pThis->m_pCurrentMsg = previousMessage; + if (handled == FALSE) + { + if (uMsg == WM_NCDESTROY) + { + saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC); + lResult = pThis->DefWindowProc(uMsg, wParam, lParam); + if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC)) + ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc)); + pThis->m_hWnd = NULL; + } + else + lResult = pThis->DefWindowProc(uMsg, wParam, lParam); + } + return lResult; + } + +}; +typedef CContainedWindowT<CWindow> CContainedWindow; + +#define BEGIN_MSG_MAP(theClass) \ +public: \ + BOOL ProcessWindowMessage(HWND GCCU(hWnd), UINT GCCU(uMsg), WPARAM GCCU(wParam), LPARAM GCCU(lParam), LRESULT &GCCU(lResult), DWORD dwMsgMapID = 0) \ + { \ + BOOL GCCU(bHandled) = TRUE; \ + Unused(hWnd); \ + Unused(uMsg); \ + Unused(wParam); \ + Unused(lParam); \ + Unused(lResult); \ + Unused(bHandled); \ + switch(dwMsgMapID) \ + { \ + case 0: + +#define END_MSG_MAP() \ + break; \ + default: \ + ATLASSERT(FALSE); \ + break; \ + } \ + return FALSE; \ + } + +#define MESSAGE_HANDLER(msg, func) \ + if (uMsg == msg) \ + { \ + bHandled = TRUE; \ + lResult = func(uMsg, wParam, lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func) \ + if (uMsg >= msgFirst && uMsg <= msgLast) \ + { \ + bHandled = TRUE; \ + lResult = func(uMsg, wParam, lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define COMMAND_ID_HANDLER(id, func) \ + if (uMsg == WM_COMMAND && id == LOWORD(wParam)) \ + { \ + bHandled = TRUE; \ + lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define COMMAND_RANGE_HANDLER(idFirst, idLast, func) \ + if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst && LOWORD(wParam) <= idLast) \ + { \ + bHandled = TRUE; \ + lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define NOTIFY_CODE_HANDLER(cd, func) \ + if(uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code) \ + { \ + bHandled = TRUE; \ + lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define NOTIFY_HANDLER(id, cd, func) \ + if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom && cd == ((LPNMHDR)lParam)->code) \ + { \ + bHandled = TRUE; \ + lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \ + if (bHandled) \ + return TRUE; \ + } + +#define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd) \ +static ATL::CWndClassInfo& GetWndClassInfo() \ +{ \ + static ATL::CWndClassInfo wc = \ + { \ + { sizeof(WNDCLASSEX), style, StartWindowProc, \ + 0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL }, \ + NULL, NULL, IDC_ARROW, TRUE, 0, _T("") \ + }; \ + return wc; \ +} + +struct _ATL_WNDCLASSINFOW +{ + WNDCLASSEXW m_wc; + LPCWSTR m_lpszOrigName; + WNDPROC pWndProc; + LPCWSTR m_lpszCursorID; + BOOL m_bSystemCursor; + ATOM m_atom; + WCHAR m_szAutoName[5 + sizeof(void *)]; + + ATOM Register(WNDPROC *p) + { + if (m_atom == 0) + m_atom = RegisterClassEx(&m_wc); + return m_atom; + } +}; + +}; // namespace ATL + +#endif // _atlwin_h Propchange: trunk/reactos/lib/atl/atlwin.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/lib/atl/statreg.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/atl/statreg.h?rev=4364… ============================================================================== --- trunk/reactos/lib/atl/statreg.h (added) +++ trunk/reactos/lib/atl/statreg.h [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -1,0 +1,679 @@ +/* + * ReactOS ATL + * + * Copyright 2005 Jacek Caban + * Copyright 2009 Andrew Hill <ash77(a)reactos.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _statreg_h +#define _statreg_h + +class IRegistrarBase : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) = 0; + virtual HRESULT STDMETHODCALLTYPE ClearReplacements() = 0; +}; + +namespace ATL +{ + +class CRegObject : public IRegistrarBase +{ +public: + typedef struct rep_list_str + { + LPOLESTR key; + LPOLESTR item; + int key_len; + struct rep_list_str *next; + } rep_list; + + typedef struct + { + LPOLESTR str; + DWORD alloc; + DWORD len; + } strbuf; + + rep_list *m_rep; + +public: + CRegObject() + { + m_rep = NULL; + } + + ~CRegObject() + { + HRESULT hResult; + + hResult = ClearReplacements(); + ATLASSERT(SUCCEEDED(hResult)); + } + + HRESULT STDMETHODCALLTYPE QueryInterface(const IID & /* riid */, void ** /* ppvObject */ ) + { + ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); + return E_NOTIMPL; + } + + ULONG STDMETHODCALLTYPE AddRef() + { + ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); + return 1; + } + + ULONG STDMETHODCALLTYPE Release() + { + ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); + return 0; + } + + HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) + { + int len; + rep_list *new_rep; + + new_rep = reinterpret_cast<rep_list *>(HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list))); + + new_rep->key_len = lstrlenW(key); + new_rep->key = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR))); + memcpy(new_rep->key, key, (new_rep->key_len + 1) * sizeof(OLECHAR)); + + len = lstrlenW(item) + 1; + new_rep->item = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, len * sizeof(OLECHAR))); + memcpy(new_rep->item, item, len * sizeof(OLECHAR)); + + new_rep->next = m_rep; + m_rep = new_rep; + + return S_OK; + } + + HRESULT STDMETHODCALLTYPE ClearReplacements() + { + rep_list *iter; + rep_list *iter2; + + iter = m_rep; + while (iter) + { + iter2 = iter->next; + HeapFree(GetProcessHeap(), 0, iter->key); + HeapFree(GetProcessHeap(), 0, iter->item); + HeapFree(GetProcessHeap(), 0, iter); + iter = iter2; + } + + m_rep = NULL; + return S_OK; + } + + HRESULT STDMETHODCALLTYPE ResourceRegisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType) + { + return RegisterWithResource(resFileName, szID, szType, TRUE); + } + + HRESULT STDMETHODCALLTYPE ResourceUnregisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType) + { + return RegisterWithResource(resFileName, szID, szType, FALSE); + } + + HRESULT STDMETHODCALLTYPE FileRegister(LPCOLESTR fileName) + { + return RegisterWithFile(fileName, TRUE); + } + + HRESULT STDMETHODCALLTYPE FileUnregister(LPCOLESTR fileName) + { + return RegisterWithFile(fileName, FALSE); + } + + HRESULT STDMETHODCALLTYPE StringRegister(LPCOLESTR data) + { + return RegisterWithString(data, TRUE); + } + + HRESULT STDMETHODCALLTYPE StringUnregister(LPCOLESTR data) + { + return RegisterWithString(data, FALSE); + } + + HRESULT STDMETHODCALLTYPE ResourceRegister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType) + { + return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType); + } + + HRESULT STDMETHODCALLTYPE ResourceUnregister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType) + { + return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType); + } + +protected: + HRESULT STDMETHODCALLTYPE RegisterWithResource(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL doRegister) + { + return resource_register(resFileName, szID, szType, doRegister); + } + + HRESULT STDMETHODCALLTYPE RegisterWithFile(LPCOLESTR fileName, BOOL doRegister) + { + return file_register(fileName, doRegister); + } + + HRESULT STDMETHODCALLTYPE RegisterWithString(LPCOLESTR data, BOOL doRegister) + { + return string_register(data, doRegister); + } + +private: + inline LONG RegDeleteTreeX(HKEY parentKey, LPCTSTR subKeyName) + { + wchar_t szBuffer[256]; + DWORD dwSize; + FILETIME time; + HKEY childKey; + LONG lRes; + + ATLASSERT(parentKey != NULL); + lRes = RegOpenKeyEx(parentKey, subKeyName, 0, KEY_READ | KEY_WRITE, &childKey); + if (lRes != ERROR_SUCCESS) + return lRes; + + dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]); + while (RegEnumKeyExW(parentKey, 0, szBuffer, &dwSize, NULL, NULL, NULL, &time) == ERROR_SUCCESS) + { + lRes = RegDeleteTreeX(childKey, szBuffer); + if (lRes != ERROR_SUCCESS) + return lRes; + dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]); + } + RegCloseKey(childKey); + return RegDeleteKey(parentKey, subKeyName); + } + + void strbuf_init(strbuf *buf) + { + buf->str = reinterpret_cast<LPOLESTR>(HeapAlloc(GetProcessHeap(), 0, 128 * sizeof(WCHAR))); + buf->alloc = 128; + buf->len = 0; + } + + void strbuf_write(LPCOLESTR str, strbuf *buf, int len) + { + if (len == -1) + len = lstrlenW(str); + if (buf->len+len+1 >= buf->alloc) + { + buf->alloc = (buf->len + len) * 2; + buf->str = reinterpret_cast<LPOLESTR>(HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc * sizeof(WCHAR))); + } + memcpy(buf->str + buf->len, str, len * sizeof(OLECHAR)); + buf->len += len; + buf->str[buf->len] = '\0'; + } + + + HRESULT file_register(LPCOLESTR fileName, BOOL do_register) + { + HANDLE file; + DWORD filelen; + DWORD len; + LPWSTR regstrw; + LPSTR regstra; + LRESULT lres; + HRESULT hResult; + + file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); + if (file != INVALID_HANDLE_VALUE) + { + filelen = GetFileSize(file, NULL); + regstra = reinterpret_cast<LPSTR>(HeapAlloc(GetProcessHeap(), 0, filelen)); + lres = ReadFile(file, regstra, filelen, NULL, NULL); + if (lres == ERROR_SUCCESS) + { + len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0) + 1; + regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR))); + MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len); + regstrw[len - 1] = '\0'; + + hResult = string_register(regstrw, do_register); + + HeapFree(GetProcessHeap(), 0, regstrw); + } + else + { + hResult = HRESULT_FROM_WIN32(lres); + } + HeapFree(GetProcessHeap(), 0, regstra); + CloseHandle(file); + } + else + { + hResult = HRESULT_FROM_WIN32(GetLastError()); + } + + return hResult; + } + + HRESULT resource_register(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL do_register) + { + HINSTANCE hins; + HRSRC src; + HGLOBAL regstra; + LPWSTR regstrw; + DWORD len; + DWORD reslen; + HRESULT hResult; + + hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE); + if (hins) + { + src = FindResourceW(hins, szID, szType); + if (src) + { + regstra = LoadResource(hins, src); + reslen = SizeofResource(hins, src); + if (regstra) + { + len = MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, NULL, 0) + 1; + regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR))); + MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, regstrw, len); + regstrw[len - 1] = '\0'; + + hResult = string_register(regstrw, do_register); + + HeapFree(GetProcessHeap(), 0, regstrw); + } + else + hResult = HRESULT_FROM_WIN32(GetLastError()); + } + else + hResult = HRESULT_FROM_WIN32(GetLastError()); + FreeLibrary(hins); + } + else + hResult = HRESULT_FROM_WIN32(GetLastError()); + + return hResult; + } + + HRESULT string_register(LPCOLESTR data, BOOL do_register) + { + strbuf buf; + HRESULT hResult; + + strbuf_init(&buf); + hResult = do_preprocess(data, &buf); + if (SUCCEEDED(hResult)) + { + hResult = do_process_root_key(buf.str, do_register); + if (FAILED(hResult) && do_register) + do_process_root_key(buf.str, FALSE); + } + + HeapFree(GetProcessHeap(), 0, buf.str); + return hResult; + } + + HRESULT do_preprocess(LPCOLESTR data, strbuf *buf) + { + LPCOLESTR iter; + LPCOLESTR iter2; + rep_list *rep_iter; + + iter2 = data; + iter = wcschr(data, '%'); + while (iter) + { + strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); + + iter2 = ++iter; + if (!*iter2) + return DISP_E_EXCEPTION; + iter = wcschr(iter2, '%'); + if (!iter) + return DISP_E_EXCEPTION; + + if (iter == iter2) + strbuf_write(_T("%"), buf, 1); + else + { + for (rep_iter = m_rep; rep_iter; rep_iter = rep_iter->next) + { + if (rep_iter->key_len == iter - iter2 && !_memicmp(iter2, rep_iter->key, rep_iter->key_len * sizeof(wchar_t))) + break; + } + if (!rep_iter) + return DISP_E_EXCEPTION; + + strbuf_write(rep_iter->item, buf, -1); + } + + iter2 = ++iter; + iter = wcschr(iter, '%'); + } + + strbuf_write(iter2, buf, -1); + + return S_OK; + } + + HRESULT get_word(LPCOLESTR *str, strbuf *buf) + { + LPCOLESTR iter; + LPCOLESTR iter2; + + iter2 = *str; + buf->len = 0; + buf->str[0] = '\0'; + + while (iswspace (*iter2)) + iter2++; + iter = iter2; + if (!*iter) + { + *str = iter; + return S_OK; + } + + if (*iter == '}' || *iter == '=') + { + strbuf_write(iter++, buf, 1); + } + else if (*iter == '\'') + { + iter2 = ++iter; + iter = wcschr(iter, '\''); + if (!iter) + { + *str = iter; + return DISP_E_EXCEPTION; + } + strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); + iter++; + } + else + { + while (*iter && !iswspace(*iter)) + iter++; + strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); + } + + while (iswspace(*iter)) + iter++; + *str = iter; + return S_OK; + } + + HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register) + { + LPCOLESTR iter; + HRESULT hres; + LONG lres; + HKEY hkey; + strbuf name; + + enum { + NORMAL, + NO_REMOVE, + IS_VAL, + FORCE_REMOVE, + DO_DELETE + } key_type = NORMAL; + + static const wchar_t *wstrNoRemove = _T("NoRemove"); + static const wchar_t *wstrForceRemove = _T("ForceRemove"); + static const wchar_t *wstrDelete = _T("Delete"); + static const wchar_t *wstrval = _T("val"); + + iter = *pstr; + hkey = NULL; + iter = *pstr; + hres = get_word(&iter, buf); + if (FAILED(hres)) + return hres; + strbuf_init(&name); + + while(buf->str[1] || buf->str[0] != '}') + { + key_type = NORMAL; + if (!lstrcmpiW(buf->str, wstrNoRemove)) + key_type = NO_REMOVE; + else if (!lstrcmpiW(buf->str, wstrForceRemove)) + key_type = FORCE_REMOVE; + else if (!lstrcmpiW(buf->str, wstrval)) + key_type = IS_VAL; + else if (!lstrcmpiW(buf->str, wstrDelete)) + key_type = DO_DELETE; + + if (key_type != NORMAL) + { + hres = get_word(&iter, buf); + if(FAILED(hres)) + break; + } + + if (do_register) + { + if (key_type == IS_VAL) + { + hkey = parent_key; + strbuf_write(buf->str, &name, -1); + } + else if (key_type == DO_DELETE) + { + RegDeleteTreeX(parent_key, buf->str); + } + else + { + if (key_type == FORCE_REMOVE) + RegDeleteTreeX(parent_key, buf->str); + lres = RegCreateKey(parent_key, buf->str, &hkey); + if (lres != ERROR_SUCCESS) + { + hres = HRESULT_FROM_WIN32(lres); + break; + } + } + } + else if (key_type != IS_VAL && key_type != DO_DELETE) + { + strbuf_write(buf->str, &name, -1); + lres = RegOpenKey(parent_key, buf->str, &hkey); + if (lres != ERROR_SUCCESS) + { + } + } + + if (key_type != DO_DELETE && *iter == '=') + { + iter++; + hres = get_word(&iter, buf); + if (FAILED(hres)) + break; + if (buf->len != 1) + { + hres = DISP_E_EXCEPTION; + break; + } + if (do_register) + { + switch(buf->str[0]) + { + case 's': + hres = get_word(&iter, buf); + if (FAILED(hres)) + break; + lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_SZ, (PBYTE)buf->str, + (lstrlenW(buf->str) + 1) * sizeof(WCHAR)); + if (lres != ERROR_SUCCESS) + { + hres = HRESULT_FROM_WIN32(lres); + break; + } + break; + case 'd': + { + WCHAR *end; + DWORD dw; + if(*iter == '0' && iter[1] == 'x') + { + iter += 2; + dw = wcstol(iter, &end, 16); + } + else + { + dw = wcstol(iter, &end, 10); + } + iter = end; + lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_DWORD, (PBYTE)&dw, sizeof(dw)); + if (lres != ERROR_SUCCESS) + { + hres = HRESULT_FROM_WIN32(lres); + break; + } + break; + } + default: + hres = DISP_E_EXCEPTION; + } + if (FAILED(hres)) + break; + } + else + { + if (*iter == '-') + iter++; + hres = get_word(&iter, buf); + if (FAILED(hres)) + break; + } + } + else if(key_type == IS_VAL) + { + hres = DISP_E_EXCEPTION; + break; + } + + if (key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && iswspace(iter[1])) + { + hres = get_word(&iter, buf); + if (FAILED(hres)) + break; + hres = do_process_key(&iter, hkey, buf, do_register); + if (FAILED(hres)) + break; + } + + if (!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) + { + RegDeleteKey(parent_key, name.str); + } + + if (hkey && key_type != IS_VAL) + RegCloseKey(hkey); + hkey = 0; + name.len = 0; + + hres = get_word(&iter, buf); + if (FAILED(hres)) + break; + } + + HeapFree(GetProcessHeap(), 0, name.str); + if (hkey && key_type != IS_VAL) + RegCloseKey(hkey); + *pstr = iter; + return hres; + } + + HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register) + { + LPCOLESTR iter; + strbuf buf; + unsigned int i; + HRESULT hResult; + static const struct { + wchar_t *name; + HKEY key; + } root_keys[] = { + {_T("HKEY_CLASSES_ROOT"), HKEY_CLASSES_ROOT}, + {_T("HKEY_CURRENT_USER"), HKEY_CURRENT_USER}, + {_T("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE}, + {_T("HKEY_USERS"), HKEY_USERS}, + {_T("HKEY_PERFORMANCE_DATA"), HKEY_PERFORMANCE_DATA}, + {_T("HKEY_DYN_DATA"), HKEY_DYN_DATA}, + {_T("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG}, + {_T("HKCR"), HKEY_CLASSES_ROOT}, + {_T("HKCU"), HKEY_CURRENT_USER}, + {_T("HKLM"), HKEY_LOCAL_MACHINE}, + {_T("HKU"), HKEY_USERS}, + {_T("HKPD"), HKEY_PERFORMANCE_DATA}, + {_T("HKDD"), HKEY_DYN_DATA}, + {_T("HKCC"), HKEY_CURRENT_CONFIG}, + }; + + iter = data; + hResult = S_OK; + + strbuf_init(&buf); + hResult = get_word(&iter, &buf); + if (FAILED(hResult)) + return hResult; + + while (*iter) + { + if (!buf.len) + { + hResult = DISP_E_EXCEPTION; + break; + } + for (i = 0; i < sizeof(root_keys) / sizeof(root_keys[0]); i++) + { + if (!lstrcmpiW(buf.str, root_keys[i].name)) + break; + } + if (i == sizeof(root_keys) / sizeof(root_keys[0])) + { + hResult = DISP_E_EXCEPTION; + break; + } + hResult = get_word(&iter, &buf); + if (FAILED(hResult)) + break; + if (buf.str[1] || buf.str[0] != '{') + { + hResult = DISP_E_EXCEPTION; + break; + } + hResult = do_process_key(&iter, root_keys[i].key, &buf, do_register); + if (FAILED(hResult)) + break; + hResult = get_word(&iter, &buf); + if (FAILED(hResult)) + break; + } + HeapFree(GetProcessHeap(), 0, buf.str); + return hResult; + } + +}; + +}; //namespace ATL + +#endif // _statreg_h Propchange: trunk/reactos/lib/atl/statreg.h ------------------------------------------------------------------------------ svn:eol-style = native Modified: trunk/reactos/lib/lib.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/lib.rbuild?rev=43645&r… ============================================================================== --- trunk/reactos/lib/lib.rbuild [iso-8859-1] (original) +++ trunk/reactos/lib/lib.rbuild [iso-8859-1] Tue Oct 20 14:26:51 2009 @@ -6,6 +6,9 @@ </directory> <directory name="sdk"> <xi:include href="sdk/sdk.rbuild" /> + </directory> + <directory name="atl"> + <xi:include href="atl/atl.rbuild" /> </directory> <directory name="cmlib"> <xi:include href="cmlib/cmlib.rbuild" />

1 0

[fireball] 43644: [fastfat_new] - Fix an incorrectly placed closing bracket which resulted in ignoring almost all actions when performing relative open. This results in a massive reformatting of FatiCreate.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 14:03:51 2009 New Revision: 43644 URL: http://svn.reactos.org/svn/reactos?rev=43644&view=rev Log: [fastfat_new] - Fix an incorrectly placed closing bracket which resulted in ignoring almost all actions when performing relative open. This results in a massive reformatting of FatiCreate. Modified: trunk/reactos/drivers/filesystems/fastfat_new/create.c Modified: trunk/reactos/drivers/filesystems/fastfat_new/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] Tue Oct 20 14:03:51 2009 @@ -605,262 +605,47 @@ ParentDcb = Vcb->RootDcb; DPRINT("ParentDcb %p\n", ParentDcb); } - - /* Check for backslash at the end */ - if (FileName.Length && - FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'\\') - { - /* Cut it out */ - FileName.Length -= sizeof(WCHAR); - - /* Remember we cut it */ - EndBackslash = TRUE; - } - - /* Ensure the name is set */ - if (!ParentDcb->FullFileName.Buffer) - { - /* Set it if it's missing */ - FatSetFullFileNameInFcb(IrpContext, ParentDcb); - } - - /* Check max path length */ - if (ParentDcb->FullFileName.Length + FileName.Length + sizeof(WCHAR) <= FileName.Length) - { - DPRINT1("Max length is way off\n"); - Iosb.Status = STATUS_OBJECT_NAME_INVALID; - ASSERT(FALSE); - } - - /* Loop through FCBs to find a good one */ - while (TRUE) - { - Fcb = ParentDcb; - - /* Dissect the name */ - RemainingPart = FileName; - while (RemainingPart.Length) - { - FsRtlDissectName(RemainingPart, &FirstName, &NextName); - - /* Check for validity */ - if ((NextName.Length && NextName.Buffer[0] == L'\\') || - (NextName.Length > 255 * sizeof(WCHAR))) - { - /* The name is invalid */ - DPRINT1("Invalid name found\n"); - Iosb.Status = STATUS_OBJECT_NAME_INVALID; - ASSERT(FALSE); - } - - /* Convert the name to ANSI */ - AnsiFirstName.Buffer = ExAllocatePool(PagedPool, FirstName.Length); - AnsiFirstName.Length = 0; - AnsiFirstName.MaximumLength = FirstName.Length; - Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiFirstName, &FirstName, FALSE); - - if (!NT_SUCCESS(Status)) - { - DPRINT1("RtlUpcaseUnicodeStringToCountedOemString() failed with 0x%08x\n", Status); - ASSERT(FALSE); - NextFcb = NULL; - AnsiFirstName.Length = 0; - } - else - { - /* Find the coresponding FCB */ - NextFcb = FatFindFcb(IrpContext, - &Fcb->Dcb.SplayLinksAnsi, - (PSTRING)&AnsiFirstName, - &OpenedAsDos); - } - - /* If nothing found - try with unicode */ - if (!NextFcb && Fcb->Dcb.SplayLinksUnicode) - { - FileNameUpcased.Buffer = FsRtlAllocatePool(PagedPool, FirstName.Length); - FileNameUpcased.Length = 0; - FileNameUpcased.MaximumLength = FirstName.Length; - - /* Downcase and then upcase to normalize it */ - Status = RtlDowncaseUnicodeString(&FileNameUpcased, &FirstName, FALSE); - Status = RtlUpcaseUnicodeString(&FileNameUpcased, &FileNameUpcased, FALSE); - - /* Try to find FCB again using unicode name */ - NextFcb = FatFindFcb(IrpContext, - &Fcb->Dcb.SplayLinksUnicode, - (PSTRING)&FileNameUpcased, - &OpenedAsDos); - } - - /* Move to the next FCB */ - if (NextFcb) - { - Fcb = NextFcb; - RemainingPart = NextName; - } - - /* Break out of this loop if nothing can be found */ - if (!NextFcb || - NextName.Length == 0 || - FatNodeType(NextFcb) == FAT_NTC_FCB) - { - break; - } - } - - /* Ensure remaining name doesn't start from a backslash */ - if (RemainingPart.Length && - RemainingPart.Buffer[0] == L'\\') - { - /* Cut it */ - RemainingPart.Buffer++; - RemainingPart.Length -= sizeof(WCHAR); - } - - if (Fcb->Condition == FcbGood) - { - /* Good FCB, break out of the loop */ - break; - } - else - { - ASSERT(FALSE); - } - } - - /* We have a valid FCB now */ - if (!RemainingPart.Length) - { - /* Check for target dir open */ - if (OpenTargetDirectory) - { - DPRINT1("Opening target dir is missing\n"); - ASSERT(FALSE); - } - - /* Check this FCB's type */ - if (FatNodeType(Fcb) == FAT_NTC_ROOT_DCB || - FatNodeType(Fcb) == FAT_NTC_DCB) - { - /* Open a directory */ - if (NonDirectoryFile) - { - /* Forbidden */ - Iosb.Status = STATUS_FILE_IS_A_DIRECTORY; - ASSERT(FALSE); - return Iosb.Status; - } - - /* Open existing DCB */ - Iosb = FatiOpenExistingDcb(IrpContext, - FileObject, - Vcb, - Fcb, - DesiredAccess, - ShareAccess, - CreateDisposition, - NoEaKnowledge, - DeleteOnClose); - - /* Save information */ - Irp->IoStatus.Information = Iosb.Information; - - /* Unlock VCB */ - FatReleaseVcb(IrpContext, Vcb); - - /* Complete the request */ - FatCompleteRequest(IrpContext, Irp, Iosb.Status); - - return Iosb.Status; - } - else if (FatNodeType(Fcb) == FAT_NTC_FCB) - { - /* Open a file */ - if (OpenDirectory) - { - /* Forbidden */ - Iosb.Status = STATUS_NOT_A_DIRECTORY; - ASSERT(FALSE); - return Iosb.Status; - } - - /* Check for trailing backslash */ - if (EndBackslash) - { - /* Forbidden */ - Iosb.Status = STATUS_OBJECT_NAME_INVALID; - ASSERT(FALSE); - return Iosb.Status; - } - - Iosb = FatiOpenExistingFcb(IrpContext, - FileObject, - Vcb, - Fcb, - DesiredAccess, - ShareAccess, - AllocationSize, - EaBuffer, - EaLength, - FileAttributes, - CreateDisposition, - NoEaKnowledge, - DeleteOnClose, - OpenedAsDos, - &OplockPostIrp); - - /* Check if it's pending */ - if (Iosb.Status != STATUS_PENDING) - { - /* In case of success set cache supported flag */ - if (NT_SUCCESS(Iosb.Status) && !NoIntermediateBuffering) - { - SetFlag(FileObject->Flags, FO_CACHE_SUPPORTED); - } - - /* Save information */ - Irp->IoStatus.Information = Iosb.Information; - - /* Unlock VCB */ - FatReleaseVcb(IrpContext, Vcb); - - /* Complete the request */ - FatCompleteRequest(IrpContext, Irp, Iosb.Status); - - return Iosb.Status; - } - else - { - /* Queue this IRP */ - UNIMPLEMENTED; - ASSERT(FALSE); - } - } - else - { - /* Unexpected FCB type */ - KeBugCheckEx(/*FAT_FILE_SYSTEM*/0x23, __LINE__, (ULONG_PTR)Fcb, 0, 0); - } - } - - /* During parsing we encountered a part which has no attached FCB/DCB. - Check that the parent is really DCB and not FCB */ - if (FatNodeType(Fcb) != FAT_NTC_ROOT_DCB && - FatNodeType(Fcb) != FAT_NTC_DCB) - { - DPRINT1("Weird FCB node type %x, expected DCB or root DCB\n", FatNodeType(Fcb)); - ASSERT(FALSE); - } - - /* Create additional DCBs for all path items */ - ParentDcb = Fcb; - while (TRUE) - { - FsRtlDissectName(RemainingPart, &FirstName, &RemainingPart); + } + + /* Check for backslash at the end */ + if (FileName.Length && + FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] == L'\\') + { + /* Cut it out */ + FileName.Length -= sizeof(WCHAR); + + /* Remember we cut it */ + EndBackslash = TRUE; + } + + /* Ensure the name is set */ + if (!ParentDcb->FullFileName.Buffer) + { + /* Set it if it's missing */ + FatSetFullFileNameInFcb(IrpContext, ParentDcb); + } + + /* Check max path length */ + if (ParentDcb->FullFileName.Length + FileName.Length + sizeof(WCHAR) <= FileName.Length) + { + DPRINT1("Max length is way off\n"); + Iosb.Status = STATUS_OBJECT_NAME_INVALID; + ASSERT(FALSE); + } + + /* Loop through FCBs to find a good one */ + while (TRUE) + { + Fcb = ParentDcb; + + /* Dissect the name */ + RemainingPart = FileName; + while (RemainingPart.Length) + { + FsRtlDissectName(RemainingPart, &FirstName, &NextName); /* Check for validity */ - if ((RemainingPart.Length && RemainingPart.Buffer[0] == L'\\') || + if ((NextName.Length && NextName.Buffer[0] == L'\\') || (NextName.Length > 255 * sizeof(WCHAR))) { /* The name is invalid */ @@ -877,55 +662,143 @@ if (!NT_SUCCESS(Status)) { + DPRINT1("RtlUpcaseUnicodeStringToCountedOemString() failed with 0x%08x\n", Status); ASSERT(FALSE); - } - - DPRINT("FirstName %wZ, RemainingPart %wZ\n", &FirstName, &RemainingPart); - - /* Break if came to the end */ - if (!RemainingPart.Length) break; - - /* Create a DCB for this entry */ - ParentDcb = FatCreateDcb(IrpContext, - Vcb, - ParentDcb, - NULL); - - /* Set its name */ - FatSetFullNameInFcb(ParentDcb, &FirstName); - } - - /* Try to open it and get a result, saying if this is a dir or a file */ - FfError = FatiTryToOpen(FileObject, Vcb); - - /* Check if we need to open target directory */ + NextFcb = NULL; + AnsiFirstName.Length = 0; + } + else + { + /* Find the coresponding FCB */ + NextFcb = FatFindFcb(IrpContext, + &Fcb->Dcb.SplayLinksAnsi, + (PSTRING)&AnsiFirstName, + &OpenedAsDos); + } + + /* If nothing found - try with unicode */ + if (!NextFcb && Fcb->Dcb.SplayLinksUnicode) + { + FileNameUpcased.Buffer = FsRtlAllocatePool(PagedPool, FirstName.Length); + FileNameUpcased.Length = 0; + FileNameUpcased.MaximumLength = FirstName.Length; + + /* Downcase and then upcase to normalize it */ + Status = RtlDowncaseUnicodeString(&FileNameUpcased, &FirstName, FALSE); + Status = RtlUpcaseUnicodeString(&FileNameUpcased, &FileNameUpcased, FALSE); + + /* Try to find FCB again using unicode name */ + NextFcb = FatFindFcb(IrpContext, + &Fcb->Dcb.SplayLinksUnicode, + (PSTRING)&FileNameUpcased, + &OpenedAsDos); + } + + /* Move to the next FCB */ + if (NextFcb) + { + Fcb = NextFcb; + RemainingPart = NextName; + } + + /* Break out of this loop if nothing can be found */ + if (!NextFcb || + NextName.Length == 0 || + FatNodeType(NextFcb) == FAT_NTC_FCB) + { + break; + } + } + + /* Ensure remaining name doesn't start from a backslash */ + if (RemainingPart.Length && + RemainingPart.Buffer[0] == L'\\') + { + /* Cut it */ + RemainingPart.Buffer++; + RemainingPart.Length -= sizeof(WCHAR); + } + + if (Fcb->Condition == FcbGood) + { + /* Good FCB, break out of the loop */ + break; + } + else + { + ASSERT(FALSE); + } + } + + /* We have a valid FCB now */ + if (!RemainingPart.Length) + { + /* Check for target dir open */ if (OpenTargetDirectory) { - // TODO: Open target directory - UNIMPLEMENTED; - } - - /* Check, if path is a directory or a file */ - if (FfError == FF_ERR_FILE_OBJECT_IS_A_DIR) - { + DPRINT1("Opening target dir is missing\n"); + ASSERT(FALSE); + } + + /* Check this FCB's type */ + if (FatNodeType(Fcb) == FAT_NTC_ROOT_DCB || + FatNodeType(Fcb) == FAT_NTC_DCB) + { + /* Open a directory */ if (NonDirectoryFile) { - DPRINT1("Can't open dir as a file\n"); - - /* Unlock VCB */ - FatReleaseVcb(IrpContext, Vcb); - - /* Complete the request */ + /* Forbidden */ Iosb.Status = STATUS_FILE_IS_A_DIRECTORY; - FatCompleteRequest(IrpContext, Irp, Iosb.Status); + ASSERT(FALSE); return Iosb.Status; } - /* Open this directory */ - Iosb = FatiOpenExistingDir(IrpContext, + /* Open existing DCB */ + Iosb = FatiOpenExistingDcb(IrpContext, FileObject, Vcb, - ParentDcb, + Fcb, + DesiredAccess, + ShareAccess, + CreateDisposition, + NoEaKnowledge, + DeleteOnClose); + + /* Save information */ + Irp->IoStatus.Information = Iosb.Information; + + /* Unlock VCB */ + FatReleaseVcb(IrpContext, Vcb); + + /* Complete the request */ + FatCompleteRequest(IrpContext, Irp, Iosb.Status); + + return Iosb.Status; + } + else if (FatNodeType(Fcb) == FAT_NTC_FCB) + { + /* Open a file */ + if (OpenDirectory) + { + /* Forbidden */ + Iosb.Status = STATUS_NOT_A_DIRECTORY; + ASSERT(FALSE); + return Iosb.Status; + } + + /* Check for trailing backslash */ + if (EndBackslash) + { + /* Forbidden */ + Iosb.Status = STATUS_OBJECT_NAME_INVALID; + ASSERT(FALSE); + return Iosb.Status; + } + + Iosb = FatiOpenExistingFcb(IrpContext, + FileObject, + Vcb, + Fcb, DesiredAccess, ShareAccess, AllocationSize, @@ -933,50 +806,177 @@ EaLength, FileAttributes, CreateDisposition, - DeleteOnClose); - - Irp->IoStatus.Information = Iosb.Information; + NoEaKnowledge, + DeleteOnClose, + OpenedAsDos, + &OplockPostIrp); + + /* Check if it's pending */ + if (Iosb.Status != STATUS_PENDING) + { + /* In case of success set cache supported flag */ + if (NT_SUCCESS(Iosb.Status) && !NoIntermediateBuffering) + { + SetFlag(FileObject->Flags, FO_CACHE_SUPPORTED); + } + + /* Save information */ + Irp->IoStatus.Information = Iosb.Information; + + /* Unlock VCB */ + FatReleaseVcb(IrpContext, Vcb); + + /* Complete the request */ + FatCompleteRequest(IrpContext, Irp, Iosb.Status); + + return Iosb.Status; + } + else + { + /* Queue this IRP */ + UNIMPLEMENTED; + ASSERT(FALSE); + } + } + else + { + /* Unexpected FCB type */ + KeBugCheckEx(/*FAT_FILE_SYSTEM*/0x23, __LINE__, (ULONG_PTR)Fcb, 0, 0); + } + } + + /* During parsing we encountered a part which has no attached FCB/DCB. + Check that the parent is really DCB and not FCB */ + if (FatNodeType(Fcb) != FAT_NTC_ROOT_DCB && + FatNodeType(Fcb) != FAT_NTC_DCB) + { + DPRINT1("Weird FCB node type %x, expected DCB or root DCB\n", FatNodeType(Fcb)); + ASSERT(FALSE); + } + + /* Create additional DCBs for all path items */ + ParentDcb = Fcb; + while (TRUE) + { + FsRtlDissectName(RemainingPart, &FirstName, &RemainingPart); + + /* Check for validity */ + if ((RemainingPart.Length && RemainingPart.Buffer[0] == L'\\') || + (NextName.Length > 255 * sizeof(WCHAR))) + { + /* The name is invalid */ + DPRINT1("Invalid name found\n"); + Iosb.Status = STATUS_OBJECT_NAME_INVALID; + ASSERT(FALSE); + } + + /* Convert the name to ANSI */ + AnsiFirstName.Buffer = ExAllocatePool(PagedPool, FirstName.Length); + AnsiFirstName.Length = 0; + AnsiFirstName.MaximumLength = FirstName.Length; + Status = RtlUpcaseUnicodeStringToCountedOemString(&AnsiFirstName, &FirstName, FALSE); + + if (!NT_SUCCESS(Status)) + { + ASSERT(FALSE); + } + + DPRINT("FirstName %wZ, RemainingPart %wZ\n", &FirstName, &RemainingPart); + + /* Break if came to the end */ + if (!RemainingPart.Length) break; + + /* Create a DCB for this entry */ + ParentDcb = FatCreateDcb(IrpContext, + Vcb, + ParentDcb, + NULL); + + /* Set its name */ + FatSetFullNameInFcb(ParentDcb, &FirstName); + } + + /* Try to open it and get a result, saying if this is a dir or a file */ + FfError = FatiTryToOpen(FileObject, Vcb); + + /* Check if we need to open target directory */ + if (OpenTargetDirectory) + { + // TODO: Open target directory + UNIMPLEMENTED; + } + + /* Check, if path is a directory or a file */ + if (FfError == FF_ERR_FILE_OBJECT_IS_A_DIR) + { + if (NonDirectoryFile) + { + DPRINT1("Can't open dir as a file\n"); /* Unlock VCB */ FatReleaseVcb(IrpContext, Vcb); /* Complete the request */ - FatCompleteRequest(IrpContext, Irp, Iosb.Status); - - return Iosb.Status; - } - - /* If end backslash here, then it's definately not permitted, - since we're opening files here */ - if (EndBackslash) - { - /* Unlock VCB */ - FatReleaseVcb(IrpContext, Vcb); - - /* Complete the request */ - Iosb.Status = STATUS_OBJECT_NAME_INVALID; + Iosb.Status = STATUS_FILE_IS_A_DIRECTORY; FatCompleteRequest(IrpContext, Irp, Iosb.Status); return Iosb.Status; } - /* Try to open the file */ - Iosb = FatiOpenExistingFile(IrpContext, - FileObject, - Vcb, - ParentDcb, - DesiredAccess, - ShareAccess, - AllocationSize, - EaBuffer, - EaLength, - FileAttributes, - CreateDisposition, - FALSE, - DeleteOnClose, - OpenedAsDos); + /* Open this directory */ + Iosb = FatiOpenExistingDir(IrpContext, + FileObject, + Vcb, + ParentDcb, + DesiredAccess, + ShareAccess, + AllocationSize, + EaBuffer, + EaLength, + FileAttributes, + CreateDisposition, + DeleteOnClose); Irp->IoStatus.Information = Iosb.Information; - } + + /* Unlock VCB */ + FatReleaseVcb(IrpContext, Vcb); + + /* Complete the request */ + FatCompleteRequest(IrpContext, Irp, Iosb.Status); + + return Iosb.Status; + } + + /* If end backslash here, then it's definately not permitted, + since we're opening files here */ + if (EndBackslash) + { + /* Unlock VCB */ + FatReleaseVcb(IrpContext, Vcb); + + /* Complete the request */ + Iosb.Status = STATUS_OBJECT_NAME_INVALID; + FatCompleteRequest(IrpContext, Irp, Iosb.Status); + return Iosb.Status; + } + + /* Try to open the file */ + Iosb = FatiOpenExistingFile(IrpContext, + FileObject, + Vcb, + ParentDcb, + DesiredAccess, + ShareAccess, + AllocationSize, + EaBuffer, + EaLength, + FileAttributes, + CreateDisposition, + FALSE, + DeleteOnClose, + OpenedAsDos); + + Irp->IoStatus.Information = Iosb.Information; /* Unlock VCB */ FatReleaseVcb(IrpContext, Vcb);

1 0

[fireball] 43643: [fastfat_new] - When creating a DCB with a known file handle, always build a full file name, because FullFAT opening code always needs a full name. - Fix debug prints (%Z -> %wZ).
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 12:32:37 2009 New Revision: 43643 URL: http://svn.reactos.org/svn/reactos?rev=43643&view=rev Log: [fastfat_new] - When creating a DCB with a known file handle, always build a full file name, because FullFAT opening code always needs a full name. - Fix debug prints (%Z -> %wZ). Modified: trunk/reactos/drivers/filesystems/fastfat_new/dir.c trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c Modified: trunk/reactos/drivers/filesystems/fastfat_new/dir.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/dir.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/dir.c [iso-8859-1] Tue Oct 20 12:32:37 2009 @@ -168,7 +168,12 @@ /* Set names */ if (FileHandle) + { FatSetFcbNames(IrpContext, Fcb); + + /* Ensure the full name is set */ + FatSetFullFileNameInFcb(IrpContext, Fcb); + } return Fcb; } Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c [iso-8859-1] Tue Oct 20 12:32:37 2009 @@ -317,7 +317,7 @@ TypeOfOpen = (*Ccb == NULL ? DirectoryFile : UserDirectoryOpen); - DPRINT1("Referencing a directory: %Z\n", &(*FcbOrDcb)->FullFileName); + DPRINT1("Referencing a directory: %wZ\n", &(*FcbOrDcb)->FullFileName); break; /* File */ @@ -327,7 +327,7 @@ TypeOfOpen = (*Ccb == NULL ? EaFile : UserFileOpen); - DPRINT("Referencing a file: %Z\n", &(*FcbOrDcb)->FullFileName); + DPRINT("Referencing a file: %wZ\n", &(*FcbOrDcb)->FullFileName); break;

1 0

[fireball] 43642: [fastfat_new] - From the moment of statically linking to FullFAT library this driver is infected by GPLv3. Fix headers accordingly.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 12:12:49 2009 New Revision: 43642 URL: http://svn.reactos.org/svn/reactos?rev=43642&view=rev Log: [fastfat_new] - From the moment of statically linking to FullFAT library this driver is infected by GPLv3. Fix headers accordingly. Modified: trunk/reactos/drivers/filesystems/fastfat_new/cleanup.c trunk/reactos/drivers/filesystems/fastfat_new/close.c trunk/reactos/drivers/filesystems/fastfat_new/create.c trunk/reactos/drivers/filesystems/fastfat_new/device.c trunk/reactos/drivers/filesystems/fastfat_new/dir.c trunk/reactos/drivers/filesystems/fastfat_new/ea.c trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c trunk/reactos/drivers/filesystems/fastfat_new/fastio.c trunk/reactos/drivers/filesystems/fastfat_new/fat.c trunk/reactos/drivers/filesystems/fastfat_new/fcb.c trunk/reactos/drivers/filesystems/fastfat_new/finfo.c trunk/reactos/drivers/filesystems/fastfat_new/flush.c trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c trunk/reactos/drivers/filesystems/fastfat_new/lock.c trunk/reactos/drivers/filesystems/fastfat_new/rw.c trunk/reactos/drivers/filesystems/fastfat_new/shutdown.c trunk/reactos/drivers/filesystems/fastfat_new/volume.c Modified: trunk/reactos/drivers/filesystems/fastfat_new/cleanup.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/cleanup.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/cleanup.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/cleanup.c * PURPOSE: Cleanup routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/close.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/close.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/close.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,7 +1,7 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory - * FILE: drivers/filesystems/fastfat/cleanup.c + * LICENSE: GNU GPLv3 as published by the Free Software Foundation + * FILE: drivers/filesystems/fastfat/close.c * PURPOSE: Closing routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) */ Modified: trunk/reactos/drivers/filesystems/fastfat_new/create.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/create.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/create.c * PURPOSE: Create routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/device.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/device.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/device.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/device.c * PURPOSE: Device control * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/dir.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/dir.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/dir.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/dir.c * PURPOSE: Directory Control * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/ea.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/ea.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/ea.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/ea.c * PURPOSE: Extended Attributes support * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fastfat.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fastfat.c * PURPOSE: Initialization routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastio.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fastio.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fastio.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fastio.c * PURPOSE: Fast IO routines * PROGRAMMERS: Herve Poussineau (hpoussin(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/fat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fat.c * PURPOSE: FAT support routines * PROGRAMMERS: Aleksey Bragin <aleksey(a)reactos.org> Modified: trunk/reactos/drivers/filesystems/fastfat_new/fcb.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fcb.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fcb.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fcb.c * PURPOSE: FCB manipulation routines. * PROGRAMMERS: Aleksey Bragin <aleksey(a)reactos.org> Modified: trunk/reactos/drivers/filesystems/fastfat_new/finfo.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/finfo.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/finfo.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/finfo.c * PURPOSE: File Information support routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/flush.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/flush.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/flush.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/flush.c * PURPOSE: Flushing routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fsctl.c * PURPOSE: Filesystem control * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/fullfat.c * PURPOSE: FullFAT integration routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/lock.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/lock.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/lock.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/lock.c * PURPOSE: Lock support routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/rw.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/rw.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/rw.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/rw.c * PURPOSE: Read/write support * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/shutdown.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/shutdown.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/shutdown.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/shutdown.c * PURPOSE: Shutdown support routines * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) Modified: trunk/reactos/drivers/filesystems/fastfat_new/volume.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/volume.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/volume.c [iso-8859-1] Tue Oct 20 12:12:49 2009 @@ -1,6 +1,6 @@ /* * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory + * LICENSE: GNU GPLv3 as published by the Free Software Foundation * FILE: drivers/filesystems/fastfat/volume.c * PURPOSE: Volume information * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org)

1 0

[fireball] 43641: [fastfat_new] - Cleanup the source code from parts which aren't needed anymore (after switching to FullFAT library usage). About 40kb of source code removed.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 12:02:27 2009 New Revision: 43641 URL: http://svn.reactos.org/svn/reactos?rev=43641&view=rev Log: [fastfat_new] - Cleanup the source code from parts which aren't needed anymore (after switching to FullFAT library usage). About 40kb of source code removed. Removed: trunk/reactos/drivers/filesystems/fastfat_new/blockdev.c trunk/reactos/drivers/filesystems/fastfat_new/direntry.c Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastfat.h trunk/reactos/drivers/filesystems/fastfat_new/fastfat.rbuild trunk/reactos/drivers/filesystems/fastfat_new/fat.c trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c trunk/reactos/drivers/filesystems/fastfat_new/rw.c Removed: trunk/reactos/drivers/filesystems/fastfat_new/blockdev.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/blockdev.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/blockdev.c (removed) @@ -1,447 +1,0 @@ -/* - * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory - * FILE: drivers/filesystems/fastfat/blockdev.c - * PURPOSE: Temporary sector reading support - * PROGRAMMERS: Alexey Vlasov - */ - -/* INCLUDES *****************************************************************/ - -#define NDEBUG -#include "fastfat.h" - -/* FUNCTIONS ***************************************************************/ -//FIXME: There is a conflicting function FatPerformDevIoCtrl doing same thing! -NTSTATUS -FatDiskIoControl_( - IN PDEVICE_OBJECT DeviceObject, - IN ULONG IoCtlCode, - IN PVOID InputBuffer, - IN ULONG InputBufferSize, - IN OUT PVOID OutputBuffer, - IN OUT PULONG OutputBufferSize OPTIONAL) -{ - PIRP Irp; - KEVENT Event; - NTSTATUS Status; - ULONG OutBufferSize; - IO_STATUS_BLOCK IoStatus; - - /* Set out buffer size if it was supplied. */ - OutBufferSize = (ARGUMENT_PRESENT(OutputBufferSize) - ? 0 : *OutputBufferSize); - - /* Initialize event if the operation will be pended. */ - KeInitializeEvent(&Event, NotificationEvent, FALSE); - - /* Build the Irp. */ - Irp = IoBuildDeviceIoControlRequest(IoCtlCode, DeviceObject, - InputBuffer, InputBufferSize, OutputBuffer, OutBufferSize, - FALSE, &Event, &IoStatus); - if (Irp == NULL) - return STATUS_INSUFFICIENT_RESOURCES; - - /* Send IRP to Disk Device */ - Status = IoCallDriver(DeviceObject, Irp); - if (Status == STATUS_PENDING) - { - KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); - Status = IoStatus.Status; - } - - /* Return output buffer length if required. */ - if (ARGUMENT_PRESENT(OutputBufferSize)) - *OutputBufferSize = IoStatus.Information; - return Status; -} - -NTSTATUS -FatLockUserBuffer ( - IN PFAT_IRP_CONTEXT IrpContext, - IN LOCK_OPERATION Operation, - IN ULONG BufferLength) -/* - * FUNCTION: - * - * - * ARGUMENTS: - * IrpContext = Pointer to FCB structure for the file. - * Operation = Type of lock operation. - * BufferLength = Buffer length to be locked. - * RETURNS: Status Value. - * NOTES: - */ -{ - PMDL Mdl; - PIRP Irp; - NTSTATUS Status; - - Mdl = NULL; - Irp = IrpContext->Irp; - Status = STATUS_SUCCESS; - if (Irp->MdlAddress == NULL) - { - NTSTATUS Status; - Mdl = IoAllocateMdl(Irp->UserBuffer, - BufferLength, FALSE, FALSE, Irp); - if (Mdl == NULL) - return STATUS_INSUFFICIENT_RESOURCES; - _SEH2_TRY - { - MmProbeAndLockPages(Mdl, - Irp->RequestorMode, Operation); - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Status = _SEH2_GetExceptionCode(); - IoFreeMdl( Mdl ); - Irp->MdlAddress = NULL; - } _SEH2_END - } - return Status; -} - -NTSTATUS -FatIoSyncCompletionRoutine( - IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp, - IN PVOID Context) -{ - PFAT_IO_CONTEXT IoContext; - - IoContext = (PFAT_IO_CONTEXT) Context; - - /* Check if this is an associated irp. */ - if (Irp != IoContext->Irp) - { - if (!NT_SUCCESS(Irp->IoStatus.Status)) - IoContext->Irp->IoStatus = Irp->IoStatus; - IoFreeMdl(Irp->MdlAddress); - IoFreeIrp(Irp); - if (InterlockedDecrement(&IoContext->RunCount) != 0) - return STATUS_MORE_PROCESSING_REQUIRED; - /* This was the last run, update master irp. */ - if (NT_SUCCESS(IoContext->Irp->IoStatus.Status)) - IoContext->Irp->IoStatus.Information = IoContext->Length; - } - - /* This is the last associated irp or a single irp IO. */ - if (NT_SUCCESS(IoContext->Irp->IoStatus.Status) && - !FlagOn(IoContext->Irp->Flags, IRP_PAGING_IO)) - { - /* Maintain FileObject CurrentByteOffset */ - IoContext->FileObject->CurrentByteOffset.QuadPart = - IoContext->Offset + IoContext->Irp->IoStatus.Information; - } - - /* Signal about completion. */ - KeSetEvent(&IoContext->Wait.SyncEvent, 0, FALSE); - return STATUS_MORE_PROCESSING_REQUIRED; -} - -NTSTATUS -FatIoAsyncCompletionRoutine( - IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp, - IN PVOID Context) -{ - PFAT_IO_CONTEXT IoContext; - - IoContext = (PFAT_IO_CONTEXT) Context; - - /* Check if this is an associated irp. */ - if (Irp != IoContext->Irp) - { - if (!NT_SUCCESS(Irp->IoStatus.Status)) - IoContext->Irp->IoStatus = Irp->IoStatus; - IoFreeMdl(Irp->MdlAddress); - IoFreeIrp(Irp); - if (InterlockedDecrement(&IoContext->RunCount) != 0) - return STATUS_MORE_PROCESSING_REQUIRED; - /* This was the last run, update master irp. */ - if (NT_SUCCESS(IoContext->Irp->IoStatus.Status)) - IoContext->Irp->IoStatus.Information = IoContext->Length; - } - - - /* This is the last associated irp or a single irp IO. */ - if (NT_SUCCESS(IoContext->Irp->IoStatus.Status) && - !FlagOn(IoContext->Irp->Flags, IRP_PAGING_IO)) - { - /* Maintain FileObject Flags */ - if (IoGetCurrentIrpStackLocation(IoContext->Irp)->MajorFunction - == IRP_MJ_READ) - { - SetFlag(IoContext->FileObject->Flags, FO_FILE_FAST_IO_READ); - } - else - { - SetFlag(IoContext->FileObject->Flags, FO_FILE_MODIFIED); - } - } - if (IoContext->Wait.Async.Resource != NULL) - ExReleaseResourceForThreadLite( - IoContext->Wait.Async.Resource, - IoContext->Wait.Async.ResourceThreadId); - - if (IoContext->Wait.Async.PagingIoResource != NULL) - ExReleaseResourceForThreadLite( - IoContext->Wait.Async.PagingIoResource, - IoContext->Wait.Async.ResourceThreadId); - - IoMarkIrpPending(Irp); - ExFreePool(Context); - return STATUS_SUCCESS; -} - -NTSTATUS -NTAPI -FatPerformLboIo( - IN PFAT_IRP_CONTEXT IrpContext, - IN PLARGE_INTEGER Offset, - IN SIZE_T Length) -{ - BOOLEAN CanWait, ReadOperation; - PIO_STACK_LOCATION IoStack; - - CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT); - ReadOperation = (IrpContext->Stack->MajorFunction == IRP_MJ_READ); - - /* Allocate completion context */ - IrpContext->FatIoContext = FsRtlAllocatePoolWithTag( - NonPagedPool, sizeof(FAT_IO_CONTEXT), (ULONG) 'xCoI'); - - if (IrpContext->FatIoContext == NULL) - return STATUS_INSUFFICIENT_RESOURCES; - - RtlZeroMemory(IrpContext->FatIoContext, - sizeof(FAT_IO_CONTEXT)); - - /* Initialize event if we are supposed to wait. */ - if (CanWait) - { - KeInitializeEvent( - &IrpContext->FatIoContext->Wait.SyncEvent, - NotificationEvent, FALSE); - } - - /* Set the completion routine depending on wait semantics. */ - IoSetCompletionRoutine(IrpContext->Irp, - (CanWait - ? FatIoSyncCompletionRoutine - : FatIoAsyncCompletionRoutine), - IrpContext->FatIoContext, TRUE, TRUE, TRUE); - - /* Setup stack location. */ - IoStack = IoGetNextIrpStackLocation(IrpContext->Irp); - IoStack->MajorFunction = IrpContext->MajorFunction; - IoStack->Parameters.Read.Length = (ULONG) Length; - IoStack->Parameters.Read.ByteOffset = *Offset; - if (FlagOn(IrpContext->Flags, IRPCONTEXT_WRITETHROUGH)) - SetFlag(IoStack->Flags, SL_WRITE_THROUGH); - - IoCallDriver( - IrpContext->Vcb->TargetDeviceObject, - IrpContext->Irp); - if (CanWait) - { - KeWaitForSingleObject( - &IrpContext->FatIoContext->Wait.SyncEvent, - Executive, KernelMode, FALSE, NULL); - return IrpContext->Irp->IoStatus.Status; - } - SetFlag(IrpContext->Flags, IRPCONTEXT_STACK_IO_CONTEXT); - return STATUS_PENDING; -} - - - -NTSTATUS -FatPerformVirtualNonCachedIo( - IN PFAT_IRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PLARGE_INTEGER Offset, - IN SIZE_T Length) -{ - NTSTATUS Status; - PIO_STACK_LOCATION IoStack; - LONGLONG Vbo, Lbo, RunLength; - ULONG RunCount, CleanupIndex, FirstIndex, BeyoundLastIndex; - BOOLEAN CanWait, ReadOperation; - PIRP* RunIrp; - PMDL Mdl; - - ASSERT(IrpContext->FatIoContext == NULL); - - - FirstIndex = CleanupIndex = 0; - CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT); - ReadOperation = (IrpContext->Stack->MajorFunction == IRP_MJ_READ); - Status = FatLockUserBuffer(IrpContext, - (ReadOperation ? IoWriteAccess : IoReadAccess), - Length); - if (!NT_SUCCESS(Status)) - goto FatIoPerformNonCachedCleanup; - Vbo = Offset->QuadPart; - RunLength = Length; - _SEH2_TRY - { - BeyoundLastIndex = FatScanFat(Fcb, Vbo, - &Lbo, &RunLength, &FirstIndex, CanWait); - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Status = _SEH2_GetExceptionCode(); - _SEH2_YIELD(goto FatIoPerformNonCachedCleanup;) - }_SEH2_END - RunCount = BeyoundLastIndex - FirstIndex; - if (RunCount == 0) - { - Status = STATUS_END_OF_FILE; - goto FatIoPerformNonCachedCleanup; - } - Length = sizeof(FAT_IO_CONTEXT); - if (RunCount > 0x1) - Length += RunCount * sizeof(PIRP); - IrpContext->FatIoContext = FsRtlAllocatePoolWithTag( - NonPagedPool, Length, (ULONG) 'xCoI'); - if (IrpContext->FatIoContext == NULL) - { - Status = STATUS_INSUFFICIENT_RESOURCES; - goto FatIoPerformNonCachedCleanup; - } - RtlZeroMemory(IrpContext->FatIoContext, Length); - if (CanWait) - { - KeInitializeEvent( - &IrpContext->FatIoContext->Wait.SyncEvent, - NotificationEvent, FALSE); - } - if (RunCount == 0x1) - { - IoSetCompletionRoutine(IrpContext->Irp, - (CanWait ? FatIoSyncCompletionRoutine - : FatIoAsyncCompletionRoutine), - IrpContext->FatIoContext, TRUE, TRUE, TRUE); - IoStack = IoGetNextIrpStackLocation(IrpContext->Irp); - IoStack->MajorFunction = IrpContext->Stack->MajorFunction; - IoStack->Parameters.Read.Length = (ULONG) RunLength; - IoStack->Parameters.Read.ByteOffset.QuadPart = Lbo; - IoStack->Flags = FlagOn( - IrpContext->Stack->Flags, - SL_WRITE_THROUGH); - Status = IoCallDriver( - IrpContext->Vcb->TargetDeviceObject, - IrpContext->Irp); - goto FatIoPerformNonCachedComplete; - } - /* - * We already have the first run retrieved by FatiScanFat. - */ - for (RunIrp = &IrpContext->FatIoContext->Irp, - CleanupIndex = FirstIndex; - CleanupIndex < BeyoundLastIndex; - CleanupIndex ++, RunIrp ++) - { -#if DBG - LONGLONG NextVbo = Vbo + RunLength; - BOOLEAN RunExists; -#endif - /* - * Allocate Irp for the run. - */ - *RunIrp = IoMakeAssociatedIrp(IrpContext->Irp, - (CCHAR)(IrpContext->Vcb->TargetDeviceObject->StackSize + 1)); - if (*RunIrp == NULL) - { - Status = STATUS_INSUFFICIENT_RESOURCES; - goto FatIoPerformNonCachedCleanup; - } - CleanupIndex ++; - /* - * Build Mdl for the run range. - */ - Mdl = IoAllocateMdl( - Add2Ptr(IrpContext->Irp->UserBuffer, Vbo, PVOID), - (ULONG) RunLength, FALSE, FALSE, *RunIrp); - if (Mdl == NULL) - { - Status = STATUS_INSUFFICIENT_RESOURCES; - goto FatIoPerformNonCachedCleanup; - } - IoBuildPartialMdl(IrpContext->Irp->MdlAddress, Mdl, - Add2Ptr(IrpContext->Irp->UserBuffer, Vbo, PVOID), - (ULONG) RunLength); - /* - * Setup IRP for each run. - */ - IoSetCompletionRoutine(IrpContext->Irp, - (CanWait ? FatIoSyncCompletionRoutine - : FatIoAsyncCompletionRoutine), - IrpContext->FatIoContext, TRUE, TRUE, TRUE); - IoStack = IoGetNextIrpStackLocation(*RunIrp); - IoStack->MajorFunction = IrpContext->Stack->MajorFunction; - IoStack->Parameters.Read.Length = (ULONG) RunLength; - IoStack->Parameters.Read.ByteOffset.QuadPart = Lbo; - - /* - * Propagate write-through to the associated IRPs - */ - if (FlagOn(IrpContext->Flags, IRPCONTEXT_WRITETHROUGH)) - SetFlag(IoStack->Flags, SL_WRITE_THROUGH); - /* - * Prepare for next iteration: - */ - #if DBG - RunExists = - #endif - FsRtlGetNextLargeMcbEntry(&Fcb->Mcb, CleanupIndex, &Vbo, &Lbo, &RunLength); - ASSERT(RunExists); - ASSERT(NextVbo == Vbo); - } - /* - * Send all IRPs to the volume device, we don't need to check - * status code because cleanup will be done - * by the completion routine in any case. - */ - for (RunIrp = &IrpContext->FatIoContext->Irp, - CleanupIndex = FirstIndex; - CleanupIndex < BeyoundLastIndex; - CleanupIndex ++, RunIrp ++) - { - IoCallDriver(IrpContext->Vcb->TargetDeviceObject, *RunIrp); - } - -FatIoPerformNonCachedComplete: - if (CanWait) - { - KeWaitForSingleObject( - &IrpContext->FatIoContext->Wait.SyncEvent, - Executive, KernelMode, FALSE, NULL); - return IrpContext->Irp->IoStatus.Status; - } - SetFlag(IrpContext->Flags, IRPCONTEXT_STACK_IO_CONTEXT); - return STATUS_PENDING; - /* - * The following block of code implements unwind logic - */ -FatIoPerformNonCachedCleanup: - if (IrpContext->FatIoContext != NULL) - { - RunIrp = &IrpContext->FatIoContext->Irp; - while (FirstIndex < CleanupIndex) - { - if ((*RunIrp)->MdlAddress != NULL) - IoFreeMdl((*RunIrp)->MdlAddress); - IoFreeIrp(*RunIrp); - FirstIndex ++; - RunIrp ++; - } - ExFreePool(IrpContext->FatIoContext); - IrpContext->FatIoContext = NULL; - } - return Status; -} - -/* EOF */ Removed: trunk/reactos/drivers/filesystems/fastfat_new/direntry.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/direntry.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/direntry.c (removed) @@ -1,775 +1,0 @@ -/* - * PROJECT: ReactOS FAT file system driver - * LICENSE: GPL - See COPYING in the top level directory - * FILE: drivers/filesystems/fastfat/direntry.c - * PURPOSE: Directory entries - * PROGRAMMERS: Alexey Vlasov - */ - -/* INCLUDES *****************************************************************/ - -#define NDEBUG -#include "fastfat.h" - -/* PROTOTYPES ***************************************************************/ - -typedef enum _FILE_TIME_INDEX -{ - FileCreationTime = 0, - FileLastAccessTime, - FileLastWriteTime, - FileChangeTime -} FILE_TIME_INDEX; - - -VOID -Fat8dot3ToUnicodeString(OUT PUNICODE_STRING FileName, - IN PUCHAR ShortName, - IN UCHAR Flags); - -ULONG -FatDirentToDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToFullDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToIdFullDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToBothDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToIdBothDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToNamesInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -ULONG -FatDirentToObjectIdInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer); - -/* FUNCTIONS *****************************************************************/ - -#define FatQueryFileName(xInfo, xDirent) \ -{ \ - UNICODE_STRING FileName; \ - if (Info->FileNameLength == 0) \ - { \ - FileName.Buffer = Info->FileName; \ - FileName.MaximumLength = 0x18; \ - Fat8dot3ToUnicodeString(&FileName, \ - (xDirent)->FileName, (xDirent)->Case); \ - Info->FileNameLength = FileName.Length; \ - } \ -} - -#define FatQueryBothFileName(xInfo, xDirent) \ -{ \ - UNICODE_STRING FileName; \ - FileName.MaximumLength = 0x18; \ - if (Info->FileNameLength == 0) \ - { \ - FileName.Buffer = Info->FileName; \ - Fat8dot3ToUnicodeString(&FileName, \ - (xDirent)->FileName, (xDirent)->Case); \ - Info->FileNameLength = FileName.Length; \ - Info->ShortNameLength = 0; \ - } \ - else \ - { \ - FileName.Buffer = Info->ShortName; \ - Fat8dot3ToUnicodeString(&FileName, \ - (xDirent)->FileName, (xDirent)->Case); \ - Info->ShortNameLength = (CCHAR) FileName.Length; \ - } \ -} - -FORCEINLINE -UCHAR -FatLfnChecksum( - PUCHAR Buffer -) -{ - UCHAR Index, Chksum; - - for (Index = 0x1, Chksum = *Buffer; - Index < RTL_FIELD_SIZE(DIR_ENTRY, FileName); - Index ++) - { - Chksum = (((Chksum & 0x1) << 0x7) | (Chksum >> 0x1)) - + Buffer[Index]; - } - return Chksum; -} - -VOID -FatFindDirent(IN OUT PFAT_FIND_DIRENT_CONTEXT Context, - OUT PDIR_ENTRY* Dirent, - OUT PUNICODE_STRING LongFileName OPTIONAL) -{ - PDIR_ENTRY Entry, EndOfPage; - UCHAR SeqNum = 0, Checksum = 0; - PUNICODE_STRING FileName; - - /* Pin first page. */ - Entry = (PDIR_ENTRY) FatPinPage(&Context->Page, 0); - EndOfPage = FatPinEndOfPage(&Context->Page, PDIR_ENTRY); - - /* Run dirents. */ - FileName = NULL; - while (TRUE) - { - /* Check if we have entered the area of never used dirents */ - if (Entry->FileName[0] == FAT_DIRENT_NEVER_USED) - ExRaiseStatus(STATUS_OBJECT_NAME_NOT_FOUND); - - /* Just ignore entries marked as deleted */ - if (Entry->FileName[0] == FAT_DIRENT_DELETED) - goto FatFindDirentNext; - - /* Check if it's an lfn */ - if (Entry->Attributes == FAT_DIRENT_ATTR_LFN) - { - PLONG_FILE_NAME_ENTRY LfnEntry; - - FileName = LongFileName; - LfnEntry = (PLONG_FILE_NAME_ENTRY) Entry; - - /* Run lfns and collect file name if required */ - do { - PWSTR Lfn; - - /* Check if we just running lfn */ - if (FileName == NULL) - goto FatFindDirentRunLfn; - - /* Check for cluster index to be zero. */ - if (LfnEntry->Reserved != 0) - { - FileName = NULL; - goto FatFindDirentRunLfn; - } - - /* Check if this is the last lfn entry. */ - if (FlagOn(LfnEntry->SeqNum, FAT_FN_DIR_ENTRY_LAST)) - { - SeqNum = (LfnEntry->SeqNum & ~FAT_FN_DIR_ENTRY_LAST); - Checksum = LfnEntry->Checksum; - - /* Check if we exceed max number of lfns */ - if (SeqNum > (FAT_FN_MAX_DIR_ENTIES + 1)) - { - FileName = NULL; - goto FatFindDirentRunLfn; - } - - /* Setup maximal expected lfn length */ - FileName->Length = (SeqNum * FAT_LFN_NAME_LENGTH); - - /* Extend lfn buffer if needed */ - if (FileName->Length > FileName->MaximumLength) - { - Lfn = ExAllocatePoolWithTag(PagedPool, - LongFileName->Length, TAG_VFAT); - if (Lfn == NULL) - ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES); - if (FileName->Buffer != NULL) - ExFreePool(FileName->Buffer); - FileName->Buffer = Lfn; - FileName->MaximumLength = FileName->Length; - } - } - else if (!(LfnEntry->SeqNum == SeqNum - && LfnEntry->Checksum == Checksum)) - { - /* Wrong SeqNum or CheckSum. */ - FileName = NULL; - goto FatFindDirentRunLfn; - } - /* Gather file name */ - Lfn = Add2Ptr(FileName->Buffer, (SeqNum * FAT_LFN_NAME_LENGTH) - - sizeof(LfnEntry->NameC), PWSTR); - RtlCopyMemory(Lfn, LfnEntry->NameC, sizeof(LfnEntry->NameC)); - Lfn -= (sizeof(LfnEntry->NameB) / sizeof(WCHAR)); - RtlCopyMemory(Lfn, LfnEntry->NameB, sizeof(LfnEntry->NameB)); - Lfn -= (sizeof(LfnEntry->NameA) / sizeof(WCHAR)); - RtlCopyMemory(Lfn, LfnEntry->NameA, sizeof(LfnEntry->NameA)); - - /* If last lfn determine exact lfn length. */ - if (FlagOn(LfnEntry->SeqNum, FAT_FN_DIR_ENTRY_LAST)) - { - PWSTR LfnEnd = Add2Ptr(FileName->Buffer, - (FileName->Length - sizeof(WCHAR)), PWSTR); - - /* Trim trailing 0xffff's */ - while (LfnEnd > Lfn && *LfnEnd == 0xffff) --LfnEnd; - - /* Trim 0 terminator is the one is there. */ - if (*LfnEnd == 0x0) --LfnEnd; - - /* Set correct lfn size */ - FileName->Length = (USHORT)PtrOffset(FileName->Buffer, LfnEnd); - } - /* Setup validation for the next iteration */ - SeqNum = LfnEntry->SeqNum - 0x1; - Checksum = LfnEntry->Checksum; - -FatFindDirentRunLfn: - /* Get next dirent */ - LfnEntry ++; - if (LfnEntry > (PLONG_FILE_NAME_ENTRY) EndOfPage) - { - if (FatPinIsLastPage(&Context->Page)) - ExRaiseStatus(STATUS_OBJECT_NAME_NOT_FOUND); - LfnEntry = (PLONG_FILE_NAME_ENTRY) FatPinNextPage(&Context->Page); - EndOfPage = FatPinEndOfPage(&Context->Page, PDIR_ENTRY); - } - } - while (LfnEntry->Attributes == FAT_DIRENT_ATTR_LFN); - Entry = (PDIR_ENTRY) LfnEntry; - continue; - } - - /* If we've got here then this is a normal dirent */ - if (FileName != NULL && FileName->Length > 0) - { - /* Check if we have a correct lfn collected. */ - if (FatLfnChecksum(Entry->FileName) != Checksum) - { - FileName = NULL; - } - else - { - /* See if we were looking for this dirent. */ - if (!Context->Valid8dot3Name && - FsRtlAreNamesEqual(FileName, Context->FileName, TRUE, NULL)) - { - Fat8dot3ToUnicodeString(&Context->ShortName, Entry->FileName, Entry->Case); - *Dirent = Entry; - return; - } - } - } - - /* We surely have a short name, check if we were looking for that. */ - if (Context->Valid8dot3Name) - { - Fat8dot3ToUnicodeString(&Context->ShortName, - Entry->FileName, Entry->Case); - if (FsRtlAreNamesEqual(&Context->ShortName, Context->FileName, TRUE, NULL)) - { - if (ARGUMENT_PRESENT(LongFileName) && FileName == NULL) - LongFileName->Length = 0; - *Dirent = Entry; - return; - } - } - FileName = NULL; - -FatFindDirentNext: - Entry ++; - if (Entry > EndOfPage) - { - if (FatPinIsLastPage(&Context->Page)) - ExRaiseStatus(STATUS_OBJECT_NAME_NOT_FOUND); - Entry = (PDIR_ENTRY) FatPinNextPage(&Context->Page); - EndOfPage = FatPinEndOfPage(&Context->Page, PDIR_ENTRY); - } - } - /* Should never get here! */ - ASSERT(TRUE); -} - -VOID -FatEnumerateDirents(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN SIZE_T Offset) -{ - PUCHAR Entry, EndOfPage; - PWSTR FileName; - USHORT FileNameLength; - USHORT FileNameMaximumLength; - PVOID InfoEntry; - UCHAR SeqNum = 0; - UCHAR Checksum = 0; - - /* Pin first page. */ - Entry = (PUCHAR)FatPinPage(&Context->Page, Offset); - EndOfPage = FatPinEndOfPage(&Context->Page, PUCHAR); - - /* Iterate dirents. */ - while (TRUE) - { - /* Check if we have entered the area of never used dirents */ - if (*Entry == FAT_DIRENT_NEVER_USED) - ExRaiseStatus(STATUS_NO_MORE_FILES); - - /* Just ignore entries marked as deleted */ - if (*Entry == FAT_DIRENT_DELETED) - goto FatEnumerateDirentsNext; - - /* Get info pointer. */ - InfoEntry = Add2Ptr(Context->Buffer, Context->Offset, PVOID); - - /* Check if info class has file name */ - if (Context->NameOffset == Context->LengthOffset) - { - FileName = NULL; - FileNameMaximumLength = 0; - } - else - { - FileName = Add2Ptr(InfoEntry, Context->NameOffset, PWSTR); - FileNameMaximumLength = (USHORT) (Context->Length - - Context->Offset + Context->NameOffset); - } - FileNameLength = 0; - - /* Check if it's an lfn */ - while (Entry[0xb] == FAT_DIRENT_ATTR_LFN) - { - PWSTR Lfn; - PLONG_FILE_NAME_ENTRY LfnEntry; - - /* Check if we just running lfn */ - if (FileNameMaximumLength == 0) - goto FatEnumerateDirentsRunLfn; - - LfnEntry = (PLONG_FILE_NAME_ENTRY) Entry; - - /* Check for cluster index to be zero. */ - if (LfnEntry->Reserved != 0) - { - FileNameMaximumLength = 0; - goto FatEnumerateDirentsRunLfn; - } - - /* Check if this is the last lfn entry. */ - if (FlagOn(LfnEntry->SeqNum, FAT_FN_DIR_ENTRY_LAST)) - { - SeqNum = (LfnEntry->SeqNum & ~FAT_FN_DIR_ENTRY_LAST); - Checksum = LfnEntry->Checksum; - - /* Check if we exceed max number of lfns */ - if (SeqNum > (FAT_FN_MAX_DIR_ENTIES + 1)) - { - FileNameMaximumLength = 0; - goto FatEnumerateDirentsRunLfn; - } - - /* Setup maximal expected lfn length */ - FileNameLength = SeqNum * FAT_LFN_NAME_LENGTH; - - /* Validate the maximal expected lfn length */ - if (FileNameLength > FileNameMaximumLength) - goto FatEnumerateDirentsRunLfn; - } - else if (!(LfnEntry->SeqNum == SeqNum - && LfnEntry->Checksum == Checksum)) - { - /* Wrong SeqNum or CheckSum. */ - FileNameMaximumLength = 0; - goto FatEnumerateDirentsRunLfn; - } - /* Gather file name */ - Lfn = Add2Ptr(FileName, (SeqNum * FAT_LFN_NAME_LENGTH) - - sizeof(LfnEntry->NameC), PWSTR); - RtlCopyMemory(Lfn, LfnEntry->NameC, sizeof(LfnEntry->NameC)); - Lfn -= (sizeof(LfnEntry->NameB) / sizeof(WCHAR)); - RtlCopyMemory(Lfn, LfnEntry->NameB, sizeof(LfnEntry->NameB)); - Lfn -= (sizeof(LfnEntry->NameA) / sizeof(WCHAR)); - RtlCopyMemory(Lfn, LfnEntry->NameA, sizeof(LfnEntry->NameA)); - - /* If last lfn determine exact lfn length. */ - if (FlagOn(LfnEntry->SeqNum, FAT_FN_DIR_ENTRY_LAST)) - { - PWSTR LfnEnd = Add2Ptr(FileName, FileNameLength - - sizeof(WCHAR), PWSTR); - - /* Trim trailing 0xffff's */ - while (LfnEnd > Lfn && *LfnEnd == 0xffff) --LfnEnd; - - /* Trim 0 terminator is the one is there. */ - if (*LfnEnd == 0x0) --LfnEnd; - - /* Set correct lfn size */ - FileNameLength = (USHORT)PtrOffset(FileName, LfnEnd); - } - /* Setup vaidation for the next iteration */ - SeqNum = LfnEntry->SeqNum - 0x1; - Checksum = LfnEntry->Checksum; -FatEnumerateDirentsRunLfn: - Entry = Add2Ptr(Entry, sizeof(DIR_ENTRY), PUCHAR); - if (Entry > EndOfPage) - { - if (FatPinIsLastPage(&Context->Page)) - ExRaiseStatus(STATUS_NO_MORE_FILES); - Entry = (PUCHAR) FatPinNextPage(&Context->Page); - EndOfPage = FatPinEndOfPage(&Context->Page, PUCHAR); - } - } - - /* if lfn was found, validate and commit. */ - if (FileNameLength > 0 && FatLfnChecksum(Entry) == Checksum) - { - *Add2Ptr(InfoEntry, Context->LengthOffset, PULONG) = FileNameLength; - } - else - { - *Add2Ptr(InfoEntry, Context->LengthOffset, PULONG) = 0; - } - /* TODO: Implement Filtering using Context->FileName & Context->CcbFlags. */ - - /* Copy the entry values. */ - Context->Offset += Context->CopyDirent((PFAT_ENUM_DIR_CONTEXT)Context, (PDIR_ENTRY) Entry, InfoEntry); - -FatEnumerateDirentsNext: - /* Get next entry */ - Entry = Add2Ptr(Entry, sizeof(DIR_ENTRY), PUCHAR); - if (Entry > EndOfPage) - { - if (FatPinIsLastPage(&Context->Page)) - ExRaiseStatus(STATUS_NO_MORE_FILES); - Entry = (PUCHAR) FatPinNextPage(&Context->Page); - EndOfPage = FatPinEndOfPage(&Context->Page, PUCHAR); - } - } -} - -FORCEINLINE -VOID -FatDateTimeToSystemTime(OUT PLARGE_INTEGER SystemTime, - IN PFAT_DATETIME FatDateTime, - IN UCHAR TenMs OPTIONAL) -{ - TIME_FIELDS TimeFields; - - /* Setup time fields */ - TimeFields.Year = FatDateTime->Date.Year + 1980; - TimeFields.Month = FatDateTime->Date.Month; - TimeFields.Day = FatDateTime->Date.Day; - TimeFields.Hour = FatDateTime->Time.Hour; - TimeFields.Minute = FatDateTime->Time.Minute; - TimeFields.Second = (FatDateTime->Time.DoubleSeconds << 1); - - /* Adjust up to 10 milliseconds - * if the parameter was supplied - */ - if (ARGUMENT_PRESENT(TenMs)) - { - TimeFields.Second += TenMs / 100; - TimeFields.Milliseconds = (TenMs % 100) * 10; - } - else - { - TimeFields.Milliseconds = 0; - } - - /* Fix seconds value that might get beyoud the bound */ - if (TimeFields.Second > 59) TimeFields.Second = 0; - - /* Perform ceonversion to system time if possible */ - if (RtlTimeFieldsToTime(&TimeFields, SystemTime)) - { - /* Convert to system time */ - ExLocalTimeToSystemTime(SystemTime, SystemTime); - } - else - { - /* Set to default time if conversion failed */ - *SystemTime = FatGlobalData.DefaultFileTime; - } -} - -VOID -FatQueryFileTimes(OUT PLARGE_INTEGER FileTimes, - IN PDIR_ENTRY Dirent) -{ - /* Convert LastWriteTime */ - FatDateTimeToSystemTime(&FileTimes[FileLastWriteTime], - &Dirent->LastWriteDateTime, - 0); - /* All other time fileds are valid (according to MS) - * only if Win31 compatability mode is set. - */ - if (FatGlobalData.Win31FileSystem) - { - /* We can avoid calling conversion routine - * if time in dirent is 0 or equals to already - * known time (LastWriteTime). - */ - if (Dirent->CreationDateTime.Value == 0) - { - /* Set it to default time */ - FileTimes[FileCreationTime] = FatGlobalData.DefaultFileTime; - } - else if (Dirent->CreationDateTime.Value - == Dirent->LastWriteDateTime.Value) - { - /* Assign the already known time */ - FileTimes[FileCreationTime] = FileTimes[FileLastWriteTime]; - /* Adjust milliseconds from extra dirent field */ - FileTimes[FileCreationTime].QuadPart - += (ULONG) Dirent->CreationTimeTenMs * 100000; - } - else - { - /* Perform conversion */ - FatDateTimeToSystemTime(&FileTimes[FileCreationTime], - &Dirent->CreationDateTime, - Dirent->CreationTimeTenMs); - } - if (Dirent->LastAccessDate.Value == 0) - { - /* Set it to default time */ - FileTimes[FileLastAccessTime] = FatGlobalData.DefaultFileTime; - } - else if (Dirent->LastAccessDate.Value - == Dirent->LastWriteDateTime.Date.Value) - { - /* Assign the already known time */ - FileTimes[FileLastAccessTime] = FileTimes[FileLastWriteTime]; - } - else - { - /* Perform conversion */ - FAT_DATETIME LastAccessDateTime; - - LastAccessDateTime.Date.Value = Dirent->LastAccessDate.Value; - LastAccessDateTime.Time.Value = 0; - FatDateTimeToSystemTime(&FileTimes[FileLastAccessTime], - &LastAccessDateTime, - 0); - } - } -} - -VOID -Fat8dot3ToUnicodeString(OUT PUNICODE_STRING FileName, - IN PUCHAR ShortName, - IN UCHAR Flags) -{ - PCHAR Name; - UCHAR Index, Ext = 0; - OEM_STRING Oem; - - Name = Add2Ptr(FileName->Buffer, 0x0c, PCHAR); - RtlCopyMemory(Name, ShortName, 0x0b); - - /* Restore the name byte used to mark deleted entries */ - if (Name[0] == 0x05) - Name[0] |= 0xe0; - - /* Locate the end of name part */ - for (Index = 0; Index < 0x08 - && Name[Index] != 0x20; Index++); - - /* Locate the end of extension part */ - if (Name[0x08] != 0x20) - { - Ext = 0x2; - Name[Index++] = 0x2e; - Name[Index++] = Name[0x08]; - if ((Name[Index] = Name[0x09]) != 0x20) - { - Index ++; Ext ++; - } - if ((Name[Index] = Name[0x0a]) != 0x20) - { - Index ++; Ext ++; - } - } - - /* Perform Oem to Unicode conversion. */ - Oem.Buffer = Name; - Oem.Length = Index; - Oem.MaximumLength = Index; - RtlOemStringToUnicodeString(FileName, &Oem, FALSE); - Index = FlagOn(Flags, FAT_CASE_LOWER_BASE|FAT_CASE_LOWER_EXT); - if (Index > 0) - { - /* Downcase the whole name */ - if (Index == (FAT_CASE_LOWER_BASE|FAT_CASE_LOWER_EXT)) - { - RtlUpcaseUnicodeString(FileName, FileName, FALSE); - } - else - { - if (Index == FAT_CASE_LOWER_EXT) - { - /* Set extension for downcase */ - Oem.Length = Ext * sizeof(WCHAR); - Oem.Buffer = Add2Ptr(FileName->Buffer, - FileName->Length - Oem.Length, - PSTR); - } - else - { - /* Set base name for downcase */ - Oem.Buffer = (PSTR) FileName->Buffer; - Oem.Length = FileName->Length - Ext * sizeof(WCHAR); - } - Oem.MaximumLength = Oem.Length; - RtlUpcaseUnicodeString((PUNICODE_STRING)&Oem, - (PUNICODE_STRING)&Oem, - FALSE); - } - } -} - -ULONG -FatDirentToDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_DIRECTORY_INFORMATION Info; - Info = (PFILE_DIRECTORY_INFORMATION) Buffer; - Info->FileIndex = 0; - /* Setup Attributes */ - Info->FileAttributes = Dirent->Attributes; - /* Setup times */ - FatQueryFileTimes(&Info->CreationTime, Dirent); - /* Setup sizes */ - Info->EndOfFile.QuadPart = Dirent->FileSize; - Info->AllocationSize.QuadPart = - (Context->BytesPerClusterMask + Dirent->FileSize) - & ~(Context->BytesPerClusterMask); - FatQueryFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToFullDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_FULL_DIR_INFORMATION Info; - Info = (PFILE_FULL_DIR_INFORMATION) Buffer; - Info->FileIndex = 0; - Info->EaSize = 0; - /* Setup Attributes */ - Info->FileAttributes = Dirent->Attributes; - /* Setup times */ - FatQueryFileTimes(&Info->CreationTime, Dirent); - /* Setup sizes */ - Info->EndOfFile.QuadPart = Dirent->FileSize; - Info->AllocationSize.QuadPart = - (Context->BytesPerClusterMask + Dirent->FileSize) - & ~(Context->BytesPerClusterMask); - FatQueryFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToIdFullDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_ID_FULL_DIR_INFORMATION Info; - Info = (PFILE_ID_FULL_DIR_INFORMATION) Buffer; - Info->FileId.QuadPart = 0; - Info->FileIndex = 0; - Info->EaSize = 0; - /* Setup Attributes */ - Info->FileAttributes = Dirent->Attributes; - /* Setup times */ - FatQueryFileTimes(&Info->CreationTime, Dirent); - /* Setup sizes */ - Info->EndOfFile.QuadPart = Dirent->FileSize; - Info->AllocationSize.QuadPart = - (Context->BytesPerClusterMask + Dirent->FileSize) - & ~(Context->BytesPerClusterMask); - FatQueryFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToBothDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_BOTH_DIR_INFORMATION Info; - Info = (PFILE_BOTH_DIR_INFORMATION) Buffer; - Info->FileIndex = 0; - Info->EaSize = 0; - /* Setup Attributes */ - Info->FileAttributes = Dirent->Attributes; - /* Setup times */ - FatQueryFileTimes(&Info->CreationTime, Dirent); - /* Setup sizes */ - Info->EndOfFile.QuadPart = Dirent->FileSize; - Info->AllocationSize.QuadPart = - (Context->BytesPerClusterMask + Dirent->FileSize) - & ~(Context->BytesPerClusterMask); - FatQueryBothFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToIdBothDirInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_ID_BOTH_DIR_INFORMATION Info; - Info = (PFILE_ID_BOTH_DIR_INFORMATION) Buffer; - Info->FileId.QuadPart = 0; - Info->FileIndex = 0; - Info->EaSize = 0; - /* Setup Attributes */ - Info->FileAttributes = Dirent->Attributes; - /* Setup times */ - FatQueryFileTimes(&Info->CreationTime, Dirent); - /* Setup sizes */ - Info->EndOfFile.QuadPart = Dirent->FileSize; - Info->AllocationSize.QuadPart = - (Context->BytesPerClusterMask + Dirent->FileSize) - & ~(Context->BytesPerClusterMask); - FatQueryBothFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToNamesInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_NAMES_INFORMATION Info; - Info = (PFILE_NAMES_INFORMATION) Buffer; - Info->FileIndex = 0; - FatQueryFileName(Info, Dirent); - Info->NextEntryOffset = sizeof(*Info); - return Info->NextEntryOffset + Info->FileNameLength; -} - -ULONG -FatDirentToObjectIdInfo(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN PDIR_ENTRY Dirent, - IN PVOID Buffer) -{ - PFILE_OBJECTID_INFORMATION Info; - Info = (PFILE_OBJECTID_INFORMATION) Buffer; - Info->FileReference = 0; - ((PLONGLONG)Info->ObjectId)[0] = 0LL; - ((PLONGLONG)Info->ObjectId)[1] = 0LL; - return sizeof(*Info); -} - -/* EOF */ Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastfat.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fastfat.h [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fastfat.h [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -65,21 +65,6 @@ ULONG ByteSize, PBCB *Bcb, PVOID *Buffer); - -/* ------------------------------------------------------ blockdev.c */ -NTSTATUS -NTAPI -FatPerformLboIo( - IN PFAT_IRP_CONTEXT IrpContext, - IN PLARGE_INTEGER Offset, - IN SIZE_T Length); - -NTSTATUS -FatPerformVirtualNonCachedIo( - IN PFAT_IRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PLARGE_INTEGER Offset, - IN SIZE_T Length); /* ----------------------------------------------------------- dir.c */ @@ -215,6 +200,10 @@ FF_T_SINT32 FatReadBlocks(FF_T_UINT8 *pBuffer, FF_T_UINT32 SectorAddress, FF_T_UINT32 Count, void *pParam); +VOID NTAPI +FatQueryFileTimes(OUT PLARGE_INTEGER FileTimes, + IN PDIR_ENTRY Dirent); + /* --------------------------------------------------------- lock.c */ NTSTATUS NTAPI @@ -249,33 +238,16 @@ DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath); /* ----------------------------------------------------------- fat.c */ -PVOID -FatPinPage( - PFAT_PAGE_CONTEXT Context, - LONGLONG ByteOffset); - -PVOID -FatPinNextPage( - PFAT_PAGE_CONTEXT Context); - -NTSTATUS +NTSTATUS NTAPI FatInitializeVcb( IN PFAT_IRP_CONTEXT IrpContext, IN PVCB Vcb, IN PDEVICE_OBJECT TargetDeviceObject, IN PVPB Vpb); -VOID +VOID NTAPI FatUninitializeVcb( IN PVCB Vcb); - -ULONG -FatScanFat( - IN PFCB Fcb, - IN LONGLONG Vbo, OUT PLONGLONG Lbo, - IN OUT PLONGLONG Length, - OUT PULONG Index, - IN BOOLEAN CanWait); /* ------------------------------------------------------ device.c */ @@ -291,36 +263,7 @@ ULONG OutputBufferSize, BOOLEAN Override); -/* ------------------------------------------------------ direntry.c */ -VOID -FatFindDirent(IN OUT PFAT_FIND_DIRENT_CONTEXT Context, - OUT PDIR_ENTRY* Dirent, - OUT PUNICODE_STRING LongFileName OPTIONAL); - -VOID -FatEnumerateDirents(IN OUT PFAT_ENUM_DIRENT_CONTEXT Context, - IN SIZE_T Offset); - -VOID -FatQueryFileTimes(OUT PLARGE_INTEGER FileTimes, - IN PDIR_ENTRY Dirent); - /* ----------------------------------------------------------- fcb.c */ -PFCB -FatLookupFcbByName( - IN PFCB ParentFcb, - IN PUNICODE_STRING Name); - -BOOLEAN -FatLinkFcbNames( - IN PFCB ParentFcb, - IN PFCB Fcb); - -VOID -FatUnlinkFcbNames( - IN PFCB ParentFcb, - IN PFCB Fcb); - PFCB NTAPI FatCreateFcb( IN PFAT_IRP_CONTEXT IrpContext, Modified: trunk/reactos/drivers/filesystems/fastfat_new/fastfat.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fastfat.rbuild [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fastfat.rbuild [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -8,13 +8,11 @@ <library>ntoskrnl</library> <library>hal</library> <library>pseh</library> - <file>blockdev.c</file> <file>cleanup.c</file> <file>close.c</file> <file>create.c</file> <file>device.c</file> <file>dir.c</file> - <file>direntry.c</file> <file>ea.c</file> <file>fastfat.c</file> <file>fat.c</file> Modified: trunk/reactos/drivers/filesystems/fastfat_new/fat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -3,7 +3,7 @@ * LICENSE: GPL - See COPYING in the top level directory * FILE: drivers/filesystems/fastfat/fat.c * PURPOSE: FAT support routines - * PROGRAMMERS: Alexey Vlasov + * PROGRAMMERS: Aleksey Bragin <aleksey(a)reactos.org> */ /* INCLUDES *****************************************************************/ @@ -12,370 +12,12 @@ #include "fastfat.h" /* PROTOTYPES ***************************************************************/ -typedef struct _FAT_SCAN_CONTEXT -{ - PFILE_OBJECT FileObject; - LARGE_INTEGER PageOffset; - LONGLONG BeyondLastEntryOffset; - PVOID PageBuffer; - PBCB PageBcb; -} FAT_SCAN_CONTEXT; - -#define FatEntryToDataOffset(xEntry, xVcb) \ - ((xVcb)->DataArea + (((LONGLONG) ((xEntry) - 0x02)) << (xVcb)->BytesPerClusterLog)) - -#define FatDataOffsetToEntry(xOffset, xVcb) \ - ((ULONG) ((xOffset - (xVcb)->DataArea) >> (xVcb)->BytesPerClusterLog) + 0x02) - -ULONG -FatScanFat32ForContinousRun(IN OUT PFAT_PAGE_CONTEXT Context, - IN OUT PULONG Index, - IN BOOLEAN CanWait); BOOLEAN NTAPI FatValidBpb(IN PBIOS_PARAMETER_BLOCK Bpb); /* VARIABLES ****************************************************************/ -FAT_METHODS Fat12Methods = { - NULL, - NULL, - NULL, - NULL -}; - -FAT_METHODS Fat16Methods = { - NULL, - NULL, - NULL, - NULL -}; - -FAT_METHODS Fat32Methods = { - FatScanFat32ForContinousRun, - NULL, - NULL, - NULL -}; - -/* FUNCTIONS ****************************************************************/ - -/** - * Pins the page containing ByteOffset byte. - * - * @param Context - * Keeps current BCB, Buffer pointer - * and maintains current and next page offset. - * - * @param ByteOffset - * Offset from the beginning of the data stream to be pinned. - * - * @return - * Pointer to the buffer starting with the specified ByteOffset. - */ -PVOID -FatPinPage( - PFAT_PAGE_CONTEXT Context, - LONGLONG ByteOffset) -{ - SIZE_T OffsetWithinPage; - - OffsetWithinPage = (SIZE_T) (ByteOffset & (PAGE_SIZE - 1)); - ByteOffset -= OffsetWithinPage; - if (ByteOffset != Context->Offset.QuadPart) - { - Context->Offset.QuadPart = ByteOffset; - if (Context->Bcb != NULL) - { - CcUnpinData(Context->Bcb); - Context->Bcb = NULL; - } - if (!CcMapData(Context->FileObject, - &Context->Offset, - PAGE_SIZE, - Context->CanWait, - &Context->Bcb, - &Context->Buffer)) - { - Context->Offset.QuadPart = 0LL; - ExRaiseStatus(STATUS_CANT_WAIT); - } - } - Context->EndOfPage.QuadPart = - Context->Offset.QuadPart + PAGE_SIZE; - if (Context->EndOfPage.QuadPart - > Context->EndOfData.QuadPart) - { - Context->ValidLength = (SIZE_T) - (Context->EndOfData.QuadPart - - Context->Offset.QuadPart); - } - else - { - Context->ValidLength = PAGE_SIZE; - } - return Add2Ptr(Context->Buffer, OffsetWithinPage, PVOID); -} - -/** - * Pins the next page of data stream. - * - * @param Context - * Keeps current BCB, Buffer pointer - * and maintains current and next page offset. - * - * @return - * Pointer to the buffer starting with the beginning of the next page. - */ -PVOID -FatPinNextPage( - PFAT_PAGE_CONTEXT Context) -{ - ASSERT ((Context->Offset.QuadPart % PAGE_SIZE) - != (Context->EndOfPage.QuadPart % PAGE_SIZE) - && Context->Bcb != NULL); - - ASSERT (Context->ValidLength == PAGE_SIZE); - - Context->Offset = Context->EndOfPage; - CcUnpinData(Context->Bcb); - if (!CcMapData(Context->FileObject, - &Context->Offset, - PAGE_SIZE, - Context->CanWait, - &Context->Bcb, - &Context->Buffer)) - { - Context->Bcb = NULL; - Context->Offset.QuadPart = 0LL; - ExRaiseStatus(STATUS_CANT_WAIT); - } - Context->EndOfPage.QuadPart = - Context->Offset.QuadPart + PAGE_SIZE; - return Context->Buffer; -} - -/** - * Determines the index of the set bit. - * - * @param Number - * Number having a single bit set. - * - * @return - * Index of the set bit. - */ -FORCEINLINE -ULONG -FatPowerOfTwo( - ULONG Number) -{ - ULONG Temp; - Temp = Number - - ((Number >> 1) & 033333333333) - - ((Number >> 2) & 011111111111); - return (((Temp + (Temp >> 3)) & 030707070707) % 63); -} - -/** - * Scans FAT32 for continous chain of clusters - * - * @param Context - * Pointer to FAT_PAGE_CONTEXT. - * - * @param Index - * Supplies the Index of the first cluster - * and receves the last index after the last - * cluster in the chain. - * - * @param CanWait - * Indicates if the context allows blocking. - * - * @return - * Value of the last claster terminated the scan. - * - * @note - * Raises STATUS_CANT_WAIT race condition. - */ -ULONG -FatScanFat32ForContinousRun(IN OUT PFAT_PAGE_CONTEXT Context, - IN OUT PULONG Index, - IN BOOLEAN CanWait) -{ - PULONG Entry, EndOfPage; - - Entry = FatPinPage(Context, ((LONGLONG) *Index) << 0x2); - EndOfPage = FatPinEndOfPage(Context, PULONG); - while (TRUE) - { - do - { - if ((*Entry & FAT_CLUSTER_LAST) != ++(*Index)) - return (*Entry & FAT_CLUSTER_LAST); - } while (++Entry < EndOfPage); - /* Check if this is the last available entry */ - if (FatPinIsLastPage(Context)) - break; - Entry = (PULONG) FatPinNextPage(Context); - EndOfPage = FatPinEndOfPage(Context, PULONG); - } - return (*Index - 1); -} - -ULONG -FatSetFat32ContinousRun(IN OUT PFAT_SCAN_CONTEXT Context, - IN ULONG Index, - IN ULONG Length, - IN BOOLEAN CanWait) -{ - ExRaiseStatus(STATUS_NOT_IMPLEMENTED); -} - -ULONG -FatScanFat32ForValueRun(IN OUT PFAT_SCAN_CONTEXT Context, - IN OUT PULONG Index, - IN ULONG IndexValue, - IN BOOLEAN CanWait) -{ - ExRaiseStatus(STATUS_NOT_IMPLEMENTED); -} - -ULONG -FatSetFat32ValueRun(IN OUT PFAT_SCAN_CONTEXT Context, - IN ULONG Index, - IN ULONG Length, - IN ULONG IndexValue, - IN BOOLEAN CanWait) -{ - ExRaiseStatus(STATUS_NOT_IMPLEMENTED); -} - -/** - * Queries file MCB for the specified region [Vbo, Vbo + Length], - * returns the number of runs in the region as well as the first - * run of the range itself. - * If the specified region is not fully cached in MCB the routine - * scans FAT for the file and fills the MCB until the file offset - * (defined as Vbo + Length) is reached. - * - * @param Fcb - * Pointer to FCB structure for the file. - * - * @param Vbo - * Virtual Byte Offset in the file. - * - * @param Lbo - * Receives the Value of Logical Byte offset corresponding - * to supplied Vbo Value. - * - * @param Length - * Supplies file range length to be examined and receives - * the length of first run. - * - * @param OutIndex - * Receives the index (in MCB cache) of first run. - * - * @return - * Incremented index of the last run (+1). - * - * @note - * Should be called by I/O routines to split the I/O operation - * into sequential or parallel I/O operations. - */ -ULONG -FatScanFat(IN PFCB Fcb, - IN LONGLONG Vbo, - OUT PLONGLONG Lbo, - IN OUT PLONGLONG Length, - OUT PULONG Index, - IN BOOLEAN CanWait) -{ - LONGLONG CurrentLbo, CurrentVbo, BeyondLastVbo, CurrentLength; - ULONG Entry, NextEntry, NumberOfEntries, CurrentIndex; - FAT_PAGE_CONTEXT Context; - PVCB Vcb; - - /* Some often used values */ - Vcb = Fcb->Vcb; - CurrentIndex = 0; - BeyondLastVbo = Vbo + *Length; - CurrentLength = ((LONGLONG) Vcb->Clusters) << Vcb->BytesPerClusterLog; - if (BeyondLastVbo > CurrentLength) - BeyondLastVbo = CurrentLength; - /* Try to locate first run */ - if (FsRtlLookupLargeMcbEntry(&Fcb->Mcb, Vbo, Lbo, Length, NULL, NULL, Index)) - { - /* Check if we have a single mapped run */ - if (Vbo >= BeyondLastVbo) - goto FatScanFcbFatExit; - } else { - *Length = 0L; - } - /* Get the first scan startup values */ - if (FsRtlLookupLastLargeMcbEntryAndIndex( - &Fcb->Mcb, &CurrentVbo, &CurrentLbo, &CurrentIndex)) - { - Entry = FatDataOffsetToEntry(CurrentLbo, Vcb); - } - else - { - /* Map is empty, set up initial values */ - Entry = Fcb->FirstCluster; - if (Entry <= 0x2) - ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); - if (Entry >= Vcb->Clusters) - { - if (Entry < FAT_CLUSTER_LAST) - ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); - BeyondLastVbo = 0LL; - } - CurrentIndex = 0L; - CurrentVbo = 0LL; - } - /* Initialize Context */ - RtlZeroMemory(&Context, sizeof(Context)); - Context.FileObject = Vcb->StreamFileObject; - Context.EndOfData.QuadPart = Vcb->BeyondLastClusterInFat; - - while (CurrentVbo < BeyondLastVbo) - { - /* Locate Continous run starting with the current entry */ - NumberOfEntries = Entry; - NextEntry = Vcb->Methods.ScanContinousRun( - &Context, &NumberOfEntries, CanWait); - NumberOfEntries -= Entry; - /* Check value that terminated the for being valid for FAT */ - if (NextEntry <= 0x2) - ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); - if (NextEntry >= Vcb->Clusters) - { - if (NextEntry < FAT_CLUSTER_LAST) - ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); - break; - } - /* Add new run */ - CurrentLength = ((LONGLONG) NumberOfEntries) - << Vcb->BytesPerClusterLog; - FsRtlAddLargeMcbEntry(&Fcb->Mcb, - CurrentVbo, - FatEntryToDataOffset(Entry, Vcb), - CurrentLength); - /* Setup next iteration */ - Entry = NextEntry; - CurrentVbo += CurrentLength; - CurrentIndex ++; - } - if (*Length == 0LL && CurrentIndex > 0) - { - if (!FsRtlLookupLargeMcbEntry(&Fcb->Mcb, - Vbo, Lbo, Length, NULL, NULL, Index)) - { - *Index = 0L; - *Lbo = 0LL; - } - } -FatScanFcbFatExit: - return CurrentIndex; -} BOOLEAN NTAPI @@ -400,7 +42,29 @@ && (Bpb->SectorsPerFat > 0 || !Bpb->MirrorDisabled)); } +/** + * Determines the index of the set bit. + * + * @param Number + * Number having a single bit set. + * + * @return + * Index of the set bit. + */ +FORCEINLINE +ULONG +FatPowerOfTwo( + ULONG Number) +{ + ULONG Temp; + Temp = Number + - ((Number >> 1) & 033333333333) + - ((Number >> 2) & 011111111111); + return (((Temp + (Temp >> 3)) & 030707070707) % 63); +} + VOID +NTAPI FatiInitializeVcb(PVCB Vcb) { ULONG ClustersCapacity; @@ -420,17 +84,17 @@ if (Vcb->BytesPerClusterLog < 4087) { Vcb->IndexDepth = 0x0c; - Vcb->Methods = Fat12Methods; + //Vcb->Methods = Fat12Methods; } else { Vcb->IndexDepth = 0x10; - Vcb->Methods = Fat16Methods; + //Vcb->Methods = Fat16Methods; } /* Large Sectors are used for FAT32 */ if (Vcb->Bpb.Sectors == 0) { Vcb->IndexDepth = 0x20; - Vcb->Methods = Fat32Methods; + //Vcb->Methods = Fat32Methods; } ClustersCapacity = (SectorsToBytes(Vcb, Vcb->Sectors) * 0x8 / Vcb->IndexDepth) - 1; if (Vcb->Clusters > ClustersCapacity) @@ -445,6 +109,7 @@ } NTSTATUS +NTAPI FatInitializeVcb(IN PFAT_IRP_CONTEXT IrpContext, IN PVCB Vcb, IN PDEVICE_OBJECT TargetDeviceObject, @@ -558,6 +223,7 @@ } VOID +NTAPI FatUninitializeVcb(IN PVCB Vcb) { LARGE_INTEGER ZeroSize; Modified: trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fatstruc.h [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -388,6 +388,14 @@ EaFile } TYPE_OF_OPEN; +typedef enum _FILE_TIME_INDEX +{ + FileCreationTime = 0, + FileLastAccessTime, + FileLastWriteTime, + FileChangeTime +} FILE_TIME_INDEX; + #define CCB_SEARCH_RETURN_SINGLE_ENTRY 0x01 #define CCB_SEARCH_PATTERN_LEGAL_8DOT3 0x02 #define CCB_SEARCH_PATTERN_HAS_WILD_CARD 0x04 Modified: trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fullfat.c [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -100,4 +100,114 @@ return FF_Open(pIoman, AnsiName.Buffer, Mode, pError); } +FORCEINLINE +VOID +FatDateTimeToSystemTime(OUT PLARGE_INTEGER SystemTime, + IN PFAT_DATETIME FatDateTime, + IN UCHAR TenMs OPTIONAL) +{ + TIME_FIELDS TimeFields; + + /* Setup time fields */ + TimeFields.Year = FatDateTime->Date.Year + 1980; + TimeFields.Month = FatDateTime->Date.Month; + TimeFields.Day = FatDateTime->Date.Day; + TimeFields.Hour = FatDateTime->Time.Hour; + TimeFields.Minute = FatDateTime->Time.Minute; + TimeFields.Second = (FatDateTime->Time.DoubleSeconds << 1); + + /* Adjust up to 10 milliseconds + * if the parameter was supplied + */ + if (ARGUMENT_PRESENT(TenMs)) + { + TimeFields.Second += TenMs / 100; + TimeFields.Milliseconds = (TenMs % 100) * 10; + } + else + { + TimeFields.Milliseconds = 0; + } + + /* Fix seconds value that might get beyoud the bound */ + if (TimeFields.Second > 59) TimeFields.Second = 0; + + /* Perform ceonversion to system time if possible */ + if (RtlTimeFieldsToTime(&TimeFields, SystemTime)) + { + /* Convert to system time */ + ExLocalTimeToSystemTime(SystemTime, SystemTime); + } + else + { + /* Set to default time if conversion failed */ + *SystemTime = FatGlobalData.DefaultFileTime; + } +} + +// TODO: Make it a helper around FullFAT library +VOID +NTAPI +FatQueryFileTimes(OUT PLARGE_INTEGER FileTimes, + IN PDIR_ENTRY Dirent) +{ + /* Convert LastWriteTime */ + FatDateTimeToSystemTime(&FileTimes[FileLastWriteTime], + &Dirent->LastWriteDateTime, + 0); + /* All other time fileds are valid (according to MS) + * only if Win31 compatability mode is set. + */ + if (FatGlobalData.Win31FileSystem) + { + /* We can avoid calling conversion routine + * if time in dirent is 0 or equals to already + * known time (LastWriteTime). + */ + if (Dirent->CreationDateTime.Value == 0) + { + /* Set it to default time */ + FileTimes[FileCreationTime] = FatGlobalData.DefaultFileTime; + } + else if (Dirent->CreationDateTime.Value + == Dirent->LastWriteDateTime.Value) + { + /* Assign the already known time */ + FileTimes[FileCreationTime] = FileTimes[FileLastWriteTime]; + /* Adjust milliseconds from extra dirent field */ + FileTimes[FileCreationTime].QuadPart + += (ULONG) Dirent->CreationTimeTenMs * 100000; + } + else + { + /* Perform conversion */ + FatDateTimeToSystemTime(&FileTimes[FileCreationTime], + &Dirent->CreationDateTime, + Dirent->CreationTimeTenMs); + } + if (Dirent->LastAccessDate.Value == 0) + { + /* Set it to default time */ + FileTimes[FileLastAccessTime] = FatGlobalData.DefaultFileTime; + } + else if (Dirent->LastAccessDate.Value + == Dirent->LastWriteDateTime.Date.Value) + { + /* Assign the already known time */ + FileTimes[FileLastAccessTime] = FileTimes[FileLastWriteTime]; + } + else + { + /* Perform conversion */ + FAT_DATETIME LastAccessDateTime; + + LastAccessDateTime.Date.Value = Dirent->LastAccessDate.Value; + LastAccessDateTime.Time.Value = 0; + FatDateTimeToSystemTime(&FileTimes[FileLastAccessTime], + &LastAccessDateTime, + 0); + } + } +} + /* EOF */ Modified: trunk/reactos/drivers/filesystems/fastfat_new/rw.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfa… ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/rw.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/rw.c [iso-8859-1] Tue Oct 20 12:02:27 2009 @@ -4,7 +4,6 @@ * FILE: drivers/filesystems/fastfat/rw.c * PURPOSE: Read/write support * PROGRAMMERS: Aleksey Bragin (aleksey(a)reactos.org) - * Alexey Vlasov */ /* INCLUDES *****************************************************************/

1 0

[fireball] 43640: [ntoskrnl/mm/ARM3] - Rewrite MmPageEntireDriver in a better way, fix bugs.
by fireball＠svn.reactos.org 20 Oct '09

20 Oct '09

Author: fireball Date: Tue Oct 20 11:53:29 2009 New Revision: 43640 URL: http://svn.reactos.org/svn/reactos?rev=43640&view=rev Log: [ntoskrnl/mm/ARM3] - Rewrite MmPageEntireDriver in a better way, fix bugs. Modified: trunk/reactos/ntoskrnl/mm/ARM3/drvmgmt.c Modified: trunk/reactos/ntoskrnl/mm/ARM3/drvmgmt.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/drvmgmt.c… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/drvmgmt.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/drvmgmt.c [iso-8859-1] Tue Oct 20 11:53:29 2009 @@ -116,32 +116,40 @@ NTAPI MmPageEntireDriver(IN PVOID AddressWithinSection) { + PAGED_CODE(); // // We should find the driver loader entry and return its base address // - //PMMPTE Pte; - PLDR_DATA_TABLE_ENTRY pLdrDataTabEntry = MiLookupDataTableEntry(AddressWithinSection); + //PMMPTE StartPte, EndPte; + PLDR_DATA_TABLE_ENTRY pLdrDataTabEntry = + MiLookupDataTableEntry(AddressWithinSection); if (pLdrDataTabEntry) { // - // Is Paging Disabled or Check if we had already mapped it in for this section - // - if ( (MmDisablePagingExecutive & 1) || pLdrDataTabEntry->SectionPointer ) - { + // Is Paging disabled or it's mapped as an image + // + if ((MmDisablePagingExecutive & 1) || pLdrDataTabEntry->SectionPointer) return pLdrDataTabEntry->DllBase; - } + // // Flush all queued DPCs. // KeFlushQueuedDpcs(); - // - // Get the PTE for this section - // - //Pte = MiGetPteAddress(pLdrDataTabEntry->DllBase); - // - //MiSetPagingOfDriver( (Pte & (4,194,304 - 4) ) - 0x40000000 , - // (Pte & (4,194,304 - 4) ) - 0x40000000 + 4 * - // pLdrDataTabEntry->SizeOfImage >> PAGE_SHIFT - 4 ); + + // + // Get PTE range for this section + // + //StartPte = MiGetPteAddress(pLdrDataTabEntry->DllBase); + //EndPte = MiGetPteAddress(pLdrDataTabEntry->DllBase + + // pLdrDataTabEntry->SizeOfImage); + + // + // Set paging for specified PTE range + // + //MiSetPagingOfDriver(StartPte, EndPte); + + // + // Return base address // return pLdrDataTabEntry->DllBase; }

1 0

← Newer
1
...
22
23
24
25
26
27
28
...
65
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs October 2009