#ifndef	__TRANSPORT_C__
#define	__TRANSPORT_C__

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <err.h>
#include <ctype.h>
#include <time.h>

#include  <osip2/osip.h>
#include  <osip2/osip_fifo.h>
#include  <osip2/osip_dialog.h>
#include  <osip2/osip_condv.h>


#include  <osipparser2/osip_const.h>
#include  <osipparser2/osip_md5.h>
#include  <osipparser2/osip_list.h>
#include  <osipparser2/osip_uri.h>
#include  <osipparser2/osip_message.h>
#include  <osipparser2/osip_port.h>
#include  <osipparser2/osip_body.h>
#include  <osipparser2/osip_parser.h>


/*!Start:
  @Elementry data type definition.
  @Modified by: Mohd. Naushad Ahmed
  @Dated: 17-OCT-2012
 */

typedef     unsigned char       I_U8;
typedef     char                I_S8;
typedef     unsigned short int  I_U16;
typedef     short int           I_S16;
typedef     unsigned int        I_U32;
typedef     int                 I_S32;
typedef     unsigned char *     I_PU8;
typedef     char *              I_PS8;
typedef			void								I_Void;
typedef			void *							I_PVoid;

#define ZERO        0
#define ONE         1
#define TWO         2
#define THREE       3
#define FOUR        4
#define FIVE        5
#define SIX         6
#define	MB					4000

/*!End:
  @Elementry data type definition.
  @Modified by: Mohd. Naushad Ahmed
  @Dated: 17-OCT-2012
 */

void hexDump(unsigned char *buf,
						 int nbytes)
{
    int i, j;

    for(i = ZERO; i < nbytes; i += (ONE<<FOUR)) 
		{
			fprintf(stderr,"%04X : ", i);
			for (j = ZERO; j < (ONE << FOUR) && i + j < nbytes; j++)
	    	fprintf(stderr,"%2.2X ", buf[i + j]);
			for (; j < (ONE << FOUR); j++)
			{
	    	fprintf(stderr,"   ");
			}
			fprintf(stderr,": ");
			for (j = ZERO; j < (ONE << FOUR) && i + j < nbytes; j++) 
			{
	    	char c = toascii(buf[i + j]);
	    	fprintf(stderr,"%c", isalnum(c) ? c : '.');
			}
		fprintf(stderr,"\n");
    } /* END OF FOR LOOP*/
}/*END OF hexdDmp*/




int InitUdpCon(int sockFd,
							char *servIpAddr,
							char *servUdpPort)
{
	struct sockaddr_in serverAddr;
  size_t serverLen;
  int  retStatus;

  serverLen   								= sizeof(serverAddr);
  serverAddr.sin_family 			= AF_INET;
  serverAddr.sin_addr.s_addr 	= inet_addr(servIpAddr);
	serverAddr.sin_port					=	htons(atoi(servUdpPort));

	retStatus = connect(sockFd,
                     (struct sockaddr *)&serverAddr,
    	                serverLen);
  if(retStatus < ZERO)
  {
   		fprintf(stderr,"Socket connect Failed...[0x%X][%d]\n",
											retStatus,retStatus);
			exit(ONE); 
  }
	
	return(retStatus);
}





int RecvUdpData (int actConIdx,
								 char *msgBuff,
								 int	 *msgBuffLen,
								 void	 *from)
{
	int retStatus				= ZERO; 

	/*! struct sockaddr_in	from;*/
	/*! If this length is not correct then
			IP Address of the Peer shall not be updated by the
			API (recvfrom...	
	*/
	size_t fromLen	=	sizeof(struct sockaddr_in);	

	retStatus  = recvfrom	(actConIdx,
												 msgBuff,
												 MB,
												 ZERO,
												 (struct sockaddr *)from,
												 &fromLen);
     
  if(retStatus > ZERO)
  {
     fprintf(stderr,"Number of Bytes read=[0x%x] Str=[%s]\n",retStatus,msgBuff);
		 /*hexDump((unsigned char *)msgBuff,retStatus);*/
  }
	*msgBuffLen	=	retStatus;
  return(retStatus); 
}



int SendUdpData (int actConIdx,
								char *msgBuff,
								int	 *msgBuffLen,
								char *ipAddr,
								int  port)
{
	int retStatus;
	struct sockaddr_in	to;

	size_t toLen   			= sizeof(to);
  to.sin_family 			= AF_INET;
  to.sin_addr.s_addr 	= inet_addr(ipAddr);
	to.sin_port					=	htons(port);

	retStatus  = sendto(actConIdx,
										msgBuff,
										*msgBuffLen,
										ZERO,
										(struct sockaddr *)&to,
										toLen);
     
  if(retStatus > ZERO)
  {
     fprintf(stderr,"Number of Bytes sent=[0x%x]\n",
										 retStatus);
										 
  }
  return(retStatus); 
}


