TsServerUDP

/*
 ============================================================================
 Name        : serverUDP.c
 Author      : hawaii
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <iostream>
#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>

#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#include <pthread.h>

typedef unsigned char  uchar;        //one    byte
typedef unsigned short ushort;       //two    byte
typedef unsigned int   uint;         //four   byte
typedef unsigned long  ulong;        //eight  byte

const uint   SIZEUDPBUFF  = 3850240;//16168; // 10240 * 376// //376 * 43 // //4037; // 87 * 376
const uint   SIZEBUFF     = 3851368;//17296;                //5165; // SIZEUDPBUFF + 3 * 376
const uint   WRITEBUF     = 1;
const uint   READBUF      = 0;

typedef struct _buf_cap
{
    uint  readWri;
    uint  dataNum;
    uint  maxNum;
    uchar dataBuf[SIZEBUFF];
}BufCap;

BufCap*   gBufBoyv1  = NULL;
BufCap*   gBufGirlv1 = NULL;

uchar* pBuffer       = NULL;
//uchar* pGirlBuffer = NULL;

FILE* rxNet = NULL;
int sock;

pthread_t writeFileThread;

void* write_file_thread(void* threadPara);

int main(int argc, char **argv)
{
    struct sockaddr_in s_addr;
    struct sockaddr_in c_addr;

    /*creating sock*/
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    {
	printf("bind address to socket failed.\n");
	exit(-1);
    }
    else
    {
	printf("create socket.\n");
    }

    /*setting sever address*/
    memset(&s_addr, 0, sizeof(struct sockaddr_in));

    s_addr.sin_family = AF_INET;

    if (argv[1])
    {
        s_addr.sin_addr.s_addr = inet_addr(argv[1]);
    }
    else
    {
    	s_addr.sin_addr.s_addr = INADDR_ANY;
    }

    if (argv[2])
    {
	s_addr.sin_port = htons(atoi(argv[2]));
    }
    else
    {
	s_addr.sin_port = htons(2323);
    }

    /*binding server address*/
    if ((bind(sock, (struct sockaddr *)&s_addr, sizeof(s_addr)))<0)
    {
	printf("binding failed.\n");
	exit(-1);
    }
    else
    {
	printf("bind address to socket.\n");
    }

    /*setting RCVBUF*/
    uint len = 0;
    socklen_t sizelen = sizeof(len);

    if(getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &len, &sizelen)<0)
    {
	printf("getsockopt err.\n");
	exit(-1);
    }
    else
    {
	printf("%d.\n", len);
    }

    len = 1024 * 1024 * 10;

    if(setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &len, sizelen)<0)
    {
	printf("setsockopt err.\n");
	exit(-1);
    }
    else
    {
	if(getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &len, &sizelen)<0)
	{
	    printf("getsockopt2 err.\n");
            exit(-1);
	}
	else
	{
	    printf("%d\n", len);
	}
    }

    /*getting udp and writing file*/
    rxNet = fopen("/work/violin/linuxserver/test_file/test.ts", "wb");

    /*creating buff*/
    gBufBoyv1  = (BufCap*)malloc(sizeof(BufCap));
    if(NULL==gBufBoyv1)
    {
	printf("gBufBoyv1 malloc failed.\n");
	exit(-1);
    }
    gBufBoyv1->readWri  = WRITEBUF;
    gBufBoyv1->dataNum  = 0;
    gBufBoyv1->maxNum   = SIZEUDPBUFF;

    gBufGirlv1 = (BufCap*)malloc(sizeof(BufCap));
    if(NULL==gBufGirlv1)
    {
	printf("gBufGirlv1 malloc failed.\n");
	exit(-1);
    }
    gBufGirlv1->readWri = WRITEBUF;
    gBufGirlv1->dataNum = 0;
    gBufGirlv1->maxNum  = SIZEUDPBUFF;

    /*create writeFileThread*/
    int resFunc = 0;
    resFunc = pthread_create(&writeFileThread, NULL, write_file_thread, NULL);
    if(resFunc!=0)
    {
        printf("writeFileThread creation failed.\n");
	exit(-1);
    }
    else
    {
        printf("writeFileThread creation success.\n");
    }

    /*setting client address*/
    socklen_t addr_len = sizeof(c_addr);

    /*capturing UDP*/
    for(uint i=0;i<1000;i++)
    {
        pBuffer  = gBufBoyv1->dataBuf;

	while(1)
	{
	    if(WRITEBUF==gBufBoyv1->readWri)
	    {
		len = recvfrom(sock, pBuffer, 376, 0, (struct sockaddr *)&c_addr, &addr_len);
		if (len < 0)
		{
		    printf("recieving failed.\n");
		    exit(-1);
		}

		gBufBoyv1->dataNum = gBufBoyv1->dataNum + len;
		pBuffer = gBufBoyv1->dataBuf + gBufBoyv1->dataNum;

    		if((gBufBoyv1->dataNum)>=(gBufBoyv1->maxNum))
    		{
                    gBufBoyv1->readWri = READBUF;
                    break;
    		}
	    }
	    else
	    {
		usleep(1);
		printf("usleep boy.\n");
            }
	}

	pBuffer = gBufGirlv1->dataBuf;

	while(1)
	{
	    if(WRITEBUF==gBufGirlv1->readWri)
	    {
		len = recvfrom(sock, pBuffer, 376, 0, (struct sockaddr *)&c_addr, &addr_len);
		if (len < 0)
		{
		    printf("recieving failed.\n");
		    exit(-1);
		}

		gBufGirlv1->dataNum = gBufGirlv1->dataNum + len;
		pBuffer = gBufGirlv1->dataBuf + gBufGirlv1->dataNum;

    		if((gBufGirlv1->dataNum)>=(gBufGirlv1->maxNum))
    		{
    		    gBufGirlv1->readWri = READBUF;
    		    break;
    		}
	    }
	    else
	    {
		usleep(1);
		printf("usleep girl.\n");
            }
	}
    }

    exit(0);
}

void* write_file_thread(void* threadPara)
{
    while(1)
    {
	while(1)
        {
	    if(READBUF==gBufBoyv1->readWri)
	    {
		fwrite(gBufBoyv1->dataBuf, 1, gBufBoyv1->dataNum, rxNet);

		gBufBoyv1->dataNum = 0;
                gBufBoyv1->readWri = WRITEBUF;

		break;
	    }
	    else
	    {
                usleep(1);
	    }
        }

	while(1)
	{
	    if(READBUF==gBufGirlv1->readWri)
	    {
		fwrite(gBufGirlv1->dataBuf, 1, gBufGirlv1->dataNum, rxNet);

		gBufGirlv1->dataNum = 0;
                gBufGirlv1->readWri = WRITEBUF;

		break;
	    }
	    else
	    {
	        usleep(1);
	    }
	}
    }

    return (void*)NULL;
}
/*END:void* write_file_thread(void* threadPara)*/