TCP/IP协议的工作原理

image.png

Socket

socket的主要类型有两种，数据流套接字(Stream Sockets)和数据报套接字(Datagram Sockets)两种。
数据流套接字 TCP 可靠传高
数据报套接字 UDP 可靠性低，传输经济

image.png

TCP

服务器端

端口说明及端口复用

端口号加协议标识一个“唯一端口”，TCP/IP协议的3000端口和HTTP协议的3000端口，并不会冲突，但是如果同时打开相同协议相同端口的“端口监听”时，就会端口冲突了

1.一个应用程序只能绑定一个端口(一个套接字只能绑定一个端口)
2.UDP端口和TCP端口 虽然端口号相同，但是是不同的端口
3.病毒端口复用，是先断开原来的端口，然后自己连接上去，然后是自己的数据就自己处理不是自己的就分发给其他程序
4.可以多个线程同时receive(接收)你绑定的套接字，共享你绑定的套接字
5.设置端口复用
SO_REUSEADDR可以用在以下4种情况下
5.1 当有一个socket1处于TIME_WAIT状态时，而你启动的程序socket2需要用到该地址和端口，你的程序可以用到此项。
5.2 SO_REUSEADDR允许同一个port上启动同一服务的多个实例(多个进程)。但每个实例绑定的ip地址不能相同。有多块网卡或用IP Alias技术的机器可以测试这种情况。
5.3 SO_REUSEADDR允许单个进程绑定相同的端口到多个socket上，但每个socket绑定的ip地址不同，这和5.2很相似，区别请看UNPv1
5.4 SO_REUSEADDR允许完全相同的地址和端口绑定，但这只用于UDP的多播，不能用于TCP。
注意：设置端口复用函数要在绑定之前调用，而且只要绑定到同一个端口的所有套接字都得设置复用。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <netinet/in.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  11. /**服务器监听端口号*/
  12. #define SERV_PORT 3000
  13. /**请求队列长度*/
  14. #define LENGTH 10
  15. /**缓冲区长度*/
  16. #define SIZE 128
  19. int main(int argc, char **argv)
  20. {
  21.   int res;
  22.   int sockfd;
  23.   int clientfd;
  25.   struct sockaddr_in hostAddr;
  26.   struct sockaddr_in clientAddr;
  27.   unsigned int addrLen;
  28.   char buf[SIZE];
  29.   int cnt;
  31.   sockfd = socket(AF_INET, SOCK_STREAM, 0);
  32.   if (sockfd == -1) {
  33.     perror("套接字创建失败");
  34.     exit(1);
  35.   }
  37.   /**套接字与IP端口绑定*/
  38.   hostAddr.sin_family = AF_INET; /**TCP/IP协议*/
  39.   hostAddr.sin_port = SERV_PORT; // htons(SERV_PORT); /**让系统使用一个未被占用的端口号*/
  40.   hostAddr.sin_addr.s_addr = INADDR_ANY; /**本机IP地址*/
  41.   bzero(&(hostAddr.sin_zero), 8); /**清零*/
  42.   res = bind(sockfd, (struct sockaddr *)&hostAddr, sizeof(struct sockaddr));
  44.   if (res == -1) {
  45.     perror("套接字绑定失败");
  46.     exit(1);
  47.   }
  49.   /**将套接字设为监听模式，以等待连接请求*/
  50.   res = listen(sockfd, LENGTH);
  51.   if (res == -1) {
  52.     perror("设置监听模式失败");
  53.     exit(1);
  54.   }
  56.   printf("服务器IP：%s\n", inet_ntoa(hostAddr.sin_addr));
  57.   printf("服务器端口号：%d\n", hostAddr.sin_port);
  58.   printf("等待客户端请求连接。\n");
  59.   // 请求到来后，接受连接请求，并接收数据
  60.   while(1) {
  61.     addrLen = sizeof(struct sockaddr_in);
  62.     clientfd = accept(sockfd, (struct sockaddr *) &clientAddr, &addrLen);
  63.     if (clientfd == -1) {
  64.       perror("接受连接请求错误");
  65.       continue;
  66.     }
  67.     printf("客户端IP：%s\n", inet_ntoa(clientAddr.sin_addr));
  68.     cnt = recv(clientfd, buf, SIZE, 0);
  69.     if (cnt == -1) {
  70.       perror("数据接收失败");
  71.       exit(1);
  72.     }
  74.     printf("收到数据：%s\n", buf);
  75.     close(clientfd);
  76.   }
  79.   return 0;
  80. }

