udp socket send /receive sample

#include      /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */
#include <stdlib.h>     /* for atoi() and exit() */
#include <string.h>     /* for memset() */
#include <unistd.h>     /* for close() */
#include <signal.h>
#include <pthread.h>


#include "clientudprx.h"




#define RCVBUFSIZE 30   /* Size of receive buffer */
#define SNDBUFSIZE 30   /* Size of send buffer */


int gRcvSocket;
int gSndSocket;
struct sockaddr_in rcvAddr;
struct sockaddr_in gSndAddr;


pthread_t Rthread_id;  
pthread_t Sthread_id;

unsigned char gDeinit=0;


T_ChannelData g_stChanData;
T_GetPairID  g_stGetPairID;


unsigned char Pair_ID_List[10][10]={0};
unsigned char Pair_ID_File[256]={0};


//0: befor pairing/idle; 1: pairing; 2: paired
unsigned char pair_state = 0;




unsigned char crc_array[256] = {
                    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 
                    0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41, 
                    0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 
                    0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc, 
                    0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 
                    0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62, 
                    0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 
                    0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff, 
                    0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 
                    0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07, 
                    0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 
                    0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a, 
                    0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 
                    0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24, 
                    0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 
                    0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9, 
                    0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 
                    0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd, 
                    0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 
                    0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50, 
                    0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 
                    0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee, 
                    0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 
                    0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73, 
                    0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 
                    0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b, 
                    0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 
                    0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16, 
                    0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 
                    0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8, 
                    0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 
                    0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35, 
        };
unsigned char CRC8_creat(unsigned char *p, char counter)
{
unsigned char crc8 = 0;
for( ; counter > 0; counter--)
{
crc8 = crc_array[crc8^*p]; 
p++;
}
return crc8;
}








static rec_cnt = 0;
static pre_packetnum = 0;
unsigned char packet_error_rate(unsigned char* packet)
{
struct Si4463_packet *psi=NULL;
unsigned char packetcrc = 0;
static unsigned char err_rate=100;
int i=0;

//printf("--- Receive:");
//for(i=0;i<30;i++)
//{
// printf("%02x ",packet[i]);
//}
//printf("\n");

psi = malloc(sizeof(Si4463_packet));
psi->packetnum = packet[POS_NUM];


rec_cnt++;
//printf("rec_cnt=%d, pre=%02x, cur=%02x ",rec_cnt,pre_packetnum,psi->packetnum);
if((psi->packetnum == 99)||(pre_packetnum > psi->packetnum))
{
err_rate = 100-rec_cnt;//((100-rec_cnt)*100)/100
rec_cnt = 0;
}


pre_packetnum = psi->packetnum;


printf("err_rate=%d \n",err_rate);





return err_rate;
}


static int rcv_socket_init(void)
{
int sock;
struct sockaddr_in rcvAddr;
sock = socket(AF_INET,SOCK_DGRAM,0); 


memset(&rcvAddr, 0, sizeof(rcvAddr));
rcvAddr.sin_family = AF_INET;
rcvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
rcvAddr.sin_port = htons(5561+1); 
if (bind(sock, (struct sockaddr *) &rcvAddr, sizeof(struct sockaddr)) < 0)
{
printf("error bind failed");
close(sock);
sock = -1;
} 


return sock;
}


static int snd_socket_init(void)
{
int sock;
sock = socket(AF_INET,SOCK_DGRAM,0); 


memset(&gSndAddr, 0, sizeof(gSndAddr));
  gSndAddr.sin_family = AF_INET;
  gSndAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
  gSndAddr.sin_port = htons(5561);   
 
return sock;
}


//ret: 1-found, 0-have not found
unsigned char find_pairid_in_list(unsigned char *pairid)
{
unsigned char i=0;
unsigned char ret=0;
for(i=0;i<10;i++)
{
if(strncmp(Pair_ID_List[i],pairid,10) == 0)
{
ret = 1;
break;
}
}

return ret;
}






void writ_pairid_to_file(unsigned char *pairid)
{
FILE *file =NULL;
int real_write=0;


file = fopen(Pair_ID_File,"w");

real_write = fwrite(pairid, 1, NUM_PAIRID_BYTES, file);
if(real_write != NUM_PAIRID_BYTES)
{
printf("write pair_id to file err!\n");
}

fclose(file);
}


