带有xml转发的select非阻塞，修正了一个错误

修改部分在transfer.c第288行，修改如下
ptr = conns[m].totalBuffer;
conns[m].edSize = 0;//-----------------------



同一文件，这样修改貌似可以减少提示出现的不是utf-8字符串的问题。
79 content[target->XmlLength+1] = '/0';//about utf-8
printf("content:%s\n",content);

tcp_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <linux/in.h>
#include <errno.h>
#include <sys/select.h>
#include <string.h>
#include <memory.h>
#include <fcntl.h>

#include "transfer.h"
#include "xmlproc.h"

#define PORT 8886
#define recvcontent_size 300

int swap;
int nullElement;
char content[300];//œÓÊÕÄÚÈÝ»ºŽæ

void process_conn_server(int s);
int getNullElement();
void resetElement(int argum);


int main(int argc, char *argv[])
{
	struct targetPack *targetSS = (struct targetPack *)malloc(sizeof(struct targetPack));
	int ss,sc;
	int err;
	int addrlen;
		int maxsock;


		
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;  

	ss = socket(AF_INET,SOCK_STREAM,0);
	
	int flags = fcntl(ss, F_GETFL, 0); 
	fcntl(ss, F_SETFL, flags | O_NONBLOCK);
	
	if(ss<0)
	{
		perror("socket");
		return -1;
	}

	bzero(&server_addr, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(PORT);

	int opt = 1; 
	setsockopt(ss,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)); 


	err = bind(ss, (struct sockaddr *) &server_addr, sizeof(server_addr));
	if(err<0)
	{
		perror("bind");
		return -1;
	}

	err = listen(ss, 5);
	if(err < 0)
	{
		perror("listen");
		return -1;
	}
	

	addrlen = sizeof(struct sockaddr);

	int l;
	for(l=0;l<50;l++)
	{
		conns[l].clientfd = 0;
		conns[l].recverfd = 0;
		conns[l].edSize = 0;
		memset(conns[l].totalBuffer,0,total_buf_size);
	}

	int clientCounter;
	clientCounter = 0;
	maxsock = ss;
		
	for(;;)
	{
		int ret, err;
		fd_set clientS,clientR;
		struct timeval tv;



		FD_ZERO(&clientS);
		FD_ZERO(&clientR);
		FD_SET(ss,&clientS);
		
		tv.tv_sec = 2;
		tv.tv_usec = 0;

		int n;
		for(n=0;n<50;n++)
		{
			if(conns[n].clientfd != 0)
			{
				FD_SET(conns[n].clientfd, &clientS);
			}
			if(conns[n].recverfd!= 0)
			{
				FD_SET(conns[n].recverfd, &clientR);
			}
		}



		ret = select(maxsock+1, &clientS, &clientR, 0, &tv);
		switch(ret)
		{
			case -1:
				perror("select");
				break;
			case 0:
				perror("timeout");
				break;
			default:
				if(FD_ISSET(ss,&clientS))
				{
					nullElement = getNullElement();
					printf("Accept:%d\n",nullElement);
					conns[nullElement].clientfd = accept(ss,(struct sockaddr *)&client_addr,&addrlen);
					if(conns[nullElement].clientfd == -1)
					{
						perror("accept");
					}
					else if(conns[nullElement].clientfd == 0)
					{
						printf("accept return 0\n");	
					}
					else if(conns[nullElement].clientfd > 0)
					{
						//FD_SET(conns[nullElement].clientfd,&clientS);
						//FD_SET(conns[nullElement].clientfd,&clientR);
						printf("accept return value:%d\n",conns[nullElement].clientfd);
						printf("nullElementvalue:%d\n",nullElement);
						if(maxsock<conns[nullElement].clientfd)
							maxsock = conns[nullElement].clientfd;

						clientCounter++;
				
					}
				}	

				int m;
				for(m=0; m<50; m++)
				{
					if(conns[m].clientfd == 0) continue;	
					if(FD_ISSET(conns[m].clientfd, &clientS))
					{
						printf("client %d is changed\n", conns[m].clientfd);
						printf("Maxsock is %d\n",maxsock);
												
						memset(targetSS,'\0',sizeof(struct targetPack));
							printf("*************************seek1\n");
						memset(content,0,300);
						recvFromClient(m, targetSS, &conns[m].recverfd, content);
						printf("content server.c:%s\n",content);
							printf("*************************seek2\n");
							sleep(1);
					}	

					if(FD_ISSET(conns[m].recverfd,&clientR))
					{
						sendToClientXML2(m,targetSS, content);						
						afterSendProc(m);
					}
					
				}
			}
			
				
	}
        return 0;
}


