devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

UNIX高级编程【深入浅出】 网络编程 UDP/TCP_unix udp抓包指令

作者：繁依Fanyi0 | 2024-02-28 12:13:18

赞

踩

unix udp抓包指令

 

目录

UDP

创建 UDP 套接字

server端

client端(主动端)

示例代码

需要注意的是

UDP支持组播（群发）

示例代码（组播）

UDP支持广播

TCP

创建 TCP 套接字

server(被动端)

client(主动端)

示例代码

需要注意的是

三次握手与四次挥手

创建连接的三次握手过程

连接断开四次挥手过程

IO多路复用在TCP服务器中的应用

示例代码

UDP与TCP 协议格式​

  1. UDP

    1. SOCK_DGRAM报式套接字
      1. 全双工，无连接，不可靠(这不是缺点)
      2. 传输协议就是UDP
      3. 收发两端，通常client和server端

    2. 创建 UDP 套接字

      1. server端
        1. socket(2)创建报式套接字
        2. connect(2) / listen(2) / accept(2)都是与连接相关的，所有报式套接字都用不到
        3. 被动端，准备好接受包的条件
          1. bind(2)地址
        4. recvfrom(2)接受数据包(得到对端地址)
        5. close(2)关闭套接字
      1. client端(主动端)
        1. socket(2)创建报式套接字
        2. 主动端，第一个动作式发送数据包
          1. bind(2)可以省略的，如果省略了内核会为进程bind一个空闲的地址
        3. sendto(2)发送数据包
        4. close(2)关闭套接字
      2. server和client需要遵循相同的协议
        1. server的地址（ip+port）
        2. 数据格式(数据类型)
  2. 示例代码
    1. #ifndef __PORT_H__
    2. #define __PORT_H__
    3.  
    4. #include <stdint.h>
    5. #define SERVERIP "x.x.x.x"
    6. #define SERVERPORT 1999
    7. #define MSGSIZE 1024
    8.  
    9. #define handler_error(msg)\
    10. 			do {perror(msg); exit(EXIT_FAILURE);} while(0)
    11. struct __msg{
    12. 	int8_t id;
    13. 	char msg[MSGSIZE];
    14. }__attribute__((packed));
    15.  
    16. typedef struct __msg msg_t;
    17.  
    18.  
    19.  
    20. #endif
    1. // Date:2023.09.14 19:51:14
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <unistd.h>
    5. #include <sys/types.h>          
    6. #include <sys/socket.h>
    7. #include <arpa/inet.h>
    8. #include <netinet/in.h>
    9. #include <netinet/ip.h>
    10. #include <string.h>
    11. #include "port.h"
    12. /* 客户端 */
    13. int main(int argc, char *argv[])
    14. {
    15. 	int cnt;
    16. 	int udp_socket;
    17. 	struct sockaddr_in addr_in;
    18. 	msg_t sendbuf;
    19. 	socklen_t addr_len;
    20.  
    21.     if (argc < 3)
    22. 		exit(1);
    23.  
    24.     // 创建报式套接子
    25.     if(-1 == (udp_socket = socket(AF_INET, SOCK_DGRAM, 0)))
    26. 		handler_error("socket()");
    27.  
    28.     // bind可省略
    29.  
    30. 	// 发送的数据
    31. 	sendbuf.id = atoi(argv[1]);
    32. 	strncpy(sendbuf.msg, argv[2], MSGSIZE);
    33.     // server地址
    34.     addr_in.sin_family = AF_INET;
    35. 	addr_in.sin_port = htons(SERVERPORT);
    36. 	addr_in.sin_addr.s_addr = inet_addr(SERVERIP);
    37. 	//inet_aton(SERVERIP, &addr_in.sin_addr);
    38.  
    39. 	if(-1 == sendto(udp_socket, &sendbuf, sizeof(sendbuf.id)+strlen(sendbuf.msg)+1, 0,\
    40. 			   	(struct sockaddr *)&addr_in, sizeof(addr_in))){
    41. 		close(udp_socket); handler_error("sendto()");
    42. 	}
    43. 	memset(sendbuf.msg, '\0', MSGSIZE);
    44. 	if(-1 == recvfrom(udp_socket, &sendbuf, sizeof(sendbuf), 0, NULL, NULL)){
    45. 		close(udp_socket); handler_error("recvfrom()");
    46. 	}
    47.  
    48. 	// 请求后得到服务器反馈
    49. 	printf("%d , %s \n", sendbuf.id, sendbuf.msg);
    50.  
    51. 	close(udp_socket);
    52. 	
    53. 	return 0;
    54. }
    1. // Date:2023.09.14 19:51:14
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <unistd.h>
    5. #include <sys/types.h>          
    6. #include <sys/socket.h>
    7. #include <arpa/inet.h>
    8. #include <netinet/in.h>
    9. #include <netinet/ip.h>
    10. #include <string.h>
    11. #include "port.h"
    12. /* 服务端 */
    13. int main(void)
    14. {
    15. 	int cnt;
    16. 	int udp_socket;
    17. 	struct sockaddr_in addr_in, client_addr;
    18. 	msg_t rcvbuf;
    19. 	socklen_t client_addr_len;
    20.     if(-1 == (udp_socket = socket(AF_INET, SOCK_DGRAM, 0)))
    21. 		handler_error("socket()");
    22.     
    23.     // 绑定地址
    24. 	addr_in.sin_family = AF_INET;
    25. 	addr_in.sin_port = htons(SERVERPORT);
    26.     // 点分十进制ip转换为ip结构体
    27. 	//addr_in.sin_addr.s_addr = inet_addr(SERVERIP);
    28. 	inet_aton(SERVERIP, &addr_in.sin_addr);
    29. 	if(-1 == bind(udp_socket, (struct sockaddr *)&addr_in, sizeof(addr_in))){
    30. 		close(udp_socket); handler_error("bind()");
    31. 	}
    32.     // 接受client的数据包之前一定要将地址长度赋值
    33. 	client_addr_len = sizeof(struct sockaddr_in);
    34. 	
    35. 	while(1){
    36. 		// 等待接受客户端请求
    37. 		if(-1 == (cnt = recvfrom(udp_socket, &rcvbuf, sizeof(rcvbuf), 0, (struct sockaddr *)&client_addr, &client_addr_len))){
    38. 		close(udp_socket); handler_error("recvfrom()");
    39. 		}
    40.         // 调试语句
    41. 		printf("[%s][%d] ", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    42. 		printf("id:%d , msg: %s\n", rcvbuf.id, rcvbuf.msg);
    43.  
    44. 		// 向客户端发送数据
    45. 		rcvbuf.id = 0;
    46. 		strcpy(rcvbuf.msg, "ok");
    47. 		sendto(udp_socket, &rcvbuf, sizeof(rcvbuf.id) + strlen(rcvbuf.msg) + 1,0, (struct sockaddr *)&client_addr, client_addr_len);
    48.  
    49. 	}
    50. 	close(udp_socket);
    51. 	
    52. 	return 0;
    53. }
    需要注意的是

    1. 在编写 UDP 程序时，你需要关注数据包的大小、分片和重组、丢包处理等问题，因为 UDP 本身不提供这些功能。此外，UDP 也不提供拥塞控制，因此在高负载或不稳定的网络环境中，可能会导致丢包和延迟增加。

    1. UDP支持组播（群发）

      1. ipv4组播地址：224~239
      2. 组播就是套接字的选项，使能组播的功能，那么就需要将套接字的组播选项打开
        1. setsockopt(2)
        2. 套接字的选项在以下手册中均有:
          1. man 7 ip(组播选项)
          2. man 7 socket
          3. man 7 udp
          4. man 7 tcp
        3. 组播选项的级别（level）:IPPROTO_IP
        4. 组播选项的开关：大多数选项需要一个整型变量，如果值为1就是开启，值为0就是关闭
        5. 选项:
          1. IP_ADD_MEMBERSHIP 加入多播组
          2. IP_MULTICAST_IF 将本地设备用于多播
        6. 抓包器
          • wireshark
      3. 示例代码（组播）
  1. #ifndef __GROUP_PROTO_H__
  2. #define __GROUP_PROTO_H__
  3.  
  4. // 多播组 接受端口
  5. #define GROUP_IP	"224.2.3.4"
  6. #define RCV_PORT	1314
  7.  
  8. // 数据类型
  9. #define MAX_MSG	1024
  10.  
  11. #endif
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <netinet/ip.h>
  6. #include <arpa/inet.h>
  7. #include <net/if.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include "group_proto.h"
  11. /* 客户端 */ 
  12. int main(void)
  13. {
  14. 	int udp_socket;
  15. 	struct sockaddr_in myaddr; // man 7 ip
  16. 	struct ip_mreqn imr;
  17. 	char *buf = NULL;
  18. 	int cnt;
  19.  
  20. 	udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
  21. 	if (-1 == udp_socket) {
  22. 		perror("socket()");
  23. 		exit(1);
  24. 	}
  25.  
  26. 	// 被动端需要bind地址
  27. 	myaddr.sin_family = AF_INET;
  28. 	myaddr.sin_port = htons(RCV_PORT);
  29. 	inet_aton("0.0.0.0"/*INADDR_ANY*/, &myaddr.sin_addr);
  30. 	if (-1 == bind(udp_socket, (struct sockaddr *)&myaddr, sizeof(myaddr))) {
  31. 		perror("bind()");
  32. 		goto ERROR1;
  33. 	}
  34.  
  35. 	// 加入多播组
  36. 	inet_aton(GROUP_IP, &imr.imr_multiaddr);
  37. 	// 注意INADDR_ANY不是字符串，是uint32_t整型数
  38. 	inet_aton("0.0.0.0", &imr.imr_address);
  39. 	// 虚拟网卡的索引值，索引名转换为值if_nametoindex(3)
  40. 	imr.imr_ifindex = if_nametoindex("ens33");
  41. 	if (-1 == setsockopt(udp_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(imr))) {
  42. 		perror("setsockopt()");
  43. 		goto ERROR1;
  44. 	}
  45.  
  46. 	// 接受消息
  47. 	buf = malloc(MAX_MSG);
  48. 	// if error
  49. 	while (1) {
  50. 		memset(buf, '\0', MAX_MSG);
  51. 		cnt = recvfrom(udp_socket, buf, MAX_MSG, 0, NULL, NULL);
  52. 		if (-1 == cnt) {
  53. 			perror("recvfrom()");
  54. 			goto ERROR1;
  55. 		}
  56. 		if (strcmp(buf, "bye") == 0)
  57. 			break;
  58. 		puts(buf);
  59. 	}
  60.  
  61. 	close(udp_socket);
  62. 	free(buf);
  63. 	buf = NULL;
  64.  
  65. 	exit(0);
  66. ERROR1:
  67. 	close(udp_socket);
  68. 	exit(1);
  69. }
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <netinet/ip.h>
  6. #include <arpa/inet.h>
  7. #include <net/if.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include "group_proto.h"
  11. /* 服务端 */
  12. int main(void)
  13. {
  14. 	int udp_socket;
  15. 	struct sockaddr_in snd_addr; // man 7 ip
  16. 	struct ip_mreqn imr;
  17.  
  18. 	udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
  19. 	if (-1 == udp_socket) {
  20. 		perror("socket()");
  21. 		exit(1);
  22. 	}
  23.  
  24. 	// 将本地设备设置为多播
  25. 	inet_aton(GROUP_IP, &imr.imr_multiaddr);
  26. 	imr.imr_address.s_addr = INADDR_ANY;
  27. 	// inet_aton("0.0.0.0", &imr.imr_address);
  28. 	// 虚拟网卡的索引值，索引名转换为值if_nametoindex(3)
  29. 	imr.imr_ifindex = if_nametoindex("ens33");
  30. 	if (-1 == setsockopt(udp_socket, IPPROTO_IP, IP_MULTICAST_IF, &imr, sizeof(imr))) {
  31. 		perror("setsockopt()");
  32. 		goto ERROR1;
  33. 	}
  34. 	printf("[%d]debug...\n", __LINE__);
  35.  
  36. 	// 发送消息
  37. 	snd_addr.sin_family = AF_INET;
  38. 	snd_addr.sin_port = htons(RCV_PORT);
  39. 	inet_aton(GROUP_IP, &snd_addr.sin_addr);
  40. 	while (1) {
  41. 		sendto(udp_socket, "hello", 5, 0, (struct sockaddr *)&snd_addr, sizeof(snd_addr));	
  42. 		sleep(1);
  43. 	}
  44.  
  45. 	close(udp_socket);
  46.  
  47. 	exit(0);
  48. ERROR1:
  49. 	close(udp_socket);
  50. 	exit(1);
  51. }

  1. UDP支持广播

    1. 广播选项man 7 socket
      1. SO_BROADCAST
    2. 广播选项级别:SOL_SOCKET
    3. 广播地址
      1. "255.255.255.255"全网广播

  2. TCP

    1. TCP套接字
      1. man 7 tcp
      2. 流式套接字
      3. 特点：
        1. 基于连接的，可靠传输

    2. 创建 TCP 套接字

      1. server(被动端)
        1. socket(2)创建流式套接字
        2. bind(2)地址
        3. listen(2)使套接字处于监听状态
        4. accept(2)等待接受对端的连接请求
        5. read(2) / write(2)收发消息 send(2) / recv(2)也可以
        6. close(2)关闭套接字
      2. client(主动端)
        1. socket(2)创建流式套接字
        2. connect(2)请求与服务器连接
        3. read(2) / write(2)收发消息 send(2) / recv(2)也可以
        4. close(2);
    3. 示例代码
      1. #ifndef __TCP_PROT_H__
      2. #define __TCP_PROT_H__
      3.  
      4. // server地址(ip + port)
      5. #define SERVER_IP	"x.x.x.x"
      6. #define SERVER_PORT	3344
      7.  
      8. // 对话格式(数据类型)
      9. #define MAXMSG	1024
      10.  
      11. struct msg_st {
      12. 	char msg[MAXMSG];
      13. }__attribute__((packed));
      14.  
      15. #endif
      1. #include <stdio.h>
      2. #include <string.h>
      3. #include <sys/socket.h>
      4. #include <netinet/in.h>
      5. #include <netinet/ip.h>
      6. #include <stdlib.h>
      7. #include <arpa/inet.h>
      8. #include <unistd.h>
      9.  
      10. #include "tcp_proto.h"
      11. /* 客户端 */
      12. int main(void)
      13. {
      14. 	int tcp_socket;
      15. 	struct sockaddr_in server_addr;
      16. 	struct msg_st rcvbuf;
      17. 	int cnt;
      18.  
      19. 	// 创建流式套接字
      20. 	tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
      21. 	if (-1 == tcp_socket) {
      22. 		perror("socket()");
      23. 		exit(1);
      24. 	}
      25.  
      26. 	// 请求与服务器连接
      27. 	server_addr.sin_family = AF_INET;
      28. 	server_addr.sin_port = htons(SERVER_PORT);
      29. 	inet_aton(SERVER_IP, &server_addr.sin_addr);
      30. 	if (-1 == connect(tcp_socket, (struct sockaddr *)&server_addr, sizeof(server_addr))) {
      31. 		perror("connect()");
      32. 		goto ERROR;
      33. 	}
      34.  
      35. 	// 接受
      36. 	memset(rcvbuf.msg, '\0', MAXMSG);
      37. 	cnt = read(tcp_socket, &rcvbuf, MAXMSG);
      38. 	printf("from server rcv msg:%s with %dbytes\n", rcvbuf.msg, cnt);
      39.  
      40. 	close(tcp_socket);
      41.  
      42. 	exit(0);
      43. ERROR:
      44. 	close(tcp_socket);
      45. 	exit(1);
      46. }
      1. #include <stdio.h>
      2. #include <sys/socket.h>
      3. #include <netinet/in.h>
      4. #include <netinet/ip.h>
      5. #include <stdlib.h>
      6. #include <arpa/inet.h>
      7. #include <unistd.h>
      8.  
      9. #include "tcp_proto.h"
      10. /* 服务端 */
      11. int main(void)
      12. {
      13. 	int tcp_socket, accepted_socket;
      14. 	struct sockaddr_in myaddr;
      15. 	pid_t pid;
      16.  
      17. 	// 创建流式套接字
      18. 	tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
      19. 	if (-1 == tcp_socket) {
      20. 		perror("socket()");
      21. 		exit(1);
      22. 	}
      23.  
      24. 	// 绑定本地地址
      25. 	myaddr.sin_family = AF_INET;
      26. 	myaddr.sin_port = htons(SERVER_PORT);
      27. 	myaddr.sin_addr.s_addr = INADDR_ANY;
      28. 	if (-1 == bind(tcp_socket, (struct sockaddr *)&myaddr, sizeof(myaddr))) {
      29. 		perror("bind()");
      30. 		goto ERROR;
      31. 	}
      32.  
      33. 	// 套接字处于监听状态
      34. 	if (-1 == listen(tcp_socket, 200)) {
      35. 		perror("listen()");
      36. 		goto ERROR;
      37. 	}
      38.  
      39. 	// sigaction(SIGCHLD, ); SA_NOCHLDWAIT
      40.  
      41. 	while (1) {
      42. 		// 等待接受客户端的连接请求
      43. 		accepted_socket = accept(tcp_socket, NULL, NULL);
      44. 		if (-1 == accepted_socket) {
      45. 			perror("accept()");
      46. 			goto ERROR;
      47. 		}
      48. 		// 成功后accepted_socket就是用于数据交换的套接字 原来的tcp_socket是用于继续接受客户端连接请求的
      49. 		pid = fork();
      50. 		if (-1 == pid) {
      51. 			perror("fork()");
      52. 			goto ERROR;
      53. 		}
      54. 		if (0 == pid) {
      55. 			// 数据交换 用accepted_socket
      56. 			close(tcp_socket);
      57. 			sleep(1);
      58. 			write(accepted_socket, "can you see that?", 17);
      59. 			close(accepted_socket);
      60. 			exit(0);
      61. 		}
      62. 		close(accepted_socket);
      63. 	}
      64.  
      65. 	close(tcp_socket);
      66.  
      67. 	exit(0);
      68. ERROR:
      69. 	close(tcp_socket);
      70. 	exit(1);
      71. }
  3. 需要注意的是
    1. TCP 提供了可靠的数据传输，包括数据的分段、重组、流量控制和拥塞控制机制。它确保数据按照正确的顺序到达目标，并通过确认机制检测和恢复丢失或损坏的数据。TCP 还实现了流量控制，以避免发送方过载和接收方缓冲区溢出，以及拥塞控制，以优化网络性能和公平共享带宽。
    2. TCP 提供了可靠的、面向连接的数据传输，适用于对数据完整性和可靠性要求较高的应用场景，如文件传输、网页浏览、电子邮件等

  4. 三次握手与四次挥手

    1. 创建连接的三次握手过程
      1. client向server发起连接请求(第一次握手)
        1. SYN置1， seq=x
      2. server收到了client发送的数据包后，会向client发送一个应答,同时发送一个序号(第二次握手)
        1. ACK=1, ack=x+1, seq=y
      3. client收到server的应答后，向server发送最后的应答(第三次握手)
        1. ACK=1, ack = y+1
      4. 即客户端发送连接请求、服务器响应连接请求并发送确认、客户端再次响应确认
  6. 连接断开四次挥手过程
    1. client向server发送请求断开的数据包(第一次挥手)
      1. FIN = 1, seq = m
    2. server收到了client请求断开的数据包后，会向client端发送应答(第二次挥手)
      1. ACK = 1, ack = m + 1
    3. 当server数据交换完成,也不需要通讯的时候，向client发送断开数据包(第三次挥手)
      1. FIN = 1,seq = n
    4. client最后向server发送应答(第四次挥手)
      1. ACK = 1, ack = n + 1
    5. 即客户端发送关闭连接请求、服务器确认关闭连接请求、服务器发送关闭连接请求、客户端确认关闭连接请求并关闭连接

  8. IO多路复用在TCP服务器中的应用

    1. tcp的服务器不是盲目的接收到链接就并发，而是使用select/poll监听到已连接的套接字可读再并发
    2. 对于套接字文件，有链接请求和有数据到达都是可读事件
    3. 当client端close套接字，则server端的套接字也是发生了可读事件，并且读到的数据是0.
  9. 示例代码
    1. #ifndef __TCP_PROT_H__
    2. #define __TCP_PROT_H__
    3.  
    4. // server地址(ip + port)
    5. #define SERVER_IP	"x.x.x.x"
    6. #define SERVER_PORT	3344
    7.  
    8. // 对话格式(数据类型)
    9. #define MAXMSG	1024
    10.  
    11. struct msg_st {
    12. 	char msg[MAXMSG];
    13. }__attribute__((packed));
    14.  
    15. #endif
    1. #include <stdio.h>
    2. #include <string.h>
    3. #include <sys/socket.h>
    4. #include <netinet/in.h>
    5. #include <netinet/ip.h>
    6. #include <stdlib.h>
    7. #include <arpa/inet.h>
    8. #include <unistd.h>
    9.  
    10. #include "tcp_proto.h"
    11. /* 客户端 */
    12. int main(void)
    13. {
    14. 	int tcp_socket;
    15. 	struct sockaddr_in server_addr;
    16. 	struct msg_st sndbuf;
    17. 	int cnt;
    18.  
    19. 	// 创建流式套接字
    20. 	tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
    21. 	if (-1 == tcp_socket) {
    22. 		perror("socket()");
    23. 		exit(1);
    24. 	}
    25.  
    26. 	// 请求与服务器连接
    27. 	server_addr.sin_family = AF_INET;
    28. 	server_addr.sin_port = htons(SERVER_PORT);
    29. 	inet_aton(SERVER_IP, &server_addr.sin_addr);
    30. 	if (-1 == connect(tcp_socket, (struct sockaddr *)&server_addr, sizeof(server_addr))) {
    31. 		perror("connect()");
    32. 		goto ERROR;
    33. 	}
    34.  
    35. 	// 接受
    36. 	memset(sndbuf.msg, '\0', MAXMSG);
    37. 	strncpy(sndbuf.msg, "this is a test", MAXMSG);
    38. 	write(tcp_socket, &sndbuf, MAXMSG);
    39.  
    40. 	sleep(2);
    41.  
    42. 	close(tcp_socket);
    43.  
    44. 	exit(0);
    45. ERROR:
    46. 	close(tcp_socket);
    47. 	exit(1);
    48. }
    1. #include <stdio.h>
    2. #include <errno.h>
    3. #include <string.h>
    4. #include <sys/socket.h>
    5. #include <netinet/in.h>
    6. #include <netinet/ip.h>
    7. #include <stdlib.h>
    8. #include <arpa/inet.h>
    9. #include <unistd.h>
    10. #include <poll.h>
    11. #include "tcp_proto.h"
    12. /* 服务端 */
    13. int main(void)
    14. {
    15. 	int tcp_socket, accepted_socket;
    16. 	struct sockaddr_in myaddr;
    17. 	pid_t pid;
    18. 	struct pollfd *pfd = NULL;
    19. 	int nfds = 0;
    20. 	struct msg_st rcvbuf;
    21. 	int i;
    22. 	int cnt;
    23.  
    24. 	// 创建流式套接字
    25. 	tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
    26. 	if (-1 == tcp_socket) {
    27. 		perror("socket()");
    28. 		exit(1);
    29. 	}
    30.  
    31. 	// 绑定本地地址
    32. 	myaddr.sin_family = AF_INET;
    33. 	myaddr.sin_port = htons(SERVER_PORT);
    34. 	myaddr.sin_addr.s_addr = INADDR_ANY;
    35. 	if (-1 == bind(tcp_socket, (struct sockaddr *)&myaddr, sizeof(myaddr))) {
    36. 		perror("bind()");
    37. 		goto ERROR;
    38. 	}
    39.  
    40. 	// 套接字处于监听状态
    41. 	if (-1 == listen(tcp_socket, 200)) {
    42. 		perror("listen()");
    43. 		goto ERROR;
    44. 	}
    45.  
    46. 	// 监听tcp_socket
    47. 	pfd = calloc(1, sizeof(struct pollfd));
    48. 	if (NULL == pfd) {
    49. 		perror("calloc()");
    50. 		goto ERROR;
    51. 	}
    52. 	pfd[0].fd = tcp_socket;
    53. 	pfd[0].events = POLLIN; // tcp_socket是否有连接 
    54. 	nfds = 1;
    55.  
    56. 	while (1) {
    57. 		if (-1 == poll(pfd, nfds, -1)) {
    58. 			if (errno == EINTR)
    59. 				continue; // 被信号打断
    60. 			perror("poll()");
    61. 			goto ERROR;
    62. 		}
    63. 		// 监听的事件发生了
    64. 		for (i = 0; i < nfds; i++) {
    65. 			if (i == 0) {
    66. 				if (pfd[0].fd == tcp_socket && pfd[0].revents & POLLIN) {
    67. 					// 套接字有连接到来了
    68. 					accepted_socket = accept(tcp_socket, NULL, NULL);
    69. 					if (-1 == accepted_socket) {
    70. 						perror("accept()");
    71. 						goto ERROR;
    72. 					}
    73. 					printf("**********client connected succefully************\n");
    74. 					// accepted_socket 就是将来用于数据交换的套接字
    75. 					// 如果可读了再读
    76. 					pfd = realloc(pfd, (nfds + 1) * sizeof(struct pollfd));
    77. 					// if error
    78. 					pfd[nfds].fd = accepted_socket;
    79. 					pfd[nfds].events = POLLIN; // 数据
    80. 					pfd[nfds].revents = 0;
    81. 					nfds ++;
    82. 				}
    83. 			} else {
    84. 				// 不是客户端的连接请求，而是有数据请求
    85. 				if (pfd[i].revents & POLLIN) {
    86. 					// 创建子进程/线程
    87. 					memset(rcvbuf.msg, '\0', MAXMSG);
    88. 					cnt = recv(pfd[i].fd, &rcvbuf, MAXMSG, 0);
    89. 					if (cnt == -1) {
    90. 						perror("recv()");
    91. 						goto ERROR;
    92. 					}
    93. 					if (cnt == 0) {
    94. 						// c端close()
    95. 						printf("***************888***************\n");
    96. 						close(pfd[i].fd);
    97. 						pfd[i].events = 0;
    98. 						memmove(pfd + i, pfd + i + 1, (nfds - (i + 1)) * sizeof(struct pollfd));
    99. 						nfds--;
    100. 						pfd = realloc(pfd, nfds * sizeof(struct pollfd));
    101. 						i--; // 下一次循环要执行i++
    102. 					} else {
    103. 						printf("!!!!!!!!!!!recv data!!!!!!!!!!!\n");
    104. 						// 接受到数据请求，处理请求
    105. 						// 暂且调试输出
    106. 						puts(rcvbuf.msg);
    107. 					}
    108. 				}
    109. 			}
    110. 		}
    111. 	}
    112.  
    113. 	close(tcp_socket);
    114.  
    115. 	exit(0);
    116. ERROR:
    117. 	close(tcp_socket);
    118. 	exit(1);
    119. }

UDP与TCP 协议格式

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/158761
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号