xref: /reactos/sdk/lib/atl/atlbase.h (revision d6d1efe7) 
1 /*
2  * ReactOS ATL
3  *
4  * Copyright 2009 Andrew Hill <ash77@reactos.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20 
21 #pragma once
22 
23 #include "atldef.h"
24 #include "atlcore.h"
25 #include "statreg.h"
26 #include "atlcomcli.h"
27 #include "atlalloc.h"
28 #include "atlexcept.h"
29 #include "comcat.h"
30 #include "tchar.h"
31 
32 #ifdef _MSC_VER
33 // It is common to use this in ATL constructors. They only store this for later use, so the usage is safe.
34 #pragma warning(disable:4355)
35 #endif
36 
37 #ifndef ATLTRY
38 #define ATLTRY(x) x;
39 #endif
40 
41 #ifdef _ATL_DISABLE_NO_VTABLE
42 #define ATL_NO_VTABLE
43 #else
44 #define ATL_NO_VTABLE __declspec(novtable)
45 #endif
46 
47 #ifndef ATL_DEPRECATED
48 #define ATL_DEPRECATED __declspec(deprecated)
49 #endif
50 
51 
52 namespace ATL
53 {
54 
55 class CAtlModule;
56 class CComModule;
57 class CAtlComModule;
58 __declspec(selectany) CAtlModule *_pAtlModule = NULL;
59 __declspec(selectany) CComModule *_pModule = NULL;
60 
61 
62 struct _ATL_CATMAP_ENTRY
63 {
64    int iType;
65    const GUID* pcatid;
66 };
67 
68 #define _ATL_CATMAP_ENTRY_END 0
69 #define _ATL_CATMAP_ENTRY_IMPLEMENTED 1
70 #define _ATL_CATMAP_ENTRY_REQUIRED 2
71 
72 
73 typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void *pv, REFIID riid, LPVOID *ppv);
74 typedef LPCTSTR (WINAPI _ATL_DESCRIPTIONFUNC)();
75 typedef const struct _ATL_CATMAP_ENTRY * (_ATL_CATMAPFUNC)();
76 
77 struct _ATL_OBJMAP_ENTRY30
78 {
79     const CLSID *pclsid;
80     HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
81     _ATL_CREATORFUNC *pfnGetClassObject;
82     _ATL_CREATORFUNC *pfnCreateInstance;
83     IUnknown *pCF;
84     DWORD dwRegister;
85     _ATL_DESCRIPTIONFUNC *pfnGetObjectDescription;
86     _ATL_CATMAPFUNC *pfnGetCategoryMap;
87     void (WINAPI *pfnObjectMain)(bool bStarting);
88 
89     HRESULT WINAPI RevokeClassObject()
90     {
91         if (dwRegister == 0)
92             return S_OK;
93         return CoRevokeClassObject(dwRegister);
94     }
95 
96     HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
97     {
98         IUnknown *p;
99         HRESULT hResult;
100 
101         p = NULL;
102         if (pfnGetClassObject == NULL)
103             return S_OK;
104 
105         hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p));
106         if (SUCCEEDED(hResult))
107             hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
108 
109         if (p != NULL)
110             p->Release();
111 
112         return hResult;
113     }
114 };
115 
116 typedef _ATL_OBJMAP_ENTRY30 _ATL_OBJMAP_ENTRY;
117 
118 typedef void (__stdcall _ATL_TERMFUNC)(DWORD_PTR dw);
119 
120 struct _ATL_TERMFUNC_ELEM
121 {
122     _ATL_TERMFUNC *pFunc;
123     DWORD_PTR dw;
124     _ATL_TERMFUNC_ELEM *pNext;
125 };
126 
127 struct _ATL_MODULE70
128 {
129     UINT cbSize;
130     LONG m_nLockCnt;
131     _ATL_TERMFUNC_ELEM *m_pTermFuncs;
132     CComCriticalSection m_csStaticDataInitAndTypeInfo;
133 };
134 typedef _ATL_MODULE70 _ATL_MODULE;
135 
136 typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void *pv, REFIID riid, LPVOID *ppv, DWORD_PTR dw);
137 
138 #define _ATL_SIMPLEMAPENTRY ((ATL::_ATL_CREATORARGFUNC *)1)
139 
140 struct _ATL_INTMAP_ENTRY
141 {
142     const IID *piid;
143     DWORD_PTR dw;
144     _ATL_CREATORARGFUNC *pFunc;
145 };
146 
147 struct _AtlCreateWndData
148 {
149     void *m_pThis;
150     DWORD m_dwThreadID;
151     _AtlCreateWndData *m_pNext;
152 };
153 
154 struct _ATL_COM_MODULE70
155 {
156     UINT cbSize;
157     HINSTANCE m_hInstTypeLib;
158     _ATL_OBJMAP_ENTRY **m_ppAutoObjMapFirst;
159     _ATL_OBJMAP_ENTRY **m_ppAutoObjMapLast;
160     CComCriticalSection m_csObjMap;
161 };
162 typedef _ATL_COM_MODULE70 _ATL_COM_MODULE;
163 
164 struct _ATL_WIN_MODULE70
165 {
166     UINT cbSize;
167     CComCriticalSection m_csWindowCreate;
168     _AtlCreateWndData *m_pCreateWndList;
169 #ifdef NOTYET
170     CSimpleArray<ATOM>                        m_rgWindowClassAtoms;
171 #endif
172 };
173 typedef _ATL_WIN_MODULE70 _ATL_WIN_MODULE;
174 
175 struct _ATL_REGMAP_ENTRY
176 {
177     LPCOLESTR szKey;
178     LPCOLESTR szData;
179 };
180 
181 HRESULT WINAPI AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule);
182 HRESULT WINAPI AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst);
183 HRESULT WINAPI AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject);
184 void WINAPI AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject);
185 void *WINAPI AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule);
186 HRESULT WINAPI AtlComModuleGetClassObject(_ATL_COM_MODULE *pComModule, REFCLSID rclsid, REFIID riid, LPVOID *ppv);
187 
188 HRESULT WINAPI AtlComModuleRegisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid);
189 HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid);
190 
191 HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags);
192 HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module);
193 
194 
195 template<class TLock>
196 class CComCritSecLock
197 {
198 private:
199     bool m_bLocked;
200     TLock &m_cs;
201 public:
202     CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs)
203     {
204         HRESULT hResult;
205 
206         m_bLocked = false;
207         if (bInitialLock)
208         {
209             hResult = Lock();
210             if (FAILED(hResult))
211             {
212                 ATLASSERT(false);
213             }
214         }
215     }
216 
217     ~CComCritSecLock()
218     {
219         if (m_bLocked)
220             Unlock();
221     }
222 
223     HRESULT Lock()
224     {
225         HRESULT                                    hResult;
226 
227         ATLASSERT(!m_bLocked);
228         hResult = m_cs.Lock();
229         if (FAILED(hResult))
230             return hResult;
231         m_bLocked = true;
232 
233         return S_OK;
234     }
235 
236     void Unlock()
237     {
238         HRESULT                                    hResult;
239 
240         ATLASSERT(m_bLocked);
241         hResult = m_cs.Unlock();
242         if (FAILED(hResult))
243         {
244             ATLASSERT(false);
245         }
246         m_bLocked = false;
247     }
248 };
249 
250 
251 class CHandle
252 {
253 public:
254     HANDLE m_handle;
255 
256 public:
257     CHandle() :
258         m_handle(NULL)
259     {
260     }
261 
262     CHandle(_Inout_ CHandle& handle) :
263         m_handle(NULL)
264     {
265         Attach(handle.Detach());
266     }
267 
268     explicit CHandle(_In_ HANDLE handle) :
269         m_handle(handle)
270     {
271     }
272 
273     ~CHandle()
274     {
275         if (m_handle)
276         {
277             Close();
278         }
279     }
280 
281     CHandle& operator=(_Inout_ CHandle& handle)
282     {
283         if (this != &handle)
284         {
285             if (m_handle)
286             {
287                 Close();
288             }
289             Attach(handle.Detach());
290         }
291 
292         return *this;
293     }
294 
295     operator HANDLE() const
296     {
297         return m_handle;
298     }
299 
300     void Attach(_In_ HANDLE handle)
301     {
302         ATLASSERT(m_handle == NULL);
303         m_handle = handle;
304     }
305 
306     HANDLE Detach()
307     {
308         HANDLE handle = m_handle;
309         m_handle = NULL;
310         return handle;
311     }
312 
313     void Close()
314     {
315         if (m_handle)
316         {
317             ::CloseHandle(m_handle);
318             m_handle = NULL;
319         }
320     }
321 };
322 
323 
324 inline BOOL WINAPI InlineIsEqualUnknown(REFGUID rguid1)
325 {
326    return (
327       ((unsigned long *)&rguid1)[0] == 0 &&
328       ((unsigned long *)&rguid1)[1] == 0 &&
329       ((unsigned long *)&rguid1)[2] == 0x000000C0 &&
330       ((unsigned long *)&rguid1)[3] == 0x46000000);
331 }
332 
333 class CComMultiThreadModelNoCS
334 {
335 public:
336     typedef CComFakeCriticalSection AutoCriticalSection;
337     typedef CComFakeCriticalSection CriticalSection;
338     typedef CComMultiThreadModelNoCS ThreadModelNoCS;
339     typedef CComFakeCriticalSection AutoDeleteCriticalSection;
340 
341     static ULONG WINAPI Increment(LPLONG p)
342     {
343         return InterlockedIncrement(p);
344     }
345 
346     static ULONG WINAPI Decrement(LPLONG p)
347     {
348         return InterlockedDecrement(p);
349     }
350 };
351 
352 class CComMultiThreadModel
353 {
354 public:
355     typedef CComAutoCriticalSection AutoCriticalSection;
356     typedef CComCriticalSection CriticalSection;
357     typedef CComMultiThreadModelNoCS ThreadModelNoCS;
358     typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection;
359 
360     static ULONG WINAPI Increment(LPLONG p)
361     {
362         return InterlockedIncrement(p);
363     }
364 
365     static ULONG WINAPI Decrement(LPLONG p)
366     {
367         return InterlockedDecrement(p);
368     }
369 };
370 
371 class CComSingleThreadModel
372 {
373 public:
374     typedef CComFakeCriticalSection AutoCriticalSection;
375     typedef CComFakeCriticalSection CriticalSection;
376     typedef CComSingleThreadModel ThreadModelNoCS;
377     typedef CComFakeCriticalSection AutoDeleteCriticalSection;
378 
379     static ULONG WINAPI Increment(LPLONG p)
380     {
381         return ++*p;
382     }
383 
384     static ULONG WINAPI Decrement(LPLONG p)
385     {
386         return --*p;
387     }
388 };
389 
390 #if defined(_ATL_FREE_THREADED)
391 
392     typedef CComMultiThreadModel CComObjectThreadModel;
393     typedef CComMultiThreadModel CComGlobalsThreadModel;
394 
395 #elif defined(_ATL_APARTMENT_THREADED)
396 
397     typedef CComSingleThreadModel CComObjectThreadModel;
398     typedef CComMultiThreadModel CComGlobalsThreadModel;
399 
400 #elif defined(_ATL_SINGLE_THREADED)
401 
402     typedef CComSingleThreadModel CComObjectThreadModel;
403     typedef CComSingleThreadModel CComGlobalsThreadModel;
404 
405 #else
406 #error No threading model
407 #endif
408 
409 class CAtlModule : public _ATL_MODULE
410 {
411 public:
412     static GUID m_libid;
413 
414     CAtlModule()
415     {
416         ATLASSERT(_pAtlModule == NULL);
417         _pAtlModule = this;
418         cbSize = sizeof(_ATL_MODULE);
419         m_nLockCnt = 0;
420     }
421 
422     virtual LONG GetLockCount()
423     {
424         return m_nLockCnt;
425     }
426 
427     virtual LONG Lock()
428     {
429         return CComGlobalsThreadModel::Increment(&m_nLockCnt);
430     }
431 
432     virtual LONG Unlock()
433     {
434         return CComGlobalsThreadModel::Decrement(&m_nLockCnt);
435     }
436 
437     virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0;
438 
439     HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
440     {
441         CRegObject registrar;
442         WCHAR modulePath[MAX_PATH];
443         HRESULT hResult;
444         PCWSTR lpwszRes;
445 
446         hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
447         if (FAILED(hResult))
448             return hResult;
449 #ifdef UNICODE
450         lpwszRes = lpszRes;
451 #else
452         /* FIXME: this is a bit of a hack, need to re-evaluate */
453         WCHAR resid[MAX_PATH];
454         MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, resid, MAX_PATH);
455         lpwszRes = resid;
456 #endif
457         if (bRegister != FALSE)
458             hResult = registrar.ResourceRegisterSz(modulePath, lpwszRes, L"REGISTRY");
459         else
460             hResult = registrar.ResourceUnregisterSz(modulePath, lpwszRes, L"REGISTRY");
461 
462         return hResult;
463     }
464 
465     HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
466     {
467         CRegObject registrar;
468         WCHAR modulePath[MAX_PATH];
469         HRESULT hResult;
470 
471         hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
472         if (FAILED(hResult))
473             return hResult;
474 
475         if (bRegister != FALSE)
476             hResult = registrar.ResourceRegister(modulePath, nResID, L"REGISTRY");
477         else
478             hResult = registrar.ResourceUnregister(modulePath, nResID, L"REGISTRY");
479 
480         return hResult;
481     }
482 
483 private:
484     HRESULT CommonInitRegistrar(CRegObject &registrar, WCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries)
485     {
486         HINSTANCE hInstance;
487         DWORD dwFLen;
488         HRESULT hResult;
489 
490         hInstance = _AtlBaseModule.GetModuleInstance();
491         dwFLen = GetModuleFileNameW(hInstance, modulePath, modulePathCount);
492         if (dwFLen == modulePathCount)
493             return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
494         else if (dwFLen == 0)
495             return HRESULT_FROM_WIN32(GetLastError());
496 
497         if (pMapEntries != NULL)
498         {
499             while (pMapEntries->szKey != NULL)
500             {
501                 ATLASSERT(pMapEntries->szData != NULL);
502                 hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData);
503                 if (FAILED(hResult))
504                     return hResult;
505                 pMapEntries++;
506             }
507         }
508 
509         hResult = AddCommonRGSReplacements(&registrar);
510         if (FAILED(hResult))
511             return hResult;
512 
513         hResult = registrar.AddReplacement(L"Module", modulePath);
514         if (FAILED(hResult))
515             return hResult;
516 
517         hResult = registrar.AddReplacement(L"Module_Raw", modulePath);
518         if (FAILED(hResult))
519             return hResult;
520 
521         return S_OK;
522     }
523 };
524 
525 __declspec(selectany) GUID CAtlModule::m_libid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
526 
527 template <class T>
528 class CAtlModuleT : public CAtlModule
529 {
530 public:
531 
532     HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL);
533     HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL);
534 
535 
536     virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar)
537     {
538         return pRegistrar->AddReplacement(L"APPID", T::GetAppId());
539     }
540 
541     static LPCOLESTR GetAppId()
542     {
543         return L"";
544     }
545 };
546 
547 class CAtlComModule : public _ATL_COM_MODULE
548 {
549 public:
550     CAtlComModule()
551     {
552         GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInstTypeLib);
553         m_ppAutoObjMapFirst = NULL;
554         m_ppAutoObjMapLast = NULL;
555         if (FAILED(m_csObjMap.Init()))
556         {
557             ATLASSERT(0);
558             CAtlBaseModule::m_bInitFailed = true;
559             return;
560         }
561         cbSize = sizeof(_ATL_COM_MODULE);
562     }
563 
564     ~CAtlComModule()
565     {
566         Term();
567     }
568 
569     HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
570     {
571         return AtlComModuleRegisterServer(this, bRegTypeLib, pCLSID);
572     }
573 
574     HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
575     {
576         return AtlComModuleUnregisterServer(this, bUnRegTypeLib, pCLSID);
577     }
578 
579 
580     void Term()
581     {
582         if (cbSize != 0)
583         {
584             ATLASSERT(m_ppAutoObjMapFirst == NULL);
585             ATLASSERT(m_ppAutoObjMapLast == NULL);
586             m_csObjMap.Term();
587             cbSize = 0;
588         }
589     }
590 };
591 
592 __declspec(selectany) CAtlComModule _AtlComModule;
593 
594 
595 template <class T>
596 HRESULT CAtlModuleT<T>::RegisterServer(BOOL bRegTypeLib, const CLSID *pCLSID)
597 {
598     return _AtlComModule.RegisterServer(bRegTypeLib, pCLSID);
599 }
600 
601 template <class T>
602 HRESULT CAtlModuleT<T>::UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID)
603 {
604     return _AtlComModule.UnregisterServer(bUnRegTypeLib, pCLSID);
605 }
606 
607 template <class T>
608 class CAtlDllModuleT : public CAtlModuleT<T>
609 {
610 public:
611     CAtlDllModuleT()
612     {
613     }
614 
615     HRESULT DllCanUnloadNow()
616     {
617         T *pThis;
618 
619         pThis = static_cast<T *>(this);
620         if (pThis->GetLockCount() == 0)
621             return S_OK;
622         return S_FALSE;
623     }
624 
625     HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
626     {
627         T *pThis;
628 
629         pThis = static_cast<T *>(this);
630         return pThis->GetClassObject(rclsid, riid, ppv);
631     }
632 
633     HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
634     {
635         T *pThis;
636         HRESULT hResult;
637 
638         pThis = static_cast<T *>(this);
639         hResult = pThis->RegisterServer(bRegTypeLib);
640         return hResult;
641     }
642 
643     HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
644     {
645         T *pThis;
646         HRESULT hResult;
647 
648         pThis = static_cast<T *>(this);
649         hResult = pThis->UnregisterServer(bUnRegTypeLib);
650         return hResult;
651     }
652 
653     HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
654     {
655         return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv);
656     }
657 };
658 
659 
660 template <class T>
661 class CAtlExeModuleT : public CAtlModuleT<T>
662 {
663 public:
664     DWORD m_dwMainThreadID;
665     //DWORD m_dwTimeOut;
666     //DWORD m_dwPause;
667     //bool m_bDelayShutdown;
668 
669     CAtlExeModuleT()
670         :m_dwMainThreadID(::GetCurrentThreadId())
671     {
672     }
673 
674     ~CAtlExeModuleT()
675     {
676     }
677 
678     int WinMain(int nShowCmd)
679     {
680         HRESULT hr = T::InitializeCom();
681         if (FAILED(hr))
682             return hr;
683 
684         T* pThis = static_cast<T*>(this);
685 
686         LPCTSTR lpCommandLine = GetCommandLine();
687         if (pThis->ParseCommandLine(lpCommandLine, &hr))
688         {
689             hr = pThis->Run(nShowCmd);
690         }
691 
692         T::UninitializeCom();
693         return hr;
694     }
695 
696 
697     HRESULT Run(int nShowCmd = SW_HIDE)
698     {
699         HRESULT hr = S_OK;
700 
701         T* pThis = static_cast<T*>(this);
702         hr = pThis->PreMessageLoop(nShowCmd);
703 
704         if (hr == S_OK)
705         {
706             pThis->RunMessageLoop();
707             hr = pThis->PostMessageLoop();
708         }
709 
710         return hr;
711     }
712 
713     LONG Lock()
714     {
715         return CoAddRefServerProcess();
716     }
717 
718     LONG Unlock()
719     {
720         LONG lRet = CoReleaseServerProcess();
721         if (lRet == 0)
722         {
723             ::PostThreadMessage(m_dwMainThreadID, WM_QUIT, 0, 0);
724         }
725         return lRet;
726     }
727 
728     bool ParseCommandLine(LPCTSTR lpCmdLine, HRESULT* pnRetCode)
729     {
730         // unimplemented!
731         return true;
732     }
733 
734     HRESULT PreMessageLoop(int nShowCmd)
735     {
736         T* pThis = static_cast<T*>(this);
737         return pThis->RegisterClassObjects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE);
738     }
739 
740     void RunMessageLoop()
741     {
742         MSG msg;
743         while (GetMessage(&msg, 0, 0, 0) > 0)
744         {
745             TranslateMessage(&msg);
746             DispatchMessage(&msg);
747         }
748     }
749 
750     HRESULT PostMessageLoop()
751     {
752         T* pThis = static_cast<T*>(this);
753         return pThis->RevokeClassObjects();
754     }
755 
756     HRESULT RegisterClassObjects(DWORD dwClsContext, DWORD dwFlags)
757     {
758         return AtlComModuleRegisterClassObjects(&_AtlComModule, dwClsContext, dwFlags);
759     }
760 
761     HRESULT RevokeClassObjects()
762     {
763         return AtlComModuleRevokeClassObjects(&_AtlComModule);
764     }
765 
766     static HRESULT InitializeCom()
767     {
768         return ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
769     }
770 
771     static void UninitializeCom()
772     {
773         ::CoUninitialize();
774     }
775 
776 };
777 
778 
779 
780 class CComModule : public CAtlModuleT<CComModule>
781 {
782 public:
783     _ATL_OBJMAP_ENTRY *m_pObjMap;
784 public:
785     CComModule()
786     {
787         ATLASSERT(_pModule == NULL);
788         _pModule = this;
789         _pModule->m_pObjMap = NULL;
790     }
791 
792     ~CComModule()
793     {
794         _pModule = NULL;
795     }
796 
797     HRESULT Init(_ATL_OBJMAP_ENTRY *p, HINSTANCE /* h */, const GUID *plibid)
798     {
799         _ATL_OBJMAP_ENTRY *objectMapEntry;
800 
801         if (plibid != NULL)
802             m_libid = *plibid;
803 
804         if (p != reinterpret_cast<_ATL_OBJMAP_ENTRY *>(-1))
805         {
806             m_pObjMap = p;
807             if (p != NULL)
808             {
809                 objectMapEntry = p;
810                 while (objectMapEntry->pclsid != NULL)
811                 {
812                     objectMapEntry->pfnObjectMain(true);
813                     objectMapEntry++;
814                 }
815             }
816         }
817         return S_OK;
818     }
819 
820     void Term()
821     {
822         _ATL_OBJMAP_ENTRY                    *objectMapEntry;
823 
824         if (m_pObjMap != NULL)
825         {
826             objectMapEntry = m_pObjMap;
827             while (objectMapEntry->pclsid != NULL)
828             {
829                 if (objectMapEntry->pCF != NULL)
830                     objectMapEntry->pCF->Release();
831                 objectMapEntry->pCF = NULL;
832                 objectMapEntry->pfnObjectMain(false);
833                 objectMapEntry++;
834             }
835         }
836     }
837 
838     HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
839     {
840         _ATL_OBJMAP_ENTRY                    *objectMapEntry;
841         HRESULT                                hResult;
842 
843         ATLASSERT(ppv != NULL);
844         if (ppv == NULL)
845             return E_POINTER;
846         *ppv = NULL;
847         hResult = S_OK;
848         if (m_pObjMap != NULL)
849         {
850             objectMapEntry = m_pObjMap;
851             while (objectMapEntry->pclsid != NULL)
852             {
853                 if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE)
854                 {
855                     if (objectMapEntry->pCF == NULL)
856                     {
857                         CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true);
858 
859                         if (objectMapEntry->pCF == NULL)
860                             hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF));
861                     }
862                     if (objectMapEntry->pCF != NULL)
863                         hResult = objectMapEntry->pCF->QueryInterface(riid, ppv);
864                     break;
865                 }
866                 objectMapEntry++;
867             }
868         }
869         if (hResult == S_OK && *ppv == NULL)
870         {
871             // FIXME: call AtlComModuleGetClassObject
872             hResult = CLASS_E_CLASSNOTAVAILABLE;
873         }
874         return hResult;
875     }
876 
877     HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
878     {
879         _ATL_OBJMAP_ENTRY *objectMapEntry;
880         HRESULT hResult;
881 
882         hResult = S_OK;
883         objectMapEntry = m_pObjMap;
884         if (objectMapEntry != NULL)
885         {
886             while (objectMapEntry->pclsid != NULL)
887             {
888                 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
889                 {
890                     hResult = objectMapEntry->pfnUpdateRegistry(TRUE);
891                     if (FAILED(hResult))
892                         break;
893                 }
894                 objectMapEntry++;
895             }
896         }
897         if (SUCCEEDED(hResult))
898             hResult = CAtlModuleT<CComModule>::RegisterServer(bRegTypeLib, pCLSID);
899         return hResult;
900     }
901 
902     HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
903     {
904         _ATL_OBJMAP_ENTRY *objectMapEntry;
905         HRESULT hResult;
906 
907         hResult = S_OK;
908         objectMapEntry = m_pObjMap;
909         if (objectMapEntry != NULL)
910         {
911             while (objectMapEntry->pclsid != NULL)
912             {
913                 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
914                 {
915                     hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister
916                     if (FAILED(hResult))
917                         break;
918                 }
919                 objectMapEntry++;
920             }
921         }
922         if (SUCCEEDED(hResult))
923             hResult = CAtlModuleT<CComModule>::UnregisterServer(bUnRegTypeLib, pCLSID);
924 
925         return hResult;
926     }
927 
928     HRESULT DllCanUnloadNow()
929     {
930         if (GetLockCount() == 0)
931             return S_OK;
932         return S_FALSE;
933     }
934 
935     HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
936     {
937         return GetClassObject(rclsid, riid, ppv);
938     }
939 
940     HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
941     {
942         return RegisterServer(bRegTypeLib);
943     }
944 
945     HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
946     {
947         return UnregisterServer(bUnRegTypeLib);
948     }
949 
950 };
951 
952 class CAtlWinModule : public _ATL_WIN_MODULE
953 {
954 public:
955     CAtlWinModule()
956     {
957         HRESULT hResult;
958 
959         hResult = AtlWinModuleInit(this);
960         if (FAILED(hResult))
961         {
962             CAtlBaseModule::m_bInitFailed = true;
963             ATLASSERT(0);
964         }
965     }
966 
967     ~CAtlWinModule()
968     {
969         Term();
970     }
971 
972     void Term()
973     {
974         AtlWinModuleTerm(this, _AtlBaseModule.GetModuleInstance());
975     }
976 
977     void AddCreateWndData(_AtlCreateWndData *pData, void *pObject)
978     {
979         AtlWinModuleAddCreateWndData(this, pData, pObject);
980     }
981 
982     void *ExtractCreateWndData()
983     {
984         return AtlWinModuleExtractCreateWndData(this);
985     }
986 };
987 
988 __declspec(selectany) CAtlWinModule _AtlWinModule;
989 
990 
991 class CComAllocator
992 {
993 public:
994     static void* Allocate(_In_ size_t size)
995     {
996         return ::CoTaskMemAlloc(size);
997     }
998 
999     static void* Reallocate(_In_opt_ void* ptr, _In_ size_t size)
1000     {
1001         return ::CoTaskMemRealloc(ptr, size);
1002     }
1003 
1004     static void Free(_In_opt_ void* ptr)
1005     {
1006         ::CoTaskMemFree(ptr);
1007     }
1008 };
1009 
1010 class CRegKey
1011 {
1012 public:
1013     HKEY m_hKey;
1014 #if 0
1015     // FIXME & TODO:
1016     CAtlTransactionManager* m_pTM;
1017 #endif
1018 
1019 public:
1020 
1021     CRegKey() throw()
1022         : m_hKey(NULL)
1023     {
1024     }
1025 
1026     CRegKey(CRegKey& key) throw()
1027         : m_hKey(key.Detach())
1028     {
1029     }
1030 
1031     explicit CRegKey(HKEY hKey) throw()
1032         : m_hKey(hKey)
1033     {
1034     }
1035 
1036 #if 0
1037     // FIXME & TODO:
1038     CRegKey(CAtlTransactionManager* pTM) throw()
1039     {
1040         ...
1041     }
1042 #endif
1043 
1044     ~CRegKey() throw()
1045     {
1046     }
1047 
1048     void Attach(HKEY hKey) throw()
1049     {
1050         m_hKey = hKey;
1051     }
1052 
1053     LONG Close() throw()
1054     {
1055         if (m_hKey)
1056         {
1057             HKEY hKey = Detach();
1058             return ::RegCloseKey(hKey);
1059         }
1060         return ERROR_SUCCESS;
1061     }
1062 
1063     HKEY Detach() throw()
1064     {
1065         HKEY hKey = m_hKey;
1066         m_hKey = NULL;
1067         return hKey;
1068     }
1069 
1070     LONG Open(HKEY hKeyParent, LPCTSTR lpszKeyName,
1071               REGSAM samDesired = KEY_READ | KEY_WRITE) throw()
1072     {
1073         ATLASSERT(hKeyParent);
1074         ATLASSERT(lpszKeyName);
1075 
1076         HKEY hKey = NULL;
1077         LONG lRes = ::RegOpenKeyEx(hKeyParent, lpszKeyName, 0, samDesired, &hKey);
1078         if (lRes != ERROR_SUCCESS)
1079         {
1080             samDesired |= KEY_WOW64_64KEY;
1081             lRes = ::RegOpenKeyEx(hKeyParent, lpszKeyName, 0, samDesired, &hKey);
1082         }
1083         if (lRes == ERROR_SUCCESS)
1084         {
1085             Close();
1086             m_hKey = hKey;
1087         }
1088         return lRes;
1089     }
1090 
1091     LONG Create(HKEY hKeyParent, LPCTSTR lpszKeyName,
1092                 LPTSTR lpszClass = REG_NONE,
1093                 DWORD dwOptions = REG_OPTION_NON_VOLATILE,
1094                 REGSAM samDesired = KEY_READ | KEY_WRITE,
1095                 LPSECURITY_ATTRIBUTES lpSecAttr = NULL,
1096                 LPDWORD lpdwDisposition = NULL) throw()
1097     {
1098         ATLASSERT(hKeyParent);
1099         ATLASSERT(lpszKeyName);
1100 
1101         HKEY hKey = NULL;
1102         LONG lRes = ::RegCreateKeyEx(hKeyParent, lpszKeyName, 0, lpszClass,
1103                                      dwOptions, samDesired, lpSecAttr, &hKey,
1104                                      lpdwDisposition);
1105         if (lRes != ERROR_SUCCESS)
1106         {
1107             samDesired |= KEY_WOW64_64KEY;
1108             lRes = ::RegCreateKeyEx(hKeyParent, lpszKeyName, 0, lpszClass,
1109                                     dwOptions, samDesired, lpSecAttr, &hKey,
1110                                     lpdwDisposition);
1111         }
1112         if (lRes == ERROR_SUCCESS)
1113         {
1114             Close();
1115             m_hKey = hKey;
1116         }
1117         return lRes;
1118     }
1119 
1120     LONG QueryValue(LPCTSTR pszValueName, DWORD* pdwType, void* pData, ULONG* pnBytes) throw()
1121     {
1122         ATLASSERT(m_hKey);
1123         return ::RegQueryValueEx(m_hKey, pszValueName, NULL, pdwType, (LPBYTE)pData, pnBytes);
1124     }
1125 
1126     LONG QueryDWORDValue(LPCTSTR pszValueName, DWORD& dwValue) throw()
1127     {
1128         ULONG size = sizeof(DWORD);
1129         DWORD type = 0;
1130         LONG lRet = QueryValue(pszValueName, &type, &dwValue, &size);
1131 
1132         if (lRet == ERROR_SUCCESS && type != REG_DWORD)
1133             lRet = ERROR_INVALID_DATA;
1134 
1135         return lRet;
1136     }
1137 
1138     LONG QueryBinaryValue(LPCTSTR pszValueName, void* pValue, ULONG* pnBytes) throw()
1139     {
1140         DWORD type = 0;
1141         LONG lRet = QueryValue(pszValueName, &type, pValue, pnBytes);
1142 
1143         if (lRet == ERROR_SUCCESS && type != REG_BINARY)
1144             lRet = ERROR_INVALID_DATA;
1145 
1146         return lRet;
1147     }
1148 
1149     LONG QueryStringValue(LPCTSTR pszValueName, LPTSTR pszValue, ULONG* pnChars) throw()
1150     {
1151         ULONG size = (*pnChars) * sizeof(TCHAR);
1152         DWORD type = 0;
1153         LONG lRet = QueryValue(pszValueName, &type, pszValue, &size);
1154 
1155         if (lRet == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ)
1156             lRet = ERROR_INVALID_DATA;
1157 
1158         *pnChars = size / sizeof(TCHAR);
1159         return lRet;
1160     }
1161 
1162     LONG QueryGUIDValue(LPCTSTR pszValueName, GUID& guidValue) throw()
1163     {
1164         OLECHAR buf[40] = {0};
1165         ULONG nChars = 39;
1166         LONG lRet;
1167 
1168 #ifdef UNICODE
1169         lRet = QueryStringValue(pszValueName, buf, &nChars);
1170 #else
1171         CHAR bufA[40] = {0};
1172         lRet = QueryStringValue(pszValueName, bufA, &nChars);
1173         if (lRet != ERROR_SUCCESS)
1174             return lRet;
1175         if (!::MultiByteToWideChar(CP_THREAD_ACP, 0, bufA, -1, buf, 39))
1176             lRet = ERROR_INVALID_DATA;
1177 #endif
1178         if (lRet != ERROR_SUCCESS)
1179             return lRet;
1180 
1181         if (!SUCCEEDED(::CLSIDFromString(buf, &guidValue)))
1182             return ERROR_INVALID_DATA;
1183 
1184         return lRet;
1185     }
1186 
1187     LONG QueryQWORDValue(LPCTSTR pszValueName, ULONGLONG& qwValue) throw()
1188     {
1189         ULONG size = sizeof(ULONGLONG);
1190         DWORD type = 0;
1191         LONG lRet = QueryValue(pszValueName, &type, &qwValue, &size);
1192 
1193         if (lRet == ERROR_SUCCESS && type != REG_QWORD)
1194             lRet = ERROR_INVALID_DATA;
1195 
1196         return lRet;
1197     }
1198 
1199     LONG QueryMultiStringValue(LPCTSTR pszValueName, LPTSTR pszValue,
1200                                ULONG* pnChars) throw()
1201     {
1202         ULONG size = (*pnChars) * sizeof(TCHAR);
1203         DWORD type;
1204         LONG lRet = QueryValue(pszValueName, &type, pszValue, &size);
1205 
1206         if (lRet == ERROR_SUCCESS && type != REG_MULTI_SZ)
1207             lRet = ERROR_INVALID_DATA;
1208 
1209         *pnChars = size / sizeof(TCHAR);
1210         return lRet;
1211     }
1212 
1213     LONG SetValue(LPCTSTR pszValueName, DWORD dwType, const void* pValue, ULONG nBytes) throw()
1214     {
1215         ATLASSERT(m_hKey);
1216         return ::RegSetValueEx(m_hKey, pszValueName, 0, dwType, (const BYTE*)pValue, nBytes);
1217     }
1218 
1219     LONG SetDWORDValue(LPCTSTR pszValueName, DWORD dwValue) throw()
1220     {
1221         return SetValue(pszValueName, REG_DWORD, &dwValue, sizeof(DWORD));
1222     }
1223 
1224     LONG SetStringValue(LPCTSTR pszValueName, LPCTSTR pszValue, DWORD dwType = REG_SZ) throw()
1225     {
1226         SIZE_T length;
1227         switch (dwType)
1228         {
1229         case REG_SZ:
1230         case REG_EXPAND_SZ:
1231             length = (_tcslen(pszValue) + 1) * sizeof(TCHAR);
1232             return SetValue(pszValueName, dwType, pszValue, length);
1233         case REG_MULTI_SZ:
1234             return SetMultiStringValue(pszValueName, pszValue);
1235         default:
1236             return ERROR_INVALID_DATA;
1237         }
1238     }
1239 
1240     LONG SetGUIDValue(LPCTSTR pszValueName, REFGUID guidValue) throw()
1241     {
1242         OLECHAR buf[40] = {0};
1243         ::StringFromGUID2(guidValue, buf, 39);
1244 #ifdef UNICODE
1245         return SetStringValue(pszValueName, buf);
1246 #else
1247         CHAR bufA[40] = {0};
1248         ::WideCharToMultiByte(CP_THREAD_ACP, 0, buf, -1, bufA, 40, NULL, NULL);
1249         return SetStringValue(pszValueName, bufA);
1250 #endif
1251     }
1252 
1253     LONG SetBinaryValue(LPCTSTR pszValueName, const void* pValue, ULONG nBytes) throw()
1254     {
1255         return SetValue(pszValueName, REG_BINARY, pValue, nBytes);
1256     }
1257 
1258     LONG SetMultiStringValue(LPCTSTR pszValueName, LPCTSTR pszValue) throw()
1259     {
1260         ULONG dwSize = CRegKey::_GetMultiStringSize(pszValue);
1261         return SetValue(pszValueName, REG_MULTI_SZ, pszValue, dwSize);
1262     }
1263 
1264     LONG SetQWORDValue(LPCTSTR pszValueName, ULONGLONG qwValue) throw()
1265     {
1266         ULONG dwSize = sizeof(ULONGLONG);
1267         return SetValue(pszValueName, REG_QWORD, &qwValue, dwSize);
1268     }
1269 
1270     LONG NotifyChangeKeyValue(BOOL bWatchSubtree, DWORD dwNotifyFilter,
1271                               HANDLE hEvent, BOOL bAsync = TRUE) throw()
1272     {
1273         ATLASSERT(m_hKey);
1274         LONG ret = ::RegNotifyChangeKeyValue(m_hKey, bWatchSubtree,
1275                                              dwNotifyFilter, hEvent, bAsync);
1276         return ret;
1277     }
1278 
1279     LONG Flush() throw()
1280     {
1281         ATLASSERT(m_hKey);
1282         LONG ret = ::RegFlushKey(m_hKey);
1283         return ret;
1284     }
1285 
1286     static LONG WINAPI SetValue(HKEY hKeyParent, LPCTSTR lpszKeyName,
1287                                 LPCTSTR lpszValue, LPCTSTR lpszValueName = NULL)
1288     {
1289         CRegKey key;
1290         LONG lRet = key.Create(hKeyParent, lpszKeyName);
1291         if (lRet == ERROR_SUCCESS)
1292         {
1293             lRet = key.SetStringValue(lpszValueName, lpszValue);
1294         }
1295         return lRet;
1296     }
1297 
1298     LONG SetKeyValue(LPCTSTR lpszKeyName, LPCTSTR lpszValue,
1299                      LPCTSTR lpszValueName = NULL) throw()
1300     {
1301         CRegKey key;
1302         LONG lRet = key.Create(m_hKey, lpszKeyName);
1303         if (lRet == ERROR_SUCCESS)
1304         {
1305             lRet = key.SetStringValue(lpszValueName, lpszValue);
1306         }
1307         return lRet;
1308     }
1309 
1310     LONG DeleteValue(LPCTSTR lpszValue) throw()
1311     {
1312         ATLASSERT(m_hKey);
1313         return ::RegDeleteValue(m_hKey, lpszValue);
1314     }
1315 
1316     LONG DeleteSubKey(LPCTSTR lpszSubKey) throw()
1317     {
1318         ATLASSERT(m_hKey);
1319         ATLASSERT(lpszSubKey);
1320         return ::RegDeleteKey(m_hKey, lpszSubKey);
1321     }
1322 
1323     LONG RecurseDeleteKey(LPCTSTR lpszKey) throw()
1324     {
1325         ATLASSERT(m_hKey);
1326         ATLASSERT(lpszKey);
1327         return CRegKey::_DoDeleteKeyTree(m_hKey, lpszKey);
1328     }
1329 
1330     LONG EnumKey(DWORD iIndex, LPTSTR pszName, LPDWORD pnNameLength,
1331                  FILETIME* pftLastWriteTime = NULL) throw()
1332     {
1333         ATLASSERT(m_hKey);
1334         LONG ret = ::RegEnumKeyEx(m_hKey, iIndex, pszName, pnNameLength, NULL,
1335                                   NULL, NULL, pftLastWriteTime);
1336         return ret;
1337     }
1338 
1339     LONG GetKeySecurity(SECURITY_INFORMATION si, PSECURITY_DESCRIPTOR psd,
1340                         LPDWORD pnBytes) throw()
1341     {
1342         ATLASSERT(m_hKey);
1343         LONG ret = ::RegGetKeySecurity(m_hKey, si, psd, pnBytes);
1344         return ret;
1345     }
1346 
1347     LONG SetKeySecurity(SECURITY_INFORMATION si,
1348                         PSECURITY_DESCRIPTOR psd) throw()
1349     {
1350         ATLASSERT(m_hKey);
1351         LONG ret = ::RegSetKeySecurity(m_hKey, si, psd);
1352         return ret;
1353     }
1354 
1355     operator HKEY() const throw()
1356     {
1357         return m_hKey;
1358     }
1359 
1360     CRegKey& operator=(CRegKey& key) throw()
1361     {
1362         Attach(key.Detach());
1363         return *this;
1364     }
1365 
1366 protected:
1367     // get the total size of a multistring
1368     static ULONG _GetMultiStringSize(LPCTSTR pszz)
1369     {
1370         int count = 0;
1371         do
1372         {
1373             int len = _tcslen(pszz);
1374             count += len + 1;
1375             pszz += len + 1;
1376         } while (*pszz != TEXT('\0'));
1377         ++count;
1378         return count * sizeof(TCHAR);
1379     }
1380 
1381     // delete key recursively
1382     static LONG _DoDeleteKeyTree(HKEY hParentKey, LPCTSTR lpszKey)
1383     {
1384         ATLASSERT(hParentKey);
1385         ATLASSERT(lpszKey);
1386 
1387         // open the key
1388         CRegKey key;
1389         LONG ret = key.Open(hParentKey, lpszKey);
1390         if (ret != ERROR_SUCCESS)
1391         {
1392             return ret;     // failure
1393         }
1394 
1395         // get the longest length of subkey names
1396         DWORD NameMax;
1397         ret = ::RegQueryInfoKey(key, NULL, NULL, NULL, NULL, &NameMax, NULL,
1398                                 NULL, NULL, NULL, NULL, NULL);
1399         if (ret != ERROR_SUCCESS)
1400         {
1401             return ret;     // failure
1402         }
1403         ++NameMax;  // for NUL
1404 
1405         // allocate the string buffer for names if necessary
1406         TCHAR szNameBuf[MAX_PATH], *pszName;
1407         if (NameMax > MAX_PATH)
1408         {
1409             pszName = (TCHAR *)malloc(NameMax * sizeof(TCHAR));
1410             ATLASSERT(pszName);
1411             if (pszName == NULL)
1412             {
1413                 return ERROR_OUTOFMEMORY;   // failure
1414             }
1415         }
1416         else
1417         {
1418             NameMax = MAX_PATH;
1419             pszName = szNameBuf;
1420         }
1421 
1422         // enumerate every subkey and delete
1423         for (;;)
1424         {
1425             DWORD Count = NameMax;
1426             ret = key.EnumKey(0, pszName, &Count);
1427             if (ret != ERROR_SUCCESS)
1428             {
1429                 if (ret == ERROR_NO_MORE_ITEMS)
1430                     ret = ERROR_SUCCESS;
1431                 break;
1432             }
1433 
1434             ret = CRegKey::_DoDeleteKeyTree(key, pszName);
1435             if (ret != ERROR_SUCCESS)
1436                 break;
1437         }
1438 
1439         // close key
1440         key.Close();
1441 
1442         // delete the subkey
1443         if (ret == ERROR_SUCCESS)
1444             ret = ::RegDeleteKey(hParentKey, lpszKey);
1445 
1446         // delete the buffer if any
1447         if (pszName != szNameBuf)
1448             free(pszName);
1449 
1450         return ret;
1451     }
1452 };
1453 
1454 template<class T>
1455 class CComHeapPtr : public CHeapPtr<T, CComAllocator>
1456 {
1457 public:
1458     CComHeapPtr()
1459     {
1460     }
1461 
1462     explicit CComHeapPtr(T *lp) :
1463         CHeapPtr<T, CComAllocator>(lp)
1464     {
1465     }
1466 };
1467 
1468 
1469 inline HRESULT __stdcall AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID &iid, LPDWORD pdw)
1470 {
1471     CComPtr<IConnectionPointContainer>        container;
1472     CComPtr<IConnectionPoint>                connectionPoint;
1473     HRESULT                                    hResult;
1474 
1475     if (pUnkCP == NULL)
1476         return E_INVALIDARG;
1477     hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
1478     if (FAILED(hResult))
1479         return hResult;
1480     hResult = container->FindConnectionPoint(iid, &connectionPoint);
1481     if (FAILED(hResult))
1482         return hResult;
1483     return connectionPoint->Advise(pUnk, pdw);
1484 }
1485 
1486 inline HRESULT __stdcall AtlUnadvise(IUnknown *pUnkCP, const IID &iid, DWORD dw)
1487 {
1488     CComPtr<IConnectionPointContainer>        container;
1489     CComPtr<IConnectionPoint>                connectionPoint;
1490     HRESULT                                    hResult;
1491 
1492     if (pUnkCP == NULL)
1493         return E_INVALIDARG;
1494     hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
1495     if (FAILED(hResult))
1496         return hResult;
1497     hResult = container->FindConnectionPoint(iid, &connectionPoint);
1498     if (FAILED(hResult))
1499         return hResult;
1500     return connectionPoint->Unadvise(dw);
1501 }
1502 
1503 inline HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
1504 {
1505     int i;
1506     IUnknown *resultInterface;
1507     HRESULT hResult;
1508 
1509     ATLASSERT(pThis != NULL && pEntries != NULL);
1510     if (pThis == NULL || pEntries == NULL)
1511         return E_INVALIDARG;
1512     ATLASSERT(ppvObject != NULL);
1513     if (ppvObject == NULL)
1514         return E_POINTER;
1515 
1516     if (InlineIsEqualUnknown(iid))
1517     {
1518         resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw);
1519         *ppvObject = resultInterface;
1520         resultInterface->AddRef();
1521         return S_OK;
1522     }
1523 
1524     i = 0;
1525     while (pEntries[i].pFunc != 0)
1526     {
1527         if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid))
1528         {
1529             if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1))
1530             {
1531                 ATLASSERT(pEntries[i].piid != NULL);
1532                 resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw);
1533                 *ppvObject = resultInterface;
1534                 resultInterface->AddRef();
1535                 return S_OK;
1536             }
1537             else
1538             {
1539                 hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0);
1540                 if (hResult == S_OK)
1541                     return hResult;
1542                 if (FAILED(hResult) && pEntries[i].piid != NULL)
1543                     break;
1544             }
1545         }
1546         i++;
1547     }
1548     *ppvObject = NULL;
1549     return E_NOINTERFACE;
1550 }
1551 
1552 inline HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule)
1553 {
1554     if (pWinModule == NULL)
1555         return E_INVALIDARG;
1556     pWinModule->m_pCreateWndList = NULL;
1557     return pWinModule->m_csWindowCreate.Init();
1558 }
1559 
1560 inline HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst)
1561 {
1562     if (pWinModule == NULL)
1563         return E_INVALIDARG;
1564     pWinModule->m_csWindowCreate.Term();
1565     return S_OK;
1566 }
1567 
1568 inline void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject)
1569 {
1570     CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
1571 
1572     ATLASSERT(pWinModule != NULL);
1573     ATLASSERT(pObject != NULL);
1574 
1575     pData->m_pThis = pObject;
1576     pData->m_dwThreadID = ::GetCurrentThreadId();
1577     pData->m_pNext = pWinModule->m_pCreateWndList;
1578     pWinModule->m_pCreateWndList = pData;
1579 }
1580 
1581 inline void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule)
1582 {
1583     CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
1584     void *result;
1585     _AtlCreateWndData *currentEntry;
1586     _AtlCreateWndData **previousLink;
1587     DWORD threadID;
1588 
1589     ATLASSERT(pWinModule != NULL);
1590 
1591     result = NULL;
1592     threadID = GetCurrentThreadId();
1593     currentEntry = pWinModule->m_pCreateWndList;
1594     previousLink = &pWinModule->m_pCreateWndList;
1595     while (currentEntry != NULL)
1596     {
1597         if (currentEntry->m_dwThreadID == threadID)
1598         {
1599             *previousLink = currentEntry->m_pNext;
1600             result = currentEntry->m_pThis;
1601             break;
1602         }
1603         previousLink = &currentEntry->m_pNext;
1604         currentEntry = currentEntry->m_pNext;
1605     }
1606     return result;
1607 }
1608 
1609 // Adapted from dll/win32/atl/atl.c
1610 inline HRESULT WINAPI AtlLoadTypeLib(HINSTANCE inst, LPCOLESTR lpszIndex,
1611         BSTR *pbstrPath, ITypeLib **ppTypeLib)
1612 {
1613     size_t index_len = lpszIndex ? wcslen(lpszIndex) : 0;
1614     CComHeapPtr<WCHAR> path;
1615     path.Allocate(MAX_PATH + index_len + wcslen(L".tlb"));
1616 
1617     if (!path)
1618         return E_OUTOFMEMORY;
1619 
1620     size_t path_len = GetModuleFileNameW(inst, path, MAX_PATH);
1621     if (!path_len)
1622         return HRESULT_FROM_WIN32(GetLastError());
1623 
1624     if (index_len)
1625         wcscat(path, lpszIndex);
1626 
1627     CComPtr<ITypeLib> typelib;
1628     HRESULT hResult = LoadTypeLib(path, &typelib);
1629     if (FAILED(hResult))
1630     {
1631         WCHAR *ptr;
1632         for (ptr = path+path_len-1; ptr > path && *ptr != '\\' && *ptr != '.'; ptr--)
1633             ;
1634         if (*ptr != '.')
1635             ptr = (WCHAR*)path + path_len;
1636         wcscpy(ptr, L".tlb");
1637 
1638         hResult = LoadTypeLib(path, &typelib);
1639     }
1640 
1641     if (SUCCEEDED(hResult))
1642     {
1643         *pbstrPath = SysAllocString(path);
1644         if (!*pbstrPath)
1645         {
1646             typelib.Release();
1647             hResult = E_OUTOFMEMORY;
1648         }
1649     }
1650 
1651     if (FAILED(hResult))
1652         return hResult;
1653 
1654     *ppTypeLib = typelib.Detach();
1655     return S_OK;
1656 }
1657 
1658 // Adapted from dll/win32/atl/atl.c
1659 inline HRESULT WINAPI AtlRegisterTypeLib(HINSTANCE inst, const WCHAR *index)
1660 {
1661     CComBSTR path;
1662     CComPtr<ITypeLib> typelib;
1663     HRESULT hResult = AtlLoadTypeLib(inst, index, &path, &typelib);
1664     if (FAILED(hResult))
1665         return hResult;
1666 
1667     return RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
1668 }
1669 
1670 // Adapted from dll/win32/atl/atl.c
1671 inline HRESULT WINAPI AtlRegisterClassCategoriesHelper(REFCLSID clsid, const _ATL_CATMAP_ENTRY *catmap, BOOL reg)
1672 {
1673     if (!catmap)
1674         return S_OK;
1675 
1676     CComPtr<ICatRegister> catreg;
1677 
1678     HRESULT hResult = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER, IID_ICatRegister, (void**)&catreg);
1679     if (FAILED(hResult))
1680         return hResult;
1681 
1682     for (const _ATL_CATMAP_ENTRY *iter = catmap; iter->iType != _ATL_CATMAP_ENTRY_END; iter++)
1683     {
1684         CATID catid = *iter->pcatid;
1685 
1686         if (iter->iType == _ATL_CATMAP_ENTRY_IMPLEMENTED)
1687         {
1688             if (reg)
1689                 hResult = catreg->RegisterClassImplCategories(clsid, 1, &catid);
1690             else
1691                 hResult = catreg->UnRegisterClassImplCategories(clsid, 1, &catid);
1692         }
1693         else
1694         {
1695             if (reg)
1696                 hResult = catreg->RegisterClassReqCategories(clsid, 1, &catid);
1697             else
1698                 hResult = catreg->UnRegisterClassReqCategories(clsid, 1, &catid);
1699         }
1700         if (FAILED(hResult))
1701             return hResult;
1702     }
1703 
1704     if (!reg)
1705     {
1706         WCHAR reg_path[256] = L"CLSID\\";
1707 
1708         StringFromGUID2(clsid, reg_path + wcslen(reg_path), 64);
1709         wcscat(reg_path, L"\\");
1710         WCHAR* ptr = reg_path + wcslen(reg_path);
1711 
1712         wcscpy(ptr, L"Implemented Categories");
1713         RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
1714 
1715         wcscpy(ptr, L"Required Categories");
1716         RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
1717     }
1718 
1719     return hResult;
1720 }
1721 
1722 
1723 // Adapted from dll/win32/atl80/atl80.c
1724 inline HRESULT __stdcall AtlComModuleRegisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid)
1725 {
1726     HRESULT hResult = S_OK;
1727 
1728     for (_ATL_OBJMAP_ENTRY ** iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++)
1729     {
1730         if (!*iter)
1731             continue;
1732         _ATL_OBJMAP_ENTRY* entry = *iter;
1733         if (clsid && !IsEqualCLSID(*entry->pclsid, *clsid))
1734             continue;
1735 
1736         hResult = entry->pfnUpdateRegistry(TRUE);
1737         if (FAILED(hResult))
1738             return hResult;
1739 
1740         const _ATL_CATMAP_ENTRY *catmap = entry->pfnGetCategoryMap();
1741         if (catmap)
1742         {
1743             hResult = AtlRegisterClassCategoriesHelper(*entry->pclsid, catmap, TRUE);
1744             if (FAILED(hResult))
1745                 return hResult;
1746         }
1747     }
1748 
1749     if (bRegTypeLib)
1750     {
1751         hResult = AtlRegisterTypeLib(mod->m_hInstTypeLib, NULL);
1752     }
1753 
1754     return hResult;
1755 }
1756 
1757 // Adapted from dll/win32/atl/atl.c
1758 inline HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bUnRegTypeLib, const CLSID *clsid)
1759 {
1760     HRESULT hResult = S_OK;
1761 
1762     for (_ATL_OBJMAP_ENTRY **iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++)
1763     {
1764         if (!*iter)
1765             continue;
1766         _ATL_OBJMAP_ENTRY* entry = *iter;
1767         if (clsid && !IsEqualCLSID(*entry->pclsid, *clsid))
1768             continue;
1769 
1770         const _ATL_CATMAP_ENTRY *catmap = entry->pfnGetCategoryMap();
1771         if (catmap)
1772         {
1773             hResult = AtlRegisterClassCategoriesHelper(*entry->pclsid, catmap, FALSE);
1774             if (FAILED(hResult))
1775                 return hResult;
1776         }
1777 
1778         hResult = entry->pfnUpdateRegistry(FALSE);
1779         if (FAILED(hResult))
1780             return hResult;
1781     }
1782 
1783     if (bUnRegTypeLib)
1784     {
1785         CComPtr<ITypeLib> typelib;
1786         TLIBATTR *attr;
1787         CComBSTR path;
1788 
1789         hResult = AtlLoadTypeLib(mod->m_hInstTypeLib, NULL, &path, &typelib);
1790         if (FAILED(hResult))
1791             return hResult;
1792 
1793         hResult = typelib->GetLibAttr(&attr);
1794         if (SUCCEEDED(hResult))
1795         {
1796             hResult = UnRegisterTypeLib(attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, attr->lcid, attr->syskind);
1797             typelib->ReleaseTLibAttr(attr);
1798         }
1799     }
1800 
1801     return hResult;
1802 }
1803 
1804 
1805 // Adapted from dll/win32/atl/atl.c
1806 inline HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags)
1807 {
1808     _ATL_OBJMAP_ENTRY **iter;
1809     IUnknown* unk = NULL;
1810     HRESULT hr;
1811 
1812     if (!module)
1813         return E_INVALIDARG;
1814 
1815     for (iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++)
1816     {
1817         if (!(*iter)->pfnGetClassObject)
1818             continue;
1819 
1820         hr = (*iter)->pfnGetClassObject((void*)(*iter)->pfnCreateInstance, IID_IUnknown, (void**)&unk);
1821         if (FAILED(hr))
1822             return hr;
1823 
1824         hr = CoRegisterClassObject(*(*iter)->pclsid, unk, context, flags, &(*iter)->dwRegister);
1825         unk->Release();
1826         if (FAILED(hr))
1827             return hr;
1828     }
1829 
1830     return S_OK;
1831 }
1832 
1833 
1834 // Adapted from dll/win32/atl/atl.c
1835 inline HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module)
1836 {
1837     _ATL_OBJMAP_ENTRY **iter;
1838     HRESULT hr;
1839 
1840     if (!module)
1841         return E_INVALIDARG;
1842 
1843     for (iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++)
1844     {
1845         hr = CoRevokeClassObject((*iter)->dwRegister);
1846         if (FAILED(hr))
1847             return hr;
1848     }
1849 
1850     return S_OK;
1851 }
1852 
1853 
1854 }; // namespace ATL
1855 
1856 #ifndef _ATL_NO_AUTOMATIC_NAMESPACE
1857 using namespace ATL;
1858 #endif //!_ATL_NO_AUTOMATIC_NAMESPACE
1859