Add contribution of 20-40. git-svn-id: svn+ssh://svn.code.sf.net/p/mingw-w64/code/trunk@190 4407c894-4637-0410-b4f5-ada5f102cad1
diff --git a/mingw-w64-headers/include/ChangeLog b/mingw-w64-headers/include/ChangeLog index 4f671aa..4cd0953 100755 --- a/mingw-w64-headers/include/ChangeLog +++ b/mingw-w64-headers/include/ChangeLog
@@ -1,3 +1,34 @@ +2007-11-07 20-40 <annonymous> + + * _dbdao.h: New. + * ieeefp.h: New. + * io.h: (_getcwd): Prototype added. + * mspab.h: New. + * mspaddr.h: New. + * mspbase.h: New. + * mspcall.h: New. + * mspcoll.h: New. + * mspenum.h: New. + * msplog.h: New. + * mspst.h: New. + * mspstrm.h: New. + * mspterm.h: New. + * mspthrd.h: New. + * msptrmac.h: New. + * msptrmar.h: New. + * msptrmvc.h: New. + * msputils.h: New. + * ws2tcpip.h: (ip_mreq): Disabled. Forced that winsock2.h is included infront. + * wmiatlprov.h: New. + * winsock2.h: Add AF_??? constants. + * wchar.h: Add protypes for swprintf and vswprintf. + * tchar.h: Likewise. + * stdio.h: Likewise. + * w32api.h: New. + * nl_types.h: New. + * langinfo.h: New. + + 2007-10-29 Kai Tietz <kai.tietz@onevision.com> * assert.h:
diff --git a/mingw-w64-headers/include/_dbdao.h b/mingw-w64-headers/include/_dbdao.h new file mode 100755 index 0000000..9512cbc --- /dev/null +++ b/mingw-w64-headers/include/_dbdao.h
@@ -0,0 +1,347 @@ +#ifndef __DBDAO_H_ +#define __DBDAO_H_ + +class COleVariant; +class CdbBookmark; +class CdbException; +class CdbOleObject; +class CdbObject; +class CdbError; +class CdbProperty; +class CdbDBEngine; +class CdbWorkspace; +class CdbDatabase; +class CdbConnection; +class CdbRecordset; +class CdbGetRowsEx; +class CdbQueryDef; +class CdbTableDef; +class CdbField; +class CdbRelation; +class CdbIndex; +class CdbUser; +class CdbGroup; +class CdbDocument; +class CdbContainer; +class CdbParameter; +class CdbCollection; +class CdbErrors; +class CdbProperties; +class CdbWorkspaces; +class CdbDatabases; +class CdbConnections; +class CdbRecordsets; +class CdbQueryDefs; +class CdbTableDefs; +class CdbFields; +class CdbRelations; +class CdbIndexes; +class CdbUsers; +class CdbGroups; +class CdbDocuments; +class CdbContainers; +class CdbParameters; +class CdbBStr; + +const char szKEY[] = "mbmabptebkjcdlgtjmskjwtsdhjbmkmwtrak"; + +#define DAO_MAXSEEKFIELDS 13 + +class DLLEXPORT CdbBSTR { +public: + CONSTRUCTOR CdbBSTR(BSTR=NULL); + DESTRUCTOR ~CdbBSTR(VOID); + operator BSTR *(VOID); + operator LPCTSTR(VOID); +private: + BSTR m_bstr; +}; + +class CdbVariant : public COleVariant { +public: + CONSTRUCTOR CdbVariant(LONG l); + CONSTRUCTOR CdbVariant(VOID); + CONSTRUCTOR CdbVariant(LPCTSTR pstr); + CONSTRUCTOR CdbVariant(SHORT s,WINBOOL bIsBool = FALSE); + CONSTRUCTOR CdbVariant(LPVARIANT pv); + CONSTRUCTOR CdbVariant(LPSAFEARRAY psa); + VOID operator =(LPVARIANT pv); + VOID operator =(LPCTSTR pstr); + VOID operator =(SHORT s); + VOID operator =(const int i); + VOID operator =(LONG l); +}; + +inline CONSTRUCTOR CdbVariant::CdbVariant(VOID) : COleVariant() { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; +} + +inline CdbVariant::CdbVariant(LONG l) { + if(l==-1) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { + vt = VT_I4; + lVal = l; + } +} + +inline CONSTRUCTOR CdbVariant::CdbVariant(LPCTSTR pstr): COleVariant(pstr,VT_BSTRT) { + if(!pstr) { + VariantClear(this); + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } +} + +inline CONSTRUCTOR CdbVariant::CdbVariant(SHORT s,WINBOOL bIsBool) : COleVariant(s) { + if(bIsBool) { + vt = VT_BOOL; + boolVal = s; + } else if(s==-1) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } +} + +inline CONSTRUCTOR CdbVariant::CdbVariant(LPVARIANT pv) { + if(!pv) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else + VariantCopy(this,pv); +} + +inline CONSTRUCTOR CdbVariant::CdbVariant(LPSAFEARRAY psa) { + if(!psa) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { + vt = VT_ARRAY|VT_UI1; + parray = psa; + } +} + +inline VOID CdbVariant::operator =(LPVARIANT pv) { + if(!pv) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else + VariantCopy(this,pv); +} + +inline VOID CdbVariant::operator =(LPCTSTR pstr) { + if(!pstr) { + VariantClear(this); + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { +#ifdef UNICODE + bstrVal = SysAllocString(pstr); +#else + bstrVal = SysAllocStringByteLen(pstr,strlen(pstr)); +#endif + vt = VT_BSTR; + } +} + +inline VOID CdbVariant::operator =(SHORT s) { + if(s==-1) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { + vt = VT_I2; + iVal = s; + } +} + +inline VOID CdbVariant::operator =(const int i) { + if(i==-1) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { + vt = VT_I2; + iVal =(SHORT)i; + } +} + +inline VOID CdbVariant::operator =(LONG l) { + if(l==-1) { + vt = VT_ERROR; + scode = DISP_E_PARAMNOTFOUND; + } else { + vt = VT_I4; + lVal = l; + } +} + +HRESULT CdbWideFromAnsi(LPSTR,unsigned int,BSTR *); + +class CdbWide { +public: + CONSTRUCTOR CdbWide(LPSTR pstr,unsigned int cb=0) { + CdbWideFromAnsi(pstr,(pstr ? (cb==0 ? strlen(pstr) : cb) : 0),&m_bstr); + } + DESTRUCTOR ~CdbWide() { + SysFreeString(m_bstr); + } + operator LPWSTR() { return (LPWSTR)m_bstr; } + operator LPSTR() { return (LPSTR)m_bstr; } + ULONG cBytes() { return SysStringByteLen(m_bstr); } +private: + BSTR m_bstr; +}; + +class DLLEXPORT CdbOleObject : public CObject { +public: + CONSTRUCTOR CdbOleObject(VOID); + virtual DESTRUCTOR ~CdbOleObject(VOID); + WINBOOL Exists(VOID); + CdbOleObject &operator = (CdbOleObject &o); + operator LPUNKNOWN(){ return GetInterface();} + VOID SetInterface(LPUNKNOWN punk,WINBOOL bAddRef=FALSE); + VOID SetInterface(REFIID riidClass,REFIID riidInterface); + VOID SetInterfaceLic(REFIID riidClass,REFIID riidInterface); + LPUNKNOWN GetInterface(WINBOOL bAddRef=FALSE,WINBOOL bThrowException=TRUE) const; + virtual VOID OnInterfaceChange(VOID); + VOID SetRichErrorInfo(LPOLESTR pstrSource,LPOLESTR pstrDescription,LPOLESTR pstrHelpFile,ULONG ulHelpID) const; +protected: + WINBOOL StartOLE(VOID); + LPUNKNOWN m_punkInterface; +}; + +class DLLEXPORT CdbCollection : public CdbOleObject { +public: + virtual CdbObject ObItem(LONG i) = 0; + virtual CdbObject ObItem(LPCTSTR pstr) = 0; + virtual LONG GetCount(VOID) = 0; + virtual VOID ObAppend(CdbObject &obj) = 0; + virtual VOID Delete(LPCTSTR pstr) = 0; + virtual VOID Refresh(VOID) = 0; +}; + +class DLLEXPORT CdbStaticCollection : public CdbCollection { +public: + CdbObject ObItem(LONG i); + CdbObject ObItem(LPCTSTR pstr); + LONG GetCount(VOID); + VOID ObAppend(CdbObject &obj); + VOID Delete(LPCTSTR pstr); + VOID Refresh(VOID); +}; + +class DLLEXPORT CdbDynamicCollection : public CdbCollection { +public: + CdbObject ObItem(LONG i); + CdbObject ObItem(LPCTSTR pstr); + LONG GetCount(VOID); + VOID ObAppend(CdbObject &obj); + VOID Delete(LPCTSTR pstr); + VOID Refresh(VOID); +}; + +#define DAOMFC_STATIC_COLLECTION_DECL(objColl,objSingle,intSingle) class DLLEXPORT objColl : public CdbStaticCollection { public: objSingle Item(LONG i); objSingle Item(LPCTSTR pstr); objSingle operator[](LONG i); objSingle operator[](LPCTSTR pstr); } +#define DAOMFC_DYNAMIC_COLLECTION_DECL(objColl,objSingle,intSingle) class DLLEXPORT objColl : public CdbDynamicCollection { public: objSingle Item(LONG i); objSingle Item(LPCTSTR pstr); VOID Append(objSingle &o); objSingle operator[](LONG i); objSingle operator[](LPCTSTR pstr); } + +DAOMFC_STATIC_COLLECTION_DECL(CdbErrors,CdbError,DAOError); +DAOMFC_STATIC_COLLECTION_DECL(CdbDatabases,CdbDatabase,DAODatabase); +DAOMFC_STATIC_COLLECTION_DECL(CdbRecordsets,CdbRecordset,DAORecordset); +DAOMFC_STATIC_COLLECTION_DECL(CdbParameters,CdbParameter,DAOParameter); +DAOMFC_STATIC_COLLECTION_DECL(CdbDocuments,CdbDocument,DAODocument); +DAOMFC_STATIC_COLLECTION_DECL(CdbContainers,CdbContainer,DAOContainer); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbProperties,CdbProperty,DAOProperty); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbFields,CdbField,DAOField); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbQueryDefs,CdbQueryDef,DAOQueryDef); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbTableDefs,CdbTableDef,DAOTableDef); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbIndexes,CdbIndex,DAOIndex); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbRelations,CdbRelation,DAORelation); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbUsers,CdbUser,DAOUser); +DAOMFC_DYNAMIC_COLLECTION_DECL(CdbGroups,CdbGroup,DAOGroup); + +class DLLEXPORT CdbWorkspaces : public CdbDynamicCollection { + friend CdbDBEngine; +private: + DAODBEngine *pDBEng; + WINBOOL m_bDontStart; +public: + CONSTRUCTOR CdbWorkspaces(VOID){pDBEng = NULL;} + CdbWorkspace Item(LONG i); + CdbWorkspace Item(LPCTSTR pstr); + VOID Append(CdbWorkspace &o); + CdbWorkspace operator[](LONG i); + CdbWorkspace operator[](LPCTSTR pstr); + VOID SetDBEngine(DAODBEngine *peng){pDBEng = peng;} + VOID GetDelayedInterface(); +}; + +class DLLEXPORT CdbConnections : public CdbStaticCollection { +public: + CONSTRUCTOR CdbConnections(CdbConnections &Connections); + CONSTRUCTOR CdbConnections() { pwrk = NULL; } + CdbConnection Item(LONG i); + CdbConnection Item(LPCTSTR pstr); + CdbConnection operator[](LONG i); + CdbConnection operator[](LPCTSTR pstr); + CdbConnections &operator = (CdbConnections &o); + LONG GetCount(VOID); + VOID Refresh(VOID); + VOID SetWorkspace(DAOWorkspace *pParent) { pwrk = pParent; } +private: + VOID CheckInterface(); + DAOWorkspace *pwrk; +}; + +class DLLEXPORT CdbObject : public CdbOleObject { +public: + CONSTRUCTOR CdbObject(VOID); + CONSTRUCTOR CdbObject(LPUNKNOWN punk,WINBOOL bAddRef=FALSE); + virtual CString GetName(VOID); + virtual VOID SetName(LPCTSTR pstr); + CdbProperties Properties; +}; + +class DLLEXPORT CdbGetRowsEx : public CdbObject { +public: + CONSTRUCTOR CdbGetRowsEx(VOID); + CONSTRUCTOR CdbGetRowsEx(ICDAORecordset *pGetRows,WINBOOL bAddRef=FALSE); + CONSTRUCTOR CdbGetRowsEx(const CdbGetRowsEx &); + CdbGetRowsEx &operator =(const CdbGetRowsEx &); + VOID OnInterfaceChange(VOID); +}; + +#define DAOVINIT(var) do { (var).vt = VT_ERROR; (var).scode = DISP_E_PARAMNOTFOUND; } while (0) +#define STV(pstr) CdbVariant(pstr) +#define STB(pstr) V_BSTR(((LPVARIANT)STV(pstr))) +#define LTV(l) CdbVariant(l) +#define OLTV(l) CdbVariant((l)) +#define BTB(b) ((VARIANT_BOOL)(b?-1:0)) +#define BTV(b) CdbVariant(BTB(b),TRUE) +#define SHTV(s) CdbVariant((SHORT)s) +#define VTV(pv) CdbVariant(pv) +#define ATV(psa,var) do { if(!psa) { var.vt = VT_ERROR; var.scode = DISP_E_PARAMNOTFOUND; } else { var.vt = VT_ARRAY|VT_UI1; SafeArrayCopy(psa,&var.parray); } } while (0) +#define DAOMFC_CALL(hr) do { HRESULT hresult = (hr); if(FAILED(hresult)) { TRACE0("\nDBDAO Call Failed.\n\t"); TRACE2("\nIn file %s on line %d\n",_T("DBDAO.CPP"),__LINE__); TRACE1("hResult = %X\n",hresult); if(GetScode(hresult)==E_OUTOFMEMORY) AfxThrowMemoryException(); else throw CdbException(hresult); } } while (0) +#define LPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); LONG l = 0; DAOMFC_CALL(p->meth(&l)); return l; } while (0) +#define LPROPSET(intDAO,meth,l) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(l)); } while(0) +#define WPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); SHORT s = 0; DAOMFC_CALL(p->meth(&s)); return s; } while (0) +#define WPROPSET(intDAO,meth,s) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(s)); } while(0) +#define SPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); CdbBSTR bstr; DAOMFC_CALL(p->meth(bstr)); return bstr; } while (0) +#define SPROPSET(intDAO,meth,s) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(STB(s))); } while(0) +#define DPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); VARIANT Var; VariantInit(&Var); DAOMFC_CALL(p->meth(&Var)); return Var; } while (0) +#define DPROPSET(intDAO,meth,pv) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(*pv)); } while(0) +#define BPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); VARIANT_BOOL vb = 0; DAOMFC_CALL(p->meth(&vb)); return(WINBOOL)vb; } while (0) +#define BPROPSET(intDAO,meth,b) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(BTB(b))); } while(0) +#define VPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); COleVariant v; VariantInit(&v); DAOMFC_CALL(p->meth(&v)); return &v; } while (0) +#define VPROPSET(intDAO,meth,pv) do { intDAO *p = (intDAO *)GetInterface(); DAOMFC_CALL(p->meth(*pv)); } while(0) +#define DWPROPGET(intDAO,meth) do { intDAO *p = (intDAO *)GetInterface(); DWORD dw = 0; DAOMFC_CALL(p->meth(&dw)); return dw; } while (0) +#define DAOMFC_STATIC_COLLECTION_IMPL(objColl,objSingle,intColl,intSingle) objSingle objColl::Item(LONG i) { return (intSingle *)(ObItem(i).GetInterface(TRUE)); } objSingle objColl::Item(LPCTSTR pstr) { return (intSingle *)(ObItem(pstr).GetInterface(TRUE)); } objSingle objColl::operator[](LONG i) { return (intSingle *)(Item(i).GetInterface(TRUE)); } objSingle objColl::operator[](LPCTSTR pstr) { return (intSingle *)(Item(pstr).GetInterface(TRUE)); } +#define DAOMFC_DYNAMIC_COLLECTION_IMPL(objColl,objSingle,intColl,intSingle) objSingle objColl::Item(LONG i) { return (intSingle *)(ObItem(i).GetInterface(TRUE)); } objSingle objColl::Item(LPCTSTR pstr) { return (intSingle *)(ObItem(pstr).GetInterface(TRUE)); } VOID objColl::Append(objSingle &o) { ObAppend(o); } objSingle objColl::operator[](LONG i) { return (intSingle *)(Item(i).GetInterface(TRUE)); } objSingle objColl::operator[](LPCTSTR pstr) { return (intSingle *)(Item(pstr).GetInterface(TRUE)); } + +DECLARE_INTERFACE_(DAOMFCSCollection,_DAOCollection) { + STDMETHOD(get_Item) (VARIANT index,LPUNKNOWN *ppunk); +}; + +DECLARE_INTERFACE_(DAOMFCDCollection,_DAODynaCollection) { + STDMETHOD(get_Item) (VARIANT index,LPUNKNOWN *ppunk); +}; +#endif
diff --git a/mingw-w64-headers/include/ieeefp.h b/mingw-w64-headers/include/ieeefp.h new file mode 100755 index 0000000..831bd1d --- /dev/null +++ b/mingw-w64-headers/include/ieeefp.h
@@ -0,0 +1,8 @@ +#ifndef _IEEE_FP_H_ +#define _IEEE_FP_H_ + +#include "_mingw.h" +#include "math.h" +#include "ansidecl.h" + +#endif /* _IEEE_FP_H_ */
diff --git a/mingw-w64-headers/include/io.h b/mingw-w64-headers/include/io.h index fa86127..cb2e371 100755 --- a/mingw-w64-headers/include/io.h +++ b/mingw-w64-headers/include/io.h
@@ -16,6 +16,7 @@ extern "C" { #endif +_CRTIMP char* __cdecl _getcwd (char*, int); #ifndef _FSIZE_T_DEFINED typedef unsigned long _fsize_t; #define _FSIZE_T_DEFINED
diff --git a/mingw-w64-headers/include/langinfo.h b/mingw-w64-headers/include/langinfo.h new file mode 100755 index 0000000..de600ba --- /dev/null +++ b/mingw-w64-headers/include/langinfo.h
@@ -0,0 +1,8 @@ +#ifndef _LANGINFO_H +#define _LANGINFO_H + +#include <nl_types.h> + +char *nl_langinfo(nl_item); + +#endif
diff --git a/mingw-w64-headers/include/mspab.h b/mingw-w64-headers/include/mspab.h new file mode 100755 index 0000000..4a4a9cf --- /dev/null +++ b/mingw-w64-headers/include/mspab.h
@@ -0,0 +1,10 @@ +#define PAB_PROVIDER_ID { 0xB5,0x3b,0xc2,0xc0,0x2c,0x77,0x10,0x1a,0xa1,0xbc,0x08,0x00,0x2b,0x2a,0x56,0xc2 } + +#define PR_PAB_PATH PROP_TAG(PT_TSTRING,0x6600) +#define PR_PAB_PATH_W PROP_TAG(PT_UNICODE,0x6600) +#define PR_PAB_PATH_A PROP_TAG(PT_STRING8,0x6600) + +#define PR_PAB_DET_DIR_VIEW_BY PROP_TAG(PT_LONG,0x6601) + +#define PAB_DIR_VIEW_FIRST_THEN_LAST 0 +#define PAB_DIR_VIEW_LAST_THEN_FIRST 1
diff --git a/mingw-w64-headers/include/mspaddr.h b/mingw-w64-headers/include/mspaddr.h new file mode 100755 index 0000000..7e535f2 --- /dev/null +++ b/mingw-w64-headers/include/mspaddr.h
@@ -0,0 +1,274 @@ +#ifndef __MSPADDR_H_ +#define __MSPADDR_H_ + +typedef struct { + LIST_ENTRY Link; + MSP_EVENT_INFO MSPEventInfo; +} MSPEVENTITEM,*PMSPEVENTITEM; + +MSPEVENTITEM *AllocateEventItem(SIZE_T nExtraBytes = 0); +WINBOOL FreeEventItem(MSPEVENTITEM *pEventItemToFree); + +typedef HRESULT (*PFNCREATETERM)(CComPtr<IMoniker> pMoniker,MSP_HANDLE htAddress,ITTerminal **pTerm); + +typedef struct { + DWORD dwMediaType; + const CLSID *clsidClassManager; + PFNCREATETERM pfnCreateTerm; +} STATIC_TERMINAL_TYPE; + +class ATL_NO_VTABLE CPlugTerminalClassInfo : public IDispatchImpl<ITPluggableTerminalClassInfo,&IID_ITPluggableTerminalClassInfo,&LIBID_TAPI3Lib>,public CComObjectRootEx<CComMultiThreadModel>,public CMSPObjectSafetyImpl +{ +public: + DECLARE_GET_CONTROLLING_UNKNOWN() + virtual HRESULT FinalConstruct(void); + BEGIN_COM_MAP(CPlugTerminalClassInfo) + COM_INTERFACE_ENTRY(ITPluggableTerminalClassInfo) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(IObjectSafety) + COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal,m_pFTM) + END_COM_MAP() +public: + CPlugTerminalClassInfo() : m_bstrName(NULL),m_bstrCompany(NULL),m_bstrVersion(NULL),m_bstrCLSID(NULL),m_bstrTerminalClass(NULL),m_lMediaType(1),m_Direction(TD_CAPTURE),m_pFTM(NULL) + { + } + ~CPlugTerminalClassInfo() { + if(m_bstrName) { + SysFreeString(m_bstrName); + } + if(m_bstrCompany) { + SysFreeString(m_bstrCompany); + } + if(m_bstrVersion) { + SysFreeString(m_bstrVersion); + } + if(m_bstrCLSID) { + SysFreeString(m_bstrCLSID); + } + if(m_bstrTerminalClass) { + SysFreeString(m_bstrTerminalClass); + } + if(m_pFTM) { + m_pFTM->Release(); + } + } +public: + STDMETHOD(get_Name)(BSTR *pName); + STDMETHOD(get_Company)(BSTR *pCompany); + STDMETHOD(get_Version)(BSTR *pVersion); + STDMETHOD(get_TerminalClass)(BSTR *pTerminalClass); + STDMETHOD(get_CLSID)(BSTR *pCLSID); + STDMETHOD(get_Direction)(TERMINAL_DIRECTION *pDirection); + STDMETHOD(get_MediaTypes)(long *pMediaTypes); +private: + CMSPCritSection m_CritSect; + BSTR m_bstrName; + BSTR m_bstrCompany; + BSTR m_bstrVersion; + BSTR m_bstrTerminalClass; + BSTR m_bstrCLSID; + long m_lMediaType; + TERMINAL_DIRECTION m_Direction; + IUnknown *m_pFTM; +private: + STDMETHOD(put_Name)(BSTR bstrName); + STDMETHOD(put_Company)(BSTR bstrCompany); + STDMETHOD(put_Version)(BSTR bstrVersion); + STDMETHOD(put_TerminalClass)(BSTR bstrTerminalClass); + STDMETHOD(put_CLSID)(BSTR bstrCLSID); + STDMETHOD(put_Direction)(TERMINAL_DIRECTION nDirection); + STDMETHOD(put_MediaTypes)(long nMediaTypes); + friend class CMSPAddress; +}; + +class ATL_NO_VTABLE CPlugTerminalSuperclassInfo : public IDispatchImpl<ITPluggableTerminalSuperclassInfo,&IID_ITPluggableTerminalSuperclassInfo,&LIBID_TAPI3Lib>,public CComObjectRootEx<CComMultiThreadModel>,public CMSPObjectSafetyImpl +{ +public: + DECLARE_GET_CONTROLLING_UNKNOWN() + virtual HRESULT FinalConstruct(void); + BEGIN_COM_MAP(CPlugTerminalSuperclassInfo) + COM_INTERFACE_ENTRY(ITPluggableTerminalSuperclassInfo) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(IObjectSafety) + COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal,m_pFTM) + END_COM_MAP() +public: + CPlugTerminalSuperclassInfo() : m_bstrCLSID(NULL),m_bstrName(NULL),m_pFTM(NULL) { + } + ~CPlugTerminalSuperclassInfo() { + if(m_bstrName) { + SysFreeString(m_bstrName); + } + if(m_bstrCLSID) { + SysFreeString(m_bstrCLSID); + } + if(m_pFTM) { + m_pFTM->Release(); + } + } +public: + STDMETHOD(get_Name)(BSTR *pName); + STDMETHOD(get_CLSID)(BSTR *pCLSID); +private: + CMSPCritSection m_CritSect; + BSTR m_bstrCLSID; + BSTR m_bstrName; + IUnknown *m_pFTM; +private: + STDMETHOD(put_Name)(BSTR bstrName); + STDMETHOD(put_CLSID)(BSTR bstrCLSID); + friend class CMSPAddress; +}; + +class ATL_NO_VTABLE CMSPAddress : public CComObjectRootEx<CComMultiThreadModelNoCS>,public ITMSPAddress,public IDispatchImpl<ITTerminalSupport2,&IID_ITTerminalSupport2,&LIBID_TAPI3Lib> +{ +public: + BEGIN_COM_MAP(CMSPAddress) + COM_INTERFACE_ENTRY(ITMSPAddress) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITTerminalSupport) + COM_INTERFACE_ENTRY(ITTerminalSupport2) + END_COM_MAP() + DECLARE_GET_CONTROLLING_UNKNOWN() + DECLARE_VQI() + CMSPAddress(); + virtual ~CMSPAddress(); + virtual ULONG MSPAddressAddRef(void) = 0; + virtual ULONG MSPAddressRelease(void) = 0; + STDMETHOD (Initialize) (MSP_HANDLE htEvent); + STDMETHOD (Shutdown) (); + STDMETHOD (CreateMSPCall) (MSP_HANDLE htCall,DWORD dwReserved,DWORD dwMediaType,IUnknown *pOuterUnknown,IUnknown **ppMSPCall) = 0; + STDMETHOD (ShutdownMSPCall) (IUnknown *pMSPCall) = 0; + STDMETHOD (ReceiveTSPData) (IUnknown *pMSPCall,LPBYTE pBuffer,DWORD dwBufferSize); + STDMETHOD (GetEvent) (DWORD *pdwSize,BYTE *pBuffer); + STDMETHOD (get_StaticTerminals) (VARIANT *pVariant); + STDMETHOD (EnumerateStaticTerminals) (IEnumTerminal **ppTerminalEnumerator); + STDMETHOD (get_DynamicTerminalClasses) (VARIANT *pVariant); + STDMETHOD (EnumerateDynamicTerminalClasses) (IEnumTerminalClass **ppTerminalClassEnumerator); + STDMETHOD (CreateTerminal) (BSTR pTerminalClass,long lMediaType,TERMINAL_DIRECTION Direction,ITTerminal **ppTerminal); + STDMETHOD (GetDefaultStaticTerminal) (long lMediaType,TERMINAL_DIRECTION Direction,ITTerminal **ppTerminal); + STDMETHOD (get_PluggableSuperclasses)(VARIANT *pVariant); + STDMETHOD (EnumeratePluggableSuperclasses)(IEnumPluggableSuperclassInfo **ppSuperclassEnumerator); + STDMETHOD (get_PluggableTerminalClasses)(BSTR bstrTerminalSuperclass,long lMediaType,VARIANT *pVariant); + STDMETHOD (EnumeratePluggableTerminalClasses)(CLSID iidTerminalSuperclass,long lMediaType,IEnumPluggableTerminalClassInfo **ppClassEnumerator); +protected: + virtual HRESULT GetStaticTerminals (DWORD *pdwNumTerminals,ITTerminal **ppTerminals); + virtual HRESULT GetDynamicTerminalClasses (DWORD *pdwNumClasses,IID *pTerminalClasses); +public: + virtual WINBOOL IsValidSetOfMediaTypes(DWORD dwMediaType,DWORD dwMask); + virtual HRESULT PostEvent(MSPEVENTITEM *EventItem); + virtual DWORD GetCallMediaTypes(void) = 0; +protected: + virtual HRESULT IsMonikerInTerminalList(IMoniker *pMoniker); + virtual HRESULT UpdateTerminalListForPnp(WINBOOL bDeviceArrival); + virtual HRESULT UpdateTerminalList(void); + virtual HRESULT ReceiveTSPAddressData(PBYTE pBuffer,DWORD dwSize); +public: + virtual HRESULT PnpNotifHandler(WINBOOL bDeviceArrival); +protected: + HANDLE m_htEvent; + LIST_ENTRY m_EventList; + CMSPCritSection m_EventDataLock; + ITTerminalManager *m_pITTerminalManager; + CMSPArray <ITTerminal *> m_Terminals; + WINBOOL m_fTerminalsUpToDate; + CMSPCritSection m_TerminalDataLock; +private: + static const STATIC_TERMINAL_TYPE m_saTerminalTypes[]; + static const DWORD m_sdwTerminalTypesCount; +}; + +template <class T> HRESULT CreateMSPCallHelper(CMSPAddress *pCMSPAddress,MSP_HANDLE htCall,DWORD dwReserved,DWORD dwMediaType,IUnknown *pOuterUnknown,IUnknown **ppMSPCall,T **ppCMSPCall) +{ + LOG((MSP_TRACE,"CreateMSPCallHelper - enter")); + HRESULT hr; + T *pMSPCall; + IUnknown *pUnknown = NULL; + if(IsBadReadPtr(pCMSPAddress,sizeof(CMSPAddress))) { + LOG((MSP_ERROR,"CreateMSPCallHelper - bad address pointer - exit E_POINTER")); + return E_POINTER; + } + if(IsBadReadPtr(pOuterUnknown,sizeof(IUnknown))) { + LOG((MSP_ERROR,"CreateMSPCallHelper - bad outer unknown - we require aggregation - exit E_POINTER")); + return E_POINTER; + } + if(IsBadReadPtr(ppMSPCall,sizeof(IUnknown *))) { + LOG((MSP_ERROR,"CreateMSPCallHelper - bad iunknown return ptr - exit E_POINTER")); + return E_POINTER; + } + if(IsBadReadPtr(ppCMSPCall,sizeof(T *))) { + LOG((MSP_ERROR,"CreateMSPCallHelper - bad class return ptr - exit E_POINTER")); + return E_POINTER; + } + if(! pCMSPAddress->IsValidSetOfMediaTypes(dwMediaType,pCMSPAddress->GetCallMediaTypes())) { + LOG((MSP_ERROR,"CreateMSPCallHelper - unsupported media types - exit TAPI_E_INVALIDMEDIATYPE")); + return TAPI_E_INVALIDMEDIATYPE; + } + CComAggObject<T> *pCall; + pCall = new CComAggObject<T>(pOuterUnknown); + if(!pCall) { + LOG((MSP_ERROR,"CreateMSPCallHelper - could not create agg call instance - exit E_OUTOFMEMORY")); + return E_OUTOFMEMORY; + } + hr = pCall->QueryInterface(IID_IUnknown,(void **)&pUnknown); + if(FAILED(hr)) { + LOG((MSP_ERROR,"CreateMSPCallHelper - QueryInterface failed: %x",hr)); + delete pCall; + return hr; + } + hr = pCall->FinalConstruct(); + if(FAILED(hr)) { + LOG((MSP_ERROR,"CreateMSPCallHelper - FinalConstruct failed: %x.",hr)); + pUnknown->Release(); + return hr; + } + pMSPCall = dynamic_cast<T *>(&(pCall->m_contained)); + if(!pMSPCall) { + LOG((MSP_ERROR,"CreateMSPCallHelper - can not cast to agg object to class pointer - exit E_UNEXPECTED")); + pUnknown->Release(); + return E_UNEXPECTED; + } + hr = pMSPCall->Init(pCMSPAddress,htCall,dwReserved,dwMediaType); + if(FAILED(hr)) { + LOG((MSP_ERROR,"CreateMSPCallHelper - call init failed: %x",hr)); + pUnknown->Release(); + return hr; + } + *ppMSPCall = pUnknown; + *ppCMSPCall = pMSPCall; + LOG((MSP_TRACE,"CreateMSPCallHelper - exit S_OK")); + return hr; +} + +template <class T> HRESULT ShutdownMSPCallHelper(IUnknown *pUnknown,T **ppCMSPCall) +{ + LOG((MSP_TRACE,"ShutdownMSPCallHelper - enter")); + if(IsBadReadPtr(pUnknown,sizeof(IUnknown))) { + LOG((MSP_ERROR,"ShutdownMSPCallHelper - bad IUnknown pointer - exit E_POINTER")); + return E_POINTER; + } + if(IsBadWritePtr(ppCMSPCall,sizeof(T *))) { + LOG((MSP_ERROR,"ShutdownMSPCallHelper - bad return pointer - exit E_POINTER")); + return E_POINTER; + } + T *pMSPCall; + CComAggObject<T> *pCall = dynamic_cast<CComAggObject<T> *> (pUnknown); + if(!pCall) { + LOG((MSP_ERROR,"ShutdownMSPCallHelper - can't cast unknown to agg object pointer - exit E_UNEXPECTED")); + return E_UNEXPECTED; + } + pMSPCall = dynamic_cast<T *> (&(pCall->m_contained)); + if(!pMSPCall) { + LOG((MSP_ERROR,"ShutdownMSPCallHelper - can't cast contained unknown to class pointer - exit E_UNEXPECTED")); + return E_UNEXPECTED; + } + HRESULT hr = pMSPCall->ShutDown(); + if(FAILED(hr)) { + LOG((MSP_ERROR,"ShutdownMSPCallHelper - ShutDownMSPCall failed: %x",hr)); + return hr; + } + *ppCMSPCall = pMSPCall; + LOG((MSP_TRACE,"ShutdownMSPCallHelper - exit S_OK")); + return S_OK; +} +#endif
diff --git a/mingw-w64-headers/include/mspbase.h b/mingw-w64-headers/include/mspbase.h new file mode 100755 index 0000000..4d6b9bd --- /dev/null +++ b/mingw-w64-headers/include/mspbase.h
@@ -0,0 +1,39 @@ +#ifndef __MSPBASE_H_ +#define __MSPBASE_H_ + +#define _ATL_FREE_THREADED + +#include <atlbase.h> + +extern CComModule _Module; + +#include <atlcom.h> +#include <tapi.h> + +#include <strmif.h> +#include <control.h> +#include <uuids.h> + +#include <termmgr.h> + +#include <msp.h> +#include <tapi3err.h> +#include <tapi3if.h> + +EXTERN_C const IID LIBID_TAPI3Lib; + +#include "mspenum.h" +#include "msplog.h" +#include "msputils.h" +#include "mspaddr.h" +#include "mspcall.h" +#include "mspstrm.h" +#include "mspthrd.h" +#include "mspcoll.h" + +#include "mspterm.h" +#include "msptrmac.h" +#include "msptrmar.h" +#include "msptrmvc.h" + +#endif
diff --git a/mingw-w64-headers/include/mspcall.h b/mingw-w64-headers/include/mspcall.h new file mode 100755 index 0000000..145679c --- /dev/null +++ b/mingw-w64-headers/include/mspcall.h
@@ -0,0 +1,76 @@ +#ifndef __MSPCALL_H_ +#define __MSPCALL_H_ + +class ATL_NO_VTABLE CMSPCallBase : public CComObjectRootEx<CComMultiThreadModelNoCS>,public IDispatchImpl<ITStreamControl,&IID_ITStreamControl,&LIBID_TAPI3Lib> { +public: + DECLARE_POLY_AGGREGATABLE(CMSPCallBase) + BEGIN_COM_MAP(CMSPCallBase) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITStreamControl) + END_COM_MAP() + DECLARE_GET_CONTROLLING_UNKNOWN() + DECLARE_VQI() + CMSPCallBase(); + virtual ~CMSPCallBase(); + virtual ULONG MSPCallAddRef (void) = 0; + virtual ULONG MSPCallRelease (void) = 0; + STDMETHOD (CreateStream) (long lMediaType,TERMINAL_DIRECTION Direction,ITStream **ppStream); + STDMETHOD (EnumerateStreams) (IEnumStream **ppEnumStream); + STDMETHOD (RemoveStream) (ITStream *pStream) = 0; + STDMETHOD (get_Streams) (VARIANT *pStreams); + virtual HRESULT Init(CMSPAddress *pMSPAddress,MSP_HANDLE htCall,DWORD dwReserved,DWORD dwMediaType) = 0; + virtual HRESULT ShutDown() = 0; + virtual HRESULT ReceiveTSPCallData(PBYTE pBuffer,DWORD dwSize); + HRESULT HandleStreamEvent(MSPEVENTITEM *EventItem) const; +protected: + virtual HRESULT InternalCreateStream(DWORD dwMediaType,TERMINAL_DIRECTION Direction,ITStream **ppStream) = 0; + virtual HRESULT CreateStreamObject(DWORD dwMediaType,TERMINAL_DIRECTION Direction,IMediaEvent *pGraph,ITStream **ppStream) = 0; +protected: + CMSPAddress *m_pMSPAddress; + MSP_HANDLE m_htCall; + DWORD m_dwMediaType; + CMSPArray <ITStream *> m_Streams; + CMSPCritSection m_lock; +}; + +class ATL_NO_VTABLE CMSPCallMultiGraph : public CMSPCallBase { +public: + typedef struct { + CMSPCallMultiGraph *pMSPCall; + ITStream *pITStream; + IMediaEvent *pIMediaEvent; + } MSPSTREAMCONTEXT,*PMSPSTREAMCONTEXT; + typedef struct _THREADPOOLWAITBLOCK { + HANDLE hWaitHandle; + MSPSTREAMCONTEXT *pContext; + WINBOOL operator ==(struct _THREADPOOLWAITBLOCK &t) { return ((hWaitHandle==t.hWaitHandle) && (pContext==t.pContext)); } + } THREADPOOLWAITBLOCK,*PTHREADPOOLWAITBLOCK; +public: + CMSPCallMultiGraph(); + virtual ~CMSPCallMultiGraph(); + STDMETHOD (RemoveStream) (ITStream *ppStream); + HRESULT Init(CMSPAddress *pMSPAddress,MSP_HANDLE htCall,DWORD dwReserved,DWORD dwMediaType); + HRESULT ShutDown(); + static VOID NTAPI DispatchGraphEvent(VOID *pContext,BOOLEAN bFlag); + virtual VOID HandleGraphEvent(MSPSTREAMCONTEXT *pContext); + virtual HRESULT ProcessGraphEvent(ITStream *pITStream,long lEventCode,LONG_PTR lParam1,LONG_PTR lParam2); +protected: + HRESULT RegisterWaitEvent(IMediaEvent *pIMediaEvent,ITStream *pITStream); + HRESULT UnregisterWaitEvent(int index); + virtual HRESULT InternalCreateStream(DWORD dwMediaType,TERMINAL_DIRECTION Direction,ITStream **ppStream); +protected: + CMSPArray <THREADPOOLWAITBLOCK> m_ThreadPoolWaitBlocks; +}; + +struct MULTI_GRAPH_EVENT_DATA { + CMSPCallMultiGraph *pCall; + ITStream *pITStream; + long lEventCode; + LONG_PTR lParam1; + LONG_PTR lParam2; + IMediaEvent *pIMediaEvent; + MULTI_GRAPH_EVENT_DATA() : pIMediaEvent(NULL),pITStream(NULL),lEventCode(0),lParam1(0),lParam2(0) { } +}; + +DWORD WINAPI AsyncMultiGraphEvent(LPVOID pVoid); +#endif
diff --git a/mingw-w64-headers/include/mspcoll.h b/mingw-w64-headers/include/mspcoll.h new file mode 100755 index 0000000..6bf186e --- /dev/null +++ b/mingw-w64-headers/include/mspcoll.h
@@ -0,0 +1,177 @@ +#ifndef _MSPCOLL_H_ +#define _MSPCOLL_H_ + +template <class T> class CTapiIfCollection : public IDispatchImpl<ITCollection,&IID_ITCollection,&LIBID_TAPI3Lib>,public CComObjectRootEx<CComMultiThreadModelNoCS> +{ +public: + typedef CTapiIfCollection<T> _CTapiCollectionBase; + BEGIN_COM_MAP(_CTapiCollectionBase) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITCollection) + END_COM_MAP() +private: + int m_nSize; + CComVariant *m_Var; + +public: + CTapiIfCollection(void) : m_nSize(0),m_Var(NULL) { } + HRESULT WINAPI Initialize(DWORD dwSize,T *pBegin,T *pEnd) { + int i; + HRESULT hr; + T *iter; + LOG((MSP_TRACE,"CTapiCollection::Initialize - enter")); + m_nSize = dwSize; + m_Var = new CComVariant[m_nSize]; + if(!m_Var) return E_OUTOFMEMORY; + i = 0; + for(iter = pBegin;iter!=pEnd;iter++) { + IDispatch *pDisp = NULL; + hr = (*iter)->QueryInterface(IID_IDispatch,(void**)&pDisp); + if(hr!=S_OK) return hr; + CComVariant& var = m_Var[i]; + VariantInit(&var); + var.vt = VT_DISPATCH; + var.pdispVal = pDisp; + i++; + } + LOG((MSP_TRACE,"CTapiCollection::Initialize - exit")); + return S_OK; + } + void FinalRelease() { + LOG((MSP_TRACE,"CTapiCollection::FinalRelease - enter")); + delete [] m_Var; + LOG((MSP_TRACE,"CTapiCollection::FinalRelease - exit")); + } + STDMETHOD(get_Count)(long *retval) { + HRESULT hr = S_OK; + LOG((MSP_TRACE,"CTapiCollection::get_Count - enter")); + try { + *retval = m_nSize; + } catch(...) { + hr = E_INVALIDARG; + } + LOG((MSP_TRACE,"CTapiCollection::get_Count - exit")); + return hr; + } + STDMETHOD(get_Item)(long Index,VARIANT *retval) { + HRESULT hr = S_OK; + LOG((MSP_TRACE,"CTapiCollection::get_Item - enter")); + if(!retval) return E_POINTER; + try { + VariantInit(retval); + } catch(...) { + hr = E_INVALIDARG; + } + if(hr!=S_OK) return hr; + retval->vt = VT_UNKNOWN; + retval->punkVal = NULL; + if((Index < 1) || (Index > m_nSize)) return E_INVALIDARG; + hr = VariantCopy(retval,&m_Var[Index-1]); + if(FAILED(hr)) { + LOG((MSP_ERROR,"CTapiCollection::get_Item - VariantCopy failed. hr = %lx",hr)); + return hr; + } + LOG((MSP_TRACE,"CTapiCollection::get_Item - exit")); + return S_OK; + } + HRESULT WINAPI get__NewEnum(IUnknown **retval) { + HRESULT hr; + LOG((MSP_TRACE,"CTapiCollection::new__Enum - enter")); + if(!retval) return E_POINTER; + *retval = NULL; + typedef CComObject<CSafeComEnum<IEnumVARIANT,&IID_IEnumVARIANT,VARIANT,_Copy<VARIANT> > > enumvar; + enumvar *p; + hr = enumvar::CreateInstance(&p); + if(FAILED(hr)) return hr; + hr = p->Init(&m_Var[0],&m_Var[m_nSize],NULL,AtlFlagCopy); + if(SUCCEEDED(hr)) hr = p->QueryInterface(IID_IEnumVARIANT,(void**)retval); + if(FAILED(hr)) delete p; + LOG((MSP_TRACE,"CTapiCollection::new__Enum - exit")); + return hr; + } +}; + +class CTapiBstrCollection : public CComObjectRootEx<CComMultiThreadModelNoCS>,public IDispatchImpl<ITCollection,&IID_ITCollection,&LIBID_TAPI3Lib>,public CMSPObjectSafetyImpl +{ +public: + BEGIN_COM_MAP(CTapiBstrCollection) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITCollection) + COM_INTERFACE_ENTRY(IObjectSafety) + END_COM_MAP() +private: + DWORD m_dwSize; + CComVariant *m_Var; +public: + CTapiBstrCollection(void) : m_dwSize(0),m_Var(NULL) { } + HRESULT WINAPI Initialize(DWORD dwSize,BSTR *pBegin,BSTR *pEnd) { + BSTR *i; + DWORD dw = 0; + LOG((MSP_TRACE,"CTapiBstrCollection::Initialize - enter")); + m_dwSize = dwSize; + m_Var = new CComVariant[m_dwSize]; + if(!m_Var) return E_OUTOFMEMORY; + for(i = pBegin;i!=pEnd;i++) { + CComVariant& var = m_Var[dw]; + var.vt = VT_BSTR; + var.bstrVal = *i; + dw++; + } + LOG((MSP_TRACE,"CTapiBstrCollection::Initialize - exit")); + return S_OK; + } + STDMETHOD(get_Count)(long *retval) { + HRESULT hr = S_OK; + LOG((MSP_TRACE,"CTapiBstrCollection::get_Count - enter")); + try { + *retval = m_dwSize; + } catch(...) { + hr = E_INVALIDARG; + } + LOG((MSP_TRACE,"CTapiBstrCollection::get_Count - exit")); + return hr; + } + STDMETHOD(get_Item)(long Index,VARIANT *retval) { + HRESULT hr = S_OK; + LOG((MSP_TRACE,"CTapiBstrCollection::get_Item - enter")); + if(!retval) return E_POINTER; + try { + VariantInit(retval); + } catch(...) { + hr = E_INVALIDARG; + } + if(hr!=S_OK) return hr; + retval->vt = VT_BSTR; + retval->bstrVal = NULL; + if((Index < 1) || ((DWORD) Index > m_dwSize)) return E_INVALIDARG; + hr = VariantCopy(retval,&m_Var[Index-1]); + if(FAILED(hr)) { + LOG((MSP_ERROR,"CTapiBstrCollection::get_Item - VariantCopy failed. hr = %lx",hr)); + return hr; + } + LOG((MSP_TRACE,"CTapiBstrCollection::get_Item - exit")); + return S_OK; + } + HRESULT WINAPI get__NewEnum(IUnknown **retval) { + HRESULT hr; + LOG((MSP_TRACE,"CTapiBstrCollection::get__NumEnum - enter")); + if(!retval) return E_POINTER; + *retval = NULL; + typedef CComObject<CSafeComEnum<IEnumVARIANT,&IID_IEnumVARIANT,VARIANT,_Copy<VARIANT> > > enumvar; + enumvar *p = new enumvar; + if(!p) return E_OUTOFMEMORY; + hr = p->Init(&m_Var[0],&m_Var[m_dwSize],NULL,AtlFlagCopy); + if(SUCCEEDED(hr)) { + hr = p->QueryInterface(IID_IEnumVARIANT,(void**)retval); + } + if(FAILED(hr)) delete p; + LOG((MSP_TRACE,"CTapiBstrCollection::get__NewEnum - exit")); + return hr; + } + void FinalRelease() { + LOG((MSP_TRACE,"CTapiBstrCollection::FinalRelease() - enter")); + delete [] m_Var; + LOG((MSP_TRACE,"CTapiBstrCollection::FinalRelease() - exit")); + } +}; +#endif
diff --git a/mingw-w64-headers/include/mspenum.h b/mingw-w64-headers/include/mspenum.h new file mode 100755 index 0000000..01cc9ec --- /dev/null +++ b/mingw-w64-headers/include/mspenum.h
@@ -0,0 +1,40 @@ +#ifndef _MSPENUM_H_ +#define _MSPENUM_H_ + +template <class Base,const IID *piid,class T,class Copy,class ThreadModel = CComObjectThreadModel> +class ATL_NO_VTABLE CSafeComEnum : public CComEnumImpl<Base,piid,T,Copy>,public CComObjectRootEx< ThreadModel > +{ + typedef CSafeComEnum<Base,piid,T,Copy,ThreadModel> ThisClass; + typedef CComEnumImpl<Base,piid,T,Copy> BaseClass; + STDMETHOD(Next)(ULONG celt,T *rgelt,ULONG *pceltFetched) { + if(IsBadWritePtr(rgelt,celt *sizeof(T))) return E_POINTER; + if((pceltFetched!=NULL) && IsBadWritePtr(pceltFetched,sizeof(ULONG))) return E_POINTER; + return BaseClass::Next(celt,rgelt,pceltFetched); + } + STDMETHOD(Clone)(Base **ppEnum) { + if(IsBadWritePtr(ppEnum,sizeof(Base *))) return E_POINTER; + return BaseClass::Clone(ppEnum); + } + BEGIN_COM_MAP(ThisClass) + COM_INTERFACE_ENTRY_IID(*piid,BaseClass) + COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal,m_pFTM) + END_COM_MAP() + DECLARE_GET_CONTROLLING_UNKNOWN() + HRESULT Init(T *begin,T *end,IUnknown *pUnk,CComEnumFlags flags = AtlFlagNoCopy) { + HRESULT hr; + IUnknown *pIU = GetControllingUnknown(); + hr = CoCreateFreeThreadedMarshaler(pIU,& m_pFTM); + if(FAILED(hr)) return hr; + return BaseClass::Init(begin,end,pUnk,flags); + } + CSafeComEnum() { m_pFTM = NULL; } + void FinalRelease(void) { + if(m_pFTM) { + m_pFTM->Release(); + } + CComObjectRootEx< ThreadModel >::FinalRelease(); + } +protected: + IUnknown *m_pFTM; +}; +#endif
diff --git a/mingw-w64-headers/include/msplog.h b/mingw-w64-headers/include/msplog.h new file mode 100755 index 0000000..57efb7f --- /dev/null +++ b/mingw-w64-headers/include/msplog.h
@@ -0,0 +1,32 @@ +#ifndef _MSPLOG_H_ +#define _MSPLOG_H_ + +#ifdef MSPLOG + +#include <rtutils.h> + +#define MSP_ERROR ((DWORD)0x00010000 | TRACE_USE_MASK) +#define MSP_WARN ((DWORD)0x00020000 | TRACE_USE_MASK) +#define MSP_INFO ((DWORD)0x00040000 | TRACE_USE_MASK) +#define MSP_TRACE ((DWORD)0x00080000 | TRACE_USE_MASK) +#define MSP_EVENT ((DWORD)0x00100000 | TRACE_USE_MASK) + +WINBOOL NTAPI MSPLogRegister(LPCTSTR szName); +void NTAPI MSPLogDeRegister(); +void NTAPI LogPrint(DWORD dwDbgLevel,LPCSTR DbgMessage,...); + +#define MSPLOGREGISTER(arg) MSPLogRegister(arg) +#define MSPLOGDEREGISTER() MSPLogDeRegister() + +extern WINBOOL g_bMSPBaseTracingOn; + +#define LOG(arg) g_bMSPBaseTracingOn?LogPrint arg:0 +#else +#define MSPLOGREGISTER(arg) +#define MSPLOGDEREGISTER() +#define LOG(arg) +#endif + +#define DECLARE_LOG_ADDREF_RELEASE(x) +#define CMSPComObject CComObject +#endif
diff --git a/mingw-w64-headers/include/mspst.h b/mingw-w64-headers/include/mspst.h new file mode 100755 index 0000000..bd3de48 --- /dev/null +++ b/mingw-w64-headers/include/mspst.h
@@ -0,0 +1,17 @@ +#ifndef _MSPST_H_ +#define _MSPST_H_ + +#define PST_EXTERN_PROPID_BASE (0x6700) +#define PR_PST_PATH PROP_TAG(PT_STRING8,PST_EXTERN_PROPID_BASE + 0) +#define PR_PST_REMEMBER_PW PROP_TAG(PT_BOOLEAN,PST_EXTERN_PROPID_BASE + 1) +#define PR_PST_ENCRYPTION PROP_TAG(PT_LONG,PST_EXTERN_PROPID_BASE + 2) +#define PR_PST_PW_SZ_OLD PROP_TAG(PT_STRING8,PST_EXTERN_PROPID_BASE + 3) +#define PR_PST_PW_SZ_NEW PROP_TAG(PT_STRING8,PST_EXTERN_PROPID_BASE + 4) + +#define PSTF_NO_ENCRYPTION ((DWORD)0x80000000) +#define PSTF_COMPRESSABLE_ENCRYPTION ((DWORD)0x40000000) +#define PSTF_BEST_ENCRYPTION ((DWORD)0x20000000) + +#define MSPST_UID_PROVIDER { 0x4e,0x49,0x54,0x41,0xf9,0xbf,0xb8,0x01,0x00,0xaa,0x00,0x37,0xd9,0x6e,0x00,0x00 } + +#endif
diff --git a/mingw-w64-headers/include/mspstrm.h b/mingw-w64-headers/include/mspstrm.h new file mode 100755 index 0000000..a0098b5 --- /dev/null +++ b/mingw-w64-headers/include/mspstrm.h
@@ -0,0 +1,93 @@ +#ifndef _MSPSTRM_H_ +#define _MSPSTRM_H_ + +#define STRM_INITIAL 0x00000000 +#define STRM_TERMINALSELECTED 0x00000001 +#define STRM_CONFIGURED 0x00000002 +#define STRM_RUNNING 0x00000004 +#define STRM_PAUSED 0x00000008 +#define STRM_STOPPED 0x00000010 + +class CMSPStream; + +class ATL_NO_VTABLE CPTEventSink : public CComObjectRootEx<CComMultiThreadModel>,public ITPluggableTerminalEventSink { +public: + CPTEventSink(); + ~CPTEventSink(); + BEGIN_COM_MAP(CPTEventSink) + COM_INTERFACE_ENTRY(ITPluggableTerminalEventSink) + END_COM_MAP() +public: + STDMETHOD(FireEvent)(const MSP_EVENT_INFO *pMspEventInfo); +public: + HRESULT SetSinkStream(CMSPStream *pStream); +private: + struct AsyncEventStruct { + CMSPStream *pMSPStream; + MSPEVENTITEM *pEventItem; + AsyncEventStruct() : pMSPStream(NULL),pEventItem(NULL) { + LOG((MSP_TRACE,"AsyncEventStruct::AsyncEventStruct[%p]",this)); + } + ~AsyncEventStruct() { + pMSPStream = NULL; + pEventItem = NULL; + LOG((MSP_TRACE,"AsyncEventStruct::~AsyncEventStruct[%p]",this)); + } + }; + static DWORD WINAPI FireEventCallBack(LPVOID pEventStructure); +private: + CMSPStream *m_pMSPStream; +}; + +class ATL_NO_VTABLE CMSPStream : public CComObjectRootEx<CComMultiThreadModelNoCS>,public IDispatchImpl<ITStream,&IID_ITStream,&LIBID_TAPI3Lib> { +public: + BEGIN_COM_MAP(CMSPStream) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITStream) + COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal,m_pFTM) + END_COM_MAP() + DECLARE_GET_CONTROLLING_UNKNOWN() + CMSPStream(); + ~CMSPStream(); + virtual void FinalRelease(); + STDMETHOD (get_MediaType) (long *plMediaType); + STDMETHOD (get_Direction) (TERMINAL_DIRECTION *pTerminalDirection); + STDMETHOD (get_Name) (BSTR *ppName) = 0; + STDMETHOD (SelectTerminal) (ITTerminal *pTerminal); + STDMETHOD (UnselectTerminal) (ITTerminal *pTerminal); + STDMETHOD (EnumerateTerminals) (IEnumTerminal **ppEnumTerminal); + STDMETHOD (get_Terminals) (VARIANT *pTerminals); + STDMETHOD (StartStream) (); + STDMETHOD (PauseStream) (); + STDMETHOD (StopStream) (); + virtual HRESULT Init(HANDLE hAddress,CMSPCallBase *pMSPCall,IMediaEvent *pGraph,DWORD dwMediaType,TERMINAL_DIRECTION Direction); + virtual HRESULT ShutDown(); + virtual HRESULT GetState(DWORD *pdwStatus) { return E_NOTIMPL; } + virtual HRESULT HandleTSPData(BYTE *pData,DWORD dwSize); + virtual HRESULT ProcessGraphEvent(long lEventCode,LONG_PTR lParam1,LONG_PTR lParam2); +protected: + HRESULT RegisterPluggableTerminalEventSink(ITTerminal *pTerminal); + HRESULT UnregisterPluggableTerminalEventSink(ITTerminal *pTerminal); + HRESULT ReleaseSink(); + ULONG InternalAddRef(); + ULONG InternalRelease(); +public: + HRESULT HandleSinkEvent(MSPEVENTITEM *pEventItem); +protected: + IUnknown *m_pFTM; + DWORD m_dwState; + DWORD m_dwMediaType; + TERMINAL_DIRECTION m_Direction; + HANDLE m_hAddress; + CMSPCallBase *m_pMSPCall; + IGraphBuilder *m_pIGraphBuilder; + IMediaControl *m_pIMediaControl; + CMSPArray <ITTerminal *> m_Terminals; + CMSPCritSection m_lock; + CMSPCritSection m_lockRefCount; + ITPluggableTerminalEventSink *m_pPTEventSink; + long m_lMyPersonalRefcount; + WINBOOL m_bFirstAddRef; +}; + +#endif
diff --git a/mingw-w64-headers/include/mspterm.h b/mingw-w64-headers/include/mspterm.h new file mode 100755 index 0000000..77e031d --- /dev/null +++ b/mingw-w64-headers/include/mspterm.h
@@ -0,0 +1,75 @@ +#ifndef _MSPTERM_H_ +#define _MSPTERM_H_ + +template <class T> class ITTerminalVtblBase : public ITTerminal { +}; + +class CBaseTerminal : virtual public CComObjectRootEx<CComMultiThreadModelNoCS>,public IDispatchImpl<ITTerminalVtblBase<CBaseTerminal>,&IID_ITTerminal,&LIBID_TAPI3Lib>,public ITTerminalControl +{ + BEGIN_COM_MAP(CBaseTerminal) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(ITTerminal) + COM_INTERFACE_ENTRY(ITTerminalControl) + COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal,m_pFTM) + END_COM_MAP() + DECLARE_VQI() + DECLARE_GET_CONTROLLING_UNKNOWN() +public: + CBaseTerminal(); + virtual ~CBaseTerminal(); +public: + STDMETHOD(get_TerminalClass)(BSTR *pVal); + STDMETHOD(get_TerminalType)(TERMINAL_TYPE *pVal); + STDMETHOD(get_State)(TERMINAL_STATE *pVal); + STDMETHOD(get_Name)(BSTR *pVal); + STDMETHOD(get_MediaType)(long *plMediaType); + STDMETHOD(get_Direction)(TERMINAL_DIRECTION *pDirection); +public: + virtual HRESULT Initialize(IID iidTerminalClass,DWORD dwMediaType,TERMINAL_DIRECTION Direction,MSP_HANDLE htAddress); +public: + STDMETHOD (get_AddressHandle)(MSP_HANDLE *phtAddress); + STDMETHOD (ConnectTerminal)(IGraphBuilder *pGraph,DWORD dwTerminalDirection,DWORD *pdwNumPins,IPin **ppPins); + STDMETHOD (CompleteConnectTerminal)(void); + STDMETHOD (DisconnectTerminal)(IGraphBuilder *pGraph,DWORD dwReserved); + STDMETHOD (RunRenderFilter)(void) = 0; + STDMETHOD (StopRenderFilter)(void) = 0; +protected: + CMSPCritSection m_CritSec; +public: + TERMINAL_DIRECTION m_TerminalDirection; + TERMINAL_TYPE m_TerminalType; + TERMINAL_STATE m_TerminalState; + TCHAR m_szName[MAX_PATH + 1]; + IID m_TerminalClassID; + DWORD m_dwMediaType; + MSP_HANDLE m_htAddress; + IUnknown *m_pFTM; + CComPtr<IGraphBuilder> m_pGraph; + virtual HRESULT AddFiltersToGraph() = 0; + virtual HRESULT ConnectFilters() { return S_OK; } + virtual HRESULT GetNumExposedPins(IGraphBuilder *pGraph,DWORD *pdwNumPins) = 0; + virtual HRESULT GetExposedPins(IPin **ppPins) = 0; + virtual DWORD GetSupportedMediaTypes(void) = 0; + virtual HRESULT RemoveFiltersFromGraph() = 0; + WINBOOL MediaTypeSupported(long lMediaType); +}; + +class CSingleFilterTerminal : public CBaseTerminal { +public: + CComPtr<IPin> m_pIPin; + CComPtr<IBaseFilter> m_pIFilter; +public: + STDMETHOD(RunRenderFilter)(void); + STDMETHOD(StopRenderFilter)(void); + virtual HRESULT GetNumExposedPins(IGraphBuilder *pGraph,DWORD *pdwNumPins); + virtual HRESULT GetExposedPins(IPin **ppPins); + virtual HRESULT RemoveFiltersFromGraph(); +}; + +class CSingleFilterStaticTerminal : public CSingleFilterTerminal { +public: + CComPtr<IMoniker> m_pMoniker; + WINBOOL m_bMark; + virtual HRESULT CompareMoniker(IMoniker *pMoniker); +}; +#endif
diff --git a/mingw-w64-headers/include/mspthrd.h b/mingw-w64-headers/include/mspthrd.h new file mode 100755 index 0000000..dd3e5d5 --- /dev/null +++ b/mingw-w64-headers/include/mspthrd.h
@@ -0,0 +1,59 @@ +#ifndef __MSPTHRD_H +#define __MSPTHRD_H + +typedef enum { + WORK_ITEM,STOP +} COMMAND; + +typedef struct { + COMMAND cmd; + LPTHREAD_START_ROUTINE pfn; + PVOID pContext; + HANDLE hEvent; +} COMMAND_NODE; + +typedef struct { + LIST_ENTRY link; + COMMAND_NODE node; +} COMMAND_QUEUE_ITEM; + +typedef struct _NOTIF_LIST { + CMSPAddress *addr; + _NOTIF_LIST *next; +} NOTIF_LIST,*PNOTIF_LIST; + +class CMSPThread { +public: + CMSPThread() { + InitializeListHead(&m_CommandQueue); + m_hCommandEvent = NULL; + m_hThread = NULL; + m_NotifList = NULL; + m_iStartCount = 0; + } + ~CMSPThread() { }; + HRESULT Start(); + HRESULT Stop(); + HRESULT Shutdown(); + HRESULT ThreadProc(); + static LRESULT CALLBACK NotifWndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam); + HRESULT RegisterPnpNotification(CMSPAddress *pCMSPAddress); + HRESULT UnregisterPnpNotification(CMSPAddress *pCMSPAddress); + HRESULT QueueWorkItem(LPTHREAD_START_ROUTINE Function,PVOID Context,WINBOOL fSynchronous); +private: + WINBOOL SignalThreadProc() { return SetEvent(m_hCommandEvent); } + CMSPCritSection m_CountLock; + CMSPCritSection m_QueueLock; + int m_iStartCount; + LIST_ENTRY m_CommandQueue; + HANDLE m_hCommandEvent; + HANDLE m_hThread; + HDEVNOTIFY m_hDevNotifyVideo; + HDEVNOTIFY m_hDevNotifyAudio; + HWND m_hWndNotif; + PNOTIF_LIST m_NotifList; + CMSPCritSection m_NotifLock; +}; + +extern CMSPThread g_Thread; +#endif
diff --git a/mingw-w64-headers/include/msptrmac.h b/mingw-w64-headers/include/msptrmac.h new file mode 100755 index 0000000..8ee612c --- /dev/null +++ b/mingw-w64-headers/include/msptrmac.h
@@ -0,0 +1,44 @@ +#ifndef _MSPTRMAC_H_ +#define _MSPTRMAC_H_ + +#define WAVEIN_NAME L"WaveIn Terminal" + +class CAudioCaptureTerminal : public IDispatchImpl<ITBasicAudioTerminal,&IID_ITBasicAudioTerminal,&LIBID_TAPI3Lib>,public IDispatchImpl<ITStaticAudioTerminal,&IID_ITStaticAudioTerminal,&LIBID_TAPI3Lib>,public CSingleFilterStaticTerminal,public CMSPObjectSafetyImpl +{ + BEGIN_COM_MAP(CAudioCaptureTerminal) + COM_INTERFACE_ENTRY(IObjectSafety) + COM_INTERFACE_ENTRY(ITBasicAudioTerminal) + COM_INTERFACE_ENTRY(ITStaticAudioTerminal) + COM_INTERFACE_ENTRY_CHAIN(CSingleFilterStaticTerminal) + END_COM_MAP() + DECLARE_VQI() + DECLARE_LOG_ADDREF_RELEASE(CAudioCaptureTerminal) +public: + CAudioCaptureTerminal(); + virtual ~CAudioCaptureTerminal(); + static HRESULT CreateTerminal(CComPtr<IMoniker> pMoniker,MSP_HANDLE htAddress,ITTerminal **ppTerm); + HRESULT FindTerminalPin(); +public: + STDMETHOD(get_Balance)(long *pVal); + STDMETHOD(put_Balance)(long newVal); + STDMETHOD(get_Volume) (long *pVal); + STDMETHOD(put_Volume) (long newVal); +public: + STDMETHOD(get_WaveId) (long *plWaveId); + STDMETHODIMP CompleteConnectTerminal(void); + STDMETHODIMP DisconnectTerminal(IGraphBuilder *pGraph,DWORD dwReserved); + virtual HRESULT AddFiltersToGraph(); + virtual DWORD GetSupportedMediaTypes(void) { return (DWORD) TAPIMEDIATYPE_AUDIO; } + HRESULT CreateFilters(); + inline HRESULT CreateFiltersIfRequired(); +private: + bool m_bResourceReserved; + CComPtr<IAMAudioInputMixer> m_pIAMAudioInputMixer; +}; + +inline HRESULT CAudioCaptureTerminal::CreateFiltersIfRequired() { + if(!m_pIFilter) return CreateFilters(); + return S_OK; +} + +#endif
diff --git a/mingw-w64-headers/include/msptrmar.h b/mingw-w64-headers/include/msptrmar.h new file mode 100755 index 0000000..257c66e --- /dev/null +++ b/mingw-w64-headers/include/msptrmar.h
@@ -0,0 +1,40 @@ +#ifndef _MSPTRMAR_H_ +#define _MSPTRMAR_H_ + +#define WAVEOUT_NAME L"WaveOut Terminal" +#define MIXER_NAME L"PCM Mixer" + +class CAudioRenderTerminal : public IDispatchImpl<ITBasicAudioTerminal,&IID_ITBasicAudioTerminal,&LIBID_TAPI3Lib>,public IDispatchImpl<ITStaticAudioTerminal,&IID_ITStaticAudioTerminal,&LIBID_TAPI3Lib>,public CSingleFilterStaticTerminal,public CMSPObjectSafetyImpl +{ +public: + CAudioRenderTerminal(); + virtual ~CAudioRenderTerminal(); + HRESULT InitializeDefaultTerminal(); + static HRESULT CreateTerminal(CComPtr<IMoniker> pMoniker,MSP_HANDLE htAddress,ITTerminal **ppTerm); + HRESULT FindTerminalPin(); + BEGIN_COM_MAP(CAudioRenderTerminal) + COM_INTERFACE_ENTRY(IObjectSafety) + COM_INTERFACE_ENTRY(ITBasicAudioTerminal) + COM_INTERFACE_ENTRY(ITStaticAudioTerminal) + COM_INTERFACE_ENTRY_CHAIN(CSingleFilterStaticTerminal) + END_COM_MAP() + DECLARE_VQI() + DECLARE_LOG_ADDREF_RELEASE(CAudioRenderTerminal) +public: + STDMETHOD(get_Balance)(long *pVal); + STDMETHOD(put_Balance)(long newVal); + STDMETHOD(get_Volume)(long *pVal); + STDMETHOD(put_Volume)(long newVal); + STDMETHOD(get_WaveId) (long *plWaveId); +public: + STDMETHODIMP CompleteConnectTerminal(void); + STDMETHODIMP DisconnectTerminal(IGraphBuilder *pGraph,DWORD dwReserved); + virtual HRESULT AddFiltersToGraph(); + virtual DWORD GetSupportedMediaTypes(void) { return (DWORD) TAPIMEDIATYPE_AUDIO; } + HRESULT CreateFilters(); +private: + bool m_bResourceReserved; + CComPtr<IBasicAudio> m_pIBasicAudio; +}; + +#endif
diff --git a/mingw-w64-headers/include/msptrmvc.h b/mingw-w64-headers/include/msptrmvc.h new file mode 100755 index 0000000..4e7508b --- /dev/null +++ b/mingw-w64-headers/include/msptrmvc.h
@@ -0,0 +1,24 @@ +#ifndef _MSPTRMVC_H_ +#define _MSPTRMVC_H_ + +class CVideoCaptureTerminal : public CSingleFilterStaticTerminal { +public: + CVideoCaptureTerminal(); + virtual ~CVideoCaptureTerminal(); +public: + static HRESULT CreateTerminal(CComPtr<IMoniker> pMoniker,MSP_HANDLE htAddress,ITTerminal **ppTerm); + DECLARE_LOG_ADDREF_RELEASE(CVideoCaptureTerminal); +private: + virtual HRESULT AddFiltersToGraph(); + virtual LONG CountOfMediaTypes() { return 1; } + virtual DWORD GetSupportedMediaTypes(void) { return (DWORD) TAPIMEDIATYPE_VIDEO; } + HRESULT CreateFilters(); + HRESULT FindCapturePin(); +}; + +inline CVideoCaptureTerminal::CVideoCaptureTerminal() { + m_TerminalDirection = TD_CAPTURE; + m_TerminalType = TT_STATIC; +} + +#endif
diff --git a/mingw-w64-headers/include/msputils.h b/mingw-w64-headers/include/msputils.h new file mode 100755 index 0000000..63aba74 --- /dev/null +++ b/mingw-w64-headers/include/msputils.h
@@ -0,0 +1,194 @@ +#ifndef __MSPUTILS_H_ +#define __MSPUTILS_H_ + +#if _ATL_VER >= 0x0300 +#define DECLARE_VQI() +#else +#define DECLARE_VQI() STDMETHOD(QueryInterface)(REFIID iid,void **ppvObject) = 0; STDMETHOD_(ULONG,AddRef)() = 0; STDMETHOD_(ULONG,Release)() = 0; +#endif + +#define MSP_(hr) (FAILED(hr)?MSP_ERROR:MSP_TRACE) + +extern __inline WINBOOL IsValidAggregatedMediaType(DWORD dwAggregatedMediaType) { + const DWORD dwAllPossibleMediaTypes = TAPIMEDIATYPE_AUDIO | TAPIMEDIATYPE_VIDEO | TAPIMEDIATYPE_DATAMODEM | TAPIMEDIATYPE_G3FAX | TAPIMEDIATYPE_MULTITRACK; + WINBOOL bValidMediaType = FALSE; + if((0==(dwAggregatedMediaType & dwAllPossibleMediaTypes)) || (0!=(dwAggregatedMediaType & (~dwAllPossibleMediaTypes)))) { + bValidMediaType = FALSE; + } else { + bValidMediaType = TRUE; + } + return bValidMediaType; +} + +extern __inline WINBOOL IsSingleMediaType(DWORD dwMediaType) { return !((dwMediaType==0) || ((dwMediaType & (dwMediaType - 1))!=0)); } +extern __inline WINBOOL IsValidSingleMediaType(DWORD dwMediaType,DWORD dwMask) { return IsSingleMediaType(dwMediaType) && ((dwMediaType & dwMask)==dwMediaType); } + +const DWORD INITIAL = 8; +const DWORD DELTA = 8; + +template <class T,DWORD dwInitial = INITIAL,DWORD dwDelta = DELTA> class CMSPArray { +protected: + T *m_aT; + int m_nSize; + int m_nAllocSize; +public: + CMSPArray() : m_aT(NULL),m_nSize(0),m_nAllocSize(0) { } + ~CMSPArray() { RemoveAll(); } + int GetSize() const { return m_nSize; } + WINBOOL Grow() { + T *aT; + int nNewAllocSize = (m_nAllocSize==0) ? dwInitial : (m_nSize + DELTA); + aT = (T *)realloc(m_aT,nNewAllocSize *sizeof(T)); + if(!aT) return FALSE; + m_nAllocSize = nNewAllocSize; + m_aT = aT; + return TRUE; + } + WINBOOL Add(T &t) { + if(m_nSize==m_nAllocSize) { + if(!Grow()) return FALSE; + } + m_nSize++; + SetAtIndex(m_nSize - 1,t); + return TRUE; + } + WINBOOL Remove(T &t) { + int nIndex = Find(t); + if(nIndex==-1) return FALSE; + return RemoveAt(nIndex); + } + WINBOOL RemoveAt(int nIndex) { + if(nIndex!=(m_nSize - 1)) + memmove((void*)&m_aT[nIndex],(void*)&m_aT[nIndex + 1],(m_nSize - (nIndex + 1))*sizeof(T)); + m_nSize--; + return TRUE; + } + void RemoveAll() { + if(m_nAllocSize > 0) { + free(m_aT); + m_aT = NULL; + m_nSize = 0; + m_nAllocSize = 0; + } + } + T &operator[] (int nIndex) const { + _ASSERTE(nIndex >= 0 && nIndex < m_nSize); + return m_aT[nIndex]; + } + T *GetData() const { return m_aT; } + void SetAtIndex(int nIndex,T &t) { + _ASSERTE(nIndex >= 0 && nIndex < m_nSize); + m_aT[nIndex] = t; + } + int Find(T &t) const { + for(int i = 0;i < m_nSize;i++) { + if(m_aT[i]==t) return i; + } + return -1; + } +}; + +class CMSPCritSection { +private: + CRITICAL_SECTION m_CritSec; +public: + CMSPCritSection() { InitializeCriticalSection(&m_CritSec); } + ~CMSPCritSection() { DeleteCriticalSection(&m_CritSec); } + void Lock() { EnterCriticalSection(&m_CritSec); } + WINBOOL TryLock() { return TryEnterCriticalSection(&m_CritSec); } + void Unlock() { LeaveCriticalSection(&m_CritSec); } +}; + +class CLock { +private: + CMSPCritSection &m_CriticalSection; +public: + CLock(CMSPCritSection &CriticalSection) : m_CriticalSection(CriticalSection) { + m_CriticalSection.Lock(); + } + ~CLock() { m_CriticalSection.Unlock(); } +}; + +class CCSLock { +private: + CRITICAL_SECTION *m_pCritSec; +public: + CCSLock(CRITICAL_SECTION *pCritSec) : m_pCritSec(pCritSec) { + EnterCriticalSection(m_pCritSec); + } + ~CCSLock() { LeaveCriticalSection(m_pCritSec); } +}; + +#ifndef CONTAINING_RECORD +#define CONTAINING_RECORD(address,type,field) ((type *)((PCHAR)(address) - (ULONG_PTR)(&((type *)0)->field))) +#endif + +#ifndef InitializeListHead +#define InitializeListHead(ListHead) ((ListHead)->Flink = (ListHead)->Blink = (ListHead)) +#define IsListEmpty(ListHead) ((ListHead)->Flink==(ListHead)) +#define RemoveHeadList(ListHead) (ListHead)->Flink; {RemoveEntryList((ListHead)->Flink)} +#define RemoveTailList(ListHead) (ListHead)->Blink; {RemoveEntryList((ListHead)->Blink)} +#define RemoveEntryList(Entry) { PLIST_ENTRY _EX_Blink; PLIST_ENTRY _EX_Flink; _EX_Flink = (Entry)->Flink; _EX_Blink = (Entry)->Blink; _EX_Blink->Flink = _EX_Flink; _EX_Flink->Blink = _EX_Blink; } +#define InsertTailList(ListHead,Entry) { PLIST_ENTRY _EX_Blink; PLIST_ENTRY _EX_ListHead; _EX_ListHead = (ListHead); _EX_Blink = _EX_ListHead->Blink; (Entry)->Flink = _EX_ListHead; (Entry)->Blink = _EX_Blink; _EX_Blink->Flink = (Entry); _EX_ListHead->Blink = (Entry); } +#define InsertHeadList(ListHead,Entry) { PLIST_ENTRY _EX_Flink; PLIST_ENTRY _EX_ListHead; _EX_ListHead = (ListHead); _EX_Flink = _EX_ListHead->Flink; (Entry)->Flink = _EX_Flink; (Entry)->Blink = _EX_ListHead; _EX_Flink->Blink = (Entry); _EX_ListHead->Flink = (Entry); } + +WINBOOL IsNodeOnList(PLIST_ENTRY ListHead,PLIST_ENTRY Entry); +#endif + +template <class T> ULONG MSPAddRefHelper (T *pMyThis) { + LOG((MSP_INFO,"MSPAddRefHelper - this = 0x%08x",pMyThis)); + typedef CComAggObject<T> AggClass; + AggClass *p = CONTAINING_RECORD(pMyThis,AggClass,m_contained); + return p->AddRef(); +} + +template <class T> ULONG MSPReleaseHelper (T *pMyThis) { + LOG((MSP_INFO,"MSPReleaseHelper - this = 0x%08x",pMyThis)); + typedef CComAggObject<T> AggClass; + AggClass *p = CONTAINING_RECORD(pMyThis,AggClass,m_contained); + return p->Release(); +} + +#include <objsafe.h> + +class CMSPObjectSafetyImpl : public IObjectSafety { +public: + CMSPObjectSafetyImpl() : m_dwSafety(0) { } + enum { + SUPPORTED_SAFETY_OPTIONS = INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA + }; + STDMETHOD(SetInterfaceSafetyOptions)(REFIID riid,DWORD dwOptionSetMask,DWORD dwEnabledOptions) { + if((~SUPPORTED_SAFETY_OPTIONS & dwOptionSetMask)!=0) return E_FAIL; + IUnknown *pUnk = NULL; + HRESULT hr = QueryInterface(riid,(void**)&pUnk); + if(SUCCEEDED(hr)) { + pUnk->Release(); + pUnk = NULL; + s_CritSection.Lock(); + m_dwSafety = (dwEnabledOptions & dwOptionSetMask) | (m_dwSafety & ~dwOptionSetMask); + s_CritSection.Unlock(); + } + return hr; + } + STDMETHOD(GetInterfaceSafetyOptions)(REFIID riid,DWORD *pdwSupportedOptions,DWORD *pdwEnabledOptions) { + if(IsBadWritePtr(pdwSupportedOptions,sizeof(DWORD)) || IsBadWritePtr(pdwEnabledOptions,sizeof(DWORD))) return E_POINTER; + *pdwSupportedOptions = 0; + *pdwEnabledOptions = 0; + IUnknown *pUnk = NULL; + HRESULT hr = QueryInterface(riid,(void**)&pUnk); + if(SUCCEEDED(hr)) { + pUnk->Release(); + pUnk = NULL; + *pdwSupportedOptions = SUPPORTED_SAFETY_OPTIONS; + s_CritSection.Lock(); + *pdwEnabledOptions = m_dwSafety; + s_CritSection.Unlock(); + } + return hr; + } +private: + DWORD m_dwSafety; + static CMSPCritSection s_CritSection; +}; + +#endif
diff --git a/mingw-w64-headers/include/nl_types.h b/mingw-w64-headers/include/nl_types.h new file mode 100755 index 0000000..0196d26 --- /dev/null +++ b/mingw-w64-headers/include/nl_types.h
@@ -0,0 +1,34 @@ +#ifndef _NL_TYPES_H +#define _NL_TYPES_H + +typedef enum { + CODESET, + D_T_FMT, + D_FMT, + T_FMT, + T_FMT_AMPM, + AM_STR, + PM_STR, + DAY_1, DAY_2, DAY_3, DAY_4, DAY_5, DAY_6, DAY_7, + ABDAY_1, ABDAY_2, ABDAY_3, ABDAY_4, ABDAY_5, ABDAY_6, ABDAY_7, + MON_1, MON_2, MON_3, MON_4, MON_5, MON_6, + MON_7, MON_8, MON_9, MON_10, MON_11, MON_12, + ABMON_1, ABMON_2, ABMON_3, ABMON_4, ABMON_5, ABMON_6, + ABMON_7, ABMON_8, ABMON_9, ABMON_10, ABMON_11, ABMON_12, + ERA, + ERA_D_FMT, + ERA_D_T_FMT, + ERA_T_FMT, + ALT_DIGITS, + RADIXCHAR, + THOUSEP, + YESEXPR, + NOEXPR, + CRNCYSTR +} nl_item; + +typedef void* nl_catd; + +enum { NL_SETD=0, NL_CAT_LOCALE=1 }; + +#endif
diff --git a/mingw-w64-headers/include/stddef.h b/mingw-w64-headers/include/stddef.h index 0d79996..4aeb0e7 100755 --- a/mingw-w64-headers/include/stddef.h +++ b/mingw-w64-headers/include/stddef.h
@@ -380,18 +380,6 @@ #undef __need_wchar_t #endif /* _STDDEF_H or __need_wchar_t. */ -#if defined (__need_wint_t) -#ifndef _WINT_T -#define _WINT_T - -#ifndef __WINT_TYPE__ -#define __WINT_TYPE__ unsigned int -#endif -typedef __WINT_TYPE__ wint_t; -#endif -#undef __need_wint_t -#endif - /* In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. are already defined. */ /* BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. */
diff --git a/mingw-w64-headers/include/stdio.h b/mingw-w64-headers/include/stdio.h index ad26151..b4468d8 100755 --- a/mingw-w64-headers/include/stdio.h +++ b/mingw-w64-headers/include/stdio.h
@@ -305,6 +305,8 @@ _CRTIMP int __cdecl _scwprintf(const wchar_t *_Format,...); int __cdecl vfwprintf(FILE *_File,const wchar_t *_Format,va_list _ArgList); int __cdecl vwprintf(const wchar_t *_Format,va_list _ArgList); + _CRTIMP int __cdecl swprintf(wchar_t*, const wchar_t*, ...); + _CRTIMP int __cdecl vswprintf(wchar_t*, const wchar_t*,va_list); _CRTIMP int __cdecl _swprintf_c(wchar_t *_DstBuf,size_t _SizeInWords,const wchar_t *_Format,...); _CRTIMP int __cdecl _vswprintf_c(wchar_t *_DstBuf,size_t _SizeInWords,const wchar_t *_Format,va_list _ArgList); _CRTIMP int __cdecl _snwprintf(wchar_t *_Dest,size_t _Count,const wchar_t *_Format,...);
diff --git a/mingw-w64-headers/include/tchar.h b/mingw-w64-headers/include/tchar.h index 8f542ba..ba6ce5b 100755 --- a/mingw-w64-headers/include/tchar.h +++ b/mingw-w64-headers/include/tchar.h
@@ -138,7 +138,7 @@ #define _ftprintf_l _fwprintf_l #define _ftprintf_p _fwprintf_p #define _ftprintf_p_l _fwprintf_p_l -#define _stprintf _swprintf +#define _stprintf swprintf #define _stprintf_l __swprintf_l #define _stprintf_p _swprintf_p #define _stprintf_p_l _swprintf_p_l @@ -156,7 +156,7 @@ #define _vftprintf_l _vfwprintf_l #define _vftprintf_p _vfwprintf_p #define _vftprintf_p_l _vfwprintf_p_l -#define _vstprintf _vswprintf +#define _vstprintf vswprintf #define _vstprintf_l _vswprintf_l #define _vstprintf_p _vswprintf_p #define _vstprintf_p_l _vswprintf_p_l
diff --git a/mingw-w64-headers/include/w32api.h b/mingw-w64-headers/include/w32api.h new file mode 100755 index 0000000..40d83d1 --- /dev/null +++ b/mingw-w64-headers/include/w32api.h
@@ -0,0 +1,52 @@ +#ifndef _W32API_H +#define _W32API_H +#define _W32API_H_ +#if __GNUC__ >=3 +#pragma GCC system_header +#endif + +#define __W32API_VERSION 3.10 +#define __W32API_MAJOR_VERSION 3 +#define __W32API_MINOR_VERSION 10 + +/* The following defines are for documentation purposes. The following defines + * identify the versions of Windows and Internet Explorer. They are not to be + * used in the w32api library but may be used by a user to set the _WIN32_WINNT + * or _WIN32_WINDOWS and the WINVER values to their minimum level of support. + * + * Similarly the user can use the Internet Explorer values to set the _WIN32_IE + * value to their minimum level of support. + */ + +/* Use these values to set _WIN32_WINDOWS and WINVER to your minimum support + * level */ +#define Windows95 0x0400 +#define Windows98 0x0410 +#define WindowsME 0x0500 + +/* Use these values to set _WIN32_WINNT and WINVER to your mimimum support + * level. */ +#define WindowsNT4 0x0400 +#define Windows2000 0x0500 +#define WindowsXP 0x0501 +#define Windows2003 0x0502 +#define WindowsVista 0x0600 + +/* Use these values to set _WIN32_IE to your minimum support level */ +#define IE3 0x0300 +#define IE301 0x0300 +#define IE302 0x0300 +#define IE4 0x0400 +#define IE401 0x0401 +#define IE5 0x0500 +#define IE5a 0x0500 +#define IE5b 0x0500 +#define IE501 0x0501 +#define IE55 0x0501 +#define IE56 0x0560 +#define IE6 0x0600 +#define IE601 0x0601 +#define IE602 0x0603 +#define IE7 0x0700 + +#endif /* ndef _W32API_H */
diff --git a/mingw-w64-headers/include/wchar.h b/mingw-w64-headers/include/wchar.h index 3bf3753..a708a3a 100755 --- a/mingw-w64-headers/include/wchar.h +++ b/mingw-w64-headers/include/wchar.h
@@ -530,6 +530,8 @@ _CRTIMP int __cdecl _scwprintf(const wchar_t *_Format,...); int __cdecl vfwprintf(FILE *_File,const wchar_t *_Format,va_list _ArgList); int __cdecl vwprintf(const wchar_t *_Format,va_list _ArgList); + _CRTIMP int __cdecl swprintf(wchar_t*, const wchar_t*, ...); + _CRTIMP int __cdecl vswprintf(wchar_t*, const wchar_t*,va_list); _CRTIMP int __cdecl _swprintf_c(wchar_t *_DstBuf,size_t _SizeInWords,const wchar_t *_Format,...); _CRTIMP int __cdecl _vswprintf_c(wchar_t *_DstBuf,size_t _SizeInWords,const wchar_t *_Format,va_list _ArgList); _CRTIMP int __cdecl _snwprintf(wchar_t *_Dest,size_t _Count,const wchar_t *_Format,...);
diff --git a/mingw-w64-headers/include/winsock2.h b/mingw-w64-headers/include/winsock2.h index 916c037..3360217 100755 --- a/mingw-w64-headers/include/winsock2.h +++ b/mingw-w64-headers/include/winsock2.h
@@ -3,6 +3,7 @@ * This file is part of the w64 mingw-runtime package. * No warranty is given; refer to the file DISCLAIMER within this package. */ + #ifndef _WINSOCK2API_ #define _WINSOCK2API_
diff --git a/mingw-w64-headers/include/wmiatlprov.h b/mingw-w64-headers/include/wmiatlprov.h new file mode 100755 index 0000000..db479bd --- /dev/null +++ b/mingw-w64-headers/include/wmiatlprov.h
@@ -0,0 +1,355 @@ +#ifndef __ATLWMIPROV_H__ +#define __ATLWMIPROV_H__ + +#ifndef __cplusplus +#error Requires C++ compilation (use a .cpp suffix) +#endif + +#ifndef __wbemprov_h__ +#include <wbemprov.h> +#endif + +#ifndef __wmiutils_h__ +#include <wmiutils.h> +#endif + +namespace ATL { + class ATL_NO_VTABLE IWbemInstProviderImpl : public IWbemServices,public IWbemProviderInit { + public: + HRESULT WINAPI OpenNamespace(const BSTR Namespace,long lFlags,IWbemContext *pCtx,IWbemServices **ppWorkingNamespace,IWbemCallResult **ppResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI CancelAsyncCall(IWbemObjectSink *pSink) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI QueryObjectSink(long lFlags,IWbemObjectSink **ppResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI GetObject(const BSTR ObjectPath,long lFlags,IWbemContext *pCtx,IWbemClassObject **ppObject,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI PutClass(IWbemClassObject *pObject,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI PutClassAsync(IWbemClassObject *pObject,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI DeleteClass(const BSTR Class,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI DeleteClassAsync(const BSTR Class,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI CreateClassEnum(const BSTR Superclass,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI CreateClassEnumAsync(const BSTR Superclass,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI PutInstance(IWbemClassObject *pInst,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI DeleteInstance(const BSTR ObjectPath,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI CreateInstanceEnum(const BSTR Class,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI ExecQuery(const BSTR QueryLanguage,const BSTR Query,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI ExecNotificationQuery(const BSTR QueryLanguage,const BSTR Query,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI ExecNotificationQueryAsync(const BSTR QueryLanguage,const BSTR Query,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI ExecMethod(const BSTR strObjectPath,const BSTR strMethodName,long lFlags,IWbemContext *pCtx,IWbemClassObject *pInParams,IWbemClassObject **ppOutParams,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + HRESULT WINAPI ExecMethodAsync(const BSTR strObjectPath,const BSTR strMethodName,long lFlags,IWbemContext *pCtx,IWbemClassObject *pInParams,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + }; + + class CProviderHelper { + private: + CComPtr<IWbemClassObject> m_pErrorObject; + HRESULT m_hr; + public: + CProviderHelper(IWbemServices *pNamespace,IWbemContext *pCtx) { + m_hr = WBEM_E_FAILED; + m_pErrorObject = NULL; + if(!pNamespace) { + m_hr = WBEM_E_INVALID_PARAMETER; + ATLASSERT (0); + return; + } + BSTR bstrString = SysAllocString(L"__ExtendedStatus"); + if(!bstrString) { + m_hr = WBEM_E_OUT_OF_MEMORY; + return; + } + m_hr = pNamespace->GetObject(bstrString,0,pCtx,&m_pErrorObject,NULL); + SysFreeString(bstrString); + return; + } + virtual ~CProviderHelper() { } + HRESULT WINAPI ConstructErrorObject (const ULONG ulStatusCode,const BSTR bstrDescription,const BSTR bstrOperation,const BSTR bstrParameter,const BSTR bstrProviderName,IWbemClassObject **ppErrorObject) { + static const LPWSTR lpwstrDescription = L"Description"; + static const LPWSTR lpwstrOperation = L"Operation"; + static const LPWSTR lpwstrStatusCode = L"StatusCode"; + static const LPWSTR lpwstrParameterInfo = L"ParameterInfo"; + static const LPWSTR lpwstrProviderName = L"ProviderName"; + + if(FAILED (m_hr)) { + ATLASSERT (0); + return m_hr; + } + if(!ppErrorObject) { + ATLASSERT (0); + return WBEM_E_INVALID_PARAMETER; + } + HRESULT hr = m_pErrorObject->SpawnInstance(0,ppErrorObject); + if(FAILED(hr)) return hr; + VARIANT var; + VariantInit(&var); + var.vt = VT_I4; + var.lVal = ulStatusCode; + hr = (*ppErrorObject)->Put(lpwstrStatusCode,0,&var,0); + if(FAILED(hr)) return hr; + var.vt = VT_BSTR; + if(bstrDescription!=NULL) { + var.bstrVal = bstrDescription; + hr = (*ppErrorObject)->Put(lpwstrDescription,0,&var,0); + if(FAILED(hr)) return hr; + } + if(bstrOperation!=NULL) { + var.bstrVal = bstrOperation; + hr = (*ppErrorObject)->Put(lpwstrOperation,0,&var,0); + if(FAILED(hr)) return hr; + } + if(bstrParameter!=NULL) { + var.bstrVal = bstrParameter; + hr = (*ppErrorObject)->Put(lpwstrParameterInfo,0,&var,0); + if(FAILED(hr)) return hr; + } + if(bstrProviderName!=NULL) { + var.bstrVal = bstrProviderName; + hr = (*ppErrorObject)->Put(lpwstrProviderName,0,&var,0); + if(FAILED(hr)) return hr; + } + return hr; + } + }; + + class CIntrinsicEventProviderHelper : public CProviderHelper { + private: + CComPtr<IWbemClassObject> m_pCreationEventClass; + CComPtr<IWbemClassObject> m_pDeletionEventClass; + CComPtr<IWbemClassObject> m_pModificationEventClass; + HRESULT m_hr; + public: + CIntrinsicEventProviderHelper(IWbemServices *pNamespace,IWbemContext *pCtx) : CProviderHelper (pNamespace,pCtx) { + m_hr = WBEM_E_FAILED; + if(!pNamespace || !pCtx) { + m_hr = WBEM_E_INVALID_PARAMETER; + ATLASSERT (0); + return; + } + m_pCreationEventClass = NULL; + m_pModificationEventClass = NULL; + m_pDeletionEventClass = NULL; + BSTR bstrString = SysAllocString(L"__InstanceCreationEvent"); + if(!bstrString) { + m_hr = WBEM_E_OUT_OF_MEMORY; + return; + } + m_hr = pNamespace->GetObject(bstrString,0,pCtx,&m_pCreationEventClass,NULL); + SysFreeString(bstrString); + bstrString=NULL; + if(FAILED(m_hr)) return; + bstrString = SysAllocString(L"__InstanceModificationEvent"); + if(!bstrString) { + m_hr = WBEM_E_OUT_OF_MEMORY; + return; + } + m_hr = pNamespace->GetObject(bstrString,0,pCtx,&m_pModificationEventClass,NULL); + SysFreeString(bstrString); + bstrString=NULL; + if(FAILED(m_hr)) return; + bstrString = SysAllocString(L"__InstanceDeletionEvent"); + if(!bstrString) { + m_hr = WBEM_E_OUT_OF_MEMORY; + return; + } + m_hr = pNamespace->GetObject(bstrString,0,pCtx,&m_pDeletionEventClass,NULL); + SysFreeString(bstrString); + bstrString=NULL; + if(FAILED(m_hr)) return; + return; + } + virtual ~CIntrinsicEventProviderHelper() { } + HRESULT WINAPI FireCreationEvent(IWbemClassObject *pNewInstance,IWbemObjectSink *pSink) { + if(FAILED(m_hr)) { + ATLASSERT (0); + return m_hr; + } + if(!pNewInstance || !pSink) { + ATLASSERT (0); + return WBEM_E_INVALID_PARAMETER; + } + CComPtr<IWbemClassObject> pEvtInstance; + HRESULT hr = m_pCreationEventClass->SpawnInstance(0,&pEvtInstance); + if(FAILED(hr)) return hr; + VARIANT var; + VariantInit(&var); + var.vt = VT_UNKNOWN; + CComQIPtr<IUnknown,&IID_IUnknown>pTemp(pNewInstance); + var.punkVal = pTemp; + hr = pEvtInstance->Put(L"TargetInstance",0,&var,0); + if(FAILED(hr)) return hr; + IWbemClassObject *_pEvtInstance = (IWbemClassObject*)pEvtInstance; + return pSink->Indicate(1,&_pEvtInstance); + } + HRESULT WINAPI FireDeletionEvent(IWbemClassObject *pInstanceToDelete,IWbemObjectSink *pSink) { + if(FAILED (m_hr)) { + ATLASSERT (0); + return m_hr; + } + if(!pInstanceToDelete || !pSink) { + ATLASSERT (0); + return WBEM_E_INVALID_PARAMETER; + } + CComPtr<IWbemClassObject> pEvtInstance; + HRESULT hr = m_pDeletionEventClass->SpawnInstance(0,&pEvtInstance); + if(FAILED(hr)) return hr; + VARIANT var; + VariantInit(&var); + var.vt = VT_UNKNOWN; + CComQIPtr<IUnknown,&IID_IUnknown>pTemp(pInstanceToDelete); + var.punkVal = pTemp; + hr = pEvtInstance->Put(L"TargetInstance",0,&var,0); + if(FAILED(hr)) return hr; + IWbemClassObject *_pEvtInstance = (IWbemClassObject*)pEvtInstance; + return pSink->Indicate(1,&_pEvtInstance); + } + HRESULT WINAPI FireModificationEvent(IWbemClassObject *pOldInstance,IWbemClassObject *pNewInstance,IWbemObjectSink *pSink) { + if(FAILED (m_hr)) { + ATLASSERT (0); + return m_hr; + } + if(!pOldInstance || !pNewInstance || !pSink) { + ATLASSERT (0); + return WBEM_E_INVALID_PARAMETER; + } + CComPtr<IWbemClassObject> pEvtInstance; + HRESULT hr = m_pModificationEventClass->SpawnInstance(0,&pEvtInstance); + if(FAILED(hr)) return hr; + VARIANT var; + VariantInit(&var); + var.vt = VT_UNKNOWN; + CComQIPtr<IUnknown,&IID_IUnknown>pTempNew(pNewInstance); + var.punkVal = pTempNew; + hr = pEvtInstance->Put(L"TargetInstance",0,&var,0); + if(FAILED(hr)) return hr; + CComQIPtr<IUnknown,&IID_IUnknown>pTempOld(pOldInstance); + var.punkVal = pTempOld; + hr = pEvtInstance->Put(L"PreviousInstance",0,&var,0); + if(FAILED(hr)) return hr; + IWbemClassObject *_pEvtInstance = (IWbemClassObject*)pEvtInstance; + return pSink->Indicate(1,&_pEvtInstance); + } + }; + + class CInstanceProviderHelper : public CProviderHelper { + public: + CInstanceProviderHelper (IWbemServices *pNamespace,IWbemContext *pCtx) : CProviderHelper (pNamespace,pCtx) { } + virtual ~CInstanceProviderHelper() { } + HRESULT WINAPI CheckInstancePath(IClassFactory *pParserFactory,const BSTR ObjectPath,const BSTR ClassName,ULONGLONG ullTest) { + if(!pParserFactory) { + ATLASSERT (0); + return WBEM_E_INVALID_PARAMETER; + } + CComPtr<IWbemPath>pPath; + HRESULT hr = pParserFactory->CreateInstance(NULL,IID_IWbemPath,(void **) &pPath); + if(FAILED(hr)) return WBEM_E_INVALID_PARAMETER; + hr = pPath->SetText(WBEMPATH_CREATE_ACCEPT_ALL,ObjectPath); + if(FAILED(hr)) return hr; + unsigned int nPathLen = SysStringLen(ObjectPath); + if(nPathLen >= (unsigned long)(-1)) return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); + unsigned long ulBufLen = (unsigned long)(nPathLen + 1); + WCHAR *wClass = new WCHAR[ulBufLen]; + if(!wClass) return WBEM_E_OUT_OF_MEMORY; + hr = pPath->GetClassName(&ulBufLen,wClass); + if(FAILED(hr)) { + delete[] wClass; + return hr; + } + DWORD lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT); + if(CSTR_EQUAL!=CompareStringW(lcid,NORM_IGNORECASE,ClassName,-1,wClass,-1)) { + delete[] wClass; + return WBEM_E_NOT_FOUND; + } + delete[] wClass; + unsigned __int64 ullPathInfo; + hr = pPath->GetInfo(0L,&ullPathInfo); + if(FAILED(hr)) return hr; + if(!(ullPathInfo & ullTest)) return WBEM_E_INVALID_OBJECT_PATH; + return WBEM_S_NO_ERROR; + } + }; + + template <class T> class ATL_NO_VTABLE IWbemPullClassProviderImpl : public IWbemServices,public IWbemProviderInit { + public: + virtual HRESULT WINAPI OpenNamespace(const BSTR strNamespace,long lFlags,IWbemContext *pCtx,IWbemServices **ppWorkingNamespace,IWbemCallResult **ppResult){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI CancelAsyncCall(IWbemObjectSink *pSink){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI QueryObjectSink(long lFlags,IWbemObjectSink **ppResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI GetObject(const BSTR strObjectPath,long lFlags,IWbemContext *pCtx,IWbemClassObject **ppObject,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI PutClass(IWbemClassObject *pObject,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI DeleteClass(const BSTR strClass,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI CreateClassEnum(const BSTR strSuperclass,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI PutInstance(IWbemClassObject *pInst,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI PutInstanceAsync(IWbemClassObject *pInst,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI DeleteInstance(const BSTR strObjectPath,long lFlags,IWbemContext *pCtx,IWbemCallResult **ppCallResult){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI DeleteInstanceAsync(const BSTR strObjectPath,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler){return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI CreateInstanceEnum(const BSTR strClass,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI CreateInstanceEnumAsync(const BSTR strClass,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI ExecQuery(const BSTR strQueryLanguage,const BSTR strQuery,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI ExecNotificationQuery(const BSTR strQueryLanguage,const BSTR strQuery,long lFlags,IWbemContext *pCtx,IEnumWbemClassObject **ppEnum) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI ExecNotificationQueryAsync(const BSTR strQueryLanguage,const BSTR strQuery,long lFlags,IWbemContext *pCtx,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI ExecMethod(const BSTR strObjectPath,const BSTR strMethodName,long lFlags,IWbemContext *pCtx,IWbemClassObject *pInParams,IWbemClassObject **ppOutParams,IWbemCallResult **ppCallResult) {return WBEM_E_NOT_SUPPORTED;}; + virtual HRESULT WINAPI ExecMethodAsync(const BSTR strObjectPath,const BSTR strMethodName,long lFlags,IWbemContext *pCtx,IWbemClassObject *pInParams,IWbemObjectSink *pResponseHandler) {return WBEM_E_NOT_SUPPORTED;}; + }; + + class CImpersonateClientHelper { + private: + WINBOOL m_bImpersonate; + public: + CImpersonateClientHelper() { m_bImpersonate = FALSE; } + ~CImpersonateClientHelper() { + if(m_bImpersonate) + CoRevertToSelf(); + } + HRESULT ImpersonateClient() { + HRESULT hr = S_OK; + if(SUCCEEDED(hr = CoImpersonateClient())) m_bImpersonate = TRUE; + return hr; + } + HRESULT GetCurrentImpersonationLevel (DWORD & a_Level) { + DWORD t_ImpersonationLevel = RPC_C_IMP_LEVEL_ANONYMOUS; + HANDLE t_ThreadToken = NULL; + HRESULT t_Result = S_OK; + if(SUCCEEDED(t_Result = CoImpersonateClient())) { + WINBOOL t_Status = OpenThreadToken (GetCurrentThread() ,TOKEN_QUERY,TRUE,&t_ThreadToken); + if(t_Status) { + SECURITY_IMPERSONATION_LEVEL t_Level = SecurityAnonymous; + DWORD t_Returned = 0; + t_Status = GetTokenInformation (t_ThreadToken ,TokenImpersonationLevel ,&t_Level ,sizeof(SECURITY_IMPERSONATION_LEVEL),&t_Returned); + CloseHandle (t_ThreadToken); + if(t_Status==FALSE) { + t_Result = MAKE_HRESULT(SEVERITY_ERROR,FACILITY_WIN32,GetLastError()); + } else { + switch(t_Level) { + case SecurityAnonymous: + { + t_ImpersonationLevel = RPC_C_IMP_LEVEL_ANONYMOUS; + } + break; + case SecurityIdentification: + { + t_ImpersonationLevel = RPC_C_IMP_LEVEL_IDENTIFY; + } + break; + case SecurityImpersonation: + { + t_ImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE; + } + break; + case SecurityDelegation: + { + t_ImpersonationLevel = RPC_C_IMP_LEVEL_DELEGATE; + } + break; + default: + { + t_Result = MAKE_HRESULT(SEVERITY_ERROR,FACILITY_WIN32,E_UNEXPECTED); + } + break; + } + } + } else { + t_Result = MAKE_HRESULT(SEVERITY_ERROR,FACILITY_WIN32,GetLastError()); + } + CoRevertToSelf(); + } + a_Level = t_ImpersonationLevel; + return t_Result; + } + }; +} +#endif
diff --git a/mingw-w64-headers/include/ws2tcpip.h b/mingw-w64-headers/include/ws2tcpip.h index 3b3cd34..0e7dca4 100755 --- a/mingw-w64-headers/include/ws2tcpip.h +++ b/mingw-w64-headers/include/ws2tcpip.h
@@ -3,14 +3,22 @@ * This file is part of the w64 mingw-runtime package. * No warranty is given; refer to the file DISCLAIMER within this package. */ -#ifndef _WS2TCPIP_H_ -#define _WS2TCPIP_H_ +#ifndef _WS2TCPIP_H +#define _WS2TCPIP_H +#if __GNUC__ >=3 +#pragma GCC system_header +#endif + +#if (defined _WINSOCK_H && !defined _WINSOCK2_H) +#error "ws2tcpip.h is not compatible with winsock.h. Include winsock2.h instead." +#endif +/** struct ip_mreq { struct in_addr imr_multiaddr; struct in_addr imr_interface; }; - +*/ struct ip_mreq_source { struct in_addr imr_multiaddr; struct in_addr imr_sourceaddr;