int getNullElement()
{
	int j;
	for(j=0;j<50;j++)
	{
		if(conns[j].clientfd == 0)
			{
			swap = j;
			break;
			}
	}
	printf("swap:%d",swap);
	return swap;	
}

void resetElement(int argum)
{
	conns[argum].clientfd = 0;
	conns[argum].edSize = 0;
	memset(conns[argum].totalBuffer,0,1024);
}

tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <linux/in.h>
#include <net/if.h>

#include "transfer.h"
#include "xmlproc.h"

#define PORT 8886
#define CONTENT_SIZE 100 //max size 300

void process_conn_client(int s);

int main(int argc, char *argv[])
{
	int s;
	int err;
	struct sockaddr_in server_addr;

	if(argc!=2)
	  {
		fprintf(stderr,"Usage:./client <IP_Address>\n");
		return -1;
          }
	  
	s = socket(AF_INET,SOCK_STREAM,0);
	if(s < 0){
	    perror("socket");
	    return -1;
	}

	bzero(&server_addr, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(PORT);

        inet_pton(AF_INET, argv[0], &server_addr.sin_addr);
	
	err = connect(s, (struct sockaddr *) &server_addr, sizeof(struct sockaddr));
	if(err < 0)
	{
	  perror("connect");
	  return -1;
	}	
	
	for(;;)
	{
		process_conn_client(s);
	}
	
	close(s);
	return 0;
}


void process_conn_client(int s)
{
	int recv_id;
	printf("Type in the socket fd:\n");
	scanf("%d",&recv_id);
	char content[200];
	printf("Type in the content:\n");
	read(1,content,200);
	sendTotalBuferToServer(s, recv_id, content);
	printf("TEST");	
	struct targetPack *trgt = (struct targetPack *)malloc(sizeof(struct targetPack));
	recvFromServer(s, trgt);
	sleep(2);
}

transfer.c

#include "transfer.h"
#define swap_buf_size 500


struct pipePack *pipe_pack;
struct targetPack *target_pack;

ssize_t sendP(int fd, const void *buf, size_t num, int flag)    
{    
	ssize_t res;    
	size_t n;    
	const char *ptr;    
	    
	    
	n = num;    
	ptr = buf;    
	while (n > 0) 
	{    
		if ((res = send(fd, ptr, n, flag)) <= 0) 
		{    
	      		if (errno == EINTR)    
	       		res = 0;    
	      		else    
	       	return (-1);    
	      }    
	    
	     ptr += res;
	     n -= res;    
	}        
	return (num);    
} 


ssize_t recvP (int fd, void *buf, size_t num, int flag)    
{    
	ssize_t res;    
	size_t n;    
	char *ptr;    
	    
	    
	n = num;    
	ptr = buf;    
	while (n > 0) 
	{    
	     	if ((res = recv (fd, ptr, n, flag)) == -1) 
		{    
		      if (errno == EINTR)    
			      res = 0;    
			else    
				return (-1);    
	     	}    
	      else if (res == 0)
		  	break;    
		  
	    ptr += res;    
	    n -= res;    
	}    	    
	return (num - n);    
}    


void recvFromServer(int s, struct targetPack *target)
{
	char temBuffer[1024];
	memset(temBuffer,0,1024);
	memset(target,0,sizeof(struct targetPack));
	
	recvP(s, temBuffer, 1024, 0);
	memcpy(target,temBuffer,sizeof(struct targetPack));
	char xmlbuf[500];
	memset(xmlbuf,0,500);
	memcpy(xmlbuf,temBuffer+sizeof(struct targetPack), target->XmlLength);
	generateTimeFile("GetServerTimeResponse.xml",xmlbuf);
	rtnSerTime("GetServerTimeResponse.xml");
	char content[500];
	memset(content,0,500);
	memcpy(content, temBuffer+sizeof(struct targetPack)+target->XmlLength, 1024-sizeof(struct targetPack)-target->XmlLength);
	content[target->XmlLength+1] = '/0';//about utf-8
	printf("content:%s\n",content);
}



/*
* 2nd
* 1st edition, non block send a targetPack structure to server, 
* the 2 edition will append the xml proccess
* Append comment: the 1st edition is missing.
*/
void sendTotalBuferToServer(int n, int recvID, char *str)
{	
	struct targetPack *tgt = (struct targetPack *)malloc(sizeof(struct targetPack));
	char senbuf[total_buf_size];
	;
	int testn = recvID;
	char ss[20];
	sprintf(ss,"%d",testn);

	char content[50];
	sprintf(content,"%s",str);
	char *xml_file_name = creatClientXmlFd(ss, content);
	char *xml_str = rtnXmlBuf(xml_file_name);
	tgt->XmlLength = strlen(xml_str);
	printf("Xml file length:%d\n",tgt->XmlLength);

	//initialize the totalbuffer of pipePack structure
	memset(senbuf,0,total_buf_size);
	memcpy(senbuf,tgt,target_buf_size);
	memcpy(senbuf+border_size, xml_str, tgt->XmlLength);

	int send_size;
	send_size = 0;
	send_size = sendP(n, senbuf, total_buf_size, 0);
	printf("send size:%d\n",send_size);
}	


/*
*send a structure to clients,
*first argument is conns struct array coordinate,
*second argument is a pointer to targetPack structure.
*the template is sendToClient();  Ïò¿Í»§¶Ë·¢ËÍ°üÍ·ºÍʱŒäxmlÎÄŒþ
*/
void sendToClientXML(int m, struct targetPack *swap)
{
	char *xml_file_name = creatServerXml();
	char *xml_str = rtnXmlBuf(xml_file_name);
	swap->XmlLength = strlen(xml_str);
	
	
	memset(conns[m].totalBuffer,0,total_buf_size);
	memcpy(conns[m].totalBuffer, swap, sizeof(struct targetPack));
	memcpy(conns[m].totalBuffer+border_size, xml_str, strlen(xml_str)+1);

	int sendsize;
	int totalsize;
	char *ptr;
	sendsize = 0;
	totalsize = 1024;
	conns[m].edSize = 0;
	ptr = conns[m].totalBuffer;
	
	for(;;)
	{
		sendsize = send(conns[m].recverfd, ptr, 1024-conns[m].edSize,MSG_DONTWAIT);
		if(sendsize > 0)
		{
			ptr += sendsize;
			conns[m].edSize += sendsize;
			printf("send %d bytes\n",sendsize);
		}
		else if(sendsize == 0)
		{
			printf("following the sendsize %d bytes\n", sendsize);
		}
		
		if(conns[m].edSize >= 1024)
		{
			printf("send finish\n");
			break;
		}
	}
}


/*
*send a structure to clients,
*first argument is conns struct array coordinate,
*second argument is a pointer to targetPack structure.
*the template is sendToClient();  Ïò¿Í»§¶Ë·¢ËÍ°üÍ·ºÍʱŒäxmlÎÄŒþ
*/
void sendToClientXML2(int m, struct targetPack *swap, char *content)
{
	char *xml_file_name = creatServerXml();
	char *xml_str = rtnXmlBuf(xml_file_name);
	swap->XmlLength = strlen(xml_str);
	
	
	memset(conns[m].totalBuffer,0,total_buf_size);
	memcpy(conns[m].totalBuffer, swap, sizeof(struct targetPack));
	memcpy(conns[m].totalBuffer+border_size, xml_str, strlen(xml_str));
	memcpy(conns[m].totalBuffer+border_size+strlen(xml_str), content, recvcontent_size);

	int sendsize;
	int totalsize;
	char *ptr;
	sendsize = 0;
	totalsize = 1024;
	conns[m].edSize = 0;
	ptr = conns[m].totalBuffer;
	
	for(;;)
	{
		sendsize = send(conns[m].recverfd, ptr, 1024-conns[m].edSize,MSG_DONTWAIT);
		if(sendsize> 0)
		{
			ptr += sendsize;
			conns[m].edSize += sendsize;
			printf("send %d bytes\n",sendsize);
		}
		else if(sendsize < 0) 
		{    
	            if(errno == EAGAIN) 
	            {    
	                errno=0;
			   printf("errno == EAGAIN");
			   break;
	            }
	            else
	            {    
	                perror("recv");    
	               // exit(EXIT_FAILURE);    
	            }    
		}
		else if(sendsize = 0)
		{
			printf("client has discontent\n");
			break;
		}   

		
		if(conns[m].edSize >= 1024)
		{
			printf("send finish\n");
			break;
		}
	}
}


/*
*send a structure to clients,
*first argument is conns struct array coordinate,
*second argument is a pointer to targetPack structure.
*/
void sendToClient(int m, struct targetPack *swap)
{
	int sendsize;
	int totalsize;
	char *ptr;
	sendsize = 0;
	totalsize = 1024;
	conns[m].edSize = 0;
	ptr = conns[m].totalBuffer;

	memset(conns[m].totalBuffer,0,total_buf_size);
	memcpy(conns[m].totalBuffer, swap, sizeof(struct targetPack));
	for(;;)
	{
		sendsize = send(conns[m].clientfd, ptr, 1024-conns[m].edSize,MSG_DONTWAIT);
		if(sendsize> 0)
		{
			ptr += sendsize;
			conns[m].edSize += sendsize;
			printf("send %d bytes\n",sendsize);
		}
		else
		{
			printf("following the sendsize %d bytes\n", sendsize);
		}
		
		if(conns[m].edSize >= 1024)
		{
			printf("send finish\n");
			break;
		}
	}
	
}




/*
*µÚÒ»žö²ÎÊýÊǜṹÌåÊý×é×ø±ê£¬µÚ¶þžö²ÎÊýÊÇÄ¿±êœá¹¹Ìå
*µÚÈýžö²ÎÊýÊÇÊÇŽÓxmlÎÄŒþÖÐÌáÈ¡µÄœÓÊÕÕßsockFD,
*µÚËÄžö²ÎÊýÊÇŽÓxml ÖÐÌáÈ¡¿Í»§¶Ë·¢ËÍÄÚÈÝ¡£
*/
void recvFromClient(int m, struct targetPack *ss, int *testint, char *content)
{
	int recvsize;
	int totalsize;
	char *ptr;
	totalsize = 1024;
	ptr = conns[m].totalBuffer;
	conns[m].edSize = 0;		
	memset(ss,0,sizeof(struct targetPack));
	//memset(conns[m].totalBuffer,0,1024);

	for(;;)
	{
		recvsize = 0;
		recvsize = recv(conns[m].clientfd, ptr, totalsize-conns[m].edSize, MSG_DONTWAIT);
		if(recvsize > 0)
		{	
			ptr += recvsize;
			conns[m].edSize += recvsize;
			printf("Received %d bytes\n",recvsize);
		}
		else if(recvsize < 0) 
		{
	            if(errno == EAGAIN) 
	            {    
	                errno=0;
					printf("errno == EAGAIN");	
					break;    
	            }
	            else
	            {    
	                perror("recv");    
	                exit(EXIT_FAILURE);    
	            }    
		}
		else if(recvsize = 0)
		{
			printf("client has discontent\n");
			break;
		}   

		
		if(conns[m].edSize >= border_size)
		{
			memcpy(ss, conns[m].totalBuffer, sizeof(struct targetPack));
			printf("xml length is %d\n", ss->XmlLength);
			
			if((conns[m].edSize - border_size) > (ss->XmlLength))
			{
				char xmlstr[900];
				memset(xmlstr,'\0',900);
				memcpy(xmlstr, conns[m].totalBuffer+border_size,ss->XmlLength);
				char *file_name = "xmlFileFromClient.xml";
				generateTimeFile(file_name, xmlstr);
	
				char xmlbuf[300];
				getFDandContent(file_name, testint, xmlbuf);
				printf("content from client xml:\n%s\n", xmlbuf);
				sprintf(content, "%s", xmlbuf);
				conns[m].recverfd = *testint;
			}
			
		}
		else if(conns[m].edSize < 0)
		{
			printf("conns[m].edSize < 0: %d\n", conns[m].edSize);
			break;
		}
	}
}


void afterSendProc(int coo)
{
	conns[coo].recverfd = 0;
	memset(conns[coo].totalBuffer, 0, total_buf_size);
}


void getStructFromPipe(struct pipePack conns[i], struct targetPack *tgt)
{
	char bufferTem[500];
	memset(bufferTem,0,500);
	memcpy(bufferTem,conns[i].totalBuffer,sizeof(struct targetPack));
	memcpy(tgt,bufferTem,sizeof(struct targetPack));
}

transfer.h

#ifndef TRANSFER
#define TRANSFER

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <linux/in.h>
#include <errno.h>
#include <sys/select.h>
#include <string.h>
#include <memory.h>
#include <errno.h>

#include "xmlproc.h"


#define total_buf_size 1024
#define target_buf_size 300
#define pipes_num 50
#define border_size sizeof(struct targetPack)
#define recvcontent_size 300

struct pipePack
{
	int clientfd;
	int recverfd;
	char totalBuffer[total_buf_size];
	int edSize;
};

struct targetPack
{
	__u32 HeadMagic;
	__u32 Seq;
	__u32 XmlLength;
	__u32 total_packets;
	char packet_no;
	char reserve[2];
};

int i;
struct pipePack conns[pipes_num];


ssize_t sendP(int fd, const void *buf, size_t num, int flag);
ssize_t recvP (int fd, void *buf, size_t num, int flag);
void getStructFromPipe(struct pipePack conns[i], struct targetPack *tgt);
void recvFromClient(int m, struct targetPack *ss, int *testint, char *content);
void sendToClient(int m, struct targetPack *swap);
void sendTotalBuferToServer(int n, int recvID, char *str);
void recvFromServer(int s, struct targetPack *target);
void sendToClientXML2(int m, struct targetPack *swap, char *content);
void afterSendProc(int coo);

#endif

xmlproc.h

#include "xmlproc.h"


char *creatServerXml()
{	
//	remove("GetServerTimeResponse.xml");
	char *xmlFileName = "GetServerTimeResponse.xml";
	struct tm *ptr;
	time_t t;
	t = time(NULL);
	ptr = gmtime(&t); 
	char *ss = ctime(&t);
	xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
	xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"message");
	xmlNewProp(root_node,BAD_CAST"type",BAD_CAST"GetServerTimeResponse");
	xmlDocSetRootElement(doc,root_node);
	xmlNodePtr serverNm = xmlNewNode(NULL,BAD_CAST"serverTime");
	xmlNodePtr serverCt = xmlNewText(BAD_CAST ss);
	xmlAddChild(root_node,serverNm);
	xmlAddChild(serverNm,serverCt);
	int nRel = xmlSaveFile(xmlFileName,doc);
	/*
	if(nRel != -1)
	{
		printf("The XML file GetServerTimeResponse.xml has been created with %d bytes.\n",nRel);
	}
	*/
	xmlFreeDoc(doc);
	return xmlFileName;
}

