linux下CS模型

/*server.c*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <netinet/in.h>

#include <signal.h>

#define SERVER_PORT 6666
#define MAX_BACKLOG_SIZE 10
#define MAX_MSG_LENGTH 1024

int server_connect(int * sockfd);
int server_recv(int sockfd, char * buf);
int server_send(int sockfd, const char * buf);
void signalhandler(void);

int main(int argc, char * argv[])
{
    signalhandler();
    int client_sockfd, server_sockfd;
    int sockfd = server_connect(&server_sockfd);
    if(sockfd != -1)
    {
        char buf[MAX_MSG_LENGTH] = {0};
        server_recv(sockfd, buf);
    }
    close(server_sockfd);
    return 0;
}

int server_connect(int * sockfd)
{
    int server_sockfd;
    int addrlen = MAX_MSG_LENGTH;
    struct sockaddr_in server_addr, client_addr;
    
    server_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(server_sockfd == -1)
    {
        printf("server socket error: %s\n", strerror(errno));
        return -1;
    }
    
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family      = AF_INET;
    server_addr.sin_port        = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    int bind_ret = bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
    if(bind_ret == -1)
    {
        printf("server bind error: %s\n", strerror(errno));
        close(server_sockfd);
        return -1;
    }

    int listen_ret = listen(server_sockfd, MAX_BACKLOG_SIZE);
    if(listen_ret == -1)
    {
        printf("server listen error: %s\n", strerror(errno));
        close(server_sockfd);
        return -1;
    }

    memset(&client_addr, 0, sizeof(struct sockaddr));
    int client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &addrlen);
    if(client_sockfd == -1)
    {
        printf("server accept error: %s\n", strerror(errno));
        close(server_sockfd);
        return -1;
    }

    * sockfd = server_sockfd;
    return client_sockfd;
}

int server_recv(int sockfd, char * buf)
{
    do
    {
        int recvBytes = recv(sockfd, buf, MAX_MSG_LENGTH, 0);
        if(recvBytes == 0)
        {

            close(sockfd);
            printf("server disconnect!\n");
            return -1;
        }
        else if(recvBytes <= 0)
        {
            if(errno == EAGAIN)
            {
                sleep(1);
                continue;
            }
            else
            {
                close(sockfd);
                close(sockfd);
                printf("server recv error: %s\n", strerror(errno));
                return -1;
            }
        }
        printf("client msg: %s\n", buf);
        if(strcmp(buf, "exit") == 0)
        {
            close(sockfd);
            break;
        }
        memset(buf, 0, MAX_MSG_LENGTH);
    }while(1);

    return 0;
}

int server_send(int sockfd, const char * buf)
{
    int sendLength;
    do
    {
        sendLength = send(sockfd, buf, strlen(buf), 0);
        if(sendLength == 0)
        {
            close(sockfd);
            printf("server disconnect!\n");
            return -1;
        }
        else if(sendLength < 0)
        {
            if(errno == EAGAIN)
            {
                sleep(1);
                continue;
            }
            else
            {
                close(sockfd);
                printf("server send error: %s\n", strerror(errno));
                return -1;
            }
        }
        break;
    }while(1);

    return 0;
}


void signalhandler(void)  
{  
    sigset_t sigSet;
    sigemptyset(&sigSet);
    sigaddset(&sigSet, SIGINT); 
    sigaddset(&sigSet, SIGQUIT);
    sigaddset(&sigSet, SIGPIPE);
    sigprocmask(SIG_BLOCK, &sigSet, NULL);
}  

/*client.c*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SERVER_PORT 6666
#define SERVER_IP   "192.168.137.3"
#define MAX_MSG_LENGTH 1024
 
int client_connect(void);
int client_send(int sockfd, const char * buf);
int client_recv(int sockfd, char * buf);

int main(int argc, char * argv[])
{
    char buf[MAX_MSG_LENGTH] = {0};
    int client_sockfd = client_connect();
    while((client_sockfd != -1))
    {
        gets(buf);
        client_send(client_sockfd, buf);
        if(strcmp(buf, "exit") == 0)
        {
            break;
        }
        memset(buf, 0, MAX_MSG_LENGTH);
    }
    close(client_sockfd);

    return 0;
}

int client_connect(void)
{
    int client_sockfd;
    client_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(client_sockfd < 0)
    {
        printf("client socket error: %s\n", strerror(errno));
        return -1;
    }

    int connect_ret;
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    connect_ret = connect(client_sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
    if(connect_ret < 0)
    {
        printf("client connect error: %s\n", strerror(errno));
        close(client_sockfd);
        return -1;

    }

    return client_sockfd;
}

int client_send(int sockfd, const char * buf)
{
    int sendLength;
    do
    {
        sendLength = send(sockfd, buf, strlen(buf), 0);
        if(sendLength == 0)
        {
            close(sockfd);
            printf("client disconnect!\n");
            return -1;
        }
        else if(sendLength < 0)
        {
            if(errno == EAGAIN)
            {
                sleep(1);
                continue;
            }
            else
            {
                close(sockfd);
                printf("client send error: %s\n", strerror(errno));
                return -1;
            }
        }
        break;
    }while(1);

    return 0;
}

int client_recv(int sockfd, char * buf)
{
    do
    {
        int recvBytes = recv(sockfd, buf, MAX_MSG_LENGTH, 0);
        if(recvBytes == 0)
        {

            close(sockfd);
            printf("disconnect!\n");
            return -1;
        }
        else if(recvBytes <= 0)
        {
            if(errno == EAGAIN)
            {
                sleep(1);
                continue;
            }
            else
            {
                close(sockfd);
                printf("client recv error: %s\n", strerror(errno));
                return -1;
            }
        }
        printf("server msg: %s\n", buf);
        if(strcmp(buf, "exit") == 0)
        {
            close(sockfd);
            break;
        }
        memset(buf, 0, MAX_MSG_LENGTH);
    }while(1);

    return 0;
}

这个只是单对单的CS模型，可以在这个的基础上添加所需要的功能。