void
vsf_sysutil_setproctitle_init(int argc, const char* argv[])
{
int i;
char** p_env = environ;
if (s_proctitle_inited)
{
bug("vsf_sysutil_setproctitle_init called twice");
}
s_proctitle_inited = 1;
if (argv[0] == 0)
{
die("no argv[0] in vsf_sysutil_setproctitle_init");
}
for (i=0; i<argc; i++)
{
s_proctitle_space += vsf_sysutil_strlen(argv[i]) + 1;
if (i > 0)
{
argv[i] = 0;
}
}
while (*p_env != 0)
{
s_proctitle_space += vsf_sysutil_strlen(*p_env) + 1;
p_env++;
}
/* Oops :-) */
environ = 0;
s_p_proctitle = (char*) argv[0];
vsf_sysutil_memclr(s_p_proctitle, s_proctitle_space);
}
void
vsf_exit(const char* p_text)
{
(void) vsf_sysutil_write_loop(VSFTP_COMMAND_FD, p_text,
vsf_sysutil_strlen(p_text));
vsf_sysutil_exit(0);
}
struct str_locate_result
str_locate_text_reverse(const struct mystr* p_str, const char* p_text)
{
struct str_locate_result retval;
unsigned int i;
unsigned int text_len = vsf_sysutil_strlen(p_text);
retval.found = 0;
retval.char_found = 0;
retval.index = 0;
if (text_len == 0 || text_len > p_str->len)
{
return retval;
}
i = p_str->len - text_len;
/* Want to go through loop once even if i==0 */
while (1)
{
if (vsf_sysutil_memcmp(p_str->p_buf + i, p_text, text_len) == 0)
{
retval.found = 1;
retval.index = i;
return retval;
}
if (i == 0)
{
break;
}
i--;
}
/* Not found */
return retval;
}
struct str_locate_result
str_locate_text(const struct mystr* p_str, const char* p_text)
{
struct str_locate_result retval;
unsigned int i;
unsigned int text_len = vsf_sysutil_strlen(p_text);
retval.found = 0;
retval.char_found = 0;
retval.index = 0;
if (text_len == 0 || text_len > p_str->len)
{
/* Not found */
return retval;
}
for (i=0; i <= (p_str->len - text_len); i++)
{
if (vsf_sysutil_memcmp(p_str->p_buf + i, p_text, text_len) == 0)
{
retval.found = 1;
retval.index = i;
return retval;
}
}
/* Not found */
return retval;
}
struct str_locate_result
str_locate_chars(const struct mystr* p_str, const char* p_chars)
{
struct str_locate_result retval;
unsigned int num_chars = vsf_sysutil_strlen(p_chars);
unsigned int i = 0;
retval.found = 0;
retval.char_found = 0;
retval.index = 0;
for (; i < p_str->len; ++i)
{
unsigned int j = 0;
char this_char = p_str->p_buf[i];
for (; j < num_chars; ++j)
{
if (p_chars[j] == this_char)
{
retval.found = 1;
retval.index = i;
retval.char_found = p_chars[j];
return retval;
}
}
}
return retval;
}
static void
str_split_text_common(struct mystr* p_src, struct mystr* p_rhs,
const char* p_text, int is_reverse)
{
struct str_locate_result locate_result;
unsigned int indexx;
unsigned int search_len = vsf_sysutil_strlen(p_text);
if (is_reverse)
{
locate_result = str_locate_text_reverse(p_src, p_text);
}
else
{
locate_result = str_locate_text(p_src, p_text);
}
/* Not found? */
if (!locate_result.found)
{
str_empty(p_rhs);
return;
}
indexx = locate_result.index;
if (indexx + search_len > p_src->len)
{
bug("indexx invalid in str_split_text");
}
/* Build rhs */
private_str_alloc_memchunk(p_rhs, p_src->p_buf + indexx + search_len,
p_src->len - indexx - search_len);
/* Build lhs */
str_trunc(p_src, indexx);
}
void
bug(const char* p_text)
{
/* Rats. Try and write the reason to the network for diagnostics */
vsf_sysutil_activate_noblock(VSFTP_COMMAND_FD);
(void) vsf_sysutil_write_loop(VSFTP_COMMAND_FD, FTP_500_STRING, FTP_500_SIZE);
(void) vsf_sysutil_write_loop(VSFTP_COMMAND_FD, p_text,
vsf_sysutil_strlen(p_text));
(void) vsf_sysutil_write_loop(VSFTP_COMMAND_FD, "\r\n", 2);
vsf_sysutil_exit(2);
}
void
ssl_init(struct vsf_session* p_sess)
{
if (!ssl_inited)
{
SSL_CTX* p_ctx;
long options;
int verify_option = 0;
SSL_library_init();
p_ctx = SSL_CTX_new(SSLv23_method());
if (p_ctx == NULL)
{
die("SSL: could not allocate SSL context");
}
options = SSL_OP_ALL;
if (!tunable_sslv2)
{
options |= SSL_OP_NO_SSLv2;
}
if (!tunable_sslv3)
{
options |= SSL_OP_NO_SSLv3;
}
if (!tunable_tlsv1)
{
options |= SSL_OP_NO_TLSv1;
}
SSL_CTX_set_options(p_ctx, options);
if (tunable_rsa_cert_file)
{
const char* p_key = tunable_rsa_private_key_file;
if (!p_key)
{
p_key = tunable_rsa_cert_file;
}
if (SSL_CTX_use_certificate_chain_file(p_ctx, tunable_rsa_cert_file) != 1)
{
die("SSL: cannot load RSA certificate");
}
if (SSL_CTX_use_PrivateKey_file(p_ctx, p_key, X509_FILETYPE_PEM) != 1)
{
die("SSL: cannot load RSA private key");
}
}
if (tunable_dsa_cert_file)
{
const char* p_key = tunable_dsa_private_key_file;
if (!p_key)
{
p_key = tunable_dsa_cert_file;
}
if (SSL_CTX_use_certificate_chain_file(p_ctx, tunable_dsa_cert_file) != 1)
{
die("SSL: cannot load DSA certificate");
}
if (SSL_CTX_use_PrivateKey_file(p_ctx, p_key, X509_FILETYPE_PEM) != 1)
{
die("SSL: cannot load DSA private key");
}
}
if (tunable_ssl_ciphers &&
SSL_CTX_set_cipher_list(p_ctx, tunable_ssl_ciphers) != 1)
{
die("SSL: could not set cipher list");
}
if (RAND_status() != 1)
{
die("SSL: RNG is not seeded");
}
if (tunable_ssl_request_cert)
{
verify_option |= SSL_VERIFY_PEER;
}
if (tunable_require_cert)
{
verify_option |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
}
if (verify_option)
{
SSL_CTX_set_verify(p_ctx, verify_option, ssl_verify_callback);
if (tunable_ca_certs_file)
{
STACK_OF(X509_NAME)* p_names;
if (!SSL_CTX_load_verify_locations(p_ctx, tunable_ca_certs_file, NULL))
{
die("SSL: could not load verify file");
}
p_names = SSL_load_client_CA_file(tunable_ca_certs_file);
if (!p_names)
{
die("SSL: could not load client certs file");
}
SSL_CTX_set_client_CA_list(p_ctx, p_names);
}
}
{
static const char* p_ctx_id = VSF_PROJECT;
SSL_CTX_set_session_id_context(p_ctx, (void*) p_ctx_id,
vsf_sysutil_strlen(p_ctx_id));
}
if (tunable_require_ssl_reuse)
{
/* Ensure cached session doesn't expire */
SSL_CTX_set_timeout(p_ctx, INT_MAX);
}
p_sess->p_ssl_ctx = p_ctx;
ssl_inited = 1;
}
}
/* Public functions */
void
str_alloc_text(struct mystr* p_str, const char* p_src)
{
unsigned int len = vsf_sysutil_strlen(p_src);
private_str_alloc_memchunk(p_str, p_src, len);
}
int
str_equal_text(const struct mystr* p_str, const char* p_text)
{
unsigned int cmplen = vsf_sysutil_strlen(p_text);
return (str_equal_internal(p_str->p_buf, p_str->len, p_text, cmplen) == 0);
}