int CreateBindUdpSocket(char *ipAddr,
												char *udpPort)
{
	struct sockaddr_in selfAddr;
	int sockFd;
  size_t selfLen;
  int  retStatus;

	selfLen   								= sizeof(selfAddr);
  selfAddr.sin_family 			= AF_INET;
  selfAddr.sin_addr.s_addr 	= inet_addr(ipAddr);
	selfAddr.sin_port					=	htons(atoi(udpPort));

  memset((void *)&selfAddr.sin_zero,
				 (int)ZERO,
				 (size_t)sizeof(selfAddr.sin_zero));
  
  	 
  sockFd	= socket(AF_INET,
									SOCK_DGRAM,
									IPPROTO_UDP);	

  if (sockFd < ZERO) 
	{
			fprintf(stderr,"sockFd Creation Failed...\n");
			errx(ONE, "%s", gai_strerror(sockFd));
  }
	fprintf(stderr,"SOCK-FD=[0x%x]\n",sockFd);

	retStatus = bind(sockFd,
									(struct sockaddr *)&selfAddr,
									selfLen);
  
  if(retStatus < ZERO)
  {
      fprintf(stderr,"Socket Bind Failed...\n");   
      errx(ONE, "%s", gai_strerror(retStatus));
  }
	return(sockFd);
	
}/* CreateBindUdpSocket(char *ipAddr,char *udpPort) */

int GetNewConIdx(int  sockFd,
								 int  *clntIpAddr,
								 int	*clntPort,
								 int  *newFd)
{
	int retStatus;
	struct sockaddr_in	peerIpAddr;
	size_t	peerLen;
  /*Time related stuff*/

	peerLen	=	sizeof(struct sockaddr_in);

	memset((void *)&peerIpAddr.sin_zero,
				 (int)ZERO,
				 (size_t)sizeof(peerIpAddr.sin_zero));

	*newFd = retStatus	=	accept(sockFd,
										 (struct sockaddr *)&peerIpAddr,
											&peerLen);
	if(retStatus < ZERO)
	{
		 fprintf(stderr,"ACCEPT FAILED...[%d] SOCK-FD=[0x%X]\n",retStatus,sockFd);  
     errx(ONE, "%s", gai_strerror(retStatus));
	}
	*clntIpAddr	=		peerIpAddr.sin_addr.s_addr;
	*clntPort		=		ntohs(peerIpAddr.sin_port);
	fprintf(stderr,"CLIENT IP ADDRESS=[0x%X] AND "
									 "PORT=[0x%X] NEW FD=[0x%X]\n",
										*clntIpAddr,
										*clntPort,
										retStatus);
	return(retStatus);
}

int CreateUdpServer(int sockFd,
										void *osip )
{
	struct timeval tv;
  fd_set  readFd;
  fd_set  tmpFd;
  fd_set  writeFd;
  fd_set  exceptFd;	
	int maxFd;
	int retStatus;
	int msgLen;
	/* Message Buffer */
	char *msgPtr;
	char msgBuff[MB];
	struct sockaddr_in peer;
	void *from = (void *)&peer;

	msgPtr	=	&msgBuff[ZERO];

	FD_ZERO(&writeFd);
	FD_ZERO(&exceptFd);
	FD_ZERO(&tmpFd);

	FD_SET(sockFd,&tmpFd);
	maxFd	=	sockFd;

	for(;;)
	{
		FD_ZERO(&readFd);
		tv.tv_sec=ONE;
		/* 500 milli second */
	  tv.tv_usec=500000; 
		readFd	=	tmpFd;
	
		retStatus	=	select((maxFd + ONE),
												&readFd,
												&writeFd,
												&exceptFd,
												&tv/*NULL*/);
    if(retStatus < ZERO)
		{
			fprintf(stderr,"\nSELECT FAILED...[%d]\n",retStatus);
			continue;   
		}
		else if(ZERO == retStatus)
		{
			fprintf(stderr,"\nSELECT TIMEOUT HAS OCCURRED\n");
		}
		else
		{
			 if(FD_ISSET(sockFd,&readFd))
			 {			 
					/* Data has been received at established connection, read it now */
					memset((void *)msgPtr,ZERO,(size_t)MB);
					retStatus	=	RecvUdpData(sockFd,
																	msgPtr,
																	&msgLen,
																	from);
					if(msgLen > ZERO)
					{
						fprintf(stderr,"DATA RECEIVED AT FD=[0x%x] OF LENGTH=[0x%x]\n",
															sockFd,
															retStatus);

						retStatus	=	HandleSipReq(msgPtr,
																		 &msgLen,
																		 sockFd,
																		 from,
																		 osip);
					}
			 } /* if */ 	
		} /* else */
		/*!Start:
 		 * Executing SIP Events
 		 * @Dated: 24-OCT-2012
 		 * @Modified by: Mohd. Naushad Ahmed */

		 osip_ict_execute((osip_t *)osip);
		 osip_ist_execute((osip_t *)osip);
		 osip_nict_execute((osip_t *)osip);
		 osip_nist_execute((osip_t *)osip);
		 osip_timers_ict_execute((osip_t *)osip);
		 osip_timers_ist_execute((osip_t *)osip);
		 osip_timers_nict_execute((osip_t *)osip);
		 osip_timers_nist_execute((osip_t *)osip);

		/*!End:
 		 * Executing SIP Events
 		 * @Dated: 24-OCT-2012
 		 * @Modified by: Mohd. Naushad Ahmed */

	} /* for(;;) */
} /* CreateUdpServer(int sockFd,int backLogQ) */

#endif