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;