[置顶]发现live555中一个小bug(2)

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

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

view
plain

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*型的，设计者的原意是不能这样用的，但找不到更好的办法，而且测试没有问题，但是不能保证在以后的版本中不会出问题哦。

转载http://blog.csdn.net/nkmnkm/article/details/7004764