[Q] 네트워크 프로그래밍할 때 데이터가 뭉쳐서(?) 들어와요...

처음 질문한 사람인데요..

데이터를 보낼때 구조체로 먼저 만들어서 보냈습니다.

서버측 소스는 다음과 같습니다.

/*
	get transmission time from a client 
*/


#include <stdio.h>     // fprintf 
#include <stdlib.h>    // exit 
#include <sys/types.h> // open
#include <fcntl.h>     // open
#include <unistd.h>    // close


#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

#include <pthread.h>

#include <sys/time.h>	//time measure

#define SERVER_PORT	2004
#define END_INDEX	1000

pthread_t thread_getFromTCP;

long sec;
double etime, etimeArray[END_INDEX];

struct timeval start_time, current_time;

int recvn(int s, void * buf, size_t len,unsigned int flags);
int sendn(int s, void* buf, int len, unsigned int flags);

int getFromTCP(void);
int ReadFile(void);

	FILE * fd_txt = NULL;
	
	typedef struct data_struct
	{
	  int nIndex;
	  int nValue;
	  //char buffer[100];
	  double fValue;
	}PACKET;
	
	PACKET p, pArray[END_INDEX];
	


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

	
	int nRet,n;
	

	
	fd_txt = fopen("ResultFile.txt","w");
	if(fd_txt == NULL)
		printf("file open failed..\n");
	
	

	nRet = pthread_create(&thread_getFromTCP, NULL, &getFromTCP, NULL);
	if(nRet != 0)
	{
		perror("thread creation error");
		return -1;
	}
	
	nRet = pthread_join(thread_getFromTCP, NULL);
	if(nRet != 0)
	{
		perror("thread join error");
		return -1;
	}
	
	
	
	//ReadFile();
	
	printf("program terminated..\n");

	close(fd_txt);
	return 0;
}
  

int getFromTCP(void)
{

	int nRet;
	int bufSize = 64*1024;	//64KB buffer for TCP/IP
	
	int s, error;
	struct sockaddr_in cliAddr, serverAddr;
	int cliLen, newSd;
	
	int n;
	


	
	s = socket(AF_INET, SOCK_STREAM, 0);
	if(s<0)
	{
	  printf("cannot open socket\n");
	}
	setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&bufSize, sizeof(bufSize));

	
	// bind any port number 
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	serverAddr.sin_port = htons(SERVER_PORT);
	error = bind(s, (struct sockaddr *) &serverAddr, sizeof(serverAddr));
	if(error<0)
	{
		printf("ERROR: cannot bind port TCP %u\n",SERVER_PORT);
		return -1;
	}
	listen(s,5);
	cliLen = sizeof(cliAddr);
	  
	// connect to server 
	printf("before connect\n");
	  
	newSd = accept(s, (struct sockaddr *) &cliAddr, &cliLen);
	if(newSd<0)
		printf("cannot accept\n ");
	printf("after accept\n");
	  
	int index = 0;
	//int nRet ;
	
	gettimeofday(&start_time,NULL);	
	
  while(index<END_INDEX)
  {
  	//memset((void*)&p,'\0',sizeof(p));
	  nRet = recvn(newSd, (void*)&p, sizeof(p), 0);
	  if(nRet < 0)
	  	printf("recvn error");
	  if(nRet == 0)
		  break;
	
		
		
	gettimeofday(&current_time,NULL);
	sec = current_time.tv_sec - start_time.tv_sec;
	etime = (current_time.tv_sec - start_time.tv_sec)+(current_time.tv_usec - start_time.tv_usec)/1000000.0;
	
	//if(index%1==0)
	//	printf("%d: p.nIndex:%d, elasped time: %lf\n",index, p.nIndex, etime);
	
	
	pArray[index].nIndex = p.nIndex;
	pArray[index].fValue = p.fValue;
	etimeArray[index] = etime;
		
	index++;
    }
    
    for(index = 0;index<END_INDEX;index++)
    {
    	fprintf(fd_txt,"%d	%f	%f\n",
		pArray[index].nIndex, etimeArray[index], pArray[index].fValue);
    }
    

    close(newSd);
    close(s);	
    
    pthread_exit(NULL);
}



int recvn(int s, void * buf, size_t len, unsigned int flags)
{
	int nleft;
	int nReceived;
	void* ptr;

	ptr = buf;
	nleft = (int)len;
	int index = 1;
	while(nleft>0)
	{
		nReceived = recv(s, ptr, nleft, flags);
		if(nReceived < 0) printf("socket recv error\n");
		else if(nReceived == 0) break;	//grateful close
		nleft-= nReceived;
		ptr+=nReceived;
//		printf("  recv called :%d received size:%d, desired size:%d\n",
//				index, nReceived, len);
		index++;
	}
	return (len-nleft);
}

