这两天有点空闲，于是写了一个非常简单的FTP服务器练练手。包括浏览、删除、上传、下载、转换目录等最基本的功能，用传统的多进程的方式实现。可供初学Linux网络编程的朋友参考。后续有时间我会考虑进一步完善，例如加入配置文件、权限控制、多线程、对FTP协议更完善的支持、断点续传、ASCII传输模式、限速、日志、……太多了。有兴趣的朋友，在充分理解FTP协议的基础上，也可以自己对它做完善。关于FTP协议，请参见RFC 0959。
什么都不用说了，一切尽在代码中，注释还是比较丰富的。 ：）
编译：
gcc cuftpd.c -o cuftpd
运行：
./cuftpd -d -p 2121
其中-d打开调试开关，会输出大量调试信息。
-p 2121指定监听端口，默认是21。
还可以./cuftpd -h看帮助信息。
cuftpd.h
[/size]
#ifndef _CUFTPD_H
#define _CUFTPD_H
#define CUFTPD_DEBUG(fmt, ...) cuftpd_debug(__FILE__, __LINE__, fmt, __VA_ARGS__)
#define CUFTPD_ARR_LEN(arr) (sizeof(arr)/sizeof(arr[0]))
#define CUFTPD_VER "1.0"
#define CUFTPD_DEF_SRV_PORT 21
#define CUFTPD_LISTEN_QU_LEN 8
#define CUFTPD_LINE_END "/r/n"
#define CUFTPD_OK 0
#define CUFTPD_ERR (-1)
#define CUFTPD_CHECK_LOGIN() /
do { /
if (!cuftpd_cur_user) { /
cuftpd_send_resp(ctrlfd, 530, "first please"); /
return CUFTPD_ERR; /
} /
} while(0)
struct cuftpd_cmd_struct {
char *cmd_name;
int (*cmd_handler)(int ctrlfd, char *cmd_line);
};
struct cuftpd_user_struct {
char user[128];
char pass[128];
};
#endif
[size=2]
cuftpd.c
[/size]
/*
* A very simple ftp server's source code for demonstration.
* It supports PASV/PORT modes and following operations:
* ls,pwd,cwd,get,put,dele.
* I have tested it using following ftp clients:
* 1. Windows XP's command line ftp client,
* 2. IE 6.0,
* 3. Redhat 9.0's ftp client,
* 4. CuteFTP 8,
* I'll introduce more functions and improve its performance
* if i have enough idle time afterwards.
* Any issues pls paste to CU.
*
* Change History:
* 11/24/2006 1.0 Initial version.
*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdarg.h>
#include <signal.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
#include "cuftpd.h"
/* local functions declarations */
static int cuftpd_do_user(int,char*);
static int cuftpd_do_pass(int,char*);
static int cuftpd_do_pwd(int, char*);
static int cuftpd_do_cwd(int, char*);
static int cuftpd_do_syst(int,char*);
static int cuftpd_do_list(int,char*);
static int cuftpd_do_size(int,char*);
static int cuftpd_do_dele(int,char*);
static int cuftpd_do_type(int,char*);
static int cuftpd_do_port(int,char*);
static int cuftpd_do_pasv(int,char*);
static int cuftpd_do_retr(int,char*);
static int cuftpd_do_stor(int,char*);
static int cuftpd_do_quit(int,char*);
/* global variables */
int cuftpd_debug_on;
int cuftpd_srv_port = CUFTPD_DEF_SRV_PORT;
int cuftpd_cur_child_num;
int cuftpd_quit_flag;
struct cuftpd_user_struct *cuftpd_cur_user;
int cuftpd_pasv_fd = -1;
int cuftpd_pasv_connfd = -1;
int cuftpd_port_connfd = -1;
char cuftpd_home_dir[PATH_MAX];
/*
* Currently supported ftp commands.
*/
struct cuftpd_cmd_struct cuftpd_cmds[] = {
{"USER", cuftpd_do_user},
{"PASS", cuftpd_do_pass},
{"PWD", cuftpd_do_pwd},
{"XPWD", cuftpd_do_pwd},
{"CWD", cuftpd_do_cwd},
{"LIST", cuftpd_do_list},
{"NLST", cuftpd_do_list},
{"SYST", cuftpd_do_syst},
{"TYPE", cuftpd_do_type},
{"SIZE", cuftpd_do_size},
{"DELE", cuftpd_do_dele},
{"RMD", cuftpd_do_dele},
{"PORT", cuftpd_do_port},
{"PASV", cuftpd_do_pasv},
{"RETR", cuftpd_do_retr},
{"STOR", cuftpd_do_stor},
{"QUIT", cuftpd_do_quit},
{ NULL, NULL}
};
/*
* Anonymous users, you can add more user/pass pairs here.
*/
struct cuftpd_user_struct cuftpd_users[] = {
{"anonymous", ""},
{"ftp", ""}
};
/*
* Ftp server's responses, and are not complete.
*/
char cuftpd_srv_resps[][256] = {
"150 Begin transfer" CUFTPD_LINE_END,
"200 OK" CUFTPD_LINE_END,
"213 %d" CUFTPD_LINE_END,
"215 UNIX Type: L8" CUFTPD_LINE_END,
"220 CuFTPD " CUFTPD_VER " Server" CUFTPD_LINE_END,
"221 Goodbye" CUFTPD_LINE_END,
"226 Transfer complete" CUFTPD_LINE_END,
"227 Entering Passive Mode (%d,%d,%d,%d,%d,%d)" CUFTPD_LINE_END,
"230 User %s logged in" CUFTPD_LINE_END,
"250 CWD command successful" CUFTPD_LINE_END,
"257 /"%s/" is current directory" CUFTPD_LINE_END,
"331 Password required for %s" CUFTPD_LINE_END,
"500 Unsupport command %s" CUFTPD_LINE_END,
"530 Login %s" CUFTPD_LINE_END,
"550 Error" CUFTPD_LINE_END
};
static void
cuftpd_debug(const char *file, int line, const char *fmt, ...)
{
va_list ap;
if (!cuftpd_debug_on)
return;
fprintf(stderr, "(%s:%d:%d)", file, line, getpid());
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
static void
cuftpd_usage(void)
{
printf("cuftpd " CUFTPD_VER " usage:/n");
printf("cuftpd -p port -d/n");
}
static void
cuftpd_parse_args(int argc, char *argv[])
{
int opt;
int err = 0;
while ((opt = getopt(argc, argv, "p:dh")) != -1) {
switch (opt) {
case 'p':
cuftpd_srv_port = atoi(optarg);
err = (cuftpd_srv_port < 0 || cuftpd_srv_port > 65535);
break;
case 'd':
cuftpd_debug_on = 1;
break;
default:
err = 1;
break;
}
if (err) {
cuftpd_usage();
exit(-1);
}
}
CUFTPD_DEBUG("srv port:%d/n", cuftpd_srv_port);
}
static void
cuftpd_sigchild(int signo)
{
int status;
if (signo != SIGCHLD)
return;
while (waitpid(-1, &status, WNOHANG) > 0)
cuftpd_cur_child_num--;
CUFTPD_DEBUG("caught a SIGCHLD, cuftpd_cur_child_num=%d/n", cuftpd_cur_child_num);
}
static int
cuftpd_init(void)
{
/* add all init statements here */
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, cuftpd_sigchild);
getcwd(cuftpd_home_dir, sizeof(cuftpd_home_dir));
return CUFTPD_OK;
}
/*
* Create ftp server's listening socket.
*/
static int
cuftpd_create_srv(void)
{
int fd;
int on = 1;
int err;
struct sockaddr_in srvaddr;
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
CUFTPD_DEBUG("socket() failed: %s/n", strerror(errno));
return fd;
}
err = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (err < 0) {
CUFTPD_DEBUG("setsockopt() failed: %s/n", strerror(errno));
close(fd);
return CUFTPD_ERR;
}
memset(&srvaddr, 0, sizeof(srvaddr));
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons(cuftpd_srv_port);
srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);
err = bind(fd, (struct sockaddr*)&srvaddr, sizeof(srvaddr));
if (err < 0) {
CUFTPD_DEBUG("bind() failed: %s/n", strerror(errno));
close(fd);
return CUFTPD_ERR;
}
err = listen(fd, CUFTPD_LISTEN_QU_LEN);
if (err < 0) {
CUFTPD_DEBUG("listen() failed: %s/n", strerror(errno));
close(fd);
return CUFTPD_ERR;
}
if (cuftpd_debug_on) {
int len = sizeof(srvaddr);
getsockname(fd, (struct sockaddr*)&srvaddr, &len);
CUFTPD_DEBUG("create srv listen socket OK: %s:%d/n",
inet_ntoa(srvaddr.sin_addr), ntohs(srvaddr.sin_port));
}
return fd;
}
/*
* Map server response's number to the msg pointer.
*/
static char *
cuftpd_srv_resp_num2msg(int num)
{
int i;
char buf[8];
snprintf(buf, sizeof(buf), "%d", num);
if (strlen(buf) != 3)
return NULL;
for (i = 0; i < CUFTPD_ARR_LEN(cuftpd_srv_resps); i++)
if (strncmp(buf, cuftpd_srv_resps, strlen(buf)) == 0)
return cuftpd_srv_resps;
return NULL;
}
static int
cuftpd_send_msg(int fd, char *msg, int len)
{
int n, off = 0, left = len;
while (1) {
n = write(fd, msg + off, left);
if (n < 0) {
if (errno == EINTR)
continue;
return n;
}
if (n < left) {
left -= n;
off += n;
continue;
}
return len;
}
}
static int
cuftpd_recv_msg(int fd, char buf[], int len)
{
int n;
while (1) {
n = read(fd, buf, len);
if (n < 0) {
if (errno == EINTR)
continue;
return n;
}
return n;
}
}
static int
cuftpd_send_resp(int fd, int num, ...)
{
char *cp = cuftpd_srv_resp_num2msg(num);
va_list ap;
char buf[BUFSIZ];
if (!cp) {
CUFTPD_DEBUG("cuftpd_srv_resp_num2msg(%d) failed/n", num);
return CUFTPD_ERR;
}
va_start(ap, num);
vsnprintf(buf, sizeof(buf), cp, ap);
va_end(ap);
CUFTPD_DEBUG("send resp:%s/n", buf);
if (cuftpd_send_msg(fd, buf, strlen(buf)) != strlen(buf)) {
CUFTPD_DEBUG("cuftpd_send_msg() failed: %s/n", strerror(errno));
return CUFTPD_ERR;
}
return CUFTPD_OK;
}
static void
cuftpd_trim_lineend(char *cp)
{
if (cp && strlen(cp) > 0) {
char *cp2 = &cp[strlen(cp) - 1];
while (*cp2 == '/r' || *cp2 == '/n')
if (--cp2 < cp)
break;
cp2[1] = '/0';
}
}
static int
cuftpd_get_connfd(void)
{
int fd;
if (cuftpd_pasv_fd >= 0) {
fd = accept(cuftpd_pasv_fd, NULL, NULL);
if (fd >= 0) {
close(cuftpd_pasv_fd);
cuftpd_pasv_fd = -1;
cuftpd_pasv_connfd = fd;
return fd;
}
else
CUFTPD_DEBUG("accept() failed:%s/n", strerror(errno));
}
else if (cuftpd_port_connfd >= 0)
return cuftpd_port_connfd;
return (-1);
}
static int
cuftpd_close_all_fd(void)
{
if (cuftpd_pasv_fd >= 0) {
close(cuftpd_pasv_fd);
cuftpd_pasv_fd = -1;
}
if (cuftpd_pasv_connfd >= 0) {
close(cuftpd_pasv_connfd);
cuftpd_pasv_connfd = -1;
}
if (cuftpd_port_connfd >= 0) {
close(cuftpd_port_connfd);
cuftpd_port_connfd = -1;
}
return CUFTPD_OK;
}
mynets 回复于：2006-11-24 21:30:15
static int
cuftpd_do_user(int ctrlfd, char *cmdline)
{
char *cp = strchr(cmdline, ' ');
if (cp) {
int i;
for (i = 0; i < CUFTPD_ARR_LEN(cuftpd_users); i++)
if (strcmp(cp + 1, cuftpd_users.user) == 0) {
CUFTPD_DEBUG("user(%s) is found/n", cp + 1);
cuftpd_cur_user = &cuftpd_users;
break;
}
if (!cuftpd_cur_user)
CUFTPD_DEBUG("user(%s) not found/n", cp + 1);
/*
* If user name is bad, we still don't close the connection
* and send back the 331 response to ask for password.
*/
return cuftpd_send_resp(ctrlfd, 331, cp + 1);
}
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_do_pass(int ctrlfd, char *cmdline)
{
char *space = strchr(cmdline, ' ');
if (cuftpd_cur_user && space) {
if (strlen(cuftpd_cur_user->pass) == 0 ||
strcmp(space + 1, cuftpd_cur_user->pass) == 0) {
CUFTPD_DEBUG("password for %s OK/n", cuftpd_cur_user->user);
return cuftpd_send_resp(ctrlfd, 230, cuftpd_cur_user->user);
}
CUFTPD_DEBUG("password for %s ERR/n", cuftpd_cur_user->user);
}
/*
* User and pass don't match or
* cmd line does not contain a space character.
*/
cuftpd_cur_user = NULL;
return cuftpd_send_resp(ctrlfd, 530, "incorrect");
}
static int
cuftpd_do_pwd(int ctrlfd, char *cmdline)
{
char curdir[PATH_MAX];
char *cp;
CUFTPD_CHECK_LOGIN();
getcwd(curdir, sizeof(curdir));
cp = &curdir[strlen(cuftpd_home_dir)];
return cuftpd_send_resp(ctrlfd, 257, (*cp == '/0') ? "/" : cp);
}
static int
cuftpd_do_cwd(int ctrlfd, char *cmdline)
{
char *space = strchr(cmdline, ' ');
char curdir[PATH_MAX];
CUFTPD_CHECK_LOGIN();
if (!space)
return cuftpd_send_resp(ctrlfd, 550);
getcwd(curdir, sizeof(curdir));
if (strcmp(curdir, cuftpd_home_dir) == 0 &&
space[1] == '.' &&
space[2] == '.')
return cuftpd_send_resp(ctrlfd, 550);
/* Absolute path */
if (space[1] == '/') {
if (chdir(cuftpd_home_dir) == 0) {
if (space[2] == '/0' || chdir(space+2) == 0)
return cuftpd_send_resp(ctrlfd, 250);
}
chdir(curdir);
return cuftpd_send_resp(ctrlfd, 550);
}
/* Relative path */
if (chdir(space+1) == 0)
return cuftpd_send_resp(ctrlfd, 250);
chdir(curdir);
return cuftpd_send_resp(ctrlfd, 550);
}
/*
* This function acts as a implementation like 'ls -l' shell command.
*/
static int
cuftpd_get_list(char buf[], int len)
{
DIR *dir;
struct dirent *ent;
int off = 0;
if ((dir = opendir(".")) < 0) {
CUFTPD_DEBUG("opendir() failed:%s/n", strerror(errno));
return CUFTPD_ERR;
}
buf[0] = '/0';
while ((ent = readdir(dir)) != NULL) {
char *filename = ent->d_name;
struct stat st;
char mode[] = "----------";
struct passwd *pwd;
struct group *grp;
struct tm *ptm;
char timebuf[BUFSIZ];
int timelen;
if (strcmp(filename, ".") == 0 ||
strcmp(filename, "..") == 0)
continue;
if (stat(filename, &st) < 0) {
closedir(dir);
CUFTPD_DEBUG("stat() failed:%s/n", strerror(errno));
return CUFTPD_ERR;
}
if (S_ISDIR(st.st_mode))
mode[0] = 'd';
if (st.st_mode & S_IRUSR)
mode[1] = 'r';
if (st.st_mode & S_IWUSR)
mode[2] = 'w';
if (st.st_mode & S_IXUSR)
mode[3] = 'x';
if (st.st_mode & S_IRGRP)
mode[4] = 'r';
if (st.st_mode & S_IWGRP)
mode[5] = 'w';
if (st.st_mode & S_IXGRP)
mode[6] = 'x';
if (st.st_mode & S_IROTH)
mode[7] = 'r';
if (st.st_mode & S_IWOTH)
mode[8] = 'w';
if (st.st_mode & S_IXOTH)
mode[9] = 'x';
mode[10] = '/0';
off += snprintf(buf + off, len - off, "%s ", mode);
/* hard link number, this field is nonsense for ftp */
off += snprintf(buf + off, len - off, "%d ", 1);
/* user */
if ((pwd = getpwuid(st.st_uid)) == NULL) {
closedir(dir);
return CUFTPD_ERR;
}
off += snprintf(buf + off, len - off, "%s ", pwd->pw_name);
/* group */
if ((grp = getgrgid(st.st_gid)) == NULL) {
closedir(dir);
return CUFTPD_ERR;
}
off += snprintf(buf + off, len - off, "%s ", grp->gr_name);
/* size */
off += snprintf(buf + off, len - off, "%*d ", 10, st.st_size);
/* mtime */
ptm = localtime(&st.st_mtime);
if (ptm && (timelen = strftime(timebuf, sizeof(timebuf), "%b %d %H:%S", ptm)) > 0) {
timebuf[timelen] = '/0';
off += snprintf(buf + off, len - off, "%s ", timebuf);
}
else {
closedir(dir);
return CUFTPD_ERR;
}
off += snprintf(buf + off, len - off, "%s/r/n", filename);
}
return off;
}
static int
cuftpd_do_list(int ctrlfd, char *cmdline)
{
char buf[BUFSIZ];
int n;
int fd;
CUFTPD_CHECK_LOGIN();
if ((fd = cuftpd_get_connfd()) < 0) {
CUFTPD_DEBUG("LIST cmd:no available fd%s", "/n");
goto err_label;
}
cuftpd_send_resp(ctrlfd, 150);
/*
* Get the 'ls -l'-like result and send it to client.
*/
n = cuftpd_get_list(buf, sizeof(buf));
if (n >= 0) {
if (cuftpd_send_msg(fd, buf, n) != n) {
CUFTPD_DEBUG("cuftpd_send_msg() failed: %s/n", strerror(errno));
goto err_label;
}
}
else {
CUFTPD_DEBUG("cuftpd_get_list() failed %s", "/n");
goto err_label;
}
cuftpd_close_all_fd();
return cuftpd_send_resp(ctrlfd, 226);
err_label:
cuftpd_close_all_fd();
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_do_syst(int ctrlfd, char *cmdline)
{
CUFTPD_CHECK_LOGIN();
return cuftpd_send_resp(ctrlfd, 215);
}
static int
cuftpd_do_size(int ctrlfd, char *cmdline)
{
char *space = strchr(cmdline, ' ');
struct stat st;
CUFTPD_CHECK_LOGIN();
if (!space || lstat(space + 1, &st) < 0) {
CUFTPD_DEBUG("SIZE cmd err: %s/n", cmdline);
return cuftpd_send_resp(ctrlfd, 550);
}
return cuftpd_send_resp(ctrlfd, 213, st.st_size);
}
static int
cuftpd_do_dele(int ctrlfd, char *cmdline)
{
char *space = strchr(cmdline, ' ');
struct stat st;
CUFTPD_CHECK_LOGIN();
if (!space || lstat(space+1, &st) < 0 ||
remove(space+1) < 0) {
CUFTPD_DEBUG("DELE cmd err: %s/n", cmdline);
return cuftpd_send_resp(ctrlfd, 550);
}
return cuftpd_send_resp(ctrlfd, 200);
}
static int
cuftpd_do_type(int ctrlfd, char *cmdline)
{
CUFTPD_CHECK_LOGIN();
/*
* Just send back 200 response and do nothing
*/
return cuftpd_send_resp(ctrlfd, 200);
}
/*
* Parse PORT cmd and fetch the ip and port,
* and both in network byte order.
*/
static int
cuftpd_get_port_mode_ipport(char *cmdline, unsigned int *ip, unsigned short *port)
{
char *cp = strchr(cmdline, ' ');
int i;
unsigned char buf[6];
if (!cp)
return CUFTPD_ERR;
for (cp++, i = 0; i < CUFTPD_ARR_LEN(buf); i++) {
buf = atoi(cp);
cp = strchr(cp, ',');
if (!cp && i < CUFTPD_ARR_LEN(buf) - 1)
return CUFTPD_ERR;
cp++;
}
if (ip)
*ip = *(unsigned int*)&buf[0];
if (port)
*port = *(unsigned short*)&buf[4];
return CUFTPD_OK;
}
/*
* Ftp client shipped with Windows XP uses PORT
* mode as default to connect ftp server.
*/
static int
cuftpd_do_port(int ctrlfd, char *cmdline)
{
unsigned int ip;
unsigned short port;
struct sockaddr_in sin;
CUFTPD_CHECK_LOGIN();
if (cuftpd_get_port_mode_ipport(cmdline, &ip, &port) != CUFTPD_OK) {
CUFTPD_DEBUG("cuftpd_get_port_mode_ipport() failed%s", "/n");
goto err_label;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = ip;
sin.sin_port = port;
CUFTPD_DEBUG("PORT cmd:%s:%d/n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
if (cuftpd_port_connfd >= 0) {
close(cuftpd_port_connfd);
cuftpd_port_connfd = -1;
}
cuftpd_port_connfd = socket(AF_INET, SOCK_STREAM, 0);
if (cuftpd_port_connfd < 0) {
CUFTPD_DEBUG("socket() failed:%s/n", strerror(errno));
goto err_label;
}
if (connect(cuftpd_port_connfd, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
CUFTPD_DEBUG("bind() failed:%s/n", strerror(errno));
goto err_label;
}
CUFTPD_DEBUG("PORT mode connect OK%s", "/n");
return cuftpd_send_resp(ctrlfd, 200);
err_label:
if (cuftpd_port_connfd >= 0) {
close(cuftpd_port_connfd);
cuftpd_port_connfd = -1;
}
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_do_pasv(int ctrlfd, char *cmdline)
{
struct sockaddr_in pasvaddr;
int len;
unsigned int ip;
unsigned short port;
CUFTPD_CHECK_LOGIN();
if (cuftpd_pasv_fd >= 0) {
close(cuftpd_pasv_fd);
cuftpd_pasv_fd = -1;
}
cuftpd_pasv_fd = socket(AF_INET, SOCK_STREAM, 0);
if (cuftpd_pasv_fd < 0) {
CUFTPD_DEBUG("socket() failed: %s/n", strerror(errno));
return cuftpd_send_resp(ctrlfd, 550);
}
/*
* must bind to the same interface as ctrl connectin came from.
*/
len = sizeof(pasvaddr);
getsockname(ctrlfd, (struct sockaddr*)&pasvaddr, &len);
pasvaddr.sin_port = 0;
if (bind(cuftpd_pasv_fd, (struct sockaddr*)&pasvaddr, sizeof(pasvaddr)) < 0) {
CUFTPD_DEBUG("bind() failed: %s/n", strerror(errno));
close(cuftpd_pasv_fd);
cuftpd_pasv_fd = -1;
return cuftpd_send_resp(ctrlfd, 550);
}
if (listen(cuftpd_pasv_fd, CUFTPD_LISTEN_QU_LEN) < 0) {
CUFTPD_DEBUG("listen() failed: %s/n", strerror(errno));
close(cuftpd_pasv_fd);
cuftpd_pasv_fd = -1;
return cuftpd_send_resp(ctrlfd, 550);
}
len = sizeof(pasvaddr);
getsockname(cuftpd_pasv_fd, (struct sockaddr*)&pasvaddr, &len);
ip = ntohl(pasvaddr.sin_addr.s_addr);
port = ntohs(pasvaddr.sin_port);
CUFTPD_DEBUG("local bind: %s:%d/n", inet_ntoa(pasvaddr.sin_addr), port);
/*
* write local ip/port into response msg
* and send to client.
*/
return cuftpd_send_resp(ctrlfd, 227, (ip>>24)&0xff, (ip>>16)&0xff,
(ip>>8)&0xff, ip&0xff, (port>>8)&0xff, port&0xff);
}
static int
cuftpd_do_retr(int ctrlfd, char *cmdline)
{
char buf[BUFSIZ];
char *space = strchr(cmdline, ' ');
struct stat st;
int fd = -1, n;
int connfd;
CUFTPD_CHECK_LOGIN();
if (!space || lstat(space + 1, &st) < 0) {
CUFTPD_DEBUG("RETR cmd err: %s/n", cmdline);
goto err_label;
}
if ((connfd = cuftpd_get_connfd()) < 0) {
CUFTPD_DEBUG("cuftpd_get_connfd() failed%s", "/n");
goto err_label;
}
cuftpd_send_resp(ctrlfd, 150);
/* begin to read file and write it to conn socket */
if ((fd = open(space + 1, O_RDONLY)) < 0) {
CUFTPD_DEBUG("open() failed: %s/n", strerror(errno));
goto err_label;
}
while (1) {
if ((n = read(fd, buf, sizeof(buf))) < 0) {
if (errno == EINTR)
continue;
CUFTPD_DEBUG("read() failed: %s/n", strerror(errno));
goto err_label;
}
if (n == 0)
break;
if (cuftpd_send_msg(connfd, buf, n) != n) {
CUFTPD_DEBUG("cuftpd_send_msg() failed: %s/n", strerror(errno));
goto err_label;
}
}
CUFTPD_DEBUG("RETR(%s) OK/n", space + 1);
if (fd >= 0)
close(fd);
cuftpd_close_all_fd();
return cuftpd_send_resp(ctrlfd, 226);
err_label:
if (fd >= 0)
close(fd);
cuftpd_close_all_fd();
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_do_stor(int ctrlfd, char *cmdline)
{
char buf[BUFSIZ];
char *space = strchr(cmdline, ' ');
struct stat st;
int fd = -1, n;
int left, off;
int connfd;
CUFTPD_CHECK_LOGIN();
/*
* Should add some permission control mechanism here.
*/
if (!space || lstat(space + 1, &st) == 0) {
CUFTPD_DEBUG("STOR cmd err: %s/n", cmdline);
goto err_label;
}
if ((connfd = cuftpd_get_connfd()) < 0) {
CUFTPD_DEBUG("cuftpd_get_connfd() failed%s", "/n");
goto err_label;
}
cuftpd_send_resp(ctrlfd, 150);
if ((fd = open(space + 1, O_WRONLY|O_CREAT|O_TRUNC, 0600)) < 0) {
CUFTPD_DEBUG("open() failed: %s/n", strerror(errno));
goto err_label;
}
/* begin to read data from socket and wirte to disk file */
while (1) {
if ((n = cuftpd_recv_msg(connfd, buf, sizeof(buf))) < 0) {
CUFTPD_DEBUG("cuftpd_recv_msg() failed: %s/n", strerror(errno));
goto err_label;
}
if (n == 0)
break;
left = n;
off = 0;
while (left > 0) {
int nwrite;
if ((nwrite = write(fd, buf + off, left)) < 0) {
if (errno == EINTR)
continue;
CUFTPD_DEBUG("write() failed:%s/n", strerror(errno));
goto err_label;
}
off += nwrite;
left -= nwrite;
}
}
CUFTPD_DEBUG("STOR(%s) OK/n", space+1);
if (fd >= 0)
close(fd);
cuftpd_close_all_fd();
sync();
return cuftpd_send_resp(ctrlfd, 226);
err_label:
if (fd >= 0) {
close(fd);
unlink(space+1);
}
cuftpd_close_all_fd();
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_do_quit(int ctrlfd, char *cmdline)
{
cuftpd_send_resp(ctrlfd, 221);
cuftpd_quit_flag = 1;
return CUFTPD_OK;
}
static int
cuftpd_do_request(int ctrlfd, char buf[])
{
char *end = &buf[strlen(buf) - 1];
char *space = strchr(buf, ' ');
int i;
char save;
int err;
if (*end == '/n' || *end == '/r') {
/*
* this is a valid ftp request.
*/
cuftpd_trim_lineend(buf);
if (!space)
space = &buf[strlen(buf)];
save = *space;
*space = '/0';
for (i = 0; cuftpd_cmds.cmd_name; i++) {
if (strcmp(buf, cuftpd_cmds.cmd_name) == 0) {
*space = save;
CUFTPD_DEBUG("recved a valid ftp cmd:%s/n", buf);
return cuftpd_cmds.cmd_handler(ctrlfd, buf);
}
}
/*
* unrecognized cmd
*/
*space = save;
CUFTPD_DEBUG("recved a unsupported ftp cmd:%s/n", buf);
*space = '/0';
err = cuftpd_send_resp(ctrlfd, 500, buf);
*space = save;
return err;
}
CUFTPD_DEBUG("recved a invalid ftp cmd:%s/n", buf);
/*
* Even if it's a invalid cmd, we should also send
* back a response to prevent client from blocking.
*/
return cuftpd_send_resp(ctrlfd, 550);
}
static int
cuftpd_ctrl_conn_handler(int connfd)
{
char buf[BUFSIZ];
int buflen;
int err = CUFTPD_OK;
/*
* Control connection has set up,
* we can send out the first ftp msg.
*/
if (cuftpd_send_resp(connfd, 220) != CUFTPD_OK) {
close(connfd);
CUFTPD_DEBUG("Close the ctrl connection OK%s", "/n");
return CUFTPD_ERR;
}
/*
* Begin to interact with client and one should implement
* a state machine here for full compatibility. But we only
* show a demonstration ftp server and i do my best to
* simplify it. Base on this skeleton, you can write a
* full-funtional ftp server if you like. ;-)
*/
while (1) {
buflen = cuftpd_recv_msg(connfd, buf, sizeof(buf));
if (buflen < 0) {
CUFTPD_DEBUG("cuftpd_recv_msg() failed: %s/n", strerror(errno));
err = CUFTPD_ERR;
break;
}
if (buflen == 0)
/* this means client launch a active close */
break;
buf[buflen] = '/0';
cuftpd_do_request(connfd, buf);
/*
* The negative return value from cuftpd_do_request
* should not cause the breaking of ctrl connection.
* Only when the client send QUIT cmd, we exit and
* launch a active close.
*/
if (cuftpd_quit_flag)
break;
}
close(connfd);
CUFTPD_DEBUG("Close the ctrl connection OK%s", "/n");
return err;
}
static int
cuftpd_do_loop(int listenfd)
{
int connfd;
int pid;
while (1) {
CUFTPD_DEBUG("Server ready, wait client's connection...%s", "/n");
connfd = accept(listenfd, NULL, NULL);
if (connfd < 0) {
CUFTPD_DEBUG("accept() failed: %s/n", strerror(errno));
continue;
}
if (cuftpd_debug_on) {
struct sockaddr_in cliaddr;
int len = sizeof(cliaddr);
getpeername(connfd, (struct sockaddr*)&cliaddr, &len);
CUFTPD_DEBUG("accept a conn from %s:%d/n",
inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
}
if ((pid = fork()) < 0) {
CUFTPD_DEBUG("fork() failed: %s/n", strerror(errno));
close(connfd);
continue;
}
if (pid > 0) {
/* parent */
close(connfd);
cuftpd_cur_child_num++;
continue;
}
/* child */
close(listenfd);
signal(SIGCHLD, SIG_IGN);
if (cuftpd_ctrl_conn_handler(connfd) != CUFTPD_OK)
exit(-1);
exit(0);
}
return CUFTPD_OK;
}
int
main(int argc, char *argv[])
{
int listenfd;
cuftpd_parse_args(argc, argv);
cuftpd_init();
listenfd = cuftpd_create_srv();
if (listenfd >= 0)
cuftpd_do_loop(listenfd);
exit(0);
}
扫一扫
834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
