关于echo服务端和客户端

1，实现的基本功能： 
客户端：发送一行文本给服务器，服务器显示收到的字节数，并返回收到的内容给客户端。 

2，一个单进程的实现实例： 
file echo.c: 

#include "csapp.h"

void echo(int connfd)
{
    size_t n;
    char buf[MAXLINE];
    rio_t rio;

    Rio_readinitb(&rio, connfd);
    while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0)
    { //line:netp:echo:eof
        printf("server received %d bytes\n", n);
        Rio_writen(connfd, buf, n);
    }
}

file echoclient.c: 

#include "csapp.h"

int main(int argc, char **argv)
{
    int clientfd, port;
    char *host, buf[MAXLINE];
    rio_t rio;

    if (argc != 3)
    {
        fprintf(stderr, "usage: %s  \n", argv[0]);
        exit(0);
    }
    host = argv[1];
    port = atoi(argv[2]);

    clientfd = Open_clientfd(host, port);
    Rio_readinitb(&rio, clientfd);

    while (Fgets(buf, MAXLINE, stdin) != NULL)
    {
        Rio_writen(clientfd, buf, strlen(buf));
        Rio_readlineb(&rio, buf, MAXLINE);
        Fputs(buf, stdout);
    }
    Close(clientfd); //line:netp:echoclient:close
    exit(0);
}

file: echoserver.c 

#include "csapp.h"

void echo(int connfd);

int main(int argc, char **argv)
{
    int listenfd, connfd, port, clientlen;
    struct sockaddr_in clientaddr;
    struct hostent *hp;
    char *haddrp;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s \n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);

    listenfd = Open_listenfd(port);
    while (1)
    {
        clientlen = sizeof(clientaddr);
        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);

        /* determine the domain name and IP address of the client */
        hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
                sizeof(clientaddr.sin_addr.s_addr), AF_INET);
        haddrp = inet_ntoa(clientaddr.sin_addr);
        printf("server connected to %s (%s)\n", hp->h_name, haddrp);

        echo(connfd);
        Close(connfd);
    }
    exit(0);
}

注：此时，只能一次处理一个客户端，当第二个客户端加入时，被阻塞。 
使用： 
服务端： 
./echoserver 8080 
server connected to kmplayer (127.0.0.1) 
server received 16 bytes 
server received 14 bytes 
server received 5 bytes 
客户端： 
./echoserver 8080 
server connected to kmplayer (127.0.0.1) 
server received 16 bytes 
server received 14 bytes 
server received 5 bytes 

3， 
基于进程的并发echo服务器： 

#include "csapp.h"

void echo(int connfd);

void sigchld_handler(int sig)
{
    while (waitpid(-1, 0, WNOHANG) > 0) //准备好接受多个僵死进程
        ;
    return;
}

int main(int argc, char **argv)
{
    int listenfd, connfd, port, clientlen = sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    struct hostent *hp;
    char *haddrp;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s \n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);
    Signal(SIGCHLD, sigchld_handler); //回收子进程

    listenfd = Open_listenfd(port);
    while (1)
    {
        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);

        if (Fork() == 0)
        {
            Close(listenfd); //关闭复制过来的监听描述符
            hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
                sizeof(clientaddr.sin_addr.s_addr), AF_INET);
            haddrp = inet_ntoa(clientaddr.sin_addr);
            printf("server connected to %s (%s)\n", hp->h_name, haddrp);
            echo(connfd);
            Close(connfd);
            exit(0);
        }

        Close(connfd);
    }
    exit(0);
}

4，基于I/O多路复用，实现了标准输入和客户端的echo服务器 

/*
 * echoserveri.c - An iterative echo server
 */
/* $begin echoserverimain */
#include "csapp.h"

void echo(int connfd);

void command(void);

int main(int argc, char **argv)
{
    int listenfd, connfd, port, clientlen = sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    struct hostent *hp;
    char *haddrp;
    fd_set read_set,ready_set;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s \n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);
    listenfd = Open_listenfd(port);

    FD_ZERO(&read_set);
    FD_SET(STDIN_FILENO, &read_set);
    FD_SET(listenfd, &read_set);
    while (1)
    {
        ready_set=read_set;//重新载入
        Select(listenfd+1, &ready_set, NULL, NULL, NULL); //挂起进程

        if(FD_ISSET(STDIN_FILENO, &ready_set))
        {
            printf("server connected to local stdin.\n");
            command();
        }
        if(FD_ISSET(listenfd, &ready_set))
        {
            connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
            hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
            sizeof(clientaddr.sin_addr.s_addr), AF_INET);
            haddrp = inet_ntoa(clientaddr.sin_addr);
            printf("server connected to %s (%s)\n", hp->h_name, haddrp);
            echo(connfd);
            Close(connfd);
        }
    }
    exit(0);
}

void command(void)
{
    char buf[MAXLINE];
    if (!Fgets(buf, MAXLINE, stdin))
        exit(0);
    printf("%s", buf);
}

注：一旦服务器连接到一个客户端，就会连续回送输入行，直到客户端关闭。 
期间，你键入命令到标准输入将不会得到响应。 

5，基于I/O多路复用，实现了多个客户端的echo服务器 

/*
 * echoserveri.c - An iterative echo server
 */
/* $begin echoserverimain */
#include "csapp.h"

