upnp_proxy.h

Windows CE 6.0 Server 源码

        arrayIn[8] = x9;
            
        return invoke_action(pszAction, pRetval, *&arrayIn);
    }
    
    
    //////////////////////////////////////////////
    // get [out] parameters returned by the call
    //////////////////////////////////////////////
    
    // 1 [out] argument
    template<typename T1>
    bool get_results(T1 x1)
    {
        if(!validate(1))
            return false;
            
        return extract_arg(1, x1);
    }
    
    // 2 [out] arguments
    template<typename T1, typename T2>
    bool get_results(T1 x1, T2 x2)
    {
        if(!validate(2))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2);
    }
    
    // 3 [out] arguments
    template<typename T1, typename T2, typename T3>
    bool get_results(T1 x1, T2 x2, T3 x3)
    {
        if(!validate(3))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3);
    }
    
    // 4 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4)
    {
        if(!validate(4))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4);
    }
    
    // 5 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4, typename T5>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5)
    {
        if(!validate(5))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4) &&
               extract_arg(5, x5);
    }
    
    // 6 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6)
    {
        if(!validate(6))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4) &&
               extract_arg(5, x5) &&
               extract_arg(6, x6);
    }
    
    // 7 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7)
    {
        if(!validate(7))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4) &&
               extract_arg(5, x5) &&
               extract_arg(6, x6) &&
               extract_arg(7, x7);
    }
    
    // 8 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8)
    {
        if(!validate(8))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4) &&
               extract_arg(5, x5) &&
               extract_arg(6, x6) &&
               extract_arg(7, x7) &&
               extract_arg(8, x8);
    }
    
    // 9 [out] arguments
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
    bool get_results(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9)
    {
        if(!validate(9))
            return false;
            
        return extract_arg(1, x1) &&
               extract_arg(2, x2) &&
               extract_arg(3, x3) &&
               extract_arg(4, x4) &&
               extract_arg(5, x5) &&
               extract_arg(6, x6) &&
               extract_arg(7, x7) &&
               extract_arg(8, x8) &&
               extract_arg(9, x9);
    }

protected:
    //
    // invoke UPnP action
    //
    HRESULT invoke_action(LPCWSTR pszAction, VARIANT* pRetval, SAFEARRAY* pInArgs)
    {
        // this unlocks the safe array so that it can be destroyed by VariantClear (see below)
        m_arrayOut.destroy();
        
        HRESULT hr;
        
        hr = m_varOut.Clear();
        
        // if this failed we would leak memory!
        assert(SUCCEEDED(hr));
        
        if(!m_pService)
        {
            DEBUGMSG(ZONE_UPNP_PROXY_ERROR, (UPNP_PROXY_TEXT("Can't invoke action \"%s\", m_pService is NULL"), pszAction));
            return E_ABORT;
        }
        
        DEBUGMSG(ZONE_UPNP_PROXY_TRACE, (UPNP_PROXY_TEXT("Invoking action \"%s\""), pszAction));
        
        ce::auto_bstr   bstrAction;
        VARIANT         vInArgs; // don't clear vInArgs

#ifdef DEBUG
        m_strAction = pszAction;
#endif

        bstrAction = SysAllocString(pszAction);
        
        vInArgs.vt = VT_ARRAY | VT_VARIANT;
        vInArgs.parray = pInArgs;

        hr = m_pService->InvokeAction(bstrAction, vInArgs, &m_varOut, pRetval);
        
        if(FAILED(hr))
        {
            DEBUGMSG(ZONE_UPNP_PROXY_WARN, (UPNP_PROXY_TEXT("Action \"%s\" failed 0x%08x"), pszAction, hr));
        }
        
        return hr;
    }
    
    //
    // When caller passes NULL to get_results for unwanted [out] argument
    //
    bool extract_arg(int nArg, int pValue)
    {
        assert(pValue == NULL);
        return true;
    }
    
    
    //
    // get VT_BSTR [out] argument
    //
    template <unsigned _BUF_SIZE, class _Tr, class _Al>
    bool extract_arg(int nArg, ce::_string_t<wchar_t, _BUF_SIZE, _Tr, _Al>* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_BSTR))
        {        
            if(pValue)
                *pValue = pvar->bstrVal;
            return true;
        }
        
        return false;
    }
    
    //
    // get VT_I4 [out] argument
    //
    bool extract_arg(int nArg, long* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_I4))
        {        
            if(pValue)
                *pValue = pvar->lVal;
            return true;
        }
        
        return false;
    }
    
    //
    // get VT_UI4 [out] argument
    //
    bool extract_arg(int nArg, unsigned long* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_UI4))
        {        
            if(pValue)
                *pValue = pvar->ulVal;
            return true;
        }
        
        return false;
    }
    
    
    //
    // get VT_I2 [out] argument
    //
    bool extract_arg(int nArg, short* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_I2))
        {        
            if(pValue)
                *pValue = pvar->iVal;
            return true;
        }
        
        return false;
    }
    
    
    //
    // get VT_UI2 [out] argument
    //
    bool extract_arg(int nArg, unsigned short* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_UI2))
        {        
            if(pValue)
                *pValue = pvar->uiVal;
            return true;
        }
        
        return false;
    }
    
    
    //
    // get VT_BOOL [out] argument
    //
    bool extract_arg(int nArg, bool* pValue)
    {
        if(VARIANT* pvar = validate_arg(nArg, VT_BOOL))
        {        
            if(pValue)
                *pValue = (pvar->boolVal != VARIANT_FALSE);
            return true;
        }
        
        return false;
    }
    
    
    //
    // validate argument number nArg
    //
    VARIANT* validate_arg(int nArg, VARTYPE vt)
    {
        assert(m_arrayOut.size() >= nArg);
        
        VARIANT* pvar = &m_arrayOut[m_arrayOut.lbound() + nArg - 1];
        
        if(pvar->vt != vt)
        {
            DEBUGMSG(ZONE_UPNP_PROXY_ERROR, (UPNP_PROXY_TEXT("Action \"%s\": expected [out] argument %d to be of type %d but received type %d"), static_cast<LPCWSTR>(m_strAction), nArg, vt, pvar->vt));
            return NULL;
        }
        
        return pvar;
    }
    
    //
    // validate that call returned nArgs [out] arguments
    //
    bool validate(int nArgs)
    {
        // calling get_results after action failed or didn't return any out arguments
        assert(m_varOut.vt != VT_EMPTY);
        
        if(m_varOut.vt != (VT_ARRAY | VT_VARIANT))
        {
            DEBUGMSG(ZONE_UPNP_PROXY_ERROR, (UPNP_PROXY_TEXT("Action \"%s\": [out] arguments should be VT_ARRAY | VT_VARIANT"), static_cast<LPCWSTR>(m_strAction)));
            return false;
        }
        
        m_arrayOut.attach(m_varOut.parray);
        
        // lock the safe array so that validate_arg can return pointers to elements
        m_arrayOut.lock();
        
        if(m_arrayOut.size() != nArgs)
        {
            DEBUGMSG(ZONE_UPNP_PROXY_ERROR, (UPNP_PROXY_TEXT("Action \"%s\": expected %d [out] arguments but received %d"), static_cast<LPCWSTR>(m_strAction), nArgs, m_arrayOut.size()));
            return false;
        }
        
        return true;
    }

private:
    CComPtr<IUPnPService>                   m_pService;
    ce::variant                             m_varOut;
    ce::safe_array<ce::variant, VT_VARIANT> m_arrayOut;
#ifdef DEBUG    
    ce::wstring                             m_strAction;
#endif    
};

}


#endif // __UPNP_PROXY__