char *creatClientXml()
{
//	remove("GetServerTime.xml");
	char *xmlFileName = "GetServerTime.xml";
	xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
	xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"message");
	xmlNewProp(root_node,BAD_CAST"type",BAD_CAST"GetServerTime");
	xmlDocSetRootElement(doc,root_node);

	xmlNodePtr clientNm = xmlNewNode(NULL,BAD_CAST"clientName");
	xmlNodePtr clientCt = xmlNewText(BAD_CAST"jxj");
	xmlAddChild(root_node,clientNm);
	xmlAddChild(clientNm,clientCt);
	
	int nRel = xmlSaveFile(xmlFileName,doc);
	/*
	if(nRel != -1)
	{
		printf("GetServerTime.xml file has been created with %d bytes.\n",nRel);
	}
	*/
	xmlFreeDoc(doc);
	return xmlFileName;
}


/*
*ŽËº¯ÊýÊÇcreateClientXmlµÄ±äÌ壬µÚÒ»žö²ÎÊýÊÇœÓÊÕ·œÌלÓ×ÖÃèÊö·û
*
*/
char *creatClientXmlFd(char *str, char *content)
{
//	remove("GetServerTime.xml");
	char *xmlFileName = "GetServerTime.xml";
	xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
	xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"message");
	xmlNewProp(root_node,BAD_CAST"type",BAD_CAST"GetServerTime");
	xmlDocSetRootElement(doc,root_node);

	xmlNodePtr clientNm = xmlNewNode(NULL,BAD_CAST"clientName");
	xmlNodePtr clientCt = xmlNewText(BAD_CAST"jxj");
	xmlAddChild(root_node,clientNm);
	xmlAddChild(clientNm,clientCt);

	xmlNodePtr clientNmfd = xmlNewNode(NULL,BAD_CAST"recverFD");
	xmlNodePtr clientCtfd = xmlNewText(BAD_CAST str);
	xmlAddChild(root_node,clientNmfd);
	xmlAddChild(clientNmfd,clientCtfd);

	xmlNodePtr clientNmContent= xmlNewNode(NULL,BAD_CAST"content");
	xmlNodePtr clientCtContent = xmlNewText(BAD_CAST content);
	xmlAddChild(root_node,clientNmContent);
	xmlAddChild(clientNmContent,clientCtContent);
	
	int nRel = xmlSaveFile(xmlFileName,doc);
	/*
	if(nRel != -1)
	{
		printf("GetServerTime.xml file has been created with %d bytes.\n",nRel);
	}
	*/
	xmlFreeDoc(doc);
	return xmlFileName;
}



