《TCP/IP网络编程》第5章基于TCP的服务器端/客户端（2）

mali378287007

已于 2023-10-19 07:19:16 修改

阅读量743

点赞数

分类专栏： tcp/ip C/C++ 整理文章标签：网络 tcp/ip

于 2022-01-06 16:43:35 首次发布

本文链接：https://blog.youkuaiyun.com/oqqyx1234567/article/details/122343035

版权

整理同时被 3 个专栏收录

181 篇文章

订阅专栏

C/C++

92 篇文章

订阅专栏

tcp/ip

34 篇文章

订阅专栏

《TCP/IP网络编程》第5章基于TCP的服务器端/客户端（2）

TCP原理
Linux计算器服务器端
- - - 05.op_server_linux.c
Linux计算器客户端
- - - 05.op_client_linux.c
Windows计算器服务器端
- - - 05.op_server_win.c
Windows计算器客户端
- - - 05.op_client_win.c

TCP原理

TCP套接字中的I/O缓冲

调用write函数时，数据将移到输出缓冲，在适当的时候（分次或者一次性）传向对方的输入缓冲，这时对方调用read函数从输入缓冲读取数据。
I/O缓冲特性：

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

TCP中滑动窗口（Sliding Window）协议会控制数据流，数据收发不会因为缓冲溢出而丢失数据。

write和send函数在数据移动输出缓冲时返回，而不是完成向对方主机的数据传输时返回。但TCP会保证对输出缓冲数据的传输，所以说write函数在数据传输完成时返回。

与对方套接字的连接

三次握手（Three-way handshaking），完成数据交换准备。
套接字以全双工（Full-duplex）方式工作，双向传递数据。

收发数据前向数据包分配序号，并向对方通报此序号，防止数据丢失所做的准备。通过向数据包分配序号并确认，可以在数据丢失时马上查看并重传丢失的数据包。

A向B传递：
首次请求连接时发送消息，SYN（Synchronization，收发数据前传输的同步消息）。

[SYN] SEQ: 1000, ACK: -
//现传递序号1000数据包，若接收，请传递1001号数据包通知我

B向A传递：
A传输数据包的确认消息（ACK 1001）和B准备传输数据的同步消息（SEQ 2000），SYN+ACK。

[SYN+ACK] SEQ: 2000, ACK: 1001
//现传递序号2000数据包，若接收，请传递2001号数据包通知我
//请传递1001号数据包（之前1000数据包已正确接收）

A再次向B传递：
B传输数据包的确认消息（ACK 2001），ACK。

[ACK] SEQ: 1001, ACK: 2001
//本次传递的数据包编号为1001
//现在可以传递2001号数据包（之前2000数据包已正确接收）

与对方主机的数据交换

正式收发数据。
ACK号增量为传输的数据字节数。
ACK号=SEQ号+传递字节数+1（+1告知对方下次要传递的SEQ号）

SEQ未收到ACK确认时，TCP套接字启动计时器以等待ACK应答，计时器超时（TIme-out）时，数据包重传。

断开与套接字的连接

四次挥手（Four-way handshaking）。双方各发送1次FIN消息后断开连接。
客户端和服务器都可以主动先发送FIN消息（EOF，close告诉对方我数据已经发送完了，但仍然可以接收消息，可能重复发送），然后对方回复ACK消息（我已经知道你传完数据，但可能有部分数据未发送完）。

先发送FIN消息（未收到对端ACK应答会再次发送FIN）的一端，收到对端FIN并ACK 应答后，会经过 2MSL（ Maximum Segment Lifetime）的时间，期间若对端未收到ACK，会再次发送。

A向B传递：
发送单向断开消息（我不会再向你发送数据了）。

[FIN] SEQ: 5000, ACK: -
//现传递序号5000数据包
//发送后，A从ESTABLISHED进入FIN-WAIT-1

B向A传递：
发送确认消息（我收到你单向断开连接的请求了）。

[ACK] SEQ: 7500, ACK: 5001
//现传递序号7500数据包
//ACK用于确认收到A的断开请求
//发送后，B从ESTABLISHED开始进入CLOSE-WAIT
//收到后，A从FIN-WAIT-1开始进入FIN-WAIT-2

B向A传递：
发送单向断开消息（我不会再向你发送数据了）。

[FIN] SEQ: 7501, ACK: 5001
//现传递序号7501数据包
//ACK为5001是因为A接收ACK消息后未接收数据而重传的
//发送后，B从CLOSE-WAIT进入LAST-ACK
//收到后，A从FIN-WAIT-2进入TIME-WAIT

A向B传递：
发送确认消息（我收到你单向断开连接的请求了），等待B未重发断开请求时（确保此时B收到了A的确认信息）。

[ACK] SEQ: 5001, ACK: 7502
//现传递序号5001数据包
//ACK用于确认收到B的断开请求
//发送后等待2MSL，A从TIME-WAIT变为CLOSED
//收到后，B从LAST-ACK变为CLOSED

Linux计算器服务器端

05.op_server_linux.c

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

#define PORT 9999

#define BUF_SIZE 1024
#define OPSZ 4