void Rx_DataLink_To_Idle(void)
{
printf("Rx_DataLink_To_Idle ...\n");
system("./lgdst 0 rx pair-id 00 00 00 00 00 00 00 00 00 00");
}
void Rx_DataLink_To_Pairing(void)
{
printf("Rx_DataLink_To_Pairing ...\n");
system("./lgdst 0 rx pair-id 00 00 00 00 00 00 00 00 00 01");
}
void Rx_DataLink_To_Pair_With_PairID(unsigned char PairID[10])
{
char lgdst_cmd[256]={0};
int i=0;
printf("Rx_DataLink_To_Pair_With_PairID ...\n");

printf("PairID: \n");
for (i=0;i<10;i++)
{
printf("%02x ",PairID[i]);
}
printf("\n");

//send pairing id to rx
memset(lgdst_cmd, 0, sizeof(lgdst_cmd));
//sprintf(lgdst_cmd, "./lgdst 0 rx pair-id %s",PairID);
sprintf(lgdst_cmd, "./lgdst 0 rx pair-id %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",PairID[0], PairID[1], PairID[2], PairID[3], PairID[4],
PairID[5], PairID[6], PairID[7], PairID[8], PairID[9]);
system(lgdst_cmd);
}


void del_paird_file(void)
{
char buf[256];
memset(buf, 0 ,256);
sprintf(buf, "rm -f %s",Pair_ID_File);
system(buf);
}


/************************************
*
*Interface for Uplayer
*
*************************************/
void write_channel_data(unsigned char *buf)   
{
pthread_mutex_lock(&g_stChanData.mutex);
g_stChanData.isOk = 1;
memset(g_stChanData.channel,0,NUM_CHANNEL_BYTES);
memcpy(g_stChanData.channel, buf, NUM_CHANNEL_BYTES);
pthread_mutex_unlock(&g_stChanData.mutex);
printf("Channel Data:%s \n",g_stChanData.channel);
}
//ret 0: ok -1: timeout
int bind_pair_id(unsigned char* pairid)
{
int do_try = 10;
int ret;
pthread_mutex_lock(&g_stGetPairID.mutex);
g_stGetPairID.isGetPairID = 1;
memcpy(g_stGetPairID.pair_id, pairid, NUM_PAIRID_BYTES);
pthread_mutex_unlock(&g_stGetPairID.mutex);
printf("Pair ID:%s \n",g_stGetPairID.pair_id);


do_try = 10;
do
{
usleep(100000); //100ms
if(pair_state == 2)
break;
}while(--do_try);

if(do_try == 0)
return -1;  //timeout
else   
return 0;  //bind ok
}


pthread_mutex_t g_GetIDList_mutex;


void get_pair_id_list(unsigned char (*pPaid_ID)[10][10])
{
pthread_mutex_lock(&g_GetIDList_mutex);
#if 0
if((pair_state == 0)||(pair_state == 2))
{
del_paird_file();
Rx_DataLink_To_Idle();
Rx_DataLink_To_Pairing();
pair_state =1;//pairing
}
#endif
memcpy(*pPaid_ID,Pair_ID_List,sizeof(Pair_ID_List));
pthread_mutex_unlock(&g_GetIDList_mutex);
}




void write_pairid_file_name(unsigned char *filename)
{
memset(Pair_ID_File,'\0',sizeof(Pair_ID_File));
strcpy(Pair_ID_File,filename);
printf("PairIDFileName:%s\n",Pair_ID_File);
}
/************************************
*end
*************************************/






void send_packet(unsigned char tx_buf[SNDBUFSIZE])//SNDBUFSIZE=30
{


int i=0;
printf("tx_buf:");
for(i=0;i<SNDBUFSIZE;i++)
{
printf("%02x ",tx_buf[i]);
}
printf("\n");
sendto(gSndSocket, tx_buf, SNDBUFSIZE, 0, (struct sockaddr*)&gSndAddr, sizeof(struct sockaddr_in));
sleep(1);
}


void receive_packet(unsigned char rx_buf[RCVBUFSIZE])
{
int rec_size=0;
int recvaddr_len=0;
int i=0;

recvaddr_len=sizeof(struct sockaddr_in);

rec_size=recvfrom(gRcvSocket, (void *)rx_buf, RCVBUFSIZE, 0, (struct sockaddr *)&rcvAddr, &recvaddr_len);
if(rec_size!=RCVBUFSIZE)
{
printf("Receive Error !\n");
}

printf("rx_buf:");
for(i=0;i<30;i++)
{
printf("%02x ",rx_buf[i]);
}
printf("\n");
}


