rtsp.c

一个简单的RTSP客户端实现源码

    					}
    					//fprintf(stderr,"start recv\n");
					ptr = Description+bytesRead;
					//ptr = &readBuf[bytesRead];
					bytesRead2 = recv(fSocketNum, (unsigned char*)ptr,numExtraBytesNeeded,0);
					if (bytesRead2 <0) break;
					ptr[bytesRead2] = '\0';
						

					bytesRead += bytesRead2;
					numExtraBytesNeeded -= bytesRead2;
				}
				if (numExtraBytesNeeded > 0) break; // one of the reads failed
			
				free(readBuffer);
				free(cmd);
				return 0;
			}
		}
	}while(0);
	free(readBuffer);
	free(cmd);
	Description = NULL;
	return -1;
}

char* getLine(char* startOfLine) 
{
	// returns the start of the next line, or NULL if none
	char* ptr;
	for (ptr = startOfLine; *ptr != '\0'; ++ptr) 
	{
		if (*ptr == '\r' || *ptr == '\n') 
		{
			// We found the end of the line
			*ptr++ = '\0';
			if (*ptr == '\n') ++ptr;
			return ptr;
		}
	}

	return NULL;
}

int openConnectionFromURL(char* url)
{
	struct hostent *hp;
	char address[100];
	int destPortNum;
	struct sockaddr_in server;
	int fSocketNum = -1;
	if (url == NULL) return -1;
	memset(address,0,100);
	if (parseRTSPURL(url, address, &destPortNum)) return -1;
  
  
	fSocketNum = socket(AF_INET, SOCK_STREAM, 0);
  
	if (fSocketNum < 0) 
	{
		fprintf(stderr,"Client: Error Opening socket\n");
		return -1;
	}
	hp = gethostbyname(address);
	if (hp == NULL ) 
	{
		fprintf(stderr,"Client: Cannot resolve address [%s]\n",address);
		return -1;
	}
	
	memset(&server,0,sizeof(struct sockaddr_in));
	memcpy(&(server.sin_addr),hp->h_addr,hp->h_length);
	server.sin_family = AF_INET;
	server.sin_port = htons((unsigned short)destPortNum);
	if (connect(fSocketNum, (struct sockaddr*)&server, sizeof(struct sockaddr_in))!= 0) 
	if (connect(fSocketNum, (struct sockaddr*)&server, sizeof(struct sockaddr_in))!= 0) 
	{
		fprintf(stderr,"connect() failed\n");
		//closesocket(fSocketNum);
		close(fSocketNum);
		return -1;
	}
//fprintf(stderr,"connect() successful \n");
	return fSocketNum;
}

int parseRTSPURL(char* url,char * address,int* portNum) 
{
	
	char const* prefix = "rtsp://";
	unsigned const prefixLength = 7;
	char* from = NULL ;
	char* to = NULL;
	unsigned i;
	char nextChar;
	if (strncmp(url, prefix, prefixLength) != 0) 
	{
		fprintf(stderr,"URL is not of the form\n");
		return -1;
	}
		
	from = &url[prefixLength];
	to = &address[0];
	for (i = 0; i < parseBufferSize; ++i) 
	{
		if (*from == '\0' || *from == ':' || *from == '/') 
		{
	// We've completed parsing the address
			*to = '\0';
			break;
		}
		*to++ = *from++;
	}
	if (i == parseBufferSize) 
	{
		fprintf(stderr,"URL is too long\n");
		return -1;
	}

 	*portNum = 554; // default value
	nextChar = *from;
	if (nextChar == ':') 
	{
		int portNumInt;
		if (sscanf(++from, "%d", &portNumInt) != 1) 
		{
			fprintf(stderr,"No port number follows :%d\n",portNumInt);
			return -1;
		}
		if (portNumInt < 1 || portNumInt > 65535) 
		{
			fprintf(stderr,"Bad port number\n");
			return -1;
		}
		*portNum = portNumInt;
	}
	//fprintf(stderr,"address is %s;portNum is %d \n",address,*portNum);
	return 0;
}

