Leaked source code of windows server 2003
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.
 
 
 
 
 
 

418 lines
13 KiB

// w32extend.h - win32 helpers
// copyright (c) Microsoft Corp. 1998
#pragma once
#ifndef W32EXTEND_H
#define W32EXTEND_H
#include <guiddef.h>
#include <ocidl.h>
#include <urlmon.h>
#if defined(DEBUG) || defined(W32_OBJECT_STREAMING)
#include <atlconv.h>
#endif
using namespace ::ATL;
#include <atltmp.h>
#include <trace.h>
#include <throw.h>
// build a class to override the standard GUID in basetyps.h
// in order to put them into STL containers and dump them to debug
class GUID2 : public GUID {
private:
void init(const LPCOLESTR guid) {
OLECHAR temp[42]; // max guid string size
HRESULT hr = StringCchCopyW(temp, SIZEOF_CH(temp), guid);
if (FAILED(hr)) {
memset(this, 0, sizeof(GUID));
THROWCOM(hr);
}
hr = CLSIDFromString(temp, this);
if (FAILED(hr)) {
memset(this, 0, sizeof(GUID));
THROWCOM(hr);
}
}
public:
inline GUID2() : GUID(GUID_NULL) {}
inline GUID2(const GUID2 &g) : GUID(g) {}
inline GUID2(const struct _GUID &g) : GUID(g) {}
inline GUID2(const struct _GUID *g) : GUID(*g) {}
inline GUID2(const BSTR guid) {
if (!guid || !SysStringLen(guid)) {
memset(this, 0, sizeof(GUID));
} else {
init(guid);
}
}
inline GUID2(const LPCOLESTR guid) {
if (!guid || !ocslen(guid)) {
memset(this, 0, sizeof(GUID));
} else {
init(guid);
}
}
// operators
GUID2 & operator=(const BSTR guid) {
if (!guid || !SysStringLen(guid)) {
memset(this, 0, sizeof(GUID));
} else {
init(guid);
}
return *this;
}
GUID2& operator=(const LPCOLESTR guid) {
if (!guid || !ocslen(guid)) {
memset(this, 0, sizeof(GUID));
} else {
init(guid);
}
}
GUID2 & operator=(const GUID2 &g) {
if (&g != this) {
ASSERT(sizeof(*this) == sizeof(struct _GUID));
memcpy(this, &g, sizeof(GUID2));
}
return *this;
}
GUID2 & operator=(const struct _GUID &g) {
if (&g != this) {
ASSERT(sizeof(*this) == sizeof(g));
memcpy(this, &g, min(sizeof(GUID2), sizeof(GUID)));
}
return *this;
}
BSTR GetBSTR() const {
OLECHAR guidstr[(((sizeof(_GUID) * 2/* bin to char*/) + 1/*str null term*/) * 2/*ansi to unicode*/)];
int rc = StringFromGUID2(*this, guidstr, sizeof(guidstr)/sizeof(OLECHAR));
ASSERT(rc);
return SysAllocString(guidstr);
}
#if defined(DEBUG) || defined(W32_OBJECT_STREAMING)
void inline Dump(tostream &dc) const {
BSTR guidstr(GetBSTR());
USES_CONVERSION;
dc << OLE2T(guidstr);
::SysFreeString(guidstr);
return;
}
#endif
bool inline operator<(const GUID2 &op2) const {
if (memcmp(this, &op2, sizeof(GUID2)) < 0) {
return true;
}
return false;
}
bool inline operator>(const GUID2 &op2) const {
if (memcmp(this, &op2, sizeof(GUID2)) > 0) {
return true;
}
return false;
}
bool inline operator==(const GUID2 &op2) const {
if (!memcmp(this, &op2, sizeof(GUID2))) {
return true;
}
return false;
}
bool inline operator!=(const GUID2 &op2) const {
if (memcmp(this, &op2, sizeof(GUID2))) {
return true;
}
return false;
}
bool inline operator<(const GUID &op2) const {
if (memcmp(this, &op2, sizeof(GUID)) < 0) {
return true;
}
return false;
}
bool inline operator>(const GUID &op2) const {
if (memcmp(this, &op2, sizeof(GUID)) > 0) {
return true;
}
return false;
}
bool inline operator==(const GUID &op2) const {
if (!memcmp(this, &op2, sizeof(GUID))) {
return true;
}
return false;
}
bool inline operator!=(const GUID &op2) const {
if (memcmp(this, &op2, sizeof(GUID))) {
return true;
}
return false;
}
};
typedef CComPtr<IUnknown> PUnknown;
#if defined(DEBUG) || defined(W32_OBJECT_STREAMING)
inline tostream &operator<<(tostream &dc, const GUID2 &g)
{
g.Dump(dc);
return dc;
}
inline tostream &operator<<(tostream &dc, const GUID &g)
{
GUID2 g2(g);
g2.Dump(dc);
return dc;
}
inline tostream &operator<<(tostream &dc, const RECT& r)
{
dc << "T(" << r.top <<
") L(" << r.left <<
") B(" << r.bottom <<
") R(" << r.right <<
") W(" << (r.right - r.left) <<
") H(" << (r.bottom - r.top) << ")";
return dc;
}
inline tostream &operator<<(tostream &dc, const SIZE& s)
{
dc << "X(" << s.cx << ") Y(" << s.cy << ")";
return dc;
}
#if 0
inline tostream &operator<<(tostream &dc, ULONGLONG &ul) {
TCHAR buf[128];
_stprintf(buf, "%I64X", ul);
dc << buf;
return dc;
}
#endif
inline tostream &operator<<(tostream &dc, const VARIANT &v)
{
USES_CONVERSION;
switch (v.vt) {
case VT_UI4:
dc << _T("VT_UI4: ") << v.ulVal;
break;
case VT_UI8: {
dc << _T("VT_UI8: ");
TCHAR buf[128];
_ui64tot(v.ullVal, buf, 16);
dc << buf;
} break;
case VT_BSTR:
dc << _T("VT_BSTR: ") << OLE2T(v.bstrVal);
break;
case VT_UNKNOWN:
dc << _T("VT_UNKNOWN: ") << v.punkVal;
break;
case VT_DISPATCH:
dc << _T("VT_DISPATCH: ") << v.pdispVal;
break;
case VT_UI1 | VT_ARRAY:
dc << _T("VT_UI1 | VT_ARRAY: blob");
break;
default:
dc << std::endl << "cant dump variant. vt = " << (int)v.vt << std::endl;
}
return dc;
}
#endif
inline bool operator!(const VARIANT &v) {
return v.vt == VT_EMPTY || v.vt == VT_NULL;
}
// provide an operator form and work around the fact that VarCmp
// only supports unsigned ints of size 1
inline bool operator==(const VARIANT &lhs, const VARIANT &rhs) {
HRESULT hrc = VarCmp(const_cast<VARIANT*>(&lhs),
const_cast<VARIANT*>(&rhs),
LOCALE_USER_DEFAULT,
0);
if (hrc == DISP_E_BADVARTYPE) {
// check for types VarCmp doesn't support that we need to support
// coerce unsigned to next largest signed if possible and then
// fall back to VarCmp for lowest risk way to get most identical
// behavior
// for UI8 which is max compiler supports we'll do the compare
// ourselves using the compiler support
switch (lhs.vt) {
case VT_UI2: {
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&lhs), LOCALE_USER_DEFAULT, 0, VT_I4);
if (SUCCEEDED(hrc)) {
return operator==(v, rhs);
}
} break;
case VT_UI4: {
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&lhs), LOCALE_USER_DEFAULT, 0, VT_I8);
if (SUCCEEDED(hrc)) {
return operator==(v, rhs);
}
} break;
case VT_UI8: {
if (rhs.vt == VT_UI8) {
return lhs.ullVal == rhs.ullVal;
}
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&rhs), LOCALE_USER_DEFAULT, 0, VT_UI8);
if (SUCCEEDED(hrc)) {
return operator==(lhs, v);
}
} break;
default: {
// the problem is either lhs of some type we can't help with
// or its the rhs. so we'll check the rhs...
switch(rhs.vt) {
case VT_UI2: {
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&rhs), LOCALE_USER_DEFAULT, 0, VT_I4);
if (SUCCEEDED(hrc)) {
return operator==(lhs, v);
}
} break;
case VT_UI4: {
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&rhs), LOCALE_USER_DEFAULT, 0, VT_I8);
if (SUCCEEDED(hrc)) {
return operator==(lhs, v);
}
} break;
case VT_UI8: {
if (lhs.vt == VT_UI8) {
return lhs.ullVal == rhs.ullVal;
}
VARIANT v;
VariantInit(&v);
hrc = VariantChangeTypeEx(&v, const_cast<VARIANT *>(&lhs), LOCALE_USER_DEFAULT, 0, VT_UI8);
if (SUCCEEDED(hrc)) {
return operator==(v, rhs);
}
}}; //switch rhs
// must be some other bad type we can't help with
}}; //switch lhs
}
return (hrc == VARCMP_EQ);
}
inline bool operator!=(const VARIANT &lhs, const VARIANT &rhs) {
return !operator==(lhs, rhs);
}
typedef CComQIPtr<IEnumVARIANT, &IID_IEnumVARIANT> PQEnumVARIANT;
typedef CComPtr<IUnknown> PUnknown;
typedef CComQIPtr<IPersist> PQPersist;
typedef CComQIPtr<IPropertyBag, &IID_IPropertyBag> PQPropertyBag;
typedef CComQIPtr<IPropertyBag2> PQPropertyBag2;
typedef CComQIPtr<IPersistPropertyBag> PQPersistPropertyBag;
typedef CComQIPtr<IPersistPropertyBag2> PQPersistPropertyBag2;
typedef CComQIPtr<IMoniker, &IID_IMoniker> PQMoniker;
typedef CComQIPtr<IBindCtx> PQBindCtx;
typedef CComQIPtr<IServiceProvider> PQServiceProvider;
typedef CComQIPtr<IGlobalInterfaceTable> PQGIT;
typedef CComQIPtr<IRunningObjectTable> PQROT;
typedef CComQIPtr<IOleWindow> PQOleWindow;
typedef CComQIPtr<IMalloc> PQMalloc;
typedef CComQIPtr<IObjectWithSite> PQObjectWithSite;
typedef CComQIPtr<IConnectionPoint> PQConnectionPoint;
typedef CComQIPtr<IInternetHostSecurityManager> PQSecurityManager;
class W32Moniker : public PQMoniker {
public:
inline W32Moniker() {}
inline W32Moniker(const PQMoniker &a) : PQMoniker(a) {}
inline W32Moniker(IMoniker *p) : PQMoniker(p) {}
inline W32Moniker(IUnknown *p) : PQMoniker(p) {}
inline W32Moniker(const W32Moniker &a) : PQMoniker(a) {}
PQPropertyBag GetPropertyBag() const {
PQPropertyBag pPropBag;
HRESULT hr = (*this)->BindToStorage(0, 0, IID_IPropertyBag, reinterpret_cast<LPVOID *>(&pPropBag));
if (FAILED(hr)) {
TRACELSM(TRACE_ERROR, (dbgDump << "W32Moniker::GetPropertyBag() can't bind to storage hr = " << hr), "");
THROWCOM(hr);
}
return pPropBag;
}
PUnknown GetObject() const {
PUnknown pObj;
HRESULT hr = (*this)->BindToObject(0, 0, __uuidof(IUnknown), reinterpret_cast<LPVOID *>(&pObj));
if (FAILED(hr)) {
TRACELSM(TRACE_ERROR, (dbgDump << "W32Moniker::GetObject() can't bind to object. hr = " << hr), "");
THROWCOM(hr);
}
return pObj;
}
CString DisplayName() const {
LPOLESTR lpszName;
HRESULT hr = (*this)->GetDisplayName(NULL, NULL, &lpszName);
if (FAILED(hr)) {
return CString();
}
CString rc(lpszName);
CoTaskMemFree(lpszName);
return rc;
}
};
inline HRESULT IsSafeZone(DWORD dwZone) {
switch (dwZone) {
case URLZONE_LOCAL_MACHINE:
case URLZONE_INTRANET:
case URLZONE_TRUSTED:
// the fixed list of zones we trust
return NOERROR;
default:
// everything else is untrusted
return E_FAIL;
}
}
inline HRESULT IsSafeSite(IUnknown* pSite) {
PQServiceProvider psp(pSite);
if (!psp) {
// no service provider interface on the site implies that we're not running in IE
// so by defn running local and trusted thus we return OK
return NOERROR;
}
PQSecurityManager pManager;
HRESULT hr = psp->QueryService(SID_SInternetHostSecurityManager, IID_IInternetHostSecurityManager, (LPVOID *)&pManager);
if (FAILED(hr)) {
// no security manager interface on the site's service provider implies that we're not
// running in IE, so by defn running local and trusted thus we return OK
return NOERROR;
}
const int MAXZONE = MAX_SIZE_SECURITY_ID+6/*scheme*/+4/*zone(dword)*/+1/*wildcard*/+1/*trailing null*/;
char pbSecurityId[MAXZONE];
DWORD pcbSecurityId = sizeof(pbSecurityId);
ZeroMemory(pbSecurityId, sizeof(pbSecurityId));
hr = pManager->GetSecurityId(reinterpret_cast<BYTE*>(pbSecurityId), &pcbSecurityId, NULL);
if(FAILED(hr)){
// security manager not working(unexpected). but, the site tried to provide one. thus we
// must assume untrusted content and fail
return E_FAIL;
}
char *pbEnd = pbSecurityId + pcbSecurityId - 1;
if (*pbEnd == '*') { //ignore the optional wildcard flag
pbEnd--;
}
pbEnd -= 3; // point to beginning of little endian zone dword
DWORD dwZone = *(reinterpret_cast<long *>(pbEnd));
return IsSafeZone(dwZone);
}
typedef CComQIPtr<IDispatch, &IID_IDispatch> PQDispatch;
#endif // w32extend.h