obex.cpp

Windows CE 6.0 Server 源码

        {
            DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::WaitForMultipleObject thread %d down\n", i));
        }
    }

    //enter lock
    gpSynch->Lock();  

    //make the thread array as empty
    _uiEnumThreadCnt = 0;
    _bStopEnum = FALSE;

    //exit lock and return
    gpSynch->Unlock();    
    return S_OK;
}

HRESULT STDMETHODCALLTYPE
CObex::EnumTransports(LPPROPERTYBAGENUM *ppTransportEnum)
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumTransports()\n"));
    HKEY hkey;
    DWORD dwRes;

    //bail if the property bag is null
    if (!ppTransportEnum)
        return E_INVALIDARG;

    gpSynch->Lock();

    //check to see if we are initialized 
    if (_stage != Initialized)
    {
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::XXX - Not yet initialized...()\n"));        
        gpSynch->Unlock();
        return OBEX_E_NOT_INITIALIZED;
    }
    
    *ppTransportEnum = 0;
    HRESULT hr = S_OK;
	
    CPropertyBagEnum *pPropBagEnum = new CPropertyBagEnum();
    if( !pPropBagEnum )
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }
	
    //open the key
    if ((ERROR_SUCCESS != (dwRes = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        k_szRegTransportKey, 0, KEY_QUERY_VALUE, &hkey)))) {         
        hr = E_FAIL;
        goto done;
    }
    
    DWORD dwIndex = 0;
    WCHAR lpName[MAX_PATH];
    DWORD cbName;
    LONG lregRetVal;
    
    do
    {       
        cbName = MAX_PATH;
        
        lregRetVal = RegEnumKeyEx(hkey,dwIndex,lpName,&cbName,NULL,NULL,NULL,NULL); 
        
        if(ERROR_SUCCESS == lregRetVal)
        {
            CPropertyBag *pPropBag = new CPropertyBag();
	     if( !pPropBag )
	     {
                RegCloseKey(hkey); 
                hr = E_OUTOFMEMORY;
                goto done;
	     }
            VARIANT var;
            VariantInit(&var);
            var.vt = VT_BSTR;
            var.bstrVal = SysAllocString(lpName);
            pPropBag->Write(L"GUID", &var);
            VariantClear(&var);
            
            pPropBagEnum->Insert(pPropBag);
            pPropBag->Release();
            DEBUGMSG(OBEX_COBEX_ZONE, (L"Found transport: %s\n", lpName));
        }
        
        dwIndex ++;
    } while(ERROR_SUCCESS == lregRetVal);

    RegCloseKey(hkey); 

done:
    *ppTransportEnum = pPropBagEnum;
    gpSynch->Unlock();
    return hr;
}


HRESULT STDMETHODCALLTYPE
CObex::EnumDevices(LPDEVICEENUM *ppDeviceEnum, REFCLSID uuidTransport)
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumDevices()\n"));
     if (!ppDeviceEnum)
        return E_INVALIDARG;
    *ppDeviceEnum = NULL;
    
    HRESULT hr = E_FAIL;
    
    gpSynch->Lock();
    
    if (_stage != Initialized)
    {
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumDevices - Not yet initialized...()\n"));
        gpSynch->Unlock();
        return OBEX_E_NOT_INITIALIZED;
    }

    if (_pDevices)
        hr = _pDevices->EnumDevices(ppDeviceEnum, uuidTransport);
    if ((SUCCEEDED(hr)) && (*ppDeviceEnum))
        (*ppDeviceEnum)->Reset();
    
    gpSynch->Unlock();
    
    return hr;
}

