• TCP编程及基础知识

    一、端口号

    • 为了区分一台主机接收到的数据包应该转交给哪个进程来进行处理，使用端口号来区分
    • TCP端口号与UDP端口号独立
    • 端口用两个字节来表示    2byte（65535个）

    1. 众所周知端口：1~1023（1~255之间为众所周知端口，256~1023端口通常由UNIX系统占用）
    2. 已登记端口：1024~49151    （选1000以上10000以下） 
    3. 动态或私有端口：49152~65535

    二、字节序  

       小端序（little-endian）  - 低序字节存储在低地址

       大端序（big-endian）    - 高序字节存储在低地址

    网络中传输一字节以上的带类型的数据（比如short、int），必须使用网络字节序，即大端字节序。

    查看主机是大端序还是小端序。

    网络传输中,需要将每个主机的主机字节序(CPU决定),转换为网络中统一顺序的网络字节序

    才能供双方主机去识别

    只需要转换IP和port就可以,不需要转换传输的数据包的字节序

    因为IP和port为 4个字节和2个字节,  而数据报一般都为char类型, 占一个字节

    根据字节序的性质,内存存储大于一个字节类型的数据在内存中的存放顺序。

    所以char类型并不具有字节序的概念

    1.主机字节序到网络字节序 （小端序->大端序）

    1. #include 
    2. u_long htonl (u_long hostlong); //host to internet long
    3. 功能：将无符号整数hostlong从主机字节顺序转换为网络字节顺序。
    4. #include 
    5. u_short htons (u_short short);  //掌握这个
    6. 功能：将无符号短整数hostshort从主机字节顺序到网络字节顺序。

    2.网络字节序到主机字节序（大端序->小端序）

    1. #include 
    2. u_long ntohl (u_long hostlong);
    3. 功能：将无符号整数netlong从网络字节顺序转换为主机字节顺序。
    4. #include 
    5. u_short ntohs (u_short short);//端口 2byte
    6. 功能：将无符号短整数netshort从网络字节顺序转换为主机字节顺序。的

    1. #include 
    2. #include 
    3.  
    4. int main(int argc, char const *argv[])
    5. {
    6.     int a = 0x12345678;
    7.     //小端转大端
    8.     int b = htonl(a);
    9.     printf("%#x\n", b);
    10.     //大端转小端
    11.     int c = ntohl(b);
    12.     printf("%#x\n", c);
    13.     return 0;
    14. }

    三、IP地址转换

    1、inet_addr主机字节序转换为网络字节序

    1. #include   
    2. #include               
    3. #include
    4. in_addr_t  inet_addr(const char *strptr);  //该参数是字符串
    5.  
    6. typedef uint32_t in_addr_t;
    7. struct in_addr 
    8. {
    9.     in_addr_t s_addr;
    10. };
    11. 功能:  主机字节序转为网络字节序
    12. 参数:  const char *strptr: 字符串
    13. 返回值: 返回一个无符号长整型数(无符号32位整数用十六进制表示), 
    14.       否则NULL
    15.

    2、inet_ntoa 网络字节序转换为主机字节序

    1. #include 
    2. #include 
    3. #include 
    4. char *inet_ntoa(struct in_addr inaddr);
    5. 功能:   将网络字节序二进制地址转换成主机字节序。 
    6. 参数:  struct in_addr in addr  : 只需传入一个结构体变量
    7. 返回值:  返回一个字符指针, 否则NULL;

    四、TCP编程

    C/S   B/S

    client/server              browser/server

    客户端/服务器 浏览器/服务器

    1、套接字工作流程

    客户端:   发送请求

    服务器端:  相应请求

    服务器：

    1.创建流式套接字（socket()）------------------------>  有手机

    2.指定本地的网络信息（struct sockaddr_in）----------> 有号码

    3.绑定套接字（bind()）------------------------------>绑定手机

    4.监听套接字（listen()）---------------------------->待机

    5.链接客户端的请求（accept()）---------------------->接电话

    6.接收/发送数据（recv()/send()）-------------------->通话

    7.关闭套接字（close()）----------------------------->挂机

    客户端：

    1.创建流式套接字（socket()）----------------------->有手机

    2.指定服务器的网络信息（struct sockaddr_in）------->有对方号码

    3.请求链接服务器（connect()）---------------------->打电话

    4.发送/接收数据（send()/recv()）------------------->通话

    5.关闭套接字（close()）--------------------------- >挂机

    服务器端（server）：

    1) socket(),创建套接字文件，创建出用于连接的套接字文件

    2) bind(), 绑定，把socket()函数返回的文件描述符和IP、端口号进行绑定;

    3) listen(), 监听,将socket()返回的文件描述符，由主动套接字变为被动套接字;

    4) accept(), 阻塞函数，阻塞等待客户端的连接请求, 返回一个用于通信的套接字文件;

    5) recv(), 接收客户端发来的数据;(read)    

    //6) send(), 发送数据;(write)

    1. close(), 关闭文件描述符; 至少要关闭: 连接、通信

    客户端（client）：

    1. socket(),创建套接字文件，既用于连接，也用于通信; 

        填充结构体:  填充服务器的ip和端口 , 用于connect连接

    2) connect(); 用于发起连接请求,阻塞等待连接服务器;

    3) send(), 发送数据;

    //4) recv(), 接收数据;

    5）close(), 关闭文件描述符;

    2、函数接口

    1）socket 创建套接字

    1. #include <sys/types.h>          /* See NOTES */
    2. #include <sys/socket.h>
    3. int socket(int domain, int type, int protocol);
    4. 功能：创建套接字
    5. 参数：
    6.    domain：协议族
    7.      AF_UNIX, AF_LOCAL  本地通信
    8.      AF_INET            ipv4
    9.      AF_INET6            ipv6
    10.    type：套接字类型
    11.      SOCK_STREAM:流式套接字
    12.      SOCK_DGRAM：数据报套接字
    13.    protocol：协议 - 填0 自动匹配底层 ，根据type系统默认自动帮助匹配对应协议
    14.        传输层：IPPROTO_TCP、IPPROTO_UDP、IPPROTO_ICMP
    15.        网络层：htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL)
    16.  返回值：
    17.     成功 文件描述符 0 -> 标准输入  1->标准输出  2->标准出错 
    18.                   3->socket
    19.     失败 -1，更新errno
    20.

    2）bind 绑定   ipv4  ip和端口 

    1. #include <sys/types.h>          /* See NOTES */
    2. #include <sys/socket.h>
    3. int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    4. 功能：绑定   ipv4  ip和端口 
    5. 参数
    6.    sockfd：文件描述符
    7.    addr：通用结构体，根据socket第一个参数选择的通信方式最终确定这需要真正填充传递的结构体是那个类型。强转后传参数。
    8.    addrlen:填充的结构体的大小   
    9. 返回值：成功0 失败-1、更新errno
    10.  
    11. 通用结构体：相当于预留一个空间
    12. struct sockaddr 
    13. {
    14.     sa_family_t sa_family;
    15.     char        sa_data[14];
    16. }
    17.  
    18. ipv4的结构体 
    19.  struct sockaddr_in 
    20.  {
    21.      sa_family_t    sin_family;  //协议族AF_INET
    22.      in_port_t      sin_port;  //端口号
    23.      struct in_addr sin_addr;  //ip地址
    24.  };
    25.   struct in_addr 11
    26.  {
    27.      uint32_t       s_addr;   //IP地址  
    28.  };
    29.  
    30.  本地址通信结构体：
    31.   struct sockaddr_un 
    32.   {
    33.      sa_family_t sun_family;  //AF_UNIX  
    34.      char        sun_path[108]; //在本地创建的套接字文件的路径及名字
    35.  };
    36.  
    37. ipv6通信结构体：
    38. struct sockaddr_in6 
    39. {
    40.     sa_family_t     sin6_family;   
    41.     in_port_t       sin6_port;     
    42.     uint32_t        sin6_flowinfo; 
    43.     struct in6_addr sin6_addr;     
    44.     uint32_t        sin6_scope_id; 
    45. };
    46. struct in6_addr 
    47. {
    48.     unsigned char   s6_addr[16];   
    49. };
    50. //如果绑定使用通用地址可使用 INADDR_ANY宏（结合代码讲的时候再添加）
    51. 含义是自动绑定所有本机网卡的地址，

    11.2作业

    3）listen 监听，将主动套接字变为被动套接字

    1. #include <sys/types.h>          /* See NOTES */
    2. #include <sys/socket.h>
    3. int listen(int sockfd, int backlog);
    4. 功能:监听，将主动套接字变为被动套接字
    5. 参数：
    6.  sockfd：套接字
    7.  backlog：同时响应客户端请求链接的最大个数，不能写0.
    8. 不同平台可同时链接的数不同，一般写6-8个
    9. 返回值：成功 0   失败-1,更新errno  

    4）accept 阻塞函数

    1. #include <sys/socket.h>
    2. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    3.  
    4. accept(sockfd,NULL,NULL);
    5. 阻塞函数，阻塞等待客户端的连接请求，如果有客户端连接，
    6. 则accept()函数返回，返回一个用于通信的套接字文件描述符（4）;
    7. 参数：
    8.    Sockfd ：套接字
    9.    addr： 链接客户端的ip和端口号
    10.       如果不需要关心具体是哪一个客户端，那么可以填NULL;
    11.    addrlen：结构体的大小
    12.      如果不需要关心具体是哪一个客户端，那么可以填NULL;
    13.      不需要查看链接的客户端ip和端口号
    14.      accept(sockfd,NULL,NULL);
    15.      需要查看链接的客户端ip和端口号
    16.      accept(sockfd,(struct sockaddr *)&saddr,&len);
    17.   返回值： 
    18.      成功：文件描述符; //用于通信
    19. 失败：-1，更新errno
    20. 同时返回客户端的ip和端口号。保存到结构体struct sockaddr *addr中。
    21. 通过结构体访问到：inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)
    22. 打印时记得使用 inet_ntoa()和ntohs()转换为主机字节序

    5）recv 接收数据 

    1. #include <sys/types.h>
    2. #include <sys/socket.h>
    3. ssize_t recv(int sockfd, void *buf, size_t len, int flags);
    4. 功能: 接收数据 
    5. 参数： 
    6.     sockfd： acceptfd ;
    7.     buf  存放位置
    8.     len  大小
    9.     flags  一般填0，相当于read()函数
    10.     MSG_DONTWAIT  非阻塞
    11. 返回值： 
    12.    < 0  失败出错  更新errno
    13.    ==0  表示客户端退出
    14.    >0   成功接收的字节个数

    发送端协议类型为TCP Client,远程目标ip地址为服务器IP地址

    端口号也应该一致

    先关闭客户端，再关闭服务器。

    6）connect 用于连接服务器；

    1. #include           /* See NOTES */
    2. #include 
    3. int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    4. 功能：用于连接服务器；
    5. 参数：
    6.      sockfd：socket函数的返回值
    7.      addr：填充的结构体是服务器端的；
    8.      addrlen：结构体的大小
    9. 返回值 
    10.       -1 失败，更新errno
    11.       正确 0

    7）send 发送数据，用来发送消息到一个套接字中。

    1. #include <sys/types.h>
    2. #include <sys/socket.h>
    3. ssize_t send(int sockfd, const void *buf, size_t len, int flags);
    4. 功能：发送数据，用来发送消息到一个套接字中。只能在套接字处于连接状态的时候才能使用。
    5. 参数：
    6.     sockfd:socket函数的返回值
    7.     buf：发送内容存放的地址
    8.     len：发送内存的长度
    9.     flags：如果填0，相当于write();
    10. 返回值；
    11.     成功 发送的字节数
    12.     失败 -1
    13. 可以使用write代替send,  都属于往发送缓存区内写入数据
    14. read代替recv , 都属于往接收缓存区内提取数据

    测试注意：

    1. 如果使用客户端软件进行连接，必须保证windows和虚拟机在同一个局域网（桥接），并能互相ping通。服务器的IP地址必须指定为虚拟机自己的IP。

    2. 必须保证客户端正常退出后在关闭服务器程序，在客户端连接状态情况下强制关闭服务器程序，下次启动服务器程序后会提示bind err。这是因为没有正常释放绑定的端口，等1~2分钟就可以了。

    3、代码优化

    1。端口和ip地址通过命令行传参到代码中。(如果参数不一致,应该提示并退出)
    2。服务器端IP地址可由“0.0.0.0”自动获取，或者由宏定义自动获取

    3。客户端发送去掉fgets获取的多余的'\n'.

    fgets(实际读到的内容小于等于指定个数-1,自动读到的内容后添加’\0’,会将’\n’也读入)

      if(buf[strlen(buf)-1] == '\n')//去掉fgets获取的'\n'

             buf[strlen(buf)-1] ='\0';

    4.设置来电显示功能，获取到请求链接服务器的客户端的ip和端口。

     int acceptfd = accept(sockfd,(struct sockaddr *)&caddr,&len);

    打印时记得使用 inet_ntoa()和ntohs()转换为主机字节序

    printf("client ip:%s ,port:%d\n", inet_ntoa(saddr.sin_addr),ntohs(saddr.sin_port));

    5、当客户端输入quit的时候,客户端退出

       strncmp

    6.实现循环服务器，服务器不退出，当链接服务器的客户端退出，服务器等到下一个客户端链接。

      accept处使用while到接受数据结束。

    1. /*服务器创建代码 */
    2. #include <stdio.h>
    3. #include <sys/types.h> /* See NOTES */
    4. #include <sys/socket.h>
    5. #include <netinet/in.h>
    6. #include <netinet/ip.h> /* superset of previous */
    7. #include <arpa/inet.h>
    8. #include <unistd.h>
    9. #include <stdlib.h>
    10. #include <string.h>
    11. int main(int argc, char const *argv[])
    12. {
    13.     if (argc < 2)
    14.     {
    15.         printf("plase input \n");
    16.         return -1;
    17.     }
    18.     //1.创建套接字,用于链接
    19.     int sockfd;
    20.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    21.     if (sockfd < 0)
    22.     {
    23.         perror("socket err");
    24.         return -1;
    25.     }
    26.     //文件描述符 0 -> 标准输入  1->标准输出  2->标准出错  3->socket
    27.     printf("sockfd:%d\n", sockfd);
    28.  
    29.     //2.绑定 ip+port 填充结构体
    30.     struct sockaddr_in saddr;
    31.     saddr.sin_family = AF_INET;            //协议族ipv4
    32.     saddr.sin_port = htons(atoi(argv[1])); //端口号,htons将无符号短整数hostshort从主机字节顺序到网络字节顺序。
    33. //atoi(),字符串转整型
    34. //saddr.sin_addr.s_addr = inet_addr(argv[1]);//ip地址,转化为16进制表示
    35. #if 0
    36.     saddr.sin_addr.s_addr = inet_addr("0.0.0.0");//ip地址,转化为16进制表示
    37. #else
    38.     saddr.sin_addr.s_addr = INADDR_ANY;
    39. #endif
    40.     socklen_t len = sizeof(saddr); //结构体大小
    41.     //bind绑定ip和端口
    42.     if (bind(sockfd, (struct sockaddr *)&saddr, len) < 0)
    43.     {
    44.         perror("bind err");
    45.         return -1;
    46.     }
    47.     printf("bind success\n");
    48.     //3.启动监听,把主动套接子变为被动套接字
    49.     if (listen(sockfd, 6) < 0)
    50.     {
    51.         perror("listen err");
    52.         return -1;
    53.     }
    54.     printf("listen success\n");
    55.     //4.阻塞等待客户端的链接请求
    56.     int acceptfd;
    57.     // acceptfd = accept(sockfd,NULL,NULL);
    58.     while (1)
    59.     {
    60.         acceptfd = accept(sockfd, (struct sockaddr *)&saddr, &len);
    61.         //获取客户端的ip和端口,(struct sockaddr *)&saddr:用来存放返回的ip,和端口
    62.         if (acceptfd < 0)
    63.         {
    64.             perror("accept err");
    65.             return -1;
    66.         }
    67.         printf("client ip:%s ,port:%d\n", inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
    68.         printf("connect success\n");
    69.     //5.接收数据
    70.     char buf[64];
    71.     int ret;
    72.     while (1)
    73.     {
    74.         ret = recv(acceptfd, buf, sizeof(buf), 0);
    75.         if (strncmp(buf, "quit", 4) == 0) //接收到quit退出
    76.         {
    77.             break;
    78.         }
    79.         if (ret < 0)
    80.         {
    81.             perror("recv err.");
    82.             return -1;
    83.         }
    84.         else if (ret == 0) //客户端退出
    85.         {
    86.             printf("client exit\n");
    87.             break;
    88.         }
    89.         else
    90.         {
    91.             printf("buf:%s\n", buf);
    92.         }
    93.     }
    94.     }
    95.     close(sockfd);
    96.     close(acceptfd);
    97.     return 0;
    98. }
    99.  

    1. /*客户端创建代码 */
    2. #include <stdio.h>
    3. #include <sys/types.h> /* See NOTES */
    4. #include <sys/socket.h>
    5. #include <netinet/in.h>
    6. #include <netinet/ip.h> /* superset of previous */
    7. #include <arpa/inet.h>
    8. #include <unistd.h>
    9. #include <stdlib.h>
    10. #include <string.h>
    11. int main(int argc, char const *argv[])
    12. {
    13.     if (argc < 3)
    14.     {
    15.         printf("plase input \n");
    16.         return -1;
    17.     }
    18.     //1.创建套接字,用于链接
    19.     int sockfd;
    20.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    21.     if (sockfd < 0)
    22.     {
    23.         perror("socket err");
    24.         return -1;
    25.     }
    26.     //文件描述符 0 -> 标准输入  1->标准输出  2->标准出错  3->socket
    27.     printf("sockfd:%d\n", sockfd);
    28.     //2.绑定 ip+port 填充结构体
    29.     struct sockaddr_in saddr;
    30.     saddr.sin_family = AF_INET;                 //协议族ipv4
    31.     saddr.sin_port = htons(atoi(argv[2]));      //端口号,htons将无符号短整数hostshort从主机字节顺序到网络字节顺序。
    32.     saddr.sin_addr.s_addr = inet_addr(argv[1]); //ip地址,转化为16进制表示
    33.     socklen_t len = sizeof(saddr);              //结构体大小
    34.     //3用于连接服务器；
    35.     if (connect(sockfd, (struct sockaddr *)&saddr, len) < 0)
    36.     {
    37.         perror("connect err");
    38.         return -1;
    39.     }
    40.     //4发送信息
    41.     char buf[64] = {0};
    42.     while (1)
    43.     {
    44.         fgets(buf, sizeof(buf), stdin);   //从终端获取内容存放到数组中
    45.         if (strncmp(buf, "quit", 4) == 0) //输入quit退出客户端
    46.         {
    47.             break;
    48.         }
    49.         if (buf[strlen(buf)] == '\0')
    50.         {
    51.             buf[strlen(buf) - 1] = '\0';
    52.         }                                  //将fgets自动补的\n去掉
    53.         send(sockfd, buf, sizeof(buf), 0); //将数组中的内容发送到主机端
    54.     }
    55.     close(sockfd);
    56.     // close()
    57.     return 0;
    58. }
    59.

    ftp文件传输协议

    tcp实现ftp功能：

    模拟FTP核心原理：客户端连接服务器后，向服务器发送一个文件。文件名可以通过参数指定，服务器端接收客户端传来的文件（文件名随意），如果文件不存在自动创建文件，如果文件存在，那么清空文件然后写入。

    项目功能介绍：

    均有服务器和客户端代码，基于TCP写的。

    在同一路径下，将客户端可执行代码复制到其他的路径下，接下来再不同的路径下运行服务器和客户端。

    相当于另外一台电脑在访问服务器。

    客户端和服务器链接成功后出现以下提示：四个功能

    ***************list**************//列出服务器所在目录下的文件名(除目录不显示)

    ***********put filename**********//客户端给服务器上传一个文件

    ***********get filename**********//客户端从服务器所在路径下载文件

    **************quit***************//退出(可只退出客户端，服务器等待下一个客户端链接)

    //读文件，读到最后一次，最后再发送end

    //粘包：1.延时 2.读多少发多少

    服务器

    1. 搭建tcp框架
    2. 服务器接收消息

    //list 列出服务器所在目录下的文件名 目录操作 文件属性获取--发送给客户端

    //put filename //接收文件 recv --》新建文件---》 写文件 

    //get filename //读文件--》发送给客户端

    //quit  while(1)accpet;

    客户端

    1. 搭建tcp框架
    2. 列出功能
    3. 给服务器发消息

    //list 接收--》列出服务器所在目录下的文件名

    //put filename 找到文件--》读文件   -》发送

    //get filename //接收文件 recv --》新建文件---》 写文件 

    //quit   

  • 相关阅读:
    计算机网络_04_传输层
    Godot信号教程（使用C#语言）| 创建自定义信号 | 发出自定义信号 | 使用代码监听信号
    小白能看懂的CyberRT学习笔记
    WWDC24 快速回顾
    Python-基于Django的新生入学管理系统
    用于独立系统应用的光伏MPPT铅酸电池充电控制器建模（Simulink实现）
    云计算中的关键技术——虚拟化
    Python&JS宏 实现保留样式合并表格后拆分
    显示相关
    16.Hystrix 实例（springcloud）
  • 原文地址：https://blog.csdn.net/m0_74937538/article/details/134238772