int ftp_rename(const char *oldname, const char *newname)
{
char *on;
char *nn;
#ifdef HAVE_LIBSSH
if (ftp->session)
return ssh_rename(oldname, newname);
#endif
on = xstrdup(oldname);
stripslash(on);
ftp_cmd("RNFR %s", on);
if(ftp->code != ctContinue) {
free(on);
return -1;
}
nn = xstrdup(newname);
stripslash(nn);
ftp_cmd("RNTO %s", nn);
if(ftp->code != ctComplete) {
free(on);
free(nn);
return -1;
}
ftp_cache_flush_mark_for(on);
ftp_cache_flush_mark_for(nn);
return 0;
}
int ssh_mkdir_verb(const char *path, verbose_t verb)
{
Attrib a;
u_int status, id;
char *abspath;
attrib_clear(&a);
a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
a.perm = 0777;
id = ftp->ssh_id++;
abspath = ftp_path_absolute(path);
stripslash(abspath);
ssh_send_string_attrs_request(id, SSH2_FXP_MKDIR, abspath,
strlen(abspath), &a);
status = ssh_get_status(id);
if(status != SSH2_FX_OK) {
ftp_err("Couldn't create directory: %s\n", fx2txt(status));
free(abspath);
return -1;
}
ftp_cache_flush_mark_for(abspath);
free(abspath);
return 0;
}
int ssh_send(const char *path, FILE *fp, putmode_t how,
transfer_mode_t mode, ftp_transfer_func hookf)
{
uint64_t offset = ftp->restart_offset;
reset_transfer_info();
ftp->ti.size = ftp->ti.restart_size = offset;
ftp->restart_offset = 0L;
ftp->ti.transfer_is_put = true;
if(how == putUnique) {
ftp_err(_("Unique put with SSH not implemented yet\n"));
return -1;
}
char* p = ftp_path_absolute(path);
stripslash(p);
ftp_cache_flush_mark_for(p);
if(how == putAppend) {
ftp_set_tmp_verbosity(vbNone);
offset = ftp_filesize(p);
}
int r = do_write(p, fp, hookf, offset);
free(p);
transfer_finished();
return r;
}
/* FIXME: path must be absolute (check)
*/
int ssh_chmod(const char *path, const char *mode)
{
Attrib a;
attrib_clear(&a);
a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
a.perm = strtoul(mode, 0, 8);
if(ssh_setstat(path, &a) == -1)
return -1;
ftp_cache_flush_mark_for(path);
return 0;
}
int ssh_send(const char *path, FILE *fp, putmode_t how,
transfer_mode_t mode, ftp_transfer_func hookf)
{
int r;
long offset = ftp->restart_offset;
char *p;
reset_transfer_info();
ftp->ti.size = ftp->ti.restart_size = offset;
ftp->restart_offset = 0L;
ftp->ti.transfer_is_put = true;
if(how == putUnique) {
ftp_err("Unique put with SSH not implemented yet\n");
return -1;
#if 0
/* try to figure out remote filename */
char *e = strstr(ftp->reply, " for ");
if(e) {
int l;
e += 5;
l = strlen(e);
if(l) {
free(ftp->ti.local_name);
if(*e == '\'')
ftp->ti.local_name = xstrndup(e+1, l-3);
else
ftp->ti.local_name = xstrndup(e, l-1);
ftp_trace("parsed unique filename as '%s'\n",
ftp->ti.local_name);
}
}
#endif
}
p = ftp_path_absolute(path);
stripslash(p);
ftp_cache_flush_mark_for(p);
if(how == putAppend) {
ftp_set_tmp_verbosity(vbNone);
offset = ftp_filesize(p);
}
r = ssh_send_binary(p, fp, hookf, offset);
free(p);
transfer_finished();
return 0;
}
/* FIXME: path must be absolute (check)
*/
int ssh_chmod(const char *path, const char *mode)
{
mode_t perm = strtoul(mode, 0, 9);
int rc = sftp_chmod(ftp->sftp_session, path, perm);
if (rc != SSH_OK)
{
ftp_err(_("Couldn't chmod file: %s\n"), ssh_get_error(ftp->session));
return -1;
}
ftp_cache_flush_mark_for(path);
return 0;
}
int ssh_rename(const char *oldname, const char *newname)
{
char* on = ftp_path_absolute(oldname);
char* nn = ftp_path_absolute(newname);
stripslash(on);
stripslash(nn);
int rc = sftp_rename(ftp->sftp_session, on, nn);
if (rc != SSH_OK)
{
ftp_err(_("Couldn't rename file '%s' to '%s': %s\n"),
on, nn, ssh_get_error(ftp->session));
free(on);
free(nn);
return -1;
}
ftp_cache_flush_mark_for(on);
ftp_cache_flush_mark_for(nn);
free(on);
free(nn);
return 0;
}
int ftp_unlink(const char *path)
{
#ifdef HAVE_LIBSSH
if(ftp->session)
return ssh_unlink(path);
#endif
ftp_cmd("DELE %s", path);
if(ftp->code == ctComplete) {
ftp_cache_flush_mark_for(path);
return 0;
}
return -1;
}
int ssh_rename(const char *oldname, const char *newname)
{
Buffer msg;
u_int status, id;
char *on, *nn;
buffer_init(&msg);
on = ftp_path_absolute(oldname);
nn = ftp_path_absolute(newname);
stripslash(on);
stripslash(nn);
/* Send rename request */
id = ftp->ssh_id++;
buffer_put_char(&msg, SSH2_FXP_RENAME);
buffer_put_int(&msg, id);
buffer_put_cstring(&msg, on);
buffer_put_cstring(&msg, nn);
ssh_cmd( &msg);
buffer_free(&msg);
status = ssh_get_status(id);
if(status != SSH2_FX_OK) {
ftp_err("Couldn't rename file \"%s\" to \"%s\": %s\n",
on, nn, fx2txt(status));
free(on);
free(nn);
return -1;
}
ftp_cache_flush_mark_for(on);
ftp_cache_flush_mark_for(nn);
free(on);
free(nn);
return 0;
}
int ssh_unlink(const char *path)
{
int rc = sftp_unlink(ftp->sftp_session, path);
if (rc != SSH_OK && sftp_get_error(ftp->sftp_session) != SSH_FX_NO_SUCH_FILE)
{
ftp_err(_("Couldn't delete file: %s\n"), ssh_get_error(ftp->session));
ftp->code = ctError;
ftp->fullcode = 500;
return -1;
}
else
ftp_cache_flush_mark_for(path);
return 0;
}
int ssh_mkdir_verb(const char *path, verbose_t verb)
{
char* abspath = ftp_path_absolute(path);
stripslash(abspath);
int rc = sftp_mkdir(ftp->sftp_session, abspath, S_IRWXU);
if (rc != SSH_OK && sftp_get_error(ftp->sftp_session) != SSH_FX_FILE_ALREADY_EXISTS)
{
ftp_err(_("Couldn't create directory: %s\n"), ssh_get_error(ftp->session));
free(abspath);
return rc;
}
ftp_cache_flush_mark_for(abspath);
free(abspath);
return 0;
}
int ssh_unlink(const char *path)
{
u_int status, id;
id = ftp->ssh_id++;
ssh_send_string_request(id, SSH2_FXP_REMOVE, path, strlen(path));
status = ssh_get_status(id);
if(status != SSH2_FX_OK) {
/* ftp_err("Couldn't delete file: %s\n", fx2txt(status));*/
ftp->code = ctError;
ftp->fullcode = 500;
return -1;
} else
ftp_cache_flush_mark_for(path);
return 0;
}
int ssh_rmdir(const char *path)
{
char* abspath = ftp_path_absolute(path);
stripslash(abspath);
int rc = sftp_rmdir(ftp->sftp_session, abspath);
if (rc != SSH_OK && sftp_get_error(ftp->sftp_session) != SSH_FX_NO_SUCH_FILE)
{
ftp_err(_("Couldn't remove directory: %s\n"), ssh_get_error(ftp->session));
free(abspath);
return rc;
}
ftp_cache_flush_mark(abspath);
ftp_cache_flush_mark_for(abspath);
free(abspath);
return 0;
}
static int ftp_mkdir_verb(const char *path, verbose_t verb)
{
char *p;
#ifdef HAVE_LIBSSH
if(ftp->session)
return ssh_mkdir_verb(path, verb);
#endif
p = xstrdup(path);
stripslash(p);
ftp_set_tmp_verbosity(verb);
ftp_cmd("MKD %s", p);
if(ftp->code == ctComplete)
ftp_cache_flush_mark_for(p);
free(p);
return ftp->code == ctComplete ? 0 : -1;
}
int ftp_rmdir(const char *path)
{
char *p;
#ifdef HAVE_LIBSSH
if(ftp->session)
return ssh_rmdir(path);
#endif
p = xstrdup(path);
stripslash(p);
ftp_set_tmp_verbosity(vbError);
ftp_cmd("RMD %s", p);
if(ftp->code == ctComplete) {
ftp_cache_flush_mark(p);
ftp_cache_flush_mark_for(p);
}
free(p);
return ftp->code == ctComplete ? 0 : -1;
}
int ftp_chmod(const char *path, const char *mode)
{
#ifdef HAVE_LIBSSH
if(ftp->session)
return ssh_chmod(path, mode);
#endif
if(ftp->has_site_chmod_command) {
ftp_set_tmp_verbosity(vbNone);
ftp_cmd("SITE CHMOD %s %s", mode, path);
if(ftp->fullcode == 502)
ftp->has_site_chmod_command = false;
if(ftp->code == ctComplete) {
ftp_cache_flush_mark_for(path);
return 0;
}
} else
ftp_err(_("Server doesn't support SITE CHMOD\n"));
return -1;
}
int ssh_rmdir(const char *path)
{
char *p;
u_int status, id;
p = ftp_path_absolute(path);
stripslash(p);
id = ftp->ssh_id++;
ssh_send_string_request(id, SSH2_FXP_RMDIR, p, strlen(p));
status = ssh_get_status(id);
if(status != SSH2_FX_OK) {
ftp_err("Couldn't remove directory: %s\n", fx2txt(status));
free(p);
return -1;
}
ftp_cache_flush_mark(p);
ftp_cache_flush_mark_for(p);
free(p);
return 0;
}
static int ftp_send(const char *path, FILE *fp, putmode_t how,
transfer_mode_t mode, ftp_transfer_func hookf)
{
int r;
long rp = ftp->restart_offset;
ftp->restart_offset = 0L;
if(how == putUnique && !ftp->has_stou_command)
return -1;
if (how == putTryUnique && !ftp->has_stou_command)
how = putNormal;
reset_transfer_info();
ftp->ti.transfer_is_put = true;
if(ftp_init_transfer() != 0)
return -1;
ftp_type(mode);
if(rp > 0) {
/* fp is assumed to be fseek'd already */
ftp_cmd("REST %ld", rp);
if(ftp->code != ctContinue)
return -1;
ftp->ti.size = rp;
ftp->ti.restart_size = rp;
}
ftp_set_tmp_verbosity(vbError);
switch (how) {
case putAppend:
ftp_cmd("APPE %s", path);
break;
case putTryUnique:
case putUnique:
ftp_cmd("STOU %s", path);
if (ftp->fullcode == 502 || ftp->fullcode == 504) {
ftp->has_stou_command = false;
if (how == putTryUnique)
how = putNormal;
else
break;
}
else
break;
default:
ftp_cmd("STOR %s", path);
break;
}
if(ftp->code != ctPrelim)
return -1;
if(how == putUnique) {
/* try to figure out remote filename */
char *e = strstr(ftp->reply, " for ");
if(e) {
int l;
e += 5;
l = strlen(e);
if(l) {
free(ftp->ti.local_name);
if(*e == '\'')
ftp->ti.local_name = xstrndup(e+1, l-3);
else
ftp->ti.local_name = xstrndup(e, l-1);
ftp_trace("parsed unique filename as '%s'\n",
ftp->ti.local_name);
}
}
}
if(!sock_accept(ftp->data, "w", ftp_is_passive())) {
ftp_err(_("data connection not accepted\n"));
return -1;
}
ftp_cache_flush_mark_for(path);
if(mode == tmBinary)
r = FILE_send_binary(fp, ftp->data);
else
r = FILE_send_ascii(fp, ftp->data);
sock_flush(ftp->data);
sock_destroy(ftp->data);
ftp->data = 0;
if(r == 0) {
transfer_finished();
ftp_read_reply();
ftp->ti.ioerror = (ftp->code != ctComplete);
if(ftp->code != ctComplete) {
ftp_trace("transfer failed\n");
return -1;
}
} else
transfer_finished();
return 0;
}
/* 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;
}