////////////////////////
void resumeStreams(int socketNum)
{
	//double start;
	//start = (double)(vloopNum*1000)/(double)(VFrameRate);
	long start;
	start = vloopNum*1000/VFrameRate;

	//if(playMediaSession(socketNum,start,(double)fMaxPlayEndTime/(double)1000)) 
	if(playMediaSession(socketNum,start,-1)) 
	{	
			fprintf(stderr,"Play MediaSubsession Failed\n");
			exit(0);
	}
	fprintf(stderr,"Play Streams successful\n");
}

int playMediaSession(int socketNum,int start,int end)//double start, double end)
{
	char* cmd = NULL;
	char cmdFmt[] =
			"PLAY %s/ RTSP/1.0\r\n"
			"CSeq: %d\r\n"
			"Session: %s\r\n"
			//"Range: \r\n"
			"Range: npt=%s-%s\r\n"
			"%s\r\n";
	char startStr[30], endStr[30];
	unsigned cmdSize;
	unsigned const readBufSize = 10000;
	char *readBuffer;
	char* readBuf;
	int bytesRead;
	char* firstLine;
	char* nextLineStart;
	unsigned responseCode;
	readBuffer = (char*)malloc(sizeof(char)*(readBufSize+1));
	if(readBuffer == NULL) return -1;
	memset(readBuffer,0,readBufSize+1);
	do 
	{
		// First, make sure that we have a RTSP session in progress
		if (fLastSessionId == NULL) 
		{
			fprintf(stderr,"No RTSP session is currently in progress\n");
			break;
		}

		// Send the PLAY command:

		// First, construct an authenticator string:
//		sprintf(startStr, "%.3f", start); 
//sprintf(endStr, "%.3f", end);
sprintf(startStr,"%d",start);
sprintf(endStr,"%d",end);
		
		if (start==-1) startStr[0]='\0';
		if (end == -1) endStr[0] = '\0';
			
		cmdSize = strlen(cmdFmt)
			+ strlen(fBaseURL)//+strlen(subsession->fControlPath)
			+ 20 /* max int len */
			+ strlen(fLastSessionId)
			+ strlen(startStr) + strlen(endStr)
			+ strlen(UserAgentHeaderStr);
		cmd = (char*)malloc(sizeof(char)*cmdSize);
		if(cmd == NULL) 
		{
			free(readBuffer);
			return -1;
		}
		memset(cmd,0,cmdSize);
		sprintf(cmd, cmdFmt,
			fBaseURL,
			//subsession->fControlPath,
			++fCSeq,
			fLastSessionId,
			startStr, endStr,
			UserAgentHeaderStr);

		fprintf(stderr,"PLAY command-%d:\n%s\n",fCSeq,cmd);
		if (send(socketNum,cmd,strlen(cmd),0)<0) 
		{
			fprintf(stderr,"PLAY send() failed\n ");
			break;
		}
		readBuf = readBuffer;
		// Get the response from the server:
		bytesRead = getResponse(socketNum,readBuf, readBufSize);

		if (bytesRead <= 0) break;
		 
		fprintf(stderr,"PLAY response-%d:\n%s\n",fCSeq,readBuf);
		
		// Inspect the first line to check whether it's a result code 200
		firstLine = readBuf;
		nextLineStart = getLine(firstLine);
		if (parseResponseCode(firstLine,&responseCode)) break;
		if (responseCode != 200) 
		{
			fprintf(stderr,"cannot handle PLAY response\n ");
			break;
		}

			free(cmd);
	free(readBuffer);
		return 0;
	} while (0);

	free(cmd);
 free(readBuffer);
	return -1;
}
/*int getPauseResponse(int socketNum,char* responseBuffer,unsigned responseBufferSize) 
{
	int fSocketNum;
	char *lastToCheck=NULL;
	char* p = NULL;//responseBuffer;
	int bytesRead = 0; // because we've already read the first byte
	unsigned bytesReadNow	= 0;
	fSocketNum = socketNum;

	if (responseBufferSize == 0) return 0; // just in case...
	//responseBuffer[0] = '\0'; // ditto
	*(responseBuffer) = '\0';

	// Keep reading data from the socket until we see "\r\n\r\n" (except
	// at the start), or until we fill up our buffer.
	// Don't read any more than this.
	while (bytesRead < (int)responseBufferSize) 
	{
		lastToCheck = NULL;
		if(blockUntilReadable(fSocketNum)<=0)
		{
			fprintf(stderr,"socket is unreadable\n");
			break;
		}
		bytesReadNow = recv(fSocketNum,(unsigned char*)(responseBuffer+bytesRead),1, 0);
		if (bytesReadNow != 1) 
		{
			fprintf(stderr,"RTSP response was truncated\n");
			break;
		}
		bytesRead++;
		
		// Check whether we have "\r\n\r\n":
	
		lastToCheck = responseBuffer+bytesRead-4;
		if (lastToCheck < responseBuffer) continue;
		p = lastToCheck;
		if (*p == '\r' && *(p+1) == '\n' &&
						*(p+2) == '\r' && *(p+3) == '\n') 
		{
			*(responseBuffer+bytesRead)= '\0';
			// Before returning, trim any \r or \n from the start:
			while (*responseBuffer == '\r' || *responseBuffer == '\n') 
			{
				++responseBuffer;
				--bytesRead;
			}
			if(strncmp(responseBuffer,"RTSP",4)==0)
				return bytesRead;
		}
	}
	return bytesRead;
}*/