/**
*·µ»ØÎÄŒþÃû×ÖΪµÚÒ»žö²ÎÊýµÄÄÚÈÝ×Ö·ûŽ®
*
*/
char *rtnXmlBuf(char * str)
{
	FILE *cltXml;
	char *xmlFileName = str;
	cltXml = fopen(xmlFileName,"r");
	char swap[2];
	size_t n = 1;
	swap[0] = fgetc(cltXml);
        memset(target,0,strlen(target)); 
	swap[1] = '\0';
	while(swap[0] != EOF)
	{
		strncat(target,swap,n);
		swap[0] = fgetc(cltXml);
	}
	int tarSize = strlen(target);
	target[tarSize] = '\0';
	/* printf("test:%s\n",target);*/
	fclose(cltXml);
	return target;
}


/*
*ŽÓbufÖеõœÒ»xmlµÄ×Ö·ûŽ®£¬Éú³ÉÃûΪfilenameµÄxmlÎÄŒþ
*
*/
void generateTimeFile(char *fileName, char *buf)
{		
	FILE *fp;
//	remove(fileName);
	if((fp = fopen(fileName,"w")) == NULL)
	{	
		printf("Create the Xml File failed!\n");
	}
	
	char *ss = buf;
	int filebuf_size = strlen(ss)+1;	
	char filebuf[filebuf_size];	
	sprintf(filebuf,"%s",ss);	

	int buf_size;
	//buf_size = strlen(filebuf);

	fputs(ss, fp);
	fclose(fp);
}