服务器端并发—多开子线程处理

注意：上面的代码以及下面的代码，使用的都是堵塞方式的套接字，使用堵塞方式的套接字，进程的效率比较低，尤其是在读写操作时，我们可以使用fcntl()或ioctl()函数来改变套接字的属性，将其设置为无堵塞方式。

在无堵塞方式下，进程调用recv，read，recvfrom函数从套接字缓冲区中读取内容时，如果缓冲区没有数据，函数立即返回，并设置相应错误码。同样写入时，send，write，sendto，如果缓冲区没有空闲空间，函数立即返回，并设置相应错误码。 将套接字设置为无阻塞模式，cpu可以通过轮询的方式同时处理多个套接字，但是这种方式会浪费大量CPU时间，从而降低系统的性能，Linux 提供了select()函数可以，有效解决这个问题。该函数用来将进程挂起，使系统内核去监听多个文件描述的状态变化，任何一个文件描述符上有时间发送时，进程都会被唤起，进而节省了CPU时间。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <netinet/in.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  11. /**服务器监听端口号*/
  12. #define SERV_PORT 3000
  13. /**请求队列长度*/
  14. #define LENGTH 10
  15. /**缓冲区长度*/
  16. #define SIZE 128
  18. int main(int argc, char **argv)
  19. {
  20.   int res;
  21.   int sockfd;
  22.   int clientfd;
  23.   int pth;
  25.   struct sockaddr_in hostAddr;
  26.   struct sockaddr_in clientAddr;
  27.   unsigned int addrLen;
  28.   char buf[SIZE];
  29.   int cnt;
  31.   sockfd = socket(AF_INET, SOCK_STREAM, 0);
  32.   if (sockfd == -1)
  33.   {
  34.     perror("套接字创建失败");
  35.     exit(1);
  36.   }
  38.   /**套接字与IP端口绑定*/
  39.   hostAddr.sin_family = AF_INET;         /**TCP/IP协议*/
  40.   hostAddr.sin_port = SERV_PORT;         // htons(SERV_PORT); /**让系统使用一个未被占用的端口号*/
  41.   hostAddr.sin_addr.s_addr = INADDR_ANY; /**本机IP地址*/
  42.   bzero(&(hostAddr.sin_zero), 8);        /**清零*/
  43.   res = bind(sockfd, (struct sockaddr *)&hostAddr, sizeof(struct sockaddr));
  45.   if (res == -1)
  46.   {
  47.     perror("套接字绑定失败");
  48.     exit(1);
  49.   }
  51.   /**将套接字设为监听模式，以等待连接请求*/
  52.   res = listen(sockfd, LENGTH);
  53.   if (res == -1)
  54.   {
  55.     perror("设置监听模式失败");
  56.     exit(1);
  57.   }
  59.   printf("服务器IP：%s\n", inet_ntoa(hostAddr.sin_addr));
  60.   printf("服务器端口号：%d\n", hostAddr.sin_port);
  61.   printf("等待客户端请求连接。\n");
  62.   // 请求到来后，接受连接请求，并接收数据
  63.   while (1)
  64.   {
  65.     addrLen = sizeof(struct sockaddr_in);
  66.     clientfd = accept(sockfd, (struct sockaddr *)&clientAddr, &addrLen);
  67.     if (clientfd == -1)
  68.     {
  69.       perror("接受连接请求错误");
  70.       continue;
  71.     }
  73.     pth = fork();
  74.     if (pth == -1) {
  75.       perror("进程创建失败");
  76.       exit(1);
  77.     }
  79.     if (pth == 0) {
  80.       close(sockfd); // 关闭父进程套接字
  81.       printf("客户端IP：%s\n", inet_ntoa(clientAddr.sin_addr));
  82.       cnt = recv(clientfd, buf, SIZE, 0);
  83.       if (cnt == -1)
  84.       {
  85.         perror("数据接收失败");
  86.         exit(1);
  87.       }
  88.       printf("收到数据：%s\n", buf);
  89.       sleep(5);
  91.       close(clientfd);
  92.       exit(0);
  93.     }
  95.     /**父亲进程关闭子进程套接字*/
  96.     close(clientfd);
  97.   }
  99.   return 0;
  100. }

