• 《TCP/IP网络编程》阅读笔记--基于TCP的服务器端/客户端

    目录

    1--TCP/IP协议栈

    2--TCP服务器端默认函数调用顺序

    3--TCP客户端的默认函数调用顺序

    4--Linux实现迭代回声服务器端/客户端

    5--Windows实现迭代回声服务器端/客户端

    6--TCP原理

    7--Windows实现计算器服务器端/客户端

    1--TCP/IP协议栈

            TCP/IP协议栈共分 4 层，可以理解为数据收发分成了 4 个层次化过程；

    链路层：

            链路层是物理链接领域标准化的结果，专门定义LAN、WAN、MAN等网络标准；

    IP层：

            IP层用于解决数据传输过程中路径的选择问题；

    TCP/IP层：

            即传输层，用于解决数据传输的问题（数据顺序、可靠性等）；

    应用层：

            程序员根据数据传输规则，编写规定的程序（例如Socket）来实现数据传输；

    2--TCP服务器端默认函数调用顺序

            一般 TCP 服务器端调用默认函数的顺序如下：socket() 创建 Socket → bind() 分配Socket 地址 → listen() 等待连接请求状态 → accept() 允许连接 → read()/write() 数据交换 → close() 断开连接；

            调用 listen() 函数进入等待连接请求状态，只有服务器端调用了 listen() 函数，客户端才能进入可发出连接请求的状态；

    1. #include 
    2.  
    3. int listen(int sock, int backlog); // 成功时返回 0, 失败时返回 -1;
    4.  
    5. // sock 表示希望进入等待连接请求状态的Socket的文件描述符
    6. // backlog 表示连接请求等待队列的长度，即最多可以使多少个连接请求进入队列

            服务器端调用 accept() 函数来受理客户端的连接请求，即受理等待队列中待处理的客户端连接请求；

    1. #include 
    2.  
    3. int accept(int sock, struct sockaddr* addr, socklen_t* addrlen);
    4. // 成功时返回创建的Socket的文件描述符，失败时返回-1

    3--TCP客户端的默认函数调用顺序

            一般 TCP 客户端调用默认函数的顺序如下：socket() 创建 Socket → connect() 请求连接 → read()/write() 交换数据 → close() 断开连接；

            在服务器端调用 listen() 函数创建连接请求等待队列后，客户端可通过调用 connect() 函数来请求连接；

    1. #include 
    2.  
    3. int connect(int sock, struct sockaddr* servaddr, socklen_t addrlen);
    4.  
    5. // sock 表示客户端socket的文件描述符
    6. // servaddr 保存了目标服务器端地址信息
    7. // addrlen 第二个结构体参数 servaddr 的地址变量长度，以字节为单位

    4--Linux实现迭代回声服务器端/客户端

    服务器端：

    1. // gcc echo_server.c -o echo_server
    2. // ./echo_server 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12. void error_handling(char *message){
    13.     fputs(message, stderr);
    14.     fputc('\n', stderr);
    15.     exit(1);
    16. }
    17.  
    18. int main(int argc, char *argv[]){
    19.     int serv_sock, clnt_sock;
    20.     char message[BUF_SIZE];
    21.     int str_len, i;
    22.  
    23.     struct sockaddr_in serv_adr, clnt_adr;
    24.     socklen_t clnt_adr_sz;
    25.  
    26.     if(argc != 2){
    27.         printf("Usage : %s \n", argv[0]);
    28.         exit(1);
    29.     }
    30.  
    31.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    32.     if(serv_sock == -1){
    33.         error_handling("socket() error");
    34.     }
    35.  
    36.     memset(&serv_adr, 0, sizeof(serv_adr));
    37.     serv_adr.sin_family = AF_INET;
    38.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    39.     serv_adr.sin_port = htons(atoi(argv[1]));
    40.  
    41.     if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1){
    42.         error_handling("bind() error");
    43.     }
    44.  
    45.     if(listen(serv_sock, 5) == -1){
    46.         error_handling("listen() error");
    47.     }
    48.  
    49.     clnt_adr_sz = sizeof(clnt_adr);
    50.  
    51.     for(i = 0; i < 5; i++){
    52.         clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
    53.         if(clnt_sock == -1){
    54.             error_handling("accept() error");
    55.         }
    56.         else{
    57.             printf("Connected client %d \n", i+1);
    58.         }
    59.  
    60.         while((str_len = read(clnt_sock, message, BUF_SIZE)) != 0){
    61.             write(clnt_sock, message, str_len);
    62.         }
    63.  
    64.         close(clnt_sock);
    65.     }
    66.     close(serv_sock);
    67.     return 0;
    68. }

    客户端：

    1. // gcc echo_client.c -o echo_client
    2. // ./echo_client 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12.  
    13. void error_handling(char *message){
    14.     fputs(message, stderr);
    15.     fputc('\n', stderr);
    16.     exit(1);
    17. }
    18.  
    19. int main(int argc, char *argv[]){
    20.     int sock;
    21.     char message[BUF_SIZE];
    22.     int str_len;
    23.     struct sockaddr_in serv_adr;
    24.  
    25.     if(argc != 3){
    26.         printf("Usage : %s  \n", argv[0]);
    27.         exit(1);
    28.     }
    29.  
    30.     sock = socket(PF_INET, SOCK_STREAM, 0);
    31.     if(sock == -1){
    32.         error_handling("socket() error");
    33.     }
    34.  
    35.     memset(&serv_adr, 0, sizeof(serv_adr));
    36.     serv_adr.sin_family = AF_INET;
    37.     serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    38.     serv_adr.sin_port = htons(atoi(argv[2]));
    39.  
    40.     if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1){
    41.         error_handling("connect() error!");
    42.     }
    43.     else{
    44.         puts("Connected.......");
    45.     }
    46.  
    47.     while(1){
    48.         fputs("Input message(Q to quit): ", stdout);
    49.         fgets(message, BUF_SIZE, stdin);
    50.  
    51.         if(!strcmp(message, "q\n") || !strcmp(message, "Q\n")){
    52.             break;
    53.         }
    54.  
    55.         write(sock, message, strlen(message));
    56.         str_len = read(sock, message, BUF_SIZE-1);
    57.         message[str_len] = 0;
    58.         printf("Message from server: %s", message);
    59.     }
    60.  
    61.     close(sock);
    62.     return 0;
    63. }

    运行结果：

    5--Windows实现迭代回声服务器端/客户端

    服务器端：

    1. // gcc echo_server_win.c -o echo_server_win -lwsock32
    2. // echo_server_win 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define BUF_SIZE 1024
    10.  
    11. void ErrorHandling(char *message){
    12.     fputs(message, stderr);
    13.     fputc('\n', stderr);
    14.     exit(1);
    15. }
    16.  
    17. int main(int argc, char *argv[]){
    18.     WSADATA wsaData;
    19.     SOCKET hServSock, hClntSock;
    20.     char message[BUF_SIZE];
    21.     int strLen, i;
    22.  
    23.     SOCKADDR_IN servAdr, clntAdr;
    24.     int clntAdrSize;
    25.  
    26.     if(argc != 2){
    27.         printf("Usage : %s \n", argv[0]);
    28.         exit(1);
    29.     }
    30.  
    31.     if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){
    32.         ErrorHandling("WSAStartup() error!");
    33.     }
    34.  
    35.     hServSock = socket(PF_INET, SOCK_STREAM, 0);
    36.     if(hServSock == INVALID_SOCKET){
    37.         ErrorHandling("socket() error");
    38.     }
    39.  
    40.     memset(&servAdr, 0, sizeof(servAdr));
    41.     servAdr.sin_family = AF_INET;
    42.     servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    43.     servAdr.sin_port = htons(atoi(argv[1]));
    44.  
    45.     if(bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR){
    46.         ErrorHandling("bind() error");
    47.     }
    48.  
    49.     if(listen(hServSock, 5) == SOCKET_ERROR){
    50.         ErrorHandling("listen() error");
    51.     }
    52.  
    53.     clntAdrSize = sizeof(clntAdr);
    54.  
    55.     for(int i = 0; i < 5; i++){
    56.         hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize);
    57.         if(hClntSock == -1){
    58.             ErrorHandling("accept() error");
    59.         }
    60.         else{
    61.             printf("Connected client %d \n", i + 1);
    62.         }
    63.         while((strLen = recv(hClntSock, message, BUF_SIZE, 0)) != 0){
    64.             send(hClntSock, message, strLen, 0);
    65.         }
    66.         closesocket(hClntSock);
    67.     }
    68.     closesocket(hServSock);
    69.     WSACleanup();
    70.     return 0;
    71. }

    客户端：

    1. // gcc echo_client_win.c -o echo_client_win -lwsock32
    2. // echo_client_win 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define BUF_SIZE 1024
    10.  
    11. void ErrorHandling(char *message){
    12.     fputs(message, stderr);
    13.     fputc('\n', stderr);
    14.     exit(1);
    15. }
    16.  
    17. int main(int argc, char *argv[]){
    18.     WSADATA wsaData;
    19.     SOCKET hSocket;
    20.     char message[BUF_SIZE];
    21.     int strLen;
    22.     SOCKADDR_IN servAdr;
    23.  
    24.     if(argc != 3){
    25.         printf("Usage: %s  \n", argv[0]);
    26.         exit(1);
    27.     }
    28.  
    29.     if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){
    30.         ErrorHandling("WSAStartup() error!");
    31.     }
    32.  
    33.     hSocket = socket(PF_INET, SOCK_STREAM, 0);
    34.     if(hSocket == INVALID_SOCKET){
    35.         ErrorHandling("socket() error");
    36.     }
    37.  
    38.     memset(&servAdr, 0, sizeof(servAdr));
    39.     servAdr.sin_family = AF_INET;
    40.     servAdr.sin_addr.s_addr = inet_addr(argv[1]);
    41.     servAdr.sin_port = htons(atoi(argv[2]));
    42.  
    43.     if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR){
    44.         ErrorHandling("connect() error!");
    45.     }
    46.     else{
    47.         puts("Connected........");
    48.     }
    49.  
    50.     while(1){
    51.         fputs("Input message(Q to quit): ", stdout);
    52.         fgets(message, BUF_SIZE, stdin);
    53.  
    54.         if(!strcmp(message, "q\n") || !strcmp(message, "Q\n")){
    55.             break;
    56.         }
    57.  
    58.         send(hSocket, message, strlen(message), 0);
    59.         strLen = recv(hSocket, message, BUF_SIZE - 1, 0);
    60.         message[strLen] = 0;
    61.         printf("Message from server: %s", message);
    62.     }
    63.     closesocket(hSocket);
    64.     WSACleanup();
    65.     return 0;
    66. }

    测试结果：

    6--TCP原理

    I/O缓冲：

            当调用 write() 函数后并不会立即传输数据，而是将数据移至输出缓冲；

            同样当调用 read() 函数后也并不会马上接收数据，而是将数据移至输入缓冲；

            TCP会控制数据流，使用滑动窗口协议（参考博主之前的笔记：TCP流量控制）来限制数据传输不会超过输入缓冲的大小；

    TCP 协议使用三次握手来建立连接，使用四次挥手来断开连接；（具体分析参考书中图解）

    7--Windows实现计算器服务器端/客户端

    服务器端：

    1. // gcc op_server_win.c -o op_server_win -lwsock32
    2. // op_server_win 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define BUF_SIZE 1024
    10. #define OPSZ 4
    11.  
    12. void ErrorHandling(char *message){
    13.     fputs(message, stderr);
    14.     fputc('\n', stderr);
    15.     exit(1);
    16. }
    17.  
    18. int calculate(int opnum, int opnds[], char op){
    19.     int result = opnds[0], i;
    20.     switch(op){
    21.         case '+':
    22.             for(i = 1; i < opnum; i++) result += opnds[i];
    23.             break;
    24.         case '-':
    25.             for(i = 1; i < opnum; i++) result -= opnds[i];
    26.             break;
    27.         case '*':
    28.             for(i = 1; i < opnum; i++) result *= opnds[i];
    29.             break;
    30.     }
    31.     return result;
    32. }
    33.  
    34. int main(int argc, char* argv[]){
    35.     WSADATA wsaData;
    36.     SOCKET hServSock, hClntSock;
    37.     char opinfo[BUF_SIZE];
    38.     int result, opndCnt, i;
    39.     int recvCnt, recvLen;
    40.     SOCKADDR_IN servAdr, clntAdr;
    41.     int clntAdrSize;
    42.     if(argc != 2){
    43.         printf("Usage: %s \n", argv[0]);
    44.         exit(1);
    45.     }
    46.  
    47.     if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){
    48.         ErrorHandling("WSAStartup() error!");
    49.     }
    50.  
    51.     hServSock = socket(PF_INET, SOCK_STREAM, 0);
    52.     if(hServSock == INVALID_SOCKET){
    53.         ErrorHandling("socket() error!");
    54.     }
    55.  
    56.     memset(&servAdr, 0, sizeof(servAdr));
    57.     servAdr.sin_family = AF_INET;
    58.     servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    59.     servAdr.sin_port = htons(atoi(argv[1]));
    60.  
    61.     if(bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR){
    62.         ErrorHandling("bind() error");
    63.     }
    64.  
    65.     if(listen(hServSock, 5) == SOCKET_ERROR){
    66.         ErrorHandling("listen() error");
    67.     }
    68.  
    69.     clntAdrSize = sizeof(clntAdr);
    70.  
    71.     for(int i = 0; i < 5; i++){
    72.         opndCnt = 0;
    73.         hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize);
    74.         recv(hClntSock, (char*)&opndCnt, 1, 0); // recv one byte
    75.  
    76.         recvLen = 0;
    77.         while((opndCnt * OPSZ + 1) > recvLen){
    78.             recvCnt = recv(hClntSock, &opinfo[recvLen], BUF_SIZE - 1, 0);
    79.             recvLen += recvCnt;
    80.         }
    81.  
    82.         result = calculate(opndCnt, (int*)opinfo, opinfo[recvLen - 1]);
    83.         send(hClntSock, (char*)&result, sizeof(result), 0);
    84.         closesocket(hClntSock);
    85.     }
    86.  
    87.     closesocket(hServSock);
    88.     WSACleanup();
    89.     return 0;
    90. }

    客户端：

    1. // gcc op_client_win.c -o op_client_win -lwsock32
    2. // op_client_win 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define BUF_SIZE 1024
    10. #define RLT_SIZE 4
    11. #define OPSZ 4
    12.  
    13. void ErrorHandling(char *message){
    14.     fputs(message, stderr);
    15.     fputc('\n', stderr);
    16.     exit(1);
    17. }
    18.  
    19. int main(int argc, char* argv[]){
    20.     WSADATA wsaData;
    21.     SOCKET hSocket;
    22.     char opmsg[BUF_SIZE];
    23.     int result, opndCnt, i;
    24.     SOCKADDR_IN servAdr;
    25.     if(argc != 3){
    26.         printf("Usage : %s  \n", argv[0]);
    27.         exit(1);
    28.     }
    29.  
    30.     if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){
    31.         ErrorHandling("WSAStartup() error!");
    32.     }
    33.  
    34.     hSocket = socket(PF_INET, SOCK_STREAM, 0);
    35.     if(hSocket == INVALID_SOCKET){
    36.         ErrorHandling("socket() error!");
    37.     }
    38.  
    39.     memset(&servAdr, 0, sizeof(servAdr));
    40.     servAdr.sin_family = AF_INET;
    41.     servAdr.sin_addr.s_addr = inet_addr(argv[1]);
    42.     servAdr.sin_port = htons(atoi(argv[2]));
    43.  
    44.     if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR){
    45.         ErrorHandling("connect() error!");
    46.     }
    47.     else{
    48.         puts("Connected........");
    49.     }
    50.  
    51.     fputs("Operand count: ", stdout);
    52.     scanf("%d", &opndCnt);
    53.     opmsg[0] = (char)opndCnt; // one byte
    54.  
    55.     for(i = 0; i < opndCnt; i++){
    56.         printf("Operand %d: ", i + 1);
    57.         scanf("%d", (int*)&opmsg[i*OPSZ + 1]);
    58.     }
    59.  
    60.     fgetc(stdin);
    61.     fputs("Operator: ", stdout);
    62.     scanf("%c", &opmsg[opndCnt * OPSZ + 1]); // one byte
    63.     send(hSocket, opmsg, opndCnt * OPSZ + 2, 0);
    64.     recv(hSocket, (char*)&result, RLT_SIZE, 0);
    65.  
    66.     printf("Operation result: %d \n", result);
    67.     closesocket(hSocket);
    68.     WSACleanup();
    69.     return 0;
    70. }

    运行结果：

  • 相关阅读:
    微服务项目：尚融宝（26）（后端搭建：Nuxt.js入门）
    bash: ./configure: /bin/sh^M: bad interpreter: No such file or directory
    git 常用操作学习
    微信小程序（一）
    QT+SQLite数据库配置和使用
    爬虫项目（四）：批量下载高清美女桌面壁纸
    Golang关键字-select
    嵌入式学习日记 27
    07Thymeleaf
    数据结构之栈的实现（附源码）
  • 原文地址：https://blog.csdn.net/weixin_43863869/article/details/132677479