hxopwavetcpsock.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 

#include "hxopwavetcpsock.h"
#include "debug.h"
#include "hxassert.h"
#include "ihxpckts.h"
#include "smartptr.h"

#define D_TCPSOCKET 0x10000000

class HXOpwaveTCPResolvResp : public IHXResolverResponse
{

public:

    HXOpwaveTCPResolvResp(HXOpwaveTCPSocket* pParent);
    ~HXOpwaveTCPResolvResp();

    /*
     *  IUnknown methods
     */
    STDMETHOD(QueryInterface)		(THIS_
									REFIID riid,
									void** ppvObj);

    STDMETHOD_(ULONG32,AddRef)		(THIS);
    STDMETHOD_(ULONG32,Release)		(THIS);

    /*
     *	IHXResolverResponse methods
     */
    STDMETHOD(GetHostByNameDone)	(THIS_
									HX_RESULT status,
									ULONG32 ulAddr);
private:

    ULONG32 m_lRefCount;
    HXOpwaveTCPSocket* m_pParent;

};



HXOpwaveTCPResolvResp::HXOpwaveTCPResolvResp(HXOpwaveTCPSocket* pParent) 
					  : m_lRefCount(0)
					  , m_pParent(pParent)
{
    HX_ADDREF(m_pParent);
}


HXOpwaveTCPResolvResp::~HXOpwaveTCPResolvResp()
{
    HX_RELEASE(m_pParent);
}

/*
 *  IUnknown methods
 */
STDMETHODIMP
HXOpwaveTCPResolvResp::QueryInterface(THIS_  REFIID riid,
											void** ppvObj)
{

    if (IsEqualIID(riid, IID_IHXResolverResponse))
    {
        AddRef();
        *ppvObj = (IHXResolverResponse*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IUnknown))
    {
        AddRef();
        *ppvObj = (IUnknown*)(IHXResolverResponse*)this;
        return HXR_OK;
    }

    *ppvObj = NULL;
    return HXR_NOINTERFACE;

}

STDMETHODIMP_(ULONG32)
HXOpwaveTCPResolvResp::AddRef(THIS)
{
    return InterlockedIncrement(&m_lRefCount);
}


STDMETHODIMP_(ULONG32)
HXOpwaveTCPResolvResp::Release(THIS)
{

    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;

    return 0;
}

/*
 *	IHXResolverResponse methods
 */
STDMETHODIMP
HXOpwaveTCPResolvResp::GetHostByNameDone(THIS_
			 		HX_RESULT status,
					ULONG32 ulAddr)
{
    return m_pParent->GetHostByNameDone(status, ulAddr);
}


HXOpwaveTCPSocket::HXOpwaveTCPSocket(IHXCommonClassFactory* pCCF,
			  	    IHXResolver* pResolver)
				  : OpSocket(kTCP)
				  , m_lRefCount(0)
				  , m_pResponse(0)
				  , m_pResolver(0)
				  , m_pCCF(0)
				  , m_state(tcpNotInitialized)
				  , m_nConnectPort(0)
				  , m_nLocalPort(0)
				  , m_ulLocalAddr(0)
				  , m_bWantWrite(FALSE)
				  , m_pReadBuffer(NULL)
				  , m_pWriteBuffer(NULL)
				  , m_ulBytesLeftToWrite(0)
				  , m_ulReadSize(0)
{

    IHXResolverResponse* pResolvResp = new HXOpwaveTCPResolvResp(this);
    if (pResolvResp)
    {
	pResolvResp->AddRef();
    
        if (pCCF && pResolver && (pResolver->Init(pResolvResp) == HXR_OK))
	{
	    m_pCCF = pCCF;
	    m_pCCF->AddRef();
	    m_pResolver = pResolver;
	    m_pResolver->AddRef();
	    m_state = tcpInitialized;
	}
    }

    HX_RELEASE(pResolvResp);

}


HXOpwaveTCPSocket::~HXOpwaveTCPSocket()
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::~HXOpwaveTCPSocket()\n"));

    if (m_state != tcpNotInitialized)
    {
	CloseConnection(HXR_OK);
    }

    HX_RELEASE(m_pResponse);
    HX_RELEASE(m_pResolver);
    HX_RELEASE(m_pCCF);


}



/*
 *  IUnknown methods
 */
STDMETHODIMP
HXOpwaveTCPSocket::QueryInterface(THIS_
								REFIID riid,
								void** ppvObj)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::QueryInterface()\n"));

    if (IsEqualIID(riid, IID_IHXTCPSocket))
    {

        AddRef();
        *ppvObj = (IHXTCPSocket*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSetSocketOption))
    {
        AddRef();
        *ppvObj = (IHXSetSocketOption*)this;
        return HXR_OK;
    }    
    else if (IsEqualIID(riid, IID_IUnknown))
    {
        AddRef();
        *ppvObj = (IUnknown*)(IHXTCPSocket*)this;
        return HXR_OK;
    }

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}


