static void getfiles(list *gl, unsigned int opt, const char *output)
{
listitem *li;
rfile *fp, *lnfp;
const char *opath, *ofile;
char *link = 0;
list_sort(gl, get_sort_func, false);
li = gl->first;
while(li && !get_quit) {
fp = (rfile *)li->data;
if(!ftp_connected())
return;
if(gvSighupReceived) {
if(!test(opt, GET_RESUME))
opt |= GET_UNIQUE;
opt |= GET_FORCE;
}
opath = fp->path;
ofile = base_name_ptr(opath);
if(strcmp(ofile, ".")==0 || strcmp(ofile, "..")==0) {
transfer_nextfile(gl, &li, true);
continue;
}
if(test(opt, GET_INTERACTIVE) && !get_batch && !gvSighupReceived) {
char* sp = shortpath(opath, 42, ftp->homedir);
int a = ask(ASKYES|ASKNO|ASKCANCEL|ASKALL, ASKYES,
_("Get '%s'?"), sp);
free(sp);
if(a == ASKNO) {
transfer_nextfile(gl, &li, true);
continue;
}
if(a == ASKCANCEL) {
get_quit = true;
break;
}
if(a == ASKALL)
get_batch = true;
/* else a==ASKYES */
}
if(rislink(fp)) {
link_to_link__duh:
if(test(opt, GET_NO_DEREFERENCE)) {
/* link the file, don't copy */
const int r = getfile(fp, opt, output, ofile);
transfer_nextfile(gl, &li, r == 0);
continue;
}
{
char *xcurdir = base_dir_xptr(opath);
link = path_absolute(fp->link, xcurdir, ftp->homedir);
stripslash(link);
free(xcurdir);
ftp_trace("found link: '%s' -> '%s'\n", opath, link);
}
lnfp = ftp_get_file(link);
if(lnfp == 0) {
/* couldn't dereference the link, try to RETR it */
ftp_trace("unable to dereference link\n");
const int r = getfile(fp, opt, output, ofile);
transfer_nextfile(gl, &li, r == 0);
continue;
}
if(strncmp(opath, lnfp->path, strlen(lnfp->path)) == 0) {
ftp_trace("opath == '%s', lnfp->path == '%s'\n", opath,
lnfp->path);
char* sp = shortpath(lnfp->path, 42, ftp->homedir);
fprintf(stderr, _("%s: circular link -- skipping\n"), sp);
free(sp);
transfer_nextfile(gl, &li, true);
continue;
}
fp = lnfp;
if(rislink(fp))
/* found a link pointing to another link
*/
/* forgive me father, for I have goto'ed */
goto link_to_link__duh;
}
if(risdir(fp)) {
if(test(opt, GET_RECURSIVE)) {
char *recurs_output;
char *recurs_mask;
list *rgl;
if((get_dir_glob_mask && fnmatch(get_dir_glob_mask,
base_name_ptr(fp->path),
FNM_EXTMATCH) == FNM_NOMATCH)
#ifdef HAVE_REGEX
|| (get_dir_rx_mask_set && regexec(&get_dir_rx_mask,
base_name_ptr(fp->path),
0, 0, 0) == REG_NOMATCH)
#endif
)
{
} else {
char *q_recurs_mask;
bool success = true;
if(!test(opt, GET_PARENTS))
success = asprintf(&recurs_output, "%s/%s",
output ? output : ".", ofile) != -1;
else
success = asprintf(&recurs_output, "%s",
output ? output : ".") != -1;
if (!success)
{
fprintf(stderr, _("Failed to allocate memory.\n"));
transfer_nextfile(gl, &li, true);
continue;
}
if (asprintf(&recurs_mask, "%s/*", opath) == -1)
{
free(recurs_output);
fprintf(stderr, _("Failed to allocate memory.\n"));
transfer_nextfile(gl, &li, true);
continue;
}
rgl = rglob_create();
q_recurs_mask = backslash_quote(recurs_mask);
rglob_glob(rgl, q_recurs_mask, true, true, get_exclude_func);
free(q_recurs_mask);
if(list_numitem(rgl) > 0)
getfiles(rgl, opt, recurs_output);
if(test(opt, GET_PRESERVE))
get_preserve_attribs(fp, recurs_output);
rglob_destroy(rgl);
free(recurs_output);
}
} else if(test(opt, GET_VERBOSE)) {
char* sp = shortpath(opath, 42, ftp->homedir);
fprintf(stderr, _("%s: omitting directory\n"), sp);
free(sp);
}
transfer_nextfile(gl, &li, true);
continue;
}
if(!risreg(fp)) {
if(test(opt, GET_VERBOSE)) {
char* sp = shortpath(opath, 42, ftp->homedir);
fprintf(stderr, _("%s: not a regular file\n"), sp);
free(sp);
}
transfer_nextfile(gl, &li, true);
continue;
}
const int r = getfile(fp, opt, output, ofile);
transfer_nextfile(gl, &li, r == 0);
if(gvInterrupted) {
gvInterrupted = false;
if(li && !get_quit && ftp_connected() && !gvSighupReceived)
{
int a = ask(ASKYES|ASKNO, ASKYES,
_("Continue transfer?"));
if(a == ASKNO) {
get_quit = true;
break;
}
/* else a == ASKYES */
fprintf(stderr, _("Excellent!!!\n"));
}
}
}
}
static void putfile(const char *path, struct stat *sb,
unsigned opt, const char *output)
{
putmode_t how = putNormal;
bool file_exists = false;
char *dest, *dpath;
int r;
bool dir_created;
char *dest_dir, *q_dest_dir;
if((put_glob_mask && fnmatch(put_glob_mask, base_name_ptr(path),
FNM_EXTMATCH) == FNM_NOMATCH)
#ifdef HAVE_REGEX
|| (put_rx_mask_set && regexec(&put_rx_mask, base_name_ptr(path),
0, 0, 0) == REG_NOMATCH)
#endif
)
return;
if(!output)
output = ".";
if(test(opt, PUT_PARENTS)) {
char *p = base_dir_xptr(path);
asprintf(&dest, "%s/%s/%s", output, p, base_name_ptr(path));
free(p);
} else if(test(opt, PUT_OUTPUT_FILE))
dest = xstrdup(output);
else
asprintf(&dest, "%s/%s", output, base_name_ptr(path));
path_collapse(dest);
/* make sure destination directory exists */
dpath = base_dir_xptr(dest);
dest_dir = ftp_path_absolute(dpath);
q_dest_dir = bash_backslash_quote(dest_dir);
r = ftp_mkpath(q_dest_dir);
free(q_dest_dir);
free(dest_dir);
if(r == -1) {
transfer_mail_msg(_("failed to create directory %s\n"), dest_dir);
free(dpath);
free(dest);
return;
}
dir_created = (r == 1);
if(!dir_created && !test(opt, PUT_UNIQUE) && !test(opt, PUT_FORCE)) {
rfile *f;
f = ftp_get_file(dest);
file_exists = (f != 0);
if(f && risdir(f)) {
/* can't overwrite a directory */
printf(_("%s: is a directory\n"), dest);
free(dest);
return;
}
}
if(test(opt, PUT_APPEND)) {
how = putAppend;
} else if(file_exists) {
if(test(opt, PUT_SKIP_EXISTING)) {
printf(_("Remote file '%s' exists, skipping...\n"),
shortpath(dest, 42, ftp->homedir));
free(dest);
return;
}
else if(test(opt, PUT_NEWER)) {
time_t ft = ftp_filetime(dest);
if(ft != (time_t)-1 && ft >= sb->st_mtime) {
printf(_("Remote file '%s' is newer than local, skipping...\n"),
shortpath(dest, 42, ftp->homedir));
free(dest);
return;
}
}
else if(!test(opt, PUT_RESUME)) {
if(!put_owbatch) {
struct tm *fan = gmtime(&sb->st_mtime);
time_t ft;
int a;
rfile *f;
char *e;
f = ftp_get_file(dest);
ft = ftp_filetime(f->path);
sb->st_mtime = gmt_mktime(fan);
e = xstrdup(ctime(&sb->st_mtime));
a = ask(ASKYES|ASKNO|ASKUNIQUE|ASKCANCEL|ASKALL|ASKRESUME,
ASKRESUME,
_("Remote file '%s' exists\nLocal: %lld bytes, %sRemote: %lld bytes, %sOverwrite?"),
shortpath(dest, 42, ftp->homedir),
(unsigned long long) sb->st_size, e ? e : "unknown size",
ftp_filesize(f->path), ctime(&ft));
free(e);
if(a == ASKCANCEL) {
put_quit = true;
free(dest);
return;
}
else if(a == ASKNO) {
free(dest);
return;
}
else if(a == ASKUNIQUE)
opt |= PUT_UNIQUE; /* for this file only */
else if(a == ASKALL)
put_owbatch = true;
else if(a == ASKRESUME)
opt |= PUT_RESUME; /* for this file only */
/* else a == ASKYES */
}
}
}
if(test(opt, PUT_RESUME))
how = putResume;
if(test(opt, PUT_UNIQUE))
how = putUnique;
r = do_the_put(path, dest, how, opt);
free(dest);
if(r != 0)
return;
if(test(opt, PUT_PRESERVE)) {
if(ftp->has_site_chmod_command)
ftp_chmod(ftp->ti.local_name, get_mode_string(sb->st_mode));
}
if(test(opt, PUT_DELETE_AFTER)) {
bool dodel = false;
if(!test(opt, PUT_FORCE) && !put_delbatch) {
int a = ask(ASKYES|ASKNO|ASKCANCEL|ASKALL, ASKYES,
_("Delete local file '%s'?"),
shortpath(path, 42, gvLocalHomeDir));
if(a == ASKALL) {
put_delbatch = true;
dodel = true;
}
else if(a == ASKCANCEL)
put_quit = true;
else if(a != ASKNO)
dodel = true;
} else
dodel = true;
if(dodel) {
if(unlink(path) == 0)
printf(_("%s: deleted\n"),
shortpath(path, 42, gvLocalHomeDir));
else
printf(_("error deleting '%s': %s\n"),
shortpath(path, 42, gvLocalHomeDir),
strerror(errno));
}
}
}
int ftp_putfile(const char *infile, const char *outfile, putmode_t how,
transfer_mode_t mode, ftp_transfer_func hookf)
{
FILE *fp;
int r;
struct stat statbuf;
if(stat(infile, &statbuf) != 0) {
perror(infile);
return -1;
}
if(S_ISDIR(statbuf.st_mode)) {
ftp_err(_("%s: is a directory\n"), infile);
return -1;
}
fp = fopen(infile, "r");
if(fp == 0) {
perror(infile);
return -1;
}
ftp->ti.total_size = statbuf.st_size;
free(ftp->ti.remote_name);
free(ftp->ti.local_name);
ftp->ti.remote_name = xstrdup(infile); /* actually local file, or _target_ */
ftp->ti.local_name = xstrdup(outfile); /* actually remote file, or _source_ */
if(how == putResume) {
rfile *f;
f = ftp_get_file(outfile);
if(f && f->size != (unsigned long long)-1)
ftp->restart_offset = f->size;
else {
ftp->restart_offset = ftp_filesize(outfile);
if(ftp->restart_offset == (unsigned long long)-1) {
ftp_err(_("unable to get remote filesize of '%s',"
" unable to resume\n"),
outfile);
ftp->restart_offset = 0L;
}
}
} else
ftp->restart_offset = 0L;
if(ftp->restart_offset > 0L) {
if(fseek(fp, ftp->restart_offset, SEEK_SET) != 0) {
ftp_err(_("%s: %s, transfer cancelled\n"),
outfile, strerror(errno));
fclose(fp);
return -1;
}
}
foo_hookf = hookf;
#ifdef HAVE_LIBSSH
if(ftp->session)
r = ssh_send(outfile, fp, how, mode, hookf);
else
#endif
r = ftp_send(outfile, fp, how, mode, hookf);
fclose(fp);
return r;
}
/* transfers SRCFILE on SRCFTP to DESTFILE on DESTFTP
* using pasv mode on SRCFTP and port mode on DESTFTP
*
*/
int ftp_fxpfile(Ftp *srcftp, const char *srcfile,
Ftp *destftp, const char *destfile,
fxpmode_t how, transfer_mode_t mode)
{
int r;
unsigned int old_reply_timeout;
Ftp *thisftp;
unsigned char addr[6];
/* printf("FxP: %s -> %s\n", srcftp->url->hostname, destftp->url->hostname);*/
if(srcftp == destftp) {
ftp_err(_("FxP between same hosts\n"));
return -1;
}
#ifdef HAVE_LIBSSH
if(ftp->session) {
ftp_err("FxP with SSH not implemented\n");
return -1;
}
#endif
thisftp = ftp; /* save currently active connection */
/* setup source side */
ftp_use(srcftp);
ftp_type(mode);
// TODO: IPv6 support
if(!ftp_pasv(false, addr, NULL)) {
ftp_use(thisftp);
return -1;
}
ftp->ti.total_size = -1;
/* setup destination side */
ftp_use(destftp);
ftp_type(mode);
ftp_cmd("PORT %d,%d,%d,%d,%d,%d",
addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
if(ftp->code != ctComplete) {
ftp_use(thisftp);
return -1;
}
ftp->ti.total_size = -1;
ftp_use(destftp);
if(how == fxpResume) {
rfile *f;
f = ftp_get_file(destfile);
if(f && f->size != (unsigned long long)-1)
ftp->restart_offset = f->size;
else {
ftp->restart_offset = ftp_filesize(destfile);
if(ftp->restart_offset == (unsigned long long)-1) {
ftp_err(_("unable to get remote filesize of '%s',"
" unable to resume\n"),
destfile);
ftp->restart_offset = 0L;
}
}
} else
ftp->restart_offset = 0L;
if(ftp->restart_offset) {
/* RESTart on destftp */
ftp_cmd("REST %ld", ftp->restart_offset);
if(ftp->code != ctContinue)
return -1;
ftp_use(srcftp);
ftp_cmd("REST %ld", ftp->restart_offset);
if(ftp->code != ctContinue)
return -1;
}
/* issue a STOR command on DESTFTP */
ftp_use(destftp);
switch(how) {
case fxpUnique:
if(ftp->has_stou_command) {
ftp_cmd("STOU %s", destfile);
if(ftp->fullcode == 502)
ftp->has_stou_command = false;
} else {
ftp->code = ctError;
ftp->fullcode = 502;
}
break;
case fxpAppend:
ftp_cmd("APPE %s", destfile);
break;
case fxpNormal:
default:
ftp_cmd("STOR %s", destfile);
break;
}
ftp_cache_flush_mark_for(destfile);
if(ftp->code != ctPrelim) {
ftp_use(thisftp);
return -1;
}
/* issue a RETR command on SRCFTP */
ftp_use(srcftp);
ftp_cmd("RETR %s", srcfile);
if(ftp->code != ctPrelim) {
ftp_use(destftp);
ftp_abort(NULL);
ftp_use(thisftp);
return -1;
}
ftp_use(destftp);
old_reply_timeout = ftp->reply_timeout;
ftp_reply_timeout(0);
ftp_read_reply();
ftp_reply_timeout(old_reply_timeout);
r = (ftp->code == ctComplete ? 0 : -1);
ftp_use(srcftp);
old_reply_timeout = ftp->reply_timeout;
ftp_reply_timeout(0);
ftp_read_reply();
ftp_reply_timeout(old_reply_timeout);
ftp_use(thisftp);
return r;
}
static int fxpfile(const rfile *fi, unsigned int opt,
const char *output, const char *destname)
{
fxpmode_t how = fxpNormal;
bool file_exists = false;
char *dest, *dpath;
bool dir_created;
char *dest_dir, *q_dest_dir;
Ftp *thisftp = ftp;
if((fxp_glob_mask
&& fnmatch(fxp_glob_mask, base_name_ptr(fi->path), 0) == FNM_NOMATCH)
#ifdef HAVE_REGEX
|| (fxp_rx_mask_set
&& regexec(&fxp_rx_mask,
base_name_ptr(fi->path), 0, 0, 0) == REG_NOMATCH)
#endif
)
return 0;
if(!output)
output = ".";
if(test(opt, FXP_PARENTS)) {
char *p = base_dir_xptr(fi->path);
if (asprintf(&dest, "%s/%s/%s", output, p, base_name_ptr(fi->path)) == -1)
{
fprintf(stderr, _("Failed to allocate memory.\n"));
free(p);
return -1;
}
free(p);
} else if(test(opt, FXP_OUTPUT_FILE))
dest = xstrdup(output);
else
if (asprintf(&dest, "%s/%s", output, base_name_ptr(fi->path)) == -1)
{
fprintf(stderr, _("Failed to allocate memory.\n"));
return -1;
}
path_collapse(dest);
ftp_use(fxp_target);
/* make sure destination directory exists */
dpath = base_dir_xptr(dest);
dest_dir = ftp_path_absolute(dpath);
q_dest_dir = backslash_quote(dest_dir);
int r = ftp_mkpath(q_dest_dir);
free(q_dest_dir);
free(dest_dir);
if(r == -1) {
transfer_mail_msg(_("Couldn't create directory: %s\n"), dest_dir);
free(dpath);
free(dest);
ftp_use(thisftp);
return -1;
}
dir_created = (r == 1);
if(!dir_created && !test(opt, FXP_UNIQUE) && !test(opt, FXP_FORCE)) {
rfile *f;
f = ftp_get_file(dest);
file_exists = (f != 0);
if(f && risdir(f)) {
/* can't overwrite a directory */
printf(_("%s: is a directory\n"), dest);
free(dest);
return 0;
}
}
if(test(opt, FXP_APPEND)) {
how = fxpAppend;
} else if(file_exists) {
if(test(opt, FXP_SKIP_EXISTING)) {
char* sp = shortpath(dest, 42, ftp->homedir);
printf(_("Remote file '%s' exists, skipping...\n"), sp);
free(sp);
free(dest);
ftp_use(thisftp);
return 0;
}
else if(test(opt, FXP_NEWER)) {
time_t src_ft;
time_t dst_ft;
ftp_use(thisftp);
src_ft = ftp_filetime(fi->path, test(opt, FXP_FORCE_NEWER));
ftp_use(fxp_target);
dst_ft = ftp_filetime(dest, test(opt, FXP_FORCE_NEWER));
if(src_ft != (time_t)-1 && dst_ft != (time_t)-1 && dst_ft >= src_ft) {
char* sp = shortpath(dest, 42, ftp->homedir);
printf(_("Remote file '%s' is newer than local, skipping...\n"), sp);
free(sp);
free(dest);
ftp_use(thisftp);
return 0;
}
}
else if(!test(opt, FXP_RESUME)) {
if(!fxp_owbatch) {
char* sp = shortpath(dest, 42, ftp->homedir);
int a = ask(ASKYES|ASKNO|ASKUNIQUE|ASKCANCEL|ASKALL|ASKRESUME,
ASKRESUME,
_("File '%s' exists, overwrite?"),
sp);
free(sp);
if(a == ASKCANCEL) {
fxp_quit = true;
free(dest);
ftp_use(thisftp);
return 0;
}
else if(a == ASKNO) {
free(dest);
ftp_use(thisftp);
return 0;
}
else if(a == ASKUNIQUE)
opt |= FXP_UNIQUE; /* for this file only */
else if(a == ASKALL)
fxp_owbatch = true;
else if(a == ASKRESUME)
opt |= FXP_RESUME; /* for this file only */
/* else a == ASKYES */
}
}
}
if(test(opt, FXP_RESUME))
how = fxpResume;
if(test(opt, FXP_UNIQUE))
how = fxpUnique;
r = do_the_fxp(thisftp, fi->path, fxp_target, dest, how, opt);
free(dest);
if(r != 0) {
ftp_use(thisftp);
return -1;
}
if(test(opt, FXP_PRESERVE))
fxp_preserve_attribs(fi, dest);
if(test(opt, FXP_DELETE_AFTER)) {
bool dodel = false;
ftp_use(thisftp);
if(!test(opt, FXP_FORCE)
&& !fxp_delbatch && !gvSighupReceived)
{
char* sp = shortpath(fi->path, 42, ftp->homedir);
int a = ask(ASKYES|ASKNO|ASKCANCEL|ASKALL, ASKYES,
_("Delete remote file '%s'?"),
sp);
free(sp);
if(a == ASKALL) {
fxp_delbatch = true;
dodel = true;
}
else if(a == ASKCANCEL)
fxp_quit = true;
else if(a != ASKNO)
dodel = true;
} else
dodel = true;
if(dodel) {
ftp_unlink(fi->path);
char* sp = shortpath(fi->path, 42, ftp->homedir);
if(ftp->code == ctComplete)
fprintf(stderr, _("%s: deleted\n"), sp);
else
fprintf(stderr, _("error deleting '%s': %s\n"), sp,
ftp_getreply(false));
free(sp);
}
}
ftp_use(thisftp);
return 0;
}
