I/O复用的高级应用：同时处理 TCP 和 UDP 服务_用i/o复用模型同时支持tcp和udp的回射服务器。要求综合流式套接字和数据报套接字

1、I/O复用的另一用武之地：同时处理 TCP 和 UDP 服务

同一端口（或socket地址）既能接收UDP请求也能接收TCP请求。我们使用同一个socket地址创建两个 socket 文件描述符，分别用于处理该端口上的UDP和TCP请求。然后使用I/O复用技术同时监听这两个socket 文件描述符的事件，就可以实现同时处理一个端口上的 TCP 和 UDP 请求。

2、实例程序

下面是一个服务器程序，他能同时处理 TCP 和 UDP 服务。

/* 本程序实现一个同时处理 TCP 请求和 UDP 请求的回射服务器 */
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<unistd.h>
#include<stdio.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
#include<sys/epoll.h>
#include<pthread.h>
#include<errno.h>

#define MAX_EVENT_NUMBER 1024
#define TCP_BUFFER_SIZE 512
#define UDP_BUFFER_SIZE 1024

int setnonblocking(int fd)
{
	int old_option = fcntl(fd, F_GETFL);
	int new_option  = old_option | O_NONBLOCK;
	fcntl(fd, F_SETFL, new_option);
	return new_option;
}

void addfd(int epollfd, int fd)
{
	epoll_event event;
	event.data.fd = fd;
	event.events = EPOLLIN | EPOLLET;
	epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
	setnonblocking(fd);
}

int main(int argc, char* argv[])
{
	if (argc <= 2)
	{
		return 1;
	}
	const char* ip = argv[1];
	int port = atoi(argv[2]);

	struct sockaddr_in address;
	bzero(&address, sizeof(address));
	address.sin_port = htons(port);
	address.sin_family = AF_INET;
	inet_pton(AF_INET, ip, &address.sin_addr);

	/* 创建 TCP socket，并将其绑定到端口 port 上 */
	int listenfd = socket(PF_INET, SOCK_STREAM, 0);
	assert(listenfd >= 0);

	int ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
	assert(ret != -1);

	ret = listen(listenfd, 5);
	assert(ret != -1);

	/* 创建 UDP socket，并将其绑定到端口 port 上 */
	bzero(&address, sizeof(address));
	address.sin_family = AF_INET;
	address.sin_port = htons(port);
	inet_pton(AF_INET, ip, &address.sin_addr);
	
	int udpfd = socket(PF_INET, SOCK_DGRAM, 0);
	assert(udpfd >= 0);

	ret = bind(udpfd, (struct sockaddr*)&address, sizeof(address));
	assert(ret != -1);

	epoll_event events[MAX_EVENT_NUMBER];
	int epollfd = epoll_create(10);
	assert(epollfd != -1);
	/* 注册 TCP socket 和 UDP socket 上的可读事件 */
	addfd(epollfd, listenfd);
	addfd(epollfd, udpfd);

	while (1)
	{
		int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
		if (number < 0)
		{
			printf("epoll failure\n");
			break;
		}

		for (int i = 0; i < number; i++)
		{
			int sockfd = events[i].data.fd;
			if (sockfd == listenfd)		/* 如果是 TCP 的监听 socket */
			{
				struct sockaddr_in client_address;
				socklen_t client_addrlength = sizeof(client_address);
				int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
				addfd(epollfd, connfd);
			}
			else if (sockfd == udpfd)	/* 如果是 UDP 的 socket */
			{
				char buf[UDP_BUFFER_SIZE];
				memset(buf, '\0', UDP_BUFFER_SIZE);
				struct sockaddr_in client_address;
				socklen_t client_addrlength = sizeof(client_address);

				ret = recvfrom(udpfd, buf, UDP_BUFFER_SIZE, 0, (struct sockaddr*)&client_address, &client_addrlength);
				if (ret > 0)
				{
					sendto(udpfd, buf, UDP_BUFFER_SIZE - 1, 0, (struct sockaddr*)&client_address, client_addrlength);
				}
			}
			else if (events[i].events & EPOLLIN)	/* 如果是 TCP 可写事件 */
			{
				char buf[TCP_BUFFER_SIZE];
				while (1)			/* 由于 TCP 传输的是字节流，所以需要用 while 确保所有数据都被读出，UDP就不用使用 while */
				{
					memset(buf, '\0', TCP_BUFFER_SIZE);
					ret = recv(events[i].data.fd, buf, TCP_BUFFER_SIZE - 1, 0);
					if (ret < 0)
					{
						if (errno == EAGAIN || errno == EWOULDBLOCK)	/* 在Vxorks和Windows上，EAGAIN 叫做 EWOULDBLOCK */
						{
							break;
						}
						close(sockfd);
						break;
					}
					else if (ret == 0)
					{
						close(sockfd);
					}
					else
					{
						send(sockfd, buf, ret, 0);
					}
				}
			}
			else
			{
				printf("something else happened\n");
			}
		}
	}

	close(listenfd);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148