static int
gftpui_gtk_tdata_connect (gftpui_callback_data * cdata)
{
gftp_transfer * tdata;
int ret;
tdata = cdata->user_data;
if (tdata->fromreq != NULL)
{
ret = gftp_connect (tdata->fromreq);
if (ret < 0)
return (ret);
}
if (tdata->toreq != NULL)
{
ret = gftp_connect (tdata->toreq);
if (ret < 0)
return (ret);
}
return (0);
}
static int
_gftpui_common_trans_file_or_dir (gftp_transfer * tdata)
{
gftp_file * curfle;
int ret;
if (g_thread_supported ())
g_static_mutex_lock (&tdata->structmutex);
curfle = tdata->curfle->data;
tdata->current_file_number++;
if (g_thread_supported ())
g_static_mutex_unlock (&tdata->structmutex);
if (curfle->transfer_action == GFTP_TRANS_ACTION_SKIP)
{
tdata->tot_file_trans = 0;
return (0);
}
if ((ret = gftp_connect (tdata->fromreq)) < 0)
return (ret);
if ((ret = gftp_connect (tdata->toreq)) < 0)
return (ret);
if (S_ISDIR (curfle->st_mode))
{
tdata->tot_file_trans = 0;
if (curfle->startsize > 0)
ret = 1;
else
ret = gftp_make_directory (tdata->toreq, curfle->destfile);
}
else
{
if (curfle->size == 0)
{
curfle->size = gftp_get_file_size (tdata->fromreq, curfle->file);
if (curfle->size < 0)
return ((int) curfle->size);
tdata->total_bytes += curfle->size;
}
if (curfle->retry_transfer)
{
curfle->transfer_action = GFTP_TRANS_ACTION_RESUME;
curfle->startsize = gftp_get_file_size (tdata->toreq, curfle->destfile);
if (curfle->startsize < 0)
return ((int) curfle->startsize);
}
tdata->tot_file_trans = gftp_transfer_file (tdata->fromreq, curfle->file,
curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ?
curfle->startsize : 0,
tdata->toreq, curfle->destfile,
curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ?
curfle->startsize : 0);
if (tdata->tot_file_trans < 0)
ret = tdata->tot_file_trans;
else
{
if (g_thread_supported ())
g_static_mutex_lock (&tdata->structmutex);
tdata->curtrans = 0;
tdata->curresumed = curfle->transfer_action == GFTP_TRANS_ACTION_RESUME ? curfle->startsize : 0;
tdata->resumed_bytes += tdata->curresumed;
if (g_thread_supported ())
g_static_mutex_unlock (&tdata->structmutex);
ret = _gftpui_common_do_transfer_file (tdata, curfle);
}
}
if (ret == 0)
ret = _gftpui_common_preserve_perm_time (tdata, curfle);
else
{
curfle->retry_transfer = 1;
tdata->fromreq->logging_function (gftp_logging_error, tdata->fromreq,
_("Could not download %s from %s\n"),
curfle->file, tdata->fromreq->hostname);
}
return (ret);
}
int
gftpui_common_run_connect (gftpui_callback_data * cdata)
{
return (gftp_connect (cdata->request));
}
off_t
gftp_transfer_file (gftp_request * fromreq, const char *fromfile,
off_t fromsize, gftp_request * toreq, const char *tofile,
off_t tosize)
{
/* Needed for systems that size(float) < size(void *) */
union { intptr_t i; float f; } maxkbs;
off_t size;
int ret;
g_return_val_if_fail (fromreq != NULL, GFTP_EFATAL);
g_return_val_if_fail (fromfile != NULL, GFTP_EFATAL);
g_return_val_if_fail (toreq != NULL, GFTP_EFATAL);
g_return_val_if_fail (tofile != NULL, GFTP_EFATAL);
gftp_lookup_request_option (toreq, "maxkbs", &maxkbs.f);
if (maxkbs.f > 0)
{
toreq->logging_function (gftp_logging_misc, toreq,
_("File transfer will be throttled to %.2f KB/s\n"),
maxkbs.f);
}
if (fromreq->protonum == toreq->protonum &&
fromreq->transfer_file != NULL)
return (fromreq->transfer_file (fromreq, fromfile, fromsize, toreq,
tofile, tosize));
fromreq->cached = 0;
toreq->cached = 0;
get_file:
size = gftp_get_file (fromreq, fromfile, tosize);
if (size < 0)
{
if (size == GFTP_ETIMEDOUT)
{
ret = gftp_connect (fromreq);
if (ret < 0)
return (ret);
goto get_file;
}
return (size);
}
put_file:
ret = gftp_put_file (toreq, tofile, tosize, size);
if (ret != 0)
{
if (size == GFTP_ETIMEDOUT)
{
ret = gftp_connect (fromreq);
if (ret < 0)
return (ret);
goto put_file;
}
if (gftp_abort_transfer (fromreq) != 0)
gftp_end_transfer (fromreq);
return (ret);
}
return (size);
}
int
gftp_get_transfer_status (gftp_transfer * tdata, ssize_t num_read)
{
intptr_t retries, sleep_time;
gftp_file * tempfle;
int ret1, ret2;
gftp_lookup_request_option (tdata->fromreq, "retries", &retries);
gftp_lookup_request_option (tdata->fromreq, "sleep_time", &sleep_time);
if (g_thread_supported ())
g_static_mutex_lock (&tdata->structmutex);
if (tdata->curfle == NULL)
{
if (g_thread_supported ())
g_static_mutex_unlock (&tdata->structmutex);
return (GFTP_EFATAL);
}
tempfle = tdata->curfle->data;
if (g_thread_supported ())
g_static_mutex_unlock (&tdata->structmutex);
gftp_disconnect (tdata->fromreq);
gftp_disconnect (tdata->toreq);
if (tdata->cancel || num_read == GFTP_EFATAL)
return (GFTP_EFATAL);
else if (num_read >= 0 && !tdata->skip_file)
return (0);
if (num_read != GFTP_ETIMEDOUT && !tdata->conn_error_no_timeout)
{
if (retries != 0 &&
tdata->current_file_retries >= retries)
{
tdata->fromreq->logging_function (gftp_logging_error, tdata->fromreq,
_("Error: Remote site %s disconnected. Max retries reached...giving up\n"),
tdata->fromreq->hostname != NULL ?
tdata->fromreq->hostname : tdata->toreq->hostname);
return (GFTP_EFATAL);
}
else
{
tdata->fromreq->logging_function (gftp_logging_error, tdata->fromreq,
_("Error: Remote site %s disconnected. Will reconnect in %d seconds\n"),
tdata->fromreq->hostname != NULL ?
tdata->fromreq->hostname : tdata->toreq->hostname,
sleep_time);
}
}
while (retries == 0 ||
tdata->current_file_retries <= retries)
{
/* Look up the options in case the user changes them... */
gftp_lookup_request_option (tdata->fromreq, "retries", &retries);
gftp_lookup_request_option (tdata->fromreq, "sleep_time", &sleep_time);
if (num_read != GFTP_ETIMEDOUT && !tdata->conn_error_no_timeout &&
!tdata->skip_file)
_do_sleep (sleep_time);
tdata->current_file_retries++;
ret1 = ret2 = 0;
if ((ret1 = gftp_connect (tdata->fromreq)) == 0 &&
(ret2 = gftp_connect (tdata->toreq)) == 0)
{
if (g_thread_supported ())
g_static_mutex_lock (&tdata->structmutex);
tdata->resumed_bytes = tdata->resumed_bytes + tdata->trans_bytes - tdata->curresumed - tdata->curtrans;
tdata->trans_bytes = 0;
if (tdata->skip_file)
{
tdata->total_bytes -= tempfle->size;
tdata->curtrans = 0;
tdata->curfle = tdata->curfle->next;
tdata->next_file = 1;
tdata->skip_file = 0;
tdata->cancel = 0;
tdata->fromreq->cancel = 0;
tdata->toreq->cancel = 0;
}
else
{
tempfle->transfer_action = GFTP_TRANS_ACTION_RESUME;
tempfle->startsize = tdata->curtrans + tdata->curresumed;
/* We decrement this here because it will be incremented in
the loop again */
tdata->curresumed = 0;
tdata->current_file_number--; /* Decrement this because it
will be incremented when we
continue in the loop */
}
gettimeofday (&tdata->starttime, NULL);
if (g_thread_supported ())
g_static_mutex_unlock (&tdata->structmutex);
return (GFTP_ERETRYABLE);
}
else if (ret1 == GFTP_EFATAL || ret2 == GFTP_EFATAL)
{
gftp_disconnect (tdata->fromreq);
gftp_disconnect (tdata->toreq);
return (GFTP_EFATAL);
}
}
return (0);
}
