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 <libssh/libssh.h>
  28 #include <libssh/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/module.h"
  35 #include "qemu/option.h"
  36 #include "qemu/ctype.h"
  37 #include "qemu/cutils.h"
  38 #include "qemu/sockets.h"
  39 #include "qemu/uri.h"
  40 #include "qapi/qapi-visit-sockets.h"
  41 #include "qapi/qapi-visit-block-core.h"
  42 #include "qapi/qmp/qdict.h"
  43 #include "qapi/qmp/qstring.h"
  44 #include "qapi/qobject-input-visitor.h"
  45 #include "qapi/qobject-output-visitor.h"
  46 #include "trace.h"
  47
  48 /*
  49  * TRACE_LIBSSH=<level> enables tracing in libssh itself.
  50  * The meaning of <level> is described here:
  51  * http://api.libssh.org/master/group__libssh__log.html
  52  */
  53 #define TRACE_LIBSSH  0 /* see: SSH_LOG_* */
  54
  55 typedef struct BDRVSSHState {
  56     /* Coroutine. */
  57     CoMutex lock;
  58
  59     /* SSH connection. */
  60     int sock;                         /* socket */
  61     ssh_session session;              /* ssh session */
  62     sftp_session sftp;                /* sftp session */
  63     sftp_file sftp_handle;            /* sftp remote file handle */
  64
  65     /*
  66      * File attributes at open.  We try to keep the .size field
  67      * updated if it changes (eg by writing at the end of the file).
  68      */
  69     sftp_attributes attrs;
  70
  71     InetSocketAddress *inet;
  72
  73     /* Used to warn if 'flush' is not supported. */
  74     bool unsafe_flush_warning;
  75
  76     /*
  77      * Store the user name for ssh_refresh_filename() because the
  78      * default depends on the system you are on -- therefore, when we
  79      * generate a filename, it should always contain the user name we
  80      * are actually using.
  81      */
  82     char *user;
  83 } BDRVSSHState;
  84
  85 static void ssh_state_init(BDRVSSHState *s)
  86 {
  87     memset(s, 0, sizeof *s);
  88     s->sock = -1;
  89     qemu_co_mutex_init(&s->lock);
  90 }
  91
  92 static void ssh_state_free(BDRVSSHState *s)
  93 {
  94     g_free(s->user);
  95
  96     if (s->attrs) {
  97         sftp_attributes_free(s->attrs);
  98     }
  99     if (s->sftp_handle) {
 100         sftp_close(s->sftp_handle);
 101     }
 102     if (s->sftp) {
 103         sftp_free(s->sftp);
 104     }
 105     if (s->session) {
 106         ssh_disconnect(s->session);
 107         ssh_free(s->session); /* This frees s->sock */
 108     }
 109 }
 110
 111 static void GCC_FMT_ATTR(3, 4)
 112 session_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
 113 {
 114     va_list args;
 115     char *msg;
 116
 117     va_start(args, fs);
 118     msg = g_strdup_vprintf(fs, args);
 119     va_end(args);
 120
 121     if (s->session) {
 122         const char *ssh_err;
 123         int ssh_err_code;
 124
 125         /* This is not an errno.  See <libssh/libssh.h>. */
 126         ssh_err = ssh_get_error(s->session);
 127         ssh_err_code = ssh_get_error_code(s->session);
 128         error_setg(errp, "%s: %s (libssh error code: %d)",
 129                    msg, ssh_err, ssh_err_code);
 130     } else {
 131         error_setg(errp, "%s", msg);
 132     }
 133     g_free(msg);
 134 }
 135
 136 static void GCC_FMT_ATTR(3, 4)
 137 sftp_error_setg(Error **errp, BDRVSSHState *s, const char *fs, ...)
 138 {
 139     va_list args;
 140     char *msg;
 141
 142     va_start(args, fs);
 143     msg = g_strdup_vprintf(fs, args);
 144     va_end(args);
 145
 146     if (s->sftp) {
 147         const char *ssh_err;
 148         int ssh_err_code;
 149         int sftp_err_code;
 150
 151         /* This is not an errno.  See <libssh/libssh.h>. */
 152         ssh_err = ssh_get_error(s->session);
 153         ssh_err_code = ssh_get_error_code(s->session);
 154         /* See <libssh/sftp.h>. */
 155         sftp_err_code = sftp_get_error(s->sftp);
 156
 157         error_setg(errp,
 158                    "%s: %s (libssh error code: %d, sftp error code: %d)",
 159                    msg, ssh_err, ssh_err_code, sftp_err_code);
 160     } else {
 161         error_setg(errp, "%s", msg);
 162     }
 163     g_free(msg);
 164 }
 165
 166 static void sftp_error_trace(BDRVSSHState *s, const char *op)
 167 {
 168     const char *ssh_err;
 169     int ssh_err_code;
 170     int sftp_err_code;
 171
 172     /* This is not an errno.  See <libssh/libssh.h>. */
 173     ssh_err = ssh_get_error(s->session);
 174     ssh_err_code = ssh_get_error_code(s->session);
 175     /* See <libssh/sftp.h>. */
 176     sftp_err_code = sftp_get_error(s->sftp);
 177
 178     trace_sftp_error(op, ssh_err, ssh_err_code, sftp_err_code);
 179 }
 180
 181 static int parse_uri(const char *filename, QDict *options, Error **errp)
 182 {
 183     URI *uri = NULL;
 184     QueryParams *qp;
 185     char *port_str;
 186     int i;
 187
 188     uri = uri_parse(filename);
 189     if (!uri) {
 190         return -EINVAL;
 191     }
 192
 193     if (g_strcmp0(uri->scheme, "ssh") != 0) {
 194         error_setg(errp, "URI scheme must be 'ssh'");
 195         goto err;
 196     }
 197
 198     if (!uri->server || strcmp(uri->server, "") == 0) {
 199         error_setg(errp, "missing hostname in URI");
 200         goto err;
 201     }
 202
 203     if (!uri->path || strcmp(uri->path, "") == 0) {
 204         error_setg(errp, "missing remote path in URI");
 205         goto err;
 206     }
 207
 208     qp = query_params_parse(uri->query);
 209     if (!qp) {
 210         error_setg(errp, "could not parse query parameters");
 211         goto err;
 212     }
 213
 214     if(uri->user && strcmp(uri->user, "") != 0) {
 215         qdict_put_str(options, "user", uri->user);
 216     }
 217
 218     qdict_put_str(options, "server.host", uri->server);
 219
 220     port_str = g_strdup_printf("%d", uri->port ?: 22);
 221     qdict_put_str(options, "server.port", port_str);
 222     g_free(port_str);
 223
 224     qdict_put_str(options, "path", uri->path);
 225
 226     /* Pick out any query parameters that we understand, and ignore
 227      * the rest.
 228      */
 229     for (i = 0; i < qp->n; ++i) {
 230         if (strcmp(qp->p[i].name, "host_key_check") == 0) {
 231             qdict_put_str(options, "host_key_check", qp->p[i].value);
 232         }
 233     }
 234
 235     query_params_free(qp);
 236     uri_free(uri);
 237     return 0;
 238
 239  err:
 240     if (uri) {
 241       uri_free(uri);
 242     }
 243     return -EINVAL;
 244 }
 245
 246 static bool ssh_has_filename_options_conflict(QDict *options, Error **errp)
 247 {
 248     const QDictEntry *qe;
 249
 250     for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) {
 251         if (!strcmp(qe->key, "host") ||
 252             !strcmp(qe->key, "port") ||
 253             !strcmp(qe->key, "path") ||
 254             !strcmp(qe->key, "user") ||
 255             !strcmp(qe->key, "host_key_check") ||
 256             strstart(qe->key, "server.", NULL))
 257         {
 258             error_setg(errp, "Option '%s' cannot be used with a file name",
 259                        qe->key);
 260             return true;
 261         }
 262     }
 263
 264     return false;
 265 }
 266
 267 static void ssh_parse_filename(const char *filename, QDict *options,
 268                                Error **errp)
 269 {
 270     if (ssh_has_filename_options_conflict(options, errp)) {
 271         return;
 272     }
 273
 274     parse_uri(filename, options, errp);
 275 }
 276
 277 static int check_host_key_knownhosts(BDRVSSHState *s, Error **errp)
 278 {
 279     int ret;
 280 #ifdef HAVE_LIBSSH_0_8
 281     enum ssh_known_hosts_e state;
 282     int r;
 283     ssh_key pubkey;
 284     enum ssh_keytypes_e pubkey_type;
 285     unsigned char *server_hash = NULL;
 286     size_t server_hash_len;
 287     char *fingerprint = NULL;
 288
 289     state = ssh_session_is_known_server(s->session);
 290     trace_ssh_server_status(state);
 291
 292     switch (state) {
 293     case SSH_KNOWN_HOSTS_OK:
 294         /* OK */
 295         trace_ssh_check_host_key_knownhosts();
 296         break;
 297     case SSH_KNOWN_HOSTS_CHANGED:
 298         ret = -EINVAL;
 299         r = ssh_get_server_publickey(s->session, &pubkey);
 300         if (r == 0) {
 301             r = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_SHA256,
 302                                        &server_hash, &server_hash_len);
 303             pubkey_type = ssh_key_type(pubkey);
 304             ssh_key_free(pubkey);
 305         }
 306         if (r == 0) {
 307             fingerprint = ssh_get_fingerprint_hash(SSH_PUBLICKEY_HASH_SHA256,
 308                                                    server_hash,
 309                                                    server_hash_len);
 310             ssh_clean_pubkey_hash(&server_hash);
 311         }
 312         if (fingerprint) {
 313             error_setg(errp,
 314                        "host key (%s key with fingerprint %s) does not match "
 315                        "the one in known_hosts; this may be a possible attack",
 316                        ssh_key_type_to_char(pubkey_type), fingerprint);
 317             ssh_string_free_char(fingerprint);
 318         } else  {
 319             error_setg(errp,
 320                        "host key does not match the one in known_hosts; this "
 321                        "may be a possible attack");
 322         }
 323         goto out;
 324     case SSH_KNOWN_HOSTS_OTHER:
 325         ret = -EINVAL;
 326         error_setg(errp,
 327                    "host key for this server not found, another type exists");
 328         goto out;
 329     case SSH_KNOWN_HOSTS_UNKNOWN:
 330         ret = -EINVAL;
 331         error_setg(errp, "no host key was found in known_hosts");
 332         goto out;
 333     case SSH_KNOWN_HOSTS_NOT_FOUND:
 334         ret = -ENOENT;
 335         error_setg(errp, "known_hosts file not found");
 336         goto out;
 337     case SSH_KNOWN_HOSTS_ERROR:
 338         ret = -EINVAL;
 339         error_setg(errp, "error while checking the host");
 340         goto out;
 341     default:
 342         ret = -EINVAL;
 343         error_setg(errp, "error while checking for known server (%d)", state);
 344         goto out;
 345     }
 346 #else /* !HAVE_LIBSSH_0_8 */
 347     int state;
 348
 349     state = ssh_is_server_known(s->session);
 350     trace_ssh_server_status(state);
 351
 352     switch (state) {
 353     case SSH_SERVER_KNOWN_OK:
 354         /* OK */
 355         trace_ssh_check_host_key_knownhosts();
 356         break;
 357     case SSH_SERVER_KNOWN_CHANGED:
 358         ret = -EINVAL;
 359         error_setg(errp,
 360                    "host key does not match the one in known_hosts; this "
 361                    "may be a possible attack");
 362         goto out;
 363     case SSH_SERVER_FOUND_OTHER:
 364         ret = -EINVAL;
 365         error_setg(errp,
 366                    "host key for this server not found, another type exists");
 367         goto out;
 368     case SSH_SERVER_FILE_NOT_FOUND:
 369         ret = -ENOENT;
 370         error_setg(errp, "known_hosts file not found");
 371         goto out;
 372     case SSH_SERVER_NOT_KNOWN:
 373         ret = -EINVAL;
 374         error_setg(errp, "no host key was found in known_hosts");
 375         goto out;
 376     case SSH_SERVER_ERROR:
 377         ret = -EINVAL;
 378         error_setg(errp, "server error");
 379         goto out;
 380     default:
 381         ret = -EINVAL;
 382         error_setg(errp, "error while checking for known server (%d)", state);
 383         goto out;
 384     }
 385 #endif /* !HAVE_LIBSSH_0_8 */
 386
 387     /* known_hosts checking successful. */
 388     ret = 0;
 389
 390  out:
 391     return ret;
 392 }
 393
 394 static unsigned hex2decimal(char ch)
 395 {
 396     if (ch >= '0' && ch <= '9') {
 397         return (ch - '0');
 398     } else if (ch >= 'a' && ch <= 'f') {
 399         return 10 + (ch - 'a');
 400     } else if (ch >= 'A' && ch <= 'F') {
 401         return 10 + (ch - 'A');
 402     }
 403
 404     return -1;
 405 }
 406
 407 /* Compare the binary fingerprint (hash of host key) with the
 408  * host_key_check parameter.
 409  */
 410 static int compare_fingerprint(const unsigned char *fingerprint, size_t len,
 411                                const char *host_key_check)
 412 {
 413     unsigned c;
 414
 415     while (len > 0) {
 416         while (*host_key_check == ':')
 417             host_key_check++;
 418         if (!qemu_isxdigit(host_key_check[0]) ||
 419             !qemu_isxdigit(host_key_check[1]))
 420             return 1;
 421         c = hex2decimal(host_key_check[0]) * 16 +
 422             hex2decimal(host_key_check[1]);
 423         if (c - *fingerprint != 0)
 424             return c - *fingerprint;
 425         fingerprint++;
 426         len--;
 427         host_key_check += 2;
 428     }
 429     return *host_key_check - '\0';
 430 }
 431
 432 static int
 433 check_host_key_hash(BDRVSSHState *s, const char *hash,
 434                     enum ssh_publickey_hash_type type, Error **errp)
 435 {
 436     int r;
 437     ssh_key pubkey;
 438     unsigned char *server_hash;
 439     size_t server_hash_len;
 440
 441 #ifdef HAVE_LIBSSH_0_8
 442     r = ssh_get_server_publickey(s->session, &pubkey);
 443 #else
 444     r = ssh_get_publickey(s->session, &pubkey);
 445 #endif
 446     if (r != SSH_OK) {
 447         session_error_setg(errp, s, "failed to read remote host key");
 448         return -EINVAL;
 449     }
 450
 451     r = ssh_get_publickey_hash(pubkey, type, &server_hash, &server_hash_len);
 452     ssh_key_free(pubkey);
 453     if (r != 0) {
 454         session_error_setg(errp, s,
 455                            "failed reading the hash of the server SSH key");
 456         return -EINVAL;
 457     }
 458
 459     r = compare_fingerprint(server_hash, server_hash_len, hash);
 460     ssh_clean_pubkey_hash(&server_hash);
 461     if (r != 0) {
 462         error_setg(errp, "remote host key does not match host_key_check '%s'",
 463                    hash);
 464         return -EPERM;
 465     }
 466
 467     return 0;
 468 }
 469
 470 static int check_host_key(BDRVSSHState *s, SshHostKeyCheck *hkc, Error **errp)
 471 {
 472     SshHostKeyCheckMode mode;
 473
 474     if (hkc) {
 475         mode = hkc->mode;
 476     } else {
 477         mode = SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS;
 478     }
 479
 480     switch (mode) {
 481     case SSH_HOST_KEY_CHECK_MODE_NONE:
 482         return 0;
 483     case SSH_HOST_KEY_CHECK_MODE_HASH:
 484         if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_MD5) {
 485             return check_host_key_hash(s, hkc->u.hash.hash,
 486                                        SSH_PUBLICKEY_HASH_MD5, errp);
 487         } else if (hkc->u.hash.type == SSH_HOST_KEY_CHECK_HASH_TYPE_SHA1) {
 488             return check_host_key_hash(s, hkc->u.hash.hash,
 489                                        SSH_PUBLICKEY_HASH_SHA1, errp);
 490         }
 491         g_assert_not_reached();
 492         break;
 493     case SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS:
 494         return check_host_key_knownhosts(s, errp);
 495     default:
 496         g_assert_not_reached();
 497     }
 498
 499     return -EINVAL;
 500 }
 501
 502 static int authenticate(BDRVSSHState *s, Error **errp)
 503 {
 504     int r, ret;
 505     int method;
 506
 507     /* Try to authenticate with the "none" method. */
 508     r = ssh_userauth_none(s->session, NULL);
 509     if (r == SSH_AUTH_ERROR) {
 510         ret = -EPERM;
 511         session_error_setg(errp, s, "failed to authenticate using none "
 512                                     "authentication");
 513         goto out;
 514     } else if (r == SSH_AUTH_SUCCESS) {
 515         /* Authenticated! */
 516         ret = 0;
 517         goto out;
 518     }
 519
 520     method = ssh_userauth_list(s->session, NULL);
 521     trace_ssh_auth_methods(method);
 522
 523     /*
 524      * Try to authenticate with publickey, using the ssh-agent
 525      * if available.
 526      */
 527     if (method & SSH_AUTH_METHOD_PUBLICKEY) {
 528         r = ssh_userauth_publickey_auto(s->session, NULL, NULL);
 529         if (r == SSH_AUTH_ERROR) {
 530             ret = -EINVAL;
 531             session_error_setg(errp, s, "failed to authenticate using "
 532                                         "publickey authentication");
 533             goto out;
 534         } else if (r == SSH_AUTH_SUCCESS) {
 535             /* Authenticated! */
 536             ret = 0;
 537             goto out;
 538         }
 539     }
 540
 541     ret = -EPERM;
 542     error_setg(errp, "failed to authenticate using publickey authentication "
 543                "and the identities held by your ssh-agent");
 544
 545  out:
 546     return ret;
 547 }
 548
 549 static QemuOptsList ssh_runtime_opts = {
 550     .name = "ssh",
 551     .head = QTAILQ_HEAD_INITIALIZER(ssh_runtime_opts.head),
 552     .desc = {
 553         {
 554             .name = "host",
 555             .type = QEMU_OPT_STRING,
 556             .help = "Host to connect to",
 557         },
 558         {
 559             .name = "port",
 560             .type = QEMU_OPT_NUMBER,
 561             .help = "Port to connect to",
 562         },
 563         {
 564             .name = "host_key_check",
 565             .type = QEMU_OPT_STRING,
 566             .help = "Defines how and what to check the host key against",
 567         },
 568         { /* end of list */ }
 569     },
 570 };
 571
 572 static bool ssh_process_legacy_options(QDict *output_opts,
 573                                        QemuOpts *legacy_opts,
 574                                        Error **errp)
 575 {
 576     const char *host = qemu_opt_get(legacy_opts, "host");
 577     const char *port = qemu_opt_get(legacy_opts, "port");
 578     const char *host_key_check = qemu_opt_get(legacy_opts, "host_key_check");
 579
 580     if (!host && port) {
 581         error_setg(errp, "port may not be used without host");
 582         return false;
 583     }
 584
 585     if (host) {
 586         qdict_put_str(output_opts, "server.host", host);
 587         qdict_put_str(output_opts, "server.port", port ?: stringify(22));
 588     }
 589
 590     if (host_key_check) {
 591         if (strcmp(host_key_check, "no") == 0) {
 592             qdict_put_str(output_opts, "host-key-check.mode", "none");
 593         } else if (strncmp(host_key_check, "md5:", 4) == 0) {
 594             qdict_put_str(output_opts, "host-key-check.mode", "hash");
 595             qdict_put_str(output_opts, "host-key-check.type", "md5");
 596             qdict_put_str(output_opts, "host-key-check.hash",
 597                           &host_key_check[4]);
 598         } else if (strncmp(host_key_check, "sha1:", 5) == 0) {
 599             qdict_put_str(output_opts, "host-key-check.mode", "hash");
 600             qdict_put_str(output_opts, "host-key-check.type", "sha1");
 601             qdict_put_str(output_opts, "host-key-check.hash",
 602                           &host_key_check[5]);
 603         } else if (strcmp(host_key_check, "yes") == 0) {
 604             qdict_put_str(output_opts, "host-key-check.mode", "known_hosts");
 605         } else {
 606             error_setg(errp, "unknown host_key_check setting (%s)",
 607                        host_key_check);
 608             return false;
 609         }
 610     }
 611
 612     return true;
 613 }
 614
 615 static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
 616 {
 617     BlockdevOptionsSsh *result = NULL;
 618     QemuOpts *opts = NULL;
 619     Error *local_err = NULL;
 620     const QDictEntry *e;
 621     Visitor *v;
 622
 623     /* Translate legacy options */
 624     opts = qemu_opts_create(&ssh_runtime_opts, NULL, 0, &error_abort);
 625     qemu_opts_absorb_qdict(opts, options, &local_err);
 626     if (local_err) {
 627         error_propagate(errp, local_err);
 628         goto fail;
 629     }
 630
 631     if (!ssh_process_legacy_options(options, opts, errp)) {
 632         goto fail;
 633     }
 634
 635     /* Create the QAPI object */
 636     v = qobject_input_visitor_new_flat_confused(options, errp);
 637     if (!v) {
 638         goto fail;
 639     }
 640
 641     visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
 642     visit_free(v);
 643
 644     if (local_err) {
 645         error_propagate(errp, local_err);
 646         goto fail;
 647     }
 648
 649     /* Remove the processed options from the QDict (the visitor processes
 650      * _all_ options in the QDict) */
 651     while ((e = qdict_first(options))) {
 652         qdict_del(options, e->key);
 653     }
 654
 655 fail:
 656     qemu_opts_del(opts);
 657     return result;
 658 }
 659
 660 static int connect_to_ssh(BDRVSSHState *s, BlockdevOptionsSsh *opts,
 661                           int ssh_flags, int creat_mode, Error **errp)
 662 {
 663     int r, ret;
 664     unsigned int port = 0;
 665     int new_sock = -1;
 666
 667     if (opts->has_user) {
 668         s->user = g_strdup(opts->user);
 669     } else {
 670         s->user = g_strdup(g_get_user_name());
 671         if (!s->user) {
 672             error_setg_errno(errp, errno, "Can't get user name");
 673             ret = -errno;
 674             goto err;
 675         }
 676     }
 677
 678     /* Pop the config into our state object, Exit if invalid */
 679     s->inet = opts->server;
 680     opts->server = NULL;
 681
 682     if (qemu_strtoui(s->inet->port, NULL, 10, &port) < 0) {
 683         error_setg(errp, "Use only numeric port value");
 684         ret = -EINVAL;
 685         goto err;
 686     }
 687
 688     /* Open the socket and connect. */
 689     new_sock = inet_connect_saddr(s->inet, errp);
 690     if (new_sock < 0) {
 691         ret = -EIO;
 692         goto err;
 693     }
 694
 695     /*
 696      * Try to disable the Nagle algorithm on TCP sockets to reduce latency,
 697      * but do not fail if it cannot be disabled.
 698      */
 699     r = socket_set_nodelay(new_sock);
 700     if (r < 0) {
 701         warn_report("can't set TCP_NODELAY for the ssh server %s: %s",
 702                     s->inet->host, strerror(errno));
 703     }
 704
 705     /* Create SSH session. */
 706     s->session = ssh_new();
 707     if (!s->session) {
 708         ret = -EINVAL;
 709         session_error_setg(errp, s, "failed to initialize libssh session");
 710         goto err;
 711     }
 712
 713     /*
 714      * Make sure we are in blocking mode during the connection and
 715      * authentication phases.
 716      */
 717     ssh_set_blocking(s->session, 1);
 718
 719     r = ssh_options_set(s->session, SSH_OPTIONS_USER, s->user);
 720     if (r < 0) {
 721         ret = -EINVAL;
 722         session_error_setg(errp, s,
 723                            "failed to set the user in the libssh session");
 724         goto err;
 725     }
 726
 727     r = ssh_options_set(s->session, SSH_OPTIONS_HOST, s->inet->host);
 728     if (r < 0) {
 729         ret = -EINVAL;
 730         session_error_setg(errp, s,
 731                            "failed to set the host in the libssh session");
 732         goto err;
 733     }
 734
 735     if (port > 0) {
 736         r = ssh_options_set(s->session, SSH_OPTIONS_PORT, &port);
 737         if (r < 0) {
 738             ret = -EINVAL;
 739             session_error_setg(errp, s,
 740                                "failed to set the port in the libssh session");
 741             goto err;
 742         }
 743     }
 744
 745     r = ssh_options_set(s->session, SSH_OPTIONS_COMPRESSION, "none");
 746     if (r < 0) {
 747         ret = -EINVAL;
 748         session_error_setg(errp, s,
 749                            "failed to disable the compression in the libssh "
 750                            "session");
 751         goto err;
 752     }
 753
 754     /* Read ~/.ssh/config. */
 755     r = ssh_options_parse_config(s->session, NULL);
 756     if (r < 0) {
 757         ret = -EINVAL;
 758         session_error_setg(errp, s, "failed to parse ~/.ssh/config");
 759         goto err;
 760     }
 761
 762     r = ssh_options_set(s->session, SSH_OPTIONS_FD, &new_sock);
 763     if (r < 0) {
 764         ret = -EINVAL;
 765         session_error_setg(errp, s,
 766                            "failed to set the socket in the libssh session");
 767         goto err;
 768     }
 769     /* libssh took ownership of the socket. */
 770     s->sock = new_sock;
 771     new_sock = -1;
 772
 773     /* Connect. */
 774     r = ssh_connect(s->session);
 775     if (r != SSH_OK) {
 776         ret = -EINVAL;
 777         session_error_setg(errp, s, "failed to establish SSH session");
 778         goto err;
 779     }
 780
 781     /* Check the remote host's key against known_hosts. */
 782     ret = check_host_key(s, opts->host_key_check, errp);
 783     if (ret < 0) {
 784         goto err;
 785     }
 786
 787     /* Authenticate. */
 788     ret = authenticate(s, errp);
 789     if (ret < 0) {
 790         goto err;
 791     }
 792
 793     /* Start SFTP. */
 794     s->sftp = sftp_new(s->session);
 795     if (!s->sftp) {
 796         session_error_setg(errp, s, "failed to create sftp handle");
 797         ret = -EINVAL;
 798         goto err;
 799     }
 800
 801     r = sftp_init(s->sftp);
 802     if (r < 0) {
 803         sftp_error_setg(errp, s, "failed to initialize sftp handle");
 804         ret = -EINVAL;
 805         goto err;
 806     }
 807
 808     /* Open the remote file. */
 809     trace_ssh_connect_to_ssh(opts->path, ssh_flags, creat_mode);
 810     s->sftp_handle = sftp_open(s->sftp, opts->path, ssh_flags, creat_mode);
 811     if (!s->sftp_handle) {
 812         sftp_error_setg(errp, s, "failed to open remote file '%s'",
 813                         opts->path);
 814         ret = -EINVAL;
 815         goto err;
 816     }
 817
 818     /* Make sure the SFTP file is handled in blocking mode. */
 819     sftp_file_set_blocking(s->sftp_handle);
 820
 821     s->attrs = sftp_fstat(s->sftp_handle);
 822     if (!s->attrs) {
 823         sftp_error_setg(errp, s, "failed to read file attributes");
 824         return -EINVAL;
 825     }
 826
 827     return 0;
 828
 829  err:
 830     if (s->attrs) {
 831         sftp_attributes_free(s->attrs);
 832     }
 833     s->attrs = NULL;
 834     if (s->sftp_handle) {
 835         sftp_close(s->sftp_handle);
 836     }
 837     s->sftp_handle = NULL;
 838     if (s->sftp) {
 839         sftp_free(s->sftp);
 840     }
 841     s->sftp = NULL;
 842     if (s->session) {
 843         ssh_disconnect(s->session);
 844         ssh_free(s->session);
 845     }
 846     s->session = NULL;
 847     s->sock = -1;
 848     if (new_sock >= 0) {
 849         close(new_sock);
 850     }
 851
 852     return ret;
 853 }
 854
 855 static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
 856                          Error **errp)
 857 {
 858     BDRVSSHState *s = bs->opaque;
 859     BlockdevOptionsSsh *opts;
 860     int ret;
 861     int ssh_flags;
 862
 863     ssh_state_init(s);
 864
 865     ssh_flags = 0;
 866     if (bdrv_flags & BDRV_O_RDWR) {
 867         ssh_flags |= O_RDWR;
 868     } else {
 869         ssh_flags |= O_RDONLY;
 870     }
 871
 872     opts = ssh_parse_options(options, errp);
 873     if (opts == NULL) {
 874         return -EINVAL;
 875     }
 876
 877     /* Start up SSH. */
 878     ret = connect_to_ssh(s, opts, ssh_flags, 0, errp);
 879     if (ret < 0) {
 880         goto err;
 881     }
 882
 883     /* Go non-blocking. */
 884     ssh_set_blocking(s->session, 0);
 885
 886     qapi_free_BlockdevOptionsSsh(opts);
 887
 888     return 0;
 889
 890  err:
 891     qapi_free_BlockdevOptionsSsh(opts);
 892
 893     return ret;
 894 }
 895
 896 /* Note: This is a blocking operation */
 897 static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
 898 {
 899     ssize_t ret;
 900     char c[1] = { '\0' };
 901     int was_blocking = ssh_is_blocking(s->session);
 902
 903     /* offset must be strictly greater than the current size so we do
 904      * not overwrite anything */
 905     assert(offset > 0 && offset > s->attrs->size);
 906
 907     ssh_set_blocking(s->session, 1);
 908
 909     sftp_seek64(s->sftp_handle, offset - 1);
 910     ret = sftp_write(s->sftp_handle, c, 1);
 911
 912     ssh_set_blocking(s->session, was_blocking);
 913
 914     if (ret < 0) {
 915         sftp_error_setg(errp, s, "Failed to grow file");
 916         return -EIO;
 917     }
 918
 919     s->attrs->size = offset;
 920     return 0;
 921 }
 922
 923 static QemuOptsList ssh_create_opts = {
 924     .name = "ssh-create-opts",
 925     .head = QTAILQ_HEAD_INITIALIZER(ssh_create_opts.head),
 926     .desc = {
 927         {
 928             .name = BLOCK_OPT_SIZE,
 929             .type = QEMU_OPT_SIZE,
 930             .help = "Virtual disk size"
 931         },
 932         { /* end of list */ }
 933     }
 934 };
 935
 936 static int ssh_co_create(BlockdevCreateOptions *options, Error **errp)
 937 {
 938     BlockdevCreateOptionsSsh *opts = &options->u.ssh;
 939     BDRVSSHState s;
 940     int ret;
 941
 942     assert(options->driver == BLOCKDEV_DRIVER_SSH);
 943
 944     ssh_state_init(&s);
 945
 946     ret = connect_to_ssh(&s, opts->location,
 947                          O_RDWR | O_CREAT | O_TRUNC,
 948                          0644, errp);
 949     if (ret < 0) {
 950         goto fail;
 951     }
 952
 953     if (opts->size > 0) {
 954         ret = ssh_grow_file(&s, opts->size, errp);
 955         if (ret < 0) {
 956             goto fail;
 957         }
 958     }
 959
 960     ret = 0;
 961 fail:
 962     ssh_state_free(&s);
 963     return ret;
 964 }
 965
 966 static int coroutine_fn ssh_co_create_opts(const char *filename, QemuOpts *opts,
 967                                            Error **errp)
 968 {
 969     BlockdevCreateOptions *create_options;
 970     BlockdevCreateOptionsSsh *ssh_opts;
 971     int ret;
 972     QDict *uri_options = NULL;
 973
 974     create_options = g_new0(BlockdevCreateOptions, 1);
 975     create_options->driver = BLOCKDEV_DRIVER_SSH;
 976     ssh_opts = &create_options->u.ssh;
 977
 978     /* Get desired file size. */
 979     ssh_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 980                               BDRV_SECTOR_SIZE);
 981     trace_ssh_co_create_opts(ssh_opts->size);
 982
 983     uri_options = qdict_new();
 984     ret = parse_uri(filename, uri_options, errp);
 985     if (ret < 0) {
 986         goto out;
 987     }
 988
 989     ssh_opts->location = ssh_parse_options(uri_options, errp);
 990     if (ssh_opts->location == NULL) {
 991         ret = -EINVAL;
 992         goto out;
 993     }
 994
 995     ret = ssh_co_create(create_options, errp);
 996
 997  out:
 998     qobject_unref(uri_options);
 999     qapi_free_BlockdevCreateOptions(create_options);
