1 files changed, 500 insertions, 0 deletions
diff --git a/private/oleauto/src/dispatch/evstub.cpp b/private/oleauto/src/dispatch/evstub.cpp
new file mode 100644
index 000000000..7989c31ca
--- /dev/null
+++ b/private/oleauto/src/dispatch/evstub.cpp
@@ -0,0 +1,500 @@
+/*** 
+*evstub.cpp
+*
+*  Copyright (C) 1992, Microsoft Corporation.  All Rights Reserved.
+*  Information Contained Herein Is Proprietary and Confidential.
+*
+*Purpose:
+*  This module implements the IEnumVARIANT stub class.
+*
+*Revision History:
+*
+* [00]	06-Dec-92 bradlo: Created.
+*
+*Implementation Notes:
+*
+*****************************************************************************/
+
+#include "oledisp.h"
+
+#ifndef WIN32
+#include <cobjps.h>
+#endif //!WIN32
+
+#include "dispmrsh.h"
+#include "evps.h"
+
+ASSERTDATA
+
+CStubEnumVARIANT::CStubEnumVARIANT()
+{
+    m_refs = 0;
+    m_punk = NULL;
+    m_penum = NULL;
+}
+
+CStubEnumVARIANT::~CStubEnumVARIANT()
+{
+    Disconnect();
+}
+
+
+HRESULT
+CStubEnumVARIANT::Create(IUnknown FAR* punkServer, ISTUB FAR* FAR* ppstub)
+{
+    CStubEnumVARIANT FAR* pstub;
+
+    if(pstub = new FAR CStubEnumVARIANT()){
+      pstub->m_refs = 1;
+      *ppstub = pstub;
+      if (punkServer)
+        return pstub->Connect(punkServer);
+      return NOERROR;
+    }
+    return RESULT(E_OUTOFMEMORY);
+}
+
+
+//---------------------------------------------------------------------
+//                     IUnknown Methods
+//---------------------------------------------------------------------
+
+STDMETHODIMP
+CStubEnumVARIANT::QueryInterface(REFIID riid, void FAR* FAR* ppv)
+{
+    if(IsEqualIID(riid, IID_IUnknown)){
+      *ppv = this;
+    }else if(IsEqualIID(riid, IID_ISTUB)){
+      *ppv = this;
+    }else{
+      *ppv = NULL;	    
+      return RESULT(E_NOINTERFACE);
+    }
+    ++m_refs; 
+    return NOERROR;
+}
+
+
+STDMETHODIMP_(unsigned long)
+CStubEnumVARIANT::AddRef()
+{
+    return ++m_refs;
+}
+
+
+STDMETHODIMP_(unsigned long)
+CStubEnumVARIANT::Release()
+{
+    if(--m_refs == 0){
+      delete this;
+      return 0;
+    }
+    return m_refs;
+}
+
+
+//---------------------------------------------------------------------
+//                     IRpcStub Methods
+//---------------------------------------------------------------------
+
+
+STDMETHODIMP
+CStubEnumVARIANT::Connect(IUnknown FAR* punkObj)
+{
+#if (defined(WIN32) || defined(WOW))
+     ASSERT(m_punk == NULL && m_penum == NULL);
+     //This will keep the server object alive until we disconnect.
+     IfFailRet(punkObj->QueryInterface(IID_IEnumVARIANT, (void FAR* FAR*)&m_penum));
+     punkObj->AddRef();
+     m_punk = punkObj;
+     return NOERROR;
+#else	
+    if(m_punk)
+      return RESULT(E_FAIL); // call Disconnect first
+	      
+    if (punkObj) {
+      punkObj->AddRef();
+      m_punk = punkObj;
+    }
+    return NOERROR;
+#endif    
+}
+
+
+STDMETHODIMP_(void)
+CStubEnumVARIANT::Disconnect()
+{
+    if(m_punk){
+      m_punk->Release();
+      m_punk = NULL;
+    }
+    if(m_penum){
+      m_penum->Release();
+      m_penum = NULL;
+    }
+}
+
+
+/***
+*PRIVATE HRESULT DispatchNext(IEnumVARIANT FAR*, IStream*)
+*Purpose:
+*  Stub implementation of IEnumVARIANT::Next()
+*
+*  In:
+*    <unsigned long = celt>
+*
+*  Out:
+*    <HRESULT = return value>
+*    <unsigned long = pceltFetched>
+*    <VARIANT[] = rgvar[]>
+*
+*Entry:
+*  penum = the IEnumVARIANT* to dispatch on
+*  pstm = the stream containing the actuals
+*
+*Exit:
+*  return value = HRESULT
+*
+***********************************************************************/
+PRIVATE_(HRESULT)
+DispatchNext(IEnumVARIANT FAR* penum, IStream FAR* pstm)
+{
+    unsigned int i;
+    VARIANT FAR* rgvar;
+    unsigned long celt, celtFetched;
+    HRESULT hresult, hresultRet;
+    unsigned long _proxySysKind, _stubSysKind;
+    
+    IfFailGo(GET(pstm, _proxySysKind), LError0);
+
+    IfFailGo(GET(pstm, celt), LError0);
+
+    if((rgvar = new FAR VARIANT[(size_t)celt]) == NULL){
+      hresult = RESULT(E_OUTOFMEMORY);
+      goto LError0;
+    }
+
+    celtFetched = 0;
+    for(i = 0; i < celt; ++i)
+      VariantInit(&rgvar[i]);
+
+    hresultRet = penum->Next(celt, rgvar, &celtFetched);
+
+    IfFailGo(REWIND_STREAM(pstm), LError0);
+
+    IfFailGo(DispMarshalHresult(pstm, hresultRet), LError1);
+    
+    // only marshal the out params if the call succeeded.
+    //
+    if(SUCCEEDED(hresultRet)){
+
+    _stubSysKind = (unsigned long) SYS_CURRENT;
+      IfFailGo(PUT(pstm, _stubSysKind), LError1);
+	    
+      IfFailGo(PUT(pstm, celtFetched), LError1);
+
+      for(i = 0; i < celtFetched; ++i){
+	IfFailGo(VariantWrite(pstm, &rgvar[i], (SYSKIND) _proxySysKind), LError1);
+      }
+    }
+
+    hresult = NOERROR;
+
+LError1:;
+    for(i = 0; i < celtFetched; ++i)
+      VariantClear(&rgvar[i]);
+
+    delete rgvar;
+
+LError0:;
+    return hresult;
+}
+
+
+/***
+*PRIVATE HRESULT DispatchSkip(IEnumVARIANT*, IStream*)
+*Purpose:
+*  Stub implementation of IEnumVARIANT::Skip()
+*
+*  In:
+*    <unsigned long = celt>
+*
+*  Out:
+*    <HRESULT = return value>
+*
+*Entry:
+*  penum = the IEnumVARIANT* to dispatch on
+*  pstm = the stream containing the actuals
+*
+*Exit:
+*  return value = HRESULT
+*
+***********************************************************************/
+PRIVATE_(HRESULT)
+DispatchSkip(IEnumVARIANT FAR* penum, IStream FAR* pstm)
+{
+    unsigned long celt;
+    HRESULT hresult, hresultRet;
+
+
+    IfFailGo(GET(pstm, celt), LError0);
+
+    hresultRet = penum->Skip(celt);
+
+    IfFailGo(REWIND_STREAM(pstm), LError0);
+
+    IfFailGo(DispMarshalHresult(pstm, hresultRet), LError0);
+
+    hresult = NOERROR;
+
+LError0:;
+    return hresult;
+}
+
+
+/***
+*PRIVATE HRESULT DispatchReset(IEnumVARIANT*, IStream*)
+*Purpose:
+*  Stub implementation of IEnumVARIANT::Reset()
+*
+*  In:
+*    None
+*
+*  Out:
+*    <HRESULT = return value>
+*
+*Entry:
+*  penum = the IEnumVARIANT* to dispatch on
+*  pstm = the stream containing the actuals
+*
+*Exit:
+*  return value = HRESULT
+*
+***********************************************************************/
+PRIVATE_(HRESULT)
+DispatchReset(IEnumVARIANT FAR* penum, IStream FAR* pstm)
+{
+    HRESULT hresultRet;
+
+    hresultRet = penum->Reset();
+    
+    REWIND_STREAM(pstm);
+
+    return DispMarshalHresult(pstm, hresultRet);
+}
+
+
+/***
+*PRIVATE HRESULT DispatchClone(IEnumVARIANT*, IStream*)
+*Purpose:
+*  Stub implementation of IEnumVARIANT::Clone()
+*
+*  In:
+*    None
+*
+*  Out:
+*    <HRESULT = return value>
+*    <IEnumVARIANT = cloned enum>
+*    
+*Entry:
+*  penum = the IEnumVARIANT* to dispatch on
+*  pstm = the stream containing the actuals
+*
+*Exit:
+*  return value = HRESULT
+*
+***********************************************************************/
+PRIVATE_(HRESULT)
+DispatchClone(IEnumVARIANT FAR* penum, IStream FAR* pstm)
+{
+    HRESULT hresult, hresultRet;
+    IEnumVARIANT FAR* penumClone;
+
+
+    hresultRet = penum->Clone(&penumClone);
+
+    REWIND_STREAM(pstm);
+    
+    IfFailGo(DispMarshalHresult(pstm, hresultRet), LError0);
+
+    // dont bother marshaling the interface if the call failed.
+    if(SUCCEEDED(hresultRet)){
+      hresult =  DispMarshalInterface(pstm, IID_IEnumVARIANT, penumClone);
+    }
+
+LError0:;
+    return hresult;
+}
+
+
+/***
+*PUBLIC HRESULT CStubEnumVARIANT::Invoke(REFIID, int, IStream*, unsigned long, void*)
+*
+*Purpose:
+*  Dispatch the method with the given index (iMethod) on the given
+*  interface, using the arguments serialized in the given stream.
+*
+*  This function is the callee side of an LRPC call.
+*
+*Entry:
+*  iid = the IID of the interface on which we are to make the call
+*  iMethod = the method index
+*  pstm = the IStream containing the method's actuals
+*
+*Exit:
+*  return value = HRESULT
+*
+***********************************************************************/
+STDMETHODIMP
+CStubEnumVARIANT::Invoke(
+#if (OE_WIN32 || defined(WOW))
+    RPCOLEMESSAGE *pMessage, 
+    ICHANNEL *pRpcChannel)
+{
+    HRESULT hresult;		
+    IStream FAR* pstm;	    
+
+    if(!m_punk)
+      return RESULT(E_FAIL);
+
+    OPEN_STUB_STREAM(pstm, pRpcChannel, pMessage, IID_IEnumVARIANT);
+
+#else
+    REFIID riid,
+    int iMethod,
+    IStream FAR* pstm,
+    unsigned long dwDestCtx,
+    void FAR* pvDestCtx)
+{
+    HRESULT hresult;	
+    
+    UNUSED(dwDestCtx);
+    UNUSED(pvDestCtx);
+
+    if(!IsEqualIID(riid, IID_IEnumVARIANT))
+      return RESULT(E_NOINTERFACE);
+
+    if(!m_punk)
+      return RESULT(E_FAIL);
+
+    if(m_penum == NULL)
+      IfFailRet(m_punk->QueryInterface(IID_IEnumVARIANT, (void FAR* FAR*)&m_penum));
+
+#endif
+
+    switch(GET_IMETHOD(pMessage)){
+      case IMETH_ENUMVARIANT_NEXT:
+        hresult = DispatchNext(m_penum, pstm);
+	break;
+	
+      case IMETH_ENUMVARIANT_SKIP:
+        hresult = DispatchSkip(m_penum, pstm);
+	break;
+	
+      case IMETH_ENUMVARIANT_RESET:
+        hresult = DispatchReset(m_penum, pstm);
+	break;
+	
+      case IMETH_ENUMVARIANT_CLONE:
+        hresult = DispatchClone(m_penum, pstm);
+	break;
+	
+      default:
+        hresult = INVALIDARG;
+	break;
+    }
+    
+    RESET_STREAM(pstm);
+    
+    DELETE_STREAM(pstm);
+    
+    return hresult;
+}
+
+
+/***
+*PUBLIC BOOL CStubEnumVARIANT::IsIIDSupported(REFIID)
+*
+*Purpose:
+*  Answer if the given IID is supported by this stub.
+*
+*Entry:
+*  iid = the IID to query for support
+*
+*Exit:
+*  return value = BOOL. TRUE if IID is supported, FALSE otherwise.
+*
+***********************************************************************/
+#if OE_MAC
+STDMETHODIMP_(unsigned long)
+#elif (OE_WIN32 || defined(WOW))
+STDMETHODIMP_(IRpcStubBuffer *)
+#else
+STDMETHODIMP_(BOOL)
+#endif
+CStubEnumVARIANT::IsIIDSupported(REFIID riid)
+{
+#if (OE_WIN32 || defined(WOW))
+    IRpcStubBuffer *pStub = 0;
+    if (IsEqualIID(riid, IID_IEnumVARIANT)) {
+      AddRef();
+      pStub = (IRpcStubBuffer *) this;
+    }
+    return pStub;
+#else
+	
+    // REVIEW: I don't understand this, but thats the way Ole does it...
+    if(m_punk == NULL)
+	return FALSE;
+
+    return(IsEqualIID(riid, IID_IEnumVARIANT));
+#endif    
+}
+
+
+/***
+*unsigned long CStubEnumVARIANT::CountRefs
+*Purpose:
+*  Return the count of references held by this stub.
+*
+*Entry:
+*  None
+*
+*Exit:
+*  return value = unsigned long, the count of references.
+*
+***********************************************************************/
+STDMETHODIMP_(unsigned long)
+CStubEnumVARIANT::CountRefs()
+{
+    unsigned long refs;
+
+    refs = 0;
+
+    if(m_punk != NULL)
+      ++refs;
+
+    if(m_penum != NULL)
+      ++refs;
+
+    return refs;
+}
+
+
+#if (OE_WIN32 || defined(WOW))
+
+STDMETHODIMP
+CStubEnumVARIANT::DebugServerQueryInterface(void FAR* FAR* ppv)
+{
+   *ppv = m_penum;
+   return S_OK;
+}
+
+
+STDMETHODIMP_(void)
+CStubEnumVARIANT::DebugServerRelease(void FAR* ppv)
+{
+
+}
+
+#endif