网络编程学习笔记（五）基于TCP的服务器端/客户端（2）

回声客户端的完美实现

回声服务器端没有问题，只有回声客户端有问题。
因为回声客户端传输的是字符串，而且是通过调用write函数一次性发送的。之后还调用一次read函数，期待着接收自己传输的字符串。
回声客户端问题实际上是初级程序员经常犯的错误，其实很容易解决，因为可以提前确定接收数据的大小。
代码修改（43~53行）：

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

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

回声客户端可以提前知道接收的数据长度，但我们应该意识到，更多情况下这不太可能。既然如此，那应该如何收发数据？此时需要的就是应用层协议的定义。之前的回声服务器端/客户端中定义了如下定义：“收到Q就立即终止连接”。
同样，收发数据过程中也需要定好规则（协议）以表示数据的边界，或提前告知收发数据的大小。服务器端/客户端实现过程中逐步定义的这些规则集合就是应用层协议。可以看出，应用层协议并不是高深莫测的存在，只不过是为特定程序的实现而制定的规则。
下面编写程序以体验应用层协议的定义过程。
服务器端从客户端获得多个数字和运算符信息。服务器端收到数字后对其进行加减乘运算，然后把结果传回客户端。
示例代码：
op_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
#define OPSZ 4
void error_handling(char *message);
int calculate(int opnum, int opnds[], char op);

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_addr,clnt_addr;
    socklen_t clnt_addr_size;

    if(argc != 2)
    {
        printf("Usage : %s <port>\n",argv[0]);
        exit(1);
    }
    serv_sock = socket(PF_INET,SOCK_STREAM,0);
    if(serv_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 = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    if(bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("bind() error");
    if(listen(serv_sock,5) == -1)
        error_handling("listen() error");
    clnt_addr_size = sizeof(clnt_addr);
    for(i = 0; i < 5; ++i)
    {
        opnd_cnt = 0;
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        read(clnt_sock, &opnd_cnt, 1);

        recv_len = 0;
        while(recv_len < opnd_cnt*OPSZ+1)
        {
            recv_cnt = read(clnt_sock, &opinfo[recv_len],BUFSIZ - 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)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

op_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char opmsg[BUF_SIZE];
    int result, opnd_cnt,i;
    struct sockaddr_in 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*OPSZ+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)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

TCP原理

TCP套接字中的I/O缓冲

如前所述，TCP套接字的数据收发无边界。
实际上，write函数调用后并非立即传输数据，调用瞬间，数据将移至输出缓冲；read函数调用后也并非马上接收数据，调用瞬间，从输入缓冲读取数据。这些I/O缓冲特性可整理如下：
1. I/O缓冲在每个TCP套接字中单独存在
2. I/O缓冲在创建套接字时自动生成
3. 即使关闭套接字也会继续传递输出缓冲中遗留的数据
4. 关闭套接字将丢失输入缓冲中的数据
有一个问题：客户端输入缓冲为50字节，而服务器传输了100字节。
其实并不会发生超过输入缓冲大小的数据传输。
因为TCP会控制数据流。TCP中有滑动窗口（Sliding Window）协议。因此，TCP中不会因为缓冲溢出而丢失数据。

TCP内部工作原理1：与对方套接字的连接

TCP建立连接的3次握手。套接字是以全双工（Full-duplex）方式工作的。也就是说可以双向传递数据。
[SYN] SEQ: 1000, ACK: -
该消息SEQ为1000，ACK为空，而SEQ为1000的含义如下：
现传递的数据包序号为1000，如果接收无误，请通知我向您传递1001号数据包
这是首次请求连接时使用的消息，又称SYN（Synchronization），表示收发数据前需要做一些准备。接下来主机B向A传递如下消息：
[SYN+ACK] SEQ: 2000, ACK: 1001
此时SEQ为2000，ACK为1001，SEQ2000的含义：
现传递的数据包序号为2000，如果接收无误，请通知我向您传递2001号数据包
ACK1001的含义：
刚才传输的SEQ为1000的数据包接收无误，现在请传递SEQ为1001的数据包
SYN+ACK消息捆绑发送。
收发数据前向数据包分配序号，并向对方通报此序号，这都是为防止数据丢失做的准备。通过向数据包分配序号并确认，可以在数据丢失时马上查看并重传丢失的数据包。因此，TCP可以保证可靠的数据传输。最后观察主机A向主机B传输的消息：
[ACK] SEQ:1001,ACK 2001
已正确收到传输的SEQ为2000的数据包，现在可以传输SEQ为2001的数据包
这样就传输了添加ACK_2001的ACK消息，至此，主机A和主机B确认了彼此均就绪。

TCP内部工作原理2：与对方主机的数据交换

如果主机A通过1个数据包发送100个字节的数据，数据包的SEQ为1200.主机B为了确认这一点，向主机A发送ACK1301消息。
此时的ACK号为1301而非1201，原因在于ACK号的增量为传输的数据字节数。假设每次ACK号不加传输的字节数，这样虽然可以确认数据包的传输，但无法明确100字节全都正确传递还是丢失了一部分，比如只传递了80字节。因此按如下公式传递ACK消息：ACK号 → SEQ号 + 传递的字节数 + 1
与三次握手协议相同，最后加1是为了告知对方下次要传递的SEQ号。
如果传递数据超时，会进行重传。

TCP的内部工作原理3：断开与套接字的连接

实际上就是我们学过的4次挥手。
前面讲解了TCP协议基本内容的TCP流控制，希望有助于理解TCP数据传输特性。

基于windows的实现

修改方式与前面所讲过的方式相同，这里就不再赘述。