25
#include "qemu/osdep.h"
27
#include <libssh/libssh.h>
28
#include <libssh/sftp.h>
30
#include "block/block-io.h"
31
#include "block/block_int.h"
32
#include "block/qdict.h"
33
#include "qapi/error.h"
34
#include "qemu/error-report.h"
35
#include "qemu/module.h"
36
#include "qemu/option.h"
37
#include "qemu/ctype.h"
38
#include "qemu/cutils.h"
39
#include "qemu/sockets.h"
40
#include "qapi/qapi-visit-sockets.h"
41
#include "qapi/qapi-visit-block-core.h"
42
#include "qapi/qmp/qdict.h"
43
#include "qapi/qmp/qstring.h"
44
#include "qapi/qobject-input-visitor.h"
45
#include "qapi/qobject-output-visitor.h"
55
typedef struct BDRVSSHState {
63
sftp_file sftp_handle;
69
sftp_attributes attrs;
71
InetSocketAddress *inet;
74
bool unsafe_flush_warning;
85
static void ssh_state_init(BDRVSSHState *s)
87
memset(s, 0, sizeof *s);
89
qemu_co_mutex_init(&s->lock);
92
static void ssh_state_free(BDRVSSHState *s)
97
sftp_attributes_free(s->attrs);
100
sftp_close(s->sftp_handle);
106
ssh_disconnect(s->session);
107
ssh_free(s->session);
111
static void G_GNUC_PRINTF(3, 4)
112
session_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
118
msg = g_strdup_vprintf(fs, args);
126
ssh_err = ssh_get_error(s->session);
127
ssh_err_code = ssh_get_error_code(s->session);
128
error_setg(errp, "%s: %s (libssh error code: %d)",
129
msg, ssh_err, ssh_err_code);
131
error_setg(errp, "%s", msg);
136
static void G_GNUC_PRINTF(3, 4)
137
sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
143
msg = g_strdup_vprintf(fs, args);
152
ssh_err = ssh_get_error(s->session);
153
ssh_err_code = ssh_get_error_code(s->session);
155
sftp_err_code = sftp_get_error(s->sftp);
158
"%s: %s (libssh error code: %d, sftp error code: %d)",
159
msg, ssh_err, ssh_err_code, sftp_err_code);
161
error_setg(errp, "%s", msg);
166
static void sftp_error_trace(BDRVSSHState *s, const char *op)
173
ssh_err = ssh_get_error(s->session);
174
ssh_err_code = ssh_get_error_code(s->session);
176
sftp_err_code = sftp_get_error(s->sftp);
178
trace_sftp_error(op, ssh_err, ssh_err_code, sftp_err_code);
181
static int parse_uri(const char *filename, QDict *options, Error **errp)
183
g_autoptr(GUri) uri = g_uri_parse(filename, G_URI_FLAGS_NONE, NULL);
184
const char *uri_host, *uri_path, *uri_user, *uri_query;
187
g_autoptr(GError) gerror = NULL;
188
char *qp_name, *qp_value;
195
if (g_strcmp0(g_uri_get_scheme(uri), "ssh") != 0) {
196
error_setg(errp, "URI scheme must be 'ssh'");
200
uri_host = g_uri_get_host(uri);
201
if (!uri_host || g_str_equal(uri_host, "")) {
202
error_setg(errp, "missing hostname in URI");
206
uri_path = g_uri_get_path(uri);
207
if (!uri_path || g_str_equal(uri_path, "")) {
208
error_setg(errp, "missing remote path in URI");
212
uri_user = g_uri_get_user(uri);
213
if (uri_user && !g_str_equal(uri_user, "")) {
214
qdict_put_str(options, "user", uri_user);
217
qdict_put_str(options, "server.host", uri_host);
219
port = g_uri_get_port(uri);
220
port_str = g_strdup_printf("%d", port > 0 ? port : 22);
221
qdict_put_str(options, "server.port", port_str);
224
qdict_put_str(options, "path", uri_path);
226
uri_query = g_uri_get_query(uri);
228
g_uri_params_iter_init(&qp, uri_query, -1, "&", G_URI_PARAMS_NONE);
229
while (g_uri_params_iter_next(&qp, &qp_name, &qp_value, &gerror)) {
230
if (!qp_name || !qp_value || gerror) {
231
warn_report("Failed to parse SSH URI parameters '%s'",
239
if (g_str_equal(qp_name, "host_key_check")) {
240
qdict_put_str(options, "host_key_check", qp_value);
242
warn_report("Unsupported parameter '%s' in URI", qp_name);
250
static bool ssh_has_filename_options_conflict(QDict *options, Error **errp)
252
const QDictEntry *qe;
254
for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) {
255
if (!strcmp(qe->key, "host") ||
256
!strcmp(qe->key, "port") ||
257
!strcmp(qe->key, "path") ||
258
!strcmp(qe->key, "user") ||
259
!strcmp(qe->key, "host_key_check") ||
260
strstart(qe->key, "server.", NULL))
262
error_setg(errp, "Option '%s' cannot be used with a file name",
271
static void ssh_parse_filename(const char *filename, QDict *options,
274
if (ssh_has_filename_options_conflict(options, errp)) {
278
parse_uri(filename, options, errp);
281
static int check_host_key_knownhosts(BDRVSSHState *s, Error **errp)
284
enum ssh_known_hosts_e state;
287
enum ssh_keytypes_e pubkey_type;
288
unsigned char *server_hash = NULL;
289
size_t server_hash_len;
290
char *fingerprint = NULL;
292
state = ssh_session_is_known_server(s->session);
293
trace_ssh_server_status(state);
296
case SSH_KNOWN_HOSTS_OK:
298
trace_ssh_check_host_key_knownhosts();
300
case SSH_KNOWN_HOSTS_CHANGED:
302
r = ssh_get_server_publickey(s->session, &pubkey);
304
r = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_SHA256,
305
&server_hash, &server_hash_len);
306
pubkey_type = ssh_key_type(pubkey);
307
ssh_key_free(pubkey);
310
fingerprint = ssh_get_fingerprint_hash(SSH_PUBLICKEY_HASH_SHA256,
313
ssh_clean_pubkey_hash(&server_hash);
317
"host key (%s key with fingerprint %s) does not match "
318
"the one in known_hosts; this may be a possible attack",
319
ssh_key_type_to_char(pubkey_type), fingerprint);
320
ssh_string_free_char(fingerprint);
323
"host key does not match the one in known_hosts; this "
324
"may be a possible attack");
327
case SSH_KNOWN_HOSTS_OTHER:
330
"host key for this server not found, another type exists");
332
case SSH_KNOWN_HOSTS_UNKNOWN:
334
error_setg(errp, "no host key was found in known_hosts");
336
case SSH_KNOWN_HOSTS_NOT_FOUND:
338
error_setg(errp, "known_hosts file not found");
340
case SSH_KNOWN_HOSTS_ERROR:
342
error_setg(errp, "error while checking the host");
346
error_setg(errp, "error while checking for known server (%d)", state);
357
static unsigned hex2decimal(char ch)
359
if (ch >= '0' && ch <= '9') {
361
} else if (ch >= 'a' && ch <= 'f') {
362
return 10 + (ch - 'a');
363
} else if (ch >= 'A' && ch <= 'F') {
364
return 10 + (ch - 'A');
373
static int compare_fingerprint(const unsigned char *fingerprint, size_t len,
374
const char *host_key_check)
379
while (*host_key_check == ':')
381
if (!qemu_isxdigit(host_key_check[0]) ||
382
!qemu_isxdigit(host_key_check[1]))
384
c = hex2decimal(host_key_check[0]) * 16 +
385
hex2decimal(host_key_check[1]);
386
if (c - *fingerprint != 0)
387
return c - *fingerprint;
392
return *host_key_check - '\0';
395
static char *format_fingerprint(const unsigned char *fingerprint, size_t len)
397
static const char *hex = "0123456789abcdef";
398
char *ret = g_new0(char, (len * 2) + 1);
399
for (size_t i = 0; i < len; i++) {
400
ret[i * 2] = hex[((fingerprint[i] >> 4) & 0xf)];
401
ret[(i * 2) + 1] = hex[(fingerprint[i] & 0xf)];
408
check_host_key_hash(BDRVSSHState *s, const char *hash,
409
enum ssh_publickey_hash_type type, const char *typestr,
414
unsigned char *server_hash;
415
size_t server_hash_len;
418
r = ssh_get_server_publickey(s->session, &pubkey);
420
session_error_setg(errp, s, "failed to read remote host key");
424
keytype = ssh_key_type_to_char(ssh_key_type(pubkey));
426
r = ssh_get_publickey_hash(pubkey, type, &server_hash, &server_hash_len);
427
ssh_key_free(pubkey);
429
session_error_setg(errp, s,
430
"failed reading the hash of the server SSH key");
434
r = compare_fingerprint(server_hash, server_hash_len, hash);
436
g_autofree char *server_fp = format_fingerprint(server_hash,
438
error_setg(errp, "remote host %s key fingerprint '%s:%s' "
439
"does not match host_key_check '%s:%s'",
440
keytype, typestr, server_fp, typestr, hash);
441
ssh_clean_pubkey_hash(&server_hash);
444
ssh_clean_pubkey_hash(&server_hash);
449
static int check_host_key(BDRVSSHState *s, SshHostKeyCheck *hkc, Error **errp)
451
SshHostKeyCheckMode mode;
456
mode = SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS;
460
case SSH_HOST_KEY_CHECK_MODE_NONE:
462
case SSH_HOST_KEY_CHECK_MODE_HASH:
463
if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_MD5) {
464
return check_host_key_hash(s, hkc->u.hash.hash,
465
SSH_PUBLICKEY_HASH_MD5, "md5",
467
} else if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_SHA1) {
468
return check_host_key_hash(s, hkc->u.hash.hash,
469
SSH_PUBLICKEY_HASH_SHA1, "sha1",
471
} else if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_SHA256) {
472
return check_host_key_hash(s, hkc->u.hash.hash,
473
SSH_PUBLICKEY_HASH_SHA256, "sha256",
476
g_assert_not_reached();
478
case SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS:
479
return check_host_key_knownhosts(s, errp);
481
g_assert_not_reached();
487
static int authenticate(BDRVSSHState *s, Error **errp)
493
r = ssh_userauth_none(s->session, NULL);
494
if (r == SSH_AUTH_ERROR) {
496
session_error_setg(errp, s, "failed to authenticate using none "
499
} else if (r == SSH_AUTH_SUCCESS) {
505
method = ssh_userauth_list(s->session, NULL);
506
trace_ssh_auth_methods(method);
512
if (method & SSH_AUTH_METHOD_PUBLICKEY) {
513
r = ssh_userauth_publickey_auto(s->session, NULL, NULL);
514
if (r == SSH_AUTH_ERROR) {
516
session_error_setg(errp, s, "failed to authenticate using "
517
"publickey authentication");
519
} else if (r == SSH_AUTH_SUCCESS) {
527
error_setg(errp, "failed to authenticate using publickey authentication "
528
"and the identities held by your ssh-agent");
534
static QemuOptsList ssh_runtime_opts = {
536
.head = QTAILQ_HEAD_INITIALIZER(ssh_runtime_opts.head),
540
.type = QEMU_OPT_STRING,
541
.help = "Host to connect to",
545
.type = QEMU_OPT_NUMBER,
546
.help = "Port to connect to",
549
.name = "host_key_check",
550
.type = QEMU_OPT_STRING,
551
.help = "Defines how and what to check the host key against",
557
static bool ssh_process_legacy_options(QDict *output_opts,
558
QemuOpts *legacy_opts,
561
const char *host = qemu_opt_get(legacy_opts, "host");
562
const char *port = qemu_opt_get(legacy_opts, "port");
563
const char *host_key_check = qemu_opt_get(legacy_opts, "host_key_check");
566
error_setg(errp, "port may not be used without host");
571
qdict_put_str(output_opts, "server.host", host);
572
qdict_put_str(output_opts, "server.port", port ?: stringify(22));
575
if (host_key_check) {
576
if (strcmp(host_key_check, "no") == 0) {
577
qdict_put_str(output_opts, "host-key-check.mode", "none");
578
} else if (strncmp(host_key_check, "md5:", 4) == 0) {
579
qdict_put_str(output_opts, "host-key-check.mode", "hash");
580
qdict_put_str(output_opts, "host-key-check.type", "md5");
581
qdict_put_str(output_opts, "host-key-check.hash",
583
} else if (strncmp(host_key_check, "sha1:", 5) == 0) {
584
qdict_put_str(output_opts, "host-key-check.mode", "hash");
585
qdict_put_str(output_opts, "host-key-check.type", "sha1");
586
qdict_put_str(output_opts, "host-key-check.hash",
588
} else if (strncmp(host_key_check, "sha256:", 7) == 0) {
589
qdict_put_str(output_opts, "host-key-check.mode", "hash");
590
qdict_put_str(output_opts, "host-key-check.type", "sha256");
591
qdict_put_str(output_opts, "host-key-check.hash",
593
} else if (strcmp(host_key_check, "yes") == 0) {
594
qdict_put_str(output_opts, "host-key-check.mode", "known_hosts");
596
error_setg(errp, "unknown host_key_check setting (%s)",
605
static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
607
BlockdevOptionsSsh *result = NULL;
608
QemuOpts *opts = NULL;
613
opts = qemu_opts_create(&ssh_runtime_opts, NULL, 0, &error_abort);
614
if (!qemu_opts_absorb_qdict(opts, options, errp)) {
618
if (!ssh_process_legacy_options(options, opts, errp)) {
623
v = qobject_input_visitor_new_flat_confused(options, errp);
628
visit_type_BlockdevOptionsSsh(v, NULL, &result, errp);
636
while ((e = qdict_first(options))) {
637
qdict_del(options, e->key);
645
static int connect_to_ssh(BDRVSSHState *s, BlockdevOptionsSsh *opts,
646
int ssh_flags, int creat_mode, Error **errp)
649
unsigned int port = 0;
653
s->user = g_strdup(opts->user);
655
s->user = g_strdup(g_get_user_name());
657
error_setg_errno(errp, errno, "Can't get user name");
664
s->inet = opts->server;
667
if (qemu_strtoui(s->inet->port, NULL, 10, &port) < 0) {
668
error_setg(errp, "Use only numeric port value");
674
new_sock = inet_connect_saddr(s->inet, errp);
684
r = socket_set_nodelay(new_sock);
686
warn_report("can't set TCP_NODELAY for the ssh server %s: %s",
687
s->inet->host, strerror(errno));
691
s->session = ssh_new();
694
session_error_setg(errp, s, "failed to initialize libssh session");
702
ssh_set_blocking(s->session, 1);
704
r = ssh_options_set(s->session, SSH_OPTIONS_USER, s->user);
707
session_error_setg(errp, s,
708
"failed to set the user in the libssh session");
712
r = ssh_options_set(s->session, SSH_OPTIONS_HOST, s->inet->host);
715
session_error_setg(errp, s,
716
"failed to set the host in the libssh session");
721
r = ssh_options_set(s->session, SSH_OPTIONS_PORT, &port);
724
session_error_setg(errp, s,
725
"failed to set the port in the libssh session");
730
r = ssh_options_set(s->session, SSH_OPTIONS_COMPRESSION, "none");
733
session_error_setg(errp, s,
734
"failed to disable the compression in the libssh "
740
r = ssh_options_parse_config(s->session, NULL);
743
session_error_setg(errp, s, "failed to parse ~/.ssh/config");
747
r = ssh_options_set(s->session, SSH_OPTIONS_FD, &new_sock);
750
session_error_setg(errp, s,
751
"failed to set the socket in the libssh session");
759
r = ssh_connect(s->session);
762
session_error_setg(errp, s, "failed to establish SSH session");
767
ret = check_host_key(s, opts->host_key_check, errp);
773
ret = authenticate(s, errp);
779
s->sftp = sftp_new(s->session);
781
session_error_setg(errp, s, "failed to create sftp handle");
786
r = sftp_init(s->sftp);
788
sftp_error_setg(errp, s, "failed to initialize sftp handle");
794
trace_ssh_connect_to_ssh(opts->path, ssh_flags, creat_mode);
795
s->sftp_handle = sftp_open(s->sftp, opts->path, ssh_flags, creat_mode);
796
if (!s->sftp_handle) {
797
sftp_error_setg(errp, s, "failed to open remote file '%s'",
804
sftp_file_set_blocking(s->sftp_handle);
806
s->attrs = sftp_fstat(s->sftp_handle);
808
sftp_error_setg(errp, s, "failed to read file attributes");
816
sftp_attributes_free(s->attrs);
819
if (s->sftp_handle) {
820
sftp_close(s->sftp_handle);
822
s->sftp_handle = NULL;
828
ssh_disconnect(s->session);
829
ssh_free(s->session);
840
static int ssh_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
843
BDRVSSHState *s = bs->opaque;
844
BlockdevOptionsSsh *opts;
851
if (bdrv_flags & BDRV_O_RDWR) {
854
ssh_flags |= O_RDONLY;
857
opts = ssh_parse_options(options, errp);
863
ret = connect_to_ssh(s, opts, ssh_flags, 0, errp);
869
ssh_set_blocking(s->session, 0);
871
if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
872
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
875
qapi_free_BlockdevOptionsSsh(opts);
880
qapi_free_BlockdevOptionsSsh(opts);
886
static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
889
char c[1] = { '\0' };
890
int was_blocking = ssh_is_blocking(s->session);
894
assert(offset > 0 && offset > s->attrs->size);
896
ssh_set_blocking(s->session, 1);
898
sftp_seek64(s->sftp_handle, offset - 1);
899
ret = sftp_write(s->sftp_handle, c, 1);
901
ssh_set_blocking(s->session, was_blocking);
904
sftp_error_setg(errp, s, "Failed to grow file");
908
s->attrs->size = offset;
912
static QemuOptsList ssh_create_opts = {
913
.name = "ssh-create-opts",
914
.head = QTAILQ_HEAD_INITIALIZER(ssh_create_opts.head),
917
.name = BLOCK_OPT_SIZE,
918
.type = QEMU_OPT_SIZE,
919
.help = "Virtual disk size"
925
static int ssh_co_create(BlockdevCreateOptions *options, Error **errp)
927
BlockdevCreateOptionsSsh *opts = &options->u.ssh;
931
assert(options->driver == BLOCKDEV_DRIVER_SSH);
935
ret = connect_to_ssh(&s, opts->location,
936
O_RDWR | O_CREAT | O_TRUNC,
942
if (opts->size > 0) {
943
ret = ssh_grow_file(&s, opts->size, errp);
955
static int coroutine_fn ssh_co_create_opts(BlockDriver *drv,
956
const char *filename,
960
BlockdevCreateOptions *create_options;
961
BlockdevCreateOptionsSsh *ssh_opts;
963
QDict *uri_options = NULL;
965
create_options = g_new0(BlockdevCreateOptions, 1);
966
create_options->driver = BLOCKDEV_DRIVER_SSH;
967
ssh_opts = &create_options->u.ssh;
970
ssh_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
972
trace_ssh_co_create_opts(ssh_opts->size);
974
uri_options = qdict_new();
975
ret = parse_uri(filename, uri_options, errp);
980
ssh_opts->location = ssh_parse_options(uri_options, errp);
981
if (ssh_opts->location == NULL) {
986
ret = ssh_co_create(create_options, errp);
989
qobject_unref(uri_options);
990
qapi_free_BlockdevCreateOptions(create_options);
994
static void ssh_close(BlockDriverState *bs)
996
BDRVSSHState *s = bs->opaque;
1001
static int ssh_has_zero_init(BlockDriverState *bs)
1003
BDRVSSHState *s = bs->opaque;
1005
int has_zero_init = 0;
1007
if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
1011
return has_zero_init;
1014
typedef struct BDRVSSHRestart {
1015
BlockDriverState *bs;
1019
static void restart_coroutine(void *opaque)
1021
BDRVSSHRestart *restart = opaque;
1022
BlockDriverState *bs = restart->bs;
1023
BDRVSSHState *s = bs->opaque;
1024
AioContext *ctx = bdrv_get_aio_context(bs);
1026
trace_ssh_restart_coroutine(restart->co);
1027
aio_set_fd_handler(ctx, s->sock, NULL, NULL, NULL, NULL, NULL);
1029
aio_co_wake(restart->co);
1036
static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
1039
IOHandler *rd_handler = NULL, *wr_handler = NULL;
1040
BDRVSSHRestart restart = {
1042
.co = qemu_coroutine_self()
1045
r = ssh_get_poll_flags(s->session);
1047
if (r & SSH_READ_PENDING) {
1048
rd_handler = restart_coroutine;
1050
if (r & SSH_WRITE_PENDING) {
1051
wr_handler = restart_coroutine;
1054
trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
1056
aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
1057
rd_handler, wr_handler, NULL, NULL, &restart);
1058
qemu_coroutine_yield();
1059
trace_ssh_co_yield_back(s->sock);
1062
static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs,
1063
int64_t offset, size_t size,
1068
char *buf, *end_of_vec;
1071
trace_ssh_read(offset, size);
1073
trace_ssh_seek(offset);
1074
sftp_seek64(s->sftp_handle, offset);
1082
end_of_vec = i->iov_base + i->iov_len;
1084
for (got = 0; got < size; ) {
1085
size_t request_read_size;
1092
request_read_size = MIN(end_of_vec - buf, 16384);
1093
trace_ssh_read_buf(buf, end_of_vec - buf, request_read_size);
1094
r = sftp_read(s->sftp_handle, buf, request_read_size);
1095
trace_ssh_read_return(r, sftp_get_error(s->sftp));
1097
if (r == SSH_AGAIN) {
1101
if (r == SSH_EOF || (r == 0 && sftp_get_error(s->sftp) == SSH_FX_EOF)) {
1103
qemu_iovec_memset(qiov, got, 0, size - got);
1107
sftp_error_trace(s, "read");
1113
if (buf >= end_of_vec && got < size) {
1116
end_of_vec = i->iov_base + i->iov_len;
1123
static coroutine_fn int ssh_co_readv(BlockDriverState *bs,
1125
int nb_sectors, QEMUIOVector *qiov)
1127
BDRVSSHState *s = bs->opaque;
1130
qemu_co_mutex_lock(&s->lock);
1131
ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE,
1132
nb_sectors * BDRV_SECTOR_SIZE, qiov);
1133
qemu_co_mutex_unlock(&s->lock);
1138
static coroutine_fn int ssh_write(BDRVSSHState *s, BlockDriverState *bs,
1139
int64_t offset, size_t size,
1144
char *buf, *end_of_vec;
1147
trace_ssh_write(offset, size);
1149
trace_ssh_seek(offset);
1150
sftp_seek64(s->sftp_handle, offset);
1158
end_of_vec = i->iov_base + i->iov_len;
1160
for (written = 0; written < size; ) {
1161
size_t request_write_size;
1167
request_write_size = MIN(end_of_vec - buf, 131072);
1168
trace_ssh_write_buf(buf, end_of_vec - buf, request_write_size);
1169
r = sftp_write(s->sftp_handle, buf, request_write_size);
1170
trace_ssh_write_return(r, sftp_get_error(s->sftp));
1172
if (r == SSH_AGAIN) {
1177
sftp_error_trace(s, "write");
1183
if (buf >= end_of_vec && written < size) {
1186
end_of_vec = i->iov_base + i->iov_len;
1189
if (offset + written > s->attrs->size) {
1190
s->attrs->size = offset + written;
1197
static coroutine_fn int ssh_co_writev(BlockDriverState *bs,
1199
int nb_sectors, QEMUIOVector *qiov,
1202
BDRVSSHState *s = bs->opaque;
1205
qemu_co_mutex_lock(&s->lock);
1206
ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE,
1207
nb_sectors * BDRV_SECTOR_SIZE, qiov);
1208
qemu_co_mutex_unlock(&s->lock);
1213
static void unsafe_flush_warning(BDRVSSHState *s, const char *what)
1215
if (!s->unsafe_flush_warning) {
1216
warn_report("ssh server %s does not support fsync",
1219
error_report("to support fsync, you need %s", what);
1221
s->unsafe_flush_warning = true;
1225
static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs)
1231
if (!sftp_extension_supported(s->sftp, "fsync@openssh.com", "1")) {
1232
unsafe_flush_warning(s, "OpenSSH >= 6.3");
1236
r = sftp_fsync(s->sftp_handle);
1237
if (r == SSH_AGAIN) {
1242
sftp_error_trace(s, "fsync");
1249
static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1251
BDRVSSHState *s = bs->opaque;
1254
qemu_co_mutex_lock(&s->lock);
1255
ret = ssh_flush(s, bs);
1256
qemu_co_mutex_unlock(&s->lock);
1261
static int64_t coroutine_fn ssh_co_getlength(BlockDriverState *bs)
1263
BDRVSSHState *s = bs->opaque;
1267
length = (int64_t) s->attrs->size;
1268
trace_ssh_getlength(length);
1273
static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
1274
bool exact, PreallocMode prealloc,
1275
BdrvRequestFlags flags, Error **errp)
1277
BDRVSSHState *s = bs->opaque;
1279
if (prealloc != PREALLOC_MODE_OFF) {
1280
error_setg(errp, "Unsupported preallocation mode '%s'",
1281
PreallocMode_str(prealloc));
1285
if (offset < s->attrs->size) {
1286
error_setg(errp, "ssh driver does not support shrinking files");
1290
if (offset == s->attrs->size) {
1294
return ssh_grow_file(s, offset, errp);
1297
static void ssh_refresh_filename(BlockDriverState *bs)
1299
BDRVSSHState *s = bs->opaque;
1300
const char *path, *host_key_check;
1307
if (s->inet->has_ipv4 || s->inet->has_ipv6 || s->inet->has_to ||
1308
s->inet->has_numeric)
1313
path = qdict_get_try_str(bs->full_open_options, "path");
1316
host_key_check = qdict_get_try_str(bs->full_open_options, "host_key_check");
1318
ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
1319
"ssh://%s@%s:%s%s%s%s",
1320
s->user, s->inet->host, s->inet->port, path,
1321
host_key_check ? "?host_key_check=" : "",
1322
host_key_check ?: "");
1323
if (ret >= sizeof(bs->exact_filename)) {
1325
bs->exact_filename[0] = '\0';
1329
static char *ssh_bdrv_dirname(BlockDriverState *bs, Error **errp)
1331
if (qdict_haskey(bs->full_open_options, "host_key_check")) {
1337
"Cannot generate a base directory with host_key_check set");
1341
if (bs->exact_filename[0] == '\0') {
1342
error_setg(errp, "Cannot generate a base directory for this ssh node");
1346
return path_combine(bs->exact_filename, "");
1349
static const char *const ssh_strong_runtime_opts[] = {
1360
static BlockDriver bdrv_ssh = {
1361
.format_name = "ssh",
1362
.protocol_name = "ssh",
1363
.instance_size = sizeof(BDRVSSHState),
1364
.bdrv_parse_filename = ssh_parse_filename,
1365
.bdrv_open = ssh_open,
1366
.bdrv_co_create = ssh_co_create,
1367
.bdrv_co_create_opts = ssh_co_create_opts,
1368
.bdrv_close = ssh_close,
1369
.bdrv_has_zero_init = ssh_has_zero_init,
1370
.bdrv_co_readv = ssh_co_readv,
1371
.bdrv_co_writev = ssh_co_writev,
1372
.bdrv_co_getlength = ssh_co_getlength,
1373
.bdrv_co_truncate = ssh_co_truncate,
1374
.bdrv_co_flush_to_disk = ssh_co_flush,
1375
.bdrv_refresh_filename = ssh_refresh_filename,
1376
.bdrv_dirname = ssh_bdrv_dirname,
1377
.create_opts = &ssh_create_opts,
1378
.strong_runtime_opts = ssh_strong_runtime_opts,
1381
static void bdrv_ssh_init(void)
1387
fprintf(stderr, "libssh initialization failed, %d\n", r);
1391
#if TRACE_LIBSSH != 0
1392
ssh_set_log_level(TRACE_LIBSSH);
1395
bdrv_register(&bdrv_ssh);
1398
block_init(bdrv_ssh_init);