1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26
27#include <libssh2.h>
28#include <libssh2_sftp.h>
29
30#include "block/block_int.h"
31#include "block/qdict.h"
32#include "qapi/error.h"
33#include "qemu/error-report.h"
34#include "qemu/option.h"
35#include "qemu/cutils.h"
36#include "qemu/sockets.h"
37#include "qemu/uri.h"
38#include "qapi/qapi-visit-sockets.h"
39#include "qapi/qapi-visit-block-core.h"
40#include "qapi/qmp/qdict.h"
41#include "qapi/qmp/qstring.h"
42#include "qapi/qobject-input-visitor.h"
43#include "qapi/qobject-output-visitor.h"
44#include "trace.h"
45
46
47
48
49
50
51
52
53#define TRACE_LIBSSH2 0
54
55typedef struct BDRVSSHState {
56
57 CoMutex lock;
58
59
60 int sock;
61 LIBSSH2_SESSION *session;
62 LIBSSH2_SFTP *sftp;
63 LIBSSH2_SFTP_HANDLE *sftp_handle;
64
65
66 int64_t offset;
67 bool offset_op_read;
68
69
70
71
72 LIBSSH2_SFTP_ATTRIBUTES attrs;
73
74 InetSocketAddress *inet;
75
76
77 bool unsafe_flush_warning;
78} BDRVSSHState;
79
80static void ssh_state_init(BDRVSSHState *s)
81{
82 memset(s, 0, sizeof *s);
83 s->sock = -1;
84 s->offset = -1;
85 qemu_co_mutex_init(&s->lock);
86}
87
88static void ssh_state_free(BDRVSSHState *s)
89{
90 if (s->sftp_handle) {
91 libssh2_sftp_close(s->sftp_handle);
92 }
93 if (s->sftp) {
94 libssh2_sftp_shutdown(s->sftp);
95 }
96 if (s->session) {
97 libssh2_session_disconnect(s->session,
98 "from qemu ssh client: "
99 "user closed the connection");
100 libssh2_session_free(s->session);
101 }
102 if (s->sock >= 0) {
103 close(s->sock);
104 }
105}
106
107static void GCC_FMT_ATTR(3, 4)
108session_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
109{
110 va_list args;
111 char *msg;
112
113 va_start(args, fs);
114 msg = g_strdup_vprintf(fs, args);
115 va_end(args);
116
117 if (s->session) {
118 char *ssh_err;
119 int ssh_err_code;
120
121
122 ssh_err_code = libssh2_session_last_error(s->session,
123 &ssh_err, NULL, 0);
124 error_setg(errp, "%s: %s (libssh2 error code: %d)",
125 msg, ssh_err, ssh_err_code);
126 } else {
127 error_setg(errp, "%s", msg);
128 }
129 g_free(msg);
130}
131
132static void GCC_FMT_ATTR(3, 4)
133sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
134{
135 va_list args;
136 char *msg;
137
138 va_start(args, fs);
139 msg = g_strdup_vprintf(fs, args);
140 va_end(args);
141
142 if (s->sftp) {
143 char *ssh_err;
144 int ssh_err_code;
145 unsigned long sftp_err_code;
146
147
148 ssh_err_code = libssh2_session_last_error(s->session,
149 &ssh_err, NULL, 0);
150
151 sftp_err_code = libssh2_sftp_last_error((s)->sftp);
152
153 error_setg(errp,
154 "%s: %s (libssh2 error code: %d, sftp error code: %lu)",
155 msg, ssh_err, ssh_err_code, sftp_err_code);
156 } else {
157 error_setg(errp, "%s", msg);
158 }
159 g_free(msg);
160}
161
162static void GCC_FMT_ATTR(2, 3)
163sftp_error_report(BDRVSSHState *s, const char *fs, ...)
164{
165 va_list args;
166
167 va_start(args, fs);
168 error_vprintf(fs, args);
169
170 if ((s)->sftp) {
171 char *ssh_err;
172 int ssh_err_code;
173 unsigned long sftp_err_code;
174
175
176 ssh_err_code = libssh2_session_last_error(s->session,
177 &ssh_err, NULL, 0);
178
179 sftp_err_code = libssh2_sftp_last_error((s)->sftp);
180
181 error_printf(": %s (libssh2 error code: %d, sftp error code: %lu)",
182 ssh_err, ssh_err_code, sftp_err_code);
183 }
184
185 va_end(args);
186 error_printf("\n");
187}
188
189static int parse_uri(const char *filename, QDict *options, Error **errp)
190{
191 URI *uri = NULL;
192 QueryParams *qp;
193 char *port_str;
194 int i;
195
196 uri = uri_parse(filename);
197 if (!uri) {
198 return -EINVAL;
199 }
200
201 if (g_strcmp0(uri->scheme, "ssh") != 0) {
202 error_setg(errp, "URI scheme must be 'ssh'");
203 goto err;
204 }
205
206 if (!uri->server || strcmp(uri->server, "") == 0) {
207 error_setg(errp, "missing hostname in URI");
208 goto err;
209 }
210
211 if (!uri->path || strcmp(uri->path, "") == 0) {
212 error_setg(errp, "missing remote path in URI");
213 goto err;
214 }
215
216 qp = query_params_parse(uri->query);
217 if (!qp) {
218 error_setg(errp, "could not parse query parameters");
219 goto err;
220 }
221
222 if(uri->user && strcmp(uri->user, "") != 0) {
223 qdict_put_str(options, "user", uri->user);
224 }
225
226 qdict_put_str(options, "server.host", uri->server);
227
228 port_str = g_strdup_printf("%d", uri->port ?: 22);
229 qdict_put_str(options, "server.port", port_str);
230 g_free(port_str);
231
232 qdict_put_str(options, "path", uri->path);
233
234
235
236
237 for (i = 0; i < qp->n; ++i) {
238 if (strcmp(qp->p[i].name, "host_key_check") == 0) {
239 qdict_put_str(options, "host_key_check", qp->p[i].value);
240 }
241 }
242
243 query_params_free(qp);
244 uri_free(uri);
245 return 0;
246
247 err:
248 if (uri) {
249 uri_free(uri);
250 }
251 return -EINVAL;
252}
253
254static bool ssh_has_filename_options_conflict(QDict *options, Error **errp)
255{
256 const QDictEntry *qe;
257
258 for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) {
259 if (!strcmp(qe->key, "host") ||
260 !strcmp(qe->key, "port") ||
261 !strcmp(qe->key, "path") ||
262 !strcmp(qe->key, "user") ||
263 !strcmp(qe->key, "host_key_check") ||
264 strstart(qe->key, "server.", NULL))
265 {
266 error_setg(errp, "Option '%s' cannot be used with a file name",
267 qe->key);
268 return true;
269 }
270 }
271
272 return false;
273}
274
275static void ssh_parse_filename(const char *filename, QDict *options,
276 Error **errp)
277{
278 if (ssh_has_filename_options_conflict(options, errp)) {
279 return;
280 }
281
282 parse_uri(filename, options, errp);
283}
284
285static int check_host_key_knownhosts(BDRVSSHState *s,
286 const char *host, int port, Error **errp)
287{
288 const char *home;
289 char *knh_file = NULL;
290 LIBSSH2_KNOWNHOSTS *knh = NULL;
291 struct libssh2_knownhost *found;
292 int ret, r;
293 const char *hostkey;
294 size_t len;
295 int type;
296
297 hostkey = libssh2_session_hostkey(s->session, &len, &type);
298 if (!hostkey) {
299 ret = -EINVAL;
300 session_error_setg(errp, s, "failed to read remote host key");
301 goto out;
302 }
303
304 knh = libssh2_knownhost_init(s->session);
305 if (!knh) {
306 ret = -EINVAL;
307 session_error_setg(errp, s,
308 "failed to initialize known hosts support");
309 goto out;
310 }
311
312 home = getenv("HOME");
313 if (home) {
314 knh_file = g_strdup_printf("%s/.ssh/known_hosts", home);
315 } else {
316 knh_file = g_strdup_printf("/root/.ssh/known_hosts");
317 }
318
319
320 libssh2_knownhost_readfile(knh, knh_file, LIBSSH2_KNOWNHOST_FILE_OPENSSH);
321
322 r = libssh2_knownhost_checkp(knh, host, port, hostkey, len,
323 LIBSSH2_KNOWNHOST_TYPE_PLAIN|
324 LIBSSH2_KNOWNHOST_KEYENC_RAW,
325 &found);
326 switch (r) {
327 case LIBSSH2_KNOWNHOST_CHECK_MATCH:
328
329 trace_ssh_check_host_key_knownhosts(found->key);
330 break;
331 case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
332 ret = -EINVAL;
333 session_error_setg(errp, s,
334 "host key does not match the one in known_hosts"
335 " (found key %s)", found->key);
336 goto out;
337 case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
338 ret = -EINVAL;
339 session_error_setg(errp, s, "no host key was found in known_hosts");
340 goto out;
341 case LIBSSH2_KNOWNHOST_CHECK_FAILURE:
342 ret = -EINVAL;
343 session_error_setg(errp, s,
344 "failure matching the host key with known_hosts");
345 goto out;
346 default:
347 ret = -EINVAL;
348 session_error_setg(errp, s, "unknown error matching the host key"
349 " with known_hosts (%d)", r);
350 goto out;
351 }
352
353
354 ret = 0;
355
356 out:
357 if (knh != NULL) {
358 libssh2_knownhost_free(knh);
359 }
360 g_free(knh_file);
361 return ret;
362}
363
364static unsigned hex2decimal(char ch)
365{
366 if (ch >= '0' && ch <= '9') {
367 return (ch - '0');
368 } else if (ch >= 'a' && ch <= 'f') {
369 return 10 + (ch - 'a');
370 } else if (ch >= 'A' && ch <= 'F') {
371 return 10 + (ch - 'A');
372 }
373
374 return -1;
375}
376
377
378
379
380static int compare_fingerprint(const unsigned char *fingerprint, size_t len,
381 const char *host_key_check)
382{
383 unsigned c;
384
385 while (len > 0) {
386 while (*host_key_check == ':')
387 host_key_check++;
388 if (!qemu_isxdigit(host_key_check[0]) ||
389 !qemu_isxdigit(host_key_check[1]))
390 return 1;
391 c = hex2decimal(host_key_check[0]) * 16 +
392 hex2decimal(host_key_check[1]);
393 if (c - *fingerprint != 0)
394 return c - *fingerprint;
395 fingerprint++;
396 len--;
397 host_key_check += 2;
398 }
399 return *host_key_check - '\0';
400}
401
402static int
403check_host_key_hash(BDRVSSHState *s, const char *hash,
404 int hash_type, size_t fingerprint_len, Error **errp)
405{
406 const char *fingerprint;
407
408 fingerprint = libssh2_hostkey_hash(s->session, hash_type);
409 if (!fingerprint) {
410 session_error_setg(errp, s, "failed to read remote host key");
411 return -EINVAL;
412 }
413
414 if(compare_fingerprint((unsigned char *) fingerprint, fingerprint_len,
415 hash) != 0) {
416 error_setg(errp, "remote host key does not match host_key_check '%s'",
417 hash);
418 return -EPERM;
419 }
420
421 return 0;
422}
423
424static int check_host_key(BDRVSSHState *s, const char *host, int port,
425 SshHostKeyCheck *hkc, Error **errp)
426{
427 SshHostKeyCheckMode mode;
428
429 if (hkc) {
430 mode = hkc->mode;
431 } else {
432 mode = SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS;
433 }
434
435 switch (mode) {
436 case SSH_HOST_KEY_CHECK_MODE_NONE:
437 return 0;
438 case SSH_HOST_KEY_CHECK_MODE_HASH:
439 if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_MD5) {
440 return check_host_key_hash(s, hkc->u.hash.hash,
441 LIBSSH2_HOSTKEY_HASH_MD5, 16, errp);
442 } else if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_SHA1) {
443 return check_host_key_hash(s, hkc->u.hash.hash,
444 LIBSSH2_HOSTKEY_HASH_SHA1, 20, errp);
445 }
446 g_assert_not_reached();
447 break;
448 case SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS:
449 return check_host_key_knownhosts(s, host, port, errp);
450 default:
451 g_assert_not_reached();
452 }
453
454 return -EINVAL;
455}
456
457static int authenticate(BDRVSSHState *s, const char *user, Error **errp)
458{
459 int r, ret;
460 const char *userauthlist;
461 LIBSSH2_AGENT *agent = NULL;
462 struct libssh2_agent_publickey *identity;
463 struct libssh2_agent_publickey *prev_identity = NULL;
464
465 userauthlist = libssh2_userauth_list(s->session, user, strlen(user));
466 if (strstr(userauthlist, "publickey") == NULL) {
467 ret = -EPERM;
468 error_setg(errp,
469 "remote server does not support \"publickey\" authentication");
470 goto out;
471 }
472
473
474 agent = libssh2_agent_init(s->session);
475 if (!agent) {
476 ret = -EINVAL;
477 session_error_setg(errp, s, "failed to initialize ssh-agent support");
478 goto out;
479 }
480 if (libssh2_agent_connect(agent)) {
481 ret = -ECONNREFUSED;
482 session_error_setg(errp, s, "failed to connect to ssh-agent");
483 goto out;
484 }
485 if (libssh2_agent_list_identities(agent)) {
486 ret = -EINVAL;
487 session_error_setg(errp, s,
488 "failed requesting identities from ssh-agent");
489 goto out;
490 }
491
492 for(;;) {
493 r = libssh2_agent_get_identity(agent, &identity, prev_identity);
494 if (r == 1) {
495 break;
496 }
497 if (r < 0) {
498 ret = -EINVAL;
499 session_error_setg(errp, s,
500 "failed to obtain identity from ssh-agent");
501 goto out;
502 }
503 r = libssh2_agent_userauth(agent, user, identity);
504 if (r == 0) {
505
506 ret = 0;
507 goto out;
508 }
509
510 prev_identity = identity;
511 }
512
513 ret = -EPERM;
514 error_setg(errp, "failed to authenticate using publickey authentication "
515 "and the identities held by your ssh-agent");
516
517 out:
518 if (agent != NULL) {
519
520
521
522 libssh2_agent_free(agent);
523 }
524
525 return ret;
526}
527
528static QemuOptsList ssh_runtime_opts = {
529 .name = "ssh",
530 .head = QTAILQ_HEAD_INITIALIZER(ssh_runtime_opts.head),
531 .desc = {
532 {
533 .name = "host",
534 .type = QEMU_OPT_STRING,
535 .help = "Host to connect to",
536 },
537 {
538 .name = "port",
539 .type = QEMU_OPT_NUMBER,
540 .help = "Port to connect to",
541 },
542 {
543 .name = "host_key_check",
544 .type = QEMU_OPT_STRING,
545 .help = "Defines how and what to check the host key against",
546 },
547 { }
548 },
549};
550
551static bool ssh_process_legacy_options(QDict *output_opts,
552 QemuOpts *legacy_opts,
553 Error **errp)
554{
555 const char *host = qemu_opt_get(legacy_opts, "host");
556 const char *port = qemu_opt_get(legacy_opts, "port");
557 const char *host_key_check = qemu_opt_get(legacy_opts, "host_key_check");
558
559 if (!host && port) {
560 error_setg(errp, "port may not be used without host");
561 return false;
562 }
563
564 if (host) {
565 qdict_put_str(output_opts, "server.host", host);
566 qdict_put_str(output_opts, "server.port", port ?: stringify(22));
567 }
568
569 if (host_key_check) {
570 if (strcmp(host_key_check, "no") == 0) {
571 qdict_put_str(output_opts, "host-key-check.mode", "none");
572 } else if (strncmp(host_key_check, "md5:", 4) == 0) {
573 qdict_put_str(output_opts, "host-key-check.mode", "hash");
574 qdict_put_str(output_opts, "host-key-check.type", "md5");
575 qdict_put_str(output_opts, "host-key-check.hash",
576 &host_key_check[4]);
577 } else if (strncmp(host_key_check, "sha1:", 5) == 0) {
578 qdict_put_str(output_opts, "host-key-check.mode", "hash");
579 qdict_put_str(output_opts, "host-key-check.type", "sha1");
580 qdict_put_str(output_opts, "host-key-check.hash",
581 &host_key_check[5]);
582 } else if (strcmp(host_key_check, "yes") == 0) {
583 qdict_put_str(output_opts, "host-key-check.mode", "known_hosts");
584 } else {
585 error_setg(errp, "unknown host_key_check setting (%s)",
586 host_key_check);
587 return false;
588 }
589 }
590
591 return true;
592}
593
594static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
595{
596 BlockdevOptionsSsh *result = NULL;
597 QemuOpts *opts = NULL;
598 Error *local_err = NULL;
599 const QDictEntry *e;
600 Visitor *v;
601
602
603 opts = qemu_opts_create(&ssh_runtime_opts, NULL, 0, &error_abort);
604 qemu_opts_absorb_qdict(opts, options, &local_err);
605 if (local_err) {
606 error_propagate(errp, local_err);
607 goto fail;
608 }
609
610 if (!ssh_process_legacy_options(options, opts, errp)) {
611 goto fail;
612 }
613
614
615 v = qobject_input_visitor_new_flat_confused(options, errp);
616 if (!v) {
617 goto fail;
618 }
619
620 visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
621 visit_free(v);
622
623 if (local_err) {
624 error_propagate(errp, local_err);
625 goto fail;
626 }
627
628
629
630 while ((e = qdict_first(options))) {
631 qdict_del(options, e->key);
632 }
633
634fail:
635 qemu_opts_del(opts);
636 return result;
637}
638
639static int connect_to_ssh(BDRVSSHState *s, BlockdevOptionsSsh *opts,
640 int ssh_flags, int creat_mode, Error **errp)
641{
642 int r, ret;
643 const char *user;
644 long port = 0;
645
646 if (opts->has_user) {
647 user = opts->user;
648 } else {
649 user = g_get_user_name();
650 if (!user) {
651 error_setg_errno(errp, errno, "Can't get user name");
652 ret = -errno;
653 goto err;
654 }
655 }
656
657
658 s->inet = opts->server;
659 opts->server = NULL;
660
661 if (qemu_strtol(s->inet->port, NULL, 10, &port) < 0) {
662 error_setg(errp, "Use only numeric port value");
663 ret = -EINVAL;
664 goto err;
665 }
666
667
668 s->sock = inet_connect_saddr(s->inet, errp);
669 if (s->sock < 0) {
670 ret = -EIO;
671 goto err;
672 }
673
674
675 s->session = libssh2_session_init();
676 if (!s->session) {
677 ret = -EINVAL;
678 session_error_setg(errp, s, "failed to initialize libssh2 session");
679 goto err;
680 }
681
682#if TRACE_LIBSSH2 != 0
683 libssh2_trace(s->session, TRACE_LIBSSH2);
684#endif
685
686 r = libssh2_session_handshake(s->session, s->sock);
687 if (r != 0) {
688 ret = -EINVAL;
689 session_error_setg(errp, s, "failed to establish SSH session");
690 goto err;
691 }
692
693
694 ret = check_host_key(s, s->inet->host, port, opts->host_key_check, errp);
695 if (ret < 0) {
696 goto err;
697 }
698
699
700 ret = authenticate(s, user, errp);
701 if (ret < 0) {
702 goto err;
703 }
704
705
706 s->sftp = libssh2_sftp_init(s->session);
707 if (!s->sftp) {
708 session_error_setg(errp, s, "failed to initialize sftp handle");
709 ret = -EINVAL;
710 goto err;
711 }
712
713
714 trace_ssh_connect_to_ssh(opts->path, ssh_flags, creat_mode);
715 s->sftp_handle = libssh2_sftp_open(s->sftp, opts->path, ssh_flags,
716 creat_mode);
717 if (!s->sftp_handle) {
718 session_error_setg(errp, s, "failed to open remote file '%s'",
719 opts->path);
720 ret = -EINVAL;
721 goto err;
722 }
723
724 r = libssh2_sftp_fstat(s->sftp_handle, &s->attrs);
725 if (r < 0) {
726 sftp_error_setg(errp, s, "failed to read file attributes");
727 return -EINVAL;
728 }
729
730 return 0;
731
732 err:
733 if (s->sftp_handle) {
734 libssh2_sftp_close(s->sftp_handle);
735 }
736 s->sftp_handle = NULL;
737 if (s->sftp) {
738 libssh2_sftp_shutdown(s->sftp);
739 }
740 s->sftp = NULL;
741 if (s->session) {
742 libssh2_session_disconnect(s->session,
743 "from qemu ssh client: "
744 "error opening connection");
745 libssh2_session_free(s->session);
746 }
747 s->session = NULL;
748
749 return ret;
750}
751
752static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
753 Error **errp)
754{
755 BDRVSSHState *s = bs->opaque;
756 BlockdevOptionsSsh *opts;
757 int ret;
758 int ssh_flags;
759
760 ssh_state_init(s);
761
762 ssh_flags = LIBSSH2_FXF_READ;
763 if (bdrv_flags & BDRV_O_RDWR) {
764 ssh_flags |= LIBSSH2_FXF_WRITE;
765 }
766
767 opts = ssh_parse_options(options, errp);
768 if (opts == NULL) {
769 return -EINVAL;
770 }
771
772
773 ret = connect_to_ssh(s, opts, ssh_flags, 0, errp);
774 if (ret < 0) {
775 goto err;
776 }
777
778
779 libssh2_session_set_blocking(s->session, 0);
780
781 qapi_free_BlockdevOptionsSsh(opts);
782
783 return 0;
784
785 err:
786 if (s->sock >= 0) {
787 close(s->sock);
788 }
789 s->sock = -1;
790
791 qapi_free_BlockdevOptionsSsh(opts);
792
793 return ret;
794}
795
796
797static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
798{
799 ssize_t ret;
800 char c[1] = { '\0' };
801 int was_blocking = libssh2_session_get_blocking(s->session);
802
803
804
805 assert(offset > 0 && offset > s->attrs.filesize);
806
807 libssh2_session_set_blocking(s->session, 1);
808
809 libssh2_sftp_seek64(s->sftp_handle, offset - 1);
810 ret = libssh2_sftp_write(s->sftp_handle, c, 1);
811
812 libssh2_session_set_blocking(s->session, was_blocking);
813
814 if (ret < 0) {
815 sftp_error_setg(errp, s, "Failed to grow file");
816 return -EIO;
817 }
818
819 s->attrs.filesize = offset;
820 return 0;
821}
822
823static QemuOptsList ssh_create_opts = {
824 .name = "ssh-create-opts",
825 .head = QTAILQ_HEAD_INITIALIZER(ssh_create_opts.head),
826 .desc = {
827 {
828 .name = BLOCK_OPT_SIZE,
829 .type = QEMU_OPT_SIZE,
830 .help = "Virtual disk size"
831 },
832 { }
833 }
834};
835
836static int ssh_co_create(BlockdevCreateOptions *options, Error **errp)
837{
838 BlockdevCreateOptionsSsh *opts = &options->u.ssh;
839 BDRVSSHState s;
840 int ret;
841
842 assert(options->driver == BLOCKDEV_DRIVER_SSH);
843
844 ssh_state_init(&s);
845
846 ret = connect_to_ssh(&s, opts->location,
847 LIBSSH2_FXF_READ|LIBSSH2_FXF_WRITE|
848 LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC,
849 0644, errp);
850 if (ret < 0) {
851 goto fail;
852 }
853
854 if (opts->size > 0) {
855 ret = ssh_grow_file(&s, opts->size, errp);
856 if (ret < 0) {
857 goto fail;
858 }
859 }
860
861 ret = 0;
862fail:
863 ssh_state_free(&s);
864 return ret;
865}
866
867static int coroutine_fn ssh_co_create_opts(const char *filename, QemuOpts *opts,
868 Error **errp)
869{
870 BlockdevCreateOptions *create_options;
871 BlockdevCreateOptionsSsh *ssh_opts;
872 int ret;
873 QDict *uri_options = NULL;
874
875 create_options = g_new0(BlockdevCreateOptions, 1);
876 create_options->driver = BLOCKDEV_DRIVER_SSH;
877 ssh_opts = &create_options->u.ssh;
878
879
880 ssh_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
881 BDRV_SECTOR_SIZE);
882 trace_ssh_co_create_opts(ssh_opts->size);
883
884 uri_options = qdict_new();
885 ret = parse_uri(filename, uri_options, errp);
886 if (ret < 0) {
887 goto out;
888 }
889
890 ssh_opts->location = ssh_parse_options(uri_options, errp);
891 if (ssh_opts->location == NULL) {
892 ret = -EINVAL;
893 goto out;
894 }
895
896 ret = ssh_co_create(create_options, errp);
897
898 out:
899 qobject_unref(uri_options);
900 qapi_free_BlockdevCreateOptions(create_options);
901 return ret;
902}
903
904static void ssh_close(BlockDriverState *bs)
905{
906 BDRVSSHState *s = bs->opaque;
907
908 ssh_state_free(s);
909}
910
911static int ssh_has_zero_init(BlockDriverState *bs)
912{
913 BDRVSSHState *s = bs->opaque;
914
915 int has_zero_init = 0;
916
917 if (s->attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
918 if (s->attrs.permissions & LIBSSH2_SFTP_S_IFREG) {
919 has_zero_init = 1;
920 }
921 }
922
923 return has_zero_init;
924}
925
926typedef struct BDRVSSHRestart {
927 BlockDriverState *bs;
928 Coroutine *co;
929} BDRVSSHRestart;
930
931static void restart_coroutine(void *opaque)
932{
933 BDRVSSHRestart *restart = opaque;
934 BlockDriverState *bs = restart->bs;
935 BDRVSSHState *s = bs->opaque;
936 AioContext *ctx = bdrv_get_aio_context(bs);
937
938 trace_ssh_restart_coroutine(restart->co);
939 aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL);
940
941 aio_co_wake(restart->co);
942}
943
944
945
946
947
948static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
949{
950 int r;
951 IOHandler *rd_handler = NULL, *wr_handler = NULL;
952 BDRVSSHRestart restart = {
953 .bs = bs,
954 .co = qemu_coroutine_self()
955 };
956
957 r = libssh2_session_block_directions(s->session);
958
959 if (r & LIBSSH2_SESSION_BLOCK_INBOUND) {
960 rd_handler = restart_coroutine;
961 }
962 if (r & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
963 wr_handler = restart_coroutine;
964 }
965
966 trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
967
968 aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
969 false, rd_handler, wr_handler, NULL, &restart);
970 qemu_coroutine_yield();
971 trace_ssh_co_yield_back(s->sock);
972}
973
974
975
976
977
978
979
980
981
982
983
984#define SSH_SEEK_WRITE 0
985#define SSH_SEEK_READ 1
986#define SSH_SEEK_FORCE 2
987
988static void ssh_seek(BDRVSSHState *s, int64_t offset, int flags)
989{
990 bool op_read = (flags & SSH_SEEK_READ) != 0;
991 bool force = (flags & SSH_SEEK_FORCE) != 0;
992
993 if (force || op_read != s->offset_op_read || offset != s->offset) {
994 trace_ssh_seek(offset);
995 libssh2_sftp_seek64(s->sftp_handle, offset);
996 s->offset = offset;
997 s->offset_op_read = op_read;
998 }
999}
1000
1001static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs,
1002 int64_t offset, size_t size,
1003 QEMUIOVector *qiov)
1004{
1005 ssize_t r;
1006 size_t got;
1007 char *buf, *end_of_vec;
1008 struct iovec *i;
1009
1010 trace_ssh_read(offset, size);
1011
1012 ssh_seek(s, offset, SSH_SEEK_READ);
1013
1014
1015
1016
1017
1018 i = &qiov->iov[0];
1019 buf = i->iov_base;
1020 end_of_vec = i->iov_base + i->iov_len;
1021
1022
1023
1024
1025
1026
1027 for (got = 0; got < size; ) {
1028 again:
1029 trace_ssh_read_buf(buf, end_of_vec - buf);
1030 r = libssh2_sftp_read(s->sftp_handle, buf, end_of_vec - buf);
1031 trace_ssh_read_return(r);
1032
1033 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) {
1034 co_yield(s, bs);
1035 goto again;
1036 }
1037 if (r < 0) {
1038 sftp_error_report(s, "read failed");
1039 s->offset = -1;
1040 return -EIO;
1041 }
1042 if (r == 0) {
1043
1044 qemu_iovec_memset(qiov, got, 0, size - got);
1045 return 0;
1046 }
1047
1048 got += r;
1049 buf += r;
1050 s->offset += r;
1051 if (buf >= end_of_vec && got < size) {
1052 i++;
1053 buf = i->iov_base;
1054 end_of_vec = i->iov_base + i->iov_len;
1055 }
1056 }
1057
1058 return 0;
1059}
1060
1061static coroutine_fn int ssh_co_readv(BlockDriverState *bs,
1062 int64_t sector_num,
1063 int nb_sectors, QEMUIOVector *qiov)
1064{
1065 BDRVSSHState *s = bs->opaque;
1066 int ret;
1067
1068 qemu_co_mutex_lock(&s->lock);
1069 ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE,
1070 nb_sectors * BDRV_SECTOR_SIZE, qiov);
1071 qemu_co_mutex_unlock(&s->lock);
1072
1073 return ret;
1074}
1075
1076static int ssh_write(BDRVSSHState *s, BlockDriverState *bs,
1077 int64_t offset, size_t size,
1078 QEMUIOVector *qiov)
1079{
1080 ssize_t r;
1081 size_t written;
1082 char *buf, *end_of_vec;
1083 struct iovec *i;
1084
1085 trace_ssh_write(offset, size);
1086
1087 ssh_seek(s, offset, SSH_SEEK_WRITE);
1088
1089
1090
1091
1092
1093 i = &qiov->iov[0];
1094 buf = i->iov_base;
1095 end_of_vec = i->iov_base + i->iov_len;
1096
1097 for (written = 0; written < size; ) {
1098 again:
1099 trace_ssh_write_buf(buf, end_of_vec - buf);
1100 r = libssh2_sftp_write(s->sftp_handle, buf, end_of_vec - buf);
1101 trace_ssh_write_return(r);
1102
1103 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) {
1104 co_yield(s, bs);
1105 goto again;
1106 }
1107 if (r < 0) {
1108 sftp_error_report(s, "write failed");
1109 s->offset = -1;
1110 return -EIO;
1111 }
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121 if (r == 0) {
1122 ssh_seek(s, offset + written, SSH_SEEK_WRITE|SSH_SEEK_FORCE);
1123 co_yield(s, bs);
1124 goto again;
1125 }
1126
1127 written += r;
1128 buf += r;
1129 s->offset += r;
1130 if (buf >= end_of_vec && written < size) {
1131 i++;
1132 buf = i->iov_base;
1133 end_of_vec = i->iov_base + i->iov_len;
1134 }
1135
1136 if (offset + written > s->attrs.filesize)
1137 s->attrs.filesize = offset + written;
1138 }
1139
1140 return 0;
1141}
1142
1143static coroutine_fn int ssh_co_writev(BlockDriverState *bs,
1144 int64_t sector_num,
1145 int nb_sectors, QEMUIOVector *qiov,
1146 int flags)
1147{
1148 BDRVSSHState *s = bs->opaque;
1149 int ret;
1150
1151 assert(!flags);
1152 qemu_co_mutex_lock(&s->lock);
1153 ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE,
1154 nb_sectors * BDRV_SECTOR_SIZE, qiov);
1155 qemu_co_mutex_unlock(&s->lock);
1156
1157 return ret;
1158}
1159
1160static void unsafe_flush_warning(BDRVSSHState *s, const char *what)
1161{
1162 if (!s->unsafe_flush_warning) {
1163 warn_report("ssh server %s does not support fsync",
1164 s->inet->host);
1165 if (what) {
1166 error_report("to support fsync, you need %s", what);
1167 }
1168 s->unsafe_flush_warning = true;
1169 }
1170}
1171
1172#ifdef HAS_LIBSSH2_SFTP_FSYNC
1173
1174static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs)
1175{
1176 int r;
1177
1178 trace_ssh_flush();
1179 again:
1180 r = libssh2_sftp_fsync(s->sftp_handle);
1181 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) {
1182 co_yield(s, bs);
1183 goto again;
1184 }
1185 if (r == LIBSSH2_ERROR_SFTP_PROTOCOL &&
1186 libssh2_sftp_last_error(s->sftp) == LIBSSH2_FX_OP_UNSUPPORTED) {
1187 unsafe_flush_warning(s, "OpenSSH >= 6.3");
1188 return 0;
1189 }
1190 if (r < 0) {
1191 sftp_error_report(s, "fsync failed");
1192 return -EIO;
1193 }
1194
1195 return 0;
1196}
1197
1198static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1199{
1200 BDRVSSHState *s = bs->opaque;
1201 int ret;
1202
1203 qemu_co_mutex_lock(&s->lock);
1204 ret = ssh_flush(s, bs);
1205 qemu_co_mutex_unlock(&s->lock);
1206
1207 return ret;
1208}
1209
1210#else
1211
1212static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1213{
1214 BDRVSSHState *s = bs->opaque;
1215
1216 unsafe_flush_warning(s, "libssh2 >= 1.4.4");
1217 return 0;
1218}
1219
1220#endif
1221
1222static int64_t ssh_getlength(BlockDriverState *bs)
1223{
1224 BDRVSSHState *s = bs->opaque;
1225 int64_t length;
1226
1227
1228 length = (int64_t) s->attrs.filesize;
1229 trace_ssh_getlength(length);
1230
1231 return length;
1232}
1233
1234static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
1235 PreallocMode prealloc, Error **errp)
1236{
1237 BDRVSSHState *s = bs->opaque;
1238
1239 if (prealloc != PREALLOC_MODE_OFF) {
1240 error_setg(errp, "Unsupported preallocation mode '%s'",
1241 PreallocMode_str(prealloc));
1242 return -ENOTSUP;
1243 }
1244
1245 if (offset < s->attrs.filesize) {
1246 error_setg(errp, "ssh driver does not support shrinking files");
1247 return -ENOTSUP;
1248 }
1249
1250 if (offset == s->attrs.filesize) {
1251 return 0;
1252 }
1253
1254 return ssh_grow_file(s, offset, errp);
1255}
1256
1257static const char *const ssh_strong_runtime_opts[] = {
1258 "host",
1259 "port",
1260 "path",
1261 "user",
1262 "host_key_check",
1263 "server.",
1264
1265 NULL
1266};
1267
1268static BlockDriver bdrv_ssh = {
1269 .format_name = "ssh",
1270 .protocol_name = "ssh",
1271 .instance_size = sizeof(BDRVSSHState),
1272 .bdrv_parse_filename = ssh_parse_filename,
1273 .bdrv_file_open = ssh_file_open,
1274 .bdrv_co_create = ssh_co_create,
1275 .bdrv_co_create_opts = ssh_co_create_opts,
1276 .bdrv_close = ssh_close,
1277 .bdrv_has_zero_init = ssh_has_zero_init,
1278 .bdrv_co_readv = ssh_co_readv,
1279 .bdrv_co_writev = ssh_co_writev,
1280 .bdrv_getlength = ssh_getlength,
1281 .bdrv_co_truncate = ssh_co_truncate,
1282 .bdrv_co_flush_to_disk = ssh_co_flush,
1283 .create_opts = &ssh_create_opts,
1284 .strong_runtime_opts = ssh_strong_runtime_opts,
1285};
1286
1287static void bdrv_ssh_init(void)
1288{
1289 int r;
1290
1291 r = libssh2_init(0);
1292 if (r != 0) {
1293 fprintf(stderr, "libssh2 initialization failed, %d\n", r);
1294 exit(EXIT_FAILURE);
1295 }
1296
1297 bdrv_register(&bdrv_ssh);
1298}
1299
1300block_init(bdrv_ssh_init);
1301