1 /* 2 * Secure Shell (ssh) backend for QEMU. 3 * 4 * Copyright (C) 2013 Red Hat Inc., Richard W.M. Jones <rjones@redhat.com> 5 * 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: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 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 22 * THE SOFTWARE. 23 */ 24 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <stdarg.h> 28 29 #include <libssh2.h> 30 #include <libssh2_sftp.h> 31 32 #include "block/block_int.h" 33 #include "qemu/sockets.h" 34 #include "qemu/uri.h" 35 #include "qapi/qmp/qint.h" 36 37 /* DEBUG_SSH=1 enables the DPRINTF (debugging printf) statements in 38 * this block driver code. 39 * 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 45 */ 46 #define DEBUG_SSH 0 47 #define TRACE_LIBSSH2 0 /* or try: LIBSSH2_TRACE_SFTP */ 48 49 #define DPRINTF(fmt, ...) \ 50 do { \ 51 if (DEBUG_SSH) { \ 52 fprintf(stderr, "ssh: %-15s " fmt "\n", \ 53 __func__, ##__VA_ARGS__); \ 54 } \ 55 } while (0) 56 57 typedef struct BDRVSSHState { 58 /* Coroutine. */ 59 CoMutex lock; 60 61 /* SSH connection. */ 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 */ 66 67 /* See ssh_seek() function below. */ 68 int64_t offset; 69 bool offset_op_read; 70 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). 73 */ 74 LIBSSH2_SFTP_ATTRIBUTES attrs; 75 76 /* Used to warn if 'flush' is not supported. */ 77 char *hostport; 78 bool unsafe_flush_warning; 79 } BDRVSSHState; 80 81 static void ssh_state_init(BDRVSSHState *s) 82 { 83 memset(s, 0, sizeof *s); 84 s->sock = -1; 85 s->offset = -1; 86 qemu_co_mutex_init(&s->lock); 87 } 88 89 static void ssh_state_free(BDRVSSHState *s) 90 { 91 g_free(s->hostport); 92 if (s->sftp_handle) { 93 libssh2_sftp_close(s->sftp_handle); 94 } 95 if (s->sftp) { 96 libssh2_sftp_shutdown(s->sftp); 97 } 98 if (s->session) { 99 libssh2_session_disconnect(s->session, 100 "from qemu ssh client: " 101 "user closed the connection"); 102 libssh2_session_free(s->session); 103 } 104 if (s->sock >= 0) { 105 close(s->sock); 106 } 107 } 108 109 static void GCC_FMT_ATTR(3, 4) 110 session_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...) 111 { 112 va_list args; 113 char *msg; 114 115 va_start(args, fs); 116 msg = g_strdup_vprintf(fs, args); 117 va_end(args); 118 119 if (s->session) { 120 char *ssh_err; 121 int ssh_err_code; 122 123 /* This is not an errno. See <libssh2.h>. */ 124 ssh_err_code = libssh2_session_last_error(s->session, 125 &ssh_err, NULL, 0); 126 error_setg(errp, "%s: %s (libssh2 error code: %d)", 127 msg, ssh_err, ssh_err_code); 128 } else { 129 error_setg(errp, "%s", msg); 130 } 131 g_free(msg); 132 } 133 134 static void GCC_FMT_ATTR(3, 4) 135 sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...) 136 { 137 va_list args; 138 char *msg; 139 140 va_start(args, fs); 141 msg = g_strdup_vprintf(fs, args); 142 va_end(args); 143 144 if (s->sftp) { 145 char *ssh_err; 146 int ssh_err_code; 147 unsigned long sftp_err_code; 148 149 /* This is not an errno. See <libssh2.h>. */ 150 ssh_err_code = libssh2_session_last_error(s->session, 151 &ssh_err, NULL, 0); 152 /* See <libssh2_sftp.h>. */ 153 sftp_err_code = libssh2_sftp_last_error((s)->sftp); 154 155 error_setg(errp, 156 "%s: %s (libssh2 error code: %d, sftp error code: %lu)", 157 msg, ssh_err, ssh_err_code, sftp_err_code); 158 } else { 159 error_setg(errp, "%s", msg); 160 } 161 g_free(msg); 162 } 163 164 static void GCC_FMT_ATTR(2, 3) 165 sftp_error_report(BDRVSSHState *s, const char *fs, ...) 166 { 167 va_list args; 168 169 va_start(args, fs); 170 error_vprintf(fs, args); 171 172 if ((s)->sftp) { 173 char *ssh_err; 174 int ssh_err_code; 175 unsigned long sftp_err_code; 176 177 /* This is not an errno. See <libssh2.h>. */ 178 ssh_err_code = libssh2_session_last_error(s->session, 179 &ssh_err, NULL, 0); 180 /* See <libssh2_sftp.h>. */ 181 sftp_err_code = libssh2_sftp_last_error((s)->sftp); 182 183 error_printf(": %s (libssh2 error code: %d, sftp error code: %lu)", 184 ssh_err, ssh_err_code, sftp_err_code); 185 } 186 187 va_end(args); 188 error_printf("\n"); 189 } 190 191 static int parse_uri(const char *filename, QDict *options, Error **errp) 192 { 193 URI *uri = NULL; 194 QueryParams *qp = NULL; 195 int i; 196 197 uri = uri_parse(filename); 198 if (!uri) { 199 return -EINVAL; 200 } 201 202 if (strcmp(uri->scheme, "ssh") != 0) { 203 error_setg(errp, "URI scheme must be 'ssh'"); 204 goto err; 205 } 206 207 if (!uri->server || strcmp(uri->server, "") == 0) { 208 error_setg(errp, "missing hostname in URI"); 209 goto err; 210 } 211 212 if (!uri->path || strcmp(uri->path, "") == 0) { 213 error_setg(errp, "missing remote path in URI"); 214 goto err; 215 } 216 217 qp = query_params_parse(uri->query); 218 if (!qp) { 219 error_setg(errp, "could not parse query parameters"); 220 goto err; 221 } 222 223 if(uri->user && strcmp(uri->user, "") != 0) { 224 qdict_put(options, "user", qstring_from_str(uri->user)); 225 } 226 227 qdict_put(options, "host", qstring_from_str(uri->server)); 228 229 if (uri->port) { 230 qdict_put(options, "port", qint_from_int(uri->port)); 231 } 232 233 qdict_put(options, "path", qstring_from_str(uri->path)); 234 235 /* Pick out any query parameters that we understand, and ignore 236 * the rest. 237 */ 238 for (i = 0; i < qp->n; ++i) { 239 if (strcmp(qp->p[i].name, "host_key_check") == 0) { 240 qdict_put(options, "host_key_check", 241 qstring_from_str(qp->p[i].value)); 242 } 243 } 244 245 query_params_free(qp); 246 uri_free(uri); 247 return 0; 248 249 err: 250 if (qp) { 251 query_params_free(qp); 252 } 253 if (uri) { 254 uri_free(uri); 255 } 256 return -EINVAL; 257 } 258 259 static void ssh_parse_filename(const char *filename, QDict *options, 260 Error **errp) 261 { 262 if (qdict_haskey(options, "user") || 263 qdict_haskey(options, "host") || 264 qdict_haskey(options, "port") || 265 qdict_haskey(options, "path") || 266 qdict_haskey(options, "host_key_check")) { 267 error_setg(errp, "user, host, port, path, host_key_check cannot be used at the same time as a file option"); 268 return; 269 } 270 271 parse_uri(filename, options, errp); 272 } 273 274 static int check_host_key_knownhosts(BDRVSSHState *s, 275 const char *host, int port, Error **errp) 276 { 277 const char *home; 278 char *knh_file = NULL; 279 LIBSSH2_KNOWNHOSTS *knh = NULL; 280 struct libssh2_knownhost *found; 281 int ret, r; 282 const char *hostkey; 283 size_t len; 284 int type; 285 286 hostkey = libssh2_session_hostkey(s->session, &len, &type); 287 if (!hostkey) { 288 ret = -EINVAL; 289 session_error_setg(errp, s, "failed to read remote host key"); 290 goto out; 291 } 292 293 knh = libssh2_knownhost_init(s->session); 294 if (!knh) { 295 ret = -EINVAL; 296 session_error_setg(errp, s, 297 "failed to initialize known hosts support"); 298 goto out; 299 } 300 301 home = getenv("HOME"); 302 if (home) { 303 knh_file = g_strdup_printf("%s/.ssh/known_hosts", home); 304 } else { 305 knh_file = g_strdup_printf("/root/.ssh/known_hosts"); 306 } 307 308 /* Read all known hosts from OpenSSH-style known_hosts file. */ 309 libssh2_knownhost_readfile(knh, knh_file, LIBSSH2_KNOWNHOST_FILE_OPENSSH); 310 311 r = libssh2_knownhost_checkp(knh, host, port, hostkey, len, 312 LIBSSH2_KNOWNHOST_TYPE_PLAIN| 313 LIBSSH2_KNOWNHOST_KEYENC_RAW, 314 &found); 315 switch (r) { 316 case LIBSSH2_KNOWNHOST_CHECK_MATCH: 317 /* OK */ 318 DPRINTF("host key OK: %s", found->key); 319 break; 320 case LIBSSH2_KNOWNHOST_CHECK_MISMATCH: 321 ret = -EINVAL; 322 session_error_setg(errp, s, 323 "host key does not match the one in known_hosts" 324 " (found key %s)", found->key); 325 goto out; 326 case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND: 327 ret = -EINVAL; 328 session_error_setg(errp, s, "no host key was found in known_hosts"); 329 goto out; 330 case LIBSSH2_KNOWNHOST_CHECK_FAILURE: 331 ret = -EINVAL; 332 session_error_setg(errp, s, 333 "failure matching the host key with known_hosts"); 334 goto out; 335 default: 336 ret = -EINVAL; 337 session_error_setg(errp, s, "unknown error matching the host key" 338 " with known_hosts (%d)", r); 339 goto out; 340 } 341 342 /* known_hosts checking successful. */ 343 ret = 0; 344 345 out: 346 if (knh != NULL) { 347 libssh2_knownhost_free(knh); 348 } 349 g_free(knh_file); 350 return ret; 351 } 352 353 static unsigned hex2decimal(char ch) 354 { 355 if (ch >= '0' && ch <= '9') { 356 return (ch - '0'); 357 } else if (ch >= 'a' && ch <= 'f') { 358 return 10 + (ch - 'a'); 359 } else if (ch >= 'A' && ch <= 'F') { 360 return 10 + (ch - 'A'); 361 } 362 363 return -1; 364 } 365 366 /* Compare the binary fingerprint (hash of host key) with the 367 * host_key_check parameter. 368 */ 369 static int compare_fingerprint(const unsigned char *fingerprint, size_t len, 370 const char *host_key_check) 371 { 372 unsigned c; 373 374 while (len > 0) { 375 while (*host_key_check == ':') 376 host_key_check++; 377 if (!qemu_isxdigit(host_key_check[0]) || 378 !qemu_isxdigit(host_key_check[1])) 379 return 1; 380 c = hex2decimal(host_key_check[0]) * 16 + 381 hex2decimal(host_key_check[1]); 382 if (c - *fingerprint != 0) 383 return c - *fingerprint; 384 fingerprint++; 385 len--; 386 host_key_check += 2; 387 } 388 return *host_key_check - '\0'; 389 } 390 391 static int 392 check_host_key_hash(BDRVSSHState *s, const char *hash, 393 int hash_type, size_t fingerprint_len, Error **errp) 394 { 395 const char *fingerprint; 396 397 fingerprint = libssh2_hostkey_hash(s->session, hash_type); 398 if (!fingerprint) { 399 session_error_setg(errp, s, "failed to read remote host key"); 400 return -EINVAL; 401 } 402 403 if(compare_fingerprint((unsigned char *) fingerprint, fingerprint_len, 404 hash) != 0) { 405 error_setg(errp, "remote host key does not match host_key_check '%s'", 406 hash); 407 return -EPERM; 408 } 409 410 return 0; 411 } 412 413 static int check_host_key(BDRVSSHState *s, const char *host, int port, 414 const char *host_key_check, Error **errp) 415 { 416 /* host_key_check=no */ 417 if (strcmp(host_key_check, "no") == 0) { 418 return 0; 419 } 420 421 /* host_key_check=md5:xx:yy:zz:... */ 422 if (strncmp(host_key_check, "md5:", 4) == 0) { 423 return check_host_key_hash(s, &host_key_check[4], 424 LIBSSH2_HOSTKEY_HASH_MD5, 16, errp); 425 } 426 427 /* host_key_check=sha1:xx:yy:zz:... */ 428 if (strncmp(host_key_check, "sha1:", 5) == 0) { 429 return check_host_key_hash(s, &host_key_check[5], 430 LIBSSH2_HOSTKEY_HASH_SHA1, 20, errp); 431 } 432 433 /* host_key_check=yes */ 434 if (strcmp(host_key_check, "yes") == 0) { 435 return check_host_key_knownhosts(s, host, port, errp); 436 } 437 438 error_setg(errp, "unknown host_key_check setting (%s)", host_key_check); 439 return -EINVAL; 440 } 441 442 static int authenticate(BDRVSSHState *s, const char *user, Error **errp) 443 { 444 int r, ret; 445 const char *userauthlist; 446 LIBSSH2_AGENT *agent = NULL; 447 struct libssh2_agent_publickey *identity; 448 struct libssh2_agent_publickey *prev_identity = NULL; 449 450 userauthlist = libssh2_userauth_list(s->session, user, strlen(user)); 451 if (strstr(userauthlist, "publickey") == NULL) { 452 ret = -EPERM; 453 error_setg(errp, 454 "remote server does not support \"publickey\" authentication"); 455 goto out; 456 } 457 458 /* Connect to ssh-agent and try each identity in turn. */ 459 agent = libssh2_agent_init(s->session); 460 if (!agent) { 461 ret = -EINVAL; 462 session_error_setg(errp, s, "failed to initialize ssh-agent support"); 463 goto out; 464 } 465 if (libssh2_agent_connect(agent)) { 466 ret = -ECONNREFUSED; 467 session_error_setg(errp, s, "failed to connect to ssh-agent"); 468 goto out; 469 } 470 if (libssh2_agent_list_identities(agent)) { 471 ret = -EINVAL; 472 session_error_setg(errp, s, 473 "failed requesting identities from ssh-agent"); 474 goto out; 475 } 476 477 for(;;) { 478 r = libssh2_agent_get_identity(agent, &identity, prev_identity); 479 if (r == 1) { /* end of list */ 480 break; 481 } 482 if (r < 0) { 483 ret = -EINVAL; 484 session_error_setg(errp, s, 485 "failed to obtain identity from ssh-agent"); 486 goto out; 487 } 488 r = libssh2_agent_userauth(agent, user, identity); 489 if (r == 0) { 490 /* Authenticated! */ 491 ret = 0; 492 goto out; 493 } 494 /* Failed to authenticate with this identity, try the next one. */ 495 prev_identity = identity; 496 } 497 498 ret = -EPERM; 499 error_setg(errp, "failed to authenticate using publickey authentication " 500 "and the identities held by your ssh-agent"); 501 502 out: 503 if (agent != NULL) { 504 /* Note: libssh2 implementation implicitly calls 505 * libssh2_agent_disconnect if necessary. 506 */ 507 libssh2_agent_free(agent); 508 } 509 510 return ret; 511 } 512 513 static int connect_to_ssh(BDRVSSHState *s, QDict *options, 514 int ssh_flags, int creat_mode, Error **errp) 515 { 516 int r, ret; 517 const char *host, *user, *path, *host_key_check; 518 int port; 519 520 host = qdict_get_str(options, "host"); 521 522 if (qdict_haskey(options, "port")) { 523 port = qdict_get_int(options, "port"); 524 } else { 525 port = 22; 526 } 527 528 path = qdict_get_str(options, "path"); 529 530 if (qdict_haskey(options, "user")) { 531 user = qdict_get_str(options, "user"); 532 } else { 533 user = g_get_user_name(); 534 if (!user) { 535 error_setg_errno(errp, errno, "Can't get user name"); 536 ret = -errno; 537 goto err; 538 } 539 } 540 541 if (qdict_haskey(options, "host_key_check")) { 542 host_key_check = qdict_get_str(options, "host_key_check"); 543 } else { 544 host_key_check = "yes"; 545 } 546 547 /* Construct the host:port name for inet_connect. */ 548 g_free(s->hostport); 549 s->hostport = g_strdup_printf("%s:%d", host, port); 550 551 /* Open the socket and connect. */ 552 s->sock = inet_connect(s->hostport, errp); 553 if (s->sock < 0) { 554 ret = -errno; 555 goto err; 556 } 557 558 /* Create SSH session. */ 559 s->session = libssh2_session_init(); 560 if (!s->session) { 561 ret = -EINVAL; 562 session_error_setg(errp, s, "failed to initialize libssh2 session"); 563 goto err; 564 } 565 566 #if TRACE_LIBSSH2 != 0 567 libssh2_trace(s->session, TRACE_LIBSSH2); 568 #endif 569 570 r = libssh2_session_handshake(s->session, s->sock); 571 if (r != 0) { 572 ret = -EINVAL; 573 session_error_setg(errp, s, "failed to establish SSH session"); 574 goto err; 575 } 576 577 /* Check the remote host's key against known_hosts. */ 578 ret = check_host_key(s, host, port, host_key_check, errp); 579 if (ret < 0) { 580 goto err; 581 } 582 583 /* Authenticate. */ 584 ret = authenticate(s, user, errp); 585 if (ret < 0) { 586 goto err; 587 } 588 589 /* Start SFTP. */ 590 s->sftp = libssh2_sftp_init(s->session); 591 if (!s->sftp) { 592 session_error_setg(errp, s, "failed to initialize sftp handle"); 593 ret = -EINVAL; 594 goto err; 595 } 596 597 /* Open the remote file. */ 598 DPRINTF("opening file %s flags=0x%x creat_mode=0%o", 599 path, ssh_flags, creat_mode); 600 s->sftp_handle = libssh2_sftp_open(s->sftp, path, ssh_flags, creat_mode); 601 if (!s->sftp_handle) { 602 session_error_setg(errp, s, "failed to open remote file '%s'", path); 603 ret = -EINVAL; 604 goto err; 605 } 606 607 r = libssh2_sftp_fstat(s->sftp_handle, &s->attrs); 608 if (r < 0) { 609 sftp_error_setg(errp, s, "failed to read file attributes"); 610 return -EINVAL; 611 } 612 613 /* Delete the options we've used; any not deleted will cause the 614 * block layer to give an error about unused options. 615 */ 616 qdict_del(options, "host"); 617 qdict_del(options, "port"); 618 qdict_del(options, "user"); 619 qdict_del(options, "path"); 620 qdict_del(options, "host_key_check"); 621 622 return 0; 623 624 err: 625 if (s->sftp_handle) { 626 libssh2_sftp_close(s->sftp_handle); 627 } 628 s->sftp_handle = NULL; 629 if (s->sftp) { 630 libssh2_sftp_shutdown(s->sftp); 631 } 632 s->sftp = NULL; 633 if (s->session) { 634 libssh2_session_disconnect(s->session, 635 "from qemu ssh client: " 636 "error opening connection"); 637 libssh2_session_free(s->session); 638 } 639 s->session = NULL; 640 641 return ret; 642 } 643 644 static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags, 645 Error **errp) 646 { 647 BDRVSSHState *s = bs->opaque; 648 int ret; 649 int ssh_flags; 650 651 ssh_state_init(s); 652 653 ssh_flags = LIBSSH2_FXF_READ; 654 if (bdrv_flags & BDRV_O_RDWR) { 655 ssh_flags |= LIBSSH2_FXF_WRITE; 656 } 657 658 /* Start up SSH. */ 659 ret = connect_to_ssh(s, options, ssh_flags, 0, errp); 660 if (ret < 0) { 661 goto err; 662 } 663 664 /* Go non-blocking. */ 665 libssh2_session_set_blocking(s->session, 0); 666 667 return 0; 668 669 err: 670 if (s->sock >= 0) { 671 close(s->sock); 672 } 673 s->sock = -1; 674 675 return ret; 676 } 677 678 static QemuOptsList ssh_create_opts = { 679 .name = "ssh-create-opts", 680 .head = QTAILQ_HEAD_INITIALIZER(ssh_create_opts.head), 681 .desc = { 682 { 683 .name = BLOCK_OPT_SIZE, 684 .type = QEMU_OPT_SIZE, 685 .help = "Virtual disk size" 686 }, 687 { /* end of list */ } 688 } 689 }; 690 691 static int ssh_create(const char *filename, QemuOpts *opts, Error **errp) 692 { 693 int r, ret; 694 int64_t total_size = 0; 695 QDict *uri_options = NULL; 696 BDRVSSHState s; 697 ssize_t r2; 698 char c[1] = { '\0' }; 699 700 ssh_state_init(&s); 701 702 /* Get desired file size. */ 703 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 704 BDRV_SECTOR_SIZE); 705 DPRINTF("total_size=%" PRIi64, total_size); 706 707 uri_options = qdict_new(); 708 r = parse_uri(filename, uri_options, errp); 709 if (r < 0) { 710 ret = r; 711 goto out; 712 } 713 714 r = connect_to_ssh(&s, uri_options, 715 LIBSSH2_FXF_READ|LIBSSH2_FXF_WRITE| 716 LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC, 717 0644, errp); 718 if (r < 0) { 719 ret = r; 720 goto out; 721 } 722 723 if (total_size > 0) { 724 libssh2_sftp_seek64(s.sftp_handle, total_size-1); 725 r2 = libssh2_sftp_write(s.sftp_handle, c, 1); 726 if (r2 < 0) { 727 sftp_error_setg(errp, &s, "truncate failed"); 728 ret = -EINVAL; 729 goto out; 730 } 731 s.attrs.filesize = total_size; 732 } 733 734 ret = 0; 735 736 out: 737 ssh_state_free(&s); 738 if (uri_options != NULL) { 739 QDECREF(uri_options); 740 } 741 return ret; 742 } 743 744 static void ssh_close(BlockDriverState *bs) 745 { 746 BDRVSSHState *s = bs->opaque; 747 748 ssh_state_free(s); 749 } 750 751 static int ssh_has_zero_init(BlockDriverState *bs) 752 { 753 BDRVSSHState *s = bs->opaque; 754 /* Assume false, unless we can positively prove it's true. */ 755 int has_zero_init = 0; 756 757 if (s->attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { 758 if (s->attrs.permissions & LIBSSH2_SFTP_S_IFREG) { 759 has_zero_init = 1; 760 } 761 } 762 763 return has_zero_init; 764 } 765 766 static void restart_coroutine(void *opaque) 767 { 768 Coroutine *co = opaque; 769 770 DPRINTF("co=%p", co); 771 772 qemu_coroutine_enter(co, NULL); 773 } 774 775 static coroutine_fn void set_fd_handler(BDRVSSHState *s, BlockDriverState *bs) 776 { 777 int r; 778 IOHandler *rd_handler = NULL, *wr_handler = NULL; 779 Coroutine *co = qemu_coroutine_self(); 780 781 r = libssh2_session_block_directions(s->session); 782 783 if (r & LIBSSH2_SESSION_BLOCK_INBOUND) { 784 rd_handler = restart_coroutine; 785 } 786 if (r & LIBSSH2_SESSION_BLOCK_OUTBOUND) { 787 wr_handler = restart_coroutine; 788 } 789 790 DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock, 791 rd_handler, wr_handler); 792 793 aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, 794 rd_handler, wr_handler, co); 795 } 796 797 static coroutine_fn void clear_fd_handler(BDRVSSHState *s, 798 BlockDriverState *bs) 799 { 800 DPRINTF("s->sock=%d", s->sock); 801 aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, NULL, NULL, NULL); 802 } 803 804 /* A non-blocking call returned EAGAIN, so yield, ensuring the 805 * handlers are set up so that we'll be rescheduled when there is an 806 * interesting event on the socket. 807 */ 808 static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs) 809 { 810 set_fd_handler(s, bs); 811 qemu_coroutine_yield(); 812 clear_fd_handler(s, bs); 813 } 814 815 /* SFTP has a function `libssh2_sftp_seek64' which seeks to a position 816 * in the remote file. Notice that it just updates a field in the 817 * sftp_handle structure, so there is no network traffic and it cannot 818 * fail. 819 * 820 * However, `libssh2_sftp_seek64' does have a catastrophic effect on 821 * performance since it causes the handle to throw away all in-flight 822 * reads and buffered readahead data. Therefore this function tries 823 * to be intelligent about when to call the underlying libssh2 function. 824 */ 825 #define SSH_SEEK_WRITE 0 826 #define SSH_SEEK_READ 1 827 #define SSH_SEEK_FORCE 2 828 829 static void ssh_seek(BDRVSSHState *s, int64_t offset, int flags) 830 { 831 bool op_read = (flags & SSH_SEEK_READ) != 0; 832 bool force = (flags & SSH_SEEK_FORCE) != 0; 833 834 if (force || op_read != s->offset_op_read || offset != s->offset) { 835 DPRINTF("seeking to offset=%" PRIi64, offset); 836 libssh2_sftp_seek64(s->sftp_handle, offset); 837 s->offset = offset; 838 s->offset_op_read = op_read; 839 } 840 } 841 842 static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs, 843 int64_t offset, size_t size, 844 QEMUIOVector *qiov) 845 { 846 ssize_t r; 847 size_t got; 848 char *buf, *end_of_vec; 849 struct iovec *i; 850 851 DPRINTF("offset=%" PRIi64 " size=%zu", offset, size); 852 853 ssh_seek(s, offset, SSH_SEEK_READ); 854 855 /* This keeps track of the current iovec element ('i'), where we 856 * will write to next ('buf'), and the end of the current iovec 857 * ('end_of_vec'). 858 */ 859 i = &qiov->iov[0]; 860 buf = i->iov_base; 861 end_of_vec = i->iov_base + i->iov_len; 862 863 /* libssh2 has a hard-coded limit of 2000 bytes per request, 864 * although it will also do readahead behind our backs. Therefore 865 * we may have to do repeated reads here until we have read 'size' 866 * bytes. 867 */ 868 for (got = 0; got < size; ) { 869 again: 870 DPRINTF("sftp_read buf=%p size=%zu", buf, end_of_vec - buf); 871 r = libssh2_sftp_read(s->sftp_handle, buf, end_of_vec - buf); 872 DPRINTF("sftp_read returned %zd", r); 873 874 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { 875 co_yield(s, bs); 876 goto again; 877 } 878 if (r < 0) { 879 sftp_error_report(s, "read failed"); 880 s->offset = -1; 881 return -EIO; 882 } 883 if (r == 0) { 884 /* EOF: Short read so pad the buffer with zeroes and return it. */ 885 qemu_iovec_memset(qiov, got, 0, size - got); 886 return 0; 887 } 888 889 got += r; 890 buf += r; 891 s->offset += r; 892 if (buf >= end_of_vec && got < size) { 893 i++; 894 buf = i->iov_base; 895 end_of_vec = i->iov_base + i->iov_len; 896 } 897 } 898 899 return 0; 900 } 901 902 static coroutine_fn int ssh_co_readv(BlockDriverState *bs, 903 int64_t sector_num, 904 int nb_sectors, QEMUIOVector *qiov) 905 { 906 BDRVSSHState *s = bs->opaque; 907 int ret; 908 909 qemu_co_mutex_lock(&s->lock); 910 ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE, 911 nb_sectors * BDRV_SECTOR_SIZE, qiov); 912 qemu_co_mutex_unlock(&s->lock); 913 914 return ret; 915 } 916 917 static int ssh_write(BDRVSSHState *s, BlockDriverState *bs, 918 int64_t offset, size_t size, 919 QEMUIOVector *qiov) 920 { 921 ssize_t r; 922 size_t written; 923 char *buf, *end_of_vec; 924 struct iovec *i; 925 926 DPRINTF("offset=%" PRIi64 " size=%zu", offset, size); 927 928 ssh_seek(s, offset, SSH_SEEK_WRITE); 929 930 /* This keeps track of the current iovec element ('i'), where we 931 * will read from next ('buf'), and the end of the current iovec 932 * ('end_of_vec'). 933 */ 934 i = &qiov->iov[0]; 935 buf = i->iov_base; 936 end_of_vec = i->iov_base + i->iov_len; 937 938 for (written = 0; written < size; ) { 939 again: 940 DPRINTF("sftp_write buf=%p size=%zu", buf, end_of_vec - buf); 941 r = libssh2_sftp_write(s->sftp_handle, buf, end_of_vec - buf); 942 DPRINTF("sftp_write returned %zd", r); 943 944 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { 945 co_yield(s, bs); 946 goto again; 947 } 948 if (r < 0) { 949 sftp_error_report(s, "write failed"); 950 s->offset = -1; 951 return -EIO; 952 } 953 /* The libssh2 API is very unclear about this. A comment in 954 * the code says "nothing was acked, and no EAGAIN was 955 * received!" which apparently means that no data got sent 956 * out, and the underlying channel didn't return any EAGAIN 957 * indication. I think this is a bug in either libssh2 or 958 * OpenSSH (server-side). In any case, forcing a seek (to 959 * discard libssh2 internal buffers), and then trying again 960 * works for me. 961 */ 962 if (r == 0) { 963 ssh_seek(s, offset + written, SSH_SEEK_WRITE|SSH_SEEK_FORCE); 964 co_yield(s, bs); 965 goto again; 966 } 967 968 written += r; 969 buf += r; 970 s->offset += r; 971 if (buf >= end_of_vec && written < size) { 972 i++; 973 buf = i->iov_base; 974 end_of_vec = i->iov_base + i->iov_len; 975 } 976 977 if (offset + written > s->attrs.filesize) 978 s->attrs.filesize = offset + written; 979 } 980 981 return 0; 982 } 983 984 static coroutine_fn int ssh_co_writev(BlockDriverState *bs, 985 int64_t sector_num, 986 int nb_sectors, QEMUIOVector *qiov) 987 { 988 BDRVSSHState *s = bs->opaque; 989 int ret; 990 991 qemu_co_mutex_lock(&s->lock); 992 ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE, 993 nb_sectors * BDRV_SECTOR_SIZE, qiov); 994 qemu_co_mutex_unlock(&s->lock); 995 996 return ret; 997 } 998 999 static void unsafe_flush_warning(BDRVSSHState *s, const char *what) 1000 { 1001 if (!s->unsafe_flush_warning) { 1002 error_report("warning: ssh server %s does not support fsync", 1003 s->hostport); 1004 if (what) { 1005 error_report("to support fsync, you need %s", what); 1006 } 1007 s->unsafe_flush_warning = true; 1008 } 1009 } 1010 1011 #ifdef HAS_LIBSSH2_SFTP_FSYNC 1012 1013 static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs) 1014 { 1015 int r; 1016 1017 DPRINTF("fsync"); 1018 again: 1019 r = libssh2_sftp_fsync(s->sftp_handle); 1020 if (r == LIBSSH2_ERROR_EAGAIN || r == LIBSSH2_ERROR_TIMEOUT) { 1021 co_yield(s, bs); 1022 goto again; 1023 } 1024 if (r == LIBSSH2_ERROR_SFTP_PROTOCOL && 1025 libssh2_sftp_last_error(s->sftp) == LIBSSH2_FX_OP_UNSUPPORTED) { 1026 unsafe_flush_warning(s, "OpenSSH >= 6.3"); 1027 return 0; 1028 } 1029 if (r < 0) { 1030 sftp_error_report(s, "fsync failed"); 1031 return -EIO; 1032 } 1033 1034 return 0; 1035 } 1036 1037 static coroutine_fn int ssh_co_flush(BlockDriverState *bs) 1038 { 1039 BDRVSSHState *s = bs->opaque; 1040 int ret; 1041 1042 qemu_co_mutex_lock(&s->lock); 1043 ret = ssh_flush(s, bs); 1044 qemu_co_mutex_unlock(&s->lock); 1045 1046 return ret; 1047 } 1048 1049 #else /* !HAS_LIBSSH2_SFTP_FSYNC */ 1050 1051 static coroutine_fn int ssh_co_flush(BlockDriverState *bs) 1052 { 1053 BDRVSSHState *s = bs->opaque; 1054 1055 unsafe_flush_warning(s, "libssh2 >= 1.4.4"); 1056 return 0; 1057 } 1058 1059 #endif /* !HAS_LIBSSH2_SFTP_FSYNC */ 1060 1061 static int64_t ssh_getlength(BlockDriverState *bs) 1062 { 1063 BDRVSSHState *s = bs->opaque; 1064 int64_t length; 1065 1066 /* Note we cannot make a libssh2 call here. */ 1067 length = (int64_t) s->attrs.filesize; 1068 DPRINTF("length=%" PRIi64, length); 1069 1070 return length; 1071 } 1072 1073 static BlockDriver bdrv_ssh = { 1074 .format_name = "ssh", 1075 .protocol_name = "ssh", 1076 .instance_size = sizeof(BDRVSSHState), 1077 .bdrv_parse_filename = ssh_parse_filename, 1078 .bdrv_file_open = ssh_file_open, 1079 .bdrv_create = ssh_create, 1080 .bdrv_close = ssh_close, 1081 .bdrv_has_zero_init = ssh_has_zero_init, 1082 .bdrv_co_readv = ssh_co_readv, 1083 .bdrv_co_writev = ssh_co_writev, 1084 .bdrv_getlength = ssh_getlength, 1085 .bdrv_co_flush_to_disk = ssh_co_flush, 1086 .create_opts = &ssh_create_opts, 1087 }; 1088 1089 static void bdrv_ssh_init(void) 1090 { 1091 int r; 1092 1093 r = libssh2_init(0); 1094 if (r != 0) { 1095 fprintf(stderr, "libssh2 initialization failed, %d\n", r); 1096 exit(EXIT_FAILURE); 1097 } 1098 1099 bdrv_register(&bdrv_ssh); 1100 } 1101 1102 block_init(bdrv_ssh_init); 1103