int sendn(int s, void* buf, int len, unsigned int flags)
{
	int nleft;
	int nsent;
	void* ptr;

	ptr = buf;
	nleft = len;
	while(nleft>0)
	{
		nsent = send(s, ptr, nleft, flags);
		if(nsent < 0) printf("socket send error\n");
		nleft-=nsent;
		ptr+=nsent;
	}
	return len;
}


int ReadFile(void)
{
	int fd_TD;
	FILE* fdi;
	off_t curpos;
	//char buf[BUFSIZ];
	char buf[1000000];
	double dblResult[BUFSIZ];
	int nResult[BUFSIZ];
	int n;
	
	typedef struct data_struct
	{
	  int nIndex;
	  int nTD;	//time delay [ms]
	}TD;
	
	TD td, tdArray[BUFSIZ];	
	
	if((fd_TD = open("/dev/rtf4",O_RDWR))<0)
	{
		fprintf(stderr, "Error opening /dev/rtf4\n");
		printf("Check if module loaded...\n");
		exit(-1);
	}
	
	

	fdi = fopen("testFile.txt","r");
	//fdi = fopen("RTT_tokyoU2_unix.txt","r");
	//fdi = fopen("RTT_MIT_20041028.txt","r");

	printf("read start.. \n");
	
	int i =0;
	while(fscanf(fdi, "%c", &buf[i] ) != EOF)
		//if( buf[i++] == '#' ) break;
		if( buf[i++] == EOF ) break;
	buf[i] = '\0';


	//parsing from the data from the file

	printf("<parsing start>\n");
	char* p;

	i=0;
	p = strtok(buf,"\n ");

	nResult[i] = atoi(p);
	

	while(p){
		i++;
		p = strtok('\0',"\n ");
		if(p)
		{
			nResult[i] = atoi(p);	
		}
	}
	
	printf("\n<conversion to struct>\n");
	int ii,iii;
	iii =0;
	
	for(ii = 0;ii<i;ii++)
	{
		if(ii%2 == 1)
		{
			tdArray[iii].nIndex = nResult[ii-1];
			tdArray[iii].nTD = nResult[ii];		
		iii++;
		}
	}
	
	for(ii=0;ii<iii;ii++)
	{
		printf("tdArray[%d].nIndex:%d, tdArray[%d].nTD:%d\n",ii,tdArray[ii].nIndex, ii, tdArray[ii].nTD);			
		//write command to rt_FIFO
		n = write (fd_TD, &tdArray[ii], sizeof(tdArray[ii]));
		if(n != sizeof(td))
		{
			printf("write to fifo failed\n");
			return -1 ;
		}
		if(n<0)
			printf("cannot send data to kernel..\n");
	}
	
	
    	close(fd_TD);		//RT_FIFO close
	close(fdi);		//text file close
	
	return 0;
}

10msec간격으로 클라이언트에서 송신했습니다.
text파일에 저장한 결과를 아래에 넣었으며(너무 길어서 처음 일부만.. ^^)
각 column은 다음과 같습니다.
1. 클라이언트에서 보낸 인덱스
2. 서버에서 각 신호를 read했을 때 시간
3. 사인파 신호

보시면 아시다시피 인덱스 1~19까지 거의 동시에 들어오고 잠시 쉬었다가 20부터 36까지 거의 동시에 들어오고 있습니다.

0	1.656891	0.000000
1	1.829503	0.031395
2	1.829517	0.062759
3	1.829519	0.094061
4	1.829521	0.125270
5	1.829522	0.156356
6	1.829524	0.187287
7	1.829526	0.218034
8	1.829528	0.248566
9	1.829529	0.278853
10	1.829531	0.308866
11	1.829533	0.338573
12	1.829534	0.367947
13	1.829536	0.396958
14	1.829538	0.425578
15	1.829539	0.453778
16	1.829541	0.481530
17	1.829543	0.508808
18	1.829545	0.535585
19	1.829547	0.561833
20	2.003231	0.587528
21	2.003245	0.612643
22	2.003247	0.637154
23	2.003248	0.661037
24	2.003250	0.684268
25	2.003252	0.706825
26	2.003254	0.728685
27	2.003255	0.749827
28	2.003257	0.770229
29	2.003259	0.789872
30	2.003260	0.808736