TCP/IP网络编程 第五章:实现基于TCP的服务端/客户端(2)

回声客户端的完美实现

在上一章中，我们提出了实现的回声客户端存在的问题，这里我们来解决一下。

先给出对应的服务端和客户端代码:

while((str_len=read(clnt_sock,message,BUF_SIZE))!=0)
     write(clnt_sock,message,str_len);

write(sock,message,strlen(message));
str_len=read(sock,message,BUF_SIZE-1);

上述代码的问题实际上很明显，我们先考虑一下服务器端。不断读取来自客户端的字符串内容，直到读取完为止，然后再将读取的所有内容都写回客户端。显然问题是出在客户端了，客户端先将他的字符串内容写到服务端中，然后客户端等待服务器端的返回，但是它只调用了一次的read函数，相当于只读取了一次字符串的内容。我们在之前的章节说过TCP传输的数据是没有数据边界的，说人话就是:"read调用的次数不等于write的次数"。就是说在这种回声客户端的情况，客户端可能需要调用多次的read的函数才能获得回声的内容。

现在针对客户端代码给出修改示例:

while(1){
    str_len=write(sock,message,strlen(message));
    
    recv_len=0;
    while(recv_len<str_len){
        recv_cnt=read(sock,&message[recv_len],BUF_SIZE-1);
        if(recv_cnt==-1)error_handling("read() error!");
        recv_len+=recv_cnt;
    }
    message[recv_len]=0;
}
     

针对之前只是调用一次read函数的问题，现在改为多次。其实逻辑很简单，就是记录回声了多少长度的字符串，如果长度没有到，那么则等待调用read，否则则说明回声完成。

如果问题不在回声客户端:定义应用层协议

如果仔细想一下，上述问题出现的根本原因不就是客户端和服务器端两者没有一个统一的规范标准，此时需要的就是应用层协议的定义。收发数据的过程中需要定好规则以表示数据的边界，或提前告知收发数据的大小。

下面编写程序以体验应用层协议的定义过程。该程序中，服务器端从客户端获得多个数字和运算符信息。服务器端收到数字后对其进行加减乘运算，然后把结果传回客户端。例如，向服务器端传递3、5、9的同时请求加法运算，则客户端收到3+5+9的运算结果；若请求做乘法运算，则客户端收到3x5x9的运算结果。而如果向服务器端传递4、3、2的同时要求做减法，则客户端将收到4-3-2的运算结果，即第一个参数成为被减数。

计算器服务器端/客户端示例

先规定一下应用层的协议

□客户端连接到服务器端后以1字节整数形式传递待算数字个数。

□客户端向服务器端传递的每个整数型数据占用4字节。

□传递整数型数据后接着传递运算符。运算符信息占用1字节。

□选择字符+、-、*之一传递。
□服务器端以4字节整数型向客户端传回运算结果。
□客户端得到运算结果后终止与服务器端的连接。
这种程度的协议相当于实现了一半程序，这也说明应用层协议设计在网络编程中的重要性。
只要设计好协议，实现就不会成为大问题。另外，之前也讲过，调用close函数将向对方传递EOF,
请各位记住这一点并加以运用。接下来给出我实现的计算器客户端代码。

//头文件和其他示例相同，这里省略
#define BUF_SIZE 1024;
#define RLT_SIZE 4;
#defind OPSZ 4;
void error_handling(char*message);

int main(int argc,char*argv[]){
    int sock;  
    char opmsg[BUF_SIZE];
    int result,open_cnt,i;
    struct sockaddr_t serv_addr;
    if(argc!=3){
       printf("Usage : %s <IP> <port>\n",argv[0]);
       exit(1);
    }

    sock=socket(PF_INET,SOCK_STREAM,0);
    if(sock==-1)error_handling("socket() error");

    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
    serv_addr.sin_port=htons(atoi(argv[2]));

    if(connect(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr))==-1)
        error_handling("connect() error!");
    else 
        puts("Connected.........");

    fputs("Operand count:",stdout);
    scanf("%d",&opnd_cnt);
    opmsg[0]=(char)opnd_cnt;

    for(i=0; i<opnd_cnt; i++){
        printf("operand %d:",i+1);
        scanf("%d"，(int*)&opmsg[i*OPSZ+1]);
    }
    fgetc(stdin);
    fputs("operator:", stdout);

    scanf("%c",&opmsg[opnd_cnt*0PSZ+1]);
    write(sock, opmsg, opnd_cnt*OPSZ+2);
    read(sock, &result, RLT_SIZE);
    printf("Operation result: %d \n", result);
    close(sock);
    return 0;
}
void error_handling(char *message)
//与其他示例的error_handling函数相同，故省略。

下面给出服务器端代码:

#include<"与其他示例的头声明相同，故省略">
#define BUF_SIZE 1024
#define OPSZ 4
void error _handling(char *message);
int calculate(int opnum, int opnds[], char oprator);

int main(int argc, char *argv[]){
    int serv_sock, clnt_sock;
    char opinfo[BUF_SIZE];
    int result, opnd _cnt,i;
    int recv_cnt, recv_len;
    struct sockaddr in serv adr, clnt adr;
    socklen_t clnt_adr_sz;

    if(argc!=2){
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock=socket(PF_INET, SOCK_STREAM, 8);
    if(serv_sock==-1)
    error_handling("socket() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_adr.sin_port=htons(atoi(argv[1]));

    if(bind(serv_sock,(struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
       error_handling("bind() error");

    if(listen(serv_sock,5)==-1)error_handling("listen() error");

    clnt_adr_sz=sizeof(clnt_adr);

    for(i=0;i<5;i++){
      opnd_cnt=0;
      clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &cint_adr_sz);
      read(clnt_sock,&opnd_cnt,1);
      recv_len=0;

      while((opnd_cnt*0PSZ+1)>recv_len){
          recv_cnt=read(clnt_sock, &opinfo[recv_len], BUF_SIZE-1);
          recv_len+=recv_cnt;
      }

      result=calculate(opnd_cnt,(int*)opinfo, opinfo[recv_len-1]);
      write(clnt_sock,(char*)&result, sizeof(result));
      close(clnt_sock);
      }

      close(serv_sock);
      return 0;
}

int calculate(int opnum, int opnds[], char op){
    int result=opnds[0], i;
    switch(op){
       case '+':
          for(i=1; i<opnum; i++) result+=opnds[i];
          break;
       case '-':
          for(i=1; i<opnum; i++) result-=opnds[i];
          break;
       case'*':
          for(i=1; i<opnum; i++) result*=opnds[i];
          break;
     }
    return result;
}

void error_handling(char *message)
//与其他示例的error_handling函数相同，故省略。

上述的客户端和服务器代码可能在指针的部分有点困难，但多加理解即可。

TCP套接字中的IO缓冲

在这里有一些疑问，就是服务器一次性传输了40字节，而客户端居然可以分批次接受。那么假如客户端接受10字节了以后，剩下30字节在何处等待呢?

实际上，write函数调用瞬间并非立即传输数据，read函数调用后也并非立马接受数据。更准确的说，write函数调用瞬间，数据将移入输出缓冲；read函数调用瞬间，从输出缓冲读取数据。

这些IO缓冲特性可以概括如下:

□ IO缓冲在每个TCP套接字中单独存在。
□ IO缓冲在创建套接字时自动生成。
□ 即使关闭套接字也会继续传递输出缓冲中遗留的数据。
□关闭套接字将丢失输入缓冲中的数据。