2 * Secure Shell (ssh) backend for QEMU.
4 * Copyright (C) 2013 Red Hat Inc., Richard W.M. Jones <rjones@redhat.com>
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
30 #include <libssh2_sftp.h>
32 #include "block/block_int.h"
33 #include "qemu/sockets.h"
35 #include "qapi/qmp/qint.h"
37 /* DEBUG_SSH=1 enables the DPRINTF (debugging printf) statements in
38 * this block driver code.
40 * TRACE_LIBSSH2=<bitmask> enables tracing in libssh2 itself. Note
41 * that this requires that libssh2 was specially compiled with the
42 * `./configure --enable-debug' option, so most likely you will have
43 * to compile it yourself. The meaning of <bitmask> is described
44 * here: http://www.libssh2.org/libssh2_trace.html
47 #define TRACE_LIBSSH2 0 /* or try: LIBSSH2_TRACE_SFTP */
49 #define DPRINTF(fmt, ...) \
52 fprintf(stderr, "ssh: %-15s " fmt "\n", \
53 __func__, ##__VA_ARGS__); \
57 typedef struct BDRVSSHState
{
62 int sock
; /* socket */
63 LIBSSH2_SESSION
*session
; /* ssh session */
64 LIBSSH2_SFTP
*sftp
; /* sftp session */
65 LIBSSH2_SFTP_HANDLE
*sftp_handle
; /* sftp remote file handle */
67 /* See ssh_seek() function below. */
71 /* File attributes at open. We try to keep the .filesize field
72 * updated if it changes (eg by writing at the end of the file).
74 LIBSSH2_SFTP_ATTRIBUTES attrs
;
76 /* Used to warn if 'flush' is not supported. */
78 bool unsafe_flush_warning
;
81 static void ssh_state_init(BDRVSSHState
*s
)
83 memset(s
, 0, sizeof *s
);
86 qemu_co_mutex_init(&s
->lock
);
89 static void ssh_state_free(BDRVSSHState
*s
)
93 libssh2_sftp_close(s
->sftp_handle
);
96 libssh2_sftp_shutdown(s
->sftp
);
99 libssh2_session_disconnect(s
->session
,
100 "from qemu ssh client: "
101 "user closed the connection");
102 libssh2_session_free(s
->session
);
109 /* Wrappers around error_report which make sure to dump as much
110 * information from libssh2 as possible.
112 static void GCC_FMT_ATTR(2, 3)
113 session_error_report(BDRVSSHState
*s
, const char *fs
, ...)
118 error_vprintf(fs
, args
);
124 /* This is not an errno. See <libssh2.h>. */
125 ssh_err_code
= libssh2_session_last_error(s
->session
,
127 error_printf(": %s (libssh2 error code: %d)", ssh_err
, ssh_err_code
);
134 static void GCC_FMT_ATTR(2, 3)
135 sftp_error_report(BDRVSSHState
*s
, const char *fs
, ...)
140 error_vprintf(fs
, args
);
145 unsigned long sftp_err_code
;
147 /* This is not an errno. See <libssh2.h>. */
148 ssh_err_code
= libssh2_session_last_error(s
->session
,
150 /* See <libssh2_sftp.h>. */
151 sftp_err_code
= libssh2_sftp_last_error((s
)->sftp
);
153 error_printf(": %s (libssh2 error code: %d, sftp error code: %lu)",
154 ssh_err
, ssh_err_code
, sftp_err_code
);
161 static int parse_uri(const char *filename
, QDict
*options
, Error
**errp
)
164 QueryParams
*qp
= NULL
;
167 uri
= uri_parse(filename
);
172 if (strcmp(uri
->scheme
, "ssh") != 0) {
173 error_setg(errp
, "URI scheme must be 'ssh'");
177 if (!uri
->server
|| strcmp(uri
->server
, "") == 0) {
178 error_setg(errp
, "missing hostname in URI");
182 if (!uri
->path
|| strcmp(uri
->path
, "") == 0) {
183 error_setg(errp
, "missing remote path in URI");
187 qp
= query_params_parse(uri
->query
);
189 error_setg(errp
, "could not parse query parameters");
193 if(uri
->user
&& strcmp(uri
->user
, "") != 0) {
194 qdict_put(options
, "user", qstring_from_str(uri
->user
));
197 qdict_put(options
, "host", qstring_from_str(uri
->server
));
200 qdict_put(options
, "port", qint_from_int(uri
->port
));
203 qdict_put(options
, "path", qstring_from_str(uri
->path
));
205 /* Pick out any query parameters that we understand, and ignore
208 for (i
= 0; i
< qp
->n
; ++i
) {
209 if (strcmp(qp
->p
[i
].name
, "host_key_check") == 0) {
210 qdict_put(options
, "host_key_check",
211 qstring_from_str(qp
->p
[i
].value
));
215 query_params_free(qp
);
221 query_params_free(qp
);
229 static void ssh_parse_filename(const char *filename
, QDict
*options
,
232 if (qdict_haskey(options
, "user") ||
233 qdict_haskey(options
, "host") ||
234 qdict_haskey(options
, "port") ||
235 qdict_haskey(options
, "path") ||
236 qdict_haskey(options
, "host_key_check")) {
237 error_setg(errp
, "user, host, port, path, host_key_check cannot be used at the same time as a file option");
241 parse_uri(filename
, options
, errp
);
244 static int check_host_key_knownhosts(BDRVSSHState
*s
,
245 const char *host
, int port
)
248 char *knh_file
= NULL
;
249 LIBSSH2_KNOWNHOSTS
*knh
= NULL
;
250 struct libssh2_knownhost
*found
;
256 hostkey
= libssh2_session_hostkey(s
->session
, &len
, &type
);
259 session_error_report(s
, "failed to read remote host key");
263 knh
= libssh2_knownhost_init(s
->session
);
266 session_error_report(s
, "failed to initialize known hosts support");
270 home
= getenv("HOME");
272 knh_file
= g_strdup_printf("%s/.ssh/known_hosts", home
);
274 knh_file
= g_strdup_printf("/root/.ssh/known_hosts");
277 /* Read all known hosts from OpenSSH-style known_hosts file. */
278 libssh2_knownhost_readfile(knh
, knh_file
, LIBSSH2_KNOWNHOST_FILE_OPENSSH
);
280 r
= libssh2_knownhost_checkp(knh
, host
, port
, hostkey
, len
,
281 LIBSSH2_KNOWNHOST_TYPE_PLAIN
|
282 LIBSSH2_KNOWNHOST_KEYENC_RAW
,
285 case LIBSSH2_KNOWNHOST_CHECK_MATCH
:
287 DPRINTF("host key OK: %s", found
->key
);
289 case LIBSSH2_KNOWNHOST_CHECK_MISMATCH
:
291 session_error_report(s
, "host key does not match the one in known_hosts (found key %s)",
294 case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND
:
296 session_error_report(s
, "no host key was found in known_hosts");
298 case LIBSSH2_KNOWNHOST_CHECK_FAILURE
:
300 session_error_report(s
, "failure matching the host key with known_hosts");
304 session_error_report(s
, "unknown error matching the host key with known_hosts (%d)",
309 /* known_hosts checking successful. */
314 libssh2_knownhost_free(knh
);
320 static unsigned hex2decimal(char ch
)
322 if (ch
>= '0' && ch
<= '9') {
324 } else if (ch
>= 'a' && ch
<= 'f') {
325 return 10 + (ch
- 'a');
326 } else if (ch
>= 'A' && ch
<= 'F') {
327 return 10 + (ch
- 'A');
333 /* Compare the binary fingerprint (hash of host key) with the
334 * host_key_check parameter.
336 static int compare_fingerprint(const unsigned char *fingerprint
, size_t len
,
337 const char *host_key_check
)
342 while (*host_key_check
== ':')
344 if (!qemu_isxdigit(host_key_check
[0]) ||
345 !qemu_isxdigit(host_key_check
[1]))
347 c
= hex2decimal(host_key_check
[0]) * 16 +
348 hex2decimal(host_key_check
[1]);
349 if (c
- *fingerprint
!= 0)
350 return c
- *fingerprint
;
355 return *host_key_check
- '\0';
359 check_host_key_hash(BDRVSSHState
*s
, const char *hash
,
360 int hash_type
, size_t fingerprint_len
)
362 const char *fingerprint
;
364 fingerprint
= libssh2_hostkey_hash(s
->session
, hash_type
);
366 session_error_report(s
, "failed to read remote host key");
370 if(compare_fingerprint((unsigned char *) fingerprint
, fingerprint_len
,
372 error_report("remote host key does not match host_key_check '%s'",
380 static int check_host_key(BDRVSSHState
*s
, const char *host
, int port
,
381 const char *host_key_check
)
383 /* host_key_check=no */
384 if (strcmp(host_key_check
, "no") == 0) {
388 /* host_key_check=md5:xx:yy:zz:... */
389 if (strncmp(host_key_check
, "md5:", 4) == 0) {
390 return check_host_key_hash(s
, &host_key_check
[4],
391 LIBSSH2_HOSTKEY_HASH_MD5
, 16);
394 /* host_key_check=sha1:xx:yy:zz:... */
395 if (strncmp(host_key_check
, "sha1:", 5) == 0) {
396 return check_host_key_hash(s
, &host_key_check
[5],
397 LIBSSH2_HOSTKEY_HASH_SHA1
, 20);
400 /* host_key_check=yes */
401 if (strcmp(host_key_check
, "yes") == 0) {
402 return check_host_key_knownhosts(s
, host
, port
);
405 error_report("unknown host_key_check setting (%s)", host_key_check
);
409 static int authenticate(BDRVSSHState
*s
, const char *user
)
412 const char *userauthlist
;
413 LIBSSH2_AGENT
*agent
= NULL
;
414 struct libssh2_agent_publickey
*identity
;
415 struct libssh2_agent_publickey
*prev_identity
= NULL
;
417 userauthlist
= libssh2_userauth_list(s
->session
, user
, strlen(user
));
418 if (strstr(userauthlist
, "publickey") == NULL
) {
420 error_report("remote server does not support \"publickey\" authentication");
424 /* Connect to ssh-agent and try each identity in turn. */
425 agent
= libssh2_agent_init(s
->session
);
428 session_error_report(s
, "failed to initialize ssh-agent support");
431 if (libssh2_agent_connect(agent
)) {
433 session_error_report(s
, "failed to connect to ssh-agent");
436 if (libssh2_agent_list_identities(agent
)) {
438 session_error_report(s
, "failed requesting identities from ssh-agent");
443 r
= libssh2_agent_get_identity(agent
, &identity
, prev_identity
);
444 if (r
== 1) { /* end of list */
449 session_error_report(s
, "failed to obtain identity from ssh-agent");
452 r
= libssh2_agent_userauth(agent
, user
, identity
);
458 /* Failed to authenticate with this identity, try the next one. */
459 prev_identity
= identity
;
463 error_report("failed to authenticate using publickey authentication "
464 "and the identities held by your ssh-agent");
468 /* Note: libssh2 implementation implicitly calls
469 * libssh2_agent_disconnect if necessary.
471 libssh2_agent_free(agent
);
477 static int connect_to_ssh(BDRVSSHState
*s
, QDict
*options
,
478 int ssh_flags
, int creat_mode
)
482 const char *host
, *user
, *path
, *host_key_check
;
485 host
= qdict_get_str(options
, "host");
487 if (qdict_haskey(options
, "port")) {
488 port
= qdict_get_int(options
, "port");
493 path
= qdict_get_str(options
, "path");
495 if (qdict_haskey(options
, "user")) {
496 user
= qdict_get_str(options
, "user");
498 user
= g_get_user_name();
505 if (qdict_haskey(options
, "host_key_check")) {
506 host_key_check
= qdict_get_str(options
, "host_key_check");
508 host_key_check
= "yes";
511 /* Construct the host:port name for inet_connect. */
513 s
->hostport
= g_strdup_printf("%s:%d", host
, port
);
515 /* Open the socket and connect. */
516 s
->sock
= inet_connect(s
->hostport
, &err
);
519 qerror_report_err(err
);
524 /* Create SSH session. */
525 s
->session
= libssh2_session_init();
528 session_error_report(s
, "failed to initialize libssh2 session");
532 #if TRACE_LIBSSH2 != 0
533 libssh2_trace(s
->session
, TRACE_LIBSSH2
);
536 r
= libssh2_session_handshake(s
->session
, s
->sock
);
539 session_error_report(s
, "failed to establish SSH session");
543 /* Check the remote host's key against known_hosts. */
544 ret
= check_host_key(s
, host
, port
, host_key_check
);
550 ret
= authenticate(s
, user
);
556 s
->sftp
= libssh2_sftp_init(s
->session
);
558 session_error_report(s
, "failed to initialize sftp handle");
563 /* Open the remote file. */
564 DPRINTF("opening file %s flags=0x%x creat_mode=0%o",
565 path
, ssh_flags
, creat_mode
);
566 s
->sftp_handle
= libssh2_sftp_open(s
->sftp
, path
, ssh_flags
, creat_mode
);
567 if (!s
->sftp_handle
) {
568 session_error_report(s
, "failed to open remote file '%s'", path
);
573 r
= libssh2_sftp_fstat(s
->sftp_handle
, &s
->attrs
);
575 sftp_error_report(s
, "failed to read file attributes");
579 /* Delete the options we've used; any not deleted will cause the
580 * block layer to give an error about unused options.
582 qdict_del(options
, "host");
583 qdict_del(options
, "port");
584 qdict_del(options
, "user");
585 qdict_del(options
, "path");
586 qdict_del(options
, "host_key_check");
591 if (s
->sftp_handle
) {
592 libssh2_sftp_close(s
->sftp_handle
);
594 s
->sftp_handle
= NULL
;
596 libssh2_sftp_shutdown(s
->sftp
);
600 libssh2_session_disconnect(s
->session
,
601 "from qemu ssh client: "
602 "error opening connection");
603 libssh2_session_free(s
->session
);
610 static int ssh_file_open(BlockDriverState
*bs
, QDict
*options
, int bdrv_flags
,
613 BDRVSSHState
*s
= bs
->opaque
;
619 ssh_flags
= LIBSSH2_FXF_READ
;
620 if (bdrv_flags
& BDRV_O_RDWR
) {
621 ssh_flags
|= LIBSSH2_FXF_WRITE
;
625 ret
= connect_to_ssh(s
, options
, ssh_flags
, 0);
630 /* Go non-blocking. */
631 libssh2_session_set_blocking(s
->session
, 0);
644 static QEMUOptionParameter ssh_create_options
[] = {
646 .name
= BLOCK_OPT_SIZE
,
648 .help
= "Virtual disk size"
653 static int ssh_create(const char *filename
, QEMUOptionParameter
*options
,
657 Error
*local_err
= NULL
;
658 int64_t total_size
= 0;
659 QDict
*uri_options
= NULL
;
662 char c
[1] = { '\0' };
666 /* Get desired file size. */
667 while (options
&& options
->name
) {
668 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
669 total_size
= options
->value
.n
;
673 DPRINTF("total_size=%" PRIi64
, total_size
);
675 uri_options
= qdict_new();
676 r
= parse_uri(filename
, uri_options
, &local_err
);
678 qerror_report_err(local_err
);
679 error_free(local_err
);
684 r
= connect_to_ssh(&s
, uri_options
,
685 LIBSSH2_FXF_READ
|LIBSSH2_FXF_WRITE
|
686 LIBSSH2_FXF_CREAT
|LIBSSH2_FXF_TRUNC
, 0644);
692 if (total_size
> 0) {
693 libssh2_sftp_seek64(s
.sftp_handle
, total_size
-1);
694 r2
= libssh2_sftp_write(s
.sftp_handle
, c
, 1);
696 sftp_error_report(&s
, "truncate failed");
700 s
.attrs
.filesize
= total_size
;
707 if (uri_options
!= NULL
) {
708 QDECREF(uri_options
);
713 static void ssh_close(BlockDriverState
*bs
)
715 BDRVSSHState
*s
= bs
->opaque
;
720 static int ssh_has_zero_init(BlockDriverState
*bs
)
722 BDRVSSHState
*s
= bs
->opaque
;
723 /* Assume false, unless we can positively prove it's true. */
724 int has_zero_init
= 0;
726 if (s
->attrs
.flags
& LIBSSH2_SFTP_ATTR_PERMISSIONS
) {
727 if (s
->attrs
.permissions
& LIBSSH2_SFTP_S_IFREG
) {
732 return has_zero_init
;
735 static void restart_coroutine(void *opaque
)
737 Coroutine
*co
= opaque
;
739 DPRINTF("co=%p", co
);
741 qemu_coroutine_enter(co
, NULL
);
744 static coroutine_fn
void set_fd_handler(BDRVSSHState
*s
)
747 IOHandler
*rd_handler
= NULL
, *wr_handler
= NULL
;
748 Coroutine
*co
= qemu_coroutine_self();
750 r
= libssh2_session_block_directions(s
->session
);
752 if (r
& LIBSSH2_SESSION_BLOCK_INBOUND
) {
753 rd_handler
= restart_coroutine
;
755 if (r
& LIBSSH2_SESSION_BLOCK_OUTBOUND
) {
756 wr_handler
= restart_coroutine
;
759 DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s
->sock
,
760 rd_handler
, wr_handler
);
762 qemu_aio_set_fd_handler(s
->sock
, rd_handler
, wr_handler
, co
);
765 static coroutine_fn
void clear_fd_handler(BDRVSSHState
*s
)
767 DPRINTF("s->sock=%d", s
->sock
);
768 qemu_aio_set_fd_handler(s
->sock
, NULL
, NULL
, NULL
);
771 /* A non-blocking call returned EAGAIN, so yield, ensuring the
772 * handlers are set up so that we'll be rescheduled when there is an
773 * interesting event on the socket.
775 static coroutine_fn
void co_yield(BDRVSSHState
*s
)
778 qemu_coroutine_yield();
782 /* SFTP has a function `libssh2_sftp_seek64' which seeks to a position
783 * in the remote file. Notice that it just updates a field in the
784 * sftp_handle structure, so there is no network traffic and it cannot
787 * However, `libssh2_sftp_seek64' does have a catastrophic effect on
788 * performance since it causes the handle to throw away all in-flight
789 * reads and buffered readahead data. Therefore this function tries
790 * to be intelligent about when to call the underlying libssh2 function.
792 #define SSH_SEEK_WRITE 0
793 #define SSH_SEEK_READ 1
794 #define SSH_SEEK_FORCE 2
796 static void ssh_seek(BDRVSSHState
*s
, int64_t offset
, int flags
)
798 bool op_read
= (flags
& SSH_SEEK_READ
) != 0;
799 bool force
= (flags
& SSH_SEEK_FORCE
) != 0;
801 if (force
|| op_read
!= s
->offset_op_read
|| offset
!= s
->offset
) {
802 DPRINTF("seeking to offset=%" PRIi64
, offset
);
803 libssh2_sftp_seek64(s
->sftp_handle
, offset
);
805 s
->offset_op_read
= op_read
;
809 static coroutine_fn
int ssh_read(BDRVSSHState
*s
,
810 int64_t offset
, size_t size
,
815 char *buf
, *end_of_vec
;
818 DPRINTF("offset=%" PRIi64
" size=%zu", offset
, size
);
820 ssh_seek(s
, offset
, SSH_SEEK_READ
);
822 /* This keeps track of the current iovec element ('i'), where we
823 * will write to next ('buf'), and the end of the current iovec
828 end_of_vec
= i
->iov_base
+ i
->iov_len
;
830 /* libssh2 has a hard-coded limit of 2000 bytes per request,
831 * although it will also do readahead behind our backs. Therefore
832 * we may have to do repeated reads here until we have read 'size'
835 for (got
= 0; got
< size
; ) {
837 DPRINTF("sftp_read buf=%p size=%zu", buf
, end_of_vec
- buf
);
838 r
= libssh2_sftp_read(s
->sftp_handle
, buf
, end_of_vec
- buf
);
839 DPRINTF("sftp_read returned %zd", r
);
841 if (r
== LIBSSH2_ERROR_EAGAIN
|| r
== LIBSSH2_ERROR_TIMEOUT
) {
846 sftp_error_report(s
, "read failed");
851 /* EOF: Short read so pad the buffer with zeroes and return it. */
852 qemu_iovec_memset(qiov
, got
, 0, size
- got
);
859 if (buf
>= end_of_vec
&& got
< size
) {
862 end_of_vec
= i
->iov_base
+ i
->iov_len
;
869 static coroutine_fn
int ssh_co_readv(BlockDriverState
*bs
,
871 int nb_sectors
, QEMUIOVector
*qiov
)
873 BDRVSSHState
*s
= bs
->opaque
;
876 qemu_co_mutex_lock(&s
->lock
);
877 ret
= ssh_read(s
, sector_num
* BDRV_SECTOR_SIZE
,
878 nb_sectors
* BDRV_SECTOR_SIZE
, qiov
);
879 qemu_co_mutex_unlock(&s
->lock
);
884 static int ssh_write(BDRVSSHState
*s
,
885 int64_t offset
, size_t size
,
890 char *buf
, *end_of_vec
;
893 DPRINTF("offset=%" PRIi64
" size=%zu", offset
, size
);
895 ssh_seek(s
, offset
, SSH_SEEK_WRITE
);
897 /* This keeps track of the current iovec element ('i'), where we
898 * will read from next ('buf'), and the end of the current iovec
903 end_of_vec
= i
->iov_base
+ i
->iov_len
;
905 for (written
= 0; written
< size
; ) {
907 DPRINTF("sftp_write buf=%p size=%zu", buf
, end_of_vec
- buf
);
908 r
= libssh2_sftp_write(s
->sftp_handle
, buf
, end_of_vec
- buf
);
909 DPRINTF("sftp_write returned %zd", r
);
911 if (r
== LIBSSH2_ERROR_EAGAIN
|| r
== LIBSSH2_ERROR_TIMEOUT
) {
916 sftp_error_report(s
, "write failed");
920 /* The libssh2 API is very unclear about this. A comment in
921 * the code says "nothing was acked, and no EAGAIN was
922 * received!" which apparently means that no data got sent
923 * out, and the underlying channel didn't return any EAGAIN
924 * indication. I think this is a bug in either libssh2 or
925 * OpenSSH (server-side). In any case, forcing a seek (to
926 * discard libssh2 internal buffers), and then trying again
930 ssh_seek(s
, offset
+ written
, SSH_SEEK_WRITE
|SSH_SEEK_FORCE
);
938 if (buf
>= end_of_vec
&& written
< size
) {
941 end_of_vec
= i
->iov_base
+ i
->iov_len
;
944 if (offset
+ written
> s
->attrs
.filesize
)
945 s
->attrs
.filesize
= offset
+ written
;
951 static coroutine_fn
int ssh_co_writev(BlockDriverState
*bs
,
953 int nb_sectors
, QEMUIOVector
*qiov
)
955 BDRVSSHState
*s
= bs
->opaque
;
958 qemu_co_mutex_lock(&s
->lock
);
959 ret
= ssh_write(s
, sector_num
* BDRV_SECTOR_SIZE
,
960 nb_sectors
* BDRV_SECTOR_SIZE
, qiov
);
961 qemu_co_mutex_unlock(&s
->lock
);
966 static void unsafe_flush_warning(BDRVSSHState
*s
, const char *what
)
968 if (!s
->unsafe_flush_warning
) {
969 error_report("warning: ssh server %s does not support fsync",
972 error_report("to support fsync, you need %s", what
);
974 s
->unsafe_flush_warning
= true;
978 #ifdef HAS_LIBSSH2_SFTP_FSYNC
980 static coroutine_fn
int ssh_flush(BDRVSSHState
*s
)
986 r
= libssh2_sftp_fsync(s
->sftp_handle
);
987 if (r
== LIBSSH2_ERROR_EAGAIN
|| r
== LIBSSH2_ERROR_TIMEOUT
) {
991 if (r
== LIBSSH2_ERROR_SFTP_PROTOCOL
&&
992 libssh2_sftp_last_error(s
->sftp
) == LIBSSH2_FX_OP_UNSUPPORTED
) {
993 unsafe_flush_warning(s
, "OpenSSH >= 6.3");
997 sftp_error_report(s
, "fsync failed");
1004 static coroutine_fn
int ssh_co_flush(BlockDriverState
*bs
)
1006 BDRVSSHState
*s
= bs
->opaque
;
1009 qemu_co_mutex_lock(&s
->lock
);
1011 qemu_co_mutex_unlock(&s
->lock
);
1016 #else /* !HAS_LIBSSH2_SFTP_FSYNC */
1018 static coroutine_fn
int ssh_co_flush(BlockDriverState
*bs
)
1020 BDRVSSHState
*s
= bs
->opaque
;
1022 unsafe_flush_warning(s
, "libssh2 >= 1.4.4");
1026 #endif /* !HAS_LIBSSH2_SFTP_FSYNC */
1028 static int64_t ssh_getlength(BlockDriverState
*bs
)
1030 BDRVSSHState
*s
= bs
->opaque
;
1033 /* Note we cannot make a libssh2 call here. */
1034 length
= (int64_t) s
->attrs
.filesize
;
1035 DPRINTF("length=%" PRIi64
, length
);
1040 static BlockDriver bdrv_ssh
= {
1041 .format_name
= "ssh",
1042 .protocol_name
= "ssh",
1043 .instance_size
= sizeof(BDRVSSHState
),
1044 .bdrv_parse_filename
= ssh_parse_filename
,
1045 .bdrv_file_open
= ssh_file_open
,
1046 .bdrv_create
= ssh_create
,
1047 .bdrv_close
= ssh_close
,
1048 .bdrv_has_zero_init
= ssh_has_zero_init
,
1049 .bdrv_co_readv
= ssh_co_readv
,
1050 .bdrv_co_writev
= ssh_co_writev
,
1051 .bdrv_getlength
= ssh_getlength
,
1052 .bdrv_co_flush_to_disk
= ssh_co_flush
,
1053 .create_options
= ssh_create_options
,
1056 static void bdrv_ssh_init(void)
1060 r
= libssh2_init(0);
1062 fprintf(stderr
, "libssh2 initialization failed, %d\n", r
);
1066 bdrv_register(&bdrv_ssh
);
1069 block_init(bdrv_ssh_init
);