enum EVSFPrivopLoginResult
vsf_privop_do_login(struct vsf_session* p_sess,
const struct mystr* p_pass_str)
{
enum EVSFPrivopLoginResult result =
handle_login(p_sess, &p_sess->user_str, p_pass_str);
vsf_log_start_entry(p_sess, kVSFLogEntryLogin);
if (result == kVSFLoginFail)
{
vsf_log_do_log(p_sess, 0);
if (tunable_delay_failed_login)
{
vsf_sysutil_sleep((double) tunable_delay_failed_login);
}
}
else
{
vsf_log_do_log(p_sess, 1);
if (tunable_delay_successful_login)
{
vsf_sysutil_sleep((double) tunable_delay_successful_login);
}
}
return result;
}
static void check_login_delay()
{
if (tunable_delay_failed_login)
{
vsf_sysutil_sleep((double) tunable_delay_failed_login);
}
}
int
vsf_privop_get_ftp_port_sock(struct vsf_session* p_sess,
unsigned short remote_port,
int use_port_sockaddr)
{
static struct vsf_sysutil_sockaddr* p_sockaddr;
const struct vsf_sysutil_sockaddr* p_connect_to;
int retval;
int i;
int s = vsf_sysutil_get_ipsock(p_sess->p_local_addr);
int port = 0;
if (vsf_sysutil_is_port_reserved(remote_port))
{
die("Illegal port request");
}
if (tunable_connect_from_port_20)
{
port = tunable_ftp_data_port;
}
vsf_sysutil_activate_reuseaddr(s);
/* A report of failure here on Solaris, presumably buggy address reuse
* support? We'll retry.
*/
for (i = 0; i < 2; ++i)
{
double sleep_for;
vsf_sysutil_sockaddr_clone(&p_sockaddr, p_sess->p_local_addr);
vsf_sysutil_sockaddr_set_port(p_sockaddr, port);
retval = vsf_sysutil_bind(s, p_sockaddr);
if (retval == 0)
{
break;
}
if (vsf_sysutil_get_error() != kVSFSysUtilErrADDRINUSE || i == 1)
{
die("vsf_sysutil_bind");
}
sleep_for = vsf_sysutil_get_random_byte();
sleep_for /= 256.0;
sleep_for += 1.0;
vsf_sysutil_sleep(sleep_for);
}
if (use_port_sockaddr)
{
p_connect_to = p_sess->p_port_sockaddr;
}
else
{
vsf_sysutil_sockaddr_set_port(p_sess->p_remote_addr, remote_port);
p_connect_to = p_sess->p_remote_addr;
}
retval = vsf_sysutil_connect_timeout(s, p_connect_to,
tunable_connect_timeout);
if (vsf_sysutil_retval_is_error(retval))
{
vsf_sysutil_close(s);
s = -1;
}
return s;
}
static void
handle_io(int retval, int fd, void* p_private)
{
long curr_sec;
long curr_usec;
unsigned int bw_rate;
double elapsed;
double pause_time;
double rate_ratio;
struct vsf_session* p_sess = (struct vsf_session*) p_private;
if (p_sess->data_fd != fd || vsf_sysutil_retval_is_error(retval) ||
retval == 0)
{
return;
}
/* Note that the session hasn't stalled, i.e. don't time it out */
p_sess->data_progress = 1;
/* Apply bandwidth quotas via a little pause, if necessary */
if (p_sess->bw_rate_max == 0)
{
return;
}
/* Calculate bandwidth rate */
vsf_sysutil_update_cached_time();
curr_sec = vsf_sysutil_get_cached_time_sec();
curr_usec = vsf_sysutil_get_cached_time_usec();
elapsed = (double) (curr_sec - p_sess->bw_send_start_sec);
elapsed += (double) (curr_usec - p_sess->bw_send_start_usec) /
(double) 1000000;
if (elapsed <= (double) 0)
{
elapsed = (double) 0.01;
}
bw_rate = (unsigned int) ((double) retval / elapsed);
if (bw_rate <= p_sess->bw_rate_max)
{
p_sess->bw_send_start_sec = curr_sec;
p_sess->bw_send_start_usec = curr_usec;
return;
}
/* Tut! Rate exceeded, calculate a pause to bring things back into line */
rate_ratio = (double) bw_rate / (double) p_sess->bw_rate_max;
pause_time = (rate_ratio - (double) 1) * elapsed;
vsf_sysutil_sleep(pause_time);
vsf_sysutil_update_cached_time();
p_sess->bw_send_start_sec = vsf_sysutil_get_cached_time_sec();
p_sess->bw_send_start_usec = vsf_sysutil_get_cached_time_usec();
}
