void
vsf_log_init(struct vsf_session* p_sess)
{
int retval;
if (tunable_syslog_enable || tunable_tcp_wrappers)
{
vsf_sysutil_openlog();
}
if (!tunable_xferlog_enable && !tunable_dual_log_enable)
{
return;
}
if (tunable_dual_log_enable || tunable_xferlog_std_format)
{
retval = vsf_sysutil_create_or_open_file(tunable_xferlog_file, 0600);
if (vsf_sysutil_retval_is_error(retval))
{
die2("failed to open xferlog log file:", tunable_xferlog_file);
}
p_sess->xferlog_fd = retval;
}
if (tunable_dual_log_enable || !tunable_xferlog_std_format)
{
if (!tunable_syslog_enable)
{
retval = vsf_sysutil_create_or_open_file(tunable_vsftpd_log_file, 0600);
if (vsf_sysutil_retval_is_error(retval))
{
die2("failed to open vsftpd log file:", tunable_vsftpd_log_file);
}
p_sess->vsftpd_log_fd = retval;
}
}
}
/*
* Add udig to set of seen udigs.
*/
static void
add_sha(char *sha)
{
unsigned int hash;
struct element *u;
hash = djb((unsigned char *)sha, 40) % HASH_TABLE_SIZE;
u = table[hash];
while (u) {
/*
* UDig already seen, so this is not a set.
*/
if (strcmp(u->sha, sha) == 0)
exit(1);
u = u->next;
}
/*
* SHA not found, so allocate a new one.
*/
u = malloc(sizeof *u);
if (u == NULL)
die2("malloc(element) failed", strerror(errno));
u->sha = malloc(strlen(sha) + 1);
if (u->sha == NULL)
die2("malloc(sha) failed", strerror(errno));
strcpy(u->sha, sha);
u->next = 0;
if (table[hash])
u->next = table[hash];
table[hash] = u;
}
static void
read_data (
const char *data_file_type[],
const char *data_file_name[]
)
{
FILE *f;
for (; data_file_name[0] && data_file_type[0];
data_file_name++, data_file_type++)
{
fprintf (stderr, "Reading `%s'\n", data_file_name[0]);
if (!(f = fopen (data_file_name[0], "rt")))
die2 ("error: cannot open `%s' for reading", data_file_name[0]);
if (!strcmp (data_file_type[0], "UnicodeData.txt"))
read_unicode_data_txt (f);
else if (!strcmp (data_file_type[0], "ArabicShaping.txt"))
read_arabic_shaping_txt (f);
else
die2 ("error: unknown data-file type %s", data_file_type[0]);
fclose (f);
}
}
int
main (
int argc,
char *argv[]
)
{
int niter = NUM_ITER;
/* Parse the command line */
argv[0] = appname;
while (1)
{
int option_index = 0, c;
static struct option long_options[] = {
{"help", 0, 0, 'h'},
{"version", 0, 0, 'V'},
{"niter", 0, 0, 'n'},
{0, 0, 0, 0}
};
c = getopt_long (argc, argv, "hVn:", long_options, &option_index);
if (c == -1)
break;
switch (c)
{
case 0:
break;
case 'h':
help ();
break;
case 'V':
version ();
break;
case 'n':
niter = atoi (optarg);
if (niter <= 0)
die2 ("invalid number of iterations `%s'\n", optarg);
break;
case ':':
case '?':
die2 (NULL, NULL);
break;
default:
break;
}
}
printf ("* Without explicit marks:\n");
benchmark (TEST_STRING, niter);
printf ("\n");
printf ("* With explicit marks:\n");
benchmark (TEST_STRING_EXPLICIT, niter);
return 0;
}
int main(int argc, char* argv[])
{
const char* bitstr;
const char* polystr;
int bits;
int digits;
uint64 poly;
const char* suffix;
int columns;
char* end;
int i;
const char* name;
int reflected;
if (argc != 5) {
msg3("usage: ", program, " NAME BITS POLY [normal|reflected]");
return 1;
}
name = argv[1];
bitstr = argv[2];
bits = strtol(bitstr, &end, 0);
if (*end != 0) die2(1, "Invalid bits value: ", bitstr);
if (bits <= 0 || bits > 64) die1(1, "bits must be between 1 and 64");
digits = (bits + 3) / 4;
if (bits > 32) suffix = "ULL,";
else if (bits > 16) suffix = "UL,";
else suffix = "U,";
columns = calc_columns(bits, suffix);
polystr = argv[3];
poly = strtoull(polystr, &end, 0);
if (*end != 0) die2(1, "Invalid poly value: ", polystr);
reflected = 0;
if (strcasecmp(argv[4], "reflected") == 0)
reflected = 1;
else if (strcasecmp(argv[4], "normal") != 0)
die2(1, "Must be either 'normal' or 'reflected': ", argv[4]);
gentab(bits, poly, reflected);
obuf_put3s(&outbuf, "#include \"", name, ".h\"\n\n");
obuf_put5s(&outbuf, "const uint", bitstr, " ", name,
"_table[256] = {\n");
for (i = 0; i < 256; ++i) {
int column = i % columns;
if (column == 0)
obuf_puts(&outbuf, " ");
obuf_puts(&outbuf, "0x");
if (bits > 32) {
obuf_putxw(&outbuf, crctab[i]>>32, digits-8, '0');
obuf_putxw(&outbuf, crctab[i] & 0xffffffffUL, 8, '0');
}
else
static void
session_init(struct vsf_session* p_sess)
{
/* Get the addresses of the control connection */
vsf_sysutil_getpeername(VSFTP_COMMAND_FD, &p_sess->p_remote_addr);
vsf_sysutil_getsockname(VSFTP_COMMAND_FD, &p_sess->p_local_addr);
/* If anonymous mode is active, fetch the uid of the anonymous user */
if (tunable_anonymous_enable)
{
const struct vsf_sysutil_user* p_user = 0;
if (tunable_ftp_username)
{
p_user = vsf_sysutil_getpwnam(tunable_ftp_username);
}
if (p_user == 0)
{
die2("vsftpd: cannot locate user specified in 'ftp_username':"******"vsftpd: cannot locate user specified in 'guest_username':"******"vsftpd: cannot locate user specified in 'chown_username':",
tunable_chown_username);
}
p_sess->anon_upload_chown_uid = vsf_sysutil_user_getuid(p_user);
}
}
int qemu_paio_init(struct qemu_paioinit *aioinit)
{
int ret;
ret = pthread_attr_init(&attr);
if (ret) die2(ret, "pthread_attr_init");
ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (ret) die2(ret, "pthread_attr_setdetachstate");
TAILQ_INIT(&request_list);
return 0;
}
int
main (
int argc,
const char **argv
)
{
const char *data_file_type = "BidiMirroring.txt";
if (argc < 3)
die2 ("usage:\n " appname " max-lookups /path/to/%s [junk...]",
data_file_type);
{
int max_depth = atoi (argv[1]);
const char *data_file_name = argv[2];
if (max_depth < 2)
die ("invalid depth");
init ();
read_data (data_file_type, data_file_name);
gen_mirroring_tab (max_depth, data_file_type);
}
return 0;
}
static int cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
struct timespec *ts)
{
int ret = pthread_cond_timedwait(cond, mutex, ts);
if (ret && ret != ETIMEDOUT) die2(ret, "pthread_cond_timedwait");
return ret;
}
static void
drop_all_privs(void)
{
struct mystr user_str = INIT_MYSTR;
struct mystr dir_str = INIT_MYSTR;
int option = VSF_SECUTIL_OPTION_CHROOT | VSF_SECUTIL_OPTION_NO_PROCS;
if (!tunable_ssl_enable)
{
/* Unfortunately, can only enable this if we can be sure of not using SSL.
* In the SSL case, we'll need to receive data transfer file descriptors.
*/
option |= VSF_SECUTIL_OPTION_NO_FDS;
}
str_alloc_text(&user_str, tunable_nopriv_user);
str_alloc_text(&dir_str, tunable_secure_chroot_dir);
/* Be kind: give good error message if the secure dir is missing */
{
struct vsf_sysutil_statbuf* p_statbuf = 0;
if (vsf_sysutil_retval_is_error(str_lstat(&dir_str, &p_statbuf)))
{
die2("vsftpd: not found: directory given in 'secure_chroot_dir':",
tunable_secure_chroot_dir);
}
vsf_sysutil_free(p_statbuf);
}
vsf_secutil_change_credentials(&user_str, &dir_str, 0, 0, option);
str_free(&user_str);
str_free(&dir_str);
}
void
vsf_two_process_start(struct vsf_session* p_sess)
{
/* Create the comms channel between privileged parent and no-priv child */
priv_sock_init(p_sess);
vsf_sysutil_install_async_sighandler(kVSFSysUtilSigCHLD, handle_sigchld);
{
int newpid = vsf_sysutil_fork();
if (newpid != 0)
{
/* Parent - go into pre-login parent process mode */
while (1)
{
process_login_req(p_sess);
}
}
}
/* Child process - time to lose as much privilege as possible and do the
* login processing
*/
if (tunable_local_enable && tunable_userlist_enable)
{
int retval = str_fileread(&p_sess->userlist_str, tunable_userlist_file,
VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot open user list file:", tunable_userlist_file);
}
}
drop_all_privs();
init_connection(p_sess);
/* NOTREACHED */
}
static void
calculate_chdir_dir(int anon, struct mystr* p_chroot_str,
struct mystr* p_chdir_str,
const struct mystr* p_user_str)
{
if (anon && tunable_anon_root)
{
str_alloc_text(p_chroot_str, tunable_anon_root);
}
else if (!anon && tunable_local_root)
{
str_alloc_text(p_chroot_str, tunable_local_root);
}
/* If enabled, the chroot() location embedded in the HOMEDIR takes
* precedence.
*/
if (!anon && tunable_passwd_chroot_enable)
{
struct mystr homedir_str = INIT_MYSTR;
const struct vsf_sysutil_user* p_user = str_getpwnam(p_user_str);
struct str_locate_result loc_result;
if (p_user == 0)
{
die2("cannot locate user entry:", str_getbuf(p_user_str));
}
str_alloc_text(&homedir_str, vsf_sysutil_user_get_homedir(p_user));
loc_result = str_locate_text(&homedir_str, "/./");
if (loc_result.found)
{
str_split_text(&homedir_str, p_chdir_str, "/./");
str_copy(p_chroot_str, &homedir_str);
}
str_free(&homedir_str);
}
}
static void
read_data (
const char *data_file_type,
const char *data_file_name
)
{
FILE *f;
fprintf (stderr, "Reading `%s'\n", data_file_name);
if (!(f = fopen (data_file_name, "rt")))
die2 ("error: cannot open `%s' for reading", data_file_name);
if (!strcmp (data_file_type, "BidiMirroring.txt"))
read_bidi_mirroring_txt (f);
else
die2 ("error: unknown data-file-type %s", data_file_type);
fclose (f);
}
static void
read_data (
const char *data_file_type,
const char *data_file_name
)
{
FILE *f;
if (!(f = fopen (data_file_name, "rt")))
die2 ("error: cannot open `%s' for reading", data_file_name);
if (!strcmp (data_file_type, "UnicodeData.txt"))
read_unicode_data_txt (f);
else if (!strcmp (data_file_type, "DerivedBidiClass.txt"))
read_derived_bidi_class_txt (f);
else
die2 ("error: unknown data-file type %s", data_file_type);
fclose (f);
}
void parse_age(const char* s, const cli_option* o)
{
char* end;
time_t* n;
if ((n = realloc((char*)opt_ages, (opt_age_count+1) * sizeof *n)) == 0)
oom();
n[opt_age_count] = strtoul(s, &end, 0);
if (*end != 0) die2(111, "Specified age is not a number: ", s);
++opt_age_count;
opt_ages = n;
(void)o;
}
static char
get_type (
const char *s
)
{
unsigned int i;
for (i = 0; i < type_names_count; i++)
if (!strcmp (s, type_names[i].name))
return type_names[i].key;
die2 ("bidi type name `%s' not found", s);
return 0;
}
static int
_read(char *buf, int size)
{
int nbytes;
again:
nbytes = read(0, buf, size);
if (nbytes >= 0)
return nbytes;
if (errno == EINTR)
goto again;
die2("read() failed", strerror(errno));
/*NOTREACHED*/
return -1; /* silence compiler */
}
static int
read_data (
const char *data_file_type,
const char *data_file_name
)
{
FILE *f;
int status;
fprintf (stderr, "Reading `%s'\n", data_file_name);
if (!(f = fopen (data_file_name, "rt")))
die2 ("error: cannot open `%s' for reading", data_file_name);
status = read_file (f);
fclose (f);
return status;
}
int main(int argc, char** argv)
{
int i;
unsigned long v;
char num[FMT_ULONG_LEN];
switch (argc) {
case 4:
i = cvm_client_authenticate_password(argv[1], argv[2], argv[3], 0, 1);
break;
case 5:
i = cvm_client_authenticate_password(argv[1], argv[2], argv[3], argv[4], 1);
break;
default:
die2(1, "Incorrect usage.", usage);
return 1;
}
if (i) {
num[fmt_udec(num, i)] = 0;
msg5("Authentication failed, error #", num, " (",
(i < cvm_nerr) ? cvm_errlist[i] : "Unknown error code", ")");
if (cvm_client_fact_uint(CVM_FACT_OUTOFSCOPE, &v) == 0)
u("out of scope: ", v);
return i;
}
s("user name: ", cvm_fact_username);
u("user ID: ", cvm_fact_userid);
u("group ID: ", cvm_fact_groupid);
s("real name: ", cvm_fact_realname);
s("directory: ", cvm_fact_directory);
s("shell: ", cvm_fact_shell);
s("group name: ", cvm_fact_groupname);
s("system user name: ", cvm_fact_sys_username);
s("system directory: ", cvm_fact_sys_directory);
s("domain: ", cvm_fact_domain);
s("mailbox path: ", cvm_fact_mailbox);
while (cvm_client_fact_uint(CVM_FACT_SUPP_GROUPID, &v) == 0)
u("supp. group ID: ", v);
return 0;
}
static void
drop_all_privs(void)
{
struct mystr user_str = INIT_MYSTR;
struct mystr dir_str = INIT_MYSTR;
str_alloc_text(&user_str, tunable_nopriv_user);
str_alloc_text(&dir_str, tunable_secure_chroot_dir);
/* Be kind: give good error message if the secure dir is missing */
{
struct vsf_sysutil_statbuf* p_statbuf = 0;
if (vsf_sysutil_retval_is_error(str_lstat(&dir_str, &p_statbuf)))
{
die2("vsftpd: not found: directory given in 'secure_chroot_dir':",
tunable_secure_chroot_dir);
}
vsf_sysutil_free(p_statbuf);
}
vsf_secutil_change_credentials(&user_str, &dir_str, 0, 0,
VSF_SECUTIL_OPTION_CHROOT);
str_free(&user_str);
str_free(&dir_str);
}
static void cond_signal(pthread_cond_t *cond)
{
int ret = pthread_cond_signal(cond);
if (ret) die2(ret, "pthread_cond_signal");
}
static void die(const char *what)
{
die2(errno, what);
}
static void mutex_unlock(pthread_mutex_t *mutex)
{
int ret = pthread_mutex_unlock(mutex);
if (ret) die2(ret, "pthread_mutex_unlock");
}
static void
benchmark (
const char *S_,
int niter
)
{
int len, i;
FriBidiChar us[MAX_STR_LEN], out_us[MAX_STR_LEN];
FriBidiStrIndex positionLtoV[MAX_STR_LEN], positionVtoL[MAX_STR_LEN];
FriBidiLevel embedding_list[MAX_STR_LEN];
FriBidiParType base;
double time0, time1;
{
int j;
len = strlen (S_);
for (i = 0, j = 0; i < len; i++)
{
if (S_[i] == '_')
switch (S_[++i])
{
case '>':
us[j++] = FRIBIDI_CHAR_LRM;
break;
case '<':
us[j++] = FRIBIDI_CHAR_RLM;
break;
case 'l':
us[j++] = FRIBIDI_CHAR_LRE;
break;
case 'r':
us[j++] = FRIBIDI_CHAR_RLE;
break;
case 'L':
us[j++] = FRIBIDI_CHAR_LRO;
break;
case 'R':
us[j++] = FRIBIDI_CHAR_RLO;
break;
case 'o':
us[j++] = FRIBIDI_CHAR_PDF;
break;
case '_':
us[j++] = '_';
break;
default:
us[j++] = '_';
i--;
break;
}
else
us[j++] = S_[i];
if (us[j] >= 'A' && us[j] <= 'F')
us[j] += FRIBIDI_CHAR_ARABIC_ALEF - 'A';
else if (us[j] >= 'G' && us[j] <= 'Z')
us[j] += FRIBIDI_CHAR_HEBREW_ALEF - 'G';
else if (us[j] >= '6' && us[j] <= '9')
us[j] += FRIBIDI_CHAR_ARABIC_ZERO - '0';
}
len = j;
}
/* Start timer */
time0 = utime ();
for (i = 0; i < niter; i++)
{
/* Create a bidi string */
base = FRIBIDI_PAR_ON;
if (!fribidi_log2vis (us, len, &base,
/* output */
out_us, positionVtoL, positionLtoV,
embedding_list))
die2
("something failed in fribidi_log2vis.\n"
"perhaps memory allocation failure.", NULL);
}
/* stop timer */
time1 = utime ();
/* output result */
printf ("Length = %d\n", len);
printf ("Iterations = %d\n", niter);
printf ("%d len*iterations in %f seconds\n", len * niter, time1 - time0);
printf ("= %.0f kilo.length.iterations/second\n",
1.0 * len * niter / 1000 / (time1 - time0));
return;
}
int
main(int argc, const char* argv[])
{
struct vsf_session the_session =
{
/* Control connection */
0, 0, 0,
/* Data connection */
-1, 0, -1, 0, 0, 0, 0,
/* Login */
1, INIT_MYSTR, INIT_MYSTR,
/* Protocol state */
0, 1, INIT_MYSTR, 0, 0,
/* Session state */
0,
/* Userids */
-1, -1, -1,
/* Pre-chroot() cache */
INIT_MYSTR, INIT_MYSTR, INIT_MYSTR, INIT_MYSTR, 1,
/* Logging */
-1, -1, INIT_MYSTR, 0, 0, 0, INIT_MYSTR, 0,
/* Buffers */
INIT_MYSTR, INIT_MYSTR,
/* Parent <-> child comms */
-1, -1,
/* Number of clients */
0, 0,
/* Home directory */
INIT_MYSTR,
/* Secure connection state */
0, 0, 0, 0, 0, 0, -1, -1
};
int config_specified = 0;
const char* p_config_name = VSFTP_DEFAULT_CONFIG;
/* Zero or one argument supported. If one argument is passed, it is the
* path to the config file
*/
if (argc > 2)
{
die("vsftpd: too many arguments (I take an optional config file only)");
}
else if (argc == 0)
{
die("vsftpd: missing argv[0]");
}
if (argc == 2)
{
if (!vsf_sysutil_strcmp(argv[1], "-v"))
{
vsf_exit("vsftpd: version " VSF_VERSION "\n");
}
p_config_name = argv[1];
config_specified = 1;
}
/* This might need to open /dev/zero on systems lacking MAP_ANON. Needs
* to be done early (i.e. before config file parse, which may use
* anonymous pages
*/
vsf_sysutil_map_anon_pages_init();
/* Parse config file if it's there */
{
struct vsf_sysutil_statbuf* p_statbuf = 0;
int retval = vsf_sysutil_stat(p_config_name, &p_statbuf);
if (!vsf_sysutil_retval_is_error(retval))
{
vsf_parseconf_load_file(p_config_name, 1);
}
else if (config_specified)
{
die2("vsftpd: cannot open config file:", p_config_name);
}
vsf_sysutil_free(p_statbuf);
}
if (!tunable_run_as_launching_user)
{
/* Just get out unless we start with requisite privilege */
die_unless_privileged();
}
if (tunable_setproctitle_enable)
{
/* Warning -- warning -- may nuke argv, environ */
vsf_sysutil_setproctitle_init(argc, argv);
}
/* Initialize the SSL system here if needed - saves the overhead of each
* child doing this itself.
*/
if (tunable_ssl_enable)
{
ssl_init(&the_session);
}
if (tunable_listen || tunable_listen_ipv6)
{
/* Standalone mode */
struct vsf_client_launch ret = vsf_standalone_main();
the_session.num_clients = ret.num_children;
the_session.num_this_ip = ret.num_this_ip;
}
/* Sanity checks - exit with a graceful error message if our STDIN is not
* a socket. Also check various config options don't collide.
*/
do_sanity_checks();
/* Initializes session globals - e.g. IP addr's etc. */
session_init(&the_session);
/* Set up "environment", e.g. process group etc. */
env_init();
/* Set up logging - must come after global init because we need the remote
* address to convert into text
*/
vsf_log_init(&the_session);
str_alloc_text(&the_session.remote_ip_str,
vsf_sysutil_inet_ntop(the_session.p_remote_addr));
/* Set up options on the command socket */
vsf_cmdio_sock_setup();
if (tunable_setproctitle_enable)
{
vsf_sysutil_set_proctitle_prefix(&the_session.remote_ip_str);
vsf_sysutil_setproctitle("connected");
}
/* We might chroot() very soon (one process model), so we need to open
* any required config files here.
*/
if (tunable_tcp_wrappers)
{
the_session.tcp_wrapper_ok = vsf_tcp_wrapper_ok(VSFTP_COMMAND_FD);
}
{
const char* p_load_conf = vsf_sysutil_getenv("VSFTPD_LOAD_CONF");
if (p_load_conf)
{
vsf_parseconf_load_file(p_load_conf, 1);
}
}
/* SSL may have been enabled by a per-IP configuration.. */
if (tunable_ssl_enable)
{
ssl_init(&the_session);
}
if (tunable_deny_email_enable)
{
int retval = str_fileread(&the_session.banned_email_str,
tunable_banned_email_file, VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot open anon e-mail list file:", tunable_banned_email_file);
}
}
if (tunable_banner_file)
{
int retval = str_fileread(&the_session.banner_str, tunable_banner_file,
VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot open banner file:", tunable_banner_file);
}
}
if (tunable_secure_email_list_enable)
{
int retval = str_fileread(&the_session.email_passwords_str,
tunable_email_password_file,
VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot open email passwords file:", tunable_email_password_file);
}
}
/* Special case - can force one process model if we've got a setup
* needing _no_ privs
*/
if (!tunable_local_enable && !tunable_connect_from_port_20 &&
!tunable_chown_uploads)
{
tunable_one_process_model = 1;
}
if (tunable_run_as_launching_user)
{
tunable_one_process_model = 1;
if (!vsf_sysutil_running_as_root())
{
tunable_connect_from_port_20 = 0;
tunable_chown_uploads = 0;
}
}
if (tunable_one_process_model)
{
vsf_one_process_start(&the_session);
}
else
{
vsf_two_process_start(&the_session);
}
/* NOTREACHED */
bug("should not get here: main");
return 1;
}
void
vsf_parseconf_load_setting(const char* p_setting, int errs_fatal)
{
static struct mystr s_setting_str;
static struct mystr s_value_str;
while (vsf_sysutil_isspace(*p_setting))
{
p_setting++;
}
str_alloc_text(&s_setting_str, p_setting);
str_split_char(&s_setting_str, &s_value_str, '=');
/* Is it a string setting? */
{
const struct parseconf_str_setting* p_str_setting = parseconf_str_array;
while (p_str_setting->p_setting_name != 0)
{
if (str_equal_text(&s_setting_str, p_str_setting->p_setting_name))
{
/* Got it */
const char** p_curr_setting = p_str_setting->p_variable;
if (*p_curr_setting)
{
vsf_sysutil_free((char*) *p_curr_setting);
}
if (str_isempty(&s_value_str))
{
*p_curr_setting = 0;
}
else
{
*p_curr_setting = str_strdup(&s_value_str);
}
return;
}
p_str_setting++;
}
}
if (str_isempty(&s_value_str))
{
if (errs_fatal)
{
die2("missing value in config file for: ", str_getbuf(&s_setting_str));
}
else
{
return;
}
}
/* Is it a boolean value? */
{
const struct parseconf_bool_setting* p_bool_setting = parseconf_bool_array;
while (p_bool_setting->p_setting_name != 0)
{
if (str_equal_text(&s_setting_str, p_bool_setting->p_setting_name))
{
/* Got it */
str_upper(&s_value_str);
if (str_equal_text(&s_value_str, "YES") ||
str_equal_text(&s_value_str, "TRUE") ||
str_equal_text(&s_value_str, "1"))
{
*(p_bool_setting->p_variable) = 1;
}
else if (str_equal_text(&s_value_str, "NO") ||
str_equal_text(&s_value_str, "FALSE") ||
str_equal_text(&s_value_str, "0"))
{
*(p_bool_setting->p_variable) = 0;
}
else if (errs_fatal)
{
die2("bad bool value in config file for: ",
str_getbuf(&s_setting_str));
}
return;
}
p_bool_setting++;
}
}
/* Is it an unsigned integer setting? */
{
const struct parseconf_uint_setting* p_uint_setting = parseconf_uint_array;
while (p_uint_setting->p_setting_name != 0)
{
if (str_equal_text(&s_setting_str, p_uint_setting->p_setting_name))
{
/* Got it */
/* If the value starts with 0, assume it's an octal value */
if (!str_isempty(&s_value_str) &&
str_get_char_at(&s_value_str, 0) == '0')
{
*(p_uint_setting->p_variable) = str_octal_to_uint(&s_value_str);
}
else
{
/* TODO: we could reject negatives instead of converting them? */
*(p_uint_setting->p_variable) = (unsigned int) str_atoi(&s_value_str);
}
return;
}
p_uint_setting++;
}
}
if (errs_fatal)
{
die2("unrecognised variable in config file: ", str_getbuf(&s_setting_str));
}
}
void
vsf_parseconf_load_file(const char* p_filename, int errs_fatal)
{
struct mystr config_file_str = INIT_MYSTR;
struct mystr config_setting_str = INIT_MYSTR;
struct mystr config_value_str = INIT_MYSTR;
unsigned int str_pos = 0;
int retval;
if (!p_filename)
{
p_filename = s_p_saved_filename;
}
else
{
if (s_p_saved_filename)
{
vsf_sysutil_free((char*)s_p_saved_filename);
}
s_p_saved_filename = vsf_sysutil_strdup(p_filename);
}
if (!p_filename)
{
bug("null filename in vsf_parseconf_load_file");
}
retval = str_fileread(&config_file_str, p_filename, VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
if (errs_fatal)
{
die2("cannot read config file: ", p_filename);
}
else
{
str_free(&config_file_str);
return;
}
}
{
struct vsf_sysutil_statbuf* p_statbuf = 0;
retval = vsf_sysutil_stat(p_filename, &p_statbuf);
/* Security: check current user owns the config file. These are sanity
* checks for the admin, and are NOT designed to be checks safe from
* race conditions.
*/
if (vsf_sysutil_retval_is_error(retval) ||
vsf_sysutil_statbuf_get_uid(p_statbuf) != vsf_sysutil_getuid() ||
!vsf_sysutil_statbuf_is_regfile(p_statbuf))
{
die("config file not owned by correct user, or not a file");
}
vsf_sysutil_free(p_statbuf);
}
while (str_getline(&config_file_str, &config_setting_str, &str_pos))
{
if (str_isempty(&config_setting_str) ||
str_get_char_at(&config_setting_str, 0) == '#' ||
str_all_space(&config_setting_str))
{
continue;
}
vsf_parseconf_load_setting(str_getbuf(&config_setting_str), errs_fatal);
}
str_free(&config_file_str);
str_free(&config_setting_str);
str_free(&config_value_str);
}
void test_mongo_connection()
{
int connect = db_connect();
if (connect < 0) die2("db connection failed");
db_disconnect();
}
int
main(int argc, const char* argv[])
{
struct vsf_session the_session =
{
/* Control connection */
0, 0, 0, 0, 0,
/* Data connection */
-1, 0, -1, 0, 0, 0, 0,
/* Login */
1, 0, INIT_MYSTR, INIT_MYSTR,
/* Protocol state */
0, 1, INIT_MYSTR, 0, 0,
/* HTTP hacks */
0, INIT_MYSTR,
/* Session state */
0,
/* Userids */
-1, -1, -1,
/* Pre-chroot() cache */
INIT_MYSTR, INIT_MYSTR, INIT_MYSTR, INIT_MYSTR, 1,
/* Logging */
-1, -1, INIT_MYSTR, 0, 0, 0, INIT_MYSTR, 0,
/* Buffers */
INIT_MYSTR, INIT_MYSTR, 0, INIT_MYSTR,
/* Parent <-> child comms */
-1, -1,
/* Number of clients */
0, 0,
/* Home directory */
INIT_MYSTR,
/* Secure connection state */
0, 0, 0, 0, 0, INIT_MYSTR, 0, -1, -1,
/* Login fails */
0,
/* write_enable */
0
};
int config_loaded = 0;
int i;
tunables_load_defaults();
/* This might need to open /dev/zero on systems lacking MAP_ANON. Needs
* to be done early (i.e. before config file parse, which may use
* anonymous pages
*/
vsf_sysutil_map_anon_pages_init();
/* Argument parsing. Any argument not starting with "-" is a config file,
* loaded in the order encountered. -o opt=value options are loading in the
* order encountered, including correct ordering with respect intermingled
* config files.
* If we see -v (version) or an unknown option, parsing bails and exits.
*/
if (argc == 0)
{
die("vsftpd: missing argv[0]");
}
for (i = 1; i < argc; ++i)
{
const char* p_arg = argv[i];
if (p_arg[0] != '-')
{
config_loaded = 1;
vsf_parseconf_load_file(p_arg, 1);
}
else
{
if (p_arg[1] == 'v')
{
vsf_exit("vsftpd: version " VSF_VERSION "\n");
}
else if (p_arg[1] == 'o')
{
vsf_parseconf_load_setting(&p_arg[2], 1);
}
else
{
die2("unrecognise option: ", p_arg);
}
}
}
/* Parse default config file if necessary */
if (!config_loaded) {
struct vsf_sysutil_statbuf* p_statbuf = 0;
int retval = vsf_sysutil_stat(VSFTP_DEFAULT_CONFIG, &p_statbuf);
if (!vsf_sysutil_retval_is_error(retval))
{
vsf_parseconf_load_file(VSFTP_DEFAULT_CONFIG, 1);
}
vsf_sysutil_free(p_statbuf);
}
/* Resolve pasv_address if required */
if (tunable_pasv_address && tunable_pasv_addr_resolve)
{
struct vsf_sysutil_sockaddr* p_addr = 0;
const char* p_numeric_addr;
vsf_sysutil_dns_resolve(&p_addr, tunable_pasv_address);
vsf_sysutil_free((char*) tunable_pasv_address);
p_numeric_addr = vsf_sysutil_inet_ntop(p_addr);
tunable_pasv_address = vsf_sysutil_strdup(p_numeric_addr);
vsf_sysutil_free(p_addr);
}
if (!tunable_run_as_launching_user)
{
/* Just get out unless we start with requisite privilege */
die_unless_privileged();
}
if (tunable_setproctitle_enable)
{
/* Warning -- warning -- may nuke argv, environ */
vsf_sysutil_setproctitle_init(argc, argv);
}
/* Initialize the SSL system here if needed - saves the overhead of each
* child doing this itself.
*/
if (tunable_ssl_enable)
{
ssl_init(&the_session);
}
if (tunable_listen || tunable_listen_ipv6)
{
/* Standalone mode */
struct vsf_client_launch ret = vsf_standalone_main();
the_session.num_clients = ret.num_children;
the_session.num_this_ip = ret.num_this_ip;
}
if (tunable_tcp_wrappers)
{
the_session.tcp_wrapper_ok = vsf_tcp_wrapper_ok(VSFTP_COMMAND_FD);
}
{
const char* p_load_conf = vsf_sysutil_getenv("VSFTPD_LOAD_CONF");
if (p_load_conf)
{
vsf_parseconf_load_file(p_load_conf, 1);
}
}
/* Sanity checks - exit with a graceful error message if our STDIN is not
* a socket. Also check various config options don't collide.
*/
do_sanity_checks();
/* Initializes session globals - e.g. IP addr's etc. */
session_init(&the_session);
/* Set up "environment", e.g. process group etc. */
env_init();
/* Set up resource limits. */
limits_init();
/* Set up logging - must come after global init because we need the remote
* address to convert into text
*/
vsf_log_init(&the_session);
str_alloc_text(&the_session.remote_ip_str,
vsf_sysutil_inet_ntop(the_session.p_remote_addr));
/* Set up options on the command socket */
vsf_cmdio_sock_setup();
if (tunable_setproctitle_enable)
{
vsf_sysutil_set_proctitle_prefix(&the_session.remote_ip_str);
vsf_sysutil_setproctitle("connected");
}
/* We might chroot() very soon (one process model), so we need to open
* any required config files here.
*/
/* SSL may have been enabled by a per-IP configuration.. */
if (tunable_ssl_enable)
{
ssl_init(&the_session);
ssl_add_entropy(&the_session);
}
if (tunable_deny_email_enable)
{
int retval = -1;
if (tunable_banned_email_file)
{
retval = str_fileread(&the_session.banned_email_str,
tunable_banned_email_file, VSFTP_CONF_FILE_MAX);
}
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot read anon e-mail list file:", tunable_banned_email_file);
}
}
if (tunable_banner_file)
{
int retval = str_fileread(&the_session.banner_str, tunable_banner_file,
VSFTP_CONF_FILE_MAX);
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot read banner file:", tunable_banner_file);
}
}
if (tunable_secure_email_list_enable)
{
int retval = -1;
if (tunable_email_password_file)
{
retval = str_fileread(&the_session.email_passwords_str,
tunable_email_password_file,
VSFTP_CONF_FILE_MAX);
}
if (vsf_sysutil_retval_is_error(retval))
{
die2("cannot read email passwords file:", tunable_email_password_file);
}
}
if (tunable_run_as_launching_user)
{
tunable_one_process_model = 1;
if (!vsf_sysutil_running_as_root())
{
tunable_connect_from_port_20 = 0;
tunable_chown_uploads = 0;
}
}
if (tunable_one_process_model)
{
vsf_one_process_start(&the_session);
}
else
{
vsf_two_process_start(&the_session);
}
/* NOTREACHED */
bug("should not get here: main");
return 1;
}
static void thread_create(pthread_t *thread, pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg)
{
int ret = pthread_create(thread, attr, start_routine, arg);
if (ret) die2(ret, "pthread_create");
}
