wsdlserv.cpp

Windows CE 6.0 Server 源码

                cb++;
            }
        }

        // now register ALL custom mappers, if ANY
        CHK(registerCustomMappers(pServiceNode));

        // now forward this to ALL ports...
        m_pPortsList->Reset();
        while(m_pPortsList->Next(1, (IWSDLPort**)&pPortDesc, &lFetched)==S_OK)
        {
            hr = pPortDesc->AddWSMLMetaInfo(pServiceNode, this,pWSDLDom,pWSMLDom, bLoadOnServer);
            if (FAILED(hr)) 
            {
                globalAddError(WSML_IDS_PORTINITFAILED, WSDL_IDS_SERVICE, hr, m_bstrName);                    
                goto Cleanup;
            }
            release(&pPortDesc);
        }

    }
    else
    {
        hr = E_INVALIDARG;
        goto Cleanup;
    }


Cleanup:
    release(&pPortDesc);
    ASSERT(hr==S_OK);
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CDispatchHolder *CWSDLService::GetDispatchHolder(TCHAR *pchID)
//
//  parameters:
//
//  description:
//        finds the correct dispatch holder
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
CDispatchHolder *CWSDLService::GetDispatchHolder(TCHAR *pchID)
{
    for (int i=0;i<m_cbDispatchHolders ;i++ )
    {
        if (wcscmp(pchID, m_pDispatchHolders[i]->m_bstrID)==0)
        {
            return(m_pDispatchHolders[i]);
            
        }
    }
    return(0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CDispatchHolder * CWSDLService::GetHeaderHandler(TCHAR *pchHeaderHandlerID)
//
//  parameters:
//      pchHeaderHandlerID -> can be 0, if so, servicelevel attribute is used
//  description:
//        finds the correct dispatch holder for a headerhandler
//          
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
CDispatchHolder * CWSDLService::GetHeaderHandler(TCHAR *pchHeaderHandlerID)
{
    if (pchHeaderHandlerID== 0)
    {
        pchHeaderHandlerID = m_bstrHeaderHandler;
    }            
    if (pchHeaderHandlerID)
    {
        return GetDispatchHolder(pchHeaderHandlerID);
    }
    return (0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CWSDLService::registerCustomMappers(IXMLDOMNode *pServiceNode)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CWSDLService::registerCustomMappers(IXMLDOMNode *pServiceNode)
{
    HRESULT hr; 
    CAutoRefc<IXMLDOMNodeList> pNodeList;
    CAutoRefc<IXMLDOMNode>   pNode; 
    CAutoBSTR                 bstrName;
    CAutoBSTR                 bstrNS;
    CAutoBSTR                 bstrUses;
    CAutoBSTR                 bstrNodeName;
    CAutoBSTR                 bstrIID; 
    CDispatchHolder             *pDispatchHolder;
    BOOL                      fElement;
    

    hr = _XPATHUtilFindNodeList(pServiceNode, _T(".//types/*"), &pNodeList);
    if (SUCCEEDED(hr))
    {
        // there are some type declarations
        while (((hr = pNodeList->nextNode(&pNode))==S_OK) && pNode!=0)
        {
            CHK(pNode->get_nodeName(&bstrNodeName));
            CHK(_WSDLUtilFindAttribute(pNode, _T("name"), &bstrName));
            CHK(_WSDLUtilFindAttribute(pNode, _T("targetNamespace"), &bstrNS));
            CHK(_WSDLUtilFindAttribute(pNode, _T("uses"), &bstrUses));

            // iid is optional, so ignore a failure for that one. 
            if (SUCCEEDED(_WSDLUtilFindAttribute(pNode, _T("iid"), &bstrIID)))
            {
                // let's try converting, so that we can fail if invalid object
                CLSID iid; 
                if (FAILED(CLSIDFromString(bstrIID, &iid)))
                {
                    globalAddError(WSML_IDS_CUSTOMMAPPERNOINTERFACE, WSDL_IDS_MAPPER, hr, bstrName, bstrNS);                
                    hr = E_INVALIDARG;
                    goto Cleanup;
                }
            }

            // if we have everything, we have a valid entry, assuming nodename is type/element

            if (_tcscmp(bstrNodeName, _T("element"))==0)
            {
                fElement = true;
            }
            else if (_tcscmp(bstrNodeName, _T("type"))==0)
            {
                fElement = false;
            }
            else
            {
                CHK(E_INVALIDARG);
            }
            // the dispatchholder holds the real progid
            pDispatchHolder = GetDispatchHolder(bstrUses);
            if (!pDispatchHolder)
            {
                globalAddError(WSML_IDS_CUSTOMMAPPERNOOBJECT, WSDL_IDS_MAPPER, hr, bstrUses);        
                hr = E_INVALIDARG;
                goto Cleanup;
            }
        
            if (fElement)
            {
                hr = m_pTypeFactory->addElementObjectMapper(bstrName, bstrNS, pDispatchHolder->getProgID(), bstrIID);                 
            }
            else
            {
                hr = m_pTypeFactory->addTypeObjectMapper(bstrName, bstrNS, pDispatchHolder->getProgID(), bstrIID);
            }
            if (FAILED(hr))
            {
                globalAddError(WSML_IDS_CUSTOMMAPPERNOINTERFACE, WSDL_IDS_MAPPER, hr, bstrName, bstrNS);                
                goto Cleanup;
            }
            

            pNode.Clear();
            bstrUses.Clear();
            bstrNS.Clear();
            bstrName.Clear();
            bstrNodeName.Clear();
            // remember that we created one
            m_bCustomMappersCreated = true;
        }
    }

    // if finding nodes failed means no custom mapper entries
    hr = S_OK;

Cleanup:
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////






/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDispatchHolder::GetDispatchPointer(IDispatch **ppDispatch)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDispatchHolder::GetDispatchPointer(IDispatch **ppDispatch)
{
    if (m_bCachable && m_gipDispatch.IsOK())
    {
        return m_gipDispatch.Localize(ppDispatch);
    }
    else
    {
        return CoCreateInstance(m_clsid, 0, CLSCTX_ALL, IID_IDispatch, (void**)ppDispatch);    
    }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDispatchHolder::GetHeaderPointer(IHeaderHandler **ppHeader)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDispatchHolder::GetHeaderPointer(IHeaderHandler **ppHeader)
{
    HRESULT hr;
    CAutoRefc<IDispatch> pDispatch;

    CHK(GetDispatchPointer(&pDispatch));
    CHK(pDispatch->QueryInterface(IID_IHeaderHandler, (void**)ppHeader));
    

Cleanup:
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDispatchHolder::GetProgID(BSTR *pbstrobjectProgID)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDispatchHolder::GetProgID(BSTR *pbstrobjectProgID)
{
    return _WSDLUtilReturnAutomationBSTR(pbstrobjectProgID, m_bstrProgID);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDispatchHolder::Init(void)
//
//  parameters:
//
//  description:
//      checks for the cachable attribute
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDispatchHolder::Init(void)
{
    HRESULT     hr = S_OK;
    LPOLESTR    p=0; 
    DWORD       dwType;
    DWORD       dwSize=_MAX_BUFFER_SIZE;
    CAutoRefc<IDispatch> pDispatch; 

#ifndef UNDER_CE
    TCHAR       achBuffer[_MAX_BUFFER_SIZE]; 
#else
    TCHAR       *achBuffer = new TCHAR[_MAX_BUFFER_SIZE]; 
    CHK_MEM(achBuffer);
#endif 

    hr = CLSIDFromProgID(m_bstrProgID, &m_clsid);
    if (FAILED(hr))
    {
        globalAddError(WSML_IDS_SERVICEINVALIDPROGID, WSDL_IDS_SERVICE, hr, m_bstrProgID);                        
        goto Cleanup;
    }
    
    if (m_bCachable)
    {
        CHkey        hKey; 
        // assume false
        m_bCachable = false; 

        // now as this is the first time, check if the component is boththreaded or freethreaded...
        // this is mainly done for VB, as the apartment model window dispatching will kill IIS
        CHK (StringFromCLSID(m_clsid, &p)); 
        wcscpy(achBuffer, _T("CLSID\\")); 
        wcscat(achBuffer, p); 
        wcscat(achBuffer, _T("\\InProcServer32")); 
        if (RegOpenKeyEx(HKEY_CLASSES_ROOT, achBuffer, 0, KEY_READ, &hKey.hkey)==ERROR_SUCCESS)
        {
            if (RegQueryValueEx(
                  hKey.hkey,            // handle to key
                  _T("ThreadingModel"),  // value name
                  0,   // reserved
                  &dwType,       // type buffer
                  (LPBYTE)achBuffer,        // data buffer
                  &dwSize      // size of data buffer
                )==ERROR_SUCCESS)
                {
                    
                 if (dwSize>0 && (wcsicmp(achBuffer, _T("Both"))==0 
                             || wcsicmp(achBuffer, _T("Free"))==0 
                             || wcsicmp(achBuffer, _T("Neutral"))==0))
                             {
                                // correct   
                                   m_bCachable = true;
                             }
                }
                            
        }
        else
        {
            // so assume an OUT of proc serve. Assume the server is able to handle
            // threading correctly
            m_bCachable = true;
        }
    }

    if (m_bCachable)
    {
        // if we are cachable, just go ahead and register the interface in the GID
        CHK(CoCreateInstance(m_clsid, 0, CLSCTX_ALL, IID_IDispatch, (void**)&pDispatch));
        CHK(m_gipDispatch.Globalize(pDispatch));
    }
    

Cleanup:
    if (p)
    {
        CoTaskMemFree(p);
    }
    
#ifdef UNDER_CE
   if(achBuffer)
        delete [] achBuffer;
#endif 
    return (hr);
    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////