void error_handling(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int calculate(int opnum, int opnds[], char op)
{
    int result = opnds[0];
    int 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;
}

int main(int argc, char *argv[])
{
    int serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1)
        error_handling("socket() error!");

    const int opt = 1;
    if (setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt)) == -1)
        error_handling("setsockopt() error!");

    socklen_t addr_size = sizeof(struct sockaddr_in);

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, addr_size);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(PORT);

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, addr_size) == -1)
        error_handling("bind() error!");

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

    for (int i = 0; i < 5; i++)
    {
        struct sockaddr_in clnt_addr;
        int clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &addr_size);
        if (clnt_sock == -1)
            error_handling("accept() error!");
        else
            printf("Connected client %d\n", i + 1);

        int opnd_cnt = 0;
        //接收一个字节，数值个数
        read(clnt_sock, &opnd_cnt, 1);

        char opinfo[BUF_SIZE];
        //接收opnd_cnt个数值+1个运算符
        int recv_len = 0;
        while (recv_len < OPSZ * opnd_cnt + 1)
        {
            int recv_cnt = read(clnt_sock, &opinfo[recv_len], BUF_SIZE - 1 - recv_len);
            recv_len += recv_cnt;
        }

        int 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;
}

// gcc 05.op_server_linux.c -o 05.op_server_linux && ./05.op_server_linux

Linux计算器客户端

05.op_client_linux.c

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

#define IP "127.0.0.1"
#define PORT 9999
#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4

void error_handling(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    int sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock == -1)
        error_handling("socket() error!");

    socklen_t addr_size = sizeof(struct sockaddr_in);

    struct sockaddr_in addr;
    memset(&addr, 0, addr_size);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(IP);
    addr.sin_port = htons(PORT);

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

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

    for (int i = 0; i < opnd_cnt; i++)
    {
        printf("Operand %d: ", i + 1);
        scanf("%d", (int *)&opmsg[1 + OPSZ * i]);
    }

    fgetc(stdin); //'\n'

    fputs("Operator: ", stdout);
    scanf("%c", &opmsg[1 + OPSZ * opnd_cnt]);

    write(sock, opmsg, 1 + OPSZ * opnd_cnt + 1);
    int result;
    read(sock, &result, RLT_SIZE);
    printf("Operation result: %d\n", result);

    close(sock);

    return 0;
}

// gcc 05.op_client_linux.c -o 05.op_client_linux && ./05.op_client_linux

Windows计算器服务器端

05.op_server_win.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define PORT 9999
#define BUF_SIZE 1024
#define OPSZ 4

void ErrorHanding(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int calculate(int opnum, int opnds[], char op)
{
    int result = opnds[0];
    int 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;
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    SOCKET hServSock = socket(PF_INET, SOCK_STREAM, 0);
    if (hServSock == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    int opt = 1;
    if (setsockopt(hServSock, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)) < 0)
        ErrorHanding("setsockopt() error!");

    int szAddr = sizeof(SOCKADDR_IN);

    SOCKADDR_IN servAddr;
    memset(&servAddr, 0, szAddr);
    servAddr.sin_family = AF_INET;
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAddr.sin_port = htons(PORT);

    if (bind(hServSock, (SOCKADDR *)&servAddr, szAddr) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    if (listen(hServSock, 5) == SOCKET_ERROR)
        ErrorHanding("listen() error!");

    for (int i = 0; i < 5; i++)
    {
        SOCKADDR_IN clntAddr;
        SOCKET hClntSock = accept(hServSock, (SOCKADDR *)&clntAddr, &szAddr);
        // if(hClntSock==INVALID_SOCKET)
        if (hClntSock == -1)
            ErrorHanding("accept() error!");
        else
            printf("Connected client %d\n", i + 1);

        int opnd_cnt = 0;
        // 接收一个字节，数值个数
        recv(hClntSock, (char *)&opnd_cnt, 1, 0);

        char opinfo[BUF_SIZE];
        int recv_len = 0;
        // 接收opnd_cnt个数值+1个运算符
        while (recv_len < OPSZ * opnd_cnt + 1)
        {
            int recv_cnt = recv(hClntSock, &opinfo[recv_len], BUF_SIZE - 1 - recv_len, 0);
            recv_len += recv_cnt;
        }

        int result = calculate(opnd_cnt, (int *)opinfo, opinfo[recv_len - 1]);
        send(hClntSock, (char *)&result, sizeof(result), 0);

        closesocket(hClntSock);
    }

    closesocket(hServSock);

    WSACleanup();

    return 0;
}

// gcc 05.op_client_win.c -o 05.op_client_win -lws2_32 && 05.op_client_win

Windows计算器客户端

05.op_client_win.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define IP "127.0.0.1"
#define PORT 9999

#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4

void ErrorHanding(const char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

int main(int argc, char *argv[])
{
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		ErrorHanding("WSAStartup() error!");

	SOCKET hSock = socket(PF_INET, SOCK_STREAM, 0);
	if (hSock == INVALID_SOCKET)
		ErrorHanding("socket() error!");

	int szAddr = sizeof(SOCKADDR_IN);

	SOCKADDR_IN servAddr;
	memset(&servAddr, 0, szAddr);
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.s_addr = inet_addr(IP);
	servAddr.sin_port = htons(PORT);

	if (connect(hSock, (SOCKADDR *)&servAddr, szAddr) == SOCKET_ERROR)
		ErrorHanding("connect() error!");
	else
		puts("Connected.......");

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

	for (int i = 0; i < opnd_cnt; i++)
	{
		printf("Operand %d: ", i + 1);
		scanf("%d", (int *)&opmsg[1 + OPSZ * i]);
	}

	fgetc(stdin); //'\n'

	fputs("Operator: ", stdout);
	scanf("%c", &opmsg[1 + OPSZ * opnd_cnt]);

	send(hSock, opmsg, 1 + OPSZ * opnd_cnt + 1, 0);
	int result;
	recv(hSock, (char *)&result, RLT_SIZE, 0);
	printf("Operation result: %d\n", result);

	closesocket(hSock);

	WSACleanup();

	return 0;
}

// gcc 05.op_client_win.c -o 05.op_client_win -lws2_32 && 05.op_client_win