/*
*ŽÓÀŽÖÁ·þÎñÆ÷¶ËµÄxmlÎÄŒþÖÐÈ¡µÃµ±Ç°Ê±Œä
*
*/
char *rtnSerTime(char *fileNMStr)
{
	xmlDocPtr doc;
	xmlNodePtr curNode;
	xmlChar *szKey;
	char *szDocName = fileNMStr;

	doc = xmlReadFile(szDocName,"",XML_PARSE_RECOVER);
	if(NULL == doc)
	{
		printf("Document parsed successful!\n");
	}
	

	curNode = xmlDocGetRootElement(doc);
	if(NULL == curNode)
	  {
		fprintf(stderr,"empty document!\n");
		xmlFreeDoc(doc);
	  }
	if(xmlStrcmp(curNode->name,BAD_CAST"message"))
		{	
			fprintf(stderr,"document of the wrong type,roo != message");
			xmlFreeDoc(doc);
		}

	curNode = curNode->xmlChildrenNode;
	xmlNodePtr propNodePtr = curNode;
	if(curNode != NULL)
	{
		
        if(!xmlStrcmp(curNode->name,(const xmlChar*)"serverTime"))
		{	
			szKey = xmlNodeGetContent(curNode);
			printf("The server time:%s\n",szKey);
			xmlFree(szKey);
		}  
	}
	xmlFreeDoc(doc);
}