void *proc_send_thread(void *arg)  
{
int i;
int sndcnt=0;
int PNum=0;
unsigned char packetcrc = 0;
unsigned char tx_buf[SNDBUFSIZE]={0};
arg = arg;
unsigned char dFlag=0;
for(;;)
{
memset(tx_buf, 0, sizeof(tx_buf));

if( (g_stGetPairID.isGetPairID == 1) && (strncmp("DRONE",g_stGetPairID.pair_id,5) ==0))//receive:DRONE12345,SEND:BIND-DRONE12345
{
printf("Send BIND-##### ... \n");
dFlag=1;
sprintf(&tx_buf[POS_DATA],"BIND-%s",g_stGetPairID.pair_id);


//packetcrc=CRC8_creat(tx_buf,29);
//tx_buf[POS_CRC]=packetcrc;

g_stGetPairID.isGetPairID=0;
//memset(g_stGetPairID.pair_id,0,NUM_PAIRID_BYTES);

}
else
{
if(g_stChanData.isOk == 1)
{
//printf("Send Channel Data ...\n");
dFlag=1;
memcpy(&tx_buf[POS_DATA], g_stChanData.channel, NUM_CHANNEL_BYTES);

//packetcrc=CRC8_creat(tx_buf,29);
//tx_buf[POS_CRC]=packetcrc;

//g_stChanData.isOk = 0;
//memset(g_stChanData.channel,0,NUM_CHANNEL_BYTES);

}
else
{
dFlag=0;
}
}

if(dFlag==1)
{
tx_buf[POS_NUM]=PNum;
PNum++;
if(PNum>99)
{
PNum=0;
}
packetcrc=CRC8_creat(tx_buf,29);
tx_buf[29]=packetcrc;
send_packet(tx_buf);
}


usleep(500000);

if(gDeinit==1)
{
pthread_exit((void *)"Exit OK!");
}

}
}


void *proc_recv_thread(void *arg)  
{
int i=0;
int rec_size=0;
int recvaddr_len=0;
static unsigned char pair_id_index=0;
unsigned char rx_buf[RCVBUFSIZE]={0};
unsigned char err_rate=0;
unsigned char err_packet[4]={0xFF,0x55,0xAA,0xFF};
unsigned char pre_rx_buf[30]={0};

recvaddr_len=sizeof(struct sockaddr_in);

arg = arg;
for(;;)
{
receive_packet(rx_buf);

if(rx_buf[29] == CRC8_creat(rx_buf, 29))
{
//recive pair id
if(strncmp("DRONE",&rx_buf[POS_DATA],5)==0)
{
printf("Receive DRONExxxxx ...\n");
unsigned char status=0;

status=find_pairid_in_list(&rx_buf[POS_DATA]);
if(!status)
{
memcpy(Pair_ID_List[pair_id_index],&rx_buf[POS_DATA],NUM_PAIRID_BYTES);
pair_id_index++;
if(pair_id_index>=10)
{
pair_id_index=0;
}
}
           
}
else if(strncmp("BINDOK-",&rx_buf[POS_DATA],7)==0)  //0xfe + seq + BINDOK-DRONE12345
{
char Binded_pairid[NUM_PAIRID_BYTES]={0};
memcpy(Binded_pairid,&rx_buf[POS_DATA+7],NUM_PAIRID_BYTES);

printf("Receive BINDOK-%s\n",Binded_pairid);
if( (strncmp(Binded_pairid, g_stGetPairID.pair_id, NUM_PAIRID_BYTES) == 0) && (pair_state != 2) )  //(pair_state != 2)   avoid same cmd input
{
printf("equal to our bind cmd ...\n");


Rx_DataLink_To_Pair_With_PairID(Binded_pairid);
usleep(500000);
printf("write Pair ID to file ...\n");
writ_pairid_to_file(Binded_pairid);


pair_state = 2;//paired
}
}
else if(strncmp("errRate-",&rx_buf[POS_DATA],8)==0)
{
printf("err Rate %s\n",&rx_buf[POS_DATA]);
}
else
{
//printf("others: %s \n",rx_buf);//eg: Camera Command ACK
#if 0
printf("others:");
for(i=0;i<30;i++)
{
printf("%02x ",rx_buf[i]);
}
printf("\n");
#endif
}
}
else
printf("crc err!----\n");


if(gDeinit==1)
{
pthread_exit((void *)"Exit OK!");
}
}  
}