/////////////


int pauseMediaSession(int socketNum)
{
	char* cmd = NULL;
	char cmdFmt[] =
			"PAUSE %s/ RTSP/1.0\r\n"
			"CSeq: %d\r\n"
			"Session: %s\r\n"
			"%s\r\n";
	unsigned cmdSize;
	unsigned readBufSize = 10000;
	char* readBuffer; 
	char* readBuf;
	int bytesRead;
	char* firstLine;
	unsigned responseCode;
	readBuffer = (char*)malloc(sizeof(char)*(readBufSize+1));
	if(readBuffer == NULL) return -1;
	memset(readBuffer,0,readBufSize+1);

	do 
	{
		// First, make sure that we have a RTSP session in progress
		if (fLastSessionId == NULL) 
		{
			fprintf(stderr,"No RTSP session is currently in progress\n");
			break;
		}
		
		// Send the PAUSE command:
		
		// First, construct an authenticator string:
		
		
		
		cmdSize = strlen(cmdFmt)
			+ strlen(fBaseURL)//+strlen(subsession->fControlPath)
			+ 20 /* max int len */
			+ strlen(fLastSessionId)
			+ strlen(UserAgentHeaderStr);
		cmd = (char*)malloc(sizeof(char)*cmdSize);
		if(cmd == NULL) 
		{
			free(readBuffer);
			return -1;
		}
		memset(cmd,0,cmdSize);
		sprintf(cmd, cmdFmt,
			fBaseURL,
			//subsession->fControlPath,
			++fCSeq,
			fLastSessionId,
			UserAgentHeaderStr);
		fprintf(stderr,"PAUSE command-%d:\n%s\n",fCSeq,cmd);
		
		if (send(socketNum,cmd,strlen(cmd),0)<0) 
		{
			fprintf(stderr,"PAUSE send() failed!\n ");
			break;
		}
		
		// Get the response from the server:
		readBuf = readBuffer;
		bytesRead = getResponse(socketNum,readBuf, readBufSize);

		if (bytesRead <= 0) break;
		
		fprintf(stderr,"bytesRead is %d\n",bytesRead);
		fprintf(stderr,"PAUSE response-%d:\n%s\n",fCSeq,readBuf);
		
		 // Inspect the first line to check whether it's a result code 200
		firstLine = readBuf;
		/*char* nextLineStart =*/ getLine(firstLine);
		
		if (parseResponseCode(firstLine,&responseCode)) break;
		
		if (responseCode != 200) 
		{
			fprintf(stderr,"cannot handle PAUSE response\n ");
			break;
		}
		// (Later, check "CSeq" too #####)
		
		free(cmd);
		free(readBuffer);
		fprintf(stderr,"Pause Streams successful\n");
		return 0;
	} while (0);
	
	free(cmd);
	free(readBuffer);
	fprintf(stderr,"Pause Streams failed\n");
	return -1;
}


