block/ssh.c

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