typedef struct
{
    int maxfd;
    fd_set read_set;
    fd_set ready_set;
    int nready;
    int maxi;
    int clientfd[FD_SETSIZE];
    rio_t clientrio[FD_SETSIZE];
}pool;

void init_pool(int listenfd, pool* p);
void add_client(int connfd, pool* p);
void check_clients(pool* p);

int byte_cnt=0;

int main(int argc, char **argv)
{
    int listenfd, connfd, port, clientlen = sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    struct hostent *hp;
    static pool pool;
    char *haddrp;
    fd_set read_set,ready_set;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s \n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);
    listenfd = Open_listenfd(port);
    init_pool(listenfd, &pool);

    while (1)
    {
        pool.ready_set = pool.read_set;//重新载入
        pool.nready = Select(pool.maxfd+1, &pool.ready_set, NULL, NULL, NULL);
        if(FD_ISSET(listenfd, &pool.ready_set))
        {
            connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);

            hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
                                sizeof(clientaddr.sin_addr.s_addr), AF_INET);
            haddrp = inet_ntoa(clientaddr.sin_addr);
            printf("server connected to %s (%s)\n", hp->h_name, haddrp);
            add_client(connfd, &pool);
        }
        check_clients(&pool);
    }
    exit(0);
}
void init_pool(int listenfd, pool* p)
{
    int i;
    p->maxi = -1;
    for(i=0; i
        p->clientfd[i] = -1;
    p->maxfd = listenfd;
    FD_ZERO(&p->read_set);
    FD_SET(listenfd, &p->read_set);
}
void add_client(int connfd, pool* p)
{
    int i;
    p->nready--;
    for (i = 0; i < FD_SETSIZE; i++)
        if (p->clientfd[i] < 0)
        {
            p->clientfd[i] = connfd;
            Rio_readinitb(&p->clientrio[i], connfd);
            FD_SET(connfd, &p->read_set);
            if (connfd > p->maxfd)
                p->maxfd = connfd;
            if (i > p->maxi)
                p->maxi = i;
            break;
        }
        if(i == FD_SETSIZE)
            app_error("add_client error: Too many clients");
}
void check_clients(pool* p)
{
    int i, connfd, n;
    char buf[MAXLINE];
    rio_t rio;
    for (i = 0; (i <= p->maxi) && (p->nready > 0); i++)
    {
        connfd = p->clientfd[i];
        rio = p->clientrio[i];
        if ((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0)
        {
            byte_cnt +=n;
            printf("Server received %d (%d total) bytes on fd %d\n",
                    n, byte_cnt, connfd);
            Rio_writen(connfd, buf, n);
        }
        else
        {
            Close(connfd);
            FD_CLR(connfd, &p->read_set);
            p->clientfd[i] = -1;
        }
    }
}

注：客户端只有交替输入时，才可以正确处理 


6，基于多线程，实现了多个客户端的echo服务器 

/*
 * echoserveri.c - An iterative echo server
 */
/* $begin echoserverimain */
#include "csapp.h"

void Pthread_create(pthread_t *tidp, pthread_attr_t *attrp,
            void * (*routine)(void *), void *argp)
{
    int rc;

    if ((rc = pthread_create(tidp, attrp, routine, argp)) != 0)
    posix_error(rc, "Pthread_create error");
}

//常常配合pthread_self，来终止当前线程
void Pthread_cancel(pthread_t tid)
{
    int rc;

    if ((rc = pthread_cancel(tid)) != 0)
        posix_error(rc, "Pthread_cancel error");
}

//阻塞， 直到等到指定的线程终止。
void Pthread_join(pthread_t tid, void **thread_return)
{
    int rc;

    if ((rc = pthread_join(tid, thread_return)) != 0)
        posix_error(rc, "Pthread_join error");
}

//线程默认是可结合的：意味着可以被其他线程收回资源和杀死
//该函数使线程变为分离的，那么 其资源就不必显式的回收了。
void Pthread_detach(pthread_t tid)
{
    int rc;
    if ((rc = pthread_detach(tid)) != 0)
        posix_error(rc, "Pthread_detach error");
}

//线程显示终止
//主线程调用，等待所有其他线程终止，然后终止主线程和整个进程
void Pthread_exit(void *retval)
{
    pthread_exit(retval);
}
//某个 线程调用exit，会终止进程以及所有与该进程相关的线程

//返回自己线程的ID
pthread_t Pthread_self(void)
{
    return pthread_self();
}

void Pthread_once(pthread_once_t *once_control, void (*init_function)()) {
    pthread_once(once_control, init_function);
}


void echo(int connfd);
void* thread(void* vargp);

int main(int argc, char **argv)
{
    int listenfd, *connfdp, port, clientlen = sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    pthread_t tid;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s \n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);
    listenfd = Open_listenfd(port);

    while (1)
    {
        connfdp = (int*)Malloc(sizeof(int));
        *connfdp =Accept(listenfd, (SA *)&clientaddr, &clientlen);
        Pthread_create(&tid, NULL, thread, connfdp);
    }
    exit(0);
}

void* thread(void* vargp)
{
    int connfd = *((int*)vargp);
    printf("server connected to a client.\n");
    Free(vargp);
    echo(connfd);
    Close(connfd);
    return NULL;
}