基于epoll和Reactor模式实现ftp服务器（C/C++代码实现）

FTP（File Transfer Protocol）是一种用于在计算机网络上进行文件传输的应用层协议。在本文中，我们将探讨如何使用epoll和Reactor模式来实现一个简单的FTP服务器。epoll是一种高效的I/O事件通知机制，而Reactor模式则是一种基于事件驱动的编程模型。通过结合这两种技术，我们可以构建一个高性能、可扩展的FTP服务器。

epoll简介

epoll 是 Linux 操作系统下提供的一种高效的 I/O 多路复用接口。它是 select 和 poll 的替代品，专门设计来解决大量并发文件描述符（FD）的 I/O 问题，特别是在高负载的网络服务中。epoll 通过更高效的事件通知机制，减少了系统资源的消耗，并提高了 I/O 事件处理的性能。

核心概念

文件描述符（File Descriptor, FD）：在 Linux 系统中，一切皆文件，包括网络连接、设备等，都通过文件描述符来访问。
事件（Event）：指的是文件描述符上发生的 I/O 状态变化，如可读、可写、错误等。
事件监听（Event Monitoring）：监控文件描述符上的事件，当事件发生时，操作系统通知应用程序。

epoll 的特点

高效的事件通知机制：epoll 通过维护一个事件列表来通知应用程序哪些文件描述符已经准备好进行 I/O 操作，而不是像 select 和 poll 那样轮询所有文件描述符。
边缘触发（Edge Triggered, ET）和水平触发（Level Triggered, LT）：epoll 支持两种事件触发模式。边缘触发模式下，事件仅在状态发生变化时通知一次；水平触发模式下，只要文件描述符处于就绪状态，就会持续通知。
资源消耗低：与 select 和 poll 相比，epoll 不需要在每次调用时传递和复制整个文件描述符集合，因为它只关心那些已经触发的事件。
可伸缩性好：epoll 可以高效地处理成千上万的并发连接，非常适合高并发的网络服务。

epoll 的使用

使用 epoll 通常包括以下几个步骤：

创建 epoll 实例：
```
int epoll_fd = epoll_create1(0);
```

添加文件描述符到 epoll 实例：

struct epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET; // 监听读事件，使用边缘触发模式
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event);

等待事件：

