1284 lines
42 KiB
C
1284 lines
42 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sqlite3.h>
|
|
#include <limits.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/select.h>
|
|
#include <netinet/in.h>
|
|
#include <stdarg.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <sys/wait.h>
|
|
#include "mnetftpd.h"
|
|
#include "../../src/inih/ini.h"
|
|
|
|
static struct ftpclient **clients;
|
|
static int client_count = 0;
|
|
|
|
static struct user_t **users;
|
|
static int user_count = 0;
|
|
|
|
char *logfile = NULL;
|
|
|
|
struct dllist {
|
|
char *data;
|
|
struct dllist *prev;
|
|
struct dllist *next;
|
|
};
|
|
|
|
void dolog(char *fmt, ...) {
|
|
char buffer[PATH_MAX];
|
|
struct tm time_now;
|
|
time_t timen;
|
|
FILE *logfptr;
|
|
int mypid = getpid();
|
|
|
|
if (logfile == NULL) return;
|
|
|
|
timen = time(NULL);
|
|
|
|
localtime_r(&timen, &time_now);
|
|
|
|
logfptr = fopen(logfile, "a");
|
|
if (!logfptr) {
|
|
return;
|
|
}
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(buffer, PATH_MAX, fmt, ap);
|
|
va_end(ap);
|
|
|
|
fprintf(logfptr, "%04d-%02d-%02d %02d:%02d:%02d [%d] %s\n", time_now.tm_year + 1900, time_now.tm_mon + 1, time_now.tm_mday, time_now.tm_hour, time_now.tm_min, time_now.tm_sec, mypid, buffer);
|
|
|
|
fclose(logfptr);
|
|
}
|
|
|
|
void sigchld_handler(int s)
|
|
{
|
|
// waitpid() might overwrite errno, so we save and restore it:
|
|
int saved_errno = errno;
|
|
|
|
while(waitpid(-1, NULL, WNOHANG) > 0);
|
|
|
|
errno = saved_errno;
|
|
}
|
|
|
|
static void parse_path(struct ftpclient *client, char *path, char **result) {
|
|
struct dllist *proot;
|
|
struct dllist *pptr;
|
|
char *rescpy;
|
|
char *ptr;
|
|
char *newpath = *result;
|
|
|
|
proot = (struct dllist *)malloc(sizeof(struct dllist));
|
|
|
|
if (!proot) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(-1);
|
|
}
|
|
|
|
proot->next = NULL;
|
|
proot->prev = NULL;
|
|
proot->data = NULL;
|
|
|
|
pptr = proot;
|
|
|
|
if (path[0] == '/') {
|
|
rescpy = strdup(path);
|
|
} else {
|
|
if (client->current_path == NULL) {
|
|
rescpy = (char *)malloc(strlen(path + 2));
|
|
} else if (strcmp(client->current_path, client->user->indir) == 0) {
|
|
rescpy = (char *)malloc(strlen(path) + 4);
|
|
} else if (strcmp(client->current_path, client->user->outdir) == 0) {
|
|
rescpy = (char *)malloc(strlen(path) + 5);
|
|
}
|
|
if (!rescpy) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(-1);
|
|
|
|
}
|
|
if (client->current_path == NULL) {
|
|
sprintf(rescpy, "/%s",path);
|
|
} else if (strcmp(client->current_path, client->user->indir) == 0) {
|
|
sprintf(rescpy, "in/%s",path);
|
|
} else if (strcmp(client->current_path, client->user->outdir) == 0) {
|
|
sprintf(rescpy, "out/%s",path);
|
|
}
|
|
|
|
}
|
|
ptr = strtok(rescpy, "/");
|
|
|
|
while (ptr != NULL) {
|
|
if (strcmp(ptr, "..") == 0) {
|
|
if (pptr->prev != NULL) {
|
|
pptr = pptr->prev;
|
|
free(pptr->next);
|
|
pptr->next = NULL;
|
|
pptr->data = NULL;
|
|
}
|
|
} else if (strcmp(ptr, ".") != 0) {
|
|
pptr->data = ptr;
|
|
pptr->next = (struct dllist *)malloc(sizeof(struct dllist));
|
|
if (!pptr->next) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(-1);
|
|
}
|
|
pptr->next->data = NULL;
|
|
pptr->next->prev = pptr;
|
|
pptr->next->next = NULL;
|
|
|
|
pptr = pptr->next;
|
|
}
|
|
|
|
ptr = strtok(NULL, "/");
|
|
}
|
|
|
|
newpath[0] = '\0';
|
|
pptr = proot;
|
|
|
|
int i = 0;
|
|
|
|
while (pptr != NULL && pptr->data != NULL) {
|
|
if (i + strlen(pptr->data) + 2 > PATH_MAX) {
|
|
break;
|
|
}
|
|
newpath[i++] = '/';
|
|
memcpy(&newpath[i], pptr->data, strlen(pptr->data));
|
|
i += strlen(pptr->data);
|
|
newpath[i] = '\0';
|
|
pptr = pptr->next;
|
|
}
|
|
|
|
pptr = proot;
|
|
|
|
while (pptr != NULL) {
|
|
if (pptr->next != NULL) {
|
|
pptr = pptr->next;
|
|
free(pptr->prev);
|
|
} else {
|
|
free(pptr);
|
|
pptr = NULL;
|
|
}
|
|
}
|
|
free(rescpy);
|
|
}
|
|
|
|
static int handler(void* user, const char* section, const char* name, const char* value) {
|
|
struct ftpserver *cfg = (struct ftpserver *)user;
|
|
struct user_t *newuser;
|
|
int i;
|
|
|
|
if (strcasecmp(section, "main") == 0) {
|
|
if (strcasecmp(name, "port") == 0) {
|
|
cfg->port = atoi(value);
|
|
} else if (strcasecmp(name, "min passive port") == 0) {
|
|
cfg->min_passive_port = atoi(value);
|
|
} else if (strcasecmp(name, "max passive port") == 0) {
|
|
cfg->max_passive_port = atoi(value);
|
|
} else if (strcasecmp(name, "enable ipv6") == 0) {
|
|
if (strcasecmp(value, "true") == 0) {
|
|
cfg->ipv6 = 1;
|
|
} else {
|
|
cfg->ipv6 = 0;
|
|
}
|
|
} else if (strcasecmp(name, "log file") == 0) {
|
|
logfile = strdup(value);
|
|
}
|
|
} else {
|
|
newuser = NULL;
|
|
for (i=0;i<user_count;i++) {
|
|
if (strcmp(users[i]->username, section) == 0) {
|
|
newuser = users[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (newuser == NULL) {
|
|
if (user_count == 0) {
|
|
users = (struct user_t **)malloc(sizeof(struct user_t *));
|
|
} else {
|
|
users = (struct user_t **)realloc(users, sizeof(struct user_t *) * (user_count + 1));
|
|
}
|
|
users[user_count] = (struct user_t *)malloc(sizeof(struct user_t));
|
|
|
|
newuser = users[user_count];
|
|
newuser->username = strdup(section);
|
|
newuser->password = NULL;
|
|
newuser->indir = NULL;
|
|
newuser->outdir = NULL;
|
|
user_count++;
|
|
}
|
|
|
|
if (strcasecmp(name, "Password") == 0) {
|
|
newuser->password = strdup(value);
|
|
} else if (strcasecmp(name, "In Directory") == 0) {
|
|
newuser->indir = strdup(value);
|
|
} else if (strcasecmp(name, "Out Directory") == 0) {
|
|
newuser->outdir = strdup(value);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void send_data(struct ftpclient *client, char *msg, int len) {
|
|
int n = 0;
|
|
|
|
while (len > 0) {
|
|
n = send(client->data_socket, msg + n, len, 0);
|
|
len -= n;
|
|
}
|
|
}
|
|
|
|
void send_msg(struct ftpclient *client, char *msg) {
|
|
int len = strlen(msg);
|
|
int n = 0;
|
|
|
|
while (len > 0) {
|
|
n = send(client->fd, msg + n, len, 0);
|
|
len -= n;
|
|
}
|
|
}
|
|
|
|
void close_tcp_connection(struct ftpclient* client) {
|
|
if (client->data_srv_socket > 0) {
|
|
close(client->data_srv_socket);
|
|
client->data_srv_socket = -1;
|
|
}
|
|
if (client->data_socket > 0) {
|
|
close(client->data_socket);
|
|
client->data_socket = -1;
|
|
}
|
|
if (strlen(client->data_ip) > 0) {
|
|
memset(client->data_ip, 0, INET6_ADDRSTRLEN);
|
|
client->data_port = 0;
|
|
}
|
|
}
|
|
|
|
int open_tcp_connection(struct ftpserver *cfg, struct ftpclient *client) {
|
|
if (client->ipver == 6) {
|
|
if (strlen(client->data_ip) != 0) {
|
|
client->data_socket = socket(AF_INET6, SOCK_STREAM, 0);
|
|
struct sockaddr_in6 servaddr;
|
|
servaddr.sin6_family = AF_INET6;
|
|
servaddr.sin6_port = htons(client->data_port);
|
|
if (inet_pton(AF_INET6, client->data_ip, &(servaddr.sin6_addr)) <= 0) {
|
|
fprintf(stderr, "Error in port command\n");
|
|
return 0;
|
|
}
|
|
if (connect(client->data_socket, (struct sockaddr *) &servaddr, sizeof(servaddr)) == -1) {
|
|
perror("Connect");
|
|
fprintf(stderr, "Error connecting to client\n");
|
|
return 0;
|
|
}
|
|
} else if (client->data_srv_socket != 0) {
|
|
socklen_t sock = sizeof(struct sockaddr);
|
|
struct sockaddr_in6 data_client;
|
|
client->data_socket = accept(client->data_srv_socket, (struct sockaddr*) &data_client, &sock);
|
|
|
|
if (client->data_socket < 0) {
|
|
fprintf(stderr, "Accept Error\n");
|
|
return 0;
|
|
}
|
|
}
|
|
} else {
|
|
if (strlen(client->data_ip) != 0) {
|
|
client->data_socket = socket(AF_INET, SOCK_STREAM, 0);
|
|
struct sockaddr_in servaddr;
|
|
servaddr.sin_family = AF_INET;
|
|
servaddr.sin_port = htons(client->data_port);
|
|
if (inet_pton(AF_INET, client->data_ip, &(servaddr.sin_addr)) <= 0) {
|
|
fprintf(stderr, "Error in port command\n");
|
|
return 0;
|
|
}
|
|
if (connect(client->data_socket, (struct sockaddr *) &servaddr, sizeof(servaddr)) == -1) {
|
|
perror("Connect");
|
|
fprintf(stderr, "Error connecting to client\n");
|
|
return 0;
|
|
}
|
|
} else if (client->data_srv_socket != 0) {
|
|
socklen_t sock = sizeof(struct sockaddr);
|
|
struct sockaddr_in data_client;
|
|
client->data_socket = accept(client->data_srv_socket, (struct sockaddr*) &data_client, &sock);
|
|
|
|
if (client->data_socket < 0) {
|
|
fprintf(stderr, "Accept Error\n");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void handle_STOR(struct ftpserver *cfg, struct ftpclient *client, char *path) {
|
|
char *newpath;
|
|
struct stat s;
|
|
pid_t pid;
|
|
char buffer[1024];
|
|
char fullpath[PATH_MAX];
|
|
char fullpathpart[PATH_MAX];
|
|
int j;
|
|
FILE *fptr;
|
|
|
|
newpath = (char *)malloc(PATH_MAX);
|
|
parse_path(client, path, &newpath);
|
|
|
|
if (newpath[0] == '/') {
|
|
if (strncmp(newpath, "/in", 3) == 0) {
|
|
send_msg(client, "532 Access Denied.\n");
|
|
free(newpath);
|
|
return;
|
|
} else if (strncmp(newpath, "/out", 4) == 0) {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, &newpath[5]);
|
|
} else {
|
|
send_msg(client, "532 Access Denied.\n");
|
|
free(newpath);
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
if (strcmp(client->current_path, client->user->outdir) == 0) {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, newpath);
|
|
} else {
|
|
send_msg(client, "532 Access Denied.\n");
|
|
free(newpath);
|
|
return;
|
|
}
|
|
}
|
|
|
|
snprintf(fullpathpart, PATH_MAX, "%s.part", fullpath);
|
|
|
|
if (stat(fullpathpart, &s) != 0 && stat(fullpath, &s) != 0) {
|
|
pid = fork();
|
|
if (pid == 0) {
|
|
|
|
fptr = fopen(fullpathpart, "wb");
|
|
if (fptr) {
|
|
if (open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
while (1) {
|
|
j = recv(client->data_socket, buffer, 1024, 0);
|
|
if (j == 0) {
|
|
break;
|
|
}
|
|
if (j < 0) {
|
|
send_msg(client, "426 TCP connection was established but then broken\r\n");
|
|
fclose(fptr);
|
|
unlink(fullpathpart);
|
|
close_tcp_connection(client);
|
|
exit(0);
|
|
}
|
|
fwrite(buffer, 1, j, fptr);
|
|
}
|
|
fclose(fptr);
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer OK.\r\n");
|
|
rename(fullpathpart, fullpath);
|
|
exit(0);
|
|
} else {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
fclose(fptr);
|
|
exit(0);
|
|
}
|
|
}
|
|
} else if (pid < 0) {
|
|
send_msg(client, "451 STOR Failed.\r\n");
|
|
} else {
|
|
close_tcp_connection(client);
|
|
}
|
|
} else {
|
|
send_msg(client, "553 File Exists.\n");
|
|
}
|
|
}
|
|
|
|
void handle_EPSV(struct ftpserver *cfg, struct ftpclient *client) {
|
|
struct sockaddr_in6 server;
|
|
struct sockaddr_in server4;
|
|
|
|
if (client->data_socket > 0) {
|
|
close(client->data_socket);
|
|
client->data_socket = -1;
|
|
}
|
|
|
|
if (client->data_srv_socket > 0) {
|
|
close(client->data_srv_socket);
|
|
}
|
|
|
|
if (client->ipver == 6) {
|
|
client->data_srv_socket = socket(AF_INET6, SOCK_STREAM, 0);
|
|
} else {
|
|
client->data_srv_socket = socket(AF_INET, SOCK_STREAM, 0);
|
|
}
|
|
if (client->data_srv_socket < 0) {
|
|
send_msg(client, "500 EPSV failure.\r\n");
|
|
return;
|
|
}
|
|
|
|
if (client->ipver == 6) {
|
|
server.sin6_family = AF_INET6;
|
|
server.sin6_addr = in6addr_any;
|
|
} else {
|
|
server4.sin_family = AF_INET;
|
|
server4.sin_addr.s_addr = INADDR_ANY;
|
|
}
|
|
|
|
cfg->last_passive_port++;
|
|
if (cfg->last_passive_port == cfg->max_passive_port) {
|
|
cfg->last_passive_port = cfg->min_passive_port;
|
|
}
|
|
|
|
int port = cfg->last_passive_port;
|
|
|
|
if (client->ipver == 6) {
|
|
server.sin6_port = htons(port);
|
|
if (bind(client->data_srv_socket, (struct sockaddr*) &server, sizeof(server)) < 0) {
|
|
send_msg(client, "500 EPSV failure\r\n");
|
|
return;
|
|
}
|
|
} else {
|
|
server4.sin_port = htons(port);
|
|
if (bind(client->data_srv_socket, (struct sockaddr*) &server4, sizeof(server4)) < 0) {
|
|
send_msg(client, "500 EPSV failure\r\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (listen(client->data_srv_socket, 1) < 0) {
|
|
send_msg(client, "500 EPSV failure\r\n");
|
|
return;
|
|
}
|
|
|
|
char buffer[256];
|
|
sprintf(buffer, "229 Entering Extended Passive Mode (|||%d|)\r\n", port);
|
|
|
|
send_msg(client, buffer);
|
|
}
|
|
|
|
void handle_PASV(struct ftpserver *cfg, struct ftpclient *client) {
|
|
char buffer[200];
|
|
char *ipcpy;
|
|
char *ipptr;
|
|
if (client->data_socket > 0) {
|
|
close(client->data_socket);
|
|
client->data_socket = -1;
|
|
}
|
|
|
|
if (client->data_srv_socket > 0) {
|
|
close(client->data_srv_socket);
|
|
}
|
|
|
|
client->data_srv_socket = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (client->data_srv_socket < 0) {
|
|
send_msg(client, "426 PASV failure.\r\n");
|
|
return;
|
|
}
|
|
struct sockaddr_in server;
|
|
server.sin_family = AF_INET;
|
|
server.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
cfg->last_passive_port++;
|
|
if (cfg->last_passive_port == cfg->max_passive_port) {
|
|
cfg->last_passive_port = cfg->min_passive_port;
|
|
}
|
|
|
|
int port = cfg->last_passive_port;
|
|
|
|
server.sin_port = htons(port);
|
|
|
|
if (bind(client->data_srv_socket, (struct sockaddr*) &server, sizeof(server)) < 0) {
|
|
send_msg(client, "426 PASV failure\r\n");
|
|
return;
|
|
}
|
|
|
|
if (listen(client->data_srv_socket, 1) < 0) {
|
|
send_msg(client, "426 PASV failure\r\n");
|
|
return;
|
|
}
|
|
|
|
struct sockaddr_in file_addr;
|
|
socklen_t file_sock_len = sizeof(struct sockaddr_in);
|
|
getsockname(client->data_srv_socket, (struct sockaddr*) &file_addr, &file_sock_len);
|
|
|
|
ipcpy = strdup(client->hostip);
|
|
|
|
ipptr = strtok(ipcpy, ".");
|
|
|
|
strcpy(buffer, "227 Entering Passive Mode (");
|
|
while (ipptr != NULL) {
|
|
sprintf(buffer, "%s%s,", buffer, ipptr);
|
|
ipptr = strtok(NULL, ".");
|
|
}
|
|
|
|
sprintf(buffer, "%s%d,%d)\r\n", buffer, port / 256, port % 256);
|
|
send_msg(client, buffer);
|
|
free(ipcpy);
|
|
}
|
|
|
|
void handle_DELE(struct ftpserver *cfg, struct ftpclient *client, char *file) {
|
|
char *newpath;
|
|
char fullpath[PATH_MAX];
|
|
|
|
if (client->current_path == NULL) {
|
|
send_msg(client, "451 RETR Failed.\r\n");
|
|
return;
|
|
}
|
|
|
|
newpath = (char *)malloc(PATH_MAX);
|
|
parse_path(client, file, &newpath);
|
|
|
|
if (newpath[0] == '/') {
|
|
if (strncmp(newpath, "/in", 3) == 0) {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, &newpath[4]);
|
|
} else if (strncmp(newpath, "/out", 4) == 0) {
|
|
send_msg(client, "451 DELE Failed.\r\n");
|
|
free(newpath);
|
|
return;
|
|
} else {
|
|
send_msg(client, "451 DELE Failed.\r\n");
|
|
free(newpath);
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, newpath);
|
|
}
|
|
|
|
if (unlink(fullpath) != 0) {
|
|
send_msg(client, "451 DELE Failed.\r\n");
|
|
} else {
|
|
send_msg(client, "213 Delete Successful.\r\n");
|
|
}
|
|
free(newpath);
|
|
return;
|
|
}
|
|
|
|
void handle_RETR(struct ftpserver *cfg, struct ftpclient *client, char *file) {
|
|
char *newpath;
|
|
char fullpath[PATH_MAX];
|
|
FILE *fptr;
|
|
char buffer[1024];
|
|
|
|
if (client->current_path == NULL) {
|
|
send_msg(client, "451 RETR Failed.\r\n");
|
|
return;
|
|
}
|
|
|
|
newpath = (char *)malloc(PATH_MAX);
|
|
parse_path(client, file, &newpath);
|
|
|
|
|
|
if (newpath[0] == '/') {
|
|
if (strncmp(newpath, "/in", 3) == 0) {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, &newpath[4]);
|
|
} else if (strncmp(newpath, "/out", 4) == 0) {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, &newpath[5]);
|
|
} else {
|
|
send_msg(client, "451 RETR Failed.\r\n");
|
|
free(newpath);
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
snprintf(fullpath, PATH_MAX, "%s/%s", client->current_path, newpath);
|
|
}
|
|
|
|
free(newpath);
|
|
struct stat s;
|
|
pid_t pid = fork();
|
|
int n;
|
|
|
|
if (pid > 0) {
|
|
// nothing
|
|
close_tcp_connection(client);
|
|
} else if (pid == 0) {
|
|
|
|
if (stat(fullpath, &s) == 0) {
|
|
if (!S_ISDIR(s.st_mode)) {
|
|
fptr = fopen(fullpath, "rb");
|
|
if (fptr) {
|
|
if (open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
do {
|
|
n = fread(buffer, 1, 1024, fptr);
|
|
send_data(client, buffer, n);
|
|
} while (n == 1024);
|
|
fclose(fptr);
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer OK.\r\n");
|
|
exit(0);
|
|
} else {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
fclose(fptr);
|
|
exit(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
send_msg(client, "451 RETR Failed.\r\n");
|
|
exit(0);
|
|
} else {
|
|
send_msg(client, "451 RETR Failed.\r\n");
|
|
}
|
|
}
|
|
|
|
void handle_LIST(struct ftpserver *cfg, struct ftpclient *client) {
|
|
DIR *dirp;
|
|
struct dirent *dp;
|
|
char newpath[PATH_MAX];
|
|
char linebuffer[PATH_MAX];
|
|
struct stat s;
|
|
struct tm file_tm;
|
|
struct tm now_tm;
|
|
time_t now;
|
|
char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
|
|
pid_t pid = fork();
|
|
|
|
if (pid > 0) {
|
|
// nothing
|
|
close_tcp_connection(client);
|
|
} else if (pid == 0) {
|
|
if (client->current_path == NULL) {
|
|
if (!open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
exit(0);
|
|
}
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
now = time(NULL);
|
|
localtime_r(&now, &now_tm);
|
|
if (stat(client->user->indir, &s) == 0) {
|
|
snprintf(linebuffer, PATH_MAX, "dr-x------ 2 0 0 4096 %s %d %02d:%02d in\r\n", months[now_tm.tm_mon], now_tm.tm_mday, now_tm.tm_hour, now_tm.tm_min);
|
|
}
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
if (stat(client->user->outdir, &s) == 0) {
|
|
snprintf(linebuffer, PATH_MAX, "drwx------ 2 0 0 4096 %s %d %02d:%02d out\r\n", months[now_tm.tm_mon], now_tm.tm_mday, now_tm.tm_hour, now_tm.tm_min);
|
|
}
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer ok.\r\n");
|
|
exit(0);
|
|
} else {
|
|
dirp = opendir(client->current_path);
|
|
|
|
if (!dirp) {
|
|
send_msg(client, "451 Could not read directory.\r\n");
|
|
exit(0);
|
|
}
|
|
|
|
if (!open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
closedir(dirp);
|
|
exit(0);
|
|
}
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
while ((dp = readdir(dirp)) != NULL) {
|
|
snprintf(newpath, PATH_MAX, "%s/%s", client->current_path, dp->d_name);
|
|
if (stat(newpath, &s) == 0) {
|
|
localtime_r(&s.st_mtime, &file_tm);
|
|
now = time(NULL);
|
|
localtime_r(&now, &now_tm);
|
|
|
|
if (now_tm.tm_year != file_tm.tm_year) {
|
|
snprintf(linebuffer, PATH_MAX, "%c%c%c%c%c%c%c%c%c%c %ld %d %d %ld %s %d %d %s\r\n", S_ISDIR(s.st_mode) ? 'd' : '-',
|
|
S_IRUSR & s.st_mode ? 'r' : '-', S_IWUSR & s.st_mode ? 'w' : '-',S_IXUSR & s.st_mode ? 'x' : '-',
|
|
S_IRGRP & s.st_mode ? 'r' : '-', S_IWGRP & s.st_mode ? 'w' : '-',S_IXGRP & s.st_mode ? 'x' : '-',
|
|
S_IROTH & s.st_mode ? 'r' : '-', S_IWOTH & s.st_mode ? 'w' : '-',S_IXOTH & s.st_mode ? 'x' : '-',
|
|
s.st_nlink, s.st_uid, s.st_gid, s.st_size, months[file_tm.tm_mon], file_tm.tm_mday, file_tm.tm_year + 1900, dp->d_name);
|
|
} else {
|
|
snprintf(linebuffer, PATH_MAX, "%c%c%c%c%c%c%c%c%c%c %ld %d %d %ld %s %d %02d:%02d %s\r\n", S_ISDIR(s.st_mode) ? 'd' : '-',
|
|
S_IRUSR & s.st_mode ? 'r' : '-', S_IWUSR & s.st_mode ? 'w' : '-',S_IXUSR & s.st_mode ? 'x' : '-',
|
|
S_IRGRP & s.st_mode ? 'r' : '-', S_IWGRP & s.st_mode ? 'w' : '-',S_IXGRP & s.st_mode ? 'x' : '-',
|
|
S_IROTH & s.st_mode ? 'r' : '-', S_IWOTH & s.st_mode ? 'w' : '-',S_IXOTH & s.st_mode ? 'x' : '-',
|
|
s.st_nlink, s.st_uid, s.st_gid, s.st_size, months[file_tm.tm_mon], file_tm.tm_mday, file_tm.tm_hour, file_tm.tm_min, dp->d_name);
|
|
}
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
}
|
|
}
|
|
closedir(dirp);
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer ok.\r\n");
|
|
exit(0);
|
|
}
|
|
} else {
|
|
send_msg(client, "451 Could not read directory.\r\n");
|
|
}
|
|
}
|
|
|
|
void handle_NLST(struct ftpserver *cfg, struct ftpclient *client) {
|
|
DIR *dirp;
|
|
struct dirent *dp;
|
|
char newpath[PATH_MAX];
|
|
char linebuffer[PATH_MAX];
|
|
struct stat s;
|
|
pid_t pid = fork();
|
|
|
|
if (pid > 0) {
|
|
// nothing
|
|
close_tcp_connection(client);
|
|
} else if (pid == 0) {
|
|
if (client->current_path == NULL) {
|
|
if (!open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
exit(0);
|
|
}
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
|
|
if (stat(client->user->indir, &s) == 0) {
|
|
snprintf(linebuffer, PATH_MAX, "in\r\n");
|
|
}
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
if (stat(client->user->outdir, &s) == 0) {
|
|
snprintf(linebuffer, PATH_MAX, "out\r\n");
|
|
}
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer ok.\r\n");
|
|
exit(0);
|
|
} else {
|
|
dirp = opendir(client->current_path);
|
|
|
|
if (!dirp) {
|
|
send_msg(client, "451 Could not read directory.\r\n");
|
|
exit(0);
|
|
}
|
|
|
|
if (!open_tcp_connection(cfg, client)) {
|
|
send_msg(client, "425 TCP connection cannot be established.\r\n");
|
|
closedir(dirp);
|
|
exit(0);
|
|
}
|
|
send_msg(client, "150 Data connection accepted; transfer starting.\r\n");
|
|
while ((dp = readdir(dirp)) != NULL) {
|
|
snprintf(newpath, PATH_MAX, "%s/%s", client->current_path, dp->d_name);
|
|
if (stat(newpath, &s) == 0) {
|
|
snprintf(linebuffer, PATH_MAX, "%s\r\n", dp->d_name);
|
|
send_data(client, linebuffer, strlen(linebuffer));
|
|
}
|
|
}
|
|
closedir(dirp);
|
|
close_tcp_connection(client);
|
|
send_msg(client, "226 Transfer ok.\r\n");
|
|
exit(0);
|
|
}
|
|
} else {
|
|
send_msg(client, "451 Could not read directory.\r\n");
|
|
}
|
|
}
|
|
|
|
void handle_PORT(struct ftpserver *cfg, struct ftpclient *client, char *arg) {
|
|
if (client->data_socket > 0) {
|
|
close(client->data_socket);
|
|
}
|
|
int a,b,c,d,e,f;
|
|
|
|
sscanf(arg, "%d,%d,%d,%d,%d,%d", &a, &b, &c, &d, &e, &f);
|
|
sprintf(client->data_ip, "%d.%d.%d.%d", a, b, c, d);
|
|
client->data_port = e * 256 + f;
|
|
send_msg(client, "200 PORT command successful.\r\n");
|
|
}
|
|
|
|
void handle_EPRT(struct ftpserver *cfg, struct ftpclient *client, char *arg) {
|
|
if (client->data_socket > 0) {
|
|
close(client->data_socket);
|
|
}
|
|
char delim[2];
|
|
char *ptr;
|
|
int addrtype;
|
|
|
|
delim[0] = arg[0];
|
|
delim[1] = '\0';
|
|
|
|
ptr = strtok(arg, delim);
|
|
if (ptr != NULL) {
|
|
addrtype = atoi(ptr);
|
|
if (addrtype == 1) {
|
|
//ipv4
|
|
ptr = strtok(NULL, delim);
|
|
if (ptr != NULL) {
|
|
sprintf(client->data_ip, "%s", ptr);
|
|
ptr = strtok(NULL, delim);
|
|
if (ptr != NULL) {
|
|
client->data_port = atoi(ptr);
|
|
send_msg(client, "200 EPRT command successful.\r\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
} else if (addrtype == 2) {
|
|
//ipv6
|
|
ptr = strtok(NULL, delim);
|
|
if (ptr != NULL) {
|
|
sprintf(client->data_ip, "%s", ptr);
|
|
ptr = strtok(NULL, delim);
|
|
if (ptr != NULL) {
|
|
client->data_port = atoi(ptr);
|
|
send_msg(client, "200 EPRT command successful.\r\n");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void handle_CWD(struct ftpserver *cfg, struct ftpclient *client, char *dir) {
|
|
char *newpath;
|
|
|
|
newpath = (char *)malloc(1024);
|
|
parse_path(client, dir, &newpath);
|
|
|
|
if (strcasecmp(newpath, "/in") == 0) {
|
|
client->current_path = client->user->indir;
|
|
send_msg(client, "250 Okay.\r\n");
|
|
} else if (strcasecmp(newpath, "/out") == 0) {
|
|
client->current_path = client->user->outdir;
|
|
send_msg(client, "250 Okay.\r\n");
|
|
} else if (strlen(newpath) == 0) {
|
|
client->current_path = NULL;
|
|
send_msg(client, "250 Okay.\r\n");
|
|
} else {
|
|
send_msg(client, "550 No such file or directory.\r\n");
|
|
}
|
|
free(newpath);
|
|
}
|
|
|
|
void handle_TYPE(struct ftpserver *cfg, struct ftpclient *client) {
|
|
send_msg(client, "200 Type set to I.\r\n");
|
|
}
|
|
|
|
void handle_PWD(struct ftpserver *cfg, struct ftpclient *client) {
|
|
char *buffer = (char *)malloc(strlen(client->current_path) + 9);
|
|
if (!buffer) {
|
|
fprintf(stderr, "Out of memory\n");
|
|
exit(-1);
|
|
}
|
|
|
|
sprintf(buffer, "257 \"%s\"\r\n", client->current_path);
|
|
send_msg(client, buffer);
|
|
free(buffer);
|
|
}
|
|
|
|
void handle_SYST(struct ftpserver *cfg, struct ftpclient *client) {
|
|
send_msg(client, "215 UNIX Type: L8\r\n");
|
|
}
|
|
|
|
void handle_PASS(struct ftpserver *cfg, struct ftpclient *client, char *password) {
|
|
if (client->user == NULL) {
|
|
send_msg(client, "503 Need username first\r\n");
|
|
return;
|
|
}
|
|
|
|
if (strcmp(client->user->password, password) == 0) {
|
|
send_msg(client, "230 User Logged in, Proceed.\r\n");
|
|
client->authenticated = 1;
|
|
} else {
|
|
send_msg(client, "530 Username or Password unacceptable.\r\n");
|
|
}
|
|
}
|
|
|
|
void handle_USER(struct ftpserver *cfg, struct ftpclient *client, char *username) {
|
|
int i;
|
|
|
|
for (i=0;i<user_count;i++) {
|
|
if (strcmp(users[i]->username, username) == 0) {
|
|
client->user = users[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (client->user == NULL) {
|
|
send_msg(client, "430 Invalid Username.\r\n");
|
|
} else {
|
|
send_msg(client, "331 User name ok, need password.\r\n");
|
|
}
|
|
}
|
|
|
|
int handle_client(struct ftpserver *cfg, struct ftpclient *client, char *buf, int nbytes) {
|
|
|
|
char cmd[1024];
|
|
char argument[1024];
|
|
int i;
|
|
int cmd_len = 0;
|
|
int argument_len = 0;
|
|
int stage = 0;
|
|
|
|
memset(cmd, 0, 1024);
|
|
memset(argument, 0, 1024);
|
|
|
|
while (buf[nbytes-1] == '\r' || buf[nbytes-1] == '\n') {
|
|
buf[nbytes-1] = '\0';
|
|
nbytes--;
|
|
}
|
|
|
|
for (i=0;i<nbytes;i++) {
|
|
if (stage == 0 && buf[i] != ' ') {
|
|
cmd[cmd_len++] = buf[i];
|
|
cmd[cmd_len] = '\0';
|
|
} else if (stage == 0 && buf[i] == ' ') {
|
|
stage = 1;
|
|
} else if (stage == 1) {
|
|
argument[argument_len++] = buf[i];
|
|
argument[argument_len] = '\0';
|
|
}
|
|
}
|
|
|
|
if (strcmp(cmd, "PASS") == 0) {
|
|
fprintf(stderr, "command: %s, argument: ****\n", cmd);
|
|
dolog("command: %s, argument: ****", cmd);
|
|
} else {
|
|
fprintf(stderr, "command: %s, argument: %s\n", cmd, argument);
|
|
dolog("command: %s, argument: %s", cmd, argument);
|
|
}
|
|
|
|
if (strcmp(cmd, "USER") == 0) {
|
|
if (argument_len > 0) {
|
|
handle_USER(cfg, client, argument);
|
|
} else {
|
|
send_msg(client, "530 Missing username.\r\n");
|
|
}
|
|
} else
|
|
if (strcmp(cmd, "PASS") == 0) {
|
|
if (argument_len > 0) {
|
|
handle_PASS(cfg, client, argument);
|
|
} else {
|
|
send_msg(client, "530 Username or Password not accepted.\r\n");
|
|
}
|
|
} else
|
|
if (strcmp(cmd, "SYST") == 0) {
|
|
handle_SYST(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "PWD") == 0) {
|
|
handle_PWD(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "TYPE") == 0) {
|
|
handle_TYPE(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "CWD") == 0) {
|
|
handle_CWD(cfg, client, argument);
|
|
} else
|
|
if (strcmp(cmd, "PORT") == 0) {
|
|
handle_PORT(cfg, client, argument);
|
|
} else
|
|
if (strcmp(cmd, "NLST") == 0) {
|
|
handle_NLST(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "LIST") == 0) {
|
|
handle_LIST(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "PASV") == 0) {
|
|
handle_PASV(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "QUIT") == 0) {
|
|
send_msg(client, "221 Goodbye!\r\n");
|
|
} else
|
|
if (strcmp(cmd, "RETR") == 0) {
|
|
handle_RETR(cfg, client, argument);
|
|
} else
|
|
if (strcmp(cmd, "STOR") == 0) {
|
|
handle_STOR(cfg, client, argument);
|
|
} else
|
|
if (strcmp(cmd, "EPRT") == 0) {
|
|
handle_EPRT(cfg, client, argument);
|
|
} else
|
|
if (strcmp(cmd, "EPSV") == 0) {
|
|
handle_EPSV(cfg, client);
|
|
} else
|
|
if (strcmp(cmd, "DELE") == 0) {
|
|
handle_DELE(cfg, client, argument);
|
|
} else {
|
|
send_msg(client, "500 Command not recognized.\r\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void init(struct ftpserver *cfg) {
|
|
int ipv6_socket, ipv4_socket;
|
|
struct sockaddr_in6 server, client, host_addr;
|
|
struct sockaddr_in server4, client4, host_addr4;
|
|
fd_set master, read_fds;
|
|
int fdmax = 0;
|
|
socklen_t c;
|
|
int i,j,k;
|
|
char buf[1024];
|
|
int new_fd;
|
|
int nbytes;
|
|
int on = 1;
|
|
|
|
FD_ZERO(&master);
|
|
|
|
if (cfg->ipv6) {
|
|
ipv6_socket = socket(AF_INET6, SOCK_STREAM, 0);
|
|
if (ipv6_socket == -1) {
|
|
fprintf(stderr, "Couldn't create socket..\n");
|
|
exit(-1);
|
|
}
|
|
if (setsockopt(ipv6_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
|
|
fprintf(stderr, "setsockopt(SO_REUSEADDR) failed");
|
|
exit(1);
|
|
}
|
|
if (setsockopt(ipv6_socket, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on, sizeof(on)) < 0) {
|
|
fprintf(stderr, "setsockopt(IPV6_V6ONLY) failed");
|
|
}
|
|
|
|
server.sin6_family = AF_INET6;
|
|
server.sin6_addr = in6addr_any;
|
|
server.sin6_port = htons(cfg->port);
|
|
|
|
if (bind(ipv6_socket, (struct sockaddr *)&server, sizeof(server)) < 0) {
|
|
perror("Bind Failed, Error\n");
|
|
exit(1);
|
|
}
|
|
|
|
listen(ipv6_socket, 3);
|
|
FD_SET(ipv6_socket, &master);
|
|
}
|
|
|
|
ipv4_socket = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
|
if (ipv4_socket == -1) {
|
|
fprintf(stderr, "Couldn't create socket..\n");
|
|
exit(-1);
|
|
}
|
|
if (setsockopt(ipv4_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
|
|
fprintf(stderr, "setsockopt(SO_REUSEADDR) failed");
|
|
exit(1);
|
|
}
|
|
server4.sin_family = AF_INET;
|
|
server4.sin_addr.s_addr = INADDR_ANY;
|
|
server4.sin_port = htons(cfg->port);
|
|
|
|
if (bind(ipv4_socket, (struct sockaddr *)&server4, sizeof(server4)) < 0) {
|
|
perror("Bind Failed, Error\n");
|
|
exit(1);
|
|
}
|
|
|
|
listen(ipv4_socket, 3);
|
|
FD_SET(ipv4_socket, &master);
|
|
|
|
if (cfg->ipv6) {
|
|
if (ipv4_socket > ipv6_socket) {
|
|
fdmax = ipv4_socket;
|
|
} else {
|
|
fdmax = ipv6_socket;
|
|
}
|
|
} else {
|
|
fdmax = ipv4_socket;
|
|
}
|
|
|
|
// c = sizeof(struct sockaddr_in6);
|
|
|
|
while (1) {
|
|
read_fds = master;
|
|
if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
|
|
if (errno == EINTR) {
|
|
continue;
|
|
}
|
|
perror("select");
|
|
exit(-1);
|
|
}
|
|
|
|
for(i = 0; i <= fdmax; i++) {
|
|
if (FD_ISSET(i, &read_fds)) {
|
|
if (cfg->ipv6 && i == ipv6_socket) {
|
|
c = sizeof(struct sockaddr_in6);
|
|
new_fd = accept(ipv6_socket, (struct sockaddr *)&client, (socklen_t *)&c);
|
|
if (new_fd == -1) {
|
|
perror("accept");
|
|
} else {
|
|
if (client_count == 0) {
|
|
clients = (struct ftpclient **)malloc(sizeof(struct ftpclient *));
|
|
} else {
|
|
clients = (struct ftpclient **)realloc(clients, sizeof(struct ftpclient *) * (client_count + 1));
|
|
}
|
|
|
|
if (!clients) {
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(-1);
|
|
}
|
|
|
|
clients[client_count] = (struct ftpclient *)malloc(sizeof(struct ftpclient));
|
|
|
|
memset(clients[client_count], 0, sizeof(struct ftpclient));
|
|
|
|
if (!clients[client_count]) {
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(-1);
|
|
}
|
|
|
|
getsockname(new_fd, (struct sockaddr*) &host_addr, &c);
|
|
inet_ntop(AF_INET6, &(host_addr.sin6_addr), clients[client_count]->hostip, INET6_ADDRSTRLEN);
|
|
|
|
getpeername(new_fd, (struct sockaddr *)&client, &c);
|
|
inet_ntop(AF_INET6, &(client.sin6_addr), clients[client_count]->ip, INET6_ADDRSTRLEN);
|
|
|
|
clients[client_count]->fd = new_fd;
|
|
strcpy(clients[client_count]->current_path, "/");
|
|
clients[client_count]->data_socket = -1;
|
|
clients[client_count]->data_srv_socket = -1;
|
|
clients[client_count]->type = 1;
|
|
clients[client_count]->status = 0;
|
|
clients[client_count]->data_port = 0;
|
|
clients[client_count]->user = NULL;
|
|
clients[client_count]->authenticated = 0;
|
|
clients[client_count]->ipver = 6;
|
|
client_count++;
|
|
|
|
FD_SET(new_fd, &master);
|
|
if (new_fd > fdmax) {
|
|
fdmax = new_fd;
|
|
}
|
|
|
|
send_msg(clients[client_count - 1], "220 mnetftpd Ready\r\n");
|
|
}
|
|
} else if (i == ipv4_socket) {
|
|
c = sizeof(struct sockaddr_in);
|
|
new_fd = accept(ipv4_socket, (struct sockaddr *)&client, (socklen_t *)&c);
|
|
if (new_fd == -1) {
|
|
perror("accept");
|
|
} else {
|
|
if (client_count == 0) {
|
|
clients = (struct ftpclient **)malloc(sizeof(struct ftpclient *));
|
|
} else {
|
|
clients = (struct ftpclient **)realloc(clients, sizeof(struct ftpclient *) * (client_count + 1));
|
|
}
|
|
|
|
if (!clients) {
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(-1);
|
|
}
|
|
|
|
clients[client_count] = (struct ftpclient *)malloc(sizeof(struct ftpclient));
|
|
|
|
memset(clients[client_count], 0, sizeof(struct ftpclient));
|
|
|
|
if (!clients[client_count]) {
|
|
fprintf(stderr, "Out of memory!\n");
|
|
exit(-1);
|
|
}
|
|
|
|
getsockname(new_fd, (struct sockaddr*) &host_addr4, &c);
|
|
inet_ntop(AF_INET, &(host_addr4.sin_addr), clients[client_count]->hostip, INET_ADDRSTRLEN);
|
|
|
|
getpeername(new_fd, (struct sockaddr *)&client4, &c);
|
|
inet_ntop(AF_INET, &(client4.sin_addr), clients[client_count]->ip, INET_ADDRSTRLEN);
|
|
|
|
clients[client_count]->fd = new_fd;
|
|
clients[client_count]->current_path = NULL;
|
|
clients[client_count]->data_socket = -1;
|
|
clients[client_count]->data_srv_socket = -1;
|
|
clients[client_count]->type = 1;
|
|
clients[client_count]->status = 0;
|
|
clients[client_count]->data_port = 0;
|
|
clients[client_count]->user = NULL;
|
|
clients[client_count]->authenticated = 0;
|
|
clients[client_count]->ipver = 4;
|
|
client_count++;
|
|
|
|
FD_SET(new_fd, &master);
|
|
if (new_fd > fdmax) {
|
|
fdmax = new_fd;
|
|
}
|
|
|
|
send_msg(clients[client_count - 1], "220 mnetftpd Ready\r\n");
|
|
}
|
|
} else {
|
|
if ((nbytes = recv(i, buf, sizeof buf, 0)) <= 0) {
|
|
for (k=0;k<client_count;k++) {
|
|
if (clients[k]->fd == i) {
|
|
if (clients[k]->data_socket > 0) {
|
|
close(clients[k]->data_socket);
|
|
}
|
|
|
|
if (clients[k]->data_srv_socket > 0) {
|
|
close(clients[k]->data_srv_socket);
|
|
}
|
|
|
|
free(clients[k]);
|
|
|
|
for (j=k;j<client_count-1;j++) {
|
|
clients[j] = clients[j+1];
|
|
}
|
|
|
|
|
|
|
|
client_count--;
|
|
|
|
if (client_count == 0) {
|
|
free(clients);
|
|
} else {
|
|
clients = realloc(clients, sizeof(struct ftpclient) * (client_count));
|
|
}
|
|
}
|
|
}
|
|
close(i); // bye!
|
|
FD_CLR(i, &master); // remove from master set
|
|
} else {
|
|
for (j=0;j<client_count;j++) {
|
|
if (clients[j]->fd == i) {
|
|
if (handle_client(cfg, clients[j], buf, nbytes) != 0) {
|
|
close(clients[j]->fd);
|
|
FD_CLR(i, &master); // remove from master set
|
|
free(clients[j]);
|
|
|
|
for (k=j;k<client_count-1;k++) {
|
|
clients[k] = clients[k+1];
|
|
}
|
|
|
|
client_count--;
|
|
|
|
if (client_count == 0) {
|
|
free(clients);
|
|
} else {
|
|
clients = realloc(clients, sizeof(struct ftpclient) * (client_count));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
struct sigaction sa;
|
|
struct ftpserver ftpsrv;
|
|
ftpsrv.port = 2121;
|
|
ftpsrv.min_passive_port = 60000;
|
|
ftpsrv.max_passive_port = 65000;
|
|
ftpsrv.ipv6 = 0;
|
|
|
|
sa.sa_handler = sigchld_handler; // reap all dead processes
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_flags = SA_RESTART | SA_SIGINFO;
|
|
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
|
|
perror("sigaction - sigchld");
|
|
exit(-1);
|
|
}
|
|
|
|
|
|
if (argc < 2) {
|
|
fprintf(stderr, "Usage: %s [config.ini]\n", argv[0]);
|
|
exit(-1);
|
|
}
|
|
|
|
if (ini_parse(argv[1], handler, &ftpsrv) <0) {
|
|
fprintf(stderr, "Unable to load configuration ini (%s)!\n", argv[1]);
|
|
exit(-1);
|
|
}
|
|
|
|
ftpsrv.last_passive_port = ftpsrv.min_passive_port;
|
|
|
|
init(&ftpsrv);
|
|
}
|