自己封装一个readline函数实现服务器客户端回射

实现的功能：一次只能读取一行，客户端输入之后，一回车，马上字符串传到服务器端并显示在终端，然后服务器端将字符串又传回给客户端。

　　　　　　服务器端可以接收多个客户端的连接请求，并fork一个子进程来进行服务。

（1）封装一个只能访问套接字描述符的readline函数

（2）服务器端启动SO_REUSEADDR套接字选项，以便服务器端不必等待TIME_WAIT状态

这是服务器端代码：

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

 #define ERR_EXIT(m) \
         do \
         { \
             perror(m); \
             exit(EXIT_FAILURE);\
         }while()

 void do_service(int conn)
 {
     char recvbuf[];
     while()
     {
         memset(recvbuf,,sizeof(recvbuf));
         int ret=readline(conn,recvbuf,sizeof(recvbuf));
         if(-==ret)
             ERR_EXIT("readline in do_servece");
         else if(==ret)
         {
             printf("client close\n");
             break;
         }
         fputs(recvbuf,stdout);
         writen(conn,recvbuf,strlen(recvbuf));
     }
 }

 ssize_t readn(int fd,void *buf,size_t count)
 {
     size_t nleft=count;
     ssize_t nread;
     char*bufp=(char*)buf;
     while(nleft>)
     {
         if((nread=read(fd,bufp,nleft))<)
         {
             if(errno==EINTR)
                 continue;
             return -;
         }
         else if(nread==)
             return count-nleft;
         bufp+=nread;
         nleft-=nread;
     }
     return count;
 }

 ssize_t writen(int fd,const void*buf,size_t count)
 {
     size_t nleft=count;
     ssize_t nwritten;
     char*bufp=(char*)buf;
     while(nleft>)
     {
         if((nwritten=write(fd,bufp,nleft))<)
         {
             if(errno==EINTR)
                 continue;
             return -;
         }
         else if(nwritten==)
             continue;
         bufp+=nwritten;
         nleft-=nwritten;
     }
     return count;
 }

 ssize_t recv_peek(int sockfd,void *buf,size_t len)
 {
     while()
     {
         int ret=recv(sockfd,buf,len,MSG_PEEK);//窥看，不清除缓存中的数据
         if(-==ret&&EINTR==errno)
             continue;
         return ret;
     }
 }

 ssize_t readline(int sockfd,void* buf,size_t maxline)
 {
     int ret;
     int nread;
     char* bufp=(char*)buf;
     int nleft=maxline;
     while()
     {
         ret=recv_peek(sockfd,bufp,nleft);
         if(ret<)
             return ret;
         else if(==ret)
             return ret;
         nread=ret;
         int i;
         for(i=;i<nread;i++)//读取到'\n'时就应该结束
         {
             if(bufp[i]=='\n')
             {
                 ret=readn(sockfd,bufp,i+);
                 if(ret!=i+)
                     exit(EXIT_FAILURE);
                 return ret;
             }
         }
         //执行到了这儿，说明没有读取到'\n'
         if(nread>nleft)
             exit(EXIT_FAILURE);
         nleft-=nread;
         ret=readn(sockfd,bufp,nread);//清空缓存中的数据，因为之前是窥视，并没有清空缓存
         if(ret!=nread)
             exit(EXIT_FAILURE);
         bufp+=nread;//指针后移，接着去执行while循环，确保数据追加到原来已读取数据的末尾
     }
     return -;
 }
 int main(void)
 {
     int listenfd;
     if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<)
         ERR_EXIT("socket");

     struct sockaddr_in servaddr;
     memset(&servaddr,,sizeof(servaddr));
     servaddr.sin_family=AF_INET;
     servaddr.sin_port=htons();
     servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
     //套接字选项的设置一定要在bind之前
     int on=;
     if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<)
             ERR_EXIT("setsockopt");
     if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<)
         ERR_EXIT("bind");
     if(listen(listenfd,SOMAXCONN)<)
         ERR_EXIT("listen");
     struct sockaddr_in peeraddr;
     socklen_t peerlen=sizeof(peeraddr);
     int conn;
     pid_t pid;
     while()
     {
         if((conn=accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<)
             ERR_EXIT("accept");
         printf("ip=%s port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
         pid=fork();
         if(-==pid)
             ERR_EXIT("fork");
         if(==pid)//子进程
         {
             close(listenfd);
             do_service(conn);
             exit(EXIT_SUCCESS);
         }
         else close(conn);//父进程
     }

     return ;
 }    

这是客户端代码：

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

 #define ERR_EXIT(m) \
         do \
         { \
             perror(m); \
             exit(EXIT_FAILURE);\
         }while()

 ssize_t readn(int fd,void *buf,size_t count)
 {
     size_t nleft=count;
     ssize_t nread;
     char*bufp=(char*)buf;
     while(nleft>)
     {
         if((nread=read(fd,bufp,nleft))<)
         {
             if(errno==EINTR)
                 continue;
             return -;
         }
         else if(nread==)
             return count-nleft;
         bufp+=nread;
         nleft-=nread;
     }
     return count;
 }

 ssize_t writen(int fd,const void*buf,size_t count)
 {
     size_t nleft=count;
     ssize_t nwritten;
     char*bufp=(char*)buf;
     while(nleft>)
     {
         if((nwritten=write(fd,bufp,nleft))<)
         {
             if(errno==EINTR)
                 continue;
             return -;
         }
         else if(nwritten==)
             continue;
         bufp+=nwritten;
         nleft-=nwritten;
     }
     return count;
 }

 ssize_t recv_peek(int sockfd,void *buf,size_t len)
 {
     while()
     {
         int ret=recv(sockfd,buf,len,MSG_PEEK);//窥看，不清除缓存中的数据
         if(-==ret&&EINTR==errno)
             continue;
         return ret;
     }
 }

 ssize_t readline(int sockfd,void* buf,size_t maxline)
 {
     int ret;
     int nread;
     char* bufp=(char*)buf;
     int nleft=maxline;
     while()
     {
         ret=recv_peek(sockfd,bufp,nleft);
         if(ret<)
             return ret;
         else if(==ret)
             return ret;
         nread=ret;
         int i;
         for(i=;i<nread;i++)//读取到'\n'时就应该结束
         {
             if(bufp[i]=='\n')
             {
                 ret=readn(sockfd,bufp,i+);
                 if(ret!=i+)
                     exit(EXIT_FAILURE);
                 return ret;
             }
         }
         //执行到了这儿，说明没有读取到'\n'
         if(nread>nleft)
             exit(EXIT_FAILURE);
         nleft-=nread;
         ret=readn(sockfd,bufp,nread);//清空缓存中的数据，因为之前是窥视，并没有清空缓存
         if(ret!=nread)
             exit(EXIT_FAILURE);
         bufp+=nread;//指针后移，接着去执行while循环，确保数据追加到原来已读取数据的末尾
     }
     return -;
 }
 int main(void)
 {
     int sock;
     if((sock=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<)
         ERR_EXIT("socket");
     struct sockaddr_in servaddr;
     memset(&servaddr,,sizeof(servaddr));
     servaddr.sin_family=AF_INET;
     servaddr.sin_port=htons();
     servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");//inet_addr将ip地址字符串转为数字形式，且已经是网络字节序    

     if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<)//
         ERR_EXIT("connect");

     char sendbuf[]={};
     char recvbuf[]={};
     while(fgets(sendbuf,sizeof(sendbuf),stdin)!=NULL)
     {
         writen(sock,sendbuf,strlen(sendbuf));

         int ret=readline(sock,recvbuf,sizeof(recvbuf));
         if(-==ret)
             ERR_EXIT("readline");
         else if(==ret)
         {
             printf("client?server close\n");
             break;
         }
         fputs(recvbuf,stdout);
     }

     return ;
 }