diff options
| -rw-r--r-- | networking/ftpd.c | 1130 |
1 files changed, 1130 insertions, 0 deletions
diff --git a/networking/ftpd.c b/networking/ftpd.c new file mode 100644 index 0000000..ab7308b --- /dev/null +++ b/networking/ftpd.c @@ -0,0 +1,1130 @@ +/* vi: set sw=4 ts=4: */ +/* + * Simple FTP daemon, based on vsftpd 2.0.7 (written by Chris Evans) + * + * Author: Adam Tkac <vonsch@gmail.com> + * + * Only subset of FTP protocol is implemented but vast majority of clients + * should not have any problem. You have to run this daemon via inetd. + * + * Options: + * -w - enable FTP write commands + */ + +#include "libbb.h" +#include <netinet/tcp.h> + +enum { + FTP_DATACONN = 150, + FTP_NOOPOK = 200, + FTP_TYPEOK = 200, + FTP_PORTOK = 200, + FTP_STRUOK = 200, + FTP_MODEOK = 200, + FTP_ALLOOK = 202, + FTP_STATOK = 211, + FTP_STATFILE_OK = 213, + FTP_HELP = 214, + FTP_SYSTOK = 215, + FTP_GREET = 220, + FTP_GOODBYE = 221, + FTP_TRANSFEROK = 226, + FTP_PASVOK = 227, + FTP_LOGINOK = 230, + FTP_CWDOK = 250, +#if ENABLE_FEATURE_FTP_WRITE + FTP_RMDIROK = 250, + FTP_DELEOK = 250, + FTP_RENAMEOK = 250, +#endif + FTP_PWDOK = 257, +#if ENABLE_FEATURE_FTP_WRITE + FTP_MKDIROK = 257, +#endif + FTP_GIVEPWORD = 331, + FTP_RESTOK = 350, +#if ENABLE_FEATURE_FTP_WRITE + FTP_RNFROK = 350, +#endif + FTP_BADSENDCONN = 425, + FTP_BADSENDNET = 426, + FTP_BADSENDFILE = 451, + FTP_BADCMD = 500, + FTP_COMMANDNOTIMPL = 502, + FTP_NEEDUSER = 503, + FTP_NEEDRNFR = 503, + FTP_BADSTRU = 504, + FTP_BADMODE = 504, + FTP_LOGINERR = 530, + FTP_FILEFAIL = 550, + FTP_NOPERM = 550, + FTP_UPLOADFAIL = 553, + +#define mk_const4(a,b,c,d) (((a * 0x100 + b) * 0x100 + c) * 0x100 + d) +#define mk_const3(a,b,c) ((a * 0x100 + b) * 0x100 + c) + const_ALLO = mk_const4('A', 'L', 'L', 'O'), + const_APPE = mk_const4('A', 'P', 'P', 'E'), + const_CDUP = mk_const4('C', 'D', 'U', 'P'), + const_CWD = mk_const3('C', 'W', 'D'), + const_DELE = mk_const4('D', 'E', 'L', 'E'), + const_HELP = mk_const4('H', 'E', 'L', 'P'), + const_LIST = mk_const4('L', 'I', 'S', 'T'), + const_MKD = mk_const3('M', 'K', 'D'), + const_MODE = mk_const4('M', 'O', 'D', 'E'), + const_NLST = mk_const4('N', 'L', 'S', 'T'), + const_NOOP = mk_const4('N', 'O', 'O', 'P'), + const_PASS = mk_const4('P', 'A', 'S', 'S'), + const_PASV = mk_const4('P', 'A', 'S', 'V'), + const_PORT = mk_const4('P', 'O', 'R', 'T'), + const_PWD = mk_const3('P', 'W', 'D'), + const_QUIT = mk_const4('Q', 'U', 'I', 'T'), + const_REST = mk_const4('R', 'E', 'S', 'T'), + const_RETR = mk_const4('R', 'E', 'T', 'R'), + const_RMD = mk_const3('R', 'M', 'D'), + const_RNFR = mk_const4('R', 'N', 'F', 'R'), + const_RNTO = mk_const4('R', 'N', 'T', 'O'), + const_STAT = mk_const4('S', 'T', 'A', 'T'), + const_STOR = mk_const4('S', 'T', 'O', 'R'), + const_STOU = mk_const4('S', 'T', 'O', 'U'), + const_STRU = mk_const4('S', 'T', 'R', 'U'), + const_SYST = mk_const4('S', 'Y', 'S', 'T'), + const_TYPE = mk_const4('T', 'Y', 'P', 'E'), + const_USER = mk_const4('U', 'S', 'E', 'R'), +}; + +struct globals { + char *p_control_line_buf; + len_and_sockaddr *local_addr; + len_and_sockaddr *port_addr; + int pasv_listen_fd; + int data_fd; + off_t restart_pos; + char *ftp_cmp; + char *ftp_arg; +#if ENABLE_FEATURE_FTP_WRITE + char *rnfr_filename; + smallint write_enable; +#endif +}; +#define G (*(struct globals*)&bb_common_bufsiz1) +#define INIT_G() do { } while (0) + + +static char * +replace_text(const char *str, const char from, const char *to) +{ + size_t retlen, remainlen, chunklen, tolen; + const char *remain; + char *ret, *found; + + remain = str; + remainlen = strlen(str); + + tolen = strlen(to); + + /* simply alloc strlen(str)*strlen(to). To is max 2 so it's allowed */ + ret = xmalloc(remainlen * strlen(to) + 1); + retlen = 0; + + for (;;) { + found = strchr(remain, from); + if (found != NULL) { + chunklen = found - remain; + + /* Copy chunk which doesn't contain 'from' to ret */ + memcpy(&ret[retlen], remain, chunklen); + retlen += chunklen; + + /* Now copy 'to' instead of 'from' */ + memcpy(&ret[retlen], to, tolen); + retlen += tolen; + + remain = found + 1; + } else { + /* + * The last chunk. We are already sure that we have enough space + * so we can use strcpy. + */ + strcpy(&ret[retlen], remain); + break; + } + } + return ret; +} + +static void +replace_char(char *str, char from, char to) +{ + char *ptr; + + /* Don't use strchr here...*/ + while ((ptr = strchr(str, from)) != NULL) { + *ptr = to; + str = ptr + 1; + } +} + +static void +str_netfd_write(const char *str, int fd) +{ + xwrite(fd, str, strlen(str)); +} + +static void +ftp_write_str_common(unsigned int status, const char *str, char sep) +{ + char *escaped_str, *response; + size_t len; + + escaped_str = replace_text(str, '\377', "\377\377"); + + response = xasprintf("%u%c%s\r\n", status, sep, escaped_str); + free(escaped_str); + + len = strlen(response); + replace_char(escaped_str, '\n', '\0'); + + /* Change trailing '\0' back to '\n' */ + response[len - 1] = '\n'; + xwrite(STDIN_FILENO, response, len); +} + +static void +cmdio_write(int status, const char *p_text) +{ + ftp_write_str_common(status, p_text, ' '); +} + +static void +cmdio_write_hyphen(int status, const char *p_text) +{ + ftp_write_str_common(status, p_text, '-'); +} + +static void +cmdio_write_raw(const char *p_text) +{ + str_netfd_write(p_text, STDIN_FILENO); +} + +static uint32_t +cmdio_get_cmd_and_arg(void) +{ + int len; + uint32_t cmdval; + char *cmd; + + free(G.ftp_cmp); + G.ftp_cmp = cmd = xmalloc_reads(STDIN_FILENO, NULL, NULL); +/* + * TODO: + * + * now we should change all '\0' to '\n' - xmalloc_reads will be improved, + * probably + */ + len = strlen(cmd) - 1; + while (len >= 0 && cmd[len] == '\r') { + cmd[len] = '\0'; + len--; + } + + G.ftp_arg = strchr(cmd, ' '); + if (G.ftp_arg != NULL) { + *G.ftp_arg = '\0'; + G.ftp_arg++; + } + cmdval = 0; + while (*cmd) + cmdval = (cmdval << 8) + ((unsigned char)*cmd++ & (unsigned char)~0x20); + + return cmdval; +} + +static void +init_data_sock_params(int sock_fd) +{ + struct linger linger; + + G.data_fd = sock_fd; + + memset(&linger, 0, sizeof(linger)); + linger.l_onoff = 1; + linger.l_linger = 32767; + + setsockopt(sock_fd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1)); + setsockopt(sock_fd, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger)); +} + +static int +ftpdataio_get_pasv_fd(void) +{ + int remote_fd; + + remote_fd = accept(G.pasv_listen_fd, NULL, 0); + + if (remote_fd < 0) { + cmdio_write(FTP_BADSENDCONN, "Can't establish connection"); + return remote_fd; + } + + init_data_sock_params(remote_fd); + return remote_fd; +} + +static int +ftpdataio_get_port_fd(void) +{ + int remote_fd; + + /* Do we want die or print error to client? */ + remote_fd = xconnect_stream(G.port_addr); + + init_data_sock_params(remote_fd); + return remote_fd; +} + +static void +ftpdataio_dispose_transfer_fd(void) +{ + /* This close() blocks because we set SO_LINGER */ + if (G.data_fd > STDOUT_FILENO) { + if (close(G.data_fd) < 0) { + /* Do it again without blocking. */ + struct linger linger; + + memset(&linger, 0, sizeof(linger)); + setsockopt(G.data_fd, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger)); + close(G.data_fd); + } + } + G.data_fd = -1; +} + +static int +port_active(void) +{ + return (G.port_addr != NULL) ? 1: 0; +} + +static int +pasv_active(void) +{ + return (G.pasv_listen_fd != -1) ? 1 : 0; +} + +static int +get_remote_transfer_fd(const char *p_status_msg) +{ + int remote_fd; + + if (pasv_active()) + remote_fd = ftpdataio_get_pasv_fd(); + else + remote_fd = ftpdataio_get_port_fd(); + + if (remote_fd < 0) + return remote_fd; + + cmdio_write(FTP_DATACONN, p_status_msg); + return remote_fd; +} + +static void +handle_pwd(void) +{ + char *cwd, *promoted_cwd, *response; + + cwd = xrealloc_getcwd_or_warn(NULL); + if (cwd == NULL) + cwd = xstrdup(""); + + /* We _have to_ promote each " to "" */ + promoted_cwd = replace_text(cwd, '\"', "\"\""); + free(cwd); + response = xasprintf("\"%s\"", promoted_cwd); + free(promoted_cwd); + cmdio_write(FTP_PWDOK, response); + free(response); +} + +static void +handle_cwd(void) +{ + int retval; + + /* XXX Do we need check ftp_arg != NULL? */ + retval = chdir(G.ftp_arg); + if (retval == 0) + cmdio_write(FTP_CWDOK, "Directory changed"); + else + cmdio_write(FTP_FILEFAIL, "Can't change directory"); +} + +static void +handle_cdup(void) +{ + G.ftp_arg = xstrdup(".."); + handle_cwd(); + free(G.ftp_arg); +} + +static int +data_transfer_checks_ok(void) +{ + if (!pasv_active() && !port_active()) { + cmdio_write(FTP_BADSENDCONN, "Use PORT or PASV first"); + return 0; + } + + return 1; +} + +static void +port_cleanup(void) +{ + if (G.port_addr != NULL) + free(G.port_addr); + + G.port_addr = NULL; +} + +static void +pasv_cleanup(void) +{ + if (G.pasv_listen_fd > STDOUT_FILENO) + close(G.pasv_listen_fd); + G.pasv_listen_fd = -1; +} + +static char * +statbuf_getperms(const struct stat *statbuf) +{ + char *perms; + enum { r = 'r', w = 'w', x = 'x', s = 's', S = 'S' }; + + perms = xmalloc(11); + memset(perms, '-', 10); + + perms[0] = '?'; + switch (statbuf->st_mode & S_IFMT) { + case S_IFREG: perms[0] = '-'; break; + case S_IFDIR: perms[0] = 'd'; break; + case S_IFLNK: perms[0] = 'l'; break; + case S_IFIFO: perms[0] = 'p'; break; + case S_IFSOCK: perms[0] = s; break; + case S_IFCHR: perms[0] = 'c'; break; + case S_IFBLK: perms[0] = 'b'; break; + } + + if (statbuf->st_mode & S_IRUSR) perms[1] = r; + if (statbuf->st_mode & S_IWUSR) perms[2] = w; + if (statbuf->st_mode & S_IXUSR) perms[3] = x; + if (statbuf->st_mode & S_IRGRP) perms[4] = r; + if (statbuf->st_mode & S_IWGRP) perms[5] = w; + if (statbuf->st_mode & S_IXGRP) perms[6] = x; + if (statbuf->st_mode & S_IROTH) perms[7] = r; + if (statbuf->st_mode & S_IWOTH) perms[8] = w; + if (statbuf->st_mode & S_IXOTH) perms[9] = x; + if (statbuf->st_mode & S_ISUID) perms[3] = (perms[3] == x) ? s : S; + if (statbuf->st_mode & S_ISGID) perms[6] = (perms[6] == x) ? s : S; + if (statbuf->st_mode & S_ISVTX) perms[9] = (perms[9] == x) ? 't' : 'T'; + + perms[10] = '\0'; + + return perms; +} + +static void +write_filestats(int fd, const char *filename, + const struct stat *statbuf) +{ + off_t size; + char *stats, *lnkname = NULL, *perms; + const char *name; + int retval; + char timestr[32]; + struct tm *tm; + const char *format = "%b %d %H:%M"; + + name = bb_get_last_path_component_nostrip(filename); + + if (statbuf != NULL) { + size = statbuf->st_size; + + if (S_ISLNK(statbuf->st_mode)) + /* Damn symlink... */ + lnkname = xmalloc_readlink(filename); + + tm = gmtime(&statbuf->st_mtime); + retval = strftime(timestr, sizeof(timestr), format, tm); + if (retval == 0) + bb_error_msg_and_die("strftime"); + + timestr[sizeof(timestr) - 1] = '\0'; + + perms = statbuf_getperms(statbuf); + + stats = xasprintf("%s %u\tftp ftp %"OFF_FMT"u\t%s %s", + perms, (int) statbuf->st_nlink, + size, timestr, name); + + free(perms); + } else + stats = xstrdup(name); + + str_netfd_write(stats, fd); + free(stats); + if (lnkname != NULL) { + str_netfd_write(" -> ", fd); + str_netfd_write(lnkname, fd); + free(lnkname); + } + str_netfd_write("\r\n", fd); +} + +static void +write_dirstats(int fd, const char *dname, int details) +{ + DIR *dir; + struct dirent *dirent; + struct stat statbuf; + char *filename; + + dir = xopendir(dname); + + for (;;) { + dirent = readdir(dir); + if (dirent == NULL) + break; + + /* Ignore . and .. */ + if (dirent->d_name[0] == '.') { + if (dirent->d_name[1] == '\0' + || (dirent->d_name[1] == '.' && dirent->d_name[2] == '\0') + ) { + continue; + } + } + + if (details) { + filename = xasprintf("%s/%s", dname, dirent->d_name); + if (lstat(filename, &statbuf) != 0) { + free(filename); + goto bail; + } + } else + filename = xstrdup(dirent->d_name); + + write_filestats(fd, filename, details ? &statbuf : NULL); + free(filename); + } + +bail: + closedir(dir); +} + +static void +handle_pasv(void) +{ + int bind_retries = 10; + unsigned short port; + enum { min_port = 1024, max_port = 65535 }; + char *addr, *wire_addr, *response; + + pasv_cleanup(); + port_cleanup(); + G.pasv_listen_fd = xsocket(G.local_addr->u.sa.sa_family, SOCK_STREAM, 0); + setsockopt_reuseaddr(G.pasv_listen_fd); + + /* TODO bind() with port == 0 and then call getsockname */ + while (--bind_retries) { + port = rand() % max_port; + if (port < min_port) { + port += min_port; + } + + set_nport(G.local_addr, htons(port)); + /* We don't want to use xbind, it'll die if port is in use */ + if (bind(G.pasv_listen_fd, &G.local_addr->u.sa, G.local_addr->len) != 0) { + /* do we want check if errno == EADDRINUSE ? */ + continue; + } + xlisten(G.pasv_listen_fd, 1); + break; + } + + if (!bind_retries) + bb_error_msg_and_die("can't create pasv socket"); + + addr = xmalloc_sockaddr2dotted_noport(&G.local_addr->u.sa); + wire_addr = replace_text(addr, '.', ","); + free(addr); + + response = xasprintf("Entering Passive Mode (%s,%u,%u)", + wire_addr, (int)(port >> 8), (int)(port & 255)); + + cmdio_write(FTP_PASVOK, response); + free(wire_addr); + free(response); +} + +static void +handle_retr(void) +{ + struct stat statbuf; + int trans_ret, retval; + int remote_fd; + int opened_file; + off_t offset = G.restart_pos; + char *response; + + G.restart_pos = 0; + + if (!data_transfer_checks_ok()) + return; + + /* XXX Do we need check if ftp_arg != NULL? */ + opened_file = open(G.ftp_arg, O_RDONLY | O_NONBLOCK); + if (opened_file < 0) { + cmdio_write(FTP_FILEFAIL, "Can't open file"); + return; + } + + retval = fstat(opened_file, &statbuf); + if (retval < 0 || !S_ISREG(statbuf.st_mode)) { + /* Note - pretend open failed */ + cmdio_write(FTP_FILEFAIL, "Can't open file"); + goto file_close_out; + } + + /* Now deactive O_NONBLOCK, otherwise we have a problem on DMAPI filesystems + * such as XFS DMAPI. + */ + ndelay_off(opened_file); + + /* Set the download offset (from REST) if any */ + if (offset != 0) + xlseek(opened_file, offset, SEEK_SET); + + response = xasprintf( + "Opening BINARY mode data connection for (%s %"OFF_FMT"u bytes).", + G.ftp_arg, statbuf.st_size); + + remote_fd = get_remote_transfer_fd(response); + free(response); + if (remote_fd < 0) + goto port_pasv_cleanup_out; + + trans_ret = bb_copyfd_eof(opened_file, remote_fd); + ftpdataio_dispose_transfer_fd(); + if (trans_ret < 0) + cmdio_write(FTP_BADSENDFILE, "Error sending local file"); + else + cmdio_write(FTP_TRANSFEROK, "File sent OK"); + +port_pasv_cleanup_out: + port_cleanup(); + pasv_cleanup(); +file_close_out: + close(opened_file); +} + +static void +handle_dir_common(int full_details, int stat_cmd) +{ + int fd; + struct stat statbuf; + + if (!stat_cmd && !data_transfer_checks_ok()) + return; + + if (stat_cmd) { + fd = STDIN_FILENO; + cmdio_write_hyphen(FTP_STATFILE_OK, "Status follows:"); + } else { + fd = get_remote_transfer_fd("Here comes the directory listing"); + if (fd < 0) + goto bail; + } + + if (G.ftp_arg != NULL) { + if (lstat(G.ftp_arg, &statbuf) != 0) { + /* Dir doesn't exist => return ok to client */ + goto bail; + } + if (S_ISREG(statbuf.st_mode) || S_ISLNK(statbuf.st_mode)) + write_filestats(fd, G.ftp_arg, &statbuf); + else if (S_ISDIR(statbuf.st_mode)) + write_dirstats(fd, G.ftp_arg, full_details); + } else + write_dirstats(fd, ".", full_details); + +bail: + /* Well, if we can't open directory/file it doesn't matter */ + if (!stat_cmd) { + ftpdataio_dispose_transfer_fd(); + pasv_cleanup(); + port_cleanup(); + cmdio_write(FTP_TRANSFEROK, "OK"); + } else + cmdio_write(FTP_STATFILE_OK, "End of status"); +} + +static void +handle_list(void) +{ + handle_dir_common(1, 0); +} + +static void +handle_type(void) +{ + if (G.ftp_arg + && ( ((G.ftp_arg[0] | 0x20) == 'i' && G.ftp_arg[1] == '\0') + || !strcasecmp(G.ftp_arg, "L8") + || !strcasecmp(G.ftp_arg, "L 8") + ) + ) { + cmdio_write(FTP_TYPEOK, "Switching to Binary mode"); + } else { + cmdio_write(FTP_BADCMD, "Unrecognised TYPE command"); + } +} + +static void +handle_port(void) +{ + unsigned short port; + char *raw = NULL, *port_part; + len_and_sockaddr *lsa = NULL; + + pasv_cleanup(); + port_cleanup(); + + if (G.ftp_arg == NULL) + goto bail; + + raw = replace_text(G.ftp_arg, ',', "."); + + port_part = strrchr(raw, '.'); + if (port_part == NULL) + goto bail; + + port = xatou16(&port_part[1]); + *port_part = '\0'; + + port_part = strrchr(raw, '.'); + if (port_part == NULL) + goto bail; + + port |= xatou16(&port_part[1]) << 8; + *port_part = '\0'; + + lsa = xdotted2sockaddr(raw, port); + +bail: + free(raw); + + if (lsa == NULL) { + cmdio_write(FTP_BADCMD, "Illegal PORT command"); + return; + } + + G.port_addr = lsa; + cmdio_write(FTP_PORTOK, "PORT command successful. Consider using PASV"); +} + +#if ENABLE_FEATURE_FTP_WRITE +static void +handle_upload_common(int is_append, int is_unique) +{ + char *template = NULL; + int trans_ret; + int new_file_fd; + int remote_fd; + + enum { + fileflags = O_CREAT | O_WRONLY | O_APPEND, + }; + + off_t offset = G.restart_pos; + + G.restart_pos = 0; + if (!data_transfer_checks_ok()) + return; + + if (is_unique) { + template = xstrdup("uniq.XXXXXX"); + /* + * XXX Use mkostemp here? vsftpd opens file with O_CREAT, O_WRONLY, + * O_APPEND and O_EXCL flags... + */ + new_file_fd = mkstemp(template); + } else { + /* XXX Do we need check if ftp_arg != NULL? */ + if (!is_append && offset == 0) + new_file_fd = open(G.ftp_arg, O_CREAT | O_WRONLY | O_APPEND | O_NONBLOCK | O_TRUNC, 0666); + else + new_file_fd = open(G.ftp_arg, O_CREAT | O_WRONLY | O_APPEND | O_NONBLOCK, 0666); + } + + if (new_file_fd < 0) { + cmdio_write(FTP_UPLOADFAIL, "Can't create file"); + return; + } + + if (!is_append && offset != 0) { + /* warning, allows seek past end of file! Check for seek > size? */ + xlseek(new_file_fd, offset, SEEK_SET); + } + + if (is_unique) { + char *resp = xasprintf("FILE: %s", template); + remote_fd = get_remote_transfer_fd(resp); + free(resp); + free(template); + } else + remote_fd = get_remote_transfer_fd("Ok to send data"); + + if (remote_fd < 0) + goto bail; + + trans_ret = bb_copyfd_eof(remote_fd, new_file_fd); + ftpdataio_dispose_transfer_fd(); + + if (trans_ret < 0) + cmdio_write(FTP_BADSENDFILE, "Failure writing to local file"); + else + cmdio_write(FTP_TRANSFEROK, "File receive OK"); + +bail: + port_cleanup(); + pasv_cleanup(); + close(new_file_fd); +} + +static void +handle_stor(void) +{ + handle_upload_common(0, 0); +} + +static void +handle_mkd(void) +{ + int retval; + + /* Do we need check if ftp_arg != NULL? */ + retval = mkdir(G.ftp_arg, 0770); + if (retval != 0) { + cmdio_write(FTP_FILEFAIL, "Create directory operation failed"); + return; + } + + cmdio_write(FTP_MKDIROK, "created"); +} + +static void +handle_rmd(void) +{ + int retval; + + /* Do we need check if ftp_arg != NULL? */ + retval = rmdir(G.ftp_arg); + if (retval != 0) + cmdio_write(FTP_FILEFAIL, "rmdir failed"); + else + cmdio_write(FTP_RMDIROK, "rmdir successful"); +} + +static void +handle_dele(void) +{ + int retval; + + /* Do we need check if ftp_arg != NULL? */ + retval = unlink(G.ftp_arg); + if (retval != 0) + cmdio_write(FTP_FILEFAIL, "Delete failed"); + else + cmdio_write(FTP_DELEOK, "Delete successful"); +} +#endif /* ENABLE_FEATURE_FTP_WRITE */ + +static void +handle_rest(void) +{ + /* When ftp_arg == NULL simply restart from beginning */ + G.restart_pos = xatoi_u(G.ftp_arg); + cmdio_write(FTP_RESTOK, "Restart OK"); +} + +#if ENABLE_FEATURE_FTP_WRITE +static void +handle_rnfr(void) +{ + struct stat statbuf; + int retval; + + /* Clear old value */ + free(G.rnfr_filename); + + /* Does it exist? Do we need check if ftp_arg != NULL? */ + retval = stat(G.ftp_arg, &statbuf); + if (retval == 0) { + /* Yes */ + G.rnfr_filename = xstrdup(G.ftp_arg); + cmdio_write(FTP_RNFROK, "Ready for RNTO"); + } else + cmdio_write(FTP_FILEFAIL, "RNFR command failed"); +} + +static void +handle_rnto(void) +{ + int retval; + + /* If we didn't get a RNFR, throw a wobbly */ + if (G.rnfr_filename == NULL) { + cmdio_write(FTP_NEEDRNFR, "RNFR required first"); + return; + } + + /* XXX Do we need check if ftp_arg != NULL? */ + retval = rename(G.rnfr_filename, G.ftp_arg); + + free(G.rnfr_filename); + + if (retval == 0) + cmdio_write(FTP_RENAMEOK, "Rename successful"); + else + cmdio_write(FTP_FILEFAIL, "Rename failed"); +} +#endif /* ENABLE_FEATURE_FTP_WRITE */ + +static void +handle_nlst(void) +{ + handle_dir_common(0, 0); +} + +#if ENABLE_FEATURE_FTP_WRITE +static void +handle_appe(void) +{ + handle_upload_common(1, 0); +} +#endif + +static void +handle_help(void) +{ + cmdio_write_hyphen(FTP_HELP, "Recognized commands:"); + cmdio_write_raw(" ALLO CDUP CWD HELP LIST\r\n" + " MODE NLST NOOP PASS PASV PORT PWD QUIT\r\n" + " REST RETR STAT STRU SYST TYPE USER\r\n" +#if ENABLE_FEATURE_FTP_WRITE + " APPE DELE MKD RMD RNFR RNTO STOR STOU\r\n" +#endif + ); + cmdio_write(FTP_HELP, "Help OK"); +} + +#if ENABLE_FEATURE_FTP_WRITE +static void +handle_stou(void) +{ + handle_upload_common(0, 1); +} +#endif + +static void +handle_stat(void) +{ + cmdio_write_hyphen(FTP_STATOK, "FTP server status:"); + cmdio_write_raw(" TYPE: BINARY\r\n"); + cmdio_write(FTP_STATOK, "End of status"); +} + +static void +handle_stat_file(void) +{ + handle_dir_common(1, 1); +} + +/* TODO: libbb candidate (tftp has another copy) */ +static len_and_sockaddr *get_sock_lsa(int s) +{ + len_and_sockaddr *lsa; + socklen_t len = 0; + + if (getsockname(s, NULL, &len) != 0) + return NULL; + lsa = xzalloc(LSA_LEN_SIZE + len); + lsa->len = len; + getsockname(s, &lsa->u.sa, &lsa->len); + return lsa; +} + +int ftpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int ftpd_main(int argc UNUSED_PARAM, char **argv) +{ + smallint user_was_specified = 0; + + INIT_G(); + + G.local_addr = get_sock_lsa(STDIN_FILENO); + if (!G.local_addr) { + /* This is confusing: + * bb_error_msg_and_die("stdin is not a socket"); + * Better: */ + bb_show_usage(); + /* Help text says that ftpd must be used as inetd service, + * which is by far the most usual cause of get_sock_lsa + * failure */ + } + + logmode = LOGMODE_SYSLOG; + + USE_FEATURE_FTP_WRITE(G.write_enable =) getopt32(argv, "" USE_FEATURE_FTP_WRITE("w")); + if (argv[optind]) { + xchdir(argv[optind]); + chroot("."); + } + +// if (G.local_addr->u.sa.sa_family != AF_INET) +// bb_error_msg_and_die("Only IPv4 is supported"); + + /* Signals. We'll always take -EPIPE rather than a rude signal, thanks */ + signal(SIGPIPE, SIG_IGN); + + /* Set up options on the command socket */ + setsockopt(STDIN_FILENO, IPPROTO_TCP, TCP_NODELAY, &const_int_1, sizeof(const_int_1)); + setsockopt(STDIN_FILENO, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1)); + setsockopt(STDIN_FILENO, SOL_SOCKET, SO_OOBINLINE, &const_int_1, sizeof(const_int_1)); + + cmdio_write(FTP_GREET, "Welcome"); + + while (1) { + uint32_t cmdval = cmdio_get_cmd_and_arg(); + + if (cmdval == const_USER) { + if (G.ftp_arg == NULL || strcasecmp(G.ftp_arg, "anonymous") != 0) + cmdio_write(FTP_LOGINERR, "Server is anonymous only"); + else { + user_was_specified = 1; + cmdio_write(FTP_GIVEPWORD, "Please specify the password"); + } + } else if (cmdval == const_PASS) { + if (user_was_specified) + break; + cmdio_write(FTP_NEEDUSER, "Login with USER"); + } else if (cmdval == const_QUIT) { + cmdio_write(FTP_GOODBYE, "Goodbye"); + return 0; + } else { + cmdio_write(FTP_LOGINERR, + "Login with USER and PASS"); + } + } + + umask(077); + cmdio_write(FTP_LOGINOK, "Login successful"); + + while (1) { + uint32_t cmdval = cmdio_get_cmd_and_arg(); + + if (cmdval == const_QUIT) { + cmdio_write(FTP_GOODBYE, "Goodbye"); + return 0; + } + if (cmdval == const_PWD) + handle_pwd(); + else if (cmdval == const_CWD) + handle_cwd(); + else if (cmdval == const_CDUP) + handle_cdup(); + else if (cmdval == const_PASV) + handle_pasv(); + else if (cmdval == const_RETR) + handle_retr(); + else if (cmdval == const_NOOP) + cmdio_write(FTP_NOOPOK, "NOOP ok"); + else if (cmdval == const_SYST) + cmdio_write(FTP_SYSTOK, "UNIX Type: L8"); + else if (cmdval == const_HELP) + handle_help(); + else if (cmdval == const_LIST) + handle_list(); + else if (cmdval == const_TYPE) + handle_type(); + else if (cmdval == const_PORT) + handle_port(); + else if (cmdval == const_REST) + handle_rest(); + else if (cmdval == const_NLST) + handle_nlst(); +#if ENABLE_FEATURE_FTP_WRITE + else if (G.write_enable) { + if (cmdval == const_STOR) + handle_stor(); + else if (cmdval == const_MKD) + handle_mkd(); + else if (cmdval == const_RMD) + handle_rmd(); + else if (cmdval == const_DELE) + handle_dele(); + else if (cmdval == const_RNFR) + handle_rnfr(); + else if (cmdval == const_RNTO) + handle_rnto(); + else if (cmdval == const_APPE) + handle_appe(); + else if (cmdval == const_STOU) + handle_stou(); + } +#endif + else if (cmdval == const_STRU) { + if (G.ftp_arg + && (G.ftp_arg[0] | 0x20) == 'f' + && G.ftp_arg[1] == '\0' + ) { + cmdio_write(FTP_STRUOK, "Structure set to F"); + } else + cmdio_write(FTP_BADSTRU, "Bad STRU command"); + + } else if (cmdval == const_MODE) { + if (G.ftp_arg + && (G.ftp_arg[0] | 0x20) == 's' + && G.ftp_arg[1] == '\0' + ) { + cmdio_write(FTP_MODEOK, "Mode set to S"); + } else + cmdio_write(FTP_BADMODE, "Bad MODE command"); + } + else if (cmdval == const_ALLO) + cmdio_write(FTP_ALLOOK, "ALLO command ignored"); + else if (cmdval == const_STAT) { + if (G.ftp_arg == NULL) + handle_stat(); + else + handle_stat_file(); + } else if (cmdval == const_USER) + cmdio_write(FTP_LOGINERR, "Can't change to another user"); + else if (cmdval == const_PASS) + cmdio_write(FTP_LOGINOK, "Already logged in"); + else if (cmdval == const_STOR + || cmdval == const_MKD + || cmdval == const_RMD + || cmdval == const_DELE + || cmdval == const_RNFR + || cmdval == const_RNTO + || cmdval == const_APPE + || cmdval == const_STOU + ) { + cmdio_write(FTP_NOPERM, "Permission denied"); + } else { + cmdio_write(FTP_BADCMD, "Unknown command"); + } + } +} |