1000     return ret;
1001 }
1002
1003 static void ssh_close(BlockDriverState *bs)
1004 {
1005     BDRVSSHState *s = bs->opaque;
1006
1007     ssh_state_free(s);
1008 }
1009
1010 static int ssh_has_zero_init(BlockDriverState *bs)
1011 {
1012     BDRVSSHState *s = bs->opaque;
1013     /* Assume false, unless we can positively prove it's true. */
1014     int has_zero_init = 0;
1015
1016     if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
1017         has_zero_init = 1;
1018     }
1019
1020     return has_zero_init;
1021 }
1022
1023 typedef struct BDRVSSHRestart {
1024     BlockDriverState *bs;
1025     Coroutine *co;
1026 } BDRVSSHRestart;
1027
1028 static void restart_coroutine(void *opaque)
1029 {
1030     BDRVSSHRestart *restart = opaque;
1031     BlockDriverState *bs = restart->bs;
1032     BDRVSSHState *s = bs->opaque;
1033     AioContext *ctx = bdrv_get_aio_context(bs);
1034
1035     trace_ssh_restart_coroutine(restart->co);
1036     aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL);
1037
1038     aio_co_wake(restart->co);
1039 }
1040
1041 /* A non-blocking call returned EAGAIN, so yield, ensuring the
1042  * handlers are set up so that we'll be rescheduled when there is an
1043  * interesting event on the socket.
1044  */
1045 static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
1046 {
1047     int r;
1048     IOHandler *rd_handler = NULL, *wr_handler = NULL;
1049     BDRVSSHRestart restart = {
1050         .bs = bs,
1051         .co = qemu_coroutine_self()
1052     };
1053
1054     r = ssh_get_poll_flags(s->session);
1055
1056     if (r & SSH_READ_PENDING) {
1057         rd_handler = restart_coroutine;
1058     }
1059     if (r & SSH_WRITE_PENDING) {
1060         wr_handler = restart_coroutine;
1061     }
1062
1063     trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
1064
1065     aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
1066                        false, rd_handler, wr_handler, NULL, &restart);
1067     qemu_coroutine_yield();
1068     trace_ssh_co_yield_back(s->sock);
1069 }
1070
1071 static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs,
1072                                  int64_t offset, size_t size,
1073                                  QEMUIOVector *qiov)
1074 {
1075     ssize_t r;
1076     size_t got;
1077     char *buf, *end_of_vec;
1078     struct iovec *i;
1079
1080     trace_ssh_read(offset, size);
1081
1082     trace_ssh_seek(offset);
1083     sftp_seek64(s->sftp_handle, offset);
1084
1085     /* This keeps track of the current iovec element ('i'), where we
1086      * will write to next ('buf'), and the end of the current iovec
1087      * ('end_of_vec').
1088      */
1089     i = &qiov->iov[0];
1090     buf = i->iov_base;
1091     end_of_vec = i->iov_base + i->iov_len;
1092
1093     for (got = 0; got < size; ) {
1094         size_t request_read_size;
1095     again:
1096         /*
1097          * The size of SFTP packets is limited to 32K bytes, so limit
1098          * the amount of data requested to 16K, as libssh currently
1099          * does not handle multiple requests on its own.
1100          */
1101         request_read_size = MIN(end_of_vec - buf, 16384);
1102         trace_ssh_read_buf(buf, end_of_vec - buf, request_read_size);
1103         r = sftp_read(s->sftp_handle, buf, request_read_size);
1104         trace_ssh_read_return(r, sftp_get_error(s->sftp));
1105
1106         if (r == SSH_AGAIN) {
1107             co_yield(s, bs);
1108             goto again;
1109         }
1110         if (r == SSH_EOF || (r == 0 && sftp_get_error(s->sftp) == SSH_FX_EOF)) {
1111             /* EOF: Short read so pad the buffer with zeroes and return it. */
1112             qemu_iovec_memset(qiov, got, 0, size - got);
1113             return 0;
1114         }
1115         if (r <= 0) {
1116             sftp_error_trace(s, "read");
1117             return -EIO;
1118         }
1119
1120         got += r;
1121         buf += r;
1122         if (buf >= end_of_vec && got < size) {
1123             i++;
1124             buf = i->iov_base;
1125             end_of_vec = i->iov_base + i->iov_len;
1126         }
1127     }
1128
1129     return 0;
1130 }
1131
1132 static coroutine_fn int ssh_co_readv(BlockDriverState *bs,
1133                                      int64_t sector_num,
1134                                      int nb_sectors, QEMUIOVector *qiov)
1135 {
1136     BDRVSSHState *s = bs->opaque;
1137     int ret;
1138
1139     qemu_co_mutex_lock(&s->lock);
1140     ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE,
1141                    nb_sectors * BDRV_SECTOR_SIZE, qiov);
1142     qemu_co_mutex_unlock(&s->lock);
1143
1144     return ret;
1145 }
1146
1147 static int ssh_write(BDRVSSHState *s, BlockDriverState *bs,
1148                      int64_t offset, size_t size,
1149                      QEMUIOVector *qiov)
1150 {
1151     ssize_t r;
1152     size_t written;
1153     char *buf, *end_of_vec;
1154     struct iovec *i;
1155
1156     trace_ssh_write(offset, size);
1157
1158     trace_ssh_seek(offset);
1159     sftp_seek64(s->sftp_handle, offset);
1160
1161     /* This keeps track of the current iovec element ('i'), where we
1162      * will read from next ('buf'), and the end of the current iovec
1163      * ('end_of_vec').
1164      */
1165     i = &qiov->iov[0];
1166     buf = i->iov_base;
1167     end_of_vec = i->iov_base + i->iov_len;
1168
1169     for (written = 0; written < size; ) {
1170         size_t request_write_size;
1171     again:
1172         /*
1173          * Avoid too large data packets, as libssh currently does not
1174          * handle multiple requests on its own.
1175          */
1176         request_write_size = MIN(end_of_vec - buf, 131072);
1177         trace_ssh_write_buf(buf, end_of_vec - buf, request_write_size);
1178         r = sftp_write(s->sftp_handle, buf, request_write_size);
1179         trace_ssh_write_return(r, sftp_get_error(s->sftp));
1180
1181         if (r == SSH_AGAIN) {
1182             co_yield(s, bs);
1183             goto again;
1184         }
1185         if (r < 0) {
1186             sftp_error_trace(s, "write");
1187             return -EIO;
1188         }
1189
1190         written += r;
1191         buf += r;
1192         if (buf >= end_of_vec && written < size) {
1193             i++;
1194             buf = i->iov_base;
1195             end_of_vec = i->iov_base + i->iov_len;
1196         }
1197
1198         if (offset + written > s->attrs->size) {
1199             s->attrs->size = offset + written;
1200         }
1201     }
1202
1203     return 0;
1204 }
1205
1206 static coroutine_fn int ssh_co_writev(BlockDriverState *bs,
1207                                       int64_t sector_num,
1208                                       int nb_sectors, QEMUIOVector *qiov,
1209                                       int flags)
1210 {
1211     BDRVSSHState *s = bs->opaque;
1212     int ret;
1213
1214     assert(!flags);
1215     qemu_co_mutex_lock(&s->lock);
1216     ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE,
1217                     nb_sectors * BDRV_SECTOR_SIZE, qiov);
1218     qemu_co_mutex_unlock(&s->lock);
1219
1220     return ret;
1221 }
1222
1223 static void unsafe_flush_warning(BDRVSSHState *s, const char *what)
1224 {
1225     if (!s->unsafe_flush_warning) {
1226         warn_report("ssh server %s does not support fsync",
1227                     s->inet->host);
1228         if (what) {
1229             error_report("to support fsync, you need %s", what);
1230         }
1231         s->unsafe_flush_warning = true;
1232     }
1233 }
1234
1235 #ifdef HAVE_LIBSSH_0_8
1236
1237 static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs)
1238 {
1239     int r;
1240
1241     trace_ssh_flush();
1242
1243     if (!sftp_extension_supported(s->sftp, "[email protected]", "1")) {
1244         unsafe_flush_warning(s, "OpenSSH >= 6.3");
1245         return 0;
1246     }
1247  again:
1248     r = sftp_fsync(s->sftp_handle);
1249     if (r == SSH_AGAIN) {
1250         co_yield(s, bs);
1251         goto again;
1252     }
1253     if (r < 0) {
1254         sftp_error_trace(s, "fsync");
1255         return -EIO;
1256     }
1257
1258     return 0;
1259 }
1260
1261 static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1262 {
1263     BDRVSSHState *s = bs->opaque;
1264     int ret;
1265
1266     qemu_co_mutex_lock(&s->lock);
1267     ret = ssh_flush(s, bs);
1268     qemu_co_mutex_unlock(&s->lock);
1269
1270     return ret;
1271 }
1272
1273 #else /* !HAVE_LIBSSH_0_8 */
1274
1275 static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1276 {
1277     BDRVSSHState *s = bs->opaque;
1278
1279     unsafe_flush_warning(s, "libssh >= 0.8.0");
1280     return 0;
1281 }
1282
1283 #endif /* !HAVE_LIBSSH_0_8 */
1284
1285 static int64_t ssh_getlength(BlockDriverState *bs)
1286 {
1287     BDRVSSHState *s = bs->opaque;
1288     int64_t length;
1289
1290     /* Note we cannot make a libssh call here. */
1291     length = (int64_t) s->attrs->size;
1292     trace_ssh_getlength(length);
1293
1294     return length;
1295 }
1296
1297 static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
1298                                         bool exact, PreallocMode prealloc,
1299                                         Error **errp)
1300 {
1301     BDRVSSHState *s = bs->opaque;
1302
1303     if (prealloc != PREALLOC_MODE_OFF) {
1304         error_setg(errp, "Unsupported preallocation mode '%s'",
1305                    PreallocMode_str(prealloc));
1306         return -ENOTSUP;
1307     }
1308
1309     if (offset < s->attrs->size) {
1310         error_setg(errp, "ssh driver does not support shrinking files");
1311         return -ENOTSUP;
1312     }
1313
1314     if (offset == s->attrs->size) {
1315         return 0;
1316     }
1317
1318     return ssh_grow_file(s, offset, errp);
1319 }
1320
1321 static void ssh_refresh_filename(BlockDriverState *bs)
1322 {
1323     BDRVSSHState *s = bs->opaque;
1324     const char *path, *host_key_check;
1325     int ret;
1326
1327     /*
1328      * None of these options can be represented in a plain "host:port"
1329      * format, so if any was given, we have to abort.
1330      */
1331     if (s->inet->has_ipv4 || s->inet->has_ipv6 || s->inet->has_to ||
1332         s->inet->has_numeric)
1333     {
1334         return;
1335     }
1336
1337     path = qdict_get_try_str(bs->full_open_options, "path");
1338     assert(path); /* mandatory option */
1339
1340     host_key_check = qdict_get_try_str(bs->full_open_options, "host_key_check");
1341
1342     ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
1343                    "ssh://%s@%s:%s%s%s%s",
1344                    s->user, s->inet->host, s->inet->port, path,
1345                    host_key_check ? "?host_key_check=" : "",
1346                    host_key_check ?: "");
1347     if (ret >= sizeof(bs->exact_filename)) {
1348         /* An overflow makes the filename unusable, so do not report any */
1349         bs->exact_filename[0] = '\0';
1350     }
1351 }
1352
1353 static char *ssh_bdrv_dirname(BlockDriverState *bs, Error **errp)
1354 {
1355     if (qdict_haskey(bs->full_open_options, "host_key_check")) {
1356         /*
1357          * We cannot generate a simple prefix if we would have to
1358          * append a query string.
1359          */
1360         error_setg(errp,
1361                    "Cannot generate a base directory with host_key_check set");
1362         return NULL;
1363     }
1364
1365     if (bs->exact_filename[0] == '\0') {
1366         error_setg(errp, "Cannot generate a base directory for this ssh node");
1367         return NULL;
1368     }
1369
1370     return path_combine(bs->exact_filename, "");
1371 }
1372
1373 static const char *const ssh_strong_runtime_opts[] = {
1374     "host",
1375     "port",
1376     "path",
1377     "user",
1378     "host_key_check",
1379     "server.",
1380
1381     NULL
1382 };
1383
1384 static BlockDriver bdrv_ssh = {
1385     .format_name                  = "ssh",
1386     .protocol_name                = "ssh",
1387     .instance_size                = sizeof(BDRVSSHState),
1388     .bdrv_parse_filename          = ssh_parse_filename,
1389     .bdrv_file_open               = ssh_file_open,
1390     .bdrv_co_create               = ssh_co_create,
1391     .bdrv_co_create_opts          = ssh_co_create_opts,
1392     .bdrv_close                   = ssh_close,
1393     .bdrv_has_zero_init           = ssh_has_zero_init,
1394     .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
1395     .bdrv_co_readv                = ssh_co_readv,
1396     .bdrv_co_writev               = ssh_co_writev,
1397     .bdrv_getlength               = ssh_getlength,
1398     .bdrv_co_truncate             = ssh_co_truncate,
1399     .bdrv_co_flush_to_disk        = ssh_co_flush,
1400     .bdrv_refresh_filename        = ssh_refresh_filename,
1401     .bdrv_dirname                 = ssh_bdrv_dirname,
1402     .create_opts                  = &ssh_create_opts,
1403     .strong_runtime_opts          = ssh_strong_runtime_opts,
1404 };
1405
1406 static void bdrv_ssh_init(void)
1407 {
1408     int r;
1409
1410     r = ssh_init();
1411     if (r != 0) {
1412         fprintf(stderr, "libssh initialization failed, %d\n", r);
1413         exit(EXIT_FAILURE);
1414     }
1415
1416 #if TRACE_LIBSSH != 0
1417     ssh_set_log_level(TRACE_LIBSSH);
1418 #endif
1419
1420     bdrv_register(&bdrv_ssh);
1421 }
1422
1423 block_init(bdrv_ssh_init);