bool
PPPStats::isUp()
{
struct ifreq ifreq;
memset( &ifreq, 0, sizeof (ifreq));
sprintf( ifreq.ifr_ifrn.ifrn_name, "ppp%d", pppDev );
if (ioctl (soc, SIOCGIFFLAGS, (caddr_t) & ifreq) == 0)
{
if ((ifreq.ifr_flags & (IFF_UP|IFF_RUNNING)) != 0)
{
if (!pppUp)
{
pppUp = true;
emit pppStatus( true );
getRemoteAddr();
}
return true;
}
}
if (pppUp)
{
pppUp = false;
emit pppStatus( false );
emit remoteAddr( "n/a" );
}
return false;
}
void UT_CIceConnectionHandler::CreateCandidatePairsL()
{
TIceNatPluginContainerIter iterator
= TIceNatPluginContainerIter( *iPluginContainer );
while ( !iterator.IsDone() )
{
CNATFWPluginApi* item = iterator++;
item->FetchCandidateL( iStreamId, 0, KAfInet );
WaitForEvent( MIceNatPluginEventObs::EFetchingCompleted );
}
CNATFWCandidate* remoteCandidate = CNATFWCandidate::NewLC();
TInetAddr remoteAddr( INET_ADDR( 192, 168, 0, 1 ), 5000 );
remoteCandidate->SetTransportAddrL( remoteAddr );
for ( TInt i = 0; i < iLocalCandidates.Count(); ++i )
{
CNATFWCandidatePair* pair = CNATFWCandidatePair::NewLC(
*iLocalCandidates[i], *remoteCandidate );
iPairs.AppendL( pair );
CleanupStack::Pop( pair );
}
CleanupStack::PopAndDestroy( remoteCandidate );
}
void UT_CIceValidList::UT_CICEValidList_HasPairL()
{
CNATFWCandidate* localCand = CNATFWCandidate::NewLC();
localCand->SetComponentId( KComponentIdRtp );
TInetAddr localAddr( KInetAddrAny );
localAddr.SetFamily( KAfInet );
localCand->SetTransportAddrL( localAddr );
CNATFWCandidate* remoteCand = CNATFWCandidate::NewLC();
remoteCand->SetComponentId( KComponentIdRtp );
TInetAddr remoteAddr( KInetAddrAny );
remoteAddr.SetFamily( KAfInet );
remoteCand->SetTransportAddrL( remoteAddr );
CNATFWCandidatePair* pair
= CNATFWCandidatePair::NewLC( *localCand, *remoteCand );
EUNIT_ASSERT( !iValidList->HasPair( *pair ) );
iValidList->AddValidPairL( *pair );
EUNIT_ASSERT( iValidList->iValidList.Count() == 1 );
EUNIT_ASSERT( iValidList->HasPair( *pair ) );
CleanupStack::PopAndDestroy( pair );
CleanupStack::PopAndDestroy( remoteCand );
CleanupStack::PopAndDestroy( localCand );
}
void UT_CRtpComm::UT_CRtpComm_CommReceiveL( )
{
TCreateSessionParams params;
TInt err( KErrNone );
TInetAddr aRtpAddr;
TInetAddr aRtcpAddr;
iLocalPort = 7777; // this should be changed to an even number by CRtpComm
/////////////////////////////////////////////////
// This object will be destroyed below
// It is used for testing construction without RTCP on an odd port
TRAP( err, iRtpComm = CRtpComm::NewL( iLocalPort,
iSocketServ,
iConnection,
params,
*this,
EFalse ) );
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
// Check some initial values
if ( iLocalPort != 7776 ||
iRtpComm->iSender[ERTPPort] != NULL ||
iRtpComm->iSender[ERTCPPort] != NULL ||
iRtpComm->iReceiver[ERTPPort] != NULL ||
iRtpComm->iReceiver[ERTCPPort] != NULL )
{
EUNIT_ASSERT ( EFalse );
}
iLocalPort = 5000; // use default port 5000
TInt result( KErrNone );
TBuf8<5> sendBuf;
TBuf8<5> recvBuf;
// Test setting a port to an address
// Run the method
TInetAddr dummyAddr( INET_ADDR( 127, 0, 0, 1 ), 5050 );
TInetAddr remoteAddr( INET_ADDR( 127, 0, 0, 1 ), 5000 );
TInt error = iRtpComm->SetToAddress( ERTPPort, dummyAddr );
EUNIT_ASSERT ( error == KErrNone )
// Test writing synchronously to a port
// Run the method
iRtpComm->ConstructReceiverL(EFalse);
// Can't verify success here
err = iRtpComm->Receive( ERTPPort, recvBuf );
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
}
void
PPPStats::getRemoteAddr()
{
// Retrieve remote IP
//
struct ifreq ifreq;
memset( &ifreq, 0, sizeof (ifreq));
sprintf( ifreq.ifr_ifrn.ifrn_name, "ppp%d", pppDev );
ioctl( soc, SIOCGIFDSTADDR, (caddr_t)&ifreq );
struct sockaddr_in *sinp;
sinp = (struct sockaddr_in *)&ifreq.ifr_dstaddr;
if (sinp->sin_addr.s_addr)
emit remoteAddr( inet_ntoa( sinp->sin_addr ) );
else
emit remoteAddr( "n/a" );
}
const char *HTTPRequest::envValue(const char *name) const
{
if (strcmp(name, "CONTENT_TYPE") == 0) {
return headerValue("Content-Type");
} else if (strcmp(name, "CONTENT_LENGTH") == 0) {
return headerValue("Content-Length");
} else if (strcmp(name, "SERVER_SIGNATURE") == 0) {
return "<address>Wt httpd server</address>";
} else if (strcmp(name, "SERVER_SOFTWARE") == 0) {
return "Wthttpd/" WT_VERSION_STR ;
} else if (strcmp(name, "SERVER_ADMIN") == 0) {
return "webmaster@localhost";
} else if (strcmp(name, "REMOTE_ADDR") == 0) {
return remoteAddr().c_str();
} else if (strcmp(name, "DOCUMENT_ROOT") == 0) {
return reply_->configuration().docRoot().c_str();
} else
return 0;
}
int main(int argc, char *argv[])
{
if (argc > 2)
{
ACE_DEBUG((LM_ERROR, "Too many parameters.\n"));
return 0;
}
int sendCount = 1;
if (argc == 2)
{
sendCount = ACE_OS::atoi(argv[1]);
if (sendCount == -1 || sendCount == 0)
{
ACE_DEBUG((LM_ERROR, "Parameter wrong.\n"));
return 0;
}
}
char sbuf[BUF_LEN] = {"a ACE_SOCK_Dgram test"};
ACE_INET_Addr remoteAddr(UDP_PORT, IP_ADDR);
ACE_INET_Addr localAddr;
ACE_SOCK_Dgram peer(localAddr);
for (int i = 0; i < sendCount; i++)
{
ACE_DEBUG((LM_INFO, "send: %s\n", sbuf));
peer.send(sbuf, ACE_OS::strlen(sbuf), remoteAddr);
char buf[BUF_LEN] = {0};
int bc = peer.recv(buf, BUF_LEN, remoteAddr);
if( bc != -1)
{
ACE_DEBUG((LM_INFO, "recv: %s\n\n", buf));
}
ACE_OS::sleep(2);
}
return 0;
}
bool WardenMgr::InitializeCommunication()
{
// Establish connection.
m_Enabled = true;
WardenSvcHandler* handler = new WardenSvcHandler;
ACE_INET_Addr remoteAddr(m_WardendPort, m_WardendAddress.c_str());
if(m_Connector.connect(handler, remoteAddr) == -1)
{
return false;
}
m_WardenProcessStream = handler->Peer;
ByteBuffer pkt;
const char *sign = WARDEND_SIGN;
pkt << sign;
m_WardenProcessStream->send((char const*)pkt.contents(), pkt.size());
m_PingOut = false;
return true;
}
std::string HTTPRequest::envValue(const std::string& name) const
{
if (name == "CONTENT_TYPE") {
return headerValue("Content-Type");
} else if (name == "CONTENT_LENGTH") {
return headerValue("Content-Length");
} else if (name == "SERVER_SIGNATURE") {
return "<address>Wt httpd Server ("
+ envValue("SERVER_SOFTWARE")
+ ")</address>";
} else if (name == "SERVER_SOFTWARE") {
return "Wthttpd/"
+ boost::lexical_cast<std::string>(WT_SERIES) + '.'
+ boost::lexical_cast<std::string>(WT_MAJOR) + '.'
+ boost::lexical_cast<std::string>(WT_MINOR);
} else if (name == "SERVER_ADMIN") {
return "webmaster@localhost"; // FIXME
} else if (name == "REMOTE_ADDR") {
return remoteAddr();
} else if (name == "DOCUMENT_ROOT") {
return reply_->configuration().docRoot();
} else
return std::string();
}
static int sendSetupMessage(const bool bTcpFlag, CRtspSession* pSession,
const char *sURL,
const INET_ADDR* pstServerAddr,
const MEDIA_ADDR* pstLocalMediaAddr)
{
// 媒体流通过TCP方式传输，用回调函数传递出去
if ((bTcpFlag) && (NULL == pSession->m_fDataCallBack))
{
IVS_RUN_LOG_CRI("data call back funtion not exist.");
return RTSP_ERR_PARAMETER;
}
// 检查连接状态
if (RTSP_SESSION_STATUS_INIT != pSession->getStatus())
{
IVS_RUN_LOG_CRI("send rtsp setup message fail, invalid status[%d], handle[%p].",
pSession->getStatus(), pSession);
return RTSP_ERR_STAUTS_ABNORMAL;
}
// 创建SETUP消息类，在收到响应或者超时释放
CRtspSetupMessage* pRtspMsg = NULL;
pRtspMsg = pSession->createRtspMessage((CRtspSetupMessage*)NULL); //lint !e838
if (NULL == pRtspMsg)
{
IVS_RUN_LOG_CRI("create rtsp setup requst message fail.");
return RET_FAIL;
}
// 保存连接方式
pRtspMsg->m_bTcpFlag = bTcpFlag;
// 设置URL
std::string strRtspUrl = "";
strRtspUrl.append(sURL);
pRtspMsg->setRtspUrl(strRtspUrl);
// 设置传输类型
if (bTcpFlag)
{
// Setup消息，记录TCP类型传输媒体流，硬解需要
pRtspMsg->setTransType(TRANS_TYPE_TCP);
if (NULL != pstLocalMediaAddr)
{
pRtspMsg->setDestinationIp(pstLocalMediaAddr->unMediaIp); //lint !e613
pRtspMsg->setClientPort(pstLocalMediaAddr->unMediaVideoPort,
pstLocalMediaAddr->unMediaAudioPort); //lint !e613
}
}
else
{
pRtspMsg->setTransType(TRANS_TYPE_UDP);
// 设置媒体流本地接收地址和端口
pRtspMsg->setDestinationIp(pstLocalMediaAddr->unMediaIp); //lint !e613
pRtspMsg->setClientPort(pstLocalMediaAddr->unMediaVideoPort,
pstLocalMediaAddr->unMediaAudioPort); //lint !e613
}
// 组装RTSP SETUP消息
std::string strRtspMsg = "";
int nRet = pRtspMsg->encodeMessage(strRtspMsg);
if (RET_OK != nRet)
{
pSession->destroyRtspMsg();
return RET_FAIL;
}
// 建立连接
ACE_INET_Addr remoteAddr(pstServerAddr->unAddrPort, pstServerAddr->unAddrIp);
nRet = pSession->connectPeer(remoteAddr);
if (RET_OK != nRet)
{
IVS_RUN_LOG_CRI("connect peer fail, remote address[%s:%d], handle[%p].",
remoteAddr.get_host_addr(),
remoteAddr.get_port_number(),
pSession);
(void)pSession->disconnectPeer();
return RTSP_ERR_DISCONNECT;
}
IVS_RUN_LOG_INF("connect peer success, remote address [%s:%d], handle[%p].",
remoteAddr.get_host_addr(),
remoteAddr.get_port_number(),
pSession);
// 发送RTSP SETUP消息
nRet = pSession->sendMessage(strRtspMsg.c_str(), strRtspMsg.length());
if (RET_OK != nRet)
{
IVS_RUN_LOG_INF("sendSetupMessage failed, remote address [%s:%d], handle[%p] nRet[%d].",
remoteAddr.get_host_addr(),
remoteAddr.get_port_number(),
pSession, nRet);
return nRet;
}
IVS_RUN_LOG_INF("sendSetupMessage succeed, remote address [%s:%d], handle[%p].",
remoteAddr.get_host_addr(),
remoteAddr.get_port_number(),
pSession);
return RET_OK;
}
void WinSockets::parseSocketTable(WinSockTableType sockType,
QueryData& results) {
unsigned int numEntries;
switch (sockType) {
case WinSockTableType::tcp:
numEntries = tcpTable_->dwNumEntries;
break;
case WinSockTableType::tcp6:
numEntries = tcp6Table_->dwNumEntries;
break;
case WinSockTableType::udp:
numEntries = udpTable_->dwNumEntries;
break;
case WinSockTableType::udp6:
numEntries = udp6Table_->dwNumEntries;
break;
default:
numEntries = 0;
break;
}
for (size_t i = 0; i < numEntries; i++) {
Row r;
std::vector<char> localAddr(128, 0x0);
std::vector<char> remoteAddr(128, 0x0);
switch (sockType) {
case WinSockTableType::tcp: {
r["protocol"] = INTEGER(IPPROTO_TCP);
auto tcpLocalAddr = tcpTable_->table[i].dwLocalAddr;
auto retVal =
InetNtopA(AF_INET, &tcpLocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] =
INTEGER(ntohs(static_cast<u_short>(tcpTable_->table[i].dwLocalPort)));
auto tcpRemoteAddr = tcpTable_->table[i].dwRemoteAddr;
retVal = InetNtopA(
AF_INET, &tcpRemoteAddr, remoteAddr.data(), remoteAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network remote address to string: "
<< WSAGetLastError();
}
r["remote_address"] = remoteAddr.data();
r["remote_port"] = INTEGER(
ntohs(static_cast<u_short>(tcpTable_->table[i].dwRemotePort)));
r["pid"] = INTEGER(tcpTable_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET);
break;
}
case WinSockTableType::tcp6: {
r["protocol"] = INTEGER(IPPROTO_TCP);
auto tcp6LocalAddr = tcp6Table_->table[i].ucLocalAddr;
auto retVal = InetNtopA(
AF_INET6, tcp6LocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] = INTEGER(
ntohs(static_cast<u_short>(tcp6Table_->table[i].dwLocalPort)));
auto tcp6RemoteAddr = tcp6Table_->table[i].ucRemoteAddr;
retVal = InetNtopA(
AF_INET6, tcp6RemoteAddr, remoteAddr.data(), remoteAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network remote address to string: "
<< WSAGetLastError();
}
r["remote_address"] = remoteAddr.data();
r["remote_port"] = INTEGER(
ntohs(static_cast<u_short>(tcp6Table_->table[i].dwRemotePort)));
r["pid"] = INTEGER(tcp6Table_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET6);
break;
}
case WinSockTableType::udp: {
r["protocol"] = INTEGER(IPPROTO_UDP);
auto udpLocalAddr = udpTable_->table[i].dwLocalAddr;
auto retVal =
InetNtopA(AF_INET, &udpLocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] =
INTEGER(ntohs(static_cast<u_short>(udpTable_->table[i].dwLocalPort)));
r["remote_address"] = "0";
r["remote_port"] = INTEGER(0);
r["pid"] = INTEGER(udpTable_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET);
break;
}
case WinSockTableType::udp6: {
r["protocol"] = INTEGER(IPPROTO_UDP);
auto udp6LocalAddr = udp6Table_->table[i].ucLocalAddr;
auto retVal = InetNtopA(
AF_INET6, udp6LocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] = INTEGER(
ntohs(static_cast<u_short>(udp6Table_->table[i].dwLocalPort)));
r["remote_address"] = "0";
r["remote_port"] = INTEGER(0);
r["pid"] = INTEGER(udp6Table_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET6);
break;
}
default:
break;
}
r["local_address"] = localAddr.data();
results.push_back(r);
}
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__NETEVNHND__RDCALLBK, "_netEventHandler::_readCallback" )
void _netEventHandler::_readCallback( const boost::system::error_code &
error )
{
PD_TRACE_ENTRY ( SDB__NETEVNHND__RDCALLBK ) ;
if ( error )
{
if ( error.value() == boost::system::errc::operation_canceled ||
error.value() == boost::system::errc::no_such_file_or_directory )
{
PD_LOG ( PDINFO, "connection aborted, node:%d, %d, %d",
_id.columns.groupID, _id.columns.nodeID,
_id.columns.serviceID ) ;
}
else
{
PD_LOG ( PDERROR, "Error received, node:%d, %d, %d, err=%d",
_id.columns.groupID, _id.columns.nodeID,
_id.columns.serviceID, error.value() ) ;
}
goto error_close ;
}
if ( NET_EVENT_HANDLER_STATE_HEADER == _state )
{
if ( ( UINT32 )MSG_SYSTEM_INFO_LEN == (UINT32)_header.messageLength )
{
if ( SDB_OK != _allocateBuf( sizeof(MsgSysInfoRequest) ))
{
goto error_close ;
}
_hasRecvMsg = TRUE ;
ossMemcpy( _buf, &_header, sizeof( MsgSysInfoRequest ) ) ;
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
goto done ;
}
else if ( sizeof(_MsgHeader) > (UINT32)_header.messageLength ||
SDB_MAX_MSG_LENGTH < (UINT32)_header.messageLength )
{
PD_LOG( PDERROR, "Error header[len: %d, opCode: (%d)%d, TID:%d] "
"received, node:%d, %d, %d", _header.messageLength,
IS_REPLY_TYPE(_header.opCode) ? 1 : 0,
GET_REQUEST_TYPE(_header.opCode), _header.TID,
_id.columns.groupID,
_id.columns.nodeID, _id.columns.serviceID ) ;
goto error_close ;
}
else
{
if ( FALSE == _hasRecvMsg )
{
_hasRecvMsg = TRUE ;
_state = NET_EVENT_HANDLER_STATE_HEADER_LAST ;
asyncRead() ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
goto done ;
}
PD_LOG( PDDEBUG, "msg header: [len:%d], [opCode: [%d]%d], "
"[TID:%d], [groupID:%d], [nodeID:%d], "
"[ADDR:%s], [PORT:%d]",
_header.messageLength, IS_REPLY_TYPE(_header.opCode)?1:0,
GET_REQUEST_TYPE(_header.opCode),
_header.TID, _header.routeID.columns.groupID,
_header.routeID.columns.nodeID,
remoteAddr().c_str(), remotePort() ) ;
if ( MSG_INVALID_ROUTEID == _id.value )
{
if ( MSG_INVALID_ROUTEID != _header.routeID.value )
{
_id = _header.routeID ;
_frame->_addRoute( shared_from_this() ) ;
}
}
}
if ( (UINT32)sizeof(_MsgHeader) == (UINT32)_header.messageLength )
{
if ( SDB_OK != _allocateBuf( sizeof(_MsgHeader) ))
{
goto error_close ;
}
ossMemcpy( _buf, &_header, sizeof( _MsgHeader ) ) ;
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
goto done ;
}
#if defined (_LINUX)
try
{
boost::asio::detail::socket_option::boolean<IPPROTO_TCP, TCP_QUICKACK>
quickack( TRUE ) ;
_sock.set_option( quickack ) ;
}
catch ( boost::system::system_error &e )
{
PD_LOG ( PDERROR, "Failed to quick ack: %s", e.what() ) ;
}
#endif // _LINUX
_state = NET_EVENT_HANDLER_STATE_BODY ;
asyncRead() ;
}
else
{
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
}
done:
PD_TRACE_EXIT ( SDB__NETEVNHND__RDCALLBK ) ;
return ;
error_close:
if ( _isConnected )
{
close() ;
}
_frame->handleClose( shared_from_this(), _id ) ;
_frame->_erase( handle() ) ;
goto done ;
}
BOOLEAN _netEventHandler::isLocalConnection() const
{
return localAddr() == remoteAddr() ? TRUE : FALSE ;
}
QTSS_Error LogRequest(QTSS_ClientSessionObject inClientSession,
QTSS_RTSPSessionObject inRTSPSession, QTSS_CliSesClosingReason *inCloseReasonPtr)
{
static StrPtrLen sUnknownStr(sVoidField);
static StrPtrLen sTCPStr("TCP");
static StrPtrLen sUDPStr("UDP");
//Fetch the URL, user agent, movielength & movie bytes to log out of the RTP session
enum {
eTempLogItemSize = 256, // must be same or larger than others
eURLSize = 256,
eUserAgentSize = 256,
ePlayerIDSize = 32,
ePlayerVersionSize = 32,
ePlayerLangSize = 32,
ePlayerOSSize = 32,
ePlayerOSVersSize = 32,
ePlayerCPUSize = 32
};
char tempLogItemBuf[eTempLogItemSize] = { 0 };
StrPtrLen tempLogStr(tempLogItemBuf, eTempLogItemSize - 1);
//
// Check to see if this session is closing because authorization failed. If that's
// the case, we've logged that already, let's not log it twice
UInt32 theLen = 0;
UInt32* authorizationFailed = NULL;
(void)QTSS_GetValuePtr(inClientSession, sLoggedAuthorizationAttrID, 0, (void**)&authorizationFailed, &theLen);
if ((authorizationFailed != NULL) && (*authorizationFailed > 0))
return QTSS_NoErr;
///inClientSession should never be NULL
//inRTSPRequest may be NULL if this is a timeout
OSMutexLocker locker(sLogMutex);
CheckAccessLogState(false);
if (sAccessLog == NULL)
return QTSS_NoErr;
//if logging is on, then log the request... first construct a timestamp
char theDateBuffer[QTSSRollingLog::kMaxDateBufferSizeInBytes];
bool result = QTSSRollingLog::FormatDate(theDateBuffer, sLogTimeInGMT);
//for now, just ignore the error.
if (!result)
theDateBuffer[0] = '\0';
theLen = sizeof(QTSS_RTSPSessionObject);
QTSS_RTSPSessionObject theRTSPSession = inRTSPSession;
if (theRTSPSession == NULL)
(void)QTSS_GetValue(inClientSession, qtssCliSesLastRTSPSession, 0, (void*)&theRTSPSession, &theLen);
// Get lots of neat info to log from the various dictionaries
// Each attribute must be copied out to ensure that it is NULL terminated.
// To ensure NULL termination, just memset the buffers to 0, and make sure that
// the last byte of each array is untouched.
Float32* packetLossPercent = NULL;
Float64* movieDuration = NULL;
UInt64* movieSizeInBytes = NULL;
UInt32* movieAverageBitRatePtr = 0;
UInt32 clientPacketsReceived = 0;
UInt32 clientPacketsLost = 0;
StrPtrLen* theTransportType = &sUnknownStr;
SInt64* theCreateTime = NULL;
SInt64* thePlayTime = NULL;
UInt32 startPlayTimeInSecs = 0;
char localIPAddrBuf[20] = { 0 };
StrPtrLen localIPAddr(localIPAddrBuf, 19);
char localDNSBuf[70] = { 0 };
StrPtrLen localDNS(localDNSBuf, 69);
char remoteDNSBuf[70] = { 0 };
StrPtrLen remoteDNS(remoteDNSBuf, 69);
char remoteAddrBuf[20] = { 0 };
StrPtrLen remoteAddr(remoteAddrBuf, 19);
char playerIDBuf[ePlayerIDSize] = { 0 };
StrPtrLen playerID(playerIDBuf, ePlayerIDSize - 1);
// First, get networking info from the RTSP session
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSessLocalAddrStr, 0, localIPAddr.Ptr, &localIPAddr.Len);
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSessLocalDNS, 0, localDNS.Ptr, &localDNS.Len);
(void)QTSS_GetValue(inClientSession, qtssCliSesHostName, 0, remoteDNS.Ptr, &remoteDNS.Len);
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSessRemoteAddrStr, 0, remoteAddr.Ptr, &remoteAddr.Len);
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSessRemoteAddrStr, 0, playerID.Ptr, &playerID.Len);
UInt32* rtpBytesSent = NULL;
UInt32* rtcpBytesRecv = NULL;
UInt32* rtpPacketsSent = NULL;
// Second, get networking info from the Client's session.
// (Including the stats for incoming RTCP packets.)
char urlBuf[eURLSize] = { 0 };
StrPtrLen url(urlBuf, eURLSize - 1);
(void)QTSS_GetValue(inClientSession, qtssCliSesPresentationURL, 0, url.Ptr, &url.Len);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesPacketLossPercent, 0, (void**)&packetLossPercent, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesMovieDurationInSecs, 0, (void**)&movieDuration, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesMovieSizeInBytes, 0, (void**)&movieSizeInBytes, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesMovieAverageBitRate, 0, (void**)&movieAverageBitRatePtr, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesCreateTimeInMsec, 0, (void**)&theCreateTime, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesFirstPlayTimeInMsec, 0, (void**)&thePlayTime, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesRTPBytesSent, 0, (void**)&rtpBytesSent, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesRTPPacketsSent, 0, (void**)&rtpPacketsSent, &theLen);
(void)QTSS_GetValuePtr(inClientSession, qtssCliSesRTCPBytesRecv, 0, (void**)&rtcpBytesRecv, &theLen);
if (theCreateTime != NULL && thePlayTime != NULL)
startPlayTimeInSecs = (UInt32)(((*theCreateTime - *thePlayTime) / 1000) + 0.5);
// We need a value of 'c-bytes' to report as a log entry. This is supposed to be the total number
// of bytes the client has received during the session. Unfortunately, the QT client does not give
// us this number. We will use the following heuristic formula to estimate the number of bytes the
// client has received during the session:
//
// client-bytes-received = bytes-sent * (100.0 - percent-packet-lost) / 100.0
//
// The 'percent-packet-lost' value has been calculated internally by QTSS based on the RTCP packets
// sent to the server from the client. If those values are accurate then the above formula will not
// be exactly correct but it will be nearly correct.
UInt32 clientBytesRecv = (UInt32)((*rtpBytesSent * (100.0 - *packetLossPercent)) / 100.0);
tempLogStr.Ptr[0] = 0; tempLogStr.Len = eUserAgentSize;
(void)QTSS_GetValue(inClientSession, qtssCliSesFirstUserAgent, 0, tempLogStr.Ptr, &tempLogStr.Len);
char userAgentBuf[eUserAgentSize] = { 0 };
StrPtrLen userAgent(userAgentBuf, eUserAgentSize - 1);
ReplaceSpaces(&tempLogStr, &userAgent, "%20");
UserAgentParser userAgentParser(&userAgent);
// StrPtrLen* playerID = userAgentParser.GetUserID() ;
StrPtrLen* playerVersion = userAgentParser.GetUserVersion();
StrPtrLen* playerLang = userAgentParser.GetUserLanguage();
StrPtrLen* playerOS = userAgentParser.GetrUserOS();
StrPtrLen* playerOSVers = userAgentParser.GetUserOSVersion();
StrPtrLen* playerCPU = userAgentParser.GetUserCPU();
// char playerIDBuf[ePlayerIDSize] = {};
char playerVersionBuf[ePlayerVersionSize] = { 0 };
char playerLangBuf[ePlayerLangSize] = { 0 };
char playerOSBuf[ePlayerOSSize] = { 0 };
char playerOSVersBuf[ePlayerOSVersSize] = { 0 };
char playerCPUBuf[ePlayerCPUSize] = { 0 };
UInt32 size;
// (ePlayerIDSize < playerID->Len ) ? size = ePlayerIDSize -1 : size = playerID->Len;
// if (playerID->Ptr != NULL) memcpy (playerIDBuf, playerID->Ptr, size);
(ePlayerVersionSize < playerVersion->Len) ? size = ePlayerVersionSize - 1 : size = playerVersion->Len;
if (playerVersion->Ptr != NULL) memcpy(playerVersionBuf, playerVersion->Ptr, size);
(ePlayerLangSize < playerLang->Len) ? size = ePlayerLangSize - 1 : size = playerLang->Len;
if (playerLang->Ptr != NULL) memcpy(playerLangBuf, playerLang->Ptr, size);
(ePlayerOSSize < playerOS->Len) ? size = ePlayerOSSize - 1 : size = playerOS->Len;
if (playerOS->Ptr != NULL) memcpy(playerOSBuf, playerOS->Ptr, size);
(ePlayerOSVersSize < playerOSVers->Len) ? size = ePlayerOSVersSize - 1 : size = playerOSVers->Len;
if (playerOSVers->Ptr != NULL) memcpy(playerOSVersBuf, playerOSVers->Ptr, size);
(ePlayerCPUSize < playerCPU->Len) ? size = ePlayerCPUSize - 1 : size = playerCPU->Len;
if (playerCPU->Ptr != NULL) memcpy(playerCPUBuf, playerCPU->Ptr, size);
// clientPacketsReceived, clientPacketsLost, videoPayloadName and audioPayloadName
// are all stored on a per-stream basis, so let's iterate through all the streams,
// finding this information
char videoPayloadNameBuf[32] = { 0 };
StrPtrLen videoPayloadName(videoPayloadNameBuf, 31);
char audioPayloadNameBuf[32] = { 0 };
StrPtrLen audioPayloadName(audioPayloadNameBuf, 31);
UInt32 qualityLevel = 0;
UInt32 clientBufferTime = 0;
UInt32 theStreamIndex = 0;
bool* isTCPPtr = NULL;
QTSS_RTPStreamObject theRTPStreamObject = NULL;
for (UInt32 theStreamObjectLen = sizeof(theRTPStreamObject);
QTSS_GetValue(inClientSession, qtssCliSesStreamObjects, theStreamIndex, (void*)&theRTPStreamObject, &theStreamObjectLen) == QTSS_NoErr;
theStreamIndex++, theStreamObjectLen = sizeof(theRTPStreamObject))
{
UInt32* streamPacketsReceived = NULL;
UInt32* streamPacketsLost = NULL;
(void)QTSS_GetValuePtr(theRTPStreamObject, qtssRTPStrTotPacketsRecv, 0, (void**)&streamPacketsReceived, &theLen);
(void)QTSS_GetValuePtr(theRTPStreamObject, qtssRTPStrTotalLostPackets, 0, (void**)&streamPacketsLost, &theLen);
// Add up packets received and packets lost to come up with a session wide total
if (streamPacketsReceived != NULL)
clientPacketsReceived += *streamPacketsReceived;
if (streamPacketsLost != NULL)
clientPacketsLost += *streamPacketsLost;
// Identify the video and audio codec types
QTSS_RTPPayloadType* thePayloadType = NULL;
(void)QTSS_GetValuePtr(theRTPStreamObject, qtssRTPStrPayloadType, 0, (void**)&thePayloadType, &theLen);
if (thePayloadType != NULL)
{
if (*thePayloadType == qtssVideoPayloadType)
(void)QTSS_GetValue(theRTPStreamObject, qtssRTPStrPayloadName, 0, videoPayloadName.Ptr, &videoPayloadName.Len);
else if (*thePayloadType == qtssAudioPayloadType)
(void)QTSS_GetValue(theRTPStreamObject, qtssRTPStrPayloadName, 0, audioPayloadName.Ptr, &audioPayloadName.Len);
}
// If any one of the streams is being delivered over UDP instead of TCP,
// report in the log that the transport type for this session was UDP.
if (isTCPPtr == NULL)
{
(void)QTSS_GetValuePtr(theRTPStreamObject, qtssRTPStrIsTCP, 0, (void**)&isTCPPtr, &theLen);
if (isTCPPtr != NULL)
{
if (*isTCPPtr == false)
theTransportType = &sUDPStr;
else
theTransportType = &sTCPStr;
}
}
Float32* clientBufferTimePtr = NULL;
(void)QTSS_GetValuePtr(theRTPStreamObject, qtssRTPStrBufferDelayInSecs, 0, (void**)&clientBufferTimePtr, &theLen);
if ((clientBufferTimePtr != NULL) && (*clientBufferTimePtr != 0))
{
if (*clientBufferTimePtr > clientBufferTime)
clientBufferTime = (UInt32)(*clientBufferTimePtr + .5); // round up to full seconds
}
}
// Add the client buffer time to our client start latency (in whole seconds).
startPlayTimeInSecs += clientBufferTime;
if (*rtpPacketsSent == 0) // no packets sent
qualityLevel = 0; // no quality
else
{
if ((clientPacketsReceived == 0) && (clientPacketsLost == 0)) // no info from client
qualityLevel = 100; //so assume 100
else
{
float qualityPercent = (float)clientPacketsReceived / (float)(clientPacketsReceived + clientPacketsLost);
qualityPercent += (float).005; // round up
qualityLevel = (UInt32)((float) 100.0 * qualityPercent); // average of sum of packet counts for all streams
}
}
//we may not have an RTSP request. Assume that the status code is 504 timeout, if there is an RTSP
//request, though, we can find out what the real status code of the response is
static UInt32 sTimeoutCode = 504;
UInt32* theStatusCode = &sTimeoutCode;
theLen = sizeof(UInt32);
(void)QTSS_GetValuePtr(inClientSession, qtssCliRTSPReqRealStatusCode, 0, (void **)&theStatusCode, &theLen);
// qtss_printf("qtssCliRTSPReqRealStatusCode = %" _U32BITARG_ " \n", *theStatusCode);
if (inCloseReasonPtr) do
{
if (*theStatusCode < 300) // it was a succesful RTSP request but...
{
if (*inCloseReasonPtr == qtssCliSesCloseTimeout) // there was a timeout
{
*theStatusCode = sTimeoutCode;
// qtss_printf(" log timeout ");
break;
}
if (*inCloseReasonPtr == qtssCliSesCloseClientTeardown) // there was a teardown
{
static QTSS_CliSesClosingReason sReason = qtssCliSesCloseClientTeardown;
QTSS_CliSesClosingReason* theReasonPtr = &sReason;
theLen = sizeof(QTSS_CliSesTeardownReason);
(void)QTSS_GetValuePtr(inClientSession, qtssCliTeardownReason, 0, (void **)&theReasonPtr, &theLen);
// qtss_printf("qtssCliTeardownReason = %" _U32BITARG_ " \n", *theReasonPtr);
if (*theReasonPtr == qtssCliSesTearDownClientRequest) // the client asked for a tear down
{
// qtss_printf(" client requests teardown ");
break;
}
if (*theReasonPtr == qtssCliSesTearDownUnsupportedMedia) // An error occured while streaming the file.
{
*theStatusCode = 415;
// qtss_printf(" log UnsupportedMedia ");
break;
}
if (*theReasonPtr == qtssCliSesTearDownBroadcastEnded) // a broadcaster stopped broadcasting
{
*theStatusCode = 452;
// qtss_printf(" log broadcast removed ");
break;
}
*theStatusCode = 500; // some unknown reason for cancelling the connection
}
// qtss_printf("return status ");
// just use the qtssCliRTSPReqRealStatusCode for the reason
}
} while (false);
// qtss_printf(" = %" _U32BITARG_ " \n", *theStatusCode);
// Find out what time it is
SInt64 curTime = QTSS_Milliseconds();
UInt32 numCurClients = 0;
theLen = sizeof(numCurClients);
(void)QTSS_GetValue(sServer, qtssRTPSvrCurConn, 0, &numCurClients, &theLen);
/*
IMPORTANT!!!!
Some values such as cpu, #conns, need to be grabbed as the session starts, not when the teardown happened (I think)
*/
#if TESTUNIXTIME
char thetestDateBuffer[QTSSRollingLog::kMaxDateBufferSizeInBytes];
TestUnixTime(QTSS_MilliSecsTo1970Secs(*theCreateTime), thetestDateBuffer);
qtss_printf("%s\n", thetestDateBuffer);
#endif
float zeroFloat = 0;
UInt64 zeroUInt64 = 0;
Float32 fcpuUtilized = 0;
theLen = sizeof(fcpuUtilized);
(void)QTSS_GetValue(sServer, qtssSvrCPULoadPercent, 0, &fcpuUtilized, &theLen);
UInt32 cpuUtilized = (UInt32)fcpuUtilized;
char lastUserName[eTempLogItemSize] = { 0 };
StrPtrLen lastUserNameStr(lastUserName, eTempLogItemSize);
char lastURLRealm[eTempLogItemSize] = { 0 };
StrPtrLen lastURLRealmStr(lastURLRealm, eTempLogItemSize);
//qtss_printf("logging of saved params are in dictionary \n");
tempLogStr.Ptr[0] = 0; tempLogStr.Len = eTempLogItemSize;
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSesUserName, 0, tempLogStr.Ptr, &tempLogStr.Len);
ReplaceSpaces(&tempLogStr, &lastUserNameStr, "%20");
//qtss_printf("qtssRTSPSesLastUserName dictionary item = %s len = %" _S32BITARG_ "\n",lastUserNameStr.Ptr,lastUserNameStr.Len);
tempLogStr.Ptr[0] = 0; tempLogStr.Len = eTempLogItemSize;
(void)QTSS_GetValue(inClientSession, qtssCliRTSPSesURLRealm, 0, tempLogStr.Ptr, &tempLogStr.Len);
ReplaceSpaces(&tempLogStr, &lastURLRealmStr, "%20");
//qtss_printf("qtssRTSPSesLastURLRealm dictionary item = %s len = %" _S32BITARG_ "\n",lastURLRealmStr.Ptr,lastURLRealmStr.Len);
char respMsgBuffer[1024] = { 0 };
StrPtrLen theRespMsg;
(void)QTSS_GetValuePtr(inClientSession, qtssCliRTSPReqRespMsg, 0, (void**)&theRespMsg.Ptr, &theRespMsg.Len);
StrPtrLen respMsgEncoded(respMsgBuffer, 1024 - 1);
SInt32 theErr = StringTranslator::EncodeURL(theRespMsg.Ptr, theRespMsg.Len, respMsgEncoded.Ptr, respMsgEncoded.Len);
if (theErr <= 0)
respMsgEncoded.Ptr[0] = '\0';
else
{
respMsgEncoded.Len = theErr;
respMsgEncoded.Ptr[respMsgEncoded.Len] = '\0';
}
//cs-uri-query
char urlQryBuf[eURLSize] = { 0 };
StrPtrLen urlQry(urlQryBuf, eURLSize - 1);
(void)QTSS_GetValue(inClientSession, qtssCliSesReqQueryString, 0, urlQry.Ptr, &urlQry.Len);
char tempLogBuffer[1024];
char logBuffer[2048];
// compatible fields (no respMsgEncoded field)
::memset(logBuffer, 0, 2048);
qtss_sprintf(tempLogBuffer, "%s ", (remoteAddr.Ptr[0] == '\0') ? sVoidField : remoteAddr.Ptr); //c-ip*
::strcpy(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (theDateBuffer[0] == '\0') ? sVoidField : theDateBuffer); //date* time*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (remoteDNS.Ptr[0] == '\0') ? sVoidField : remoteDNS.Ptr); //c-dns
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (url.Ptr[0] == '\0') ? sVoidField : url.Ptr); //cs-uri-stem*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", startPlayTimeInSecs); //c-starttime
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", theCreateTime == NULL ? (UInt32)0 : (UInt32)(QTSS_MilliSecsTo1970Secs(curTime)
- QTSS_MilliSecsTo1970Secs(*theCreateTime))); //x-duration*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _S32BITARG_ " ", (UInt32)1); //c-rate
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _S32BITARG_ " ", *theStatusCode); //c-status*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerIDBuf[0] == '\0') ? sVoidField : playerIDBuf); //c-playerid*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerVersionBuf[0] == '\0') ? sVoidField : playerVersionBuf); //c-playerversion
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerLangBuf[0] == '\0') ? sVoidField : playerLangBuf); //c-playerlanguage*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (userAgent.Ptr[0] == '\0') ? sVoidField : userAgent.Ptr); //cs(User-Agent)
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerOSBuf[0] == '\0') ? sVoidField : playerOSBuf); //c-os*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerOSVersBuf[0] == '\0') ? sVoidField : playerOSVersBuf); //c-osversion
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (playerCPUBuf[0] == '\0') ? sVoidField : playerCPUBuf); //c-cpu*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%0.0f ", movieDuration == NULL ? zeroFloat : *movieDuration); //filelength in secs*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _64BITARG_ "d ", movieSizeInBytes == NULL ? zeroUInt64 : *movieSizeInBytes); //filesize in bytes*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", movieAverageBitRatePtr == NULL ? (UInt32)0 : *movieAverageBitRatePtr); //avgbandwidth in bits per second
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", "RTP"); //protocol
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (theTransportType->Ptr[0] == '\0') ? sVoidField : theTransportType->Ptr); //transport
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (audioPayloadName.Ptr[0] == '\0') ? sVoidField : audioPayloadName.Ptr); //audiocodec*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (videoPayloadName.Ptr[0] == '\0') ? sVoidField : videoPayloadName.Ptr); //videocodec*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", rtpBytesSent == NULL ? (UInt32)0 : *rtpBytesSent); //sc-bytes*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", rtcpBytesRecv == NULL ? (UInt32)0 : *rtcpBytesRecv); //cs-bytes*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", clientBytesRecv); //c-bytes
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", rtpPacketsSent == NULL ? (UInt32)0 : *rtpPacketsSent); //s-pkts-sent*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", clientPacketsReceived); //c-pkts-recieved
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", clientPacketsLost); //c-pkts-lost-client*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", (UInt32)1); //c-buffercount
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", clientBufferTime); //c-totalbuffertime*
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", qualityLevel); //c-quality
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (localIPAddr.Ptr[0] == '\0') ? sVoidField : localIPAddr.Ptr); //s-ip
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (localDNS.Ptr[0] == '\0') ? sVoidField : localDNS.Ptr); //s-dns
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", numCurClients); //s-totalclients
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%" _U32BITARG_ " ", cpuUtilized); //s-cpu-util
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (urlQry.Ptr[0] == '\0') ? sVoidField : urlQry.Ptr); //cs-uri-query
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (lastUserName[0] == '\0') ? sVoidField : lastUserName); //c-username
::strcat(logBuffer, tempLogBuffer);
qtss_sprintf(tempLogBuffer, "%s ", (lastURLRealm[0] == '\0') ? sVoidField : lastURLRealm); //sc(Realm)
::strcat(logBuffer, tempLogBuffer);
::strcat(logBuffer, "\n");
Assert(::strlen(logBuffer) < 2048);
//finally, write the log message
sAccessLog->WriteToLog(logBuffer, kAllowLogToRoll);
return QTSS_NoErr;
}
void UT_CRtpComm::UT_CRtpComm_SetToAddressL( )
{
TCreateSessionParams params;
TInt err( KErrNone );
TInetAddr aRtpAddr;
TInetAddr aRtcpAddr;
iLocalPort = 7777; // this should be changed to an even number by CRtpComm
/////////////////////////////////////////////////
// This object will be destroyed below
// It is used for testing construction without RTCP on an odd port
TRAP( err, iRtpComm = CRtpComm::NewL( iLocalPort,
iSocketServ,
iConnection,
params,
*this,
EFalse ) );
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
// Check some initial values
if ( iLocalPort != 7776 ||
iRtpComm->iSender[ERTPPort] != NULL ||
iRtpComm->iSender[ERTCPPort] != NULL ||
iRtpComm->iReceiver[ERTPPort] != NULL ||
iRtpComm->iReceiver[ERTCPPort] != NULL )
{
EUNIT_ASSERT ( EFalse );
}
iLocalPort = 5000; // use default port 5000
TInt result( KErrNone );
TBuf8<5> sendBuf;
TBuf8<5> recvBuf;
// Test setting a port to an address
// Run the method
TInetAddr dummyAddr( INET_ADDR( 127, 0, 0, 1 ), 5050 );
TInetAddr remoteAddr( INET_ADDR( 127, 0, 0, 1 ), 5000 );
TInt error = iRtpComm->SetToAddress( ERTPPort, dummyAddr );
EUNIT_ASSERT ( error == KErrNone )
// Test writing synchronously to a port
// Run the method
//
iRtpComm->ConstructSenderL(remoteAddr, dummyAddr);
err = iRtpComm->Send( ERTPPort, sendBuf );
DelayL();
iRtpComm->CancelSend( ERTPPort );
DelayL();
// Check the results
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
// Run the method
TRequestStatus status;
iRtpComm->Send( ERTPPort, sendBuf, status );
EUNIT_ASSERT( KRequestPending == status.Int() );
User::WaitForRequest( iRtpComm->iSender[ERTPPort]->iStatus );
iRtpComm->iSender[ERTPPort]->RunL();
iRtpComm->iSender[ERTPPort]->iStatus = TRequestStatus();
User::WaitForRequest( status );
// Check the results
EUNIT_ASSERT ( status == KErrNone )
// Run the method
iRtpComm->CancelSend( ERTPPort );
DelayL();
// Can't verify success here
// Run the method
iRtpComm->RegisterReceivedNotify( this );
iRtpComm->ConstructReceiverL(EFalse);
// Can't verify success here
err = iRtpComm->Receive( ERTPPort, recvBuf );
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
err = iRtpComm->Send( ERTPPort, sendBuf );
DelayL();
iRtpComm->CancelSend( ERTPPort );
DelayL();
// Check the results
RTP_EUNIT_ASSERT_EQUALS ( err, KErrNone );
RSocket* socket( NULL );
// Run the method
socket = iRtpComm->GetSocket( ERTPPort );
TProtocolDesc desc1, desc2;
socket->Info( desc1 );
iRtpComm->iSocket[ERTPPort].Info( desc2 );
// The info should match
if ( desc1.iAddrFamily != desc2.iAddrFamily ||
desc1.iByteOrder != desc2.iByteOrder ||
desc1.iMessageSize != desc2.iMessageSize ||
desc1.iName != desc2.iName ||
desc1.iNamingServices != desc2.iNamingServices ||
desc1.iProtocol != desc2.iProtocol ||
desc1.iSecurity != desc2.iSecurity ||
desc1.iServiceInfo != desc2.iServiceInfo ||
desc1.iSockType != desc2.iSockType )
{
EUNIT_ASSERT(EFalse);
}
}