static int enter_paired_mode_at_powerup(void)
{
char PairID[NUM_PAIRID_BYTES]={0};
char buf[256];


FILE *file = fopen(Pair_ID_File,"r");
int real_read = fread(PairID, 1, NUM_PAIRID_BYTES, file);
if(real_read != NUM_PAIRID_BYTES)
{
printf("read pair_id from file err!\n");
return -1;
}
else
{
unsigned char i=0;
printf("PairID:");
for(i=0;i<real_read;i++)
{
printf("%c",PairID[i]);
}
printf(" /");

for(i=0;i<real_read;i++)
{
printf("0x%02x ",PairID[i]);
}
printf("\n");
}
fclose(file);




//Rx_DataLink_To_Idle();
//usleep(500000);
//Rx_DataLink_To_Pairing();
//usleep(500000);
//Rx_DataLink_To_Pair_With_PairID(PairID);
//usleep(500000);

return 0;
}




int init(unsigned char *filename)
{


int ret;

memset(Pair_ID_File,'\0',sizeof(Pair_ID_File));
if(filename==NULL)
{
strcpy(Pair_ID_File,PAIR_ID_FILE_DEFAULT);
}
else
{
strcpy(Pair_ID_File,filename);
}
printf("Pair_ID_File=%s\n",Pair_ID_File);

gRcvSocket = rcv_socket_init();
if(gRcvSocket < 0)
{
printf("g_rcv_socket < 0");
return -1;
}

gSndSocket = snd_socket_init();
if(gSndSocket < 0)
{
printf("g_rcv_socket < 0");
return -1;
}


UDP_INFO("gRcvSocket:%d, gSndSocket:%d create ok\n", gRcvSocket, gSndSocket);


pthread_mutex_init(&g_stChanData.mutex, NULL);
g_stChanData.isOk = 0;
pthread_mutex_init(&g_stGetPairID.mutex, NULL);
g_stGetPairID.isGetPairID = 0;
pthread_mutex_init(&g_GetIDList_mutex, NULL);


ret = pthread_create(&Sthread_id, NULL, proc_send_thread, NULL);
if(ret != 0)
{
printf("proc_send_thread create err!\n");
return -1;
}

ret = pthread_create(&Rthread_id, NULL, proc_recv_thread, NULL);
if(ret != 0)
{
printf("proc_recv_thread create err!\n");
return -1;
}



if(access(Pair_ID_File, F_OK) == 0)
{
printf("find pair_id file! enter paired mode at start up\n");
enter_paired_mode_at_powerup();
}
else
{
printf("can't find pair_id file! \n");
if((pair_state == 0)||(pair_state == 2))
{
del_paird_file();
Rx_DataLink_To_Idle();
usleep(500000);
Rx_DataLink_To_Pairing();
pair_state =1;//pairing
}
//enter_pairing_mode();
}

printf("Init successfull ...\n");
return 0;
}


int deinit(void)
{
void *tmp=NULL;

gDeinit=1;

printf("Waitting Send Thread end ...\n");
if(pthread_join(Sthread_id,&tmp)!=0)
{
printf("Join send Thread Err!\n");
}
printf("Send Thread Exit ret is %s ...\n",(char *)tmp);

printf("Waitting Receive Thread end ...\n");
if(pthread_join(Rthread_id,&tmp)!=0)
{
printf("Join Receive Thread Err!\n");
}
printf("Receive Thread Exit ret is %s ...\n",(char *)tmp);

pthread_mutex_destroy(&g_stChanData.mutex);
pthread_mutex_destroy(&g_stGetPairID.mutex);
pthread_mutex_destroy(&g_GetIDList_mutex);
close(gRcvSocket);
close(gSndSocket);
return 0;
}






#if 0
void Rx_test(void)
{
FILE *stream;  
char buf[1024]={0}; 

printf("lgdst0: \n");

memset( buf, '\0', sizeof(buf) );
stream = popen( "./lgdst 0 rx recv", "r" );
fread( buf, sizeof(char), sizeof(buf),  stream);  
pclose( stream );
sleep(1);


while(strstr(buf,"Tx")==NULL)//no Tx
{
memset( buf, '\0', sizeof(buf) );
stream = popen( "./lgdst 0 rx recv", "r" );
fread( buf, sizeof(char), sizeof(buf),  stream);  
pclose( stream );
sleep(1);
}

}


int main(int argc, char **argv)
{

init(NULL);

//Rx_test();
//Rx_Into_Pairing_Mode();
//Rx_Send_Pair_ID(unsigned char PairID[10]);
//Rx_Into_Paired_Mode();

while(1)
{
sleep(1);
}
deinit();

}
#endif