/*
*ÀàËÆÓërtnbuftime º¯Êý£¬²ÎÊý2ºÍ²ÎÊý3 ÊÇÌáÈ¡ŽÓ¿Í·þ¶ËµÃµœxml ÖÐœÓÊÕÕß
* idºÍÄÚÈÝ
*/
char *getFDandContent(char *fileNMStr, int *sockfd, char *str)
{
	xmlDocPtr doc;
	xmlNodePtr curNode;
	xmlChar *szKey;
	xmlChar *fdKey;
	xmlChar *cntKey;
	
	char *szDocName = fileNMStr;

	doc = xmlReadFile(szDocName,"",XML_PARSE_RECOVER);
	if(NULL == doc)
	{
		printf("Document parsed successful!\n");
	}
	

	curNode = xmlDocGetRootElement(doc);
	if(NULL == curNode)
	  {
		fprintf(stderr,"empty document!\n");
		xmlFreeDoc(doc);
	  }
	if(xmlStrcmp(curNode->name,BAD_CAST"message"))
		{	
			fprintf(stderr,"document of the wrong type,roo != message");
			xmlFreeDoc(doc);
		}

	curNode = curNode->xmlChildrenNode;
	xmlNodePtr propNodePtr = curNode;
	if(curNode != NULL)
	{
          	if(!xmlStrcmp(curNode->name,(const xmlChar*)"serverTime"))
		{	
			szKey = xmlNodeGetContent(curNode);
			printf("The server time:%s\n",szKey);
		}
	}

	curNode = curNode->next;
	if(curNode != NULL)
	{
          	if(!xmlStrcmp(curNode->name,(const xmlChar*)"recverFD"))
		{	
			szKey = xmlNodeGetContent(curNode);
			printf("The xmk recvID:%s\n",szKey);
			*sockfd = atoi(szKey);
			//printf("The xmk recvID int:%d\n",*sockfd);
		}
	}	

	curNode = curNode->next;
	if(curNode != NULL)
	{
          	if(!xmlStrcmp(curNode->name,(const xmlChar*)"content"))
		{	
			szKey = xmlNodeGetContent(curNode);
			//printf("The xmk content:%s\n",szKey);
			sprintf(str,"%s",szKey);
		}
	}	
	xmlFree(szKey);
	xmlFreeDoc(doc);
}

xmlproc.h

#ifndef __XMLPROC__
#define __XMLPROC__

#include <stdio.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <time.h>
#include <memory.h>

char target[1024];

char *rtnSerTime(char *fileNMStr);
void generateTimeFile(char * fileName, char * buf);
char *rtnXmlBuf(char * str);
char *creatClientXml();
char *creatServerXml();
char *creatClientXmlFd(char *str, char *content);

#endif

Makefile

all:client server

client: tcp_client.o transfer.o xmlproc.o
	cc -lxml2 -o client tcp_client.o transfer.o xmlproc.o

server: tcp_server.o transfer.o xmlproc.o
	cc -lxml2 -o server tcp_server.o transfer.o xmlproc.o

tcp_server.o:tcp_server.c
	cc -I /usr/include/libxml2 -c -o tcp_server.o tcp_server.c

tcp_client.o:tcp_client.c 
	cc -I /usr/include/libxml2 -c -o tcp_client.o tcp_client.c

transfer.o:transfer.c transfer.h
	cc -I /usr/include/libxml2 -c -o transfer.o transfer.c

xmlproc.o:xmlproc.c xmlproc.h
	cc -I /usr/include/libxml2 -c -o xmlproc.o xmlproc.c

clean:
	rm -f client server *.o *.xml