HRESULT STDMETHODCALLTYPE
CObex::BindToDevice(LPPROPERTYBAG pPropertyBag, LPDEVICE *ppDevice)
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::BindToDevice()\n"));
    if (!pPropertyBag || !ppDevice)
        return E_POINTER;    
    *ppDevice = NULL;


    gpSynch->Lock();    
    if (_stage != Initialized)
    {
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::BindToDevice - Not yet initialized...()\n"));
        gpSynch->Unlock();
        return OBEX_E_NOT_INITIALIZED;
    }
    gpSynch->Unlock();


    VARIANT var;
    VariantInit(&var);
    HRESULT hr = pPropertyBag->Read(c_szDevicePropTransport, &var, NULL);
    if ((FAILED(hr)) || (var.vt != VT_BSTR))
    {
        VariantClear(&var);
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::BindToDevice - invalid arg...()\n"));        
        return E_INVALIDARG;
    }

    CLSID clsid;
    if ((SUCCEEDED(CLSIDFromString(var.bstrVal, &clsid))) && 
        ( (0 == memcmp(&clsid, &CLSID_BthTransport, sizeof(CLSID))) ||
          (0 == memcmp(&clsid, &CLSID_IpTransport, sizeof(CLSID))) ||
          (0 == memcmp(&clsid, &CLSID_IrdaTransport, sizeof(CLSID)))  
        ))
    {
        VariantClear(&var);
    
        CObexDevice *pDevice = new CObexDevice(pPropertyBag, clsid);
        if (!pDevice)
        {
            DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::BindToDevice - out of memory...()\n"));    
            return E_OUTOFMEMORY;
        }
		
        hr = pDevice->QueryInterface(IID_IObexDevice, (LPVOID *)ppDevice);
		
		//dont connect up if SEND_DEVICE_UPDATES is set... this is to make the
		//  obex client work with PPC2002
        if(SUCCEEDED(hr) && (g_dwObexCaps & SEND_DEVICE_UPDATES))
        {
            hr = pDevice->ConnectSocket();
			
            if(FAILED(hr))
            {
                DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumDevices - ConnectSocket failed...()\n"));        
                (*ppDevice)->Release();
                *ppDevice = NULL;
            }
            else
            {
                DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumDevices - ConnectSocket SUCCEEDED...()\n"));            
            }
        }
        pDevice->Release();
        return hr;
    }
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::BindToDevice - somethings messed up!  tried to connect to non BT/IRDA!\n"));
    VariantClear(&var);
    return E_FAIL;
}

HRESULT STDMETHODCALLTYPE
CObex::RegisterService(LPPROPERTYBAG pPropertyBag, LPSERVICE *ppService)
{
    return E_NOTIMPL;
}

/*
HRESULT STDMETHODCALLTYPE
CObex::RegisterServiceBlob(unsigned long ulSize, byte * pbData, LPSERVICE *ppService)
{
    return E_NOTIMPL;
}
*/

HRESULT STDMETHODCALLTYPE
CObex::EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumConnectionPoints()\n"));
    if (!ppEnum)
        return E_POINTER;

    *ppEnum = NULL;
    HRESULT hr = E_FAIL;

    gpSynch->Lock();

    if (_stage != Initialized)
    {
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::EnumConnectionPoints - Not yet initialized...()\n"));
        gpSynch->Unlock();
        return E_FAIL;
    }

    if (_pConnPt)
    {
        CEnumConnectionPoints *pEnumPts = new CEnumConnectionPoints((IConnectionPoint *)_pConnPt);
        if (pEnumPts)
        {
            *ppEnum = (IEnumConnectionPoints *)pEnumPts;
            hr = S_OK;
        }
        else
            hr = E_OUTOFMEMORY;
    }

    gpSynch->Unlock();
    return hr;
}

HRESULT STDMETHODCALLTYPE
CObex::FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::FindConnectionPoint()\n"));
    if (!ppCP)
        return E_POINTER;

    *ppCP = NULL;

    HRESULT hr = E_FAIL;
    
    gpSynch->Lock();

    if (_stage != Initialized)
    {
        DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::FindConnectionPoint - Not yet initialized...()\n"));
        gpSynch->Unlock();
        return E_FAIL;
    }

    if ( (riid == IID_IObexSink) && (_pConnPt) )
    {
        *ppCP = _pConnPt;
        _pConnPt->AddRef();
        hr = S_OK;
    }
    else
        hr = CONNECT_E_NOCONNECTION;

    gpSynch->Unlock();
    return hr;
}