struct epoll_event events[MAX_EVENTS];
int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
for (int i = 0; i < n; i++) {if (events[i].events & EPOLLIN) {// 处理读事件}
}

关闭 epoll 实例：
```
close(epoll_fd);
```

Reactor模式简介

Reactor模式是一种设计模式，主要用于处理服务端的并发请求，它通过事件多路复用技术来高效地处理多个客户端的请求。Reactor模式的核心思想是将服务端的资源（如套接字）注册到事件多路复用器上，当资源上发生事件（如读、写、连接请求等）时，事件多路复用器会通知相应的处理器来处理这些事件。

Reactor模式通常包含以下几个关键组件：

事件多路复用器（Event Demultiplexer）：
- 负责监听多个事件，并将发生的事件分发给相应的处理器。
- 常见的事件多路复用器有select、poll和epoll。
事件处理器（Event Handler）：
- 用于处理特定的事件，每个处理器负责一种类型的事件。
- 例如，可以有专门的处理器处理客户端连接请求、数据读取、数据写入等。
事件分派器（Event Dispatcher）：
- 通常作为事件多路复用器和事件处理器之间的中介，负责将事件分发给正确的处理器。
- 在某些实现中，事件分派器可能与事件多路复用器合并。
资源（Resource）：
- 需要监听的实体，如套接字、文件描述符等。
- 资源可以是被动的，它们不主动产生事件，而是等待事件多路复用器的监听和分派。
客户端请求（Client Request）：
- 客户端发起的请求，这些请求会触发资源上的事件。

Reactor模式的工作流程大致如下：

初始化：创建事件多路复用器，并将需要监听的资源注册到事件多路复用器上。
事件监听：事件多路复用器监听注册的资源，等待事件发生。
事件分发：当事件发生时，事件多路复用器将事件通知给事件分派器。
事件处理：事件分派器将事件分发给相应的事件处理器。
响应客户端：事件处理器处理完事件后，可能会生成响应发送给客户端。

Reactor模式的优势在于它可以有效地处理大量并发连接，而不需要为每个连接创建新的线程或进程，从而节省了资源并提高了性能。这种模式在网络服务器、数据库服务器等需要处理大量并发请求的场景中非常常见。

三、实现FTP服务器

初始化epoll和Reactor
首先，我们需要初始化epoll和Reactor。创建一个epoll实例，并将其与Reactor关联。同时，设置Reactor的事件处理函数，用于处理epoll通知的事件。

#include <sys/epoll.h>
#include <event2/event.h>int epoll_fd = epoll_create(1);
struct event_base *base = event_base_new();

监听端口并接受连接
使用socket创建一个监听端口，并将其注册到epoll中。当有新的连接到来时，Acceptor会接受连接，并将新的连接注册到epoll中。

int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
bind(listen_fd, ...);
listen(listen_fd, ...);struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = listen_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

处理事件
在Reactor的事件处理函数中，我们需要根据epoll通知的事件类型来调用相应的Handler。例如，当有新的连接到来时，我们需要调用Acceptor来接受连接；当有数据可读时，我们需要调用Reader来读取数据；当可以写入数据时，我们需要调用Writer来发送数据。

void event_handler(int fd, short events, void *arg) {if (events & EPOLLIN) {// 调用Acceptor或Reader} else if (events & EPOLLOUT) {// 调用Writer}
}

实现FTP协议
为了实现FTP协议，我们需要实现一系列的命令和数据传输。例如，当客户端发送“LIST”命令时，服务器需要返回当前目录下的文件列表；当客户端发送“RETR”命令时，服务器需要将指定的文件发送给客户端。
测试和优化
最后，我们需要对FTP服务器进行测试和优化。可以使用ftp命令行工具或者文件浏览器来测试服务器的功能和性能。如果发现性能瓶颈，可以考虑使用多线程或者异步I/O来提高服务器的并发能力。

总结：
通过结合epoll和Reactor模式，我们可以实现一个高性能、可扩展的FTP服务器。在实际应用中，还需要考虑安全性、稳定性等因素，以满足不同场景的需求。


...typedef struct free_queue_t {void *payload;struct free_queue_t *next;
} free_queue_t;typedef struct util_config_t {int wait_size;int ep_fd;char root[PATH_MAX_LEN];size_t root_len;char *port;net_listener_t listener_head;service_handler_t service_head;struct free_queue_t free_head;enum log_level_t log_level;
} util_config_t;extern util_config_t util_config;int start_up();int main_loop();void tear_down();void add_free_list(void *payload);void clear_free_list();int pop_dir(char *tmp, int tmp_len);int join_path(const char *root, int root_len,const char *wd, int wd_len,const char *path, int path_len, char *res);
...#define PATH_MAX_LEN 4096
#define MAX_EPOLL_PER 64
#define HOST_MAX_LEN 4096
#define SO_MAX_QUEUE 64
#define CONTROL_BUFFER_LEN 4096
#define DATA_BUFFER_LEN 8192
#define PWD_MAX_LEN 8192
#define ARG_MAX_LEN 20
#define PASV_MAX_LEN 200enum log_level_t {LOG_NONE,LOG_ERR,LOG_WARN,LOG_INFO,LOG_DEBUG
};typedef void(*epoll_callback_t)(void *receiver, int events);typedef struct epoll_payload_t {epoll_callback_t callback;void *receiver;
} epoll_payload_t;...typedef struct net_listener_t {epoll_payload_t accept_event;char hostname[HOST_MAX_LEN];in_port_t port;int server_fd;struct net_listener_t *prev, *next;
} net_listener_t;int net_listener_start();void listener_remove_all();void accept_callback(void *receiver, int events);...
enum data_type {DT_LIST, DT_RETR, DT_STOR, DT_NONE
};typedef struct service_handler_t {char path[PATH_MAX_LEN];size_t root_len, wd_len;char rename_path[PATH_MAX_LEN];size_t rename_len;int control_fd;int control_flag;int data_in_fd, data_out_fd;int data_flag;int pasv_listen_fd, remote_fd;int local_fd;epoll_payload_t control_payload, data_in_payload, data_out_payload, pasv_payload;char control_read_buffer[CONTROL_BUFFER_LEN];size_t read_buffer_len, read_buffer_head;char control_write_buffer[CONTROL_BUFFER_LEN];size_t write_buffer_len;char data_transfer_buffer[DATA_BUFFER_LEN];int data_buffer_len;int should_exit, entered, transfer_flag;int user_used, logged_in;struct sockaddr_in port_addr;int port_len;struct sockaddr_in local_addr;int local_addr_len;enum data_type command_type;int start_position;struct service_handler_t *prev, *next;
} service_handler_t;typedef void(*service_handler_callback_t)(service_handler_t *handler, char *parameter);typedef struct service_command_t {char *command_name;service_handler_callback_t callback;int require_login;
} service_command_t;void service_write_line(service_handler_t *handler, const char *line);
void service_add(int fd);
void service_remove(service_handler_t *handler);
void service_remove_all();
void control_update(service_handler_t *handler);
void service_start();
int data_can_start(service_handler_t *handler);
void data_start_transfer(service_handler_t *handler);
void data_update(service_handler_t *handler);
void data_abort_connection(service_handler_t *handler, char *line);
void control_callback(void *receiver, int events);
void data_in_callback(void *receiver, int events);
void data_out_callback(void *receiver, int events);
void pasv_listen_callback(void *receiver, int events);
void data_clear_connection(service_handler_t *handler);...
void parse_arguments(int argc, char *argv[]) {struct option options[] = {{"root",  required_argument, NULL, 'r'},{"port",  required_argument, NULL, 'p'},{"info",  no_argument,       NULL, 'i'},{"debug", no_argument,       NULL, 'd'}};int c;char *root = "/tmp", *port = "21";util_config.log_level = LOG_WARN;while ((c = getopt_long_only(argc, argv, "idr:p:", options, NULL)) != -1) {switch (c) {case 'i':util_config.log_level = LOG_INFO;break;case 'd':util_config.log_level = LOG_DEBUG;break;case 'r':root = optarg;break; case 'p':port = optarg;break;default:printf("usage: server [-root <root>] [-port <port>]\n");exit(-1);}}util_config.root_len = strlen(root);if (util_config.root_len >= PATH_MAX_LEN) {if (util_config.log_level >= LOG_ERR) {fprintf(stderr, "root path too long\n");}exit(-1);}if (util_config.root_len > 0 && root[util_config.root_len - 1] == '/') {root[--util_config.root_len] = '\0'; // 确保根不以结尾 /}char cwd[PATH_MAX_LEN];if (getcwd(cwd, PATH_MAX_LEN) == NULL) {if (util_config.log_level >= LOG_ERR) {perror("getcwd");}exit(-1);}int root_len = (int) strlen(root);int cwd_len = (int) strlen(cwd);util_config.root_len = (size_t) join_path("", 0,cwd, cwd_len,root, root_len, util_config.root);if (util_config.root_len == -1) {if (util_config.log_level >= LOG_ERR) {fprintf(stderr, "get root dir fail\n");}exit(-1);}if (util_config.log_level >= LOG_DEBUG) {printf("root is set to %s\n", util_config.root);}util_config.port = port;
}int main(int argc, char *argv[]) {parse_arguments(argc, argv);if (start_up() == -1) {return -1;}main_loop();tear_down();return 0;
}