Tested closing tcp connections, updated docs

Author: j0r1

src/rtptcpaddress.h

@@ -49,7 +49,9 @@ namespace jrtplib
 class RTPMemoryManager;
 
 /** Represents a TCP 'address' and port.
- *  This class is used by the TCP transmission component.
+ *  This class is used by the TCP transmission component, to specify which sockets
+ *  should be used to send/receive data, and to know on which socket incoming data
+ *  was received.
  */
 class JRTPLIB_IMPORTEXPORT RTPTCPAddress : public RTPAddress
 {

src/rtptcptransmitter.cpp

@@ -305,7 +305,13 @@ int RTPTCPTransmitter::Poll()
 			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;
 	}
@@ -899,17 +905,20 @@ int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len)
 
 	std::map<SocketType, SocketData>::iterator it = m_destSockets.begin();
 	std::map<SocketType, SocketData>::iterator end = m_destSockets.end();
-	int status = 0;
 
 	vector<SocketType> errSockets;
+	int flags = 0;
+#ifndef RTP_SOCKETTYPE_WINSOCK // TODO: replace this by a test
+	flags = MSG_NOSIGNAL;
+#endif
 
 	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,0) < 0 ||
-			send(sock,(const char *)data,len,0) < 0)
+		if (send(sock,(const char *)lengthBytes,2,flags) < 0 ||
+			send(sock,(const char *)data,len,flags) < 0)
 			errSockets.push_back(sock);
 		++it;
 	}
@@ -918,13 +927,14 @@ int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len)
 
 	if (errSockets.size() != 0)
 	{
-		status = ERR_RTP_TCPTRANS_ERRORINSEND;
-
 		for (size_t i = 0 ; i < errSockets.size() ; i++)
 			OnSendError(errSockets[i]);
 	}
 
-	return status;
+	// Don't return an error code to avoid the poll thread exiting
+	// due to one closed connection for example
+
+	return 0;
 }
 
 int RTPTCPTransmitter::ValidateSocket(SocketType)

src/rtptcptransmitter.h

@@ -60,7 +60,7 @@ class JRTPLIB_IMPORTEXPORT RTPTCPTransmissionParams : public RTPTransmissionPara
 	RTPTCPTransmissionParams();
 
 	/** If non null, the specified abort descriptors will be used to cancel
-	 *  the function that's waiting for packets to arrive; set to null (the default
+	 *  the function that's waiting for packets to arrive; set to null (the default)
 	 *  to let the transmitter create its own instance. */
 	void SetCreatedAbortDescriptors(RTPAbortDescriptors *desc) { m_pAbortDesc = desc; }
 
@@ -89,11 +89,25 @@ class JRTPLIB_IMPORTEXPORT RTPTCPTransmissionInfo : public RTPTransmissionInfo
 #define RTPTCPTRANS_HEADERSIZE						(20+20+2) // 20 IP, 20 TCP, 2 for framing (RFC 4571)
 
 /** A TCP transmission component.
+ *
  *  This class inherits the RTPTransmitter interface and implements a transmission component 
  *  which uses TCP to send and receive RTP and RTCP data. The component's parameters 
  *  are described by the class RTPTCPTransmissionParams. The functions which have an RTPAddress 
- *  argument require an argument of RTPTCPAddress. The GetTransmissionInfo member function
+ *  argument require an argument of RTPTCPAddress. The RTPTransmitter::GetTransmissionInfo member function
  *  returns an instance of type RTPTCPTransmissionInfo.
+ *
+ *  After this transmission component was created, no data will actually be sent or received
+ *  yet. You can specify over which TCP connections (which must be established first) data
+ *  should be transmitted by using the RTPTransmitter::AddDestination member function. This
+ *  takes an argument of type RTPTCPAddress, with which relevant the socket descriptor can
+ *  be passed to the transmitter. 
+ *
+ *  These sockets will also be used to check for incoming RTP or RTCP data. The RTPTCPAddress
+ *  instance that's associated with a received packet, will contain the socket descriptor
+ *  on which the data was received. This descriptor can be obtained using RTPTCPAddress::GetSocket.
+ *
+ *  To get notified of an error when sending over or receiving from a socket, override the
+ *  RTPTCPTransmitter::OnSendError and RTPTCPTransmitter::OnReceiveError member functions.
  */
 class JRTPLIB_IMPORTEXPORT RTPTCPTransmitter : public RTPTransmitter
 {
@@ -142,9 +156,9 @@ class JRTPLIB_IMPORTEXPORT RTPTCPTransmitter : public RTPTransmitter
 	void Dump();
 #endif // RTPDEBUG
 protected:
-	// TODO
+	/** By overriding this function you can be notified of an error when sending over a socket. */
 	virtual void OnSendError(SocketType sock);
-	// TODO
+	/** By overriding this function you can be notified of an error when receiving from a socket. */
 	virtual void OnReceiveError(SocketType sock);
 private:
 	class SocketData

tests/tcptest.cpp

@@ -6,10 +6,8 @@
 #include "rtperrors.h"
 #include "rtpsourcedata.h"
 #include "rtptcpaddress.h"
+#include "rtptcptransmitter.h"
 #include "rtppacket.h"
-#ifndef RTP_SOCKETTYPE_WINSOCK
-#include <netinet/tcp.h>
-#endif
 #include <string.h>
 #include <stdlib.h>
 #include <iostream>
@@ -54,19 +52,50 @@ class MyRTPSession : public RTPSession
 	}
 };
 
