HX_RESULT HXCloakedV2TCPSocket::GetAddrInfoDone(HX_RESULT status,
UINT32 nVecLen,
IHXSockAddr** ppAddrVec)
{
HX_RESULT res = HXR_FAIL;
HX_ASSERT(0!=m_nProxyPort);
//We are done getting the addr info for the proxy host.
if( SUCCEEDED(status) && 1<=nVecLen )
{
HX_ASSERT(!m_pProxyAddr);
HX_ASSERT(m_pTCPSocket);
HX_RELEASE(m_pProxyAddr);
ppAddrVec[0]->Clone(&m_pProxyAddr);
m_pProxyAddr->SetPort(m_nProxyPort);
if( m_pTCPSocket )
{
res = m_pTCPSocket->ConnectToOne(m_pProxyAddr);
}
}
if( !SUCCEEDED(res) )
{
HX_RELEASE(m_pProxyAddr);
}
//hardcoded because I have no idea what the IHXSocket would do
//with any other return code. Not sure why we return one at all.
return HXR_OK;
}
STDMETHODIMP HXCloakedV2TCPSocket::Write(IHXBuffer* pBuffer)
{
IHXBuffer* pNew = NULL;
HX_RESULT res = HXR_FAIL;
CHXString GetString = "";
// HX_ASSERT( csReady == m_CloakingState && pBuffer );
// if( csReady == m_CloakingState && pBuffer )
if( pBuffer )
{
pBuffer->AddRef();
res = _GeneratePostRequest(pBuffer, pNew);
HX_ASSERT(SUCCEEDED(res));
if( SUCCEEDED(res) && pNew )
{
res = m_pTCPSocket->Write(pNew);
}
HX_RELEASE(pBuffer);
HX_RELEASE(pNew);
//We always follow our POST request with a Get request.
GetString = _GenerateGetRequest();
_WriteString(GetString);
}
return res;
}
void OutputBuffers(UINT16 ulStreamID, IHXValues* pHdr)
{
const char* pName = 0;
IHXBuffer* pValue = 0;
HX_RESULT res = pHdr->GetFirstPropertyBuffer(pName, pValue);
while (HXR_OK == res)
{
printf("GetBuffer %u \"%s\" \"", ulStreamID, pName);
UCHAR* pCur = pValue->GetBuffer();
UCHAR* pEnd = pCur + pValue->GetSize();
static const char z_hexChars[] = "0123456789abcdef";
for (;pCur < pEnd; pCur++)
{
printf("%c%c", z_hexChars[*pCur >> 4], z_hexChars[*pCur & 0xf]);
}
printf("\"\n");
HX_RELEASE(pValue);
res = pHdr->GetNextPropertyBuffer(pName, pValue);
}
HX_RELEASE(pValue);
}
void CHXPrefList::SetPreferences(IUnknown* pContext)
{
IHXPreferences* pPrefs = NULL;
IHXCommonClassFactory* pCCF = NULL;
if (pContext &&
(HXR_OK == pContext->QueryInterface(IID_IHXPreferences,
(void**)&pPrefs)) &&
(HXR_OK == pContext->QueryInterface(IID_IHXCommonClassFactory,
(void**)&pCCF)))
{
CHXSimpleList::Iterator itr = m_prefInfo.Begin();
for(; itr != m_prefInfo.End(); ++itr)
{
CHXPrefInfo* pInfo = (CHXPrefInfo*)(*itr);
IHXBuffer* pBuf = NULL;
if ((HXR_OK == pCCF->CreateInstance(CLSID_IHXBuffer,
(void**)&pBuf)) &&
(HXR_OK == pBuf->Set((const unsigned char*)pInfo->Value(),
strlen(pInfo->Value()))))
{
pPrefs->WritePref(pInfo->Key(), pBuf);
}
HX_RELEASE(pBuf);
}
}
HX_RELEASE(pPrefs);
HX_RELEASE(pCCF);
}
CSymbIHXDataFile::~CSymbIHXDataFile(void)
{
Close();
HX_RELEASE(m_pFileName);
HX_RELEASE(m_pSessionManager);
HX_RELEASE(m_pContext);
}
int DLLAccessClient::open(const char* dllName,
UINT16 nLibType,
IUnknown* pContext)
{
HX_RESULT status;
int retVal = DLLAccess::NO_LOAD;
IHXCommonClassFactory* pCCF = NULL;
HX_RELEASE(m_pDllAccessServer);
status = pContext->QueryInterface(IID_IHXCommonClassFactory,
(void**) &pCCF);
if (SUCCEEDED(status))
{
pCCF->CreateInstance(CLSID_IHXDllAccess,
(void**) &m_pDllAccessServer);
}
HX_RELEASE(pCCF);
if (m_pDllAccessServer)
{
if (SUCCEEDED(m_pDllAccessServer->Open(dllName, nLibType)))
{
retVal = DLLAccess::DLL_OK;
}
}
return retVal;
}
CAudioOutOpenwave::~CAudioOutOpenwave()
{
//We must assume that _Imp_Close has already been called. If not, we are
//in big trouble.
if ( m_wState != RA_AOS_CLOSED )
{
HX_ASSERT( "Device not closed in dtor." == NULL );
}
//Clean up the scheduler.
HX_RELEASE( m_pScheduler );
HX_DELETE(m_pPlaybackCountCBTime);
HX_RELEASE(m_pCallback);
//OpDPRINTF("dtor: Freeing sample buffer, expect an exception\n");
for (int i=0; i<10; i++)
HX_DELETE(m_SndBuf[i].fSampleBuffer);
//OpDPRINTF("dtor: Done freeing sample buffers \n");
if (m_pSndDev)
{
//OpDPRINTF("dtor : before freeing the channel\n");
op_sound_unregister_callback(m_pSndDev, iodone_callback);
op_sound_freechan(m_pSndDev);
//OpDPRINTF("dtor : freeing the channel\n");
}
HX_DELETE(m_pWriteList); // Remove all elements in the list, if any
}
HX_RESULT CMP4ADecoder::OpenNext(IHXValues* pHeader,
IMP4APayloadFormat* pRssm,
IHXAudioDecoder** pOutAudioDecoder,
IUnknown* pContext)
{
HX_RESULT retVal = HXR_FAIL;
if (pHeader && pOutAudioDecoder)
{
// Close the decoder
Close();
// Get the mime type
IHXBuffer* pMimeType = NULL;
pHeader->GetPropertyCString("MimeType", pMimeType);
if (pMimeType)
{
m_pDecoderInfo = m_decInfoStore.GetInfoNext((const char*) pMimeType->GetBuffer(), pRssm);
if (m_pDecoderInfo)
{
HX_RELEASE(*pOutAudioDecoder);
retVal = BuildDLLAccessBridge(pOutAudioDecoder, pMimeType, pRssm, pContext);
}
}
HX_RELEASE(pMimeType);
}
return retVal;
}
/*
* ClientRegTree::RegTreeInit()
*
* This object is meant to be passed from client to client as the sequential
* WMT HTTP requests come in. Therefore, only one client at a time is
* accessing it (so no mutex needed), but we must ensure that this object has
* the context and registry for the current proc. Thus, it must be init'ed
* every time a new client picks it up.
*/
HX_RESULT
ClientRegTree::RegTreeInit(Client* pClient, IHXBuffer* pStartTime)
{
HX_RELEASE(m_pContext);
HX_RELEASE(m_pRegistry);
HX_RELEASE(m_pClassFactory);
m_pProc = pClient->proc; // don't addref/release
m_pProc->pc->server_context->
QueryInterface(IID_IUnknown, (void**) &m_pContext);
m_pContext->QueryInterface(IID_IHXRegistry, (void**) &m_pRegistry);
m_pContext->QueryInterface(IID_IHXCommonClassFactory,
(void**) &m_pClassFactory);
// The seqnum (session id) is persistent across calls.
// Only set up the registry tree once.
if (!m_ulRegistryConnId)
{
m_ulRegistryConnId = m_pProc->pc->server_info->
IncrementTotalClientCount(m_pProc);
InitRegistry(pStartTime);
}
return HXR_OK;
}
WebkitClientAdviseSink::~WebkitClientAdviseSink(void)
{
HX_RELEASE(m_pRegistry);
HX_RELEASE(m_pPlayer);
HX_RELEASE(m_pUnknown);
HX_RELEASE(m_pWebkitContext);
}
void
HXRecordControl::Cleanup()
{
OnEndOfPackets();
for(UINT16 nStream = 0; nStream < m_PendingGetPackets.GetSize(); nStream++)
{
IHXPacket* pPacket = (IHXPacket*)m_PendingGetPackets.GetAt(nStream);
m_PendingGetPackets.SetAt(nStream, NULL);
HX_RELEASE(pPacket);
}
if(m_pRecordService)
m_pRecordService->CloseRecordSource(m_pRecordSource);
HX_RELEASE(m_pRecordService);
HX_RELEASE(m_pRecordSource);
HX_VECTOR_DELETE(m_pStreamInfo);
#if defined(HELIX_FEATURE_RECORDCONTROL_MERGESORT)
HX_DELETE(m_pMergeSorter);
#endif /* #if defined(HELIX_FEATURE_RECORDCONTROL_MERGESORT) */
while(!m_PendingPutPackets.IsEmpty())
{
PendingPutPacket* pPutPacket = (PendingPutPacket*)m_PendingPutPackets.RemoveHead();
HX_ASSERT(pPutPacket);
HX_RELEASE(pPutPacket->pPacket);
HX_DELETE(pPutPacket);
}
}
STDMETHODIMP
StaticPushSource::Done()
{
HX_VECTOR_DELETE(m_pStreams);
HX_RELEASE(m_pSinkControl);
HX_RELEASE(m_pFileObject);
HX_RELEASE(m_pBWEValues);
HX_RELEASE(m_pRequest);
if (m_pSink)
{
m_pSink->SourceDone();
m_pSink->Release();
m_pSink = NULL;
}
if (m_pFileFormat)
{
/*
* Close() must be called before Release() so that the
* IHXFileFormatObject will properly free its IHXFileObject
*/
m_pFileFormat->Close();
m_pFileFormat->Release();
m_pFileFormat = NULL;
}
return HXR_OK;
}
ConfigWatcher::~ConfigWatcher()
{
Cleanup();
HX_RELEASE(m_pRegistry);
HX_RELEASE(m_pActiveRegistry);
HX_RELEASE(m_pPropWatch);
}
HXFileSystemManager::~HXFileSystemManager()
{
if (m_pContext)
{
m_pContext->Release();
m_pContext = 0;
}
if(m_pSamePool)
{
m_pSamePool->Release();
m_pSamePool = NULL;
}
if (m_pFSManagerResponse)
{
m_pFSManagerResponse->Release();
m_pFSManagerResponse = 0;
}
HX_RELEASE(m_pRequest);
if (m_pCallback &&
m_pCallback->m_bIsCallbackPending &&
m_pScheduler)
{
m_pScheduler->Remove(m_pCallback->m_Handle);
}
HX_RELEASE(m_pCallback);
HX_RELEASE(m_pScheduler);
HX_RELEASE(m_pOriginalObject);
HX_VECTOR_DELETE(m_pRelativePath);
}
static /* private */
bool MatchClass(IHXSockAddr* pAddr, HXIN4AddrClass addrClassIN4,
HXIN6AddrClass addrClassIN6)
{
HX_ASSERT(HX_IN6_CLASS_V4MAPPED != addrClassIN6);
bool isMatch = false;
HX_RESULT hxr = HXR_FAILED;
IHXSockAddrIN6* pAddr6 = 0;
hxr = pAddr->QueryInterface(IID_IHXSockAddrIN6,
reinterpret_cast<void**>(&pAddr6));
if(SUCCEEDED(hxr))
{
isMatch = MatchClassIN6(pAddr6, addrClassIN4, addrClassIN6);
HX_RELEASE(pAddr6);
}
else
{
IHXSockAddrIN4* pAddr4 = 0;
hxr = pAddr->QueryInterface(IID_IHXSockAddrIN4,
reinterpret_cast<void**>(&pAddr4));
if(SUCCEEDED(hxr))
{
isMatch = (addrClassIN4 == pAddr4->GetAddrClass());
HX_RELEASE(pAddr4);
}
}
return isMatch;
}
STDMETHODIMP
DataRevertController::RevertedFileHeaderReady(HX_RESULT status,
IHXValues* pHeader)
{
if (pHeader)
{
HX_RELEASE(m_pFileHeaders);
m_pFileHeaders = pHeader;
pHeader->AddRef();
}
pHeader = (IHXValues*)m_pStreamHeaders->RemoveHead();
if (!pHeader)
{
m_pControlResp->RevertHeadersDone(m_pFileHeaders,
m_pRevertedStreamHeaders,
m_pResponseHeaders,
TRUE);
return HXR_OK;
}
HX_RELEASE(m_pCurrentStreamHeader);
m_pCurrentStreamHeader = pHeader;
m_pDataRevert->RevertStreamHeader(pHeader);
return HXR_OK;
}
HXExternalResourceManager::~HXExternalResourceManager()
{
delete[] m_pExternalResDir;
if(m_pResourceList)
{
CHXSimpleList::Iterator i = m_pResourceList->Begin();
for (; i != m_pResourceList->End(); ++i)
{
IHXXResFile* pRes = (IHXXResFile*)(*i);
pRes->Close();
pRes->Release();
}
}
HX_DELETE(m_pResourceList);
HX_RELEASE(m_pPrefs);
HX_RELEASE(m_pRegistry);
HX_RELEASE(m_pContext);
HX_RELEASE(m_pHXXResPlugin);
#if defined(HELIX_CONFIG_NOSTATICS)
HXExternalResourceManager*& m_pResourceManager =
(HXExternalResourceManager*&)HXGlobalPtr::Get(
&HXExternalResourceManager::m_pResourceManager);
#endif
m_pResourceManager = NULL;
}
void
HXOverlayManager::Close()
{
CSiteStats* pStats;
CStatPoint* pPoint;
while (m_ListOfSiteStats.GetCount())
{
pStats = (CSiteStats*) m_ListOfSiteStats.RemoveHead();
while(pStats->samples.GetCount())
{
pPoint = (CStatPoint*) pStats->samples.RemoveHead();
HX_DELETE(pPoint);
}
HX_DELETE(pStats);
}
if (m_CallbackHandle)
{
m_pScheduler->Remove(m_CallbackHandle);
m_CallbackHandle = 0;
}
HX_RELEASE(m_pContext);
HX_RELEASE(m_pScheduler);
HX_RELEASE(m_pMutex);
}
HX_RESULT CHXAudioDeviceDS::InternalClose()
{
HX_RESULT theErr = HXR_OK;
KillThreadAndEvent();
HX_RELEASE(m_pAudioHookDMO);
HX_RELEASE(m_pPrimaryBuffer);
HX_RELEASE(m_pSecondaryBuffer);
HX_RELEASE(m_pDSDev);
m_pAudioPtrStart = NULL;
m_ulLastPlayCursor = 0;
m_ulLastWriteCursor =0;
m_eState = E_DEV_CLOSED;
m_ulLoops = 0;
m_ulLoopTime = 0;
m_nBlocksPerBuffer = 0;
m_ulCurrPlayTime = 0;
m_ulCurrLoopTime = 0;
if (m_hwnd)
{
SetWindowLong(m_hwnd, GWL_USERDATA, NULL);
}
return HXR_OK;
}
HX_RESULT
FileFormatSource::Init(IHXPSinkControl* pSink)
{
HX_RESULT h_result = HXR_OK;
IHXFileObject* pFileObject;
IHXBandwidthNegotiator* pBandwidthNegotiator;
HX_RELEASE(m_pSinkControl);
pSink->AddRef();
m_pSinkControl = pSink;
AddRef();
if (HXR_OK == h_result)
{
if(HXR_OK == m_pFileObject->QueryInterface(IID_IHXFileObject,
(void**)&pFileObject))
{
if(m_bwe_values &&
(HXR_OK == m_file_format->QueryInterface(
IID_IHXBandwidthNegotiator,
(void**)&pBandwidthNegotiator)))
{
pBandwidthNegotiator->SetBandwidthInfo(m_bwe_values);
pBandwidthNegotiator->Release();
m_bwe_values->Release();
m_bwe_values = NULL;
}
HX_ASSERT(m_file_format != NULL);
if (m_bFileFormatInitialized)
{
InitDone(HXR_OK);
}
else
{
m_bFileFormatInitialized = TRUE;
h_result = m_file_format->InitFileFormat(m_pRequest, this,
pFileObject);
}
HX_RELEASE(pFileObject);
if (HXR_OK != h_result)
{
ERRMSG(m_proc->pc->error_handler,
"File Format initialization failed\n");
m_file_format->Close();
m_file_format->Release();
m_file_format = 0;
m_bFileFormatInitialized = FALSE;
}
}
}
Release();
return h_result;
}
HX_RESULT
CHXAltGroupIterator::getIterator(IUnknown* pUnk)
{
HX_RESULT res = HXR_INVALID_PARAMETER;
if (pUnk)
{
IHXList* pList = NULL;
res = pUnk->QueryInterface(IID_IHXList, (void**)&pList);
if (HXR_OK == res)
{
HX_RELEASE(m_pItr);
m_pItr = pList->Begin();
if (!m_pItr)
{
res = HXR_UNEXPECTED;
}
}
HX_RELEASE(pList);
}
return res;
}
HX_RESULT CBaseArchiver2::MakeNuggetFileObject(IHXFileObject* pFileObject,
const char* pFileMimeType,
IHXFileObject* &pNuggetFileObject)
{
HX_RESULT retVal = HXR_OUTOFMEMORY;
CNGTFileObject* pNewNuggetFileObject = new CNGTFileObject();
if (pNewNuggetFileObject)
{
pNewNuggetFileObject->AddRef();
retVal = pNewNuggetFileObject->InitNugget(m_pContext,
pFileObject,
HX_FILE_READ | HX_FILE_WRITE | HX_FILE_BINARY,
NULL, // IHXMetaFileFormatResponse
TRUE); // bForceNew
if (SUCCEEDED(retVal))
{
UINT32 ulExpiration = 0;
UINT32 ulConnectTime = 0;
IHXBuffer* pRemoteSourceURLBuffer = NULL;
m_pAdviser->GetPropertyULONG32("NuggetExpiration",
ulExpiration);
m_pAdviser->GetPropertyCString("NuggetRemoteSourceURL",
pRemoteSourceURLBuffer);
m_pAdviser->GetPropertyULONG32("NuggetConnectTime",
ulConnectTime);
retVal = pNewNuggetFileObject->ConfigureNugget(
ulExpiration,
ulConnectTime,
m_ulNuggetMinLocalDuration,
m_ulMaxDuration,
pFileMimeType,
pRemoteSourceURLBuffer ? ((const char*) pRemoteSourceURLBuffer->GetBuffer()) : NULL);
HX_RELEASE(pRemoteSourceURLBuffer);
}
if (SUCCEEDED(retVal))
{
retVal = pNewNuggetFileObject->QueryInterface(IID_IHXFileObject,
(void**) &pNuggetFileObject);
}
if (SUCCEEDED(retVal))
{
m_pNuggetFileObject = pNewNuggetFileObject;
HX_ADDREF(m_pNuggetFileObject);
}
}
HX_RELEASE(pNewNuggetFileObject);
return retVal;
}
void
BasicPacketFlow::ScheduleStreamDone(BasicPacketFlow* pFlow,
Transport* pTransport,
PacketStream* pStream,
UINT16 unStreamNumber)
{
/*
* Notify the protocol if we've reached the end of the stream following a
* seek and have no packets to send.
*/
if (!pStream->IsFirstPacketTSSet())
{
SetStreamStartTime(unStreamNumber, (UINT32)~0);
pStream->SetFirstPacketTS((UINT32)~0);
}
if (m_pRateManager)
{
IHXPacketFlowControl* pRateMgrFlowControl = NULL;
if (HXR_OK == m_pRateManager->QueryInterface(IID_IHXPacketFlowControl,
(void**)&pRateMgrFlowControl))
{
pRateMgrFlowControl->StreamDone(unStreamNumber);
HX_RELEASE(pRateMgrFlowControl);
}
}
HandleStreamDone(pStream);
pStream->m_bSentStreamDone = TRUE;
HX_ASSERT(!pStream->m_uScheduledStreamDoneID);
if (pStream->m_uScheduledStreamDoneID)
{
return;
}
else if (!pStream->m_pStreamDoneCallback)
{
pStream->m_pStreamDoneCallback =
new (m_pProc->pc->mem_cache) PacketStreamDoneCallback();
pStream->m_pStreamDoneCallback->m_pFlow = pFlow;
pStream->m_pStreamDoneCallback->m_pTransport = pTransport;
pStream->m_pStreamDoneCallback->m_pStream = pStream;
pStream->m_pStreamDoneCallback->m_unStreamNumber = unStreamNumber;
pStream->m_pStreamDoneCallback->AddRef();
}
Timeval tNow = m_pProc->pc->engine->now;
Timeval tCallbackTime;
pStream->m_uScheduledStreamDoneID =
m_pProc->pc->engine->schedule.enter(tCallbackTime,
pStream->m_pStreamDoneCallback);
if (!pStream->m_uScheduledStreamDoneID)
HX_RELEASE(pStream->m_pStreamDoneCallback);
}
ClientRegTree::~ClientRegTree()
{
DeleteRegEntry();
HX_RELEASE(m_pRegistry);
HX_RELEASE(m_pClassFactory);
HX_RELEASE(m_pContext);
}
void
GetTypeTest::cleanup()
{
HX_DELETE(m_pBRD);
HX_RELEASE(m_pSHdr);
HX_RELEASE(m_pBufA);
HX_RELEASE(m_pBufB);
}
CloakConn::~CloakConn(void)
{
HX_RELEASE(m_pRTSPProt);
HX_RELEASE(m_pGETHandler);
HX_RELEASE(m_pRTSPSvrProt);
HX_RELEASE(m_pRefSock);
HXDestroyMutex(m_pMutex);
}
void
FunctionalityTest::cleanup()
{
HX_DELETE(m_pBRD);
HX_RELEASE(m_pSHdr);
HX_RELEASE(m_pBufA);
HX_RELEASE(m_pBufB);
}
///////////////////////
//
// CHXAudioDeviceHookBase::~CHXAudioDeviceHookBase
//
// Destructor for CHXAudioDeviceHookBase.
//
CHXAudioDeviceHookBase::~CHXAudioDeviceHookBase()
{
// Free streaming resources in case it hasn't been done by the client
InternalFreeStreamingResources();
HX_RELEASE( m_pContext );
HX_RELEASE( m_pHook );
};
CHXAudioDevice::~CHXAudioDevice()
{
Close(TRUE);
m_iTimer.Close();
HX_DELETE(m_pPrioritySettings);
HX_RELEASE(m_pContext);
HX_RELEASE(m_pErrorMessages);
}
STDMETHODIMP HXCloakedV2TCPSocket::Init( HXSockFamily family,
HXSockType type,
HXSockProtocol protocol)
{
HX_RESULT res = HXR_FAIL;
m_family = family;
m_type = type;
m_protocol = protocol;
//Create the TCP socket to transport our HTTP requests.
HX_ASSERT(m_pNetworkServices);
if(m_pNetworkServices)
{
if( m_pTCPSocket )
{
m_pTCPSocket->Close();
HX_RELEASE( m_pTCPSocket );
}
res = m_pNetworkServices->CreateSocket(&m_pTCPSocket);
if(m_pTCPSocket && SUCCEEDED(res) )
{
res = m_pTCPSocket->SetResponse(this);
if( SUCCEEDED(res) )
{
res = m_pTCPSocket->Init(family, type, protocol);
m_pTCPSocket->SetOption( HX_SOCKOPT_APP_BUFFER_TYPE,
HX_SOCKBUF_DEFAULT);
m_pTCPSocket->SelectEvents(HX_SOCK_EVENT_READ|
HX_SOCK_EVENT_CONNECT|
HX_SOCK_EVENT_CLOSE);
}
}
if( m_pNetworkServices && SUCCEEDED(res) && !m_pResolver )
{
res = m_pNetworkServices->CreateResolver(&m_pResolver);
if( SUCCEEDED(res) && m_pResolver )
{
res = m_pResolver->Init(this);
}
}
}
if( !SUCCEEDED(res) )
{
if( m_pTCPSocket )
{
m_pTCPSocket->Close();
HX_RELEASE(m_pTCPSocket);
}
HX_RELEASE(m_pResolver);
}
return res;
}
