linux下C实现客户端服务器通信框架

服务器端

首先等候客户连接请求，一旦连接成功则接受客户端发送过来的字符，采用带有头结点的链表方式存贮字符，每个结点存储一个字符，接着通过对链表实现插入删除操作，完成对字符的升序排序，最后将排序后字符发送给客户端。

客户端

首先与服务器相连，接着发送客户端名字，然后发送客户信息，接受到服务器发送来排序结果并且显示。

服务器端代码：server.c

#include <sys/types.h>  
    #include <sys/socket.h>  
    #include <stdio.h>  
    #include <netinet/in.h>  
    #include <arpa/inet.h>  
    #include <unistd.h>  
    #include <stdlib.h>  
    #include <malloc.h>

struct LNode  
{  
    char data;  
    struct LNode *next;  
};  
  
//按升序创建链表,count为创建的链表的节点数目  
struct LNode *create(int count,char cdata[])  
{  
    int i=0;  
    struct LNode *pNode = NULL;  
    struct LNode *pNewNode = NULL;  
    struct LNode *head = NULL;  
   
  head = (struct LNode*)malloc(sizeof(struct LNode));
  head->next= NULL;
    for(i =0;i <count;i++)  
    {  
        pNewNode = (struct LNode*)malloc(sizeof(struct LNode));//分配节点空间  
       pNewNode->data=cdata[i];
	 pNewNode->next=NULL;
        if(head->next == NULL)    //指定头结点  
        {  
            head->next= pNewNode;  
         //   pNode = pNewNode;  
        }  
    	else   //有序插入
	{
		pNode=head;
		while(pNode->next!=NULL&&pNode->next->data<pNewNode->data){
			pNode=pNode->next;
		}
		pNewNode->next=pNode->next;
		pNode->next=pNewNode;
	}
    }  
	return head; 
    
} 



    int main()  
    {  
        int server_sockfd,client_sockfd;  
        int server_len,client_len;  
        struct sockaddr_in server_address;  
        struct sockaddr_in client_address;  
        int i,btye,j=0;  
        int rleng=0,sleng=0;
        char char_recv[100],char_send[100];    
	 struct LNode *node,*p;  

        server_address.sin_family = AF_INET;  
        server_address.sin_addr.s_addr = inet_addr("127.0.0.1");  
        server_address.sin_port = 8080;  
        server_len = sizeof(server_address);  
          
        server_sockfd = socket(AF_INET,SOCK_STREAM,0);  
          
        bind(server_sockfd,(struct sockaddr *)&server_address,server_len);  
          
        listen(server_sockfd,5);  
        printf("server waiting for connect\n");  
          
        client_len = sizeof(client_address);  
        client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_address,(socklen_t *)&client_len);  
          

      if(btye = recv(client_sockfd,&rleng,1,0) == -1)  //收长度
        {  
            perror("recvleng");  
            exit(EXIT_FAILURE);  
        }  


        if(btye = recv(client_sockfd,&char_recv,rleng,0) == -1)  //收数据
        {  
            perror("recv");  
            exit(EXIT_FAILURE);  
        }  

      
       printf("receive from client is:");
	while(j<rleng){
		//char_send[j]=char_recv[j];
        printf("%c",char_recv[j++]);
       }
     printf("\n");


	node = create(rleng,char_recv);  //处理发送数据
	j=0;
	p=node->next;
	while(p){
       char_send[j++]=p->data;
         p=p->next;
   }

     sleng=j+1;
      if(btye = send(client_sockfd,&sleng,1,0) == -1)  //发长度
        {  
            perror("sendleng");  
            exit(EXIT_FAILURE);  
        }  


        if(btye = send(client_sockfd,&char_send,sleng,0) == -1)  //发数据
        {  
            perror("send");  
            exit(EXIT_FAILURE);  
        }  


        shutdown(client_sockfd,2);  
        shutdown(server_sockfd,2);   
        return 0;  
    }  

客户端代码：client.c

#include <sys/types.h>  
    #include <sys/socket.h>  
    #include <stdio.h>  
    #include <netinet/in.h>  
    #include <arpa/inet.h>  
    #include <unistd.h>  
    #include <stdlib.h>  
    int main()  
    {  
        int sockfd;  
        int len;  
        struct sockaddr_in address;  
        int result;  
        int i,byte,j=0;  
        

	  int rleng=0,sleng=0;
	  char char_recv[100],char_send[100];
 
        if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)  //socket套接字
        {  
            perror("socket");  
            exit(EXIT_FAILURE);  
        }  
        address.sin_family = AF_INET;  
        address.sin_addr.s_addr = inet_addr("127.0.0.1");  
        address.sin_port = 8080;  
        len = sizeof(address);  
        if((result = connect(sockfd,(struct sockaddr *)&address,len)) == -1)  //建立链接
        {  
            perror("connect");  
            exit(EXIT_FAILURE);  
        }  
      
       printf("please enter the context you want to send to server and the end of !:");  
	
	 while(j<100 && char_send[j-1]!='!'){  //输入
        scanf("%c",&char_send[j++]); 
         }		  
                 
	sleng=j-1;
      if(byte = send(sockfd,&sleng,1,0) == -1)  //发长度
        {  
            perror("sendleng");  
            exit(EXIT_FAILURE);  
        }  

        if(byte = send(sockfd,&char_send,sleng,0) == -1)  //发数据
        {  
            perror("send");  
            exit(EXIT_FAILURE);  
        }  

        if(byte = recv(sockfd,&rleng,1,0) == -1)  //收长度
        {  
            perror("recv");  
            exit(EXIT_FAILURE);  
        }  

 
     if(byte = recv(sockfd,&char_recv,rleng,0) == -1)  //收数据
        {  
            perror("recv");  
            exit(EXIT_FAILURE);  
        }  
       printf("receive from server is:");
	j=0;
	while(j<rleng){
        printf("%c",char_recv[j++]);
       }
     printf("\n");


        close(sockfd);  //断开链接
        exit(0);  
    }  

实验操作如图所示，先打开两个终端分别编译，就能进行相互通信了。