+class MyTCPTransmitter : public RTPTCPTransmitter
+{
+public:
+	MyTCPTransmitter(const string &name) : RTPTCPTransmitter(0), m_name(name) { }
+
+	void OnSendError(SocketType sock)
+	{
+		cout << m_name << ": Error sending over socket " << sock << ", removing destination" << endl;
+		DeleteDestination(RTPTCPAddress(sock));
+	}
+	
+	void OnReceiveError(SocketType sock)
+	{
+		cout << m_name << ": Error receiving from socket " << sock << ", removing destination" << endl;
+		DeleteDestination(RTPTCPAddress(sock));
+	}
+private:
+	string m_name;
+};
+
 void runTest(int sock1, int sock2)
 {
 	const int packSize = 45678;
 	RTPSessionParams sessParams;
+	MyTCPTransmitter trans1("Transmitter1"), trans2("Transmitter2");
 	MyRTPSession sess1, sess2;
 
 	sessParams.SetProbationType(RTPSources::NoProbation);
 	sessParams.SetOwnTimestampUnit(1.0/packSize);
 	sessParams.SetMaximumPacketSize(packSize + 64); // some extra room for rtp header
 
-	checkerror(sess1.Create(sessParams, 0, RTPTransmitter::TCPProto));
+	bool threadsafe = false;
+#ifdef RTP_SUPPORT_THREAD
+	threadsafe = true;
+#endif // RTP_SUPPORT_THREAD
+
+	checkerror(trans1.Init(threadsafe));
+	checkerror(trans2.Init(threadsafe));
+	checkerror(trans1.Create(65535, 0));
+	checkerror(trans2.Create(65535, 0));
+
+	checkerror(sess1.Create(sessParams, &trans1));
 	cout << "Session 1 created " << endl;
-	checkerror(sess2.Create(sessParams, 0, RTPTransmitter::TCPProto));
+	checkerror(sess2.Create(sessParams, &trans2));
 	cout << "Session 2 created " << endl;
 
 	checkerror(sess1.AddDestination(RTPTCPAddress(sock1)));
@@ -83,6 +112,9 @@ void runTest(int sock1, int sock2)
 		int len = (i%2 == 0)?pack.size():0;
 		checkerror(sess1.SendPacket((void *)&pack[0],len,0,false,10));
 
+		if (i == 10)
+			RTPCLOSE(sock1); // Induce an error when sending/receiving
+
 		// Either the background thread or the poll function itself will
 		// cause the OnValidatedRTPPacket and OnRTCPSDESItem functions to
 		// be called, so in this loop there's not much left to do. 
@@ -154,16 +186,6 @@ int main(int argc, char *argv[])
 	RTPCLOSE(listener);
 
 	cout << "Got connected socket pair" << endl;
-	cout << "Turning off Nagle's algorithm" << endl;
-
-	int flag = 1;
-	if (setsockopt(client, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)) != 0 ||
-		setsockopt(server, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)) != 0)
-	{
-		cerr << "Unable to turn off Nagle's algorithm on a socket" << endl;
-		return -1;
-	}
-
 
 	runTest(server, client);