///////////////////////////
int teardownMediaSession(int socketNum) 
{
	char* cmd = NULL;
	char* const cmdFmt = "TEARDOWN %s RTSP/1.0\r\n"
				"CSeq: %d\r\n"
				"Session: %s\r\n"
				"%s\r\n";
	unsigned cmdSize;
	unsigned readBufSize = 10000;
	char* readBuffer; 
	char* readBuf;
	char* firstLine;
	unsigned responseCode;
	int bytesRead;
	readBuffer = (char *)malloc((readBufSize+1)*sizeof(char));
	if(readBuffer == NULL) return -1;
	memset(readBuffer,0,readBufSize+1);
	readBuf = readBuffer;
	do 
	{
		if (fLastSessionId == NULL) 
		{
			fprintf(stderr,"No RTSP session is currently in progress\n");
			break;
		}
		
		// Send the TEARDOWN command:

		// First, construct an authenticator string:
		
		cmdSize = strlen(cmdFmt)
			+ strlen(fBaseURL)
			+ 20 /* max int len */
			+ strlen(fLastSessionId)
			+ strlen(UserAgentHeaderStr);
		cmd = (char*)malloc(cmdSize*sizeof(char));
		if(cmd == NULL) return -1;
		memset(cmd,0,cmdSize);
		sprintf(cmd, cmdFmt,
			fBaseURL,
			++fCSeq,
			fLastSessionId,
			UserAgentHeaderStr);
		fprintf(stderr,"TEARDOWN command-%d:\n%s\n",fCSeq,cmd);
		
		if (send(socketNum,cmd,strlen(cmd),0)<0) 
		{
			fprintf(stderr,"TEARDOWN send() failed\n ");
			break;
		}

		// Get the response from the server:
		
		bytesRead = getResponse(socketNum,readBuf, readBufSize);
		if (bytesRead <= 0) break;
		fprintf(stderr,"TEARDOWN response-%d:\n%s\n",fCSeq,readBuf);
		// Inspect the first line to check whether it's a result code 200
		firstLine = readBuf;
		/*char* nextLineStart =*/ getLine(firstLine);
		if (parseResponseCode(firstLine,&responseCode)) break;
		if (responseCode != 200) 
		{
			fprintf(stderr,"cannot handle TEARDOWN response\n ");
			break;
		}
		
		free(readBuffer);
		free(cmd);
		return 0;
	} while (0);

	free(readBuffer);
	free(cmd);
	return -1;
}


char* strDup(char* str) 
{
	char* copy;
	unsigned int len;
	if (str == NULL) return NULL;
	len = strlen(str) + 1;
	copy = (char*)malloc(len*sizeof(char));

	if (copy != NULL) {
		memcpy(copy, str, len);
	}
	return copy;
}

char* strDupSize(char* str) 
{
	char* copy;
	unsigned int len;
	if (str == NULL) return NULL;
	len = strlen(str) + 1;
	copy = (char *)malloc(len*sizeof(char));

	return copy;
}

int hex_a(unsigned char *hex, char *a,unsigned char length)
{
	unsigned char hLowbit,hHighbit;
	int i;

	for(i=0;i<length*2;i+=2)
	{
		hLowbit=hex[i/2]&0x0f;
		hHighbit=hex[i/2]/16;
		if (hHighbit>=10) a[i]=hHighbit+'7';
		else a[i]=hHighbit+'0';
		if (hLowbit>=10) a[i+1]=hLowbit+'7';
		else a[i+1]=hLowbit+'0';
	}
	a[length*2]='\0';
	return 0;
}


int a_hex( char *a,unsigned char *hex,unsigned char len)
{
	 short i;
	 unsigned char aLowbit,aHighbit;
	 unsigned char hconval,lconval;

	 for(i=0;i<len;i+=2)
	 {
		aHighbit=toupper(a[i]);
		if ((aHighbit>='A')&&(aHighbit<='F')) 
			hconval='7';
		else
			 if ((aHighbit>='0')&&(aHighbit<='9')) 
			 	hconval='0';
			 else	
			 	return -1;
		aLowbit=toupper(a[i+1]);
		if ((aLowbit>='A')&&(aLowbit<='F')) 
			lconval='7';
		else
			 if ((aLowbit>='0')&&(aLowbit<='9')) 
			 	lconval='0';
			 else 
			 	return -1;
		hex[(i/2)]=((aHighbit-hconval)*16+(aLowbit-lconval));
	 }
	 hex[len/2]=0x00;
	 return 0;
}