struct vsf_client_launch vsf_standalone_main(void) { struct vsf_sysutil_sockaddr* p_accept_addr = 0; int listen_sock = -1; int retval; s_ipaddr_size = vsf_sysutil_get_ipaddr_size(); if (tunable_listen && tunable_listen_ipv6) { die("run two copies of vsftpd for IPv4 and IPv6"); } if (tunable_background) { int forkret = vsf_sysutil_fork(); if (forkret > 0) { /* Parent, just exit */ vsf_sysutil_exit(0); } vsf_sysutil_make_session_leader(); } if (tunable_listen) { listen_sock = vsf_sysutil_get_ipv4_sock(); } else { listen_sock = vsf_sysutil_get_ipv6_sock(); } vsf_sysutil_activate_reuseaddr(listen_sock); s_p_ip_count_hash = hash_alloc(256, s_ipaddr_size, sizeof(unsigned int), hash_ip); s_p_pid_ip_hash = hash_alloc(256, sizeof(int), s_ipaddr_size, hash_pid); if (tunable_setproctitle_enable) { vsf_sysutil_setproctitle("LISTENER"); } vsf_sysutil_install_async_sighandler(kVSFSysUtilSigCHLD, handle_sigchld); vsf_sysutil_install_async_sighandler(kVSFSysUtilSigHUP, handle_sighup); if (tunable_listen) { struct vsf_sysutil_sockaddr* p_sockaddr = 0; vsf_sysutil_sockaddr_alloc_ipv4(&p_sockaddr); vsf_sysutil_sockaddr_set_port(p_sockaddr, tunable_listen_port); if (!tunable_listen_address) { vsf_sysutil_sockaddr_set_any(p_sockaddr); } else { if (!vsf_sysutil_inet_aton(tunable_listen_address, p_sockaddr)) { die2("bad listen_address: ", tunable_listen_address); } } retval = vsf_sysutil_bind(listen_sock, p_sockaddr); vsf_sysutil_free(p_sockaddr); if (vsf_sysutil_retval_is_error(retval)) { die("could not bind listening IPv4 socket"); } } else { struct vsf_sysutil_sockaddr* p_sockaddr = 0; vsf_sysutil_sockaddr_alloc_ipv6(&p_sockaddr); vsf_sysutil_sockaddr_set_port(p_sockaddr, tunable_listen_port); if (!tunable_listen_address6) { vsf_sysutil_sockaddr_set_any(p_sockaddr); } else { struct mystr addr_str = INIT_MYSTR; const unsigned char* p_raw_addr; str_alloc_text(&addr_str, tunable_listen_address6); p_raw_addr = vsf_sysutil_parse_ipv6(&addr_str); str_free(&addr_str); if (!p_raw_addr) { die2("bad listen_address6: ", tunable_listen_address6); } vsf_sysutil_sockaddr_set_ipv6addr(p_sockaddr, p_raw_addr); } retval = vsf_sysutil_bind(listen_sock, p_sockaddr); vsf_sysutil_free(p_sockaddr); if (vsf_sysutil_retval_is_error(retval)) { die("could not bind listening IPv6 socket"); } } vsf_sysutil_listen(listen_sock, VSFTP_LISTEN_BACKLOG); vsf_sysutil_sockaddr_alloc(&p_accept_addr); while (1) { struct vsf_client_launch child_info; void* p_raw_addr; int new_child; int new_client_sock; vsf_sysutil_unblock_sig(kVSFSysUtilSigCHLD); vsf_sysutil_unblock_sig(kVSFSysUtilSigHUP); new_client_sock = vsf_sysutil_accept_timeout( listen_sock, p_accept_addr, 0); vsf_sysutil_block_sig(kVSFSysUtilSigCHLD); vsf_sysutil_block_sig(kVSFSysUtilSigHUP); if (vsf_sysutil_retval_is_error(new_client_sock)) { continue; } ++s_children; child_info.num_children = s_children; child_info.num_this_ip = 0; p_raw_addr = vsf_sysutil_sockaddr_get_raw_addr(p_accept_addr); child_info.num_this_ip = handle_ip_count(p_raw_addr); new_child = vsf_sysutil_fork_failok(); if (new_child != 0) { /* Parent context */ vsf_sysutil_close(new_client_sock); if (new_child > 0) { hash_add_entry(s_p_pid_ip_hash, (void*)&new_child, p_raw_addr); } else { /* fork() failed, clear up! */ --s_children; drop_ip_count(p_raw_addr); } /* Fall through to while() loop and accept() again */ } else { /* Child context */ vsf_sysutil_close(listen_sock); prepare_child(new_client_sock); /* By returning here we "launch" the child process with the same * contract as xinetd would provide. */ return child_info; } } }
struct vsf_client_launch vsf_standalone_main(void) { struct vsf_sysutil_sockaddr* p_sockaddr = 0; struct vsf_sysutil_ipv4addr listen_ipaddr; int listen_sock = vsf_sysutil_get_ipv4_sock(); int retval; s_p_ip_count_hash = hash_alloc(256, sizeof(struct vsf_sysutil_ipv4addr), sizeof(unsigned int), hash_ip); s_p_pid_ip_hash = hash_alloc(256, sizeof(int), sizeof(struct vsf_sysutil_ipv4addr), hash_pid); if (tunable_setproctitle_enable) { vsf_sysutil_setproctitle("LISTENER"); } vsf_sysutil_install_sighandler(kVSFSysUtilSigCHLD, handle_sigchld, 0); vsf_sysutil_install_async_sighandler(kVSFSysUtilSigHUP, handle_sighup); vsf_sysutil_activate_reuseaddr(listen_sock); vsf_sysutil_sockaddr_alloc_ipv4(&p_sockaddr); vsf_sysutil_sockaddr_set_port( p_sockaddr, vsf_sysutil_ipv4port_from_int(tunable_listen_port)); if (!tunable_listen_address || vsf_sysutil_inet_aton(tunable_listen_address, &listen_ipaddr) == 0) { listen_ipaddr = vsf_sysutil_sockaddr_get_any(); } vsf_sysutil_sockaddr_set_ipaddr(p_sockaddr, listen_ipaddr); retval = vsf_sysutil_bind(listen_sock, p_sockaddr); vsf_sysutil_free(p_sockaddr); if (vsf_sysutil_retval_is_error(retval)) { die("could not bind listening socket"); } vsf_sysutil_listen(listen_sock, VSFTP_LISTEN_BACKLOG); while (1) { struct vsf_client_launch child_info; static struct vsf_sysutil_sockaddr* p_accept_addr; int new_child; struct vsf_sysutil_ipv4addr ip_addr; /* NOTE - wake up every 10 seconds to make sure we notice child exit * in a timely manner (the sync signal framework race) */ int new_client_sock = vsf_sysutil_accept_timeout( listen_sock, &p_accept_addr, 10); if (s_reload_needed) { s_reload_needed = 0; do_reload(); } if (vsf_sysutil_retval_is_error(new_client_sock)) { continue; } ip_addr = vsf_sysutil_sockaddr_get_ipaddr(p_accept_addr); ++s_children; child_info.num_children = s_children; child_info.num_this_ip = handle_ip_count(&ip_addr); new_child = vsf_sysutil_fork_failok(); if (new_child != 0) { /* Parent context */ vsf_sysutil_close(new_client_sock); if (new_child > 0) { hash_add_entry(s_p_pid_ip_hash, (void*)&new_child, (void*)&ip_addr); } else { /* fork() failed, clear up! */ --s_children; drop_ip_count(&ip_addr); } /* Fall through to while() loop and accept() again */ } else { /* Child context */ vsf_sysutil_close(listen_sock); prepare_child(new_client_sock); /* By returning here we "launch" the child process with the same * contract as xinetd would provide. */ return child_info; } } }
int main(void) { daemon(1, 0); parseconf_load_file(MINIFTPD_CONF); if (getuid() != 0) { fprintf(stderr, "must be started by root.\n"); exit(EXIT_FAILURE); } int listenfd = tcp_server(tunable_listen_address, tunable_listen_port); int conn; session_t sess = { //控制连接 0, -1, "", "", "", // ftp协议进程与nobody进程通信 -1, -1, //限速 0, 0, 0, 0, // 数据连接 NULL, -1, -1, 0, // ftp协议控制 0, 0, NULL, 0, //客户端连接数控制 0, 0 }; p_sess = &sess; sess.upload_speed_max = tunable_upload_max_rate; sess.download_speed_max = tunable_download_max_rate; signal(SIGCHLD, handle_sigchld); struct sockaddr_in peeraddr; s_ip_count_hash = hash_alloc(256, hash_func); s_pid_ip_hash = hash_alloc(256, hash_func); while(1) { if ((conn = accept_timeout(listenfd, &peeraddr, 0)) < 0) ERR_EXIT("accept_timeout"); unsigned int ip = (unsigned int)peeraddr.sin_addr.s_addr; sess.num_this_ip = handle_ip_count(&ip); ++cur_childrens; sess.num_clients = cur_childrens; pid_t pid = fork(); if (pid == -1) { --cur_childrens; ERR_EXIT("fork"); } if (pid == 0) { sess.ctrl_fd = conn; close(listenfd); check_clients_limit(&sess); signal(SIGCHLD, SIG_IGN); begin_session(&sess); } else if (pid > 0) { hash_add_entry(s_pid_ip_hash, &pid, sizeof(pid), &ip, sizeof(unsigned int)); close(conn); } } hash_free(s_ip_count_hash); hash_free(s_pid_ip_hash); return 0; }