STDMETHODIMP_(ULONG32)
HXOpwaveTCPSocket::AddRef(THIS)
{
    return InterlockedIncrement(&m_lRefCount);
}



STDMETHODIMP_(ULONG32)
HXOpwaveTCPSocket::Release(THIS)
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;
    return 0;
}

/*
 *	IHXTCPSocket methods
 *
 *  Network addresses and ports are in native byte order
 *  
 */
STDMETHODIMP
HXOpwaveTCPSocket::Init(THIS_
				     IHXTCPResponse* /*IN*/ pTCPResponse)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::Init()\n"));

    HX_RELEASE(m_pResponse);
    m_pResponse = pTCPResponse;
    if (m_pResponse)
    {
	m_pResponse->AddRef();
    }

    return (m_pResponse) ? HXR_OK : HXR_FAILED;

}



STDMETHODIMP 
HXOpwaveTCPSocket::SetResponse(THIS_
			        IHXTCPResponse* pTCPResponse)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::SetResponse()\n"));

    HX_RELEASE(m_pResponse);
    m_pResponse = pTCPResponse;

    if (m_pResponse)
	m_pResponse->AddRef();

    return (m_pResponse) ? HXR_OK : HXR_FAILED;
}



STDMETHODIMP 
HXOpwaveTCPSocket::Bind(THIS_
			UINT32 ulLocalAddr,
	        	UINT16 nPort)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::Bind(%08lx, %u)\n", ulLocalAddr, nPort));

	/// Until OpSocket implement the DNS layer, this is nothting but cache address and
	/// port values
	/// OpSocket has bind function built into connect
    HX_RESULT res = HXR_OK;
    m_ulLocalAddr = ulLocalAddr;
    m_nLocalPort = nPort;
    m_state = tcpBound;
    return res;
}


/*
 * pDestination is a string containing host name or dotted-ip notation
 */
STDMETHODIMP 
HXOpwaveTCPSocket::Connect(THIS_ 
        		   const char* pDestination,
			   UINT16 nPort)    
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::Connect('%s', %u)\n", pDestination, nPort));

    HX_RESULT res = HXR_OK;

    if (m_state == tcpInitialized)
    {
         Bind(0, 0);
    }

    m_ipDest = 0;
    m_nConnectPort = nPort;
    m_state = tcpResolving;   
    res = m_pResolver->GetHostByName(pDestination);

    return res;
}



STDMETHODIMP 
HXOpwaveTCPSocket::Read(THIS_
						UINT16 Size)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::Read(%u)\n", Size));

    HX_RESULT res = HXR_OK;

    HX_ASSERT(m_state == tcpConnected);

    m_ulReadSize = Size;

    //OpDPRINTF("Read: this=%p, size=%d, bread=%d, state=%d, bwrite=%d\n", this, Size, m_bReadable, m_state, m_bWritable);
    if (m_state == tcpConnected)
    {
        if (m_bReadable &&m_ulReadSize)
        {
            /// avoid recursion that might occur because 
            /// OnReadDone call in DoRead invoke ::Read again
            m_bReadable = FALSE;
            res = DoRead();
        }
        
    }
    else
    {
    	res = HXR_FAILED;
    }
    return res;

}

/// Work horse for reading. As long as we are initilized once 
/// to read, we always try to read something of the socket.
HX_RESULT
HXOpwaveTCPSocket::DoRead()
{
    /// Create a new IHXBuffer for every read
    HX_RESULT res = HXR_FAIL;
    IHXBuffer* pReadBuffer = NULL;
    res = m_pCCF->CreateInstance(IID_IHXBuffer, (void**)&pReadBuffer);
    if (SUCCEEDED(res))
    {
        res = pReadBuffer->SetSize(m_ulReadSize);
    
        UCHAR* pData = pReadBuffer->GetBuffer();
        int nRead = read(pData, m_ulReadSize);
 
        //OpDPRINTF("DoRead: this=%p, read=%d, askfor=%d\n\n", this, nRead, m_ulReadSize);
        if (nRead > 0)
        {
            pReadBuffer->SetSize(nRead);
            m_pReadBuffer = pReadBuffer;
            // Don't ADDREF, m_pReadBuffer will be released in the callback OnReadDone
        
            OnReadDone(res, m_pReadBuffer);
        }
    }
    HX_RELEASE(m_pReadBuffer);
    return res;
}

STDMETHODIMP 
HXOpwaveTCPSocket::Write(THIS_
			 IHXBuffer*	pBuffer)
{

    DPRINTF(D_TCPSOCKET, ("HXOpwaveTCPSocket::Write()\n"));

    HX_RESULT res = HXR_OK;
    if (!pBuffer)
    {
    	res = HXR_INVALID_PARAMETER;