You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
624 lines
17 KiB
624 lines
17 KiB
/*****************************************************************************
|
|
*
|
|
* fnd.h - Main private header file
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Coding conventions:
|
|
*
|
|
* + Follow standard shell coding conventions.
|
|
*
|
|
* + Standard K&R brace placement and indentation style.
|
|
*
|
|
* + Indent by 4 spaces.
|
|
*
|
|
* + Fully-brace all dependent clauses. Never write "if (c) foo();"
|
|
*
|
|
* + Do not return in the middle of a function. If forced,
|
|
* use a "goto exit". This way, you can stick entry/exit stuff
|
|
* later without getting caught out. (I learned this rule the
|
|
* hard way.)
|
|
*
|
|
* + Declare variables with narrowest possible scope.
|
|
*
|
|
* + Always test for success, not failure! The compiler will
|
|
* thank you.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* NOTE! This code was written for readability, not efficiency.
|
|
*
|
|
* I'm trusting the compiler to do optimizations like these:
|
|
*
|
|
* "Parameter alias":
|
|
*
|
|
* Function(LPFOO pfoo)
|
|
* {
|
|
* LPBAR pbar = (LPBAR)pfoo;
|
|
* ... use pbar and never mention pfoo again ...
|
|
* }
|
|
*
|
|
* --> becomes
|
|
*
|
|
* Function(LPFOO pfoo)
|
|
* {
|
|
* #define pbar ((LPBAR)pfoo)
|
|
* ... use pbar and never mention pfoo again ...
|
|
* #undef pbar
|
|
* }
|
|
*
|
|
* "Speculative Execution":
|
|
*
|
|
* Function(PFOO pfoo)
|
|
* {
|
|
* BOOL fRc;
|
|
* if (... condition 1 ...) {
|
|
* ... complicated stuff ...
|
|
* *pfoo = result;
|
|
* fRc = 1;
|
|
* } else { // condition 1 failed
|
|
* *pfoo = 0;
|
|
* fRc = 0;
|
|
* }
|
|
* return fRc;
|
|
* }
|
|
*
|
|
* --> becomes
|
|
*
|
|
* Function(PFOO pfoo)
|
|
* {
|
|
* BOOL fRc = 0;
|
|
* *pfoo = 0;
|
|
* if (... condition 1 ...) {
|
|
* ... complicated stuff ...
|
|
* *pfoo = result;
|
|
* fRc = 1;
|
|
* }
|
|
* return fRc;
|
|
* }
|
|
*
|
|
* "Single Exit":
|
|
*
|
|
* Function(...)
|
|
* {
|
|
* BOOL fRc;
|
|
* if (... condition 1 ...) {
|
|
* ...
|
|
* if (... condition 2 ...) {
|
|
* ...
|
|
* fRc = 1;
|
|
* } else { // condition 2 failed
|
|
* ... clean up ...
|
|
* fRc = 0;
|
|
* }
|
|
* } else { // condition 1 failed
|
|
* ... clean up ...
|
|
* fRc = 0;
|
|
* }
|
|
* return fRc;
|
|
* }
|
|
*
|
|
* --> becomes
|
|
*
|
|
* Function(...)
|
|
* {
|
|
* if (... condition 1 ...) {
|
|
* ...
|
|
* if (... condition 2 ...) {
|
|
* ...
|
|
* return 1;
|
|
* } else { // condition 2 failed
|
|
* ... clean up ...
|
|
* return 0;
|
|
* }
|
|
* } else { // condition 1 failed
|
|
* ... clean up ...
|
|
* return 0;
|
|
* }
|
|
* NOTREACHED;
|
|
* }
|
|
*
|
|
*
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#define NOIME
|
|
#define NOSERVICE
|
|
#define _WIN32_WINDOWS 0x0400
|
|
#include <windows.h>
|
|
|
|
#ifdef RC_INVOKED /* Define some tags to speed up rc.exe */
|
|
#define __RPCNDR_H__ /* Don't need RPC network data representation */
|
|
#define __RPC_H__ /* Don't need RPC */
|
|
#include <oleidl.h> /* Get the DROPEFFECT stuff */
|
|
#define _OLE2_H_ /* But none of the rest */
|
|
#define _WINDEF_
|
|
#define _WINBASE_
|
|
#define _WINGDI_
|
|
#define NONLS
|
|
#define _WINCON_
|
|
#define _WINREG_
|
|
#define _WINNETWK_
|
|
#define _INC_COMMCTRL
|
|
#define _INC_SHELLAPI
|
|
#else
|
|
#include <windowsx.h>
|
|
#endif
|
|
|
|
|
|
#include <shlobj.h>
|
|
#include <shellapi.h>
|
|
#include <objbase.h>
|
|
#include "resrc2.h"
|
|
|
|
#define _IOffset(class, itf) ((UINT_PTR)&(((class *)0)->itf))
|
|
#define IToClass(class, itf, pitf) ((class *)(((LPSTR)pitf)-_IOffset(class, itf)))
|
|
|
|
#ifndef RC_INVOKED
|
|
|
|
#ifdef _WIN64
|
|
#pragma pack(push,8)
|
|
#endif // _WIN64
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Stuff I'm tired of typing over and over.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef LPITEMIDLIST PIDL, *PPIDL;
|
|
typedef LPCITEMIDLIST PCIDL;
|
|
typedef LPSHELLFOLDER PSF;
|
|
typedef LPVOID PV;
|
|
typedef LPVOID *PPV;
|
|
typedef LPCVOID PCV;
|
|
typedef REFIID RIID;
|
|
typedef LPUNKNOWN PUNK;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Baggage - Stuff I carry everywhere
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define INTERNAL NTAPI /* Called only within a translation unit */
|
|
#define EXTERNAL NTAPI /* Called from other translation units */
|
|
#define INLINE static __inline
|
|
|
|
#define BEGIN_CONST_DATA data_seg(".text", "CODE")
|
|
#define END_CONST_DATA data_seg(".data", "DATA")
|
|
|
|
#define OBJAT(T, v) (*(T *)(v)) /* Pointer punning */
|
|
#define PUN(T, v) OBJAT(T, &(v)) /* General-purpose type-punning */
|
|
|
|
/*
|
|
* Convert a count of TCHAR's to a count of bytes.
|
|
*/
|
|
#define cbCtch(ctch) ((ctch) * sizeof(TCHAR))
|
|
|
|
/*
|
|
* Convert an object (X) to a count of bytes (cb).
|
|
*/
|
|
|
|
/*
|
|
* Convert an array name (A) to a generic count (c).
|
|
*/
|
|
#define cA(a) (cbX(a)/cbX(a[0]))
|
|
|
|
/*
|
|
* Convert an array name (A) to a pointer to its Max.
|
|
* (I.e., one past the last element.)
|
|
*/
|
|
#define pvMaxA(a) (&a[cA(a)])
|
|
|
|
#ifdef _WIN64
|
|
#define ALIGNTYPE LARGE_INTEGER
|
|
#define ALIGN ((ULONG) (sizeof(ALIGNTYPE) - 1))
|
|
#define LcbAlignLcb(lcb) (((lcb) + ALIGN) & ~ALIGN)
|
|
#endif
|
|
|
|
#ifdef _WIN64
|
|
#define pvSubPvCb(pv, cb) ((PV)((PBYTE)pv - LcbAlignLcb((cb))))
|
|
#define pvAddPvCb(pv, cb) ((PV)((PBYTE)pv + LcbAlignLcb((cb))))
|
|
#define cbSubPvPv(p1, p2) ((PBYTE)(p1) - (PBYTE)(p2))
|
|
#else
|
|
#define pvSubPvCb(pv, cb) ((PV)((PBYTE)pv - (cb)))
|
|
#define pvAddPvCb(pv, cb) ((PV)((PBYTE)pv + (cb)))
|
|
#define cbSubPvPv(p1, p2) ((PBYTE)(p1) - (PBYTE)(p2))
|
|
#endif //WIN64
|
|
/*
|
|
* Round cb up to the nearest multiple of cbAlign. cbAlign must be
|
|
* a power of 2 whose evaluation entails no side-effects.
|
|
*/
|
|
#define ROUNDUP(cb, cbAlign) ((((cb) + (cbAlign) - 1) / (cbAlign)) * (cbAlign))
|
|
|
|
#define cbX(X) sizeof(X)
|
|
|
|
/*
|
|
* lfNeVV
|
|
*
|
|
* Given two values, return zero if they are equal and nonzero if they
|
|
* are different. This is the same as (v1) != (v2), except that the
|
|
* return value on unequal is a random nonzero value instead of 1.
|
|
* (lf = logical flag)
|
|
*
|
|
* lfNePvPv
|
|
*
|
|
* The same as lfNeVV, but for pointers.
|
|
*
|
|
* lfPv
|
|
*
|
|
* Nonzero if pv is not null.
|
|
*
|
|
*/
|
|
#define lfNeVV(v1, v2) ((v1) - (v2))
|
|
#define lfNePvPv(v1, v2) lfNeVV((DWORD)(PV)(v1), (DWORD)(PV)(v2))
|
|
#define lfPv(pv) ((BOOL)(PV)(pv))
|
|
|
|
/*
|
|
* land -- Logical and. Evaluate the first. If the first is zero,
|
|
* then return zero. Otherwise, return the second.
|
|
*/
|
|
|
|
#define fLandFF(f1, f2) ((f1) ? (f2) : 0)
|
|
|
|
/*
|
|
* lor -- Logical or. Evaluate the first. If the first is nonzero,
|
|
* return it. Otherwise, return the second.
|
|
*
|
|
* Unfortunately, due to the C language, this can't
|
|
* be implemented, so we just return 1 if the first is nonzero.
|
|
* GNU has an extension that supports this, which we use. //;Internal
|
|
*/
|
|
|
|
#if defined(__GNUC__) //;Internal
|
|
#define fLorFF(f1, f2) ((f1) ?: (f2)) //;Internal
|
|
#else //;Internal
|
|
#define fLorFF(f1, f2) ((f1) ? 1 : (f2))
|
|
#endif //;Internal
|
|
|
|
/*
|
|
* limp - logical implication. True unless the first is nonzero and
|
|
* the second is zero.
|
|
*/
|
|
#define fLimpFF(f1, f2) (!(f1) || (f2))
|
|
|
|
/*
|
|
* leqv - logical equivalence. True if both are zero or both are nonzero.
|
|
*/
|
|
#define fLeqvFF(f1, f2) (!(f1) == !(f2))
|
|
|
|
/*
|
|
* InOrder - checks that i1 <= i2 < i3.
|
|
*/
|
|
#define fInOrder(i1, i2, i3) ((unsigned)((i2)-(i1)) < (unsigned)((i3)-(i1)))
|
|
|
|
/*
|
|
* memeq - Reverse of memcmp
|
|
*/
|
|
#define memeq !memcmp
|
|
|
|
/*
|
|
* fPvPfnCmpPv - Compare two objects for equality using the comparison
|
|
* function and the desired outcome. E.g.,
|
|
*
|
|
* fPvPfnCmpPv(psz1, lstrcmpi, >, psz2)
|
|
*
|
|
* returns nonzero if psz1 is greater than psz2 according
|
|
* to lstrcmpi.
|
|
*/
|
|
|
|
#define fPvPfnCmpPv(p1, pfn, cmp, p2) (pfn(p1, p2) cmp 0)
|
|
|
|
/*
|
|
* lstreq - nonzero if two strings (according to lstrcmp) are equal
|
|
* lstrne - nonzero if two strings (according to lstrcmp) are different
|
|
*
|
|
* lstrieq - nonzero if two strings (according to lstrcmpi) are equal
|
|
* lstrine - nonzero if two strings (according to lstrcmpi) are different
|
|
*
|
|
* lstrieqA - nonzero if two strings (according to lstrcmpiA) are equal
|
|
* lstrineA - nonzero if two strings (according to lstrcmpiA) are different
|
|
*/
|
|
|
|
#define lstreq !lstrcmp
|
|
#define lstrne lstrcmp
|
|
|
|
#define lstrieq !lstrcmpi
|
|
#define lstrine lstrcmpi
|
|
|
|
#define lstrieqA !lstrcmpiA
|
|
#define lstrineA lstrcmpiA
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Wrappers and other quickies
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define pvExchangePpvPv(ppv, pv) \
|
|
(PV)InterlockedExchangePointer((ppv), (pv))
|
|
|
|
#define hresUs(us) MAKE_HRESULT(SEVERITY_SUCCESS, 0, (USHORT)(us))
|
|
#define hresLe(le) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, (USHORT)(le))
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Static globals: Initialized at PROCESS_ATTACH and never modified.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HINSTANCE g_hinst; /* My resource instance handle */
|
|
HINSTANCE g_hinstApp; /* My instance handle */
|
|
HINSTANCE g_hinstWABDLL; /* My WAB32.DLL instance handle */
|
|
|
|
//DEFINE_GUID(CLSID_Fnd, 0x37865980, 0x75d1, 0x11cf,
|
|
// 0xbf,0xc7,0x44,0x45,0x53,0x54,0,0);
|
|
// {32714800-2E5F-11d0-8B85-00AA0044F941}
|
|
DEFINE_GUID(CLSID_Fnd,
|
|
0x32714800, 0x2e5f, 0x11d0, 0x8b, 0x85, 0x0, 0xaa, 0x0, 0x44, 0xf9, 0x41);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Dynamic Globals. There should be as few of these as possible.
|
|
*
|
|
* All access to dynamic globals must be thread-safe.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
ULONG g_cRef; /* Global reference count */
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* fndcf.c - Class Factory
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CFndFactory_New(RIID riid, PPV ppvObj);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* fndcm.c - IContextMenu, IShellExtInit
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CFndCm_New(RIID riid, PPV ppvObj);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Common object managers.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
typedef struct PREVTBL0 { /* Simple (non-OLE) object */
|
|
void (NTAPI *FinalizeProc)(PV pv); /* Finalization procedure */
|
|
} PREVTBL0, *PPREVTBL0;
|
|
|
|
typedef struct PREVTBL { /* Primary interface */
|
|
REFIID riid; /* Type of this object */
|
|
void (NTAPI *FinalizeProc)(PV pv); /* Finalization procedure */
|
|
} PREVTBL, *PPREVTBL;
|
|
|
|
typedef struct PREVTBL2 { /* Secondary interface */
|
|
ULONG lib; /* offset from start of object */
|
|
} PREVTBL2, *PPREVTBL2;
|
|
|
|
#define Simple_Interface(C) Primary_Interface(C, IUnknown)
|
|
#define Simple_Vtbl(C) Primary_Vtbl(C)
|
|
#define Simple_Interface_Begin(C) \
|
|
struct S_##C##Vtbl c_####C##VI = { { \
|
|
&IID_##IUnknown, \
|
|
C##_Finalize, \
|
|
}, { \
|
|
Common##_QueryInterface, \
|
|
Common##_AddRef, \
|
|
Common##_Release, \
|
|
|
|
#define Simple_Interface_End(C) Primary_Interface_End(C, IUnknown)
|
|
|
|
#define Primary_Interface(C, I) \
|
|
extern struct S_##C##Vtbl { \
|
|
PREVTBL prevtbl; \
|
|
I##Vtbl vtbl; \
|
|
} c_##C##VI \
|
|
|
|
#define Primary_Vtbl(C) &c_##C##VI.vtbl
|
|
|
|
#define Primary_Interface_Begin(C, I) \
|
|
struct S_##C##Vtbl c_####C##VI = { { \
|
|
&IID_##I, \
|
|
C##_Finalize, \
|
|
}, { \
|
|
C##_QueryInterface, \
|
|
C##_AddRef, \
|
|
C##_Release, \
|
|
|
|
#define Primary_Interface_End(C, I) \
|
|
} }; \
|
|
|
|
#define Secondary_Interface(C, I) \
|
|
extern struct S_##I##_##C##Vtbl { \
|
|
PREVTBL2 prevtbl; \
|
|
I##Vtbl vtbl; \
|
|
} c_##I##_##C##VI \
|
|
|
|
#define Secondary_Vtbl(C, I) &c_##I##_##C##VI.vtbl
|
|
|
|
#define Secondary_Interface_Begin(C, I, nm) \
|
|
struct S_##I##_##C##Vtbl c_##I##_##C##VI = { { \
|
|
_IOffset(C, nm), \
|
|
}, { \
|
|
Forward_QueryInterface, \
|
|
Forward_AddRef, \
|
|
Forward_Release, \
|
|
|
|
#define Secondary_Interface_End(C, I, nm) \
|
|
} }; \
|
|
|
|
#ifdef _WIN64
|
|
#pragma pack(pop)
|
|
#endif //_WIN64
|
|
|
|
STDMETHODIMP Common_QueryInterface(PV, REFIID, PPV);
|
|
STDMETHODIMP_(ULONG) _Common_AddRef(PV pv);
|
|
STDMETHODIMP_(ULONG) _Common_Release(PV pv);
|
|
|
|
#define Common_AddRef _Common_AddRef
|
|
#define Common_Release _Common_Release
|
|
|
|
void EXTERNAL Common_Finalize(PV);
|
|
|
|
STDMETHODIMP _Common_New(ULONG cb, PV vtbl, PPV ppvObj);
|
|
#define Common_NewCb(cb, C, ppvObj) _Common_New(cb, Primary_Vtbl(C), ppvObj)
|
|
#define Common_New(C, ppvObj) Common_NewCb(cbX(C), C, ppvObj)
|
|
|
|
STDMETHODIMP Forward_QueryInterface(PV pv, REFIID riid, PPV ppvObj);
|
|
STDMETHODIMP_(ULONG) Forward_AddRef(PV pv);
|
|
STDMETHODIMP_(ULONG) Forward_Release(PV pv);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Common_CopyAddRef
|
|
*
|
|
* Copy a pointer and increment its reference count.
|
|
*
|
|
* Cannot be a macro because Common_AddRef evaluates its argument
|
|
* twice.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
INLINE void Common_CopyAddRef(PV pvDst, PV pvSrc)
|
|
{
|
|
PPV ppvDst = pvDst;
|
|
*ppvDst = pvSrc;
|
|
Common_AddRef(pvSrc);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Invoking OLE methods.
|
|
*
|
|
* Invoke_Release is called with a pointer to the object, not with
|
|
* the object itself. It zeros out the variable on the release.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL Invoke_AddRef(PV pv);
|
|
void EXTERNAL Invoke_Release(PV pv);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* assert.c - Assertion stuff
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef enum {
|
|
sqflAlways = 0x00000000, /* Unconditional */
|
|
sqflDll = 0x00000001, /* Dll bookkeeping */
|
|
sqflFactory = 0x00000002, /* IClassFactory */
|
|
sqflCm = 0x00000004, /* IContextMenu */
|
|
sqflCommon = 0x00000000, /* common.c */
|
|
sqflError = 0x80000000, /* Errors */
|
|
} SQFL; /* squiffle */
|
|
|
|
void EXTERNAL SquirtSqflPtszV(SQFL sqfl, LPCTSTR ptsz, ...);
|
|
int EXTERNAL AssertPtszPtszLn(LPCTSTR ptszExpr, LPCTSTR ptszFile, int iLine);
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Procedure enter/exit tracking.
|
|
*
|
|
* Start a procedure with
|
|
*
|
|
* EnterProc(ProcedureName, (_ "format", arg, arg, arg, ...));
|
|
*
|
|
* The format string is documented in EmitPal.
|
|
*
|
|
* End a procedure with one of the following:
|
|
*
|
|
* ExitProc();
|
|
*
|
|
* Procedure returns no value.
|
|
*
|
|
* ExitProcX();
|
|
*
|
|
* Procedure returns an arbitrary DWORD.
|
|
*
|
|
* ExitOleProc();
|
|
*
|
|
* Procedure returns an HRESULT (named "hres").
|
|
*
|
|
* ExitOleProcPpv(ppvOut);
|
|
*
|
|
* Procedure returns an HRESULT (named "hres") and, on success,
|
|
* puts a new object in ppvOut.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define cpvArgMax 10 /* Max of 10 args per procedure */
|
|
|
|
#ifdef _WIN64
|
|
#pragma pack(push,8)
|
|
#endif // _WIN64
|
|
|
|
typedef struct ARGLIST {
|
|
LPCSTR pszProc;
|
|
LPCSTR pszFormat;
|
|
PV rgpv[cpvArgMax];
|
|
} ARGLIST, *PARGLIST;
|
|
|
|
void EXTERNAL ArgsPalPszV(PARGLIST pal, LPCSTR psz, ...);
|
|
void EXTERNAL EnterSqflPszPal(SQFL sqfl, LPCTSTR psz, PARGLIST pal);
|
|
void EXTERNAL ExitSqflPalHresPpv(SQFL, PARGLIST, HRESULT, PPV);
|
|
|
|
#define AssertFPtsz(c, ptsz)
|
|
#define ValidateF(c) (c)
|
|
#define D(x)
|
|
|
|
#define SetupEnterProc(nm)
|
|
#define DoEnterProc(v)
|
|
#define EnterProc(nm, v)
|
|
#define ExitOleProcPpv(ppv)
|
|
#define ExitOleProc()
|
|
#define ExitProc()
|
|
|
|
|
|
#define AssertF(c) AssertFPtsz(c, TEXT(#c))
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Macros that forward to the common handlers after squirting.
|
|
* Use these only in DEBUG.
|
|
*
|
|
* It is assumed that sqfl has been #define'd to the appropriate sqfl.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* mem.c
|
|
*
|
|
* Be extremely careful with FreePv, because it doesn't work if
|
|
* the pointer is null.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP EXTERNAL ReallocCbPpv(UINT cb, PV ppvObj);
|
|
STDMETHODIMP EXTERNAL AllocCbPpv(UINT cb, PV ppvObj);
|
|
|
|
#define FreePpv(ppv) ReallocCbPpv(0, ppv)
|
|
#define FreePv(pv) LocalFree((HLOCAL)(pv))
|
|
|
|
#ifdef _WIN64
|
|
#pragma pack(pop)
|
|
#endif //_WIN64
|
|
|
|
#endif /* !RC_INVOKED */
|