version 1.115, 2014/04/21 14:36:16 |
version 1.116, 2015/01/14 13:54:13 |
|
|
#include <unistd.h> |
#include <unistd.h> |
|
|
#include "xmalloc.h" |
#include "xmalloc.h" |
#include "buffer.h" |
#include "ssherr.h" |
|
#include "sshbuf.h" |
#include "log.h" |
#include "log.h" |
#include "atomicio.h" |
#include "atomicio.h" |
#include "progressmeter.h" |
#include "progressmeter.h" |
|
|
struct bwlimit bwlimit_in, bwlimit_out; |
struct bwlimit bwlimit_in, bwlimit_out; |
}; |
}; |
|
|
static char * |
static u_char * |
get_handle(struct sftp_conn *conn, u_int expected_id, u_int *len, |
get_handle(struct sftp_conn *conn, u_int expected_id, size_t *len, |
const char *errfmt, ...) __attribute__((format(printf, 4, 5))); |
const char *errfmt, ...) __attribute__((format(printf, 4, 5))); |
|
|
/* ARGSUSED */ |
/* ARGSUSED */ |
|
|
} |
} |
|
|
static void |
static void |
send_msg(struct sftp_conn *conn, Buffer *m) |
send_msg(struct sftp_conn *conn, struct sshbuf *m) |
{ |
{ |
u_char mlen[4]; |
u_char mlen[4]; |
struct iovec iov[2]; |
struct iovec iov[2]; |
|
|
if (buffer_len(m) > SFTP_MAX_MSG_LENGTH) |
if (sshbuf_len(m) > SFTP_MAX_MSG_LENGTH) |
fatal("Outbound message too long %u", buffer_len(m)); |
fatal("Outbound message too long %zu", sshbuf_len(m)); |
|
|
/* Send length first */ |
/* Send length first */ |
put_u32(mlen, buffer_len(m)); |
put_u32(mlen, sshbuf_len(m)); |
iov[0].iov_base = mlen; |
iov[0].iov_base = mlen; |
iov[0].iov_len = sizeof(mlen); |
iov[0].iov_len = sizeof(mlen); |
iov[1].iov_base = buffer_ptr(m); |
iov[1].iov_base = (u_char *)sshbuf_ptr(m); |
iov[1].iov_len = buffer_len(m); |
iov[1].iov_len = sshbuf_len(m); |
|
|
if (atomiciov6(writev, conn->fd_out, iov, 2, |
if (atomiciov6(writev, conn->fd_out, iov, 2, |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_out) != |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_out) != |
buffer_len(m) + sizeof(mlen)) |
sshbuf_len(m) + sizeof(mlen)) |
fatal("Couldn't send packet: %s", strerror(errno)); |
fatal("Couldn't send packet: %s", strerror(errno)); |
|
|
buffer_clear(m); |
sshbuf_reset(m); |
} |
} |
|
|
static void |
static void |
get_msg(struct sftp_conn *conn, Buffer *m) |
get_msg(struct sftp_conn *conn, struct sshbuf *m) |
{ |
{ |
u_int msg_len; |
u_int msg_len; |
|
u_char *p; |
|
int r; |
|
|
buffer_append_space(m, 4); |
if ((r = sshbuf_reserve(m, 4, &p)) != 0) |
if (atomicio6(read, conn->fd_in, buffer_ptr(m), 4, |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
if (atomicio6(read, conn->fd_in, p, 4, |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) != 4) { |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) != 4) { |
if (errno == EPIPE) |
if (errno == EPIPE) |
fatal("Connection closed"); |
fatal("Connection closed"); |
|
|
fatal("Couldn't read packet: %s", strerror(errno)); |
fatal("Couldn't read packet: %s", strerror(errno)); |
} |
} |
|
|
msg_len = buffer_get_int(m); |
if ((r = sshbuf_get_u32(m, &msg_len)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (msg_len > SFTP_MAX_MSG_LENGTH) |
if (msg_len > SFTP_MAX_MSG_LENGTH) |
fatal("Received message too long %u", msg_len); |
fatal("Received message too long %u", msg_len); |
|
|
buffer_append_space(m, msg_len); |
if ((r = sshbuf_reserve(m, msg_len, &p)) != 0) |
if (atomicio6(read, conn->fd_in, buffer_ptr(m), msg_len, |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
if (atomicio6(read, conn->fd_in, p, msg_len, |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) |
conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) |
!= msg_len) { |
!= msg_len) { |
if (errno == EPIPE) |
if (errno == EPIPE) |
|
|
} |
} |
|
|
static void |
static void |
send_string_request(struct sftp_conn *conn, u_int id, u_int code, char *s, |
send_string_request(struct sftp_conn *conn, u_int id, u_int code, const char *s, |
u_int len) |
u_int len) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_put_char(&msg, code); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, code)) != 0 || |
buffer_put_string(&msg, s, len); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_string(msg, s, len)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); |
debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); |
buffer_free(&msg); |
sshbuf_free(msg); |
} |
} |
|
|
static void |
static void |
send_string_attrs_request(struct sftp_conn *conn, u_int id, u_int code, |
send_string_attrs_request(struct sftp_conn *conn, u_int id, u_int code, |
char *s, u_int len, Attrib *a) |
const void *s, u_int len, Attrib *a) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_put_char(&msg, code); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, code)) != 0 || |
buffer_put_string(&msg, s, len); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
encode_attrib(&msg, a); |
(r = sshbuf_put_string(msg, s, len)) != 0 || |
send_msg(conn, &msg); |
(r = encode_attrib(msg, a)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); |
debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); |
buffer_free(&msg); |
sshbuf_free(msg); |
} |
} |
|
|
static u_int |
static u_int |
get_status(struct sftp_conn *conn, u_int expected_id) |
get_status(struct sftp_conn *conn, u_int expected_id) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, id, status; |
u_char type; |
|
u_int id, status; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
get_msg(conn, &msg); |
fatal("%s: sshbuf_new failed", __func__); |
type = buffer_get_char(&msg); |
get_msg(conn, msg); |
id = buffer_get_int(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
|
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
if (id != expected_id) |
if (id != expected_id) |
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
|
|
fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u", |
fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u", |
SSH2_FXP_STATUS, type); |
SSH2_FXP_STATUS, type); |
|
|
status = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
buffer_free(&msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
sshbuf_free(msg); |
|
|
debug3("SSH2_FXP_STATUS %u", status); |
debug3("SSH2_FXP_STATUS %u", status); |
|
|
return status; |
return status; |
} |
} |
|
|
static char * |
static u_char * |
get_handle(struct sftp_conn *conn, u_int expected_id, u_int *len, |
get_handle(struct sftp_conn *conn, u_int expected_id, size_t *len, |
const char *errfmt, ...) |
const char *errfmt, ...) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, id; |
u_int id, status; |
char *handle, errmsg[256]; |
u_char type; |
|
u_char *handle; |
|
char errmsg[256]; |
va_list args; |
va_list args; |
int status; |
int r; |
|
|
va_start(args, errfmt); |
va_start(args, errfmt); |
if (errfmt != NULL) |
if (errfmt != NULL) |
vsnprintf(errmsg, sizeof(errmsg), errfmt, args); |
vsnprintf(errmsg, sizeof(errmsg), errfmt, args); |
va_end(args); |
va_end(args); |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
get_msg(conn, &msg); |
fatal("%s: sshbuf_new failed", __func__); |
type = buffer_get_char(&msg); |
get_msg(conn, msg); |
id = buffer_get_int(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
|
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
if (id != expected_id) |
if (id != expected_id) |
fatal("%s: ID mismatch (%u != %u)", |
fatal("%s: ID mismatch (%u != %u)", |
errfmt == NULL ? __func__ : errmsg, id, expected_id); |
errfmt == NULL ? __func__ : errmsg, id, expected_id); |
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
status = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (errfmt != NULL) |
if (errfmt != NULL) |
error("%s: %s", errmsg, fx2txt(status)); |
error("%s: %s", errmsg, fx2txt(status)); |
buffer_free(&msg); |
sshbuf_free(msg); |
return(NULL); |
return(NULL); |
} else if (type != SSH2_FXP_HANDLE) |
} else if (type != SSH2_FXP_HANDLE) |
fatal("%s: Expected SSH2_FXP_HANDLE(%u) packet, got %u", |
fatal("%s: Expected SSH2_FXP_HANDLE(%u) packet, got %u", |
errfmt == NULL ? __func__ : errmsg, SSH2_FXP_HANDLE, type); |
errfmt == NULL ? __func__ : errmsg, SSH2_FXP_HANDLE, type); |
|
|
handle = buffer_get_string(&msg, len); |
if ((r = sshbuf_get_string(msg, &handle, len)) != 0) |
buffer_free(&msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
sshbuf_free(msg); |
|
|
return(handle); |
return handle; |
} |
} |
|
|
static Attrib * |
static Attrib * |
get_decode_stat(struct sftp_conn *conn, u_int expected_id, int quiet) |
get_decode_stat(struct sftp_conn *conn, u_int expected_id, int quiet) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, id; |
u_int id; |
Attrib *a; |
u_char type; |
|
int r; |
|
static Attrib a; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
get_msg(conn, &msg); |
fatal("%s: sshbuf_new failed", __func__); |
|
get_msg(conn, msg); |
|
|
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug3("Received stat reply T:%u I:%u", type, id); |
debug3("Received stat reply T:%u I:%u", type, id); |
if (id != expected_id) |
if (id != expected_id) |
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
int status = buffer_get_int(&msg); |
u_int status; |
|
|
|
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (quiet) |
if (quiet) |
debug("Couldn't stat remote file: %s", fx2txt(status)); |
debug("Couldn't stat remote file: %s", fx2txt(status)); |
else |
else |
error("Couldn't stat remote file: %s", fx2txt(status)); |
error("Couldn't stat remote file: %s", fx2txt(status)); |
buffer_free(&msg); |
sshbuf_free(msg); |
return(NULL); |
return(NULL); |
} else if (type != SSH2_FXP_ATTRS) { |
} else if (type != SSH2_FXP_ATTRS) { |
fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u", |
fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u", |
SSH2_FXP_ATTRS, type); |
SSH2_FXP_ATTRS, type); |
} |
} |
a = decode_attrib(&msg); |
if ((r = decode_attrib(msg, &a)) != 0) { |
buffer_free(&msg); |
error("%s: couldn't decode attrib: %s", __func__, ssh_err(r)); |
|
sshbuf_free(msg); |
|
return NULL; |
|
} |
|
sshbuf_free(msg); |
|
|
return(a); |
return &a; |
} |
} |
|
|
static int |
static int |
get_decode_statvfs(struct sftp_conn *conn, struct sftp_statvfs *st, |
get_decode_statvfs(struct sftp_conn *conn, struct sftp_statvfs *st, |
u_int expected_id, int quiet) |
u_int expected_id, int quiet) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, id, flag; |
u_char type; |
|
u_int id; |
|
u_int64_t flag; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
get_msg(conn, &msg); |
fatal("%s: sshbuf_new failed", __func__); |
|
get_msg(conn, msg); |
|
|
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug3("Received statvfs reply T:%u I:%u", type, id); |
debug3("Received statvfs reply T:%u I:%u", type, id); |
if (id != expected_id) |
if (id != expected_id) |
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
int status = buffer_get_int(&msg); |
u_int status; |
|
|
|
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (quiet) |
if (quiet) |
debug("Couldn't statvfs: %s", fx2txt(status)); |
debug("Couldn't statvfs: %s", fx2txt(status)); |
else |
else |
error("Couldn't statvfs: %s", fx2txt(status)); |
error("Couldn't statvfs: %s", fx2txt(status)); |
buffer_free(&msg); |
sshbuf_free(msg); |
return -1; |
return -1; |
} else if (type != SSH2_FXP_EXTENDED_REPLY) { |
} else if (type != SSH2_FXP_EXTENDED_REPLY) { |
fatal("Expected SSH2_FXP_EXTENDED_REPLY(%u) packet, got %u", |
fatal("Expected SSH2_FXP_EXTENDED_REPLY(%u) packet, got %u", |
|
|
} |
} |
|
|
memset(st, 0, sizeof(*st)); |
memset(st, 0, sizeof(*st)); |
st->f_bsize = buffer_get_int64(&msg); |
if ((r = sshbuf_get_u64(msg, &st->f_bsize)) != 0 || |
st->f_frsize = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_frsize)) != 0 || |
st->f_blocks = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_blocks)) != 0 || |
st->f_bfree = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_bfree)) != 0 || |
st->f_bavail = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_bavail)) != 0 || |
st->f_files = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_files)) != 0 || |
st->f_ffree = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_ffree)) != 0 || |
st->f_favail = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_favail)) != 0 || |
st->f_fsid = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_fsid)) != 0 || |
flag = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &flag)) != 0 || |
st->f_namemax = buffer_get_int64(&msg); |
(r = sshbuf_get_u64(msg, &st->f_namemax)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
st->f_flag = (flag & SSH2_FXE_STATVFS_ST_RDONLY) ? ST_RDONLY : 0; |
st->f_flag = (flag & SSH2_FXE_STATVFS_ST_RDONLY) ? ST_RDONLY : 0; |
st->f_flag |= (flag & SSH2_FXE_STATVFS_ST_NOSUID) ? ST_NOSUID : 0; |
st->f_flag |= (flag & SSH2_FXE_STATVFS_ST_NOSUID) ? ST_NOSUID : 0; |
|
|
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
return 0; |
return 0; |
} |
} |
|
|
do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests, |
do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests, |
u_int64_t limit_kbps) |
u_int64_t limit_kbps) |
{ |
{ |
u_int type; |
u_char type; |
Buffer msg; |
struct sshbuf *msg; |
struct sftp_conn *ret; |
struct sftp_conn *ret; |
|
int r; |
|
|
ret = xcalloc(1, sizeof(*ret)); |
ret = xcalloc(1, sizeof(*ret)); |
ret->msg_id = 1; |
ret->msg_id = 1; |
|
|
ret->exts = 0; |
ret->exts = 0; |
ret->limit_kbps = 0; |
ret->limit_kbps = 0; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_put_char(&msg, SSH2_FXP_INIT); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_int(&msg, SSH2_FILEXFER_VERSION); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_INIT)) != 0 || |
send_msg(ret, &msg); |
(r = sshbuf_put_u32(msg, SSH2_FILEXFER_VERSION)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(ret, msg); |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
|
|
get_msg(ret, &msg); |
get_msg(ret, msg); |
|
|
/* Expecting a VERSION reply */ |
/* Expecting a VERSION reply */ |
if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) { |
if ((r = sshbuf_get_u8(msg, &type)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
if (type != SSH2_FXP_VERSION) { |
error("Invalid packet back from SSH2_FXP_INIT (type %u)", |
error("Invalid packet back from SSH2_FXP_INIT (type %u)", |
type); |
type); |
buffer_free(&msg); |
sshbuf_free(msg); |
return(NULL); |
return(NULL); |
} |
} |
ret->version = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &ret->version)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug2("Remote version: %u", ret->version); |
debug2("Remote version: %u", ret->version); |
|
|
/* Check for extensions */ |
/* Check for extensions */ |
while (buffer_len(&msg) > 0) { |
while (sshbuf_len(msg) > 0) { |
char *name = buffer_get_string(&msg, NULL); |
char *name; |
char *value = buffer_get_string(&msg, NULL); |
u_char *value; |
|
size_t vlen; |
int known = 0; |
int known = 0; |
|
|
|
if ((r = sshbuf_get_cstring(msg, &name, NULL)) != 0 || |
|
(r = sshbuf_get_string(msg, &value, &vlen)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (strcmp(name, "posix-rename@openssh.com") == 0 && |
if (strcmp(name, "posix-rename@openssh.com") == 0 && |
strcmp(value, "1") == 0) { |
strcmp((char *)value, "1") == 0) { |
ret->exts |= SFTP_EXT_POSIX_RENAME; |
ret->exts |= SFTP_EXT_POSIX_RENAME; |
known = 1; |
known = 1; |
} else if (strcmp(name, "statvfs@openssh.com") == 0 && |
} else if (strcmp(name, "statvfs@openssh.com") == 0 && |
strcmp(value, "2") == 0) { |
strcmp((char *)value, "2") == 0) { |
ret->exts |= SFTP_EXT_STATVFS; |
ret->exts |= SFTP_EXT_STATVFS; |
known = 1; |
known = 1; |
} else if (strcmp(name, "fstatvfs@openssh.com") == 0 && |
} else if (strcmp(name, "fstatvfs@openssh.com") == 0 && |
strcmp(value, "2") == 0) { |
strcmp((char *)value, "2") == 0) { |
ret->exts |= SFTP_EXT_FSTATVFS; |
ret->exts |= SFTP_EXT_FSTATVFS; |
known = 1; |
known = 1; |
} else if (strcmp(name, "hardlink@openssh.com") == 0 && |
} else if (strcmp(name, "hardlink@openssh.com") == 0 && |
strcmp(value, "1") == 0) { |
strcmp((char *)value, "1") == 0) { |
ret->exts |= SFTP_EXT_HARDLINK; |
ret->exts |= SFTP_EXT_HARDLINK; |
known = 1; |
known = 1; |
} else if (strcmp(name, "fsync@openssh.com") == 0 && |
} else if (strcmp(name, "fsync@openssh.com") == 0 && |
strcmp(value, "1") == 0) { |
strcmp((char *)value, "1") == 0) { |
ret->exts |= SFTP_EXT_FSYNC; |
ret->exts |= SFTP_EXT_FSYNC; |
known = 1; |
known = 1; |
} |
} |
if (known) { |
if (known) { |
debug2("Server supports extension \"%s\" revision %s", |
debug2("Server supports extension \"%s\" revision %s", |
|
|
free(value); |
free(value); |
} |
} |
|
|
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
/* Some filexfer v.0 servers don't support large packets */ |
/* Some filexfer v.0 servers don't support large packets */ |
if (ret->version == 0) |
if (ret->version == 0) |
|
|
} |
} |
|
|
int |
int |
do_close(struct sftp_conn *conn, char *handle, u_int handle_len) |
do_close(struct sftp_conn *conn, const u_char *handle, u_int handle_len) |
{ |
{ |
u_int id, status; |
u_int id, status; |
Buffer msg; |
struct sshbuf *msg; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
id = conn->msg_id++; |
id = conn->msg_id++; |
buffer_put_char(&msg, SSH2_FXP_CLOSE); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_CLOSE)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_string(&msg, handle, handle_len); |
(r = sshbuf_put_string(msg, handle, handle_len)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message SSH2_FXP_CLOSE I:%u", id); |
debug3("Sent message SSH2_FXP_CLOSE I:%u", id); |
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't close file: %s", fx2txt(status)); |
error("Couldn't close file: %s", fx2txt(status)); |
|
|
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
return status; |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
|
|
static int |
static int |
do_lsreaddir(struct sftp_conn *conn, char *path, int print_flag, |
do_lsreaddir(struct sftp_conn *conn, const char *path, int print_flag, |
SFTP_DIRENT ***dir) |
SFTP_DIRENT ***dir) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int count, type, id, handle_len, i, expected_id, ents = 0; |
u_int count, id, i, expected_id, ents = 0; |
|
size_t handle_len; |
|
u_char type; |
char *handle; |
char *handle; |
int status = SSH2_FX_FAILURE; |
int status = SSH2_FX_FAILURE; |
|
int r; |
|
|
if (dir) |
if (dir) |
*dir = NULL; |
*dir = NULL; |
|
|
id = conn->msg_id++; |
id = conn->msg_id++; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_put_char(&msg, SSH2_FXP_OPENDIR); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_OPENDIR)) != 0 || |
buffer_put_cstring(&msg, path); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_cstring(msg, path)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
|
|
handle = get_handle(conn, id, &handle_len, |
handle = get_handle(conn, id, &handle_len, |
"remote readdir(\"%s\")", path); |
"remote readdir(\"%s\")", path); |
if (handle == NULL) { |
if (handle == NULL) { |
buffer_free(&msg); |
sshbuf_free(msg); |
return -1; |
return -1; |
} |
} |
|
|
|
|
|
|
debug3("Sending SSH2_FXP_READDIR I:%u", id); |
debug3("Sending SSH2_FXP_READDIR I:%u", id); |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
buffer_put_char(&msg, SSH2_FXP_READDIR); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_READDIR)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_string(&msg, handle, handle_len); |
(r = sshbuf_put_string(msg, handle, handle_len)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
|
|
get_msg(conn, &msg); |
get_msg(conn, msg); |
|
|
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug3("Received reply T:%u I:%u", type, id); |
debug3("Received reply T:%u I:%u", type, id); |
|
|
|
|
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
|
|
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
status = buffer_get_int(&msg); |
u_int rstatus; |
debug3("Received SSH2_FXP_STATUS %d", status); |
|
if (status == SSH2_FX_EOF) |
if ((r = sshbuf_get_u32(msg, &rstatus)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
|
debug3("Received SSH2_FXP_STATUS %d", rstatus); |
|
if (rstatus == SSH2_FX_EOF) |
break; |
break; |
error("Couldn't read directory: %s", fx2txt(status)); |
error("Couldn't read directory: %s", fx2txt(rstatus)); |
goto out; |
goto out; |
} else if (type != SSH2_FXP_NAME) |
} else if (type != SSH2_FXP_NAME) |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
SSH2_FXP_NAME, type); |
SSH2_FXP_NAME, type); |
|
|
count = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &count)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (count == 0) |
if (count == 0) |
break; |
break; |
debug3("Received %d SSH2_FXP_NAME responses", count); |
debug3("Received %d SSH2_FXP_NAME responses", count); |
for (i = 0; i < count; i++) { |
for (i = 0; i < count; i++) { |
char *filename, *longname; |
char *filename, *longname; |
Attrib *a; |
Attrib a; |
|
|
filename = buffer_get_string(&msg, NULL); |
if ((r = sshbuf_get_cstring(msg, &filename, |
longname = buffer_get_string(&msg, NULL); |
NULL)) != 0 || |
a = decode_attrib(&msg); |
(r = sshbuf_get_cstring(msg, &longname, |
|
NULL)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
|
if ((r = decode_attrib(msg, &a)) != 0) { |
|
error("%s: couldn't decode attrib: %s", |
|
__func__, ssh_err(r)); |
|
free(filename); |
|
free(longname); |
|
sshbuf_free(msg); |
|
return -1; |
|
} |
|
|
if (print_flag) |
if (print_flag) |
printf("%s\n", longname); |
printf("%s\n", longname); |
|
|
(*dir)[ents] = xcalloc(1, sizeof(***dir)); |
(*dir)[ents] = xcalloc(1, sizeof(***dir)); |
(*dir)[ents]->filename = xstrdup(filename); |
(*dir)[ents]->filename = xstrdup(filename); |
(*dir)[ents]->longname = xstrdup(longname); |
(*dir)[ents]->longname = xstrdup(longname); |
memcpy(&(*dir)[ents]->a, a, sizeof(*a)); |
memcpy(&(*dir)[ents]->a, &a, sizeof(a)); |
(*dir)[++ents] = NULL; |
(*dir)[++ents] = NULL; |
} |
} |
free(filename); |
free(filename); |
|
|
status = 0; |
status = 0; |
|
|
out: |
out: |
buffer_free(&msg); |
sshbuf_free(msg); |
do_close(conn, handle, handle_len); |
do_close(conn, handle, handle_len); |
free(handle); |
free(handle); |
|
|
|
|
} |
} |
|
|
int |
int |
do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir) |
do_readdir(struct sftp_conn *conn, const char *path, SFTP_DIRENT ***dir) |
{ |
{ |
return(do_lsreaddir(conn, path, 0, dir)); |
return(do_lsreaddir(conn, path, 0, dir)); |
} |
} |
|
|
} |
} |
|
|
int |
int |
do_rm(struct sftp_conn *conn, char *path) |
do_rm(struct sftp_conn *conn, const char *path) |
{ |
{ |
u_int status, id; |
u_int status, id; |
|
|
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't delete file: %s", fx2txt(status)); |
error("Couldn't delete file: %s", fx2txt(status)); |
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_mkdir(struct sftp_conn *conn, char *path, Attrib *a, int print_flag) |
do_mkdir(struct sftp_conn *conn, const char *path, Attrib *a, int print_flag) |
{ |
{ |
u_int status, id; |
u_int status, id; |
|
|
|
|
if (status != SSH2_FX_OK && print_flag) |
if (status != SSH2_FX_OK && print_flag) |
error("Couldn't create directory: %s", fx2txt(status)); |
error("Couldn't create directory: %s", fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_rmdir(struct sftp_conn *conn, char *path) |
do_rmdir(struct sftp_conn *conn, const char *path) |
{ |
{ |
u_int status, id; |
u_int status, id; |
|
|
|
|
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't remove directory: %s", fx2txt(status)); |
error("Couldn't remove directory: %s", fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
Attrib * |
Attrib * |
do_stat(struct sftp_conn *conn, char *path, int quiet) |
do_stat(struct sftp_conn *conn, const char *path, int quiet) |
{ |
{ |
u_int id; |
u_int id; |
|
|
|
|
} |
} |
|
|
Attrib * |
Attrib * |
do_lstat(struct sftp_conn *conn, char *path, int quiet) |
do_lstat(struct sftp_conn *conn, const char *path, int quiet) |
{ |
{ |
u_int id; |
u_int id; |
|
|
|
|
|
|
#ifdef notyet |
#ifdef notyet |
Attrib * |
Attrib * |
do_fstat(struct sftp_conn *conn, char *handle, u_int handle_len, int quiet) |
do_fstat(struct sftp_conn *conn, const u_char *handle, u_int handle_len, |
|
int quiet) |
{ |
{ |
u_int id; |
u_int id; |
|
|
|
|
#endif |
#endif |
|
|
int |
int |
do_setstat(struct sftp_conn *conn, char *path, Attrib *a) |
do_setstat(struct sftp_conn *conn, const char *path, Attrib *a) |
{ |
{ |
u_int status, id; |
u_int status, id; |
|
|
|
|
error("Couldn't setstat on \"%s\": %s", path, |
error("Couldn't setstat on \"%s\": %s", path, |
fx2txt(status)); |
fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_fsetstat(struct sftp_conn *conn, char *handle, u_int handle_len, |
do_fsetstat(struct sftp_conn *conn, const u_char *handle, u_int handle_len, |
Attrib *a) |
Attrib *a) |
{ |
{ |
u_int status, id; |
u_int status, id; |
|
|
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't fsetstat: %s", fx2txt(status)); |
error("Couldn't fsetstat: %s", fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
char * |
char * |
do_realpath(struct sftp_conn *conn, char *path) |
do_realpath(struct sftp_conn *conn, const char *path) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, expected_id, count, id; |
u_int expected_id, count, id; |
char *filename, *longname; |
char *filename, *longname; |
Attrib *a; |
Attrib a; |
|
u_char type; |
|
int r; |
|
|
expected_id = id = conn->msg_id++; |
expected_id = id = conn->msg_id++; |
send_string_request(conn, id, SSH2_FXP_REALPATH, path, |
send_string_request(conn, id, SSH2_FXP_REALPATH, path, |
strlen(path)); |
strlen(path)); |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
get_msg(conn, &msg); |
get_msg(conn, msg); |
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
if (id != expected_id) |
if (id != expected_id) |
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
|
|
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
u_int status = buffer_get_int(&msg); |
u_int status; |
|
|
|
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
error("Couldn't canonicalize: %s", fx2txt(status)); |
error("Couldn't canonicalize: %s", fx2txt(status)); |
buffer_free(&msg); |
sshbuf_free(msg); |
return NULL; |
return NULL; |
} else if (type != SSH2_FXP_NAME) |
} else if (type != SSH2_FXP_NAME) |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
SSH2_FXP_NAME, type); |
SSH2_FXP_NAME, type); |
|
|
count = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &count)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (count != 1) |
if (count != 1) |
fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count); |
fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count); |
|
|
filename = buffer_get_string(&msg, NULL); |
if ((r = sshbuf_get_cstring(msg, &filename, NULL)) != 0 || |
longname = buffer_get_string(&msg, NULL); |
(r = sshbuf_get_cstring(msg, &longname, NULL)) != 0 || |
a = decode_attrib(&msg); |
(r = decode_attrib(msg, &a)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug3("SSH_FXP_REALPATH %s -> %s size %lu", path, filename, |
debug3("SSH_FXP_REALPATH %s -> %s size %lu", path, filename, |
(unsigned long)a->size); |
(unsigned long)a.size); |
|
|
free(longname); |
free(longname); |
|
|
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
return(filename); |
return(filename); |
} |
} |
|
|
int |
int |
do_rename(struct sftp_conn *conn, char *oldpath, char *newpath, |
do_rename(struct sftp_conn *conn, const char *oldpath, const char *newpath, |
int force_legacy) |
int force_legacy) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int status, id; |
u_int status, id; |
int use_ext = (conn->exts & SFTP_EXT_POSIX_RENAME) && !force_legacy; |
int r, use_ext = (conn->exts & SFTP_EXT_POSIX_RENAME) && !force_legacy; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
/* Send rename request */ |
/* Send rename request */ |
id = conn->msg_id++; |
id = conn->msg_id++; |
if (use_ext) { |
if (use_ext) { |
buffer_put_char(&msg, SSH2_FXP_EXTENDED); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, "posix-rename@openssh.com"); |
(r = sshbuf_put_cstring(msg, |
|
"posix-rename@openssh.com")) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
} else { |
} else { |
buffer_put_char(&msg, SSH2_FXP_RENAME); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_RENAME)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
} |
} |
buffer_put_cstring(&msg, oldpath); |
if ((r = sshbuf_put_cstring(msg, oldpath)) != 0 || |
buffer_put_cstring(&msg, newpath); |
(r = sshbuf_put_cstring(msg, newpath)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message %s \"%s\" -> \"%s\"", |
debug3("Sent message %s \"%s\" -> \"%s\"", |
use_ext ? "posix-rename@openssh.com" : "SSH2_FXP_RENAME", |
use_ext ? "posix-rename@openssh.com" : |
oldpath, newpath); |
"SSH2_FXP_RENAME", oldpath, newpath); |
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, |
error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, |
newpath, fx2txt(status)); |
newpath, fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_hardlink(struct sftp_conn *conn, char *oldpath, char *newpath) |
do_hardlink(struct sftp_conn *conn, const char *oldpath, const char *newpath) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int status, id; |
u_int status, id; |
|
int r; |
|
|
if ((conn->exts & SFTP_EXT_HARDLINK) == 0) { |
if ((conn->exts & SFTP_EXT_HARDLINK) == 0) { |
error("Server does not support hardlink@openssh.com extension"); |
error("Server does not support hardlink@openssh.com extension"); |
return -1; |
return -1; |
} |
} |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
/* Send link request */ |
/* Send link request */ |
id = conn->msg_id++; |
id = conn->msg_id++; |
buffer_put_char(&msg, SSH2_FXP_EXTENDED); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, "hardlink@openssh.com"); |
(r = sshbuf_put_cstring(msg, "hardlink@openssh.com")) != 0 || |
buffer_put_cstring(&msg, oldpath); |
(r = sshbuf_put_cstring(msg, oldpath)) != 0 || |
buffer_put_cstring(&msg, newpath); |
(r = sshbuf_put_cstring(msg, newpath)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message hardlink@openssh.com \"%s\" -> \"%s\"", |
debug3("Sent message hardlink@openssh.com \"%s\" -> \"%s\"", |
oldpath, newpath); |
oldpath, newpath); |
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't link file \"%s\" to \"%s\": %s", oldpath, |
error("Couldn't link file \"%s\" to \"%s\": %s", oldpath, |
newpath, fx2txt(status)); |
newpath, fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_symlink(struct sftp_conn *conn, char *oldpath, char *newpath) |
do_symlink(struct sftp_conn *conn, const char *oldpath, const char *newpath) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int status, id; |
u_int status, id; |
|
int r; |
|
|
if (conn->version < 3) { |
if (conn->version < 3) { |
error("This server does not support the symlink operation"); |
error("This server does not support the symlink operation"); |
return(SSH2_FX_OP_UNSUPPORTED); |
return(SSH2_FX_OP_UNSUPPORTED); |
} |
} |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
/* Send symlink request */ |
/* Send symlink request */ |
id = conn->msg_id++; |
id = conn->msg_id++; |
buffer_put_char(&msg, SSH2_FXP_SYMLINK); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_SYMLINK)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, oldpath); |
(r = sshbuf_put_cstring(msg, oldpath)) != 0 || |
buffer_put_cstring(&msg, newpath); |
(r = sshbuf_put_cstring(msg, newpath)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath, |
debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath, |
newpath); |
newpath); |
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath, |
error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath, |
newpath, fx2txt(status)); |
newpath, fx2txt(status)); |
|
|
return(status); |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
int |
int |
do_fsync(struct sftp_conn *conn, char *handle, u_int handle_len) |
do_fsync(struct sftp_conn *conn, u_char *handle, u_int handle_len) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int status, id; |
u_int status, id; |
|
int r; |
|
|
/* Silently return if the extension is not supported */ |
/* Silently return if the extension is not supported */ |
if ((conn->exts & SFTP_EXT_FSYNC) == 0) |
if ((conn->exts & SFTP_EXT_FSYNC) == 0) |
return -1; |
return -1; |
|
|
buffer_init(&msg); |
|
|
|
/* Send fsync request */ |
/* Send fsync request */ |
|
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
id = conn->msg_id++; |
id = conn->msg_id++; |
|
if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED)) != 0 || |
buffer_put_char(&msg, SSH2_FXP_EXTENDED); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_cstring(msg, "fsync@openssh.com")) != 0 || |
buffer_put_cstring(&msg, "fsync@openssh.com"); |
(r = sshbuf_put_string(msg, handle, handle_len)) != 0) |
buffer_put_string(&msg, handle, handle_len); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
send_msg(conn, &msg); |
send_msg(conn, msg); |
debug3("Sent message fsync@openssh.com I:%u", id); |
debug3("Sent message fsync@openssh.com I:%u", id); |
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
status = get_status(conn, id); |
status = get_status(conn, id); |
if (status != SSH2_FX_OK) |
if (status != SSH2_FX_OK) |
|
|
|
|
#ifdef notyet |
#ifdef notyet |
char * |
char * |
do_readlink(struct sftp_conn *conn, char *path) |
do_readlink(struct sftp_conn *conn, const char *path) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int type, expected_id, count, id; |
u_int expected_id, count, id; |
char *filename, *longname; |
char *filename, *longname; |
Attrib *a; |
Attrib a; |
|
u_char type; |
|
int r; |
|
|
expected_id = id = conn->msg_id++; |
expected_id = id = conn->msg_id++; |
send_string_request(conn, id, SSH2_FXP_READLINK, path, strlen(path)); |
send_string_request(conn, id, SSH2_FXP_READLINK, path, strlen(path)); |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
get_msg(conn, &msg); |
get_msg(conn, msg); |
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
if (id != expected_id) |
if (id != expected_id) |
fatal("ID mismatch (%u != %u)", id, expected_id); |
fatal("ID mismatch (%u != %u)", id, expected_id); |
|
|
if (type == SSH2_FXP_STATUS) { |
if (type == SSH2_FXP_STATUS) { |
u_int status = buffer_get_int(&msg); |
u_int status; |
|
|
|
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
error("Couldn't readlink: %s", fx2txt(status)); |
error("Couldn't readlink: %s", fx2txt(status)); |
buffer_free(&msg); |
sshbuf_free(msg); |
return(NULL); |
return(NULL); |
} else if (type != SSH2_FXP_NAME) |
} else if (type != SSH2_FXP_NAME) |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", |
SSH2_FXP_NAME, type); |
SSH2_FXP_NAME, type); |
|
|
count = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &count)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
if (count != 1) |
if (count != 1) |
fatal("Got multiple names (%d) from SSH_FXP_READLINK", count); |
fatal("Got multiple names (%d) from SSH_FXP_READLINK", count); |
|
|
filename = buffer_get_string(&msg, NULL); |
if ((r = sshbuf_get_cstring(msg, &filename, NULL)) != 0 || |
longname = buffer_get_string(&msg, NULL); |
(r = sshbuf_get_cstring(msg, &longname, NULL)) != 0 || |
a = decode_attrib(&msg); |
(r = decode_attrib(msg, &a)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
debug3("SSH_FXP_READLINK %s -> %s", path, filename); |
debug3("SSH_FXP_READLINK %s -> %s", path, filename); |
|
|
free(longname); |
free(longname); |
|
|
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
return(filename); |
return filename; |
} |
} |
#endif |
#endif |
|
|
|
|
do_statvfs(struct sftp_conn *conn, const char *path, struct sftp_statvfs *st, |
do_statvfs(struct sftp_conn *conn, const char *path, struct sftp_statvfs *st, |
int quiet) |
int quiet) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int id; |
u_int id; |
|
int r; |
|
|
if ((conn->exts & SFTP_EXT_STATVFS) == 0) { |
if ((conn->exts & SFTP_EXT_STATVFS) == 0) { |
error("Server does not support statvfs@openssh.com extension"); |
error("Server does not support statvfs@openssh.com extension"); |
|
|
|
|
id = conn->msg_id++; |
id = conn->msg_id++; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_clear(&msg); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_char(&msg, SSH2_FXP_EXTENDED); |
sshbuf_reset(msg); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED)) != 0 || |
buffer_put_cstring(&msg, "statvfs@openssh.com"); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, path); |
(r = sshbuf_put_cstring(msg, "statvfs@openssh.com")) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_cstring(msg, path)) != 0) |
buffer_free(&msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
|
sshbuf_free(msg); |
|
|
return get_decode_statvfs(conn, st, id, quiet); |
return get_decode_statvfs(conn, st, id, quiet); |
} |
} |
|
|
#ifdef notyet |
#ifdef notyet |
int |
int |
do_fstatvfs(struct sftp_conn *conn, const char *handle, u_int handle_len, |
do_fstatvfs(struct sftp_conn *conn, const u_char *handle, u_int handle_len, |
struct sftp_statvfs *st, int quiet) |
struct sftp_statvfs *st, int quiet) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
u_int id; |
u_int id; |
|
|
if ((conn->exts & SFTP_EXT_FSTATVFS) == 0) { |
if ((conn->exts & SFTP_EXT_FSTATVFS) == 0) { |
|
|
|
|
id = conn->msg_id++; |
id = conn->msg_id++; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_clear(&msg); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_char(&msg, SSH2_FXP_EXTENDED); |
sshbuf_reset(msg); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED)) != 0 || |
buffer_put_cstring(&msg, "fstatvfs@openssh.com"); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_string(&msg, handle, handle_len); |
(r = sshbuf_put_cstring(msg, "fstatvfs@openssh.com")) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_string(msg, handle, handle_len)) != 0) |
buffer_free(&msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
|
sshbuf_free(msg); |
|
|
return get_decode_statvfs(conn, st, id, quiet); |
return get_decode_statvfs(conn, st, id, quiet); |
} |
} |
|
|
|
|
static void |
static void |
send_read_request(struct sftp_conn *conn, u_int id, u_int64_t offset, |
send_read_request(struct sftp_conn *conn, u_int id, u_int64_t offset, |
u_int len, char *handle, u_int handle_len) |
u_int len, const u_char *handle, u_int handle_len) |
{ |
{ |
Buffer msg; |
struct sshbuf *msg; |
|
int r; |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
buffer_clear(&msg); |
fatal("%s: sshbuf_new failed", __func__); |
buffer_put_char(&msg, SSH2_FXP_READ); |
sshbuf_reset(msg); |
buffer_put_int(&msg, id); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_READ)) != 0 || |
buffer_put_string(&msg, handle, handle_len); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_int64(&msg, offset); |
(r = sshbuf_put_string(msg, handle, handle_len)) != 0 || |
buffer_put_int(&msg, len); |
(r = sshbuf_put_u64(msg, offset)) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_u32(msg, len)) != 0) |
buffer_free(&msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
|
sshbuf_free(msg); |
} |
} |
|
|
int |
int |
do_download(struct sftp_conn *conn, char *remote_path, char *local_path, |
do_download(struct sftp_conn *conn, const char *remote_path, |
Attrib *a, int preserve_flag, int resume_flag, int fsync_flag) |
const char *local_path, Attrib *a, int preserve_flag, int resume_flag, |
|
int fsync_flag) |
{ |
{ |
Attrib junk; |
Attrib junk; |
Buffer msg; |
struct sshbuf *msg; |
char *handle; |
u_char *handle; |
int local_fd = -1, status = 0, write_error; |
int local_fd = -1, write_error; |
int read_error, write_errno, reordered = 0; |
int read_error, write_errno, reordered = 0, r; |
u_int64_t offset = 0, size, highwater; |
u_int64_t offset = 0, size, highwater; |
u_int handle_len, mode, type, id, buflen, num_req, max_req; |
u_int mode, id, buflen, num_req, max_req, status = SSH2_FX_OK; |
off_t progress_counter; |
off_t progress_counter; |
|
size_t handle_len; |
struct stat st; |
struct stat st; |
struct request { |
struct request { |
u_int id; |
u_int id; |
u_int len; |
size_t len; |
u_int64_t offset; |
u_int64_t offset; |
TAILQ_ENTRY(request) tq; |
TAILQ_ENTRY(request) tq; |
}; |
}; |
TAILQ_HEAD(reqhead, request) requests; |
TAILQ_HEAD(reqhead, request) requests; |
struct request *req; |
struct request *req; |
|
u_char type; |
|
|
TAILQ_INIT(&requests); |
TAILQ_INIT(&requests); |
|
|
|
|
size = 0; |
size = 0; |
|
|
buflen = conn->transfer_buflen; |
buflen = conn->transfer_buflen; |
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
|
attrib_clear(&junk); /* Send empty attributes */ |
|
|
/* Send open request */ |
/* Send open request */ |
id = conn->msg_id++; |
id = conn->msg_id++; |
buffer_put_char(&msg, SSH2_FXP_OPEN); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_OPEN)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, remote_path); |
(r = sshbuf_put_cstring(msg, remote_path)) != 0 || |
buffer_put_int(&msg, SSH2_FXF_READ); |
(r = sshbuf_put_u32(msg, SSH2_FXF_READ)) != 0 || |
attrib_clear(&junk); /* Send empty attributes */ |
(r = encode_attrib(msg, &junk)) != 0) |
encode_attrib(&msg, &junk); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
send_msg(conn, &msg); |
send_msg(conn, msg); |
debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); |
debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); |
|
|
handle = get_handle(conn, id, &handle_len, |
handle = get_handle(conn, id, &handle_len, |
"remote open(\"%s\")", remote_path); |
"remote open(\"%s\")", remote_path); |
if (handle == NULL) { |
if (handle == NULL) { |
buffer_free(&msg); |
sshbuf_free(msg); |
return(-1); |
return(-1); |
} |
} |
|
|
|
|
"local file is larger than remote", local_path); |
"local file is larger than remote", local_path); |
fail: |
fail: |
do_close(conn, handle, handle_len); |
do_close(conn, handle, handle_len); |
buffer_free(&msg); |
sshbuf_free(msg); |
free(handle); |
free(handle); |
if (local_fd != -1) |
if (local_fd != -1) |
close(local_fd); |
close(local_fd); |
|
|
start_progress_meter(remote_path, size, &progress_counter); |
start_progress_meter(remote_path, size, &progress_counter); |
|
|
while (num_req > 0 || max_req > 0) { |
while (num_req > 0 || max_req > 0) { |
char *data; |
u_char *data; |
u_int len; |
size_t len; |
|
|
/* |
/* |
* Simulate EOF on interrupt: stop sending new requests and |
* Simulate EOF on interrupt: stop sending new requests and |
|
|
req->len, handle, handle_len); |
req->len, handle, handle_len); |
} |
} |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
get_msg(conn, &msg); |
get_msg(conn, msg); |
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &id)) != 0) |
|
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
debug3("Received reply T:%u I:%u R:%d", type, id, max_req); |
debug3("Received reply T:%u I:%u R:%d", type, id, max_req); |
|
|
/* Find the request in our queue */ |
/* Find the request in our queue */ |
|
|
|
|
switch (type) { |
switch (type) { |
case SSH2_FXP_STATUS: |
case SSH2_FXP_STATUS: |
status = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
if (status != SSH2_FX_EOF) |
if (status != SSH2_FX_EOF) |
read_error = 1; |
read_error = 1; |
max_req = 0; |
max_req = 0; |
|
|
num_req--; |
num_req--; |
break; |
break; |
case SSH2_FXP_DATA: |
case SSH2_FXP_DATA: |
data = buffer_get_string(&msg, &len); |
if ((r = sshbuf_get_string(msg, &data, &len)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
debug3("Received data %llu -> %llu", |
debug3("Received data %llu -> %llu", |
(unsigned long long)req->offset, |
(unsigned long long)req->offset, |
(unsigned long long)req->offset + len - 1); |
(unsigned long long)req->offset + len - 1); |
if (len > req->len) |
if (len > req->len) |
fatal("Received more data than asked for " |
fatal("Received more data than asked for " |
"%u > %u", len, req->len); |
"%zu > %zu", len, req->len); |
if ((lseek(local_fd, req->offset, SEEK_SET) == -1 || |
if ((lseek(local_fd, req->offset, SEEK_SET) == -1 || |
atomicio(vwrite, local_fd, data, len) != len) && |
atomicio(vwrite, local_fd, data, len) != len) && |
!write_error) { |
!write_error) { |
|
|
} else if (write_error) { |
} else if (write_error) { |
error("Couldn't write to \"%s\": %s", local_path, |
error("Couldn't write to \"%s\": %s", local_path, |
strerror(write_errno)); |
strerror(write_errno)); |
status = -1; |
status = SSH2_FX_FAILURE; |
do_close(conn, handle, handle_len); |
do_close(conn, handle, handle_len); |
} else { |
} else { |
status = do_close(conn, handle, handle_len); |
if (do_close(conn, handle, handle_len) != 0 || interrupted) |
if (interrupted || status != SSH2_FX_OK) |
status = SSH2_FX_FAILURE; |
status = -1; |
else |
|
status = SSH2_FX_OK; |
/* Override umask and utimes if asked */ |
/* Override umask and utimes if asked */ |
if (preserve_flag && fchmod(local_fd, mode) == -1) |
if (preserve_flag && fchmod(local_fd, mode) == -1) |
error("Couldn't set mode on \"%s\": %s", local_path, |
error("Couldn't set mode on \"%s\": %s", local_path, |
|
|
} |
} |
} |
} |
close(local_fd); |
close(local_fd); |
buffer_free(&msg); |
sshbuf_free(msg); |
free(handle); |
free(handle); |
|
|
return(status); |
return(status); |
} |
} |
|
|
static int |
static int |
download_dir_internal(struct sftp_conn *conn, char *src, char *dst, int depth, |
download_dir_internal(struct sftp_conn *conn, const char *src, const char *dst, |
Attrib *dirattrib, int preserve_flag, int print_flag, int resume_flag, |
int depth, Attrib *dirattrib, int preserve_flag, int print_flag, |
int fsync_flag) |
int resume_flag, int fsync_flag) |
{ |
{ |
int i, ret = 0; |
int i, ret = 0; |
SFTP_DIRENT **dir_entries; |
SFTP_DIRENT **dir_entries; |
|
|
} |
} |
|
|
int |
int |
download_dir(struct sftp_conn *conn, char *src, char *dst, |
download_dir(struct sftp_conn *conn, const char *src, const char *dst, |
Attrib *dirattrib, int preserve_flag, int print_flag, |
Attrib *dirattrib, int preserve_flag, int print_flag, int resume_flag, |
int resume_flag, int fsync_flag) |
int fsync_flag) |
{ |
{ |
char *src_canon; |
char *src_canon; |
int ret; |
int ret; |
|
|
} |
} |
|
|
int |
int |
do_upload(struct sftp_conn *conn, char *local_path, char *remote_path, |
do_upload(struct sftp_conn *conn, const char *local_path, |
int preserve_flag, int resume, int fsync_flag) |
const char *remote_path, int preserve_flag, int resume, int fsync_flag) |
{ |
{ |
int local_fd; |
int r, local_fd; |
int status = SSH2_FX_OK; |
u_int status = SSH2_FX_OK; |
u_int handle_len, id, type; |
u_int id; |
|
u_char type; |
off_t offset, progress_counter; |
off_t offset, progress_counter; |
char *handle, *data; |
u_char *handle, *data; |
Buffer msg; |
struct sshbuf *msg; |
struct stat sb; |
struct stat sb; |
Attrib a, *c = NULL; |
Attrib a, *c = NULL; |
u_int32_t startid; |
u_int32_t startid; |
|
|
}; |
}; |
TAILQ_HEAD(ackhead, outstanding_ack) acks; |
TAILQ_HEAD(ackhead, outstanding_ack) acks; |
struct outstanding_ack *ack = NULL; |
struct outstanding_ack *ack = NULL; |
|
size_t handle_len; |
|
|
TAILQ_INIT(&acks); |
TAILQ_INIT(&acks); |
|
|
|
|
} |
} |
} |
} |
|
|
buffer_init(&msg); |
if ((msg = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
|
/* Send open request */ |
/* Send open request */ |
id = conn->msg_id++; |
id = conn->msg_id++; |
buffer_put_char(&msg, SSH2_FXP_OPEN); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_OPEN)) != 0 || |
buffer_put_int(&msg, id); |
(r = sshbuf_put_u32(msg, id)) != 0 || |
buffer_put_cstring(&msg, remote_path); |
(r = sshbuf_put_cstring(msg, remote_path)) != 0 || |
buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT| |
(r = sshbuf_put_u32(msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT| |
(resume ? SSH2_FXF_APPEND : SSH2_FXF_TRUNC)); |
(resume ? SSH2_FXF_APPEND : SSH2_FXF_TRUNC))) != 0 || |
encode_attrib(&msg, &a); |
(r = encode_attrib(msg, &a)) != 0) |
send_msg(conn, &msg); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); |
debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
|
|
handle = get_handle(conn, id, &handle_len, |
handle = get_handle(conn, id, &handle_len, |
"remote open(\"%s\")", remote_path); |
"remote open(\"%s\")", remote_path); |
if (handle == NULL) { |
if (handle == NULL) { |
close(local_fd); |
close(local_fd); |
buffer_free(&msg); |
sshbuf_free(msg); |
return -1; |
return -1; |
} |
} |
|
|
|
|
ack->len = len; |
ack->len = len; |
TAILQ_INSERT_TAIL(&acks, ack, tq); |
TAILQ_INSERT_TAIL(&acks, ack, tq); |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
buffer_put_char(&msg, SSH2_FXP_WRITE); |
if ((r = sshbuf_put_u8(msg, SSH2_FXP_WRITE)) != 0 || |
buffer_put_int(&msg, ack->id); |
(r = sshbuf_put_u32(msg, ack->id)) != 0 || |
buffer_put_string(&msg, handle, handle_len); |
(r = sshbuf_put_string(msg, handle, |
buffer_put_int64(&msg, offset); |
handle_len)) != 0 || |
buffer_put_string(&msg, data, len); |
(r = sshbuf_put_u64(msg, offset)) != 0 || |
send_msg(conn, &msg); |
(r = sshbuf_put_string(msg, data, len)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
|
send_msg(conn, msg); |
debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u", |
debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u", |
id, (unsigned long long)offset, len); |
id, (unsigned long long)offset, len); |
} else if (TAILQ_FIRST(&acks) == NULL) |
} else if (TAILQ_FIRST(&acks) == NULL) |
|
|
|
|
if (id == startid || len == 0 || |
if (id == startid || len == 0 || |
id - ackid >= conn->num_requests) { |
id - ackid >= conn->num_requests) { |
u_int r_id; |
u_int rid; |
|
|
buffer_clear(&msg); |
sshbuf_reset(msg); |
get_msg(conn, &msg); |
get_msg(conn, msg); |
type = buffer_get_char(&msg); |
if ((r = sshbuf_get_u8(msg, &type)) != 0 || |
r_id = buffer_get_int(&msg); |
(r = sshbuf_get_u32(msg, &rid)) != 0) |
|
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
|
|
if (type != SSH2_FXP_STATUS) |
if (type != SSH2_FXP_STATUS) |
fatal("Expected SSH2_FXP_STATUS(%d) packet, " |
fatal("Expected SSH2_FXP_STATUS(%d) packet, " |
"got %d", SSH2_FXP_STATUS, type); |
"got %d", SSH2_FXP_STATUS, type); |
|
|
status = buffer_get_int(&msg); |
if ((r = sshbuf_get_u32(msg, &status)) != 0) |
debug3("SSH2_FXP_STATUS %d", status); |
fatal("%s: buffer error: %s", |
|
__func__, ssh_err(r)); |
|
debug3("SSH2_FXP_STATUS %u", status); |
|
|
/* Find the request in our queue */ |
/* Find the request in our queue */ |
for (ack = TAILQ_FIRST(&acks); |
for (ack = TAILQ_FIRST(&acks); |
ack != NULL && ack->id != r_id; |
ack != NULL && ack->id != rid; |
ack = TAILQ_NEXT(ack, tq)) |
ack = TAILQ_NEXT(ack, tq)) |
; |
; |
if (ack == NULL) |
if (ack == NULL) |
fatal("Can't find request for ID %u", r_id); |
fatal("Can't find request for ID %u", rid); |
TAILQ_REMOVE(&acks, ack, tq); |
TAILQ_REMOVE(&acks, ack, tq); |
debug3("In write loop, ack for %u %u bytes at %lld", |
debug3("In write loop, ack for %u %u bytes at %lld", |
ack->id, ack->len, (long long)ack->offset); |
ack->id, ack->len, (long long)ack->offset); |
|
|
if (offset < 0) |
if (offset < 0) |
fatal("%s: offset < 0", __func__); |
fatal("%s: offset < 0", __func__); |
} |
} |
buffer_free(&msg); |
sshbuf_free(msg); |
|
|
if (showprogress) |
if (showprogress) |
stop_progress_meter(); |
stop_progress_meter(); |
|
|
if (status != SSH2_FX_OK) { |
if (status != SSH2_FX_OK) { |
error("Couldn't write to remote file \"%s\": %s", |
error("Couldn't write to remote file \"%s\": %s", |
remote_path, fx2txt(status)); |
remote_path, fx2txt(status)); |
status = -1; |
status = SSH2_FX_FAILURE; |
} |
} |
|
|
if (close(local_fd) == -1) { |
if (close(local_fd) == -1) { |
error("Couldn't close local file \"%s\": %s", local_path, |
error("Couldn't close local file \"%s\": %s", local_path, |
strerror(errno)); |
strerror(errno)); |
status = -1; |
status = SSH2_FX_FAILURE; |
} |
} |
|
|
/* Override umask and utimes if asked */ |
/* Override umask and utimes if asked */ |
|
|
(void)do_fsync(conn, handle, handle_len); |
(void)do_fsync(conn, handle, handle_len); |
|
|
if (do_close(conn, handle, handle_len) != SSH2_FX_OK) |
if (do_close(conn, handle, handle_len) != SSH2_FX_OK) |
status = -1; |
status = SSH2_FX_FAILURE; |
|
|
free(handle); |
free(handle); |
|
|
return status; |
return status == SSH2_FX_OK ? 0 : -1; |
} |
} |
|
|
static int |
static int |
upload_dir_internal(struct sftp_conn *conn, char *src, char *dst, int depth, |
upload_dir_internal(struct sftp_conn *conn, const char *src, const char *dst, |
int preserve_flag, int print_flag, int resume, int fsync_flag) |
int depth, int preserve_flag, int print_flag, int resume, int fsync_flag) |
{ |
{ |
int ret = 0, status; |
int ret = 0; |
|
u_int status; |
DIR *dirp; |
DIR *dirp; |
struct dirent *dp; |
struct dirent *dp; |
char *filename, *new_src, *new_dst; |
char *filename, *new_src, *new_dst; |
|
|
} |
} |
|
|
int |
int |
upload_dir(struct sftp_conn *conn, char *src, char *dst, int preserve_flag, |
upload_dir(struct sftp_conn *conn, const char *src, const char *dst, |
int print_flag, int resume, int fsync_flag) |
int preserve_flag, int print_flag, int resume, int fsync_flag) |
{ |
{ |
char *dst_canon; |
char *dst_canon; |
int ret; |
int ret; |
|
|
} |
} |
|
|
char * |
char * |
path_append(char *p1, char *p2) |
path_append(const char *p1, const char *p2) |
{ |
{ |
char *ret; |
char *ret; |
size_t len = strlen(p1) + strlen(p2) + 2; |
size_t len = strlen(p1) + strlen(p2) + 2; |