HRESULT STDMETHODCALLTYPE 
CObex::QueryInterface(REFIID riid, void** ppv) 
{
    DEBUGMSG(OBEX_COBEX_ZONE,(L"CObex::QueryInterface()\n"));
       if(!ppv) 
        return E_POINTER;
    if(riid == IID_IUnknown) 
        *ppv = this;
    else if(riid == IID_IObex) 
        *ppv = static_cast<IObex*>(this);
    else if(riid == IID_IObex2) 
        *ppv = static_cast<IObex2*>(this);
    else if(riid == IID_IConnectionPointContainer) 
        *ppv = static_cast<IConnectionPointContainer*>(this);
    else if(riid == IID_IObexCaps)
    	 *ppv = static_cast<IObexCaps *>(this);
    else 
        return *ppv = 0, E_NOINTERFACE;

    AddRef();
    return S_OK;    
}

HRESULT  
CObex::AddActiveTransport(IObexTransport *pTransport)
{
    if(FALSE == GetLock()) 
       return E_UNEXPECTED;
                   
    TRANSPORT_NODE *pNew;
    if(NULL == (pNew = new TRANSPORT_NODE())) {
        return E_OUTOFMEMORY;
    }
    pTransport->AddRef();
    pNew->pTransport = pTransport;
    pNew->pNext =_pActiveTransports;
    _pActiveTransports = pNew;
    
    ReleaseLock();
        return S_OK;
}

HRESULT  
CObex::RemoveActiveTransport(IObexTransport *pTransport)
{
    TRANSPORT_NODE *pDel;
    TRANSPORT_NODE *pParent;
    HRESULT hr;
    
    if(FALSE == GetLock()) 
        return E_UNEXPECTED;
    
    if(NULL == _pActiveTransports) {
        hr = E_FAIL;
        goto Done;
    }   
    
    pParent = NULL;
    pDel = _pActiveTransports;

    while (pDel && (pDel->pTransport != pTransport))
    {
        pParent = pDel;
        pDel = pDel->pNext;
    }

    if (pDel)
    {
        if (pParent)
            pParent->pNext = pDel->pNext;
        else
            _pActiveTransports = pDel->pNext;

        pDel->pTransport->Release();
        delete pDel; 
        hr = S_OK;
    }
    else
        hr = E_FAIL;
    
    Done:
        ReleaseLock();
        ASSERT(SUCCEEDED(hr));
        return hr;    
}

HRESULT  
CObex::AbortActiveTransports(BOOL fAbort)
{
    TRANSPORT_NODE *pTemp = _pActiveTransports;
    ASSERT(TRUE == gpSynch->IsLocked());
    
    while(NULL != pTemp) {
        IObexAbortTransportEnumeration *pAbortEnum;
        
        if(SUCCEEDED(pTemp->pTransport->QueryInterface(IID_IObexAbortTransportEnumeration, (LPVOID *)&pAbortEnum))) {
            if(TRUE == fAbort) {
                pAbortEnum->Abort();
            } else {
                pAbortEnum->Resume();
            }
            pAbortEnum->Release();
        } 
        pTemp = pTemp->pNext;
    }
    return S_OK;
}

ULONG STDMETHODCALLTYPE 
CObex::AddRef() 
{
    DEBUGMSG(OBEX_ADDREFREL_ZONE,(L"CObex::AddRef()\n"));
    return InterlockedIncrement((LONG *)&_refCount);
}

ULONG STDMETHODCALLTYPE 
CObex::Release() 
{   
    SVSUTIL_ASSERT(_refCount != 0xFFFFFFFF);
    ULONG ret = InterlockedDecrement((LONG *)&_refCount);    
    DEBUGMSG(OBEX_ADDREFREL_ZONE,(L"CObex::Release(%d)\n", ret));
    if(!ret) 
        delete this; 
    return ret;
}


template<typename T> class CFactory : public IClassFactory
{
public:
    // IUnknown
    ULONG STDMETHODCALLTYPE AddRef();
    ULONG STDMETHODCALLTYPE Release();
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppv);

    // IClassFactory
    HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown *pUnknownOuter, REFIID riid, void** ppv);
    HRESULT STDMETHODCALLTYPE LockServer(BOOL bLock);

    CFactory() : m_cRef(1) {
        InterlockedIncrement(&g_cServerLocks);
    }
    ~CFactory() { 
        InterlockedDecrement(&g_cServerLocks);
    }

    static HRESULT GetClassObject(REFIID riid, void** ppv) {
        if(!ppv) return E_POINTER;

        CFactory<T>* pFactory = new CFactory<T>;