发现live555中一个小bug(2)

在《发现live555中一个小bug》一文中所修改的代码并不起作用。

经测试，RTPSource的Socket检测不到网络出错的情况。而RTCPInstance中的socket可以检测到，所以可以利用RTCPInstance通知RTPSource应停止流传输了。修改如下（//---------------------包含的代码为修改处）：

void RTCPInstance::incomingReportHandler1()
{
do {
int tcpReadStreamSocketNum = fRTCPInterface.nextTCPReadStreamSocketNum();
unsigned char tcpReadStreamChannelId = fRTCPInterface.nextTCPReadStreamChannelId();
unsigned packetSize = 0;
unsigned numBytesRead;
struct sockaddr_in fromAddress;
Boolean packetReadWasIncomplete;
Boolean readResult = fRTCPInterface.handleRead(
&fInBuf[fNumBytesAlreadyRead],
maxPacketSize - fNumBytesAlreadyRead, numBytesRead, fromAddress,
packetReadWasIncomplete);
if (packetReadWasIncomplete) {
fNumBytesAlreadyRead += numBytesRead;
return; // more reads are needed to get the entire packet
} else { // normal case: We've read the entire packet
packetSize = fNumBytesAlreadyRead + numBytesRead;
fNumBytesAlreadyRead = 0; // for next time
}
if (!readResult){
//--------------------------------
//出错了，停止网络读
fRTCPInterface.stopNetworkReading();
//通知RTPSource和RTPSink，网络出错了，应该停止了
if(fSink)
fSink->stopPlaying();
if(fSource)
fSource->handleClosure((void*)fSource);
//---------------------------------
break;
}

// Ignore the packet if it was looped-back from ourself:
Boolean packetWasFromOurHost = False;
if (RTCPgs()->wasLoopedBackFromUs(envir(), fromAddress)) {
packetWasFromOurHost = True;
// However, we still want to handle incoming RTCP packets from
// *other processes* on the same machine.  To distinguish this
// case from a true loop-back, check whether we've just sent a
// packet of the same size.  (This check isn't perfect, but it seems
// to be the best we can do.)
if (fHaveJustSentPacket && fLastPacketSentSize == packetSize) {
// This is a true loop-back:
fHaveJustSentPacket = False;
break; // ignore this packet
}
}

unsigned char* pkt = fInBuf;
if (fIsSSMSource && !packetWasFromOurHost) {
// This packet is assumed to have been received via unicast (because we're a SSM source, and SSM receivers send back RTCP "RR"
// packets via unicast).  'Reflect' the packet by resending it to the multicast group, so that any other receivers can also
// get to see it.

// NOTE: Denial-of-service attacks are possible here.
// Users of this software may wish to add their own,
// application-specific mechanism for 'authenticating' the
// validity of this packet before reflecting it.

// NOTE: The test for "!packetWasFromOurHost" means that we won't reflect RTCP packets that come from other processes on
// the same host as us.  The reason for this is that the 'packet size' test above is not 100% reliable; some packets
// that were truly looped back from us might not be detected as such, and this might lead to infinite forwarding/receiving
// of some packets.  To avoid this possibility, we only reflect RTCP packets that we know for sure originated elsewhere.
// (Note, though, that if we ever re-enable the code in "Groupsock::multicastSendOnly()", then we could remove the test for
// "!packetWasFromOurHost".)
fRTCPInterface.sendPacket(pkt, packetSize);
fHaveJustSentPacket = True;
fLastPacketSentSize = packetSize;
}

#ifdef DEBUG
fprintf(stderr, "[%p]saw incoming RTCP packet (from address %s, port %d)\n", this, our_inet_ntoa(fromAddress.sin_addr), ntohs(fromAddress.sin_port));
for (unsigned i = 0; i < packetSize; ++i) {
if (i%4 == 0) fprintf(stderr, " ");
fprintf(stderr, "%02x", pkt[i]);
}
fprintf(stderr, "\n");
#endif
int totPacketSize = IP_UDP_HDR_SIZE + packetSize;

// Check the RTCP packet for validity:
// It must at least contain a header (4 bytes), and this header
// must be version=2, with no padding bit, and a payload type of
// SR (200) or RR (201):
if (packetSize < 4)
break;
unsigned rtcpHdr = ntohl(*(u_int32_t*) pkt);
if ((rtcpHdr & 0xE0FE0000) != (0x80000000 | (RTCP_PT_SR << 16))) {
#ifdef DEBUG
fprintf(stderr, "rejected bad RTCP packet: header 0x%08x\n", rtcpHdr);
#endif
break;
}

// Process each of the individual RTCP 'subpackets' in (what may be)
// a compound RTCP packet.
int typeOfPacket = PACKET_UNKNOWN_TYPE;
unsigned reportSenderSSRC = 0;
Boolean packetOK = False;
while (1) {
unsigned rc = (rtcpHdr >> 24) & 0x1F;
unsigned pt = (rtcpHdr >> 16) & 0xFF;
unsigned length = 4 * (rtcpHdr & 0xFFFF); // doesn't count hdr
ADVANCE(4);
// skip over the header
if (length > packetSize)
break;

// Assume that each RTCP subpacket begins with a 4-byte SSRC:
if (length < 4)
break;
length -= 4;
reportSenderSSRC = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);

Boolean subPacketOK = False;
switch (pt) {
case RTCP_PT_SR: {
#ifdef DEBUG
fprintf(stderr, "SR\n");
#endif
if (length < 20)
break;
length -= 20;

// Extract the NTP timestamp, and note this:
unsigned NTPmsw = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned NTPlsw = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned rtpTimestamp = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
if (fSource != NULL) {
RTPReceptionStatsDB& receptionStats = fSource->receptionStatsDB();
receptionStats.noteIncomingSR(reportSenderSSRC, NTPmsw,
NTPlsw, rtpTimestamp);
}ADVANCE(8);
// skip over packet count, octet count

// If a 'SR handler' was set, call it now:
if (fSRHandlerTask != NULL)
(*fSRHandlerTask)(fSRHandlerClientData);

// The rest of the SR is handled like a RR (so, no "break;" here)
}
case RTCP_PT_RR: {
#ifdef DEBUG
fprintf(stderr, "RR\n");
#endif
unsigned reportBlocksSize = rc * (6 * 4);
if (length < reportBlocksSize)
break;
length -= reportBlocksSize;

if (fSink != NULL) {
// Use this information to update stats about our transmissions:
RTPTransmissionStatsDB& transmissionStats = fSink->transmissionStatsDB();
for (unsigned i = 0; i < rc; ++i) {
unsigned senderSSRC = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
// We care only about reports about our own transmission, not others'
if (senderSSRC == fSink->SSRC()) {
unsigned lossStats = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned highestReceived = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned jitter = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned timeLastSR = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
unsigned timeSinceLastSR = ntohl(*(u_int32_t*) pkt);
ADVANCE(4);
transmissionStats.noteIncomingRR(reportSenderSSRC,
fromAddress, lossStats, highestReceived,
jitter, timeLastSR, timeSinceLastSR);
} else {
ADVANCE(4*5);
}
}
} else {
ADVANCE(reportBlocksSize);
}

if (pt == RTCP_PT_RR) { // i.e., we didn't fall through from 'SR'
// If a 'RR handler' was set, call it now:

// Specific RR handler:
if (fSpecificRRHandlerTable != NULL) {
netAddressBits fromAddr;
portNumBits fromPortNum;
if (tcpReadStreamSocketNum < 0) {
// Normal case: We read the RTCP packet over UDP
fromAddr = fromAddress.sin_addr.s_addr;
fromPortNum = ntohs(fromAddress.sin_port);
} else {
// Special case: We read the RTCP packet over TCP (interleaved)
// Hack: Use the TCP socket and channel id to look up the handler
fromAddr = tcpReadStreamSocketNum;
fromPortNum = tcpReadStreamChannelId;
}
Port fromPort(fromPortNum);
RRHandlerRecord* rrHandler = (RRHandlerRecord*) (fSpecificRRHandlerTable->Lookup(
fromAddr, (~0), fromPort));
if (rrHandler != NULL) {
if (rrHandler->rrHandlerTask != NULL) {
(*(rrHandler->rrHandlerTask))(
rrHandler->rrHandlerClientData);
}
}
}

// General RR handler:
if (fRRHandlerTask != NULL)
(*fRRHandlerTask)(fRRHandlerClientData);
}

subPacketOK = True;
typeOfPacket = PACKET_RTCP_REPORT;
break;
}
case RTCP_PT_BYE: {
#ifdef DEBUG
fprintf(stderr, "BYE\n");
#endif
// If a 'BYE handler' was set, call it now:
TaskFunc* byeHandler = fByeHandlerTask;
if (byeHandler != NULL
&& (!fByeHandleActiveParticipantsOnly
|| (fSource != NULL
&& fSource->receptionStatsDB().lookup(
reportSenderSSRC) != NULL)
|| (fSink != NULL
&& fSink->transmissionStatsDB().lookup(
reportSenderSSRC) != NULL))) {
fByeHandlerTask = NULL;
// we call this only once by default
(*byeHandler)(fByeHandlerClientData);
}

// We should really check for & handle >1 SSRCs being present #####

subPacketOK = True;
typeOfPacket = PACKET_BYE;
break;
}
// Later handle SDES, APP, and compound RTCP packets #####
default:
#ifdef DEBUG
fprintf(stderr, "UNSUPPORTED TYPE(0x%x)\n", pt);
#endif
subPacketOK = True;
break;
}
if (!subPacketOK)
break;

// need to check for (& handle) SSRC collision! #####

#ifdef DEBUG
fprintf(stderr, "validated RTCP subpacket (type %d): %d, %d, %d, 0x%08x\n", typeOfPacket, rc, pt, length, reportSenderSSRC);
#endif

// Skip over any remaining bytes in this subpacket:
ADVANCE(length);

// Check whether another RTCP 'subpacket' follows:
if (packetSize == 0) {
packetOK = True;
break;
} else if (packetSize < 4) {
#ifdef DEBUG
fprintf(stderr, "extraneous %d bytes at end of RTCP packet!\n", packetSize);
#endif
break;
}
rtcpHdr = ntohl(*(u_int32_t*) pkt);
if ((rtcpHdr & 0xC0000000) != 0x80000000) {
#ifdef DEBUG
fprintf(stderr, "bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
#endif
break;
}
}

if (!packetOK) {
#ifdef DEBUG
fprintf(stderr, "rejected bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
#endif
break;
} else {
#ifdef DEBUG
fprintf(stderr, "validated entire RTCP packet\n");
#endif
}

onReceive(typeOfPacket, totPacketSize, reportSenderSSRC);
} while (0);
}

注意，fSource为 const*型的，设计者的原意是不能这样用的，但找不到更好的办法，而且测试没有问题，但是不能保证在以后的版本中不会出问题哦。