From 493b37c37c3340d9d4683b66002834ad6e969cbf Mon Sep 17 00:00:00 2001 From: f4exb Date: Wed, 28 Feb 2018 00:19:19 +0100 Subject: [PATCH] qrtplib: removed mutex macros --- qrtplib/rtpexternaltransmitter.cpp | 676 ++++----- qrtplib/rtptcptransmitter.cpp | 950 ++++++------ qrtplib/rtpudpv4transmitter.cpp | 1955 ++++++++++++------------ qrtplib/rtpudpv4transmitternobind.cpp | 1958 ++++++++++++------------- 4 files changed, 2626 insertions(+), 2913 deletions(-) diff --git a/qrtplib/rtpexternaltransmitter.cpp b/qrtplib/rtpexternaltransmitter.cpp index bfb578915..1c909f4ad 100644 --- a/qrtplib/rtpexternaltransmitter.cpp +++ b/qrtplib/rtpexternaltransmitter.cpp @@ -42,11 +42,6 @@ #include -#define MAINMUTEX_LOCK -#define MAINMUTEX_UNLOCK -#define WAITMUTEX_LOCK -#define WAITMUTEX_UNLOCK - namespace qrtplib { @@ -82,11 +77,8 @@ int RTPExternalTransmitter::Create(size_t maximumpacketsize, const RTPTransmissi if (!init) return ERR_RTP_EXTERNALTRANS_NOTINIT; - MAINMUTEX_LOCK - if (created) { - MAINMUTEX_UNLOCK return ERR_RTP_EXTERNALTRANS_ALREADYCREATED; } @@ -94,12 +86,10 @@ int RTPExternalTransmitter::Create(size_t maximumpacketsize, const RTPTransmissi if (transparams == 0) { - MAINMUTEX_UNLOCK return ERR_RTP_EXTERNALTRANS_ILLEGALPARAMETERS; } if (transparams->GetTransmissionProtocol() != RTPTransmitter::ExternalProto) { - MAINMUTEX_UNLOCK return ERR_RTP_EXTERNALTRANS_ILLEGALPARAMETERS; } @@ -107,7 +97,6 @@ int RTPExternalTransmitter::Create(size_t maximumpacketsize, const RTPTransmissi if ((status = m_abortDesc.Init()) < 0) { - MAINMUTEX_UNLOCK return status; } m_abortCount = 0; @@ -121,7 +110,6 @@ int RTPExternalTransmitter::Create(size_t maximumpacketsize, const RTPTransmissi waitingfordata = false; created = true; - MAINMUTEX_UNLOCK return 0; } @@ -130,10 +118,8 @@ void RTPExternalTransmitter::Destroy() if (!init) return; - MAINMUTEX_LOCK if (!created) { - MAINMUTEX_UNLOCK; return; } @@ -152,262 +138,223 @@ void RTPExternalTransmitter::Destroy() m_abortDesc.SendAbortSignal(); m_abortCount++; m_abortDesc.Destroy(); - MAINMUTEX_UNLOCK - WAITMUTEX_LOCK // to make sure that the WaitForIncomingData function ended - WAITMUTEX_UNLOCK -} -else - m_abortDesc.Destroy(); + // to make sure that the WaitForIncomingData function ended + + } + else + m_abortDesc.Destroy(); -MAINMUTEX_UNLOCK } RTPTransmissionInfo *RTPExternalTransmitter::GetTransmissionInfo() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK -RTPTransmissionInfo *tinf = new RTPExternalTransmissionInfo(&packetinjector); -MAINMUTEX_UNLOCK -return tinf; + RTPTransmissionInfo *tinf = new RTPExternalTransmissionInfo(&packetinjector); + return tinf; } void RTPExternalTransmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i) { -if (!init) -return; + if (!init) + return; -delete i; + delete i; } int RTPExternalTransmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } -if (localhostname == 0) -{ + if (localhostname == 0) + { // We'll just use 'gethostname' for simplicity -char name[1024]; + char name[1024]; -if (gethostname(name, 1023) != 0) - strcpy(name, "localhost"); // failsafe -else - name[1023] = 0; // ensure null-termination + if (gethostname(name, 1023) != 0) + strcpy(name, "localhost"); // failsafe + else + name[1023] = 0; // ensure null-termination -localhostnamelength = strlen(name); -localhostname = new uint8_t[localhostnamelength + 1]; + localhostnamelength = strlen(name); + localhostname = new uint8_t[localhostnamelength + 1]; -memcpy(localhostname, name, localhostnamelength); -localhostname[localhostnamelength] = 0; -} + memcpy(localhostname, name, localhostnamelength); + localhostname[localhostnamelength] = 0; + } -if ((*bufferlength) < localhostnamelength) -{ -*bufferlength = localhostnamelength; // tell the application the required size of the buffer -MAINMUTEX_UNLOCK -return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; -} + if ((*bufferlength) < localhostnamelength) + { + *bufferlength = localhostnamelength; // tell the application the required size of the buffer + return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; + } -memcpy(buffer, localhostname, localhostnamelength); -*bufferlength = localhostnamelength; + memcpy(buffer, localhostname, localhostnamelength); + *bufferlength = localhostnamelength; -MAINMUTEX_UNLOCK -return 0; + return 0; } bool RTPExternalTransmitter::ComesFromThisTransmitter(const RTPAddress *addr) { -MAINMUTEX_LOCK -bool value = false; -if (sender) -value = sender->ComesFromThisSender(addr); -MAINMUTEX_UNLOCK -return value; + + bool value = false; + if (sender) + value = sender->ComesFromThisSender(addr); + return value; } int RTPExternalTransmitter::Poll() { -return 0; + return 0; } int RTPExternalTransmitter::WaitForIncomingData(const RTPTime &delay, bool *dataavailable) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + if (waitingfordata) + { + return ERR_RTP_EXTERNALTRANS_ALREADYWAITING; + } -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -if (waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_ALREADYWAITING; -} + waitingfordata = true; -waitingfordata = true; + if (!rawpacketlist.empty()) + { + if (dataavailable != 0) + *dataavailable = true; + waitingfordata = false; + return 0; + } -if (!rawpacketlist.empty()) -{ -if (dataavailable != 0) - *dataavailable = true; -waitingfordata = false; -MAINMUTEX_UNLOCK -return 0; -} + int8_t isset = 0; + SocketType abortSock = m_abortDesc.GetAbortSocket(); + int status = RTPSelect(&abortSock, &isset, 1, delay); + if (status < 0) + { -WAITMUTEX_LOCK -MAINMUTEX_UNLOCK + waitingfordata = false; -int8_t isset = 0; -SocketType abortSock = m_abortDesc.GetAbortSocket(); -int status = RTPSelect(&abortSock, &isset, 1, delay); -if (status < 0) -{ -MAINMUTEX_LOCK -waitingfordata = false; -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return status; -} + return status; + } -MAINMUTEX_LOCK -waitingfordata = false; -if (!created) // destroy called -{ -MAINMUTEX_UNLOCK; -WAITMUTEX_UNLOCK -return 0; -} + waitingfordata = false; + if (!created) // destroy called + { - // if aborted, read from abort buffer -if (isset) -{ -m_abortDesc.ClearAbortSignal(); -m_abortCount = 0; -} + return 0; + } -if (dataavailable != 0) -{ -if (rawpacketlist.empty()) - *dataavailable = false; -else - *dataavailable = true; -} + // if aborted, read from abort buffer + if (isset) + { + m_abortDesc.ClearAbortSignal(); + m_abortCount = 0; + } -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return 0; + if (dataavailable != 0) + { + if (rawpacketlist.empty()) + *dataavailable = false; + else + *dataavailable = true; + } + + return 0; } int RTPExternalTransmitter::AbortWait() { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -if (!waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTWAITING; -} + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + if (!waitingfordata) + { + return ERR_RTP_EXTERNALTRANS_NOTWAITING; + } -m_abortDesc.SendAbortSignal(); -m_abortCount++; + m_abortDesc.SendAbortSignal(); + m_abortCount++; -MAINMUTEX_UNLOCK -return 0; + return 0; } int RTPExternalTransmitter::SendRTPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + if (len > maxpacksize) + { + return ERR_RTP_EXTERNALTRANS_SPECIFIEDSIZETOOBIG; + } -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_SPECIFIEDSIZETOOBIG; -} + if (!sender) + { + return ERR_RTP_EXTERNALTRANS_NOSENDER; + } -if (!sender) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOSENDER; -} + if (!sender->SendRTP(data, len)) + return ERR_RTP_EXTERNALTRANS_SENDERROR; -MAINMUTEX_UNLOCK - -if (!sender->SendRTP(data, len)) -return ERR_RTP_EXTERNALTRANS_SENDERROR; - -return 0; + return 0; } int RTPExternalTransmitter::SendRTCPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + if (len > maxpacksize) + { + return ERR_RTP_EXTERNALTRANS_SPECIFIEDSIZETOOBIG; + } -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_SPECIFIEDSIZETOOBIG; -} + if (!sender) + { + return ERR_RTP_EXTERNALTRANS_NOSENDER; + } -if (!sender) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOSENDER; -} -MAINMUTEX_UNLOCK + if (!sender->SendRTCP(data, len)) + return ERR_RTP_EXTERNALTRANS_SENDERROR; -if (!sender->SendRTCP(data, len)) -return ERR_RTP_EXTERNALTRANS_SENDERROR; - -return 0; + return 0; } int RTPExternalTransmitter::AddDestination(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NODESTINATIONSSUPPORTED; + return ERR_RTP_EXTERNALTRANS_NODESTINATIONSSUPPORTED; } int RTPExternalTransmitter::DeleteDestination(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NODESTINATIONSSUPPORTED; + return ERR_RTP_EXTERNALTRANS_NODESTINATIONSSUPPORTED; } void RTPExternalTransmitter::ClearDestinations() @@ -416,17 +363,17 @@ void RTPExternalTransmitter::ClearDestinations() bool RTPExternalTransmitter::SupportsMulticasting() { -return false; + return false; } int RTPExternalTransmitter::JoinMulticastGroup(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOMULTICASTSUPPORT; + return ERR_RTP_EXTERNALTRANS_NOMULTICASTSUPPORT; } int RTPExternalTransmitter::LeaveMulticastGroup(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOMULTICASTSUPPORT; + return ERR_RTP_EXTERNALTRANS_NOMULTICASTSUPPORT; } void RTPExternalTransmitter::LeaveAllMulticastGroups() @@ -435,32 +382,28 @@ void RTPExternalTransmitter::LeaveAllMulticastGroups() int RTPExternalTransmitter::SetReceiveMode(RTPTransmitter::ReceiveMode m) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -if (m != RTPTransmitter::AcceptAll) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_BADRECEIVEMODE; -} -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + if (m != RTPTransmitter::AcceptAll) + { + return ERR_RTP_EXTERNALTRANS_BADRECEIVEMODE; + } + return 0; } int RTPExternalTransmitter::AddToIgnoreList(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOIGNORELIST; + return ERR_RTP_EXTERNALTRANS_NOIGNORELIST; } int RTPExternalTransmitter::DeleteFromIgnoreList(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOIGNORELIST; + return ERR_RTP_EXTERNALTRANS_NOIGNORELIST; } void RTPExternalTransmitter::ClearIgnoreList() @@ -469,12 +412,12 @@ void RTPExternalTransmitter::ClearIgnoreList() int RTPExternalTransmitter::AddToAcceptList(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOACCEPTLIST; + return ERR_RTP_EXTERNALTRANS_NOACCEPTLIST; } int RTPExternalTransmitter::DeleteFromAcceptList(const RTPAddress &) { -return ERR_RTP_EXTERNALTRANS_NOACCEPTLIST; + return ERR_RTP_EXTERNALTRANS_NOACCEPTLIST; } void RTPExternalTransmitter::ClearAcceptList() @@ -483,228 +426,207 @@ void RTPExternalTransmitter::ClearAcceptList() int RTPExternalTransmitter::SetMaximumPacketSize(size_t s) { -if (!init) -return ERR_RTP_EXTERNALTRANS_NOTINIT; + if (!init) + return ERR_RTP_EXTERNALTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_EXTERNALTRANS_NOTCREATED; -} -maxpacksize = s; -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + return ERR_RTP_EXTERNALTRANS_NOTCREATED; + } + maxpacksize = s; + return 0; } bool RTPExternalTransmitter::NewDataAvailable() { -if (!init) -return false; + if (!init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!created) + v = false; + else + { + if (rawpacketlist.empty()) + v = false; + else + v = true; + } -if (!created) -v = false; -else -{ -if (rawpacketlist.empty()) - v = false; -else - v = true; -} - -MAINMUTEX_UNLOCK -return v; + return v; } RTPRawPacket *RTPExternalTransmitter::GetNextPacket() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK + RTPRawPacket *p; -RTPRawPacket *p; + if (!created) + { + return 0; + } + if (rawpacketlist.empty()) + { + return 0; + } -if (!created) -{ -MAINMUTEX_UNLOCK -return 0; -} -if (rawpacketlist.empty()) -{ -MAINMUTEX_UNLOCK -return 0; -} + p = *(rawpacketlist.begin()); + rawpacketlist.pop_front(); -p = *(rawpacketlist.begin()); -rawpacketlist.pop_front(); - -MAINMUTEX_UNLOCK -return p; + return p; } // Here the private functions start... void RTPExternalTransmitter::FlushPackets() { -std::list::const_iterator it; + std::list::const_iterator it; -for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) -delete *it; -rawpacketlist.clear(); + for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) + delete *it; + rawpacketlist.clear(); } void RTPExternalTransmitter::InjectRTP(const void *data, size_t len, const RTPAddress &a) { -if (!init) -return; + if (!init) + return; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return; -} + if (!created) + { + return; + } -RTPAddress *addr = a.CreateCopy(); -if (addr == 0) -return; + RTPAddress *addr = a.CreateCopy(); + if (addr == 0) + return; -uint8_t *datacopy; + uint8_t *datacopy; -datacopy = new uint8_t[len]; -if (datacopy == 0) -{ -delete addr; -return; -} -memcpy(datacopy, data, len); + datacopy = new uint8_t[len]; + if (datacopy == 0) + { + delete addr; + return; + } + memcpy(datacopy, data, len); -RTPTime curtime = RTPTime::CurrentTime(); -RTPRawPacket *pack; + RTPTime curtime = RTPTime::CurrentTime(); + RTPRawPacket *pack; -pack = new RTPRawPacket(datacopy, len, addr, curtime, true); -if (pack == 0) -{ -delete addr; -delete[] localhostname; -return; -} -rawpacketlist.push_back(pack); + pack = new RTPRawPacket(datacopy, len, addr, curtime, true); + if (pack == 0) + { + delete addr; + delete[] localhostname; + return; + } + rawpacketlist.push_back(pack); -if (m_abortCount == 0) -{ -m_abortDesc.SendAbortSignal(); -m_abortCount++; -} + if (m_abortCount == 0) + { + m_abortDesc.SendAbortSignal(); + m_abortCount++; + } -MAINMUTEX_UNLOCK } void RTPExternalTransmitter::InjectRTCP(const void *data, size_t len, const RTPAddress &a) { -if (!init) -return; + if (!init) + return; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return; -} + if (!created) + { + return; + } -RTPAddress *addr = a.CreateCopy(); -if (addr == 0) -return; + RTPAddress *addr = a.CreateCopy(); + if (addr == 0) + return; -uint8_t *datacopy; + uint8_t *datacopy; -datacopy = new uint8_t[len]; -if (datacopy == 0) -{ -delete addr; -return; -} -memcpy(datacopy, data, len); + datacopy = new uint8_t[len]; + if (datacopy == 0) + { + delete addr; + return; + } + memcpy(datacopy, data, len); -RTPTime curtime = RTPTime::CurrentTime(); -RTPRawPacket *pack; + RTPTime curtime = RTPTime::CurrentTime(); + RTPRawPacket *pack; -pack = new RTPRawPacket(datacopy, len, addr, curtime, false); -if (pack == 0) -{ -delete addr; -delete[] localhostname; -return; -} -rawpacketlist.push_back(pack); + pack = new RTPRawPacket(datacopy, len, addr, curtime, false); + if (pack == 0) + { + delete addr; + delete[] localhostname; + return; + } + rawpacketlist.push_back(pack); -if (m_abortCount == 0) -{ -m_abortDesc.SendAbortSignal(); -m_abortCount++; -} + if (m_abortCount == 0) + { + m_abortDesc.SendAbortSignal(); + m_abortCount++; + } -MAINMUTEX_UNLOCK } void RTPExternalTransmitter::InjectRTPorRTCP(const void *data, size_t len, const RTPAddress &a) { -if (!init) -return; + if (!init) + return; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return; -} + if (!created) + { + return; + } -RTPAddress *addr = a.CreateCopy(); -if (addr == 0) -return; + RTPAddress *addr = a.CreateCopy(); + if (addr == 0) + return; -uint8_t *datacopy; -bool rtp = true; + uint8_t *datacopy; + bool rtp = true; -if (len >= 2) -{ -const uint8_t *pData = (const uint8_t *) data; -if (pData[1] >= 200 && pData[1] <= 204) -rtp = false; -} + if (len >= 2) + { + const uint8_t *pData = (const uint8_t *) data; + if (pData[1] >= 200 && pData[1] <= 204) + rtp = false; + } -datacopy = new uint8_t[len]; -if (datacopy == 0) -{ -delete addr; -return; -} -memcpy(datacopy, data, len); + datacopy = new uint8_t[len]; + if (datacopy == 0) + { + delete addr; + return; + } + memcpy(datacopy, data, len); -RTPTime curtime = RTPTime::CurrentTime(); -RTPRawPacket *pack; + RTPTime curtime = RTPTime::CurrentTime(); + RTPRawPacket *pack; -pack = new RTPRawPacket(datacopy, len, addr, curtime, rtp); -if (pack == 0) -{ -delete addr; -delete[] localhostname; -return; -} -rawpacketlist.push_back(pack); + pack = new RTPRawPacket(datacopy, len, addr, curtime, rtp); + if (pack == 0) + { + delete addr; + delete[] localhostname; + return; + } + rawpacketlist.push_back(pack); -if (m_abortCount == 0) -{ -m_abortDesc.SendAbortSignal(); -m_abortCount++; -} - -MAINMUTEX_UNLOCK + if (m_abortCount == 0) + { + m_abortDesc.SendAbortSignal(); + m_abortCount++; + } } diff --git a/qrtplib/rtptcptransmitter.cpp b/qrtplib/rtptcptransmitter.cpp index 428cdb7ef..ce8ce0dde 100644 --- a/qrtplib/rtptcptransmitter.cpp +++ b/qrtplib/rtptcptransmitter.cpp @@ -49,11 +49,6 @@ using namespace std; #define RTPTCPTRANS_MAXPACKSIZE 65535 -#define MAINMUTEX_LOCK -#define MAINMUTEX_UNLOCK -#define WAITMUTEX_LOCK -#define WAITMUTEX_UNLOCK - namespace qrtplib { @@ -89,11 +84,8 @@ int RTPTCPTransmitter::Create(size_t maximumpacketsize __attribute__((unused)), if (!m_init) return ERR_RTP_TCPTRANS_NOTINIT; - MAINMUTEX_LOCK - if (m_created) { - MAINMUTEX_UNLOCK return ERR_RTP_TCPTRANS_ALREADYCREATED; } @@ -105,7 +97,6 @@ int RTPTCPTransmitter::Create(size_t maximumpacketsize __attribute__((unused)), { if (transparams->GetTransmissionProtocol() != RTPTransmitter::TCPProto) { - MAINMUTEX_UNLOCK return ERR_RTP_TCPTRANS_ILLEGALPARAMETERS; } params = static_cast(transparams); @@ -115,7 +106,6 @@ int RTPTCPTransmitter::Create(size_t maximumpacketsize __attribute__((unused)), { if ((status = m_abortDesc.Init()) < 0) { - MAINMUTEX_UNLOCK return status; } m_pAbortDesc = &m_abortDesc; @@ -125,14 +115,12 @@ int RTPTCPTransmitter::Create(size_t maximumpacketsize __attribute__((unused)), m_pAbortDesc = params->GetCreatedAbortDescriptors(); if (!m_pAbortDesc->IsInitialized()) { - MAINMUTEX_UNLOCK return ERR_RTP_ABORTDESC_NOTINIT; } } m_waitingForData = false; m_created = true; - MAINMUTEX_UNLOCK return 0; } @@ -141,10 +129,8 @@ void RTPTCPTransmitter::Destroy() if (!m_init) return; - MAINMUTEX_LOCK if (!m_created) { - MAINMUTEX_UNLOCK; return; } @@ -156,387 +142,346 @@ void RTPTCPTransmitter::Destroy() { m_pAbortDesc->SendAbortSignal(); m_abortDesc.Destroy(); // Doesn't do anything if not initialized - MAINMUTEX_UNLOCK - WAITMUTEX_LOCK// to make sure that the WaitForIncomingData function ended - WAITMUTEX_UNLOCK -} -else - m_abortDesc.Destroy(); // Doesn't do anything if not initialized + // to make sure that the WaitForIncomingData function ended + + } + else + m_abortDesc.Destroy(); // Doesn't do anything if not initialized -MAINMUTEX_UNLOCK } RTPTransmissionInfo *RTPTCPTransmitter::GetTransmissionInfo() { -if (!m_init) -return 0; + if (!m_init) + return 0; -MAINMUTEX_LOCK -RTPTransmissionInfo *tinf = new RTPTCPTransmissionInfo(); -MAINMUTEX_UNLOCK -return tinf; + RTPTransmissionInfo *tinf = new RTPTCPTransmissionInfo(); + return tinf; } void RTPTCPTransmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i) { -if (!m_init) -return; + if (!m_init) + return; -delete i; + delete i; } int RTPTCPTransmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} + if (!m_created) + { + return ERR_RTP_TCPTRANS_NOTCREATED; + } -if (m_localHostname.size() == 0) -{ + if (m_localHostname.size() == 0) + { // // TODO // TODO // TODO // TODO // -m_localHostname.resize(9); -memcpy(&m_localHostname[0], "localhost", m_localHostname.size()); -} + m_localHostname.resize(9); + memcpy(&m_localHostname[0], "localhost", m_localHostname.size()); + } -if ((*bufferlength) < m_localHostname.size()) -{ -*bufferlength = m_localHostname.size(); // tell the application the required size of the buffer -MAINMUTEX_UNLOCK -return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; -} + if ((*bufferlength) < m_localHostname.size()) + { + *bufferlength = m_localHostname.size(); // tell the application the required size of the buffer + return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; + } -memcpy(buffer, &m_localHostname[0], m_localHostname.size()); -*bufferlength = m_localHostname.size(); + memcpy(buffer, &m_localHostname[0], m_localHostname.size()); + *bufferlength = m_localHostname.size(); -MAINMUTEX_UNLOCK -return 0; + return 0; } bool RTPTCPTransmitter::ComesFromThisTransmitter(const RTPAddress *addr) { -if (!m_init) -return false; + if (!m_init) + return false; -if (addr == 0) -return false; + if (addr == 0) + return false; -MAINMUTEX_LOCK + if (!m_created) + return false; -if (!m_created) -return false; + if (addr->GetAddressType() != RTPAddress::TCPAddress) + return false; -if (addr->GetAddressType() != RTPAddress::TCPAddress) -return false; + bool v = false; -bool v = false; + // TODO: for now, we're assuming that we can't just send to the same transmitter - // TODO: for now, we're assuming that we can't just send to the same transmitter - -MAINMUTEX_UNLOCK -return v; + return v; } int RTPTCPTransmitter::Poll() { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} - -std::map::iterator it = m_destSockets.begin(); -std::map::iterator end = m_destSockets.end(); -int status = 0; - -vector errSockets; - -while (it != end) -{ -SocketType sock = it->first; -status = PollSocket(sock, it->second); -if (status < 0) -{ - // Stop immediately on out of memory - if (status == ERR_RTP_OUTOFMEM) - break; - else + if (!m_created) { - errSockets.push_back(sock); - // Don't let this count as an error (due to a closed connection for example), - // otherwise the poll thread (if used) will stop because of this. Since there - // may be more than one connection, that's not desirable in general. - status = 0; + return ERR_RTP_TCPTRANS_NOTCREATED; } -} -++it; -} -MAINMUTEX_UNLOCK -for (size_t i = 0; i < errSockets.size(); i++) -OnReceiveError(errSockets[i]); + std::map::iterator it = m_destSockets.begin(); + std::map::iterator end = m_destSockets.end(); + int status = 0; -return status; + vector errSockets; + + while (it != end) + { + SocketType sock = it->first; + status = PollSocket(sock, it->second); + if (status < 0) + { + // Stop immediately on out of memory + if (status == ERR_RTP_OUTOFMEM) + break; + else + { + errSockets.push_back(sock); + // Don't let this count as an error (due to a closed connection for example), + // otherwise the poll thread (if used) will stop because of this. Since there + // may be more than one connection, that's not desirable in general. + status = 0; + } + } + ++it; + } + + for (size_t i = 0; i < errSockets.size(); i++) + OnReceiveError(errSockets[i]); + + return status; } int RTPTCPTransmitter::WaitForIncomingData(const RTPTime &delay, bool *dataavailable) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK - -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} -if (m_waitingForData) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_ALREADYWAITING; -} - -m_tmpSocks.resize(m_destSockets.size() + 1); -m_tmpFlags.resize(m_tmpSocks.size()); -SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); - -std::map::iterator it = m_destSockets.begin(); -std::map::iterator end = m_destSockets.end(); -int idx = 0; - -while (it != end) -{ -m_tmpSocks[idx] = it->first; -m_tmpFlags[idx] = 0; -++it; -idx++; -} -m_tmpSocks[idx] = abortSocket; -m_tmpFlags[idx] = 0; -int idxAbort = idx; - -m_waitingForData = true; - -WAITMUTEX_LOCK -MAINMUTEX_UNLOCK - - //cout << "Waiting for " << delay.GetDouble() << " seconds for data on " << m_tmpSocks.size() << " sockets" << endl; -int status = RTPSelect(&m_tmpSocks[0], &m_tmpFlags[0], m_tmpSocks.size(), delay); -if (status < 0) -{ -MAINMUTEX_LOCK -m_waitingForData = false; -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return status; -} - -MAINMUTEX_LOCK -m_waitingForData = false; -if (!m_created) // destroy called -{ -MAINMUTEX_UNLOCK; -WAITMUTEX_UNLOCK -return 0; -} - - // if aborted, read from abort buffer -if (m_tmpFlags[idxAbort]) -m_pAbortDesc->ReadSignallingByte(); - -if (dataavailable != 0) -{ -bool avail = false; - -for (size_t i = 0; i < m_tmpFlags.size(); i++) -{ - if (m_tmpFlags[i]) + if (!m_created) { - avail = true; - //cout << "Data available!" << endl; - break; + return ERR_RTP_TCPTRANS_NOTCREATED; + } + if (m_waitingForData) + { + return ERR_RTP_TCPTRANS_ALREADYWAITING; } -} -if (avail) - *dataavailable = true; -else - *dataavailable = false; -} + m_tmpSocks.resize(m_destSockets.size() + 1); + m_tmpFlags.resize(m_tmpSocks.size()); + SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return 0; + std::map::iterator it = m_destSockets.begin(); + std::map::iterator end = m_destSockets.end(); + int idx = 0; + + while (it != end) + { + m_tmpSocks[idx] = it->first; + m_tmpFlags[idx] = 0; + ++it; + idx++; + } + m_tmpSocks[idx] = abortSocket; + m_tmpFlags[idx] = 0; + int idxAbort = idx; + + m_waitingForData = true; + + //cout << "Waiting for " << delay.GetDouble() << " seconds for data on " << m_tmpSocks.size() << " sockets" << endl; + int status = RTPSelect(&m_tmpSocks[0], &m_tmpFlags[0], m_tmpSocks.size(), delay); + if (status < 0) + { + m_waitingForData = false; + + return status; + } + + m_waitingForData = false; + if (!m_created) // destroy called + { + + return 0; + } + + // if aborted, read from abort buffer + if (m_tmpFlags[idxAbort]) + m_pAbortDesc->ReadSignallingByte(); + + if (dataavailable != 0) + { + bool avail = false; + + for (size_t i = 0; i < m_tmpFlags.size(); i++) + { + if (m_tmpFlags[i]) + { + avail = true; + //cout << "Data available!" << endl; + break; + } + } + + if (avail) + *dataavailable = true; + else + *dataavailable = false; + } + + return 0; } int RTPTCPTransmitter::AbortWait() { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} -if (!m_waitingForData) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTWAITING; -} + if (!m_created) + { + return ERR_RTP_TCPTRANS_NOTCREATED; + } + if (!m_waitingForData) + { + return ERR_RTP_TCPTRANS_NOTWAITING; + } -m_pAbortDesc->SendAbortSignal(); + m_pAbortDesc->SendAbortSignal(); -MAINMUTEX_UNLOCK -return 0; + return 0; } int RTPTCPTransmitter::SendRTPData(const void *data, size_t len) { -return SendRTPRTCPData(data, len); + return SendRTPRTCPData(data, len); } int RTPTCPTransmitter::SendRTCPData(const void *data, size_t len) { -return SendRTPRTCPData(data, len); + return SendRTPRTCPData(data, len); } int RTPTCPTransmitter::AddDestination(const RTPAddress &addr) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!m_created) + { + return ERR_RTP_TCPTRANS_NOTCREATED; + } -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} + if (addr.GetAddressType() != RTPAddress::TCPAddress) + { + return ERR_RTP_TCPTRANS_INVALIDADDRESSTYPE; + } -if (addr.GetAddressType() != RTPAddress::TCPAddress) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_INVALIDADDRESSTYPE; -} + const RTPTCPAddress &a = static_cast(addr); + SocketType s = a.GetSocket(); + if (s == 0) + { + return ERR_RTP_TCPTRANS_NOSOCKETSPECIFIED; + } -const RTPTCPAddress &a = static_cast(addr); -SocketType s = a.GetSocket(); -if (s == 0) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOSOCKETSPECIFIED; -} + int status = ValidateSocket(s); + if (status != 0) + { -int status = ValidateSocket(s); -if (status != 0) -{ -MAINMUTEX_UNLOCK -return status; -} + return status; + } -std::map::iterator it = m_destSockets.find(s); -if (it != m_destSockets.end()) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_SOCKETALREADYINDESTINATIONS; -} -m_destSockets[s] = SocketData(); + std::map::iterator it = m_destSockets.find(s); + if (it != m_destSockets.end()) + { - // Because the sockets are also used for incoming data, we'll abort a wait - // that may be in progress, otherwise it could take a few seconds until the - // new socket is monitored for incoming data -m_pAbortDesc->SendAbortSignal(); + return ERR_RTP_TCPTRANS_SOCKETALREADYINDESTINATIONS; + } + m_destSockets[s] = SocketData(); -MAINMUTEX_UNLOCK -return 0; + // Because the sockets are also used for incoming data, we'll abort a wait + // that may be in progress, otherwise it could take a few seconds until the + // new socket is monitored for incoming data + m_pAbortDesc->SendAbortSignal(); + + return 0; } int RTPTCPTransmitter::DeleteDestination(const RTPAddress &addr) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!m_created) + { -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} + return ERR_RTP_TCPTRANS_NOTCREATED; + } -if (addr.GetAddressType() != RTPAddress::TCPAddress) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_INVALIDADDRESSTYPE; -} + if (addr.GetAddressType() != RTPAddress::TCPAddress) + { -const RTPTCPAddress &a = static_cast(addr); -SocketType s = a.GetSocket(); -if (s == 0) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOSOCKETSPECIFIED; -} + return ERR_RTP_TCPTRANS_INVALIDADDRESSTYPE; + } -std::map::iterator it = m_destSockets.find(s); -if (it == m_destSockets.end()) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_SOCKETNOTFOUNDINDESTINATIONS; -} + const RTPTCPAddress &a = static_cast(addr); + SocketType s = a.GetSocket(); + if (s == 0) + { - // Clean up possibly allocated memory -uint8_t *pBuf = it->second.ExtractDataBuffer(); -if (pBuf) -delete[] pBuf; + return ERR_RTP_TCPTRANS_NOSOCKETSPECIFIED; + } -m_destSockets.erase(it); + std::map::iterator it = m_destSockets.find(s); + if (it == m_destSockets.end()) + { -MAINMUTEX_UNLOCK -return 0; + return ERR_RTP_TCPTRANS_SOCKETNOTFOUNDINDESTINATIONS; + } + + // Clean up possibly allocated memory + uint8_t *pBuf = it->second.ExtractDataBuffer(); + if (pBuf) + delete[] pBuf; + + m_destSockets.erase(it); + + return 0; } void RTPTCPTransmitter::ClearDestinations() { -if (!m_init) -return; + if (!m_init) + return; + + if (m_created) + ClearDestSockets(); -MAINMUTEX_LOCK -if (m_created) -ClearDestSockets(); -MAINMUTEX_UNLOCK } bool RTPTCPTransmitter::SupportsMulticasting() { -return false; + return false; } int RTPTCPTransmitter::JoinMulticastGroup(const RTPAddress &) { -return ERR_RTP_TCPTRANS_NOMULTICASTSUPPORT; + return ERR_RTP_TCPTRANS_NOMULTICASTSUPPORT; } int RTPTCPTransmitter::LeaveMulticastGroup(const RTPAddress &) { -return ERR_RTP_TCPTRANS_NOMULTICASTSUPPORT; + return ERR_RTP_TCPTRANS_NOMULTICASTSUPPORT; } void RTPTCPTransmitter::LeaveAllMulticastGroups() @@ -545,19 +490,19 @@ void RTPTCPTransmitter::LeaveAllMulticastGroups() int RTPTCPTransmitter::SetReceiveMode(RTPTransmitter::ReceiveMode m) { -if (m != RTPTransmitter::AcceptAll) -return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; -return 0; + if (m != RTPTransmitter::AcceptAll) + return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; + return 0; } int RTPTCPTransmitter::AddToIgnoreList(const RTPAddress &) { -return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; + return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; } int RTPTCPTransmitter::DeleteFromIgnoreList(const RTPAddress &) { -return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; + return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; } void RTPTCPTransmitter::ClearIgnoreList() @@ -566,12 +511,12 @@ void RTPTCPTransmitter::ClearIgnoreList() int RTPTCPTransmitter::AddToAcceptList(const RTPAddress &) { -return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; + return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; } int RTPTCPTransmitter::DeleteFromAcceptList(const RTPAddress &) { -return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; + return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED; } void RTPTCPTransmitter::ClearAcceptList() @@ -580,317 +525,306 @@ void RTPTCPTransmitter::ClearAcceptList() int RTPTCPTransmitter::SetMaximumPacketSize(size_t s) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} -if (s > RTPTCPTRANS_MAXPACKSIZE) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_SPECIFIEDSIZETOOBIG; -} -m_maxPackSize = s; -MAINMUTEX_UNLOCK -return 0; + if (!m_created) + { + + return ERR_RTP_TCPTRANS_NOTCREATED; + } + if (s > RTPTCPTRANS_MAXPACKSIZE) + { + + return ERR_RTP_TCPTRANS_SPECIFIEDSIZETOOBIG; + } + m_maxPackSize = s; + + return 0; } bool RTPTCPTransmitter::NewDataAvailable() { -if (!m_init) -return false; + if (!m_init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!m_created) + v = false; + else + { + if (m_rawpacketlist.empty()) + v = false; + else + v = true; + } -if (!m_created) -v = false; -else -{ -if (m_rawpacketlist.empty()) -v = false; -else -v = true; -} - -MAINMUTEX_UNLOCK -return v; + return v; } RTPRawPacket *RTPTCPTransmitter::GetNextPacket() { -if (!m_init) -return 0; + if (!m_init) + return 0; -MAINMUTEX_LOCK + RTPRawPacket *p; -RTPRawPacket *p; + if (!m_created) + { -if (!m_created) -{ -MAINMUTEX_UNLOCK -return 0; -} -if (m_rawpacketlist.empty()) -{ -MAINMUTEX_UNLOCK -return 0; -} + return 0; + } + if (m_rawpacketlist.empty()) + { -p = *(m_rawpacketlist.begin()); -m_rawpacketlist.pop_front(); + return 0; + } -MAINMUTEX_UNLOCK -return p; + p = *(m_rawpacketlist.begin()); + m_rawpacketlist.pop_front(); + + return p; } // Here the private functions start... void RTPTCPTransmitter::FlushPackets() { -std::list::const_iterator it; + std::list::const_iterator it; -for (it = m_rawpacketlist.begin(); it != m_rawpacketlist.end(); ++it) -delete *it; -m_rawpacketlist.clear(); + for (it = m_rawpacketlist.begin(); it != m_rawpacketlist.end(); ++it) + delete *it; + m_rawpacketlist.clear(); } int RTPTCPTransmitter::PollSocket(SocketType sock, SocketData &sdata) { #ifdef RTP_SOCKETTYPE_WINSOCK -unsigned long len; + unsigned long len; #else -size_t len; + size_t len; #endif // RTP_SOCKETTYPE_WINSOCK -bool dataavailable; + bool dataavailable; -do -{ -len = 0; -RTPIOCTL(sock, FIONREAD, &len); - -if (len <= 0) -dataavailable = false; -else -dataavailable = true; - -if (dataavailable) -{ -RTPTime curtime = RTPTime::CurrentTime(); -int relevantLen = RTPTCPTRANS_MAXPACKSIZE + 2; - -if ((int) len < relevantLen) - relevantLen = (int) len; - -bool complete = false; -int status = sdata.ProcessAvailableBytes(sock, relevantLen, complete); -if (status < 0) - return status; - -if (complete) -{ - uint8_t *pBuf = sdata.ExtractDataBuffer(); - if (pBuf) + do { - int dataLength = sdata.m_dataLength; - sdata.Reset(); + len = 0; + RTPIOCTL(sock, FIONREAD, &len); - RTPTCPAddress *pAddr = new RTPTCPAddress(sock); - if (pAddr == 0) - return ERR_RTP_OUTOFMEM; + if (len <= 0) + dataavailable = false; + else + dataavailable = true; - bool isrtp = true; - if (dataLength > (int) sizeof(RTCPCommonHeader)) + if (dataavailable) { - RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) pBuf; - uint8_t packettype = rtcpheader->packettype; + RTPTime curtime = RTPTime::CurrentTime(); + int relevantLen = RTPTCPTRANS_MAXPACKSIZE + 2; - if (packettype >= 200 && packettype <= 204) - isrtp = false; + if ((int) len < relevantLen) + relevantLen = (int) len; + + bool complete = false; + int status = sdata.ProcessAvailableBytes(sock, relevantLen, complete); + if (status < 0) + return status; + + if (complete) + { + uint8_t *pBuf = sdata.ExtractDataBuffer(); + if (pBuf) + { + int dataLength = sdata.m_dataLength; + sdata.Reset(); + + RTPTCPAddress *pAddr = new RTPTCPAddress(sock); + if (pAddr == 0) + return ERR_RTP_OUTOFMEM; + + bool isrtp = true; + if (dataLength > (int) sizeof(RTCPCommonHeader)) + { + RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) pBuf; + uint8_t packettype = rtcpheader->packettype; + + if (packettype >= 200 && packettype <= 204) + isrtp = false; + } + + RTPRawPacket *pPack = new RTPRawPacket(pBuf, dataLength, pAddr, curtime, isrtp); + if (pPack == 0) + { + delete pAddr; + delete[] pBuf; + return ERR_RTP_OUTOFMEM; + } + m_rawpacketlist.push_back(pPack); + } + } } + } while (dataavailable); - RTPRawPacket *pPack = new RTPRawPacket(pBuf, dataLength, pAddr, curtime, isrtp); - if (pPack == 0) - { - delete pAddr; - delete[] pBuf; - return ERR_RTP_OUTOFMEM; - } - m_rawpacketlist.push_back(pPack); - } -} -} -} while (dataavailable); - -return 0; + return 0; } int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len) { -if (!m_init) -return ERR_RTP_TCPTRANS_NOTINIT; + if (!m_init) + return ERR_RTP_TCPTRANS_NOTINIT; -MAINMUTEX_LOCK + if (!m_created) + { -if (!m_created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_NOTCREATED; -} -if (len > RTPTCPTRANS_MAXPACKSIZE) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_TCPTRANS_SPECIFIEDSIZETOOBIG; -} + return ERR_RTP_TCPTRANS_NOTCREATED; + } + if (len > RTPTCPTRANS_MAXPACKSIZE) + { -std::map::iterator it = m_destSockets.begin(); -std::map::iterator end = m_destSockets.end(); + return ERR_RTP_TCPTRANS_SPECIFIEDSIZETOOBIG; + } -vector errSockets; -int flags = 0; + std::map::iterator it = m_destSockets.begin(); + std::map::iterator end = m_destSockets.end(); + + vector errSockets; + int flags = 0; #ifdef RTP_HAVE_MSG_NOSIGNAL -flags = MSG_NOSIGNAL; + flags = MSG_NOSIGNAL; #endif // RTP_HAVE_MSG_NOSIGNAL -while (it != end) -{ -uint8_t lengthBytes[2] = -{ (uint8_t) ((len >> 8) & 0xff), (uint8_t) (len & 0xff) }; -SocketType sock = it->first; + while (it != end) + { + uint8_t lengthBytes[2] = + { (uint8_t) ((len >> 8) & 0xff), (uint8_t) (len & 0xff) }; + SocketType sock = it->first; -if (send(sock, (const char *) lengthBytes, 2, flags) < 0 || send(sock, (const char *) data, len, flags) < 0) -errSockets.push_back(sock); -++it; -} + if (send(sock, (const char *) lengthBytes, 2, flags) < 0 || send(sock, (const char *) data, len, flags) < 0) + errSockets.push_back(sock); + ++it; + } -MAINMUTEX_UNLOCK + if (errSockets.size() != 0) + { + for (size_t i = 0; i < errSockets.size(); i++) + OnSendError(errSockets[i]); + } -if (errSockets.size() != 0) -{ -for (size_t i = 0; i < errSockets.size(); i++) -OnSendError(errSockets[i]); -} + // Don't return an error code to avoid the poll thread exiting + // due to one closed connection for example - // Don't return an error code to avoid the poll thread exiting - // due to one closed connection for example - -return 0; + return 0; } int RTPTCPTransmitter::ValidateSocket(SocketType) { - // TODO: should we even do a check (for a TCP socket)? -return 0; + // TODO: should we even do a check (for a TCP socket)? + return 0; } void RTPTCPTransmitter::ClearDestSockets() { -std::map::iterator it = m_destSockets.begin(); -std::map::iterator end = m_destSockets.end(); + std::map::iterator it = m_destSockets.begin(); + std::map::iterator end = m_destSockets.end(); -while (it != end) -{ -uint8_t *pBuf = it->second.ExtractDataBuffer(); -if (pBuf) -delete[] pBuf; + while (it != end) + { + uint8_t *pBuf = it->second.ExtractDataBuffer(); + if (pBuf) + delete[] pBuf; -++it; -} -m_destSockets.clear(); + ++it; + } + m_destSockets.clear(); } RTPTCPTransmitter::SocketData::SocketData() { -Reset(); + Reset(); } void RTPTCPTransmitter::SocketData::Reset() { -m_lengthBufferOffset = 0; -m_dataLength = 0; -m_dataBufferOffset = 0; -m_pDataBuffer = 0; + m_lengthBufferOffset = 0; + m_dataLength = 0; + m_dataBufferOffset = 0; + m_pDataBuffer = 0; } RTPTCPTransmitter::SocketData::~SocketData() { -assert(m_pDataBuffer == 0); // Should be deleted externally to avoid storing a memory manager in the class + assert(m_pDataBuffer == 0); // Should be deleted externally to avoid storing a memory manager in the class } int RTPTCPTransmitter::SocketData::ProcessAvailableBytes(SocketType sock, int availLen, bool &complete) { -const int numLengthBuffer = 2; -if (m_lengthBufferOffset < numLengthBuffer) // first we need to get the length -{ -assert(m_pDataBuffer == 0); -int num = numLengthBuffer - m_lengthBufferOffset; -if (num > availLen) -num = availLen; + const int numLengthBuffer = 2; + if (m_lengthBufferOffset < numLengthBuffer) // first we need to get the length + { + assert(m_pDataBuffer == 0); + int num = numLengthBuffer - m_lengthBufferOffset; + if (num > availLen) + num = availLen; -int r = 0; -if (num > 0) -{ -r = (int) recv(sock, (char *) (m_lengthBuffer + m_lengthBufferOffset), num, 0); -if (r < 0) - return ERR_RTP_TCPTRANS_ERRORINRECV; -} + int r = 0; + if (num > 0) + { + r = (int) recv(sock, (char *) (m_lengthBuffer + m_lengthBufferOffset), num, 0); + if (r < 0) + return ERR_RTP_TCPTRANS_ERRORINRECV; + } -m_lengthBufferOffset += r; -availLen -= r; + m_lengthBufferOffset += r; + availLen -= r; -assert(m_lengthBufferOffset <= numLengthBuffer); -if (m_lengthBufferOffset == numLengthBuffer) // we can constuct a length -{ -int l = 0; -for (int i = numLengthBuffer - 1, shift = 0; i >= 0; i--, shift += 8) - l |= ((int) m_lengthBuffer[i]) << shift; + assert(m_lengthBufferOffset <= numLengthBuffer); + if (m_lengthBufferOffset == numLengthBuffer) // we can constuct a length + { + int l = 0; + for (int i = numLengthBuffer - 1, shift = 0; i >= 0; i--, shift += 8) + l |= ((int) m_lengthBuffer[i]) << shift; -m_dataLength = l; -m_dataBufferOffset = 0; + m_dataLength = l; + m_dataBufferOffset = 0; //cout << "Expecting " << m_dataLength << " bytes" << endl; // avoid allocation of length 0 -if (l == 0) - l = 1; + if (l == 0) + l = 1; // We don't yet know if it's an RTP or RTCP packet, so we'll stick to RTP -m_pDataBuffer = new uint8_t[l]; -if (m_pDataBuffer == 0) - return ERR_RTP_OUTOFMEM; -} -} + m_pDataBuffer = new uint8_t[l]; + if (m_pDataBuffer == 0) + return ERR_RTP_OUTOFMEM; + } + } -if (m_lengthBufferOffset == numLengthBuffer && m_pDataBuffer) // the last one is to make sure we didn't run out of memory -{ -if (m_dataBufferOffset < m_dataLength) -{ -int num = m_dataLength - m_dataBufferOffset; -if (num > availLen) - num = availLen; + if (m_lengthBufferOffset == numLengthBuffer && m_pDataBuffer) // the last one is to make sure we didn't run out of memory + { + if (m_dataBufferOffset < m_dataLength) + { + int num = m_dataLength - m_dataBufferOffset; + if (num > availLen) + num = availLen; -int r = 0; -if (num > 0) -{ - r = (int) recv(sock, (char *) (m_pDataBuffer + m_dataBufferOffset), num, 0); - if (r < 0) - return ERR_RTP_TCPTRANS_ERRORINRECV; -} + int r = 0; + if (num > 0) + { + r = (int) recv(sock, (char *) (m_pDataBuffer + m_dataBufferOffset), num, 0); + if (r < 0) + return ERR_RTP_TCPTRANS_ERRORINRECV; + } -m_dataBufferOffset += r; -availLen -= r; -} + m_dataBufferOffset += r; + availLen -= r; + } -if (m_dataBufferOffset == m_dataLength) -complete = true; -} -return 0; + if (m_dataBufferOffset == m_dataLength) + complete = true; + } + return 0; } } // end namespace diff --git a/qrtplib/rtpudpv4transmitter.cpp b/qrtplib/rtpudpv4transmitter.cpp index c687f8f93..47cc89aac 100644 --- a/qrtplib/rtpudpv4transmitter.cpp +++ b/qrtplib/rtpudpv4transmitter.cpp @@ -59,10 +59,6 @@ using namespace std; mreq.imr_interface.s_addr = htonl(mcastifaceIP);\ status = setsockopt(socket,IPPROTO_IP,type,(const char *)&mreq,sizeof(struct ip_mreq));\ } -#define MAINMUTEX_LOCK -#define MAINMUTEX_UNLOCK -#define WAITMUTEX_LOCK -#define WAITMUTEX_UNLOCK #define CLOSESOCKETS do { \ if (closesocketswhendone) \ @@ -269,11 +265,9 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (!init) return ERR_RTP_UDPV4TRANS_NOTINIT; - MAINMUTEX_LOCK - if (created) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_ALREADYCREATED; } @@ -285,7 +279,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP { if (transparams->GetTransmissionProtocol() != RTPTransmitter::IPv4UDPProto) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_ILLEGALPARAMETERS; } params = (const RTPUDPv4TransmissionParams *) transparams; @@ -299,13 +293,13 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP int status = GetIPv4SocketPort(rtpsock, &m_rtpPort); if (status < 0) { - MAINMUTEX_UNLOCK + return status; } status = GetIPv4SocketPort(rtcpsock, &m_rtcpPort); if (status < 0) { - MAINMUTEX_UNLOCK + return status; } } @@ -318,7 +312,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP int status = GetAutoSockets(params->GetBindIP(), params->GetAllowOddPortbase(), params->GetRTCPMultiplexing(), &rtpsock, &rtcpsock, &m_rtpPort, &m_rtcpPort); if (status < 0) { - MAINMUTEX_UNLOCK + return status; } } @@ -327,7 +321,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP // Check if portbase is even (if necessary) if (!params->GetAllowOddPortbase() && params->GetPortbase() % 2 != 0) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_PORTBASENOTEVEN; } @@ -336,7 +330,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP rtpsock = socket(PF_INET, SOCK_DGRAM, 0); if (rtpsock == RTPSOCKERR) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET; } @@ -349,7 +343,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (rtcpsock == RTPSOCKERR) { RTPCLOSE(rtpsock); - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET; } } @@ -367,7 +361,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (bind(rtpsock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTBINDRTPSOCKET; } @@ -390,7 +384,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (bind(rtcpsock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTBINDRTCPSOCKET; } @@ -406,14 +400,14 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (setsockopt(rtpsock, SOL_SOCKET, SO_RCVBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTPRECEIVEBUF; } size = params->GetRTPSendBuffer(); if (setsockopt(rtpsock, SOL_SOCKET, SO_SNDBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTPTRANSMITBUF; } @@ -423,14 +417,14 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (setsockopt(rtcpsock, SOL_SOCKET, SO_RCVBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTCPRECEIVEBUF; } size = params->GetRTCPSendBuffer(); if (setsockopt(rtcpsock, SOL_SOCKET, SO_SNDBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTCPTRANSMITBUF; } } @@ -446,7 +440,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if ((status = CreateLocalIPList()) < 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return status; } } @@ -463,7 +457,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (maximumpacketsize > RTPUDPV4TRANS_MAXPACKSIZE) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; } @@ -472,7 +466,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if ((status = m_abortDesc.Init()) < 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return status; } m_pAbortDesc = &m_abortDesc; @@ -483,7 +477,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP if (!m_pAbortDesc->IsInitialized()) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_ABORTDESC_NOTINIT; } } @@ -498,7 +492,7 @@ int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionP waitingfordata = false; created = true; - MAINMUTEX_UNLOCK + return 0; } @@ -507,10 +501,9 @@ void RTPUDPv4Transmitter::Destroy() if (!init) return; - MAINMUTEX_LOCK if (!created) { - MAINMUTEX_UNLOCK; + ; return; } @@ -535,605 +528,563 @@ void RTPUDPv4Transmitter::Destroy() { m_pAbortDesc->SendAbortSignal(); m_abortDesc.Destroy(); // Doesn't do anything if not initialized - MAINMUTEX_UNLOCK - WAITMUTEX_LOCK// to make sure that the WaitForIncomingData function ended - WAITMUTEX_UNLOCK -} -else - m_abortDesc.Destroy(); // Doesn't do anything if not initialized -MAINMUTEX_UNLOCK + // to make sure that the WaitForIncomingData function ended + + } + else + m_abortDesc.Destroy(); // Doesn't do anything if not initialized + } RTPTransmissionInfo *RTPUDPv4Transmitter::GetTransmissionInfo() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK -RTPTransmissionInfo *tinf = new RTPUDPv4TransmissionInfo(localIPs, rtpsock, rtcpsock, m_rtpPort, m_rtcpPort); -MAINMUTEX_UNLOCK -return tinf; + RTPTransmissionInfo *tinf = new RTPUDPv4TransmissionInfo(localIPs, rtpsock, rtcpsock, m_rtpPort, m_rtcpPort); + + return tinf; } void RTPUDPv4Transmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i) { -if (!init) -return; + if (!init) + return; -delete i; + delete i; } int RTPUDPv4Transmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} - -if (localhostname == 0) -{ -if (localIPs.empty()) -{ - MAINMUTEX_UNLOCK - return ERR_RTP_UDPV4TRANS_NOLOCALIPS; -} - -std::list::const_iterator it; -std::list hostnames; - -for (it = localIPs.begin(); it != localIPs.end(); it++) -{ - bool founddouble = false; - bool foundentry = true; - - while (!founddouble && foundentry) + if (!created) { - struct hostent *he; - uint8_t addr[4]; - uint32_t ip = (*it); - addr[0] = (uint8_t) ((ip >> 24) & 0xFF); - addr[1] = (uint8_t) ((ip >> 16) & 0xFF); - addr[2] = (uint8_t) ((ip >> 8) & 0xFF); - addr[3] = (uint8_t) (ip & 0xFF); - he = gethostbyaddr((char *) addr, 4, AF_INET); - if (he != 0) + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + + if (localhostname == 0) + { + if (localIPs.empty()) + { + + return ERR_RTP_UDPV4TRANS_NOLOCALIPS; + } + + std::list::const_iterator it; + std::list hostnames; + + for (it = localIPs.begin(); it != localIPs.end(); it++) + { + bool founddouble = false; + bool foundentry = true; + + while (!founddouble && foundentry) + { + struct hostent *he; + uint8_t addr[4]; + uint32_t ip = (*it); + + addr[0] = (uint8_t) ((ip >> 24) & 0xFF); + addr[1] = (uint8_t) ((ip >> 16) & 0xFF); + addr[2] = (uint8_t) ((ip >> 8) & 0xFF); + addr[3] = (uint8_t) (ip & 0xFF); + he = gethostbyaddr((char *) addr, 4, AF_INET); + if (he != 0) + { + std::string hname = std::string(he->h_name); + std::list::const_iterator it; + + for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) + if ((*it) == hname) + founddouble = true; + + if (!founddouble) + hostnames.push_back(hname); + + int i = 0; + while (!founddouble && he->h_aliases[i] != 0) + { + std::string hname = std::string(he->h_aliases[i]); + + for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) + if ((*it) == hname) + founddouble = true; + + if (!founddouble) + { + hostnames.push_back(hname); + i++; + } + } + } + else + foundentry = false; + } + } + + bool found = false; + + if (!hostnames.empty()) // try to select the most appropriate hostname { - std::string hname = std::string(he->h_name); std::list::const_iterator it; - for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) - if ((*it) == hname) - founddouble = true; - - if (!founddouble) - hostnames.push_back(hname); - - int i = 0; - while (!founddouble && he->h_aliases[i] != 0) + hostnames.sort(); + for (it = hostnames.begin(); !found && it != hostnames.end(); it++) { - std::string hname = std::string(he->h_aliases[i]); - - for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) - if ((*it) == hname) - founddouble = true; - - if (!founddouble) + if ((*it).find('.') != std::string::npos) { - hostnames.push_back(hname); - i++; + found = true; + localhostnamelength = (*it).length(); + localhostname = new uint8_t[localhostnamelength + 1]; + if (localhostname == 0) + { + + return ERR_RTP_OUTOFMEM; + } + memcpy(localhostname, (*it).c_str(), localhostnamelength); + localhostname[localhostnamelength] = 0; } } } - else - foundentry = false; - } -} -bool found = false; - -if (!hostnames.empty()) // try to select the most appropriate hostname -{ - std::list::const_iterator it; - - hostnames.sort(); - for (it = hostnames.begin(); !found && it != hostnames.end(); it++) - { - if ((*it).find('.') != std::string::npos) + if (!found) // use an IP address { - found = true; - localhostnamelength = (*it).length(); + uint32_t ip; + int len; + char str[16]; + + it = localIPs.begin(); + ip = (*it); + + RTP_SNPRINTF(str, 16, "%d.%d.%d.%d", (int) ((ip >> 24) & 0xFF), (int) ((ip >> 16) & 0xFF), (int) ((ip >> 8) & 0xFF), (int) (ip & 0xFF)); + len = strlen(str); + + localhostnamelength = len; localhostname = new uint8_t[localhostnamelength + 1]; if (localhostname == 0) { - MAINMUTEX_UNLOCK + return ERR_RTP_OUTOFMEM; } - memcpy(localhostname, (*it).c_str(), localhostnamelength); + memcpy(localhostname, str, localhostnamelength); localhostname[localhostnamelength] = 0; } } -} -if (!found) // use an IP address -{ - uint32_t ip; - int len; - char str[16]; - - it = localIPs.begin(); - ip = (*it); - - RTP_SNPRINTF(str, 16, "%d.%d.%d.%d", (int) ((ip >> 24) & 0xFF), (int) ((ip >> 16) & 0xFF), (int) ((ip >> 8) & 0xFF), (int) (ip & 0xFF)); - len = strlen(str); - - localhostnamelength = len; - localhostname = new uint8_t[localhostnamelength + 1]; - if (localhostname == 0) + if ((*bufferlength) < localhostnamelength) { - MAINMUTEX_UNLOCK - return ERR_RTP_OUTOFMEM; + *bufferlength = localhostnamelength; // tell the application the required size of the buffer + + return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; } - memcpy(localhostname, str, localhostnamelength); - localhostname[localhostnamelength] = 0; -} -} -if ((*bufferlength) < localhostnamelength) -{ -*bufferlength = localhostnamelength; // tell the application the required size of the buffer -MAINMUTEX_UNLOCK -return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; -} + memcpy(buffer, localhostname, localhostnamelength); + *bufferlength = localhostnamelength; -memcpy(buffer, localhostname, localhostnamelength); -*bufferlength = localhostnamelength; - -MAINMUTEX_UNLOCK -return 0; + return 0; } bool RTPUDPv4Transmitter::ComesFromThisTransmitter(const RTPAddress *addr) { -if (!init) -return false; + if (!init) + return false; -if (addr == 0) -return false; + if (addr == 0) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (created && addr->GetAddressType() == RTPAddress::IPv4Address) + { + const RTPIPv4Address *addr2 = (const RTPIPv4Address *) addr; + bool found = false; + std::list::const_iterator it; -if (created && addr->GetAddressType() == RTPAddress::IPv4Address) -{ -const RTPIPv4Address *addr2 = (const RTPIPv4Address *) addr; -bool found = false; -std::list::const_iterator it; + it = localIPs.begin(); + while (!found && it != localIPs.end()) + { + if (addr2->GetIP() == *it) + found = true; + else + ++it; + } -it = localIPs.begin(); -while (!found && it != localIPs.end()) -{ - if (addr2->GetIP() == *it) - found = true; - else - ++it; -} - -if (!found) - v = false; -else -{ - if (addr2->GetPort() == m_rtpPort || addr2->GetPort() == m_rtcpPort) // check for RTP port and RTCP port - v = true; + if (!found) + v = false; + else + { + if (addr2->GetPort() == m_rtpPort || addr2->GetPort() == m_rtcpPort) // check for RTP port and RTCP port + v = true; + else + v = false; + } + } else v = false; -} -} -else -v = false; -MAINMUTEX_UNLOCK -return v; + return v; } int RTPUDPv4Transmitter::Poll() { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -int status; + int status; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -status = PollSocket(true); // poll RTP socket -if (rtpsock != rtcpsock) // no need to poll twice when multiplexing -{ -if (status >= 0) - status = PollSocket(false); // poll RTCP socket -} -MAINMUTEX_UNLOCK -return status; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + status = PollSocket(true); // poll RTP socket + if (rtpsock != rtcpsock) // no need to poll twice when multiplexing + { + if (status >= 0) + status = PollSocket(false); // poll RTCP socket + } + + return status; } int RTPUDPv4Transmitter::WaitForIncomingData(const RTPTime &delay, bool *dataavailable) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_ALREADYWAITING; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (waitingfordata) + { -SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); + return ERR_RTP_UDPV4TRANS_ALREADYWAITING; + } -SocketType socks[3] = -{ rtpsock, rtcpsock, abortSocket }; -int8_t readflags[3] = -{ 0, 0, 0 }; -const int idxRTP = 0; -const int idxRTCP = 1; -const int idxAbort = 2; + SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); -waitingfordata = true; + SocketType socks[3] = + { rtpsock, rtcpsock, abortSocket }; + int8_t readflags[3] = + { 0, 0, 0 }; + const int idxRTP = 0; + const int idxRTCP = 1; + const int idxAbort = 2; -WAITMUTEX_LOCK -MAINMUTEX_UNLOCK + waitingfordata = true; -int status = RTPSelect(socks, readflags, 3, delay); -if (status < 0) -{ -MAINMUTEX_LOCK -waitingfordata = false; -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return status; -} + int status = RTPSelect(socks, readflags, 3, delay); + if (status < 0) + { + waitingfordata = false; -MAINMUTEX_LOCK -waitingfordata = false; -if (!created) // destroy called -{ -MAINMUTEX_UNLOCK; -WAITMUTEX_UNLOCK -return 0; -} + return status; + } - // if aborted, read from abort buffer -if (readflags[idxAbort]) -m_pAbortDesc->ReadSignallingByte(); + waitingfordata = false; + if (!created) // destroy called + { + ; -if (dataavailable != 0) -{ -if (readflags[idxRTP] || readflags[idxRTCP]) - *dataavailable = true; -else - *dataavailable = false; -} + return 0; + } -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return 0; + // if aborted, read from abort buffer + if (readflags[idxAbort]) + m_pAbortDesc->ReadSignallingByte(); + + if (dataavailable != 0) + { + if (readflags[idxRTP] || readflags[idxRTCP]) + *dataavailable = true; + else + *dataavailable = false; + } + + return 0; } int RTPUDPv4Transmitter::AbortWait() { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (!waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTWAITING; -} + if (!created) + { -m_pAbortDesc->SendAbortSignal(); + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (!waitingfordata) + { -MAINMUTEX_UNLOCK -return 0; + return ERR_RTP_UDPV4TRANS_NOTWAITING; + } + + m_pAbortDesc->SendAbortSignal(); + + return 0; } int RTPUDPv4Transmitter::SendRTPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (len > maxpacksize) + { -destinations.GotoFirstElement(); -while (destinations.HasCurrentElement()) -{ -sendto(rtpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTPSockAddr(), sizeof(struct sockaddr_in)); -destinations.GotoNextElement(); -} + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } -MAINMUTEX_UNLOCK -return 0; + destinations.GotoFirstElement(); + while (destinations.HasCurrentElement()) + { + sendto(rtpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTPSockAddr(), sizeof(struct sockaddr_in)); + destinations.GotoNextElement(); + } + + return 0; } int RTPUDPv4Transmitter::SendRTCPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (len > maxpacksize) + { -destinations.GotoFirstElement(); -while (destinations.HasCurrentElement()) -{ -sendto(rtcpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTCPSockAddr(), sizeof(struct sockaddr_in)); -destinations.GotoNextElement(); -} + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } -MAINMUTEX_UNLOCK -return 0; + destinations.GotoFirstElement(); + while (destinations.HasCurrentElement()) + { + sendto(rtcpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTCPSockAddr(), sizeof(struct sockaddr_in)); + destinations.GotoNextElement(); + } + + return 0; } int RTPUDPv4Transmitter::AddDestination(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } -RTPIPv4Destination dest; -if (!RTPIPv4Destination::AddressToDestination(addr, dest)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + RTPIPv4Destination dest; + if (!RTPIPv4Destination::AddressToDestination(addr, dest)) + { -int status = destinations.AddElement(dest); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -MAINMUTEX_UNLOCK -return status; + int status = destinations.AddElement(dest); + + return status; } int RTPUDPv4Transmitter::DeleteDestination(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -RTPIPv4Destination dest; -if (!RTPIPv4Destination::AddressToDestination(addr, dest)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + RTPIPv4Destination dest; + if (!RTPIPv4Destination::AddressToDestination(addr, dest)) + { -int status = destinations.DeleteElement(dest); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -MAINMUTEX_UNLOCK -return status; + int status = destinations.DeleteElement(dest); + + return status; } void RTPUDPv4Transmitter::ClearDestinations() { -if (!init) -return; + if (!init) + return; + + if (created) + destinations.Clear(); -MAINMUTEX_LOCK -if (created) -destinations.Clear(); -MAINMUTEX_UNLOCK } bool RTPUDPv4Transmitter::SupportsMulticasting() { -if (!init) -return false; + if (!init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!created) + v = false; + else + v = supportsmulticasting; -if (!created) -v = false; -else -v = supportsmulticasting; - -MAINMUTEX_UNLOCK -return v; + return v; } #ifdef RTP_SUPPORT_IPV4MULTICAST int RTPUDPv4Transmitter::JoinMulticastGroup(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -uint32_t mcastIP = address.GetIP(); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -if (!RTPUDPV4TRANS_IS_MCASTADDR(mcastIP)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; -} + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + uint32_t mcastIP = address.GetIP(); -status = multicastgroups.AddElement(mcastIP); -if (status >= 0) -{ -RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_ADD_MEMBERSHIP, mcastIP, status); -if (status != 0) -{ -multicastgroups.DeleteElement(mcastIP); -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; -} + if (!RTPUDPV4TRANS_IS_MCASTADDR(mcastIP)) + { -if (rtpsock != rtcpsock) // no need to join multicast group twice when multiplexing -{ -RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_ADD_MEMBERSHIP, mcastIP, status); -if (status != 0) -{ - RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); - multicastgroups.DeleteElement(mcastIP); - MAINMUTEX_UNLOCK - return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; -} -} -} -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; + } + + status = multicastgroups.AddElement(mcastIP); + if (status >= 0) + { + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_ADD_MEMBERSHIP, mcastIP, status); + if (status != 0) + { + multicastgroups.DeleteElement(mcastIP); + + return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; + } + + if (rtpsock != rtcpsock) // no need to join multicast group twice when multiplexing + { + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_ADD_MEMBERSHIP, mcastIP, status); + if (status != 0) + { + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + multicastgroups.DeleteElement(mcastIP); + + return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; + } + } + } + + return status; } int RTPUDPv4Transmitter::LeaveMulticastGroup(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -uint32_t mcastIP = address.GetIP(); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -if (!RTPUDPV4TRANS_IS_MCASTADDR(mcastIP)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; -} + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + uint32_t mcastIP = address.GetIP(); -status = multicastgroups.DeleteElement(mcastIP); -if (status >= 0) -{ -RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); -if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing -RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (!RTPUDPV4TRANS_IS_MCASTADDR(mcastIP)) + { -status = 0; -} + return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; + } -MAINMUTEX_UNLOCK -return status; + status = multicastgroups.DeleteElement(mcastIP); + if (status >= 0) + { + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + + status = 0; + } + + return status; } void RTPUDPv4Transmitter::LeaveAllMulticastGroups() { -if (!init) -return; + if (!init) + return; -MAINMUTEX_LOCK -if (created) -{ -multicastgroups.GotoFirstElement(); -while (multicastgroups.HasCurrentElement()) -{ -uint32_t mcastIP; -int status __attribute__((unused)) = 0; + if (created) + { + multicastgroups.GotoFirstElement(); + while (multicastgroups.HasCurrentElement()) + { + uint32_t mcastIP; + int status __attribute__((unused)) = 0; -mcastIP = multicastgroups.GetCurrentElement(); + mcastIP = multicastgroups.GetCurrentElement(); -RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); -if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing - RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing + RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + + multicastgroups.GotoNextElement(); + } + multicastgroups.Clear(); + } -multicastgroups.GotoNextElement(); -} -multicastgroups.Clear(); -} -MAINMUTEX_UNLOCK } #else // no multicast support int RTPUDPv4Transmitter::JoinMulticastGroup(const RTPAddress &addr) { -return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; + return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; } int RTPUDPv4Transmitter::LeaveMulticastGroup(const RTPAddress &addr) { -return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; + return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; } void RTPUDPv4Transmitter::LeaveAllMulticastGroups() @@ -1144,243 +1095,221 @@ void RTPUDPv4Transmitter::LeaveAllMulticastGroups() int RTPUDPv4Transmitter::SetReceiveMode(RTPTransmitter::ReceiveMode m) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (m != receivemode) -{ -receivemode = m; -acceptignoreinfo.Clear(); -} -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (m != receivemode) + { + receivemode = m; + acceptignoreinfo.Clear(); + } + + return 0; } int RTPUDPv4Transmitter::AddToIgnoreList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::IgnoreSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::IgnoreSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } int RTPUDPv4Transmitter::DeleteFromIgnoreList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::IgnoreSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::IgnoreSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } void RTPUDPv4Transmitter::ClearIgnoreList() { -if (!init) -return; + if (!init) + return; + + if (created && receivemode == RTPTransmitter::IgnoreSome) + ClearAcceptIgnoreInfo(); -MAINMUTEX_LOCK -if (created && receivemode == RTPTransmitter::IgnoreSome) -ClearAcceptIgnoreInfo(); -MAINMUTEX_UNLOCK } int RTPUDPv4Transmitter::AddToAcceptList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::AcceptSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::AcceptSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } int RTPUDPv4Transmitter::DeleteFromAcceptList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::AcceptSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::AcceptSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } void RTPUDPv4Transmitter::ClearAcceptList() { -if (!init) -return; + if (!init) + return; + + if (created && receivemode == RTPTransmitter::AcceptSome) + ClearAcceptIgnoreInfo(); -MAINMUTEX_LOCK -if (created && receivemode == RTPTransmitter::AcceptSome) -ClearAcceptIgnoreInfo(); -MAINMUTEX_UNLOCK } int RTPUDPv4Transmitter::SetMaximumPacketSize(size_t s) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (s > RTPUDPV4TRANS_MAXPACKSIZE) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} -maxpacksize = s; -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (s > RTPUDPV4TRANS_MAXPACKSIZE) + { + + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } + maxpacksize = s; + + return 0; } bool RTPUDPv4Transmitter::NewDataAvailable() { -if (!init) -return false; + if (!init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!created) + v = false; + else + { + if (rawpacketlist.empty()) + v = false; + else + v = true; + } -if (!created) -v = false; -else -{ -if (rawpacketlist.empty()) -v = false; -else -v = true; -} - -MAINMUTEX_UNLOCK -return v; + return v; } RTPRawPacket *RTPUDPv4Transmitter::GetNextPacket() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK + RTPRawPacket *p; -RTPRawPacket *p; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return 0; -} -if (rawpacketlist.empty()) -{ -MAINMUTEX_UNLOCK -return 0; -} + return 0; + } + if (rawpacketlist.empty()) + { -p = *(rawpacketlist.begin()); -rawpacketlist.pop_front(); + return 0; + } -MAINMUTEX_UNLOCK -return p; + p = *(rawpacketlist.begin()); + rawpacketlist.pop_front(); + + return p; } // Here the private functions start... @@ -1388,372 +1317,372 @@ return p; #ifdef RTP_SUPPORT_IPV4MULTICAST bool RTPUDPv4Transmitter::SetMulticastTTL(uint8_t ttl) { -int ttl2, status; + int ttl2, status; -ttl2 = (int) ttl; -status = setsockopt(rtpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); -if (status != 0) -return false; + ttl2 = (int) ttl; + status = setsockopt(rtpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); + if (status != 0) + return false; -if (rtpsock != rtcpsock) // no need to set TTL twice when multiplexing -{ -status = setsockopt(rtcpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); -if (status != 0) -return false; -} -return true; + if (rtpsock != rtcpsock) // no need to set TTL twice when multiplexing + { + status = setsockopt(rtcpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); + if (status != 0) + return false; + } + return true; } #endif // RTP_SUPPORT_IPV4MULTICAST void RTPUDPv4Transmitter::FlushPackets() { -std::list::const_iterator it; + std::list::const_iterator it; -for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) -delete *it; -rawpacketlist.clear(); + for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) + delete *it; + rawpacketlist.clear(); } int RTPUDPv4Transmitter::PollSocket(bool rtp) { -RTPSOCKLENTYPE fromlen; -int recvlen; -char packetbuffer[RTPUDPV4TRANS_MAXPACKSIZE]; + RTPSOCKLENTYPE fromlen; + int recvlen; + char packetbuffer[RTPUDPV4TRANS_MAXPACKSIZE]; #ifdef RTP_SOCKETTYPE_WINSOCK -SOCKET sock; -unsigned long len; + SOCKET sock; + unsigned long len; #else -size_t len; -int sock; + size_t len; + int sock; #endif // RTP_SOCKETTYPE_WINSOCK -struct sockaddr_in srcaddr; -bool dataavailable; + struct sockaddr_in srcaddr; + bool dataavailable; -if (rtp) -sock = rtpsock; -else -sock = rtcpsock; + if (rtp) + sock = rtpsock; + else + sock = rtcpsock; -do -{ -len = 0; -RTPIOCTL(sock, FIONREAD, &len); + do + { + len = 0; + RTPIOCTL(sock, FIONREAD, &len); -if (len <= 0) // make sure a packet of length zero is not queued -{ - // An alternative workaround would be to just use non-blocking sockets. - // However, since the user does have access to the sockets and I do not - // know how this would affect anyone else's code, I chose to do it using - // an extra select call in case ioctl says the length is zero. + if (len <= 0) // make sure a packet of length zero is not queued + { + // An alternative workaround would be to just use non-blocking sockets. + // However, since the user does have access to the sockets and I do not + // know how this would affect anyone else's code, I chose to do it using + // an extra select call in case ioctl says the length is zero. -int8_t isset = 0; -int status = RTPSelect(&sock, &isset, 1, RTPTime(0)); -if (status < 0) -return status; + int8_t isset = 0; + int status = RTPSelect(&sock, &isset, 1, RTPTime(0)); + if (status < 0) + return status; -if (isset) -dataavailable = true; -else -dataavailable = false; -} -else -dataavailable = true; + if (isset) + dataavailable = true; + else + dataavailable = false; + } + else + dataavailable = true; -if (dataavailable) -{ -RTPTime curtime = RTPTime::CurrentTime(); -fromlen = sizeof(struct sockaddr_in); -recvlen = recvfrom(sock, packetbuffer, RTPUDPV4TRANS_MAXPACKSIZE, 0, (struct sockaddr *) &srcaddr, &fromlen); -if (recvlen > 0) -{ -bool acceptdata; + if (dataavailable) + { + RTPTime curtime = RTPTime::CurrentTime(); + fromlen = sizeof(struct sockaddr_in); + recvlen = recvfrom(sock, packetbuffer, RTPUDPV4TRANS_MAXPACKSIZE, 0, (struct sockaddr *) &srcaddr, &fromlen); + if (recvlen > 0) + { + bool acceptdata; - // got data, process it -if (receivemode == RTPTransmitter::AcceptAll) -acceptdata = true; -else -acceptdata = ShouldAcceptData(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); + // got data, process it + if (receivemode == RTPTransmitter::AcceptAll) + acceptdata = true; + else + acceptdata = ShouldAcceptData(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); -if (acceptdata) -{ -RTPRawPacket *pack; -RTPIPv4Address *addr; -uint8_t *datacopy; + if (acceptdata) + { + RTPRawPacket *pack; + RTPIPv4Address *addr; + uint8_t *datacopy; -addr = new RTPIPv4Address(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); -if (addr == 0) -return ERR_RTP_OUTOFMEM; -datacopy = new uint8_t[recvlen]; -if (datacopy == 0) -{ -delete addr; -return ERR_RTP_OUTOFMEM; -} -memcpy(datacopy, packetbuffer, recvlen); + addr = new RTPIPv4Address(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); + if (addr == 0) + return ERR_RTP_OUTOFMEM; + datacopy = new uint8_t[recvlen]; + if (datacopy == 0) + { + delete addr; + return ERR_RTP_OUTOFMEM; + } + memcpy(datacopy, packetbuffer, recvlen); -bool isrtp = rtp; -if (rtpsock == rtcpsock) // check payload type when multiplexing -{ -isrtp = true; + bool isrtp = rtp; + if (rtpsock == rtcpsock) // check payload type when multiplexing + { + isrtp = true; -if ((size_t) recvlen > sizeof(RTCPCommonHeader)) -{ - RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy; - uint8_t packettype = rtcpheader->packettype; + if ((size_t) recvlen > sizeof(RTCPCommonHeader)) + { + RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy; + uint8_t packettype = rtcpheader->packettype; - if (packettype >= 200 && packettype <= 204) - isrtp = false; -} -} + if (packettype >= 200 && packettype <= 204) + isrtp = false; + } + } -pack = new RTPRawPacket(datacopy, recvlen, addr, curtime, isrtp); -if (pack == 0) -{ -delete addr; -delete[] datacopy; -return ERR_RTP_OUTOFMEM; -} -rawpacketlist.push_back(pack); -} -} -} -} while (dataavailable); + pack = new RTPRawPacket(datacopy, recvlen, addr, curtime, isrtp); + if (pack == 0) + { + delete addr; + delete[] datacopy; + return ERR_RTP_OUTOFMEM; + } + rawpacketlist.push_back(pack); + } + } + } + } while (dataavailable); -return 0; + return 0; } int RTPUDPv4Transmitter::ProcessAddAcceptIgnoreEntry(uint32_t ip, uint16_t port) { -acceptignoreinfo.GotoElement(ip); -if (acceptignoreinfo.HasCurrentElement()) // An entry for this IP address already exists -{ -PortInfo *portinf = acceptignoreinfo.GetCurrentElement(); + acceptignoreinfo.GotoElement(ip); + if (acceptignoreinfo.HasCurrentElement()) // An entry for this IP address already exists + { + PortInfo *portinf = acceptignoreinfo.GetCurrentElement(); -if (port == 0) // select all ports -{ -portinf->all = true; -portinf->portlist.clear(); -} -else if (!portinf->all) -{ -std::list::const_iterator it, begin, end; + if (port == 0) // select all ports + { + portinf->all = true; + portinf->portlist.clear(); + } + else if (!portinf->all) + { + std::list::const_iterator it, begin, end; -begin = portinf->portlist.begin(); -end = portinf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == port) // already in list -return 0; -} -portinf->portlist.push_front(port); -} -} -else // got to create an entry for this IP address -{ -PortInfo *portinf; -int status; + begin = portinf->portlist.begin(); + end = portinf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == port) // already in list + return 0; + } + portinf->portlist.push_front(port); + } + } + else // got to create an entry for this IP address + { + PortInfo *portinf; + int status; -portinf = new PortInfo(); -if (port == 0) // select all ports -portinf->all = true; -else -portinf->portlist.push_front(port); + portinf = new PortInfo(); + if (port == 0) // select all ports + portinf->all = true; + else + portinf->portlist.push_front(port); -status = acceptignoreinfo.AddElement(ip, portinf); -if (status < 0) -{ -delete portinf; -return status; -} -} + status = acceptignoreinfo.AddElement(ip, portinf); + if (status < 0) + { + delete portinf; + return status; + } + } -return 0; + return 0; } void RTPUDPv4Transmitter::ClearAcceptIgnoreInfo() { -acceptignoreinfo.GotoFirstElement(); -while (acceptignoreinfo.HasCurrentElement()) -{ -PortInfo *inf; + acceptignoreinfo.GotoFirstElement(); + while (acceptignoreinfo.HasCurrentElement()) + { + PortInfo *inf; -inf = acceptignoreinfo.GetCurrentElement(); -delete inf; -acceptignoreinfo.GotoNextElement(); -} -acceptignoreinfo.Clear(); + inf = acceptignoreinfo.GetCurrentElement(); + delete inf; + acceptignoreinfo.GotoNextElement(); + } + acceptignoreinfo.Clear(); } int RTPUDPv4Transmitter::ProcessDeleteAcceptIgnoreEntry(uint32_t ip, uint16_t port) { -acceptignoreinfo.GotoElement(ip); -if (!acceptignoreinfo.HasCurrentElement()) -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + acceptignoreinfo.GotoElement(ip); + if (!acceptignoreinfo.HasCurrentElement()) + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -PortInfo *inf; + PortInfo *inf; -inf = acceptignoreinfo.GetCurrentElement(); -if (port == 0) // delete all entries -{ -inf->all = false; -inf->portlist.clear(); -} -else // a specific port was selected -{ -if (inf->all) // currently, all ports are selected. Add the one to remove to the list -{ - // we have to check if the list doesn't contain the port already -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (port == 0) // delete all entries + { + inf->all = false; + inf->portlist.clear(); + } + else // a specific port was selected + { + if (inf->all) // currently, all ports are selected. Add the one to remove to the list + { + // we have to check if the list doesn't contain the port already + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == port) // already in list: this means we already deleted the entry -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -} -inf->portlist.push_front(port); -} -else // check if we can find the port in the list -{ -std::list::iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == port) // already in list: this means we already deleted the entry + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + } + inf->portlist.push_front(port); + } + else // check if we can find the port in the list + { + std::list::iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; ++it) -{ -if (*it == port) // found it! -{ -inf->portlist.erase(it); -return 0; -} -} - // didn't find it -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -} -} -return 0; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; ++it) + { + if (*it == port) // found it! + { + inf->portlist.erase(it); + return 0; + } + } + // didn't find it + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + } + } + return 0; } bool RTPUDPv4Transmitter::ShouldAcceptData(uint32_t srcip, uint16_t srcport) { -if (receivemode == RTPTransmitter::AcceptSome) -{ -PortInfo *inf; + if (receivemode == RTPTransmitter::AcceptSome) + { + PortInfo *inf; -acceptignoreinfo.GotoElement(srcip); -if (!acceptignoreinfo.HasCurrentElement()) -return false; + acceptignoreinfo.GotoElement(srcip); + if (!acceptignoreinfo.HasCurrentElement()) + return false; -inf = acceptignoreinfo.GetCurrentElement(); -if (!inf->all) // only accept the ones in the list -{ -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (!inf->all) // only accept the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return true; -} -return false; -} -else // accept all, except the ones in the list -{ -std::list::const_iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return true; + } + return false; + } + else // accept all, except the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return false; -} -return true; -} -} -else // IgnoreSome -{ -PortInfo *inf; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return false; + } + return true; + } + } + else // IgnoreSome + { + PortInfo *inf; -acceptignoreinfo.GotoElement(srcip); -if (!acceptignoreinfo.HasCurrentElement()) -return true; + acceptignoreinfo.GotoElement(srcip); + if (!acceptignoreinfo.HasCurrentElement()) + return true; -inf = acceptignoreinfo.GetCurrentElement(); -if (!inf->all) // ignore the ports in the list -{ -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (!inf->all) // ignore the ports in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return false; -} -return true; -} -else // ignore all, except the ones in the list -{ -std::list::const_iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return false; + } + return true; + } + else // ignore all, except the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return true; -} -return false; -} -} -return true; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return true; + } + return false; + } + } + return true; } int RTPUDPv4Transmitter::CreateLocalIPList() { - // first try to obtain the list from the network interface info + // first try to obtain the list from the network interface info -if (!GetLocalIPList_Interfaces()) -{ - // If this fails, we'll have to depend on DNS info -GetLocalIPList_DNS(); -} -AddLoopbackAddress(); -return 0; + if (!GetLocalIPList_Interfaces()) + { + // If this fails, we'll have to depend on DNS info + GetLocalIPList_DNS(); + } + AddLoopbackAddress(); + return 0; } #ifdef RTP_SOCKETTYPE_WINSOCK bool RTPUDPv4Transmitter::GetLocalIPList_Interfaces() { -unsigned char buffer[RTPUDPV4TRANS_IFREQBUFSIZE]; -DWORD outputsize; -DWORD numaddresses,i; -SOCKET_ADDRESS_LIST *addrlist; + unsigned char buffer[RTPUDPV4TRANS_IFREQBUFSIZE]; + DWORD outputsize; + DWORD numaddresses,i; + SOCKET_ADDRESS_LIST *addrlist; -if (WSAIoctl(rtpsock,SIO_ADDRESS_LIST_QUERY,NULL,0,&buffer,RTPUDPV4TRANS_IFREQBUFSIZE,&outputsize,NULL,NULL)) -return false; + if (WSAIoctl(rtpsock,SIO_ADDRESS_LIST_QUERY,NULL,0,&buffer,RTPUDPV4TRANS_IFREQBUFSIZE,&outputsize,NULL,NULL)) + return false; -addrlist = (SOCKET_ADDRESS_LIST *)buffer; -numaddresses = addrlist->iAddressCount; -for (i = 0; i < numaddresses; i++) -{ -SOCKET_ADDRESS *sockaddr = &(addrlist->Address[i]); -if (sockaddr->iSockaddrLength == sizeof(struct sockaddr_in)) // IPv4 address -{ -struct sockaddr_in *addr = (struct sockaddr_in *)sockaddr->lpSockaddr; + addrlist = (SOCKET_ADDRESS_LIST *)buffer; + numaddresses = addrlist->iAddressCount; + for (i = 0; i < numaddresses; i++) + { + SOCKET_ADDRESS *sockaddr = &(addrlist->Address[i]); + if (sockaddr->iSockaddrLength == sizeof(struct sockaddr_in)) // IPv4 address + { + struct sockaddr_in *addr = (struct sockaddr_in *)sockaddr->lpSockaddr; -localIPs.push_back(ntohl(addr->sin_addr.s_addr)); -} -} + localIPs.push_back(ntohl(addr->sin_addr.s_addr)); + } + } -if (localIPs.empty()) -return false; + if (localIPs.empty()) + return false; -return true; + return true; } #else // use either getifaddrs or ioctl @@ -1762,92 +1691,92 @@ return true; bool RTPUDPv4Transmitter::GetLocalIPList_Interfaces() { -struct ifaddrs *addrs, *tmp; + struct ifaddrs *addrs, *tmp; -getifaddrs(&addrs); -tmp = addrs; + getifaddrs(&addrs); + tmp = addrs; -while (tmp != 0) -{ -if (tmp->ifa_addr != 0 && tmp->ifa_addr->sa_family == AF_INET) -{ -struct sockaddr_in *inaddr = (struct sockaddr_in *) tmp->ifa_addr; -localIPs.push_back(ntohl(inaddr->sin_addr.s_addr)); -} -tmp = tmp->ifa_next; -} + while (tmp != 0) + { + if (tmp->ifa_addr != 0 && tmp->ifa_addr->sa_family == AF_INET) + { + struct sockaddr_in *inaddr = (struct sockaddr_in *) tmp->ifa_addr; + localIPs.push_back(ntohl(inaddr->sin_addr.s_addr)); + } + tmp = tmp->ifa_next; + } -freeifaddrs(addrs); + freeifaddrs(addrs); -if (localIPs.empty()) -return false; -return true; + if (localIPs.empty()) + return false; + return true; } #else // user ioctl bool RTPUDPv4Transmitter::GetLocalIPList_Interfaces() { -int status; -char buffer[RTPUDPV4TRANS_IFREQBUFSIZE]; -struct ifconf ifc; -struct ifreq *ifr; -struct sockaddr *sa; -char *startptr,*endptr; -int remlen; + int status; + char buffer[RTPUDPV4TRANS_IFREQBUFSIZE]; + struct ifconf ifc; + struct ifreq *ifr; + struct sockaddr *sa; + char *startptr,*endptr; + int remlen; -ifc.ifc_len = RTPUDPV4TRANS_IFREQBUFSIZE; -ifc.ifc_buf = buffer; -status = ioctl(rtpsock,SIOCGIFCONF,&ifc); -if (status < 0) -return false; + ifc.ifc_len = RTPUDPV4TRANS_IFREQBUFSIZE; + ifc.ifc_buf = buffer; + status = ioctl(rtpsock,SIOCGIFCONF,&ifc); + if (status < 0) + return false; -startptr = (char *)ifc.ifc_req; -endptr = startptr + ifc.ifc_len; -remlen = ifc.ifc_len; -while((startptr < endptr) && remlen >= (int)sizeof(struct ifreq)) -{ -ifr = (struct ifreq *)startptr; -sa = &(ifr->ifr_addr); + startptr = (char *)ifc.ifc_req; + endptr = startptr + ifc.ifc_len; + remlen = ifc.ifc_len; + while((startptr < endptr) && remlen >= (int)sizeof(struct ifreq)) + { + ifr = (struct ifreq *)startptr; + sa = &(ifr->ifr_addr); #ifdef RTP_HAVE_SOCKADDR_LEN -if (sa->sa_len <= sizeof(struct sockaddr)) -{ -if (sa->sa_len == sizeof(struct sockaddr_in) && sa->sa_family == PF_INET) -{ -uint32_t ip; -struct sockaddr_in *addr = (struct sockaddr_in *)sa; + if (sa->sa_len <= sizeof(struct sockaddr)) + { + if (sa->sa_len == sizeof(struct sockaddr_in) && sa->sa_family == PF_INET) + { + uint32_t ip; + struct sockaddr_in *addr = (struct sockaddr_in *)sa; -ip = ntohl(addr->sin_addr.s_addr); -localIPs.push_back(ip); -} -remlen -= sizeof(struct ifreq); -startptr += sizeof(struct ifreq); -} -else -{ -int l = sa->sa_len-sizeof(struct sockaddr)+sizeof(struct ifreq); + ip = ntohl(addr->sin_addr.s_addr); + localIPs.push_back(ip); + } + remlen -= sizeof(struct ifreq); + startptr += sizeof(struct ifreq); + } + else + { + int l = sa->sa_len-sizeof(struct sockaddr)+sizeof(struct ifreq); -remlen -= l; -startptr += l; -} + remlen -= l; + startptr += l; + } #else // don't have sa_len in struct sockaddr -if (sa->sa_family == PF_INET) -{ -uint32_t ip; -struct sockaddr_in *addr = (struct sockaddr_in *)sa; + if (sa->sa_family == PF_INET) + { + uint32_t ip; + struct sockaddr_in *addr = (struct sockaddr_in *)sa; -ip = ntohl(addr->sin_addr.s_addr); -localIPs.push_back(ip); -} -remlen -= sizeof(struct ifreq); -startptr += sizeof(struct ifreq); + ip = ntohl(addr->sin_addr.s_addr); + localIPs.push_back(ip); + } + remlen -= sizeof(struct ifreq); + startptr += sizeof(struct ifreq); #endif // RTP_HAVE_SOCKADDR_LEN -} + } -if (localIPs.empty()) -return false; -return true; + if (localIPs.empty()) + return false; + return true; } #endif // RTP_SUPPORT_IFADDRS @@ -1856,49 +1785,49 @@ return true; void RTPUDPv4Transmitter::GetLocalIPList_DNS() { -struct hostent *he; -char name[1024]; -bool done; -int i, j; + struct hostent *he; + char name[1024]; + bool done; + int i, j; -gethostname(name, 1023); -name[1023] = 0; -he = gethostbyname(name); -if (he == 0) -return; + gethostname(name, 1023); + name[1023] = 0; + he = gethostbyname(name); + if (he == 0) + return; -i = 0; -done = false; -while (!done) -{ -if (he->h_addr_list[i] == NULL) -done = true; -else -{ -uint32_t ip = 0; + i = 0; + done = false; + while (!done) + { + if (he->h_addr_list[i] == NULL) + done = true; + else + { + uint32_t ip = 0; -for (j = 0; j < 4; j++) -ip |= ((uint32_t) ((unsigned char) he->h_addr_list[i][j]) << ((3 - j) * 8)); -localIPs.push_back(ip); -i++; -} -} + for (j = 0; j < 4; j++) + ip |= ((uint32_t) ((unsigned char) he->h_addr_list[i][j]) << ((3 - j) * 8)); + localIPs.push_back(ip); + i++; + } + } } void RTPUDPv4Transmitter::AddLoopbackAddress() { -uint32_t loopbackaddr = (((uint32_t) 127) << 24) | ((uint32_t) 1); -std::list::const_iterator it; -bool found = false; + uint32_t loopbackaddr = (((uint32_t) 127) << 24) | ((uint32_t) 1); + std::list::const_iterator it; + bool found = false; -for (it = localIPs.begin(); !found && it != localIPs.end(); it++) -{ -if (*it == loopbackaddr) -found = true; -} + for (it = localIPs.begin(); !found && it != localIPs.end(); it++) + { + if (*it == loopbackaddr) + found = true; + } -if (!found) -localIPs.push_back(loopbackaddr); + if (!found) + localIPs.push_back(loopbackaddr); } } // end namespace diff --git a/qrtplib/rtpudpv4transmitternobind.cpp b/qrtplib/rtpudpv4transmitternobind.cpp index d10149b88..ad4f79d86 100644 --- a/qrtplib/rtpudpv4transmitternobind.cpp +++ b/qrtplib/rtpudpv4transmitternobind.cpp @@ -59,10 +59,6 @@ using namespace std; mreq.imr_interface.s_addr = htonl(mcastifaceIP);\ status = setsockopt(socket,IPPROTO_IP,type,(const char *)&mreq,sizeof(struct ip_mreq));\ } -#define MAINMUTEX_LOCK -#define MAINMUTEX_UNLOCK -#define WAITMUTEX_LOCK -#define WAITMUTEX_UNLOCK #define CLOSESOCKETS do { \ if (closesocketswhendone) \ @@ -77,9 +73,8 @@ namespace qrtplib { RTPUDPv4TransmitterNoBind::RTPUDPv4TransmitterNoBind() : - init(false), created(false), waitingfordata(false), rtpsock(-1), rtcpsock(-1), mcastifaceIP(0), m_rtpPort(0), m_rtcpPort(0), multicastTTL(0), receivemode( - AcceptAll), localhostname(0), localhostnamelength(0), - supportsmulticasting(false), maxpacksize(0), closesocketswhendone(false), m_pAbortDesc(0) + init(false), created(false), waitingfordata(false), rtpsock(-1), rtcpsock(-1), mcastifaceIP(0), m_rtpPort(0), m_rtcpPort(0), multicastTTL(0), receivemode(AcceptAll), localhostname( + 0), localhostnamelength(0), supportsmulticasting(false), maxpacksize(0), closesocketswhendone(false), m_pAbortDesc(0) { } @@ -270,11 +265,9 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (!init) return ERR_RTP_UDPV4TRANS_NOTINIT; - MAINMUTEX_LOCK - if (created) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_ALREADYCREATED; } @@ -286,7 +279,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi { if (transparams->GetTransmissionProtocol() != RTPTransmitter::IPv4UDPProto) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_ILLEGALPARAMETERS; } params = (const RTPUDPv4TransmissionNoBindParams *) transparams; @@ -309,7 +302,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi int status = GetAutoSockets(params->GetBindIP(), params->GetAllowOddPortbase(), params->GetRTCPMultiplexing(), &rtpsock, &rtcpsock, &m_rtpPort, &m_rtcpPort); if (status < 0) { - MAINMUTEX_UNLOCK + return status; } } @@ -318,7 +311,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi // Check if portbase is even (if necessary) if (!params->GetAllowOddPortbase() && params->GetPortbase() % 2 != 0) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_PORTBASENOTEVEN; } @@ -327,7 +320,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi rtpsock = socket(PF_INET, SOCK_DGRAM, 0); if (rtpsock == RTPSOCKERR) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET; } @@ -340,7 +333,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (rtcpsock == RTPSOCKERR) { RTPCLOSE(rtpsock); - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET; } } @@ -353,14 +346,14 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (setsockopt(rtpsock, SOL_SOCKET, SO_RCVBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTPRECEIVEBUF; } size = params->GetRTPSendBuffer(); if (setsockopt(rtpsock, SOL_SOCKET, SO_SNDBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTPTRANSMITBUF; } @@ -370,14 +363,14 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (setsockopt(rtcpsock, SOL_SOCKET, SO_RCVBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTCPRECEIVEBUF; } size = params->GetRTCPSendBuffer(); if (setsockopt(rtcpsock, SOL_SOCKET, SO_SNDBUF, (const char *) &size, sizeof(int)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTSETRTCPTRANSMITBUF; } } @@ -393,7 +386,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if ((status = CreateLocalIPList()) < 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return status; } } @@ -410,7 +403,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (maximumpacketsize > RTPUDPV4TRANSNOBIND_MAXPACKSIZE) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; } @@ -419,7 +412,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if ((status = m_abortDesc.Init()) < 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return status; } m_pAbortDesc = &m_abortDesc; @@ -430,7 +423,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi if (!m_pAbortDesc->IsInitialized()) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_ABORTDESC_NOTINIT; } } @@ -445,7 +438,7 @@ int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmi waitingfordata = false; created = true; - MAINMUTEX_UNLOCK + return 0; } @@ -453,7 +446,7 @@ int RTPUDPv4TransmitterNoBind::BindSockets(const RTPTransmissionParams *transpar { if (transparams->GetTransmissionProtocol() != RTPTransmitter::IPv4UDPProto) { - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_ILLEGALPARAMETERS; } @@ -470,7 +463,7 @@ int RTPUDPv4TransmitterNoBind::BindSockets(const RTPTransmissionParams *transpar if (bind(rtpsock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTBINDRTPSOCKET; } @@ -493,7 +486,7 @@ int RTPUDPv4TransmitterNoBind::BindSockets(const RTPTransmissionParams *transpar if (bind(rtcpsock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0) { CLOSESOCKETS; - MAINMUTEX_UNLOCK + return ERR_RTP_UDPV4TRANS_CANTBINDRTCPSOCKET; } @@ -510,10 +503,9 @@ void RTPUDPv4TransmitterNoBind::Destroy() if (!init) return; - MAINMUTEX_LOCK if (!created) { - MAINMUTEX_UNLOCK; + ; return; } @@ -538,605 +530,563 @@ void RTPUDPv4TransmitterNoBind::Destroy() { m_pAbortDesc->SendAbortSignal(); m_abortDesc.Destroy(); // Doesn't do anything if not initialized - MAINMUTEX_UNLOCK - WAITMUTEX_LOCK// to make sure that the WaitForIncomingData function ended - WAITMUTEX_UNLOCK -} -else - m_abortDesc.Destroy(); // Doesn't do anything if not initialized -MAINMUTEX_UNLOCK + // to make sure that the WaitForIncomingData function ended + + } + else + m_abortDesc.Destroy(); // Doesn't do anything if not initialized + } RTPTransmissionInfo *RTPUDPv4TransmitterNoBind::GetTransmissionInfo() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK -RTPTransmissionInfo *tinf = new RTPUDPv4TransmissionNoBindInfo(localIPs, rtpsock, rtcpsock, m_rtpPort, m_rtcpPort); -MAINMUTEX_UNLOCK -return tinf; + RTPTransmissionInfo *tinf = new RTPUDPv4TransmissionNoBindInfo(localIPs, rtpsock, rtcpsock, m_rtpPort, m_rtcpPort); + + return tinf; } void RTPUDPv4TransmitterNoBind::DeleteTransmissionInfo(RTPTransmissionInfo *i) { -if (!init) -return; + if (!init) + return; -delete i; + delete i; } int RTPUDPv4TransmitterNoBind::GetLocalHostName(uint8_t *buffer, size_t *bufferlength) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} - -if (localhostname == 0) -{ -if (localIPs.empty()) -{ - MAINMUTEX_UNLOCK - return ERR_RTP_UDPV4TRANS_NOLOCALIPS; -} - -std::list::const_iterator it; -std::list hostnames; - -for (it = localIPs.begin(); it != localIPs.end(); it++) -{ - bool founddouble = false; - bool foundentry = true; - - while (!founddouble && foundentry) + if (!created) { - struct hostent *he; - uint8_t addr[4]; - uint32_t ip = (*it); - addr[0] = (uint8_t) ((ip >> 24) & 0xFF); - addr[1] = (uint8_t) ((ip >> 16) & 0xFF); - addr[2] = (uint8_t) ((ip >> 8) & 0xFF); - addr[3] = (uint8_t) (ip & 0xFF); - he = gethostbyaddr((char *) addr, 4, AF_INET); - if (he != 0) + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + + if (localhostname == 0) + { + if (localIPs.empty()) + { + + return ERR_RTP_UDPV4TRANS_NOLOCALIPS; + } + + std::list::const_iterator it; + std::list hostnames; + + for (it = localIPs.begin(); it != localIPs.end(); it++) + { + bool founddouble = false; + bool foundentry = true; + + while (!founddouble && foundentry) + { + struct hostent *he; + uint8_t addr[4]; + uint32_t ip = (*it); + + addr[0] = (uint8_t) ((ip >> 24) & 0xFF); + addr[1] = (uint8_t) ((ip >> 16) & 0xFF); + addr[2] = (uint8_t) ((ip >> 8) & 0xFF); + addr[3] = (uint8_t) (ip & 0xFF); + he = gethostbyaddr((char *) addr, 4, AF_INET); + if (he != 0) + { + std::string hname = std::string(he->h_name); + std::list::const_iterator it; + + for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) + if ((*it) == hname) + founddouble = true; + + if (!founddouble) + hostnames.push_back(hname); + + int i = 0; + while (!founddouble && he->h_aliases[i] != 0) + { + std::string hname = std::string(he->h_aliases[i]); + + for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) + if ((*it) == hname) + founddouble = true; + + if (!founddouble) + { + hostnames.push_back(hname); + i++; + } + } + } + else + foundentry = false; + } + } + + bool found = false; + + if (!hostnames.empty()) // try to select the most appropriate hostname { - std::string hname = std::string(he->h_name); std::list::const_iterator it; - for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) - if ((*it) == hname) - founddouble = true; - - if (!founddouble) - hostnames.push_back(hname); - - int i = 0; - while (!founddouble && he->h_aliases[i] != 0) + hostnames.sort(); + for (it = hostnames.begin(); !found && it != hostnames.end(); it++) { - std::string hname = std::string(he->h_aliases[i]); - - for (it = hostnames.begin(); !founddouble && it != hostnames.end(); it++) - if ((*it) == hname) - founddouble = true; - - if (!founddouble) + if ((*it).find('.') != std::string::npos) { - hostnames.push_back(hname); - i++; + found = true; + localhostnamelength = (*it).length(); + localhostname = new uint8_t[localhostnamelength + 1]; + if (localhostname == 0) + { + + return ERR_RTP_OUTOFMEM; + } + memcpy(localhostname, (*it).c_str(), localhostnamelength); + localhostname[localhostnamelength] = 0; } } } - else - foundentry = false; - } -} -bool found = false; - -if (!hostnames.empty()) // try to select the most appropriate hostname -{ - std::list::const_iterator it; - - hostnames.sort(); - for (it = hostnames.begin(); !found && it != hostnames.end(); it++) - { - if ((*it).find('.') != std::string::npos) + if (!found) // use an IP address { - found = true; - localhostnamelength = (*it).length(); + uint32_t ip; + int len; + char str[16]; + + it = localIPs.begin(); + ip = (*it); + + RTP_SNPRINTF(str, 16, "%d.%d.%d.%d", (int) ((ip >> 24) & 0xFF), (int) ((ip >> 16) & 0xFF), (int) ((ip >> 8) & 0xFF), (int) (ip & 0xFF)); + len = strlen(str); + + localhostnamelength = len; localhostname = new uint8_t[localhostnamelength + 1]; if (localhostname == 0) { - MAINMUTEX_UNLOCK + return ERR_RTP_OUTOFMEM; } - memcpy(localhostname, (*it).c_str(), localhostnamelength); + memcpy(localhostname, str, localhostnamelength); localhostname[localhostnamelength] = 0; } } -} -if (!found) // use an IP address -{ - uint32_t ip; - int len; - char str[16]; - - it = localIPs.begin(); - ip = (*it); - - RTP_SNPRINTF(str, 16, "%d.%d.%d.%d", (int) ((ip >> 24) & 0xFF), (int) ((ip >> 16) & 0xFF), (int) ((ip >> 8) & 0xFF), (int) (ip & 0xFF)); - len = strlen(str); - - localhostnamelength = len; - localhostname = new uint8_t[localhostnamelength + 1]; - if (localhostname == 0) + if ((*bufferlength) < localhostnamelength) { - MAINMUTEX_UNLOCK - return ERR_RTP_OUTOFMEM; + *bufferlength = localhostnamelength; // tell the application the required size of the buffer + + return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; } - memcpy(localhostname, str, localhostnamelength); - localhostname[localhostnamelength] = 0; -} -} -if ((*bufferlength) < localhostnamelength) -{ -*bufferlength = localhostnamelength; // tell the application the required size of the buffer -MAINMUTEX_UNLOCK -return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL; -} + memcpy(buffer, localhostname, localhostnamelength); + *bufferlength = localhostnamelength; -memcpy(buffer, localhostname, localhostnamelength); -*bufferlength = localhostnamelength; - -MAINMUTEX_UNLOCK -return 0; + return 0; } bool RTPUDPv4TransmitterNoBind::ComesFromThisTransmitter(const RTPAddress *addr) { -if (!init) -return false; + if (!init) + return false; -if (addr == 0) -return false; + if (addr == 0) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (created && addr->GetAddressType() == RTPAddress::IPv4Address) + { + const RTPIPv4Address *addr2 = (const RTPIPv4Address *) addr; + bool found = false; + std::list::const_iterator it; -if (created && addr->GetAddressType() == RTPAddress::IPv4Address) -{ -const RTPIPv4Address *addr2 = (const RTPIPv4Address *) addr; -bool found = false; -std::list::const_iterator it; + it = localIPs.begin(); + while (!found && it != localIPs.end()) + { + if (addr2->GetIP() == *it) + found = true; + else + ++it; + } -it = localIPs.begin(); -while (!found && it != localIPs.end()) -{ - if (addr2->GetIP() == *it) - found = true; - else - ++it; -} - -if (!found) - v = false; -else -{ - if (addr2->GetPort() == m_rtpPort || addr2->GetPort() == m_rtcpPort) // check for RTP port and RTCP port - v = true; + if (!found) + v = false; + else + { + if (addr2->GetPort() == m_rtpPort || addr2->GetPort() == m_rtcpPort) // check for RTP port and RTCP port + v = true; + else + v = false; + } + } else v = false; -} -} -else -v = false; -MAINMUTEX_UNLOCK -return v; + return v; } int RTPUDPv4TransmitterNoBind::Poll() { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -int status; + int status; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -status = PollSocket(true); // poll RTP socket -if (rtpsock != rtcpsock) // no need to poll twice when multiplexing -{ -if (status >= 0) - status = PollSocket(false); // poll RTCP socket -} -MAINMUTEX_UNLOCK -return status; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + status = PollSocket(true); // poll RTP socket + if (rtpsock != rtcpsock) // no need to poll twice when multiplexing + { + if (status >= 0) + status = PollSocket(false); // poll RTCP socket + } + + return status; } int RTPUDPv4TransmitterNoBind::WaitForIncomingData(const RTPTime &delay, bool *dataavailable) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_ALREADYWAITING; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (waitingfordata) + { -SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); + return ERR_RTP_UDPV4TRANS_ALREADYWAITING; + } -SocketType socks[3] = -{ rtpsock, rtcpsock, abortSocket }; -int8_t readflags[3] = -{ 0, 0, 0 }; -const int idxRTP = 0; -const int idxRTCP = 1; -const int idxAbort = 2; + SocketType abortSocket = m_pAbortDesc->GetAbortSocket(); -waitingfordata = true; + SocketType socks[3] = + { rtpsock, rtcpsock, abortSocket }; + int8_t readflags[3] = + { 0, 0, 0 }; + const int idxRTP = 0; + const int idxRTCP = 1; + const int idxAbort = 2; -WAITMUTEX_LOCK -MAINMUTEX_UNLOCK + waitingfordata = true; -int status = RTPSelect(socks, readflags, 3, delay); -if (status < 0) -{ -MAINMUTEX_LOCK -waitingfordata = false; -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return status; -} + int status = RTPSelect(socks, readflags, 3, delay); + if (status < 0) + { + waitingfordata = false; -MAINMUTEX_LOCK -waitingfordata = false; -if (!created) // destroy called -{ -MAINMUTEX_UNLOCK; -WAITMUTEX_UNLOCK -return 0; -} + return status; + } - // if aborted, read from abort buffer -if (readflags[idxAbort]) -m_pAbortDesc->ReadSignallingByte(); + waitingfordata = false; + if (!created) // destroy called + { + ; -if (dataavailable != 0) -{ -if (readflags[idxRTP] || readflags[idxRTCP]) - *dataavailable = true; -else - *dataavailable = false; -} + return 0; + } -MAINMUTEX_UNLOCK -WAITMUTEX_UNLOCK -return 0; + // if aborted, read from abort buffer + if (readflags[idxAbort]) + m_pAbortDesc->ReadSignallingByte(); + + if (dataavailable != 0) + { + if (readflags[idxRTP] || readflags[idxRTCP]) + *dataavailable = true; + else + *dataavailable = false; + } + + return 0; } int RTPUDPv4TransmitterNoBind::AbortWait() { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (!waitingfordata) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTWAITING; -} + if (!created) + { -m_pAbortDesc->SendAbortSignal(); + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (!waitingfordata) + { -MAINMUTEX_UNLOCK -return 0; + return ERR_RTP_UDPV4TRANS_NOTWAITING; + } + + m_pAbortDesc->SendAbortSignal(); + + return 0; } int RTPUDPv4TransmitterNoBind::SendRTPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (len > maxpacksize) + { -destinations.GotoFirstElement(); -while (destinations.HasCurrentElement()) -{ -sendto(rtpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTPSockAddr(), sizeof(struct sockaddr_in)); -destinations.GotoNextElement(); -} + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } -MAINMUTEX_UNLOCK -return 0; + destinations.GotoFirstElement(); + while (destinations.HasCurrentElement()) + { + sendto(rtpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTPSockAddr(), sizeof(struct sockaddr_in)); + destinations.GotoNextElement(); + } + + return 0; } int RTPUDPv4TransmitterNoBind::SendRTCPData(const void *data, size_t len) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (len > maxpacksize) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (len > maxpacksize) + { -destinations.GotoFirstElement(); -while (destinations.HasCurrentElement()) -{ -sendto(rtcpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTCPSockAddr(), sizeof(struct sockaddr_in)); -destinations.GotoNextElement(); -} + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } -MAINMUTEX_UNLOCK -return 0; + destinations.GotoFirstElement(); + while (destinations.HasCurrentElement()) + { + sendto(rtcpsock, (const char *) data, len, 0, (const struct sockaddr *) destinations.GetCurrentElement().GetRTCPSockAddr(), sizeof(struct sockaddr_in)); + destinations.GotoNextElement(); + } + + return 0; } int RTPUDPv4TransmitterNoBind::AddDestination(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } -RTPIPv4Destination dest; -if (!RTPIPv4Destination::AddressToDestination(addr, dest)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + RTPIPv4Destination dest; + if (!RTPIPv4Destination::AddressToDestination(addr, dest)) + { -int status = destinations.AddElement(dest); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -MAINMUTEX_UNLOCK -return status; + int status = destinations.AddElement(dest); + + return status; } int RTPUDPv4TransmitterNoBind::DeleteDestination(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -RTPIPv4Destination dest; -if (!RTPIPv4Destination::AddressToDestination(addr, dest)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + RTPIPv4Destination dest; + if (!RTPIPv4Destination::AddressToDestination(addr, dest)) + { -int status = destinations.DeleteElement(dest); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -MAINMUTEX_UNLOCK -return status; + int status = destinations.DeleteElement(dest); + + return status; } void RTPUDPv4TransmitterNoBind::ClearDestinations() { -if (!init) -return; + if (!init) + return; + + if (created) + destinations.Clear(); -MAINMUTEX_LOCK -if (created) -destinations.Clear(); -MAINMUTEX_UNLOCK } bool RTPUDPv4TransmitterNoBind::SupportsMulticasting() { -if (!init) -return false; + if (!init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!created) + v = false; + else + v = supportsmulticasting; -if (!created) -v = false; -else -v = supportsmulticasting; - -MAINMUTEX_UNLOCK -return v; + return v; } #ifdef RTP_SUPPORT_IPV4MULTICAST int RTPUDPv4TransmitterNoBind::JoinMulticastGroup(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -uint32_t mcastIP = address.GetIP(); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -if (!RTPUDPV4TRANSNOBIND_IS_MCASTADDR(mcastIP)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; -} + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + uint32_t mcastIP = address.GetIP(); -status = multicastgroups.AddElement(mcastIP); -if (status >= 0) -{ -RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_ADD_MEMBERSHIP, mcastIP, status); -if (status != 0) -{ -multicastgroups.DeleteElement(mcastIP); -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; -} + if (!RTPUDPV4TRANSNOBIND_IS_MCASTADDR(mcastIP)) + { -if (rtpsock != rtcpsock) // no need to join multicast group twice when multiplexing -{ -RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_ADD_MEMBERSHIP, mcastIP, status); -if (status != 0) -{ - RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); - multicastgroups.DeleteElement(mcastIP); - MAINMUTEX_UNLOCK - return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; -} -} -} -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; + } + + status = multicastgroups.AddElement(mcastIP); + if (status >= 0) + { + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_ADD_MEMBERSHIP, mcastIP, status); + if (status != 0) + { + multicastgroups.DeleteElement(mcastIP); + + return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; + } + + if (rtpsock != rtcpsock) // no need to join multicast group twice when multiplexing + { + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_ADD_MEMBERSHIP, mcastIP, status); + if (status != 0) + { + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + multicastgroups.DeleteElement(mcastIP); + + return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP; + } + } + } + + return status; } int RTPUDPv4TransmitterNoBind::LeaveMulticastGroup(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -uint32_t mcastIP = address.GetIP(); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } -if (!RTPUDPV4TRANSNOBIND_IS_MCASTADDR(mcastIP)) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; -} + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + uint32_t mcastIP = address.GetIP(); -status = multicastgroups.DeleteElement(mcastIP); -if (status >= 0) -{ -RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); -if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing -RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (!RTPUDPV4TRANSNOBIND_IS_MCASTADDR(mcastIP)) + { -status = 0; -} + return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS; + } -MAINMUTEX_UNLOCK -return status; + status = multicastgroups.DeleteElement(mcastIP); + if (status >= 0) + { + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + + status = 0; + } + + return status; } void RTPUDPv4TransmitterNoBind::LeaveAllMulticastGroups() { -if (!init) -return; + if (!init) + return; -MAINMUTEX_LOCK -if (created) -{ -multicastgroups.GotoFirstElement(); -while (multicastgroups.HasCurrentElement()) -{ -uint32_t mcastIP; -int status __attribute__((unused)) = 0; + if (created) + { + multicastgroups.GotoFirstElement(); + while (multicastgroups.HasCurrentElement()) + { + uint32_t mcastIP; + int status __attribute__((unused)) = 0; -mcastIP = multicastgroups.GetCurrentElement(); + mcastIP = multicastgroups.GetCurrentElement(); -RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); -if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing - RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + if (rtpsock != rtcpsock) // no need to leave multicast group twice when multiplexing + RTPUDPV4TRANSNOBIND_MCASTMEMBERSHIP(rtcpsock, IP_DROP_MEMBERSHIP, mcastIP, status); + + multicastgroups.GotoNextElement(); + } + multicastgroups.Clear(); + } -multicastgroups.GotoNextElement(); -} -multicastgroups.Clear(); -} -MAINMUTEX_UNLOCK } #else // no multicast support int RTPUDPv4TransmitterNoBind::JoinMulticastGroup(const RTPAddress &addr) { -return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; + return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; } int RTPUDPv4Transmitter::LeaveMulticastGroup(const RTPAddress &addr) { -return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; + return ERR_RTP_UDPV4TRANS_NOMULTICASTSUPPORT; } void RTPUDPv4TransmitterNoBind::LeaveAllMulticastGroups() @@ -1147,243 +1097,221 @@ void RTPUDPv4TransmitterNoBind::LeaveAllMulticastGroups() int RTPUDPv4TransmitterNoBind::SetReceiveMode(RTPTransmitter::ReceiveMode m) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (m != receivemode) -{ -receivemode = m; -acceptignoreinfo.Clear(); -} -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (m != receivemode) + { + receivemode = m; + acceptignoreinfo.Clear(); + } + + return 0; } int RTPUDPv4TransmitterNoBind::AddToIgnoreList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::IgnoreSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::IgnoreSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } int RTPUDPv4TransmitterNoBind::DeleteFromIgnoreList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::IgnoreSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::IgnoreSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } void RTPUDPv4TransmitterNoBind::ClearIgnoreList() { -if (!init) -return; + if (!init) + return; + + if (created && receivemode == RTPTransmitter::IgnoreSome) + ClearAcceptIgnoreInfo(); -MAINMUTEX_LOCK -if (created && receivemode == RTPTransmitter::IgnoreSome) -ClearAcceptIgnoreInfo(); -MAINMUTEX_UNLOCK } int RTPUDPv4TransmitterNoBind::AddToAcceptList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::AcceptSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::AcceptSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessAddAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } int RTPUDPv4TransmitterNoBind::DeleteFromAcceptList(const RTPAddress &addr) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK + int status; -int status; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (addr.GetAddressType() != RTPAddress::IPv4Address) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; -} -if (receivemode != RTPTransmitter::AcceptSome) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; -} + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (addr.GetAddressType() != RTPAddress::IPv4Address) + { -const RTPIPv4Address &address = (const RTPIPv4Address &) addr; -status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE; + } + if (receivemode != RTPTransmitter::AcceptSome) + { -MAINMUTEX_UNLOCK -return status; + return ERR_RTP_UDPV4TRANS_DIFFERENTRECEIVEMODE; + } + + const RTPIPv4Address &address = (const RTPIPv4Address &) addr; + status = ProcessDeleteAcceptIgnoreEntry(address.GetIP(), address.GetPort()); + + return status; } void RTPUDPv4TransmitterNoBind::ClearAcceptList() { -if (!init) -return; + if (!init) + return; + + if (created && receivemode == RTPTransmitter::AcceptSome) + ClearAcceptIgnoreInfo(); -MAINMUTEX_LOCK -if (created && receivemode == RTPTransmitter::AcceptSome) -ClearAcceptIgnoreInfo(); -MAINMUTEX_UNLOCK } int RTPUDPv4TransmitterNoBind::SetMaximumPacketSize(size_t s) { -if (!init) -return ERR_RTP_UDPV4TRANS_NOTINIT; + if (!init) + return ERR_RTP_UDPV4TRANS_NOTINIT; -MAINMUTEX_LOCK -if (!created) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_NOTCREATED; -} -if (s > RTPUDPV4TRANSNOBIND_MAXPACKSIZE) -{ -MAINMUTEX_UNLOCK -return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; -} -maxpacksize = s; -MAINMUTEX_UNLOCK -return 0; + if (!created) + { + + return ERR_RTP_UDPV4TRANS_NOTCREATED; + } + if (s > RTPUDPV4TRANSNOBIND_MAXPACKSIZE) + { + + return ERR_RTP_UDPV4TRANS_SPECIFIEDSIZETOOBIG; + } + maxpacksize = s; + + return 0; } bool RTPUDPv4TransmitterNoBind::NewDataAvailable() { -if (!init) -return false; + if (!init) + return false; -MAINMUTEX_LOCK + bool v; -bool v; + if (!created) + v = false; + else + { + if (rawpacketlist.empty()) + v = false; + else + v = true; + } -if (!created) -v = false; -else -{ -if (rawpacketlist.empty()) -v = false; -else -v = true; -} - -MAINMUTEX_UNLOCK -return v; + return v; } RTPRawPacket *RTPUDPv4TransmitterNoBind::GetNextPacket() { -if (!init) -return 0; + if (!init) + return 0; -MAINMUTEX_LOCK + RTPRawPacket *p; -RTPRawPacket *p; + if (!created) + { -if (!created) -{ -MAINMUTEX_UNLOCK -return 0; -} -if (rawpacketlist.empty()) -{ -MAINMUTEX_UNLOCK -return 0; -} + return 0; + } + if (rawpacketlist.empty()) + { -p = *(rawpacketlist.begin()); -rawpacketlist.pop_front(); + return 0; + } -MAINMUTEX_UNLOCK -return p; + p = *(rawpacketlist.begin()); + rawpacketlist.pop_front(); + + return p; } // Here the private functions start... @@ -1391,372 +1319,372 @@ return p; #ifdef RTP_SUPPORT_IPV4MULTICAST bool RTPUDPv4TransmitterNoBind::SetMulticastTTL(uint8_t ttl) { -int ttl2, status; + int ttl2, status; -ttl2 = (int) ttl; -status = setsockopt(rtpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); -if (status != 0) -return false; + ttl2 = (int) ttl; + status = setsockopt(rtpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); + if (status != 0) + return false; -if (rtpsock != rtcpsock) // no need to set TTL twice when multiplexing -{ -status = setsockopt(rtcpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); -if (status != 0) -return false; -} -return true; + if (rtpsock != rtcpsock) // no need to set TTL twice when multiplexing + { + status = setsockopt(rtcpsock, IPPROTO_IP, IP_MULTICAST_TTL, (const char *) &ttl2, sizeof(int)); + if (status != 0) + return false; + } + return true; } #endif // RTP_SUPPORT_IPV4MULTICAST void RTPUDPv4TransmitterNoBind::FlushPackets() { -std::list::const_iterator it; + std::list::const_iterator it; -for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) -delete *it; -rawpacketlist.clear(); + for (it = rawpacketlist.begin(); it != rawpacketlist.end(); ++it) + delete *it; + rawpacketlist.clear(); } int RTPUDPv4TransmitterNoBind::PollSocket(bool rtp) { -RTPSOCKLENTYPE fromlen; -int recvlen; -char packetbuffer[RTPUDPV4TRANSNOBIND_MAXPACKSIZE]; + RTPSOCKLENTYPE fromlen; + int recvlen; + char packetbuffer[RTPUDPV4TRANSNOBIND_MAXPACKSIZE]; #ifdef RTP_SOCKETTYPE_WINSOCK -SOCKET sock; -unsigned long len; + SOCKET sock; + unsigned long len; #else -size_t len; -int sock; + size_t len; + int sock; #endif // RTP_SOCKETTYPE_WINSOCK -struct sockaddr_in srcaddr; -bool dataavailable; + struct sockaddr_in srcaddr; + bool dataavailable; -if (rtp) -sock = rtpsock; -else -sock = rtcpsock; + if (rtp) + sock = rtpsock; + else + sock = rtcpsock; -do -{ -len = 0; -RTPIOCTL(sock, FIONREAD, &len); + do + { + len = 0; + RTPIOCTL(sock, FIONREAD, &len); -if (len <= 0) // make sure a packet of length zero is not queued -{ - // An alternative workaround would be to just use non-blocking sockets. - // However, since the user does have access to the sockets and I do not - // know how this would affect anyone else's code, I chose to do it using - // an extra select call in case ioctl says the length is zero. + if (len <= 0) // make sure a packet of length zero is not queued + { + // An alternative workaround would be to just use non-blocking sockets. + // However, since the user does have access to the sockets and I do not + // know how this would affect anyone else's code, I chose to do it using + // an extra select call in case ioctl says the length is zero. -int8_t isset = 0; -int status = RTPSelect(&sock, &isset, 1, RTPTime(0)); -if (status < 0) -return status; + int8_t isset = 0; + int status = RTPSelect(&sock, &isset, 1, RTPTime(0)); + if (status < 0) + return status; -if (isset) -dataavailable = true; -else -dataavailable = false; -} -else -dataavailable = true; + if (isset) + dataavailable = true; + else + dataavailable = false; + } + else + dataavailable = true; -if (dataavailable) -{ -RTPTime curtime = RTPTime::CurrentTime(); -fromlen = sizeof(struct sockaddr_in); -recvlen = recvfrom(sock, packetbuffer, RTPUDPV4TRANSNOBIND_MAXPACKSIZE, 0, (struct sockaddr *) &srcaddr, &fromlen); -if (recvlen > 0) -{ -bool acceptdata; + if (dataavailable) + { + RTPTime curtime = RTPTime::CurrentTime(); + fromlen = sizeof(struct sockaddr_in); + recvlen = recvfrom(sock, packetbuffer, RTPUDPV4TRANSNOBIND_MAXPACKSIZE, 0, (struct sockaddr *) &srcaddr, &fromlen); + if (recvlen > 0) + { + bool acceptdata; - // got data, process it -if (receivemode == RTPTransmitter::AcceptAll) -acceptdata = true; -else -acceptdata = ShouldAcceptData(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); + // got data, process it + if (receivemode == RTPTransmitter::AcceptAll) + acceptdata = true; + else + acceptdata = ShouldAcceptData(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); -if (acceptdata) -{ -RTPRawPacket *pack; -RTPIPv4Address *addr; -uint8_t *datacopy; + if (acceptdata) + { + RTPRawPacket *pack; + RTPIPv4Address *addr; + uint8_t *datacopy; -addr = new RTPIPv4Address(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); -if (addr == 0) -return ERR_RTP_OUTOFMEM; -datacopy = new uint8_t[recvlen]; -if (datacopy == 0) -{ -delete addr; -return ERR_RTP_OUTOFMEM; -} -memcpy(datacopy, packetbuffer, recvlen); + addr = new RTPIPv4Address(ntohl(srcaddr.sin_addr.s_addr), ntohs(srcaddr.sin_port)); + if (addr == 0) + return ERR_RTP_OUTOFMEM; + datacopy = new uint8_t[recvlen]; + if (datacopy == 0) + { + delete addr; + return ERR_RTP_OUTOFMEM; + } + memcpy(datacopy, packetbuffer, recvlen); -bool isrtp = rtp; -if (rtpsock == rtcpsock) // check payload type when multiplexing -{ -isrtp = true; + bool isrtp = rtp; + if (rtpsock == rtcpsock) // check payload type when multiplexing + { + isrtp = true; -if ((size_t) recvlen > sizeof(RTCPCommonHeader)) -{ - RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy; - uint8_t packettype = rtcpheader->packettype; + if ((size_t) recvlen > sizeof(RTCPCommonHeader)) + { + RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy; + uint8_t packettype = rtcpheader->packettype; - if (packettype >= 200 && packettype <= 204) - isrtp = false; -} -} + if (packettype >= 200 && packettype <= 204) + isrtp = false; + } + } -pack = new RTPRawPacket(datacopy, recvlen, addr, curtime, isrtp); -if (pack == 0) -{ -delete addr; -delete[] datacopy; -return ERR_RTP_OUTOFMEM; -} -rawpacketlist.push_back(pack); -} -} -} -} while (dataavailable); + pack = new RTPRawPacket(datacopy, recvlen, addr, curtime, isrtp); + if (pack == 0) + { + delete addr; + delete[] datacopy; + return ERR_RTP_OUTOFMEM; + } + rawpacketlist.push_back(pack); + } + } + } + } while (dataavailable); -return 0; + return 0; } int RTPUDPv4TransmitterNoBind::ProcessAddAcceptIgnoreEntry(uint32_t ip, uint16_t port) { -acceptignoreinfo.GotoElement(ip); -if (acceptignoreinfo.HasCurrentElement()) // An entry for this IP address already exists -{ -PortInfo *portinf = acceptignoreinfo.GetCurrentElement(); + acceptignoreinfo.GotoElement(ip); + if (acceptignoreinfo.HasCurrentElement()) // An entry for this IP address already exists + { + PortInfo *portinf = acceptignoreinfo.GetCurrentElement(); -if (port == 0) // select all ports -{ -portinf->all = true; -portinf->portlist.clear(); -} -else if (!portinf->all) -{ -std::list::const_iterator it, begin, end; + if (port == 0) // select all ports + { + portinf->all = true; + portinf->portlist.clear(); + } + else if (!portinf->all) + { + std::list::const_iterator it, begin, end; -begin = portinf->portlist.begin(); -end = portinf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == port) // already in list -return 0; -} -portinf->portlist.push_front(port); -} -} -else // got to create an entry for this IP address -{ -PortInfo *portinf; -int status; + begin = portinf->portlist.begin(); + end = portinf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == port) // already in list + return 0; + } + portinf->portlist.push_front(port); + } + } + else // got to create an entry for this IP address + { + PortInfo *portinf; + int status; -portinf = new PortInfo(); -if (port == 0) // select all ports -portinf->all = true; -else -portinf->portlist.push_front(port); + portinf = new PortInfo(); + if (port == 0) // select all ports + portinf->all = true; + else + portinf->portlist.push_front(port); -status = acceptignoreinfo.AddElement(ip, portinf); -if (status < 0) -{ -delete portinf; -return status; -} -} + status = acceptignoreinfo.AddElement(ip, portinf); + if (status < 0) + { + delete portinf; + return status; + } + } -return 0; + return 0; } void RTPUDPv4TransmitterNoBind::ClearAcceptIgnoreInfo() { -acceptignoreinfo.GotoFirstElement(); -while (acceptignoreinfo.HasCurrentElement()) -{ -PortInfo *inf; + acceptignoreinfo.GotoFirstElement(); + while (acceptignoreinfo.HasCurrentElement()) + { + PortInfo *inf; -inf = acceptignoreinfo.GetCurrentElement(); -delete inf; -acceptignoreinfo.GotoNextElement(); -} -acceptignoreinfo.Clear(); + inf = acceptignoreinfo.GetCurrentElement(); + delete inf; + acceptignoreinfo.GotoNextElement(); + } + acceptignoreinfo.Clear(); } int RTPUDPv4TransmitterNoBind::ProcessDeleteAcceptIgnoreEntry(uint32_t ip, uint16_t port) { -acceptignoreinfo.GotoElement(ip); -if (!acceptignoreinfo.HasCurrentElement()) -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + acceptignoreinfo.GotoElement(ip); + if (!acceptignoreinfo.HasCurrentElement()) + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -PortInfo *inf; + PortInfo *inf; -inf = acceptignoreinfo.GetCurrentElement(); -if (port == 0) // delete all entries -{ -inf->all = false; -inf->portlist.clear(); -} -else // a specific port was selected -{ -if (inf->all) // currently, all ports are selected. Add the one to remove to the list -{ - // we have to check if the list doesn't contain the port already -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (port == 0) // delete all entries + { + inf->all = false; + inf->portlist.clear(); + } + else // a specific port was selected + { + if (inf->all) // currently, all ports are selected. Add the one to remove to the list + { + // we have to check if the list doesn't contain the port already + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == port) // already in list: this means we already deleted the entry -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -} -inf->portlist.push_front(port); -} -else // check if we can find the port in the list -{ -std::list::iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == port) // already in list: this means we already deleted the entry + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + } + inf->portlist.push_front(port); + } + else // check if we can find the port in the list + { + std::list::iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; ++it) -{ -if (*it == port) // found it! -{ -inf->portlist.erase(it); -return 0; -} -} - // didn't find it -return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; -} -} -return 0; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; ++it) + { + if (*it == port) // found it! + { + inf->portlist.erase(it); + return 0; + } + } + // didn't find it + return ERR_RTP_UDPV4TRANS_NOSUCHENTRY; + } + } + return 0; } bool RTPUDPv4TransmitterNoBind::ShouldAcceptData(uint32_t srcip, uint16_t srcport) { -if (receivemode == RTPTransmitter::AcceptSome) -{ -PortInfo *inf; + if (receivemode == RTPTransmitter::AcceptSome) + { + PortInfo *inf; -acceptignoreinfo.GotoElement(srcip); -if (!acceptignoreinfo.HasCurrentElement()) -return false; + acceptignoreinfo.GotoElement(srcip); + if (!acceptignoreinfo.HasCurrentElement()) + return false; -inf = acceptignoreinfo.GetCurrentElement(); -if (!inf->all) // only accept the ones in the list -{ -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (!inf->all) // only accept the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return true; -} -return false; -} -else // accept all, except the ones in the list -{ -std::list::const_iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return true; + } + return false; + } + else // accept all, except the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return false; -} -return true; -} -} -else // IgnoreSome -{ -PortInfo *inf; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return false; + } + return true; + } + } + else // IgnoreSome + { + PortInfo *inf; -acceptignoreinfo.GotoElement(srcip); -if (!acceptignoreinfo.HasCurrentElement()) -return true; + acceptignoreinfo.GotoElement(srcip); + if (!acceptignoreinfo.HasCurrentElement()) + return true; -inf = acceptignoreinfo.GetCurrentElement(); -if (!inf->all) // ignore the ports in the list -{ -std::list::const_iterator it, begin, end; + inf = acceptignoreinfo.GetCurrentElement(); + if (!inf->all) // ignore the ports in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return false; -} -return true; -} -else // ignore all, except the ones in the list -{ -std::list::const_iterator it, begin, end; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return false; + } + return true; + } + else // ignore all, except the ones in the list + { + std::list::const_iterator it, begin, end; -begin = inf->portlist.begin(); -end = inf->portlist.end(); -for (it = begin; it != end; it++) -{ -if (*it == srcport) -return true; -} -return false; -} -} -return true; + begin = inf->portlist.begin(); + end = inf->portlist.end(); + for (it = begin; it != end; it++) + { + if (*it == srcport) + return true; + } + return false; + } + } + return true; } int RTPUDPv4TransmitterNoBind::CreateLocalIPList() { - // first try to obtain the list from the network interface info + // first try to obtain the list from the network interface info -if (!GetLocalIPList_Interfaces()) -{ - // If this fails, we'll have to depend on DNS info -GetLocalIPList_DNS(); -} -AddLoopbackAddress(); -return 0; + if (!GetLocalIPList_Interfaces()) + { + // If this fails, we'll have to depend on DNS info + GetLocalIPList_DNS(); + } + AddLoopbackAddress(); + return 0; } #ifdef RTP_SOCKETTYPE_WINSOCK bool RTPUDPv4TransmitterNoBind::GetLocalIPList_Interfaces() { -unsigned char buffer[RTPUDPV4TRANSNOBIND_IFREQBUFSIZE]; -DWORD outputsize; -DWORD numaddresses,i; -SOCKET_ADDRESS_LIST *addrlist; + unsigned char buffer[RTPUDPV4TRANSNOBIND_IFREQBUFSIZE]; + DWORD outputsize; + DWORD numaddresses,i; + SOCKET_ADDRESS_LIST *addrlist; -if (WSAIoctl(rtpsock,SIO_ADDRESS_LIST_QUERY,NULL,0,&buffer,RTPUDPV4TRANSNOBIND_IFREQBUFSIZE,&outputsize,NULL,NULL)) -return false; + if (WSAIoctl(rtpsock,SIO_ADDRESS_LIST_QUERY,NULL,0,&buffer,RTPUDPV4TRANSNOBIND_IFREQBUFSIZE,&outputsize,NULL,NULL)) + return false; -addrlist = (SOCKET_ADDRESS_LIST *)buffer; -numaddresses = addrlist->iAddressCount; -for (i = 0; i < numaddresses; i++) -{ -SOCKET_ADDRESS *sockaddr = &(addrlist->Address[i]); -if (sockaddr->iSockaddrLength == sizeof(struct sockaddr_in)) // IPv4 address -{ -struct sockaddr_in *addr = (struct sockaddr_in *)sockaddr->lpSockaddr; + addrlist = (SOCKET_ADDRESS_LIST *)buffer; + numaddresses = addrlist->iAddressCount; + for (i = 0; i < numaddresses; i++) + { + SOCKET_ADDRESS *sockaddr = &(addrlist->Address[i]); + if (sockaddr->iSockaddrLength == sizeof(struct sockaddr_in)) // IPv4 address + { + struct sockaddr_in *addr = (struct sockaddr_in *)sockaddr->lpSockaddr; -localIPs.push_back(ntohl(addr->sin_addr.s_addr)); -} -} + localIPs.push_back(ntohl(addr->sin_addr.s_addr)); + } + } -if (localIPs.empty()) -return false; + if (localIPs.empty()) + return false; -return true; + return true; } #else // use either getifaddrs or ioctl @@ -1765,92 +1693,92 @@ return true; bool RTPUDPv4TransmitterNoBind::GetLocalIPList_Interfaces() { -struct ifaddrs *addrs, *tmp; + struct ifaddrs *addrs, *tmp; -getifaddrs(&addrs); -tmp = addrs; + getifaddrs(&addrs); + tmp = addrs; -while (tmp != 0) -{ -if (tmp->ifa_addr != 0 && tmp->ifa_addr->sa_family == AF_INET) -{ -struct sockaddr_in *inaddr = (struct sockaddr_in *) tmp->ifa_addr; -localIPs.push_back(ntohl(inaddr->sin_addr.s_addr)); -} -tmp = tmp->ifa_next; -} + while (tmp != 0) + { + if (tmp->ifa_addr != 0 && tmp->ifa_addr->sa_family == AF_INET) + { + struct sockaddr_in *inaddr = (struct sockaddr_in *) tmp->ifa_addr; + localIPs.push_back(ntohl(inaddr->sin_addr.s_addr)); + } + tmp = tmp->ifa_next; + } -freeifaddrs(addrs); + freeifaddrs(addrs); -if (localIPs.empty()) -return false; -return true; + if (localIPs.empty()) + return false; + return true; } #else // user ioctl bool RTPUDPv4TransmitterNoBind::GetLocalIPList_Interfaces() { -int status; -char buffer[RTPUDPV4TRANSNOBIND_IFREQBUFSIZE]; -struct ifconf ifc; -struct ifreq *ifr; -struct sockaddr *sa; -char *startptr,*endptr; -int remlen; + int status; + char buffer[RTPUDPV4TRANSNOBIND_IFREQBUFSIZE]; + struct ifconf ifc; + struct ifreq *ifr; + struct sockaddr *sa; + char *startptr,*endptr; + int remlen; -ifc.ifc_len = RTPUDPV4TRANSNOBIND_IFREQBUFSIZE; -ifc.ifc_buf = buffer; -status = ioctl(rtpsock,SIOCGIFCONF,&ifc); -if (status < 0) -return false; + ifc.ifc_len = RTPUDPV4TRANSNOBIND_IFREQBUFSIZE; + ifc.ifc_buf = buffer; + status = ioctl(rtpsock,SIOCGIFCONF,&ifc); + if (status < 0) + return false; -startptr = (char *)ifc.ifc_req; -endptr = startptr + ifc.ifc_len; -remlen = ifc.ifc_len; -while((startptr < endptr) && remlen >= (int)sizeof(struct ifreq)) -{ -ifr = (struct ifreq *)startptr; -sa = &(ifr->ifr_addr); + startptr = (char *)ifc.ifc_req; + endptr = startptr + ifc.ifc_len; + remlen = ifc.ifc_len; + while((startptr < endptr) && remlen >= (int)sizeof(struct ifreq)) + { + ifr = (struct ifreq *)startptr; + sa = &(ifr->ifr_addr); #ifdef RTP_HAVE_SOCKADDR_LEN -if (sa->sa_len <= sizeof(struct sockaddr)) -{ -if (sa->sa_len == sizeof(struct sockaddr_in) && sa->sa_family == PF_INET) -{ -uint32_t ip; -struct sockaddr_in *addr = (struct sockaddr_in *)sa; + if (sa->sa_len <= sizeof(struct sockaddr)) + { + if (sa->sa_len == sizeof(struct sockaddr_in) && sa->sa_family == PF_INET) + { + uint32_t ip; + struct sockaddr_in *addr = (struct sockaddr_in *)sa; -ip = ntohl(addr->sin_addr.s_addr); -localIPs.push_back(ip); -} -remlen -= sizeof(struct ifreq); -startptr += sizeof(struct ifreq); -} -else -{ -int l = sa->sa_len-sizeof(struct sockaddr)+sizeof(struct ifreq); + ip = ntohl(addr->sin_addr.s_addr); + localIPs.push_back(ip); + } + remlen -= sizeof(struct ifreq); + startptr += sizeof(struct ifreq); + } + else + { + int l = sa->sa_len-sizeof(struct sockaddr)+sizeof(struct ifreq); -remlen -= l; -startptr += l; -} + remlen -= l; + startptr += l; + } #else // don't have sa_len in struct sockaddr -if (sa->sa_family == PF_INET) -{ -uint32_t ip; -struct sockaddr_in *addr = (struct sockaddr_in *)sa; + if (sa->sa_family == PF_INET) + { + uint32_t ip; + struct sockaddr_in *addr = (struct sockaddr_in *)sa; -ip = ntohl(addr->sin_addr.s_addr); -localIPs.push_back(ip); -} -remlen -= sizeof(struct ifreq); -startptr += sizeof(struct ifreq); + ip = ntohl(addr->sin_addr.s_addr); + localIPs.push_back(ip); + } + remlen -= sizeof(struct ifreq); + startptr += sizeof(struct ifreq); #endif // RTP_HAVE_SOCKADDR_LEN -} + } -if (localIPs.empty()) -return false; -return true; + if (localIPs.empty()) + return false; + return true; } #endif // RTP_SUPPORT_IFADDRS @@ -1859,49 +1787,49 @@ return true; void RTPUDPv4TransmitterNoBind::GetLocalIPList_DNS() { -struct hostent *he; -char name[1024]; -bool done; -int i, j; + struct hostent *he; + char name[1024]; + bool done; + int i, j; -gethostname(name, 1023); -name[1023] = 0; -he = gethostbyname(name); -if (he == 0) -return; + gethostname(name, 1023); + name[1023] = 0; + he = gethostbyname(name); + if (he == 0) + return; -i = 0; -done = false; -while (!done) -{ -if (he->h_addr_list[i] == NULL) -done = true; -else -{ -uint32_t ip = 0; + i = 0; + done = false; + while (!done) + { + if (he->h_addr_list[i] == NULL) + done = true; + else + { + uint32_t ip = 0; -for (j = 0; j < 4; j++) -ip |= ((uint32_t) ((unsigned char) he->h_addr_list[i][j]) << ((3 - j) * 8)); -localIPs.push_back(ip); -i++; -} -} + for (j = 0; j < 4; j++) + ip |= ((uint32_t) ((unsigned char) he->h_addr_list[i][j]) << ((3 - j) * 8)); + localIPs.push_back(ip); + i++; + } + } } void RTPUDPv4TransmitterNoBind::AddLoopbackAddress() { -uint32_t loopbackaddr = (((uint32_t) 127) << 24) | ((uint32_t) 1); -std::list::const_iterator it; -bool found = false; + uint32_t loopbackaddr = (((uint32_t) 127) << 24) | ((uint32_t) 1); + std::list::const_iterator it; + bool found = false; -for (it = localIPs.begin(); !found && it != localIPs.end(); it++) -{ -if (*it == loopbackaddr) -found = true; -} + for (it = localIPs.begin(); !found && it != localIPs.end(); it++) + { + if (*it == loopbackaddr) + found = true; + } -if (!found) -localIPs.push_back(loopbackaddr); + if (!found) + localIPs.push_back(loopbackaddr); } } // end namespace