客户端

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <netinet/in.h>
  8. #include <sys/socket.h>
  10. /**服务器监听端口号*/
  11. #define SERV_PORT 3000
  12. /**请求队列长度*/
  13. #define LENGTH 10
  14. /**缓冲区长度*/
  15. #define SIZE 128
  17. int main(int argc, char **argv)
  18. {
  19.   int res;
  20.   int sockfd;
  22.   struct sockaddr_in hostAddr;
  23.   char buf[SIZE];
  24.   int cnt;
  26.   if (argc != 2) {
  27.     perror("参数错误");
  28.     exit(1);
  29.   }
  31.   sockfd = socket(AF_INET, SOCK_STREAM, 0);
  32.   if (sockfd == -1) {
  33.     perror("套接字创建失败");
  34.     exit(1);
  35.   }
  37.   /**套接字与IP端口绑定*/
  38.   hostAddr.sin_family = AF_INET;         /**TCP/IP协议*/
  39.   hostAddr.sin_port = SERV_PORT;         // htons(SERV_PORT); /**让系统使用一个未被占用的端口号*/
  40.   hostAddr.sin_addr.s_addr = INADDR_ANY; /**本机IP地址*/
  41.   bzero(&(hostAddr.sin_zero), 8);        /**清零*/
  43.   res = connect(sockfd, (struct sockaddr *)&hostAddr, sizeof(struct sockaddr));
  45.   if (res == -1)
  46.   {
  47.     perror("连接失败");
  48.     exit(1);
  49.   }
  51.   strcpy(buf, argv[1]);
  52.   cnt = send(sockfd, buf, SIZE, 0);
  53.   if (cnt == -1) {
  54.     perror("发送数据失败");
  55.     exit(1);
  56.   }
  58.   printf("发送数据：%s\n", buf);
  59.   close(sockfd);
  61.   return 0;
  62. }

UDP

服务器端

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <netinet/in.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  11. /**服务器监听端口号*/
  12. #define SERV_PORT 3000
  13. /**请求队列长度*/
  14. #define LENGTH 10
  15. /**缓冲区长度*/
  16. #define SIZE 128
  18. int main(int argc, char **argv)
  19. {
  20.   int res;
  21.   int sockfd;
  22.   int clientfd;
  24.   struct sockaddr_in hostAddr;
  25.   struct sockaddr_in clientAddr;
  26.   unsigned int addrLen;
  27.   char buf[SIZE];
  28.   int cnt;
  30.   sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  31.   if (sockfd == -1) {
  32.     perror("套接字创建失败");
  33.     exit(1);
  34.   }
  36.   /**套接字与IP端口绑定*/
  37.   hostAddr.sin_family = AF_INET; /**TCP/IP协议*/
  38.   hostAddr.sin_port = SERV_PORT; // htons(SERV_PORT); /**让系统使用一个未被占用的端口号*/
  39.   hostAddr.sin_addr.s_addr = INADDR_ANY; /**本机IP地址*/
  40.   bzero(&(hostAddr.sin_zero), 8); /**清零*/
  42.   res = bind(sockfd, (struct sockaddr *)&hostAddr, sizeof(struct sockaddr));
  44.   if (res == -1) {
  45.     perror("套接字绑定失败");
  46.     exit(1);
  47.   }
  49.   printf("服务器IP：%s\n", inet_ntoa(hostAddr.sin_addr));
  50.   printf("服务器端口号：%d\n", hostAddr.sin_port);
  51.   printf("等待客户端请求连接。\n");
  52.   // 请求到来后，接受连接请求，并接收数据
  53.   while(1) {
  54.     addrLen = sizeof(struct sockaddr_in);
  56.     cnt = recvfrom(sockfd, buf, SIZE, 0,
  57.       (struct sockaddr *)&clientAddr, &addrLen
  58.     );
  60.     if (cnt == -1) {
  61.       perror("数据接收失败");
  62.       exit(1);
  63.     }
  65.     printf("客户端IP：%s\n", inet_ntoa(clientAddr.sin_addr));
  67.     printf("收到数据：%s\n", buf);
  68.   }
  69.   close(clientfd);
  71.   return 0;
  72. }

客户端

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <netinet/in.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  11. /**服务器监听端口号*/
  12. #define SERV_PORT 3000
  13. /**请求队列长度*/
  14. #define LENGTH 10
  15. /**缓冲区长度*/
  16. #define SIZE 128
  18. int main(int argc, char **argv)
  19. {
  20.   int res;
  21.   int sockfd;
  23.   struct sockaddr_in hostAddr;
  24.   unsigned int addrLen;
  25.   char buf[SIZE];
  26.   int cnt;
  28.   if (argc != 3) {
  29.     perror("参数错误");
  30.     exit(1);
  31.   }
  33.   sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  34.   if (sockfd == -1) {
  35.     perror("套接字创建失败");
  36.     exit(1);
  37.   }
  39.   /**套接字与IP端口绑定*/
  40.   hostAddr.sin_family = AF_INET;         /**TCP/IP协议*/
  41.   hostAddr.sin_port = SERV_PORT;         // htons(SERV_PORT); /**让系统使用一个未被占用的端口号*/
  42.   hostAddr.sin_addr.s_addr = inet_addr(argv[1]); // INADDR_ANY; /**本机IP地址*/
  43.   bzero(&(hostAddr.sin_zero), 8);           /**清零*/
  45.   addrLen = sizeof(struct sockaddr_in);
  46.   strcpy(buf, argv[2]);
  47.   cnt = sendto(sockfd, buf, SIZE, 0,
  48.     (struct sockaddr *)&hostAddr, addrLen
  49.   );
  50.   if (cnt == -1) {
  51.     perror("发送数据失败");
  52.     exit(1);
  53.   }
  55.   printf("发送数据：%s\n", buf);
  56.   close(sockfd);
  58.   return 0;
  59. }

域名系统

通过域名获取主机信息
通过地址获取主机信息
获取本地主机信息

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <netinet/in.h>
  6. #include <sys/socket.h>
  7. #include <arpa/inet.h>
  8. #include <netdb.h>
  10. /**uname函数*/
  11. #include <sys/utsname.h>
  13. int main(int argc, char **argv)
  14. {
  15.   struct sockaddr_in addr;
  16.   struct hostent *host;
  17.   struct hostent *webHost;
  18.   if (argc != 2) {
  19.     printf("参数错误");
  20.     exit(1);
  21.   }
  23.   char domainName[] = "www.baidu.com";
  24.   webHost = gethostbyname((char *) &domainName);
  25.   printf("webHost.h_name=%s\n", webHost->h_name);
  26.   printf("webHost.h_aliases=%s\n", *webHost->h_aliases);
  28.   /**将ip地址由字符串转换为二进制形式*/
  29.   inet_aton(argv[1], &addr.sin_addr);
  30.   /**查找IP对应的主机信息*/
  31.   host = gethostbyaddr((char *)&addr.sin_addr, 4, AF_INET);
  33.   printf("host=%s\n", host->h_name);
  35.   char name[128];
  36.   /**获取本地主机信息，gethostname函数调用成功返回0，否则返回-1*/
  37.   gethostname((char *)&name, sizeof(name));
  38.   printf("name=%s\n", name);
  40.   struct utsname utsName;
  42.   uname((struct utsname *)&utsName);
  44.   printf("sysname=%s\n", utsName.sysname);
  45.   printf("nodename=%s\n", utsName.nodename);
  46.   printf("release=%s\n", utsName.release);
  47.   printf("version=%s\n", utsName.version);
  48.   printf("machine=%s\n", utsName.machine);
  50.   return 0;
  51. }