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(BlockDriver *drv,
 967                                            const char *filename,
 968                                            QemuOpts *opts,
 969                                            Error **errp)
 970 {
 971     BlockdevCreateOptions *create_options;
 972     BlockdevCreateOptionsSsh *ssh_opts;
 973     int ret;
 974     QDict *uri_options = NULL;
 975
 976     create_options = g_new0(BlockdevCreateOptions, 1);
 977     create_options->driver = BLOCKDEV_DRIVER_SSH;
 978     ssh_opts = &create_options->u.ssh;
 979
 980     /* Get desired file size. */
 981     ssh_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 982                               BDRV_SECTOR_SIZE);
 983     trace_ssh_co_create_opts(ssh_opts->size);
 984
 985     uri_options = qdict_new();
 986     ret = parse_uri(filename, uri_options, errp);
 987     if (ret < 0) {
 988         goto out;
 989     }
 990
 991     ssh_opts->location = ssh_parse_options(uri_options, errp);
 992     if (ssh_opts->location == NULL) {
 993         ret = -EINVAL;
 994         goto out;
 995     }
 996
 997     ret = ssh_co_create(create_options, errp);
 998
 999  out:
1000     qobject_unref(uri_options);
1001     qapi_free_BlockdevCreateOptions(create_options);
1002     return ret;
1003 }
1004
1005 static void ssh_close(BlockDriverState *bs)
1006 {
1007     BDRVSSHState *s = bs->opaque;
1008
1009     ssh_state_free(s);
1010 }
1011
1012 static int ssh_has_zero_init(BlockDriverState *bs)
1013 {
1014     BDRVSSHState *s = bs->opaque;
1015     /* Assume false, unless we can positively prove it's true. */
1016     int has_zero_init = 0;
1017
1018     if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
1019         has_zero_init = 1;
1020     }
1021
1022     return has_zero_init;
1023 }
1024
1025 typedef struct BDRVSSHRestart {
1026     BlockDriverState *bs;
1027     Coroutine *co;
1028 } BDRVSSHRestart;
1029
1030 static void restart_coroutine(void *opaque)
1031 {
1032     BDRVSSHRestart *restart = opaque;
1033     BlockDriverState *bs = restart->bs;
1034     BDRVSSHState *s = bs->opaque;
1035     AioContext *ctx = bdrv_get_aio_context(bs);
1036
1037     trace_ssh_restart_coroutine(restart->co);
1038     aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL);
1039
1040     aio_co_wake(restart->co);
1041 }
1042
1043 /* A non-blocking call returned EAGAIN, so yield, ensuring the
1044  * handlers are set up so that we'll be rescheduled when there is an
1045  * interesting event on the socket.
1046  */
1047 static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
1048 {
1049     int r;
1050     IOHandler *rd_handler = NULL, *wr_handler = NULL;
1051     BDRVSSHRestart restart = {
1052         .bs = bs,
1053         .co = qemu_coroutine_self()
1054     };
1055
1056     r = ssh_get_poll_flags(s->session);
1057
1058     if (r & SSH_READ_PENDING) {
1059         rd_handler = restart_coroutine;
1060     }
1061     if (r & SSH_WRITE_PENDING) {
1062         wr_handler = restart_coroutine;
1063     }
1064
1065     trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
1066
1067     aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
1068                        false, rd_handler, wr_handler, NULL, &restart);
1069     qemu_coroutine_yield();
1070     trace_ssh_co_yield_back(s->sock);
1071 }
1072
1073 static coroutine_fn int ssh_read(BDRVSSHState *s, BlockDriverState *bs,
1074                                  int64_t offset, size_t size,
1075                                  QEMUIOVector *qiov)
1076 {
1077     ssize_t r;
1078     size_t got;
1079     char *buf, *end_of_vec;
1080     struct iovec *i;
1081
1082     trace_ssh_read(offset, size);
1083
1084     trace_ssh_seek(offset);
1085     sftp_seek64(s->sftp_handle, offset);
1086
1087     /* This keeps track of the current iovec element ('i'), where we
1088      * will write to next ('buf'), and the end of the current iovec
1089      * ('end_of_vec').
1090      */
1091     i = &qiov->iov[0];
1092     buf = i->iov_base;
1093     end_of_vec = i->iov_base + i->iov_len;
1094
1095     for (got = 0; got < size; ) {
1096         size_t request_read_size;
1097     again:
1098         /*
1099          * The size of SFTP packets is limited to 32K bytes, so limit
1100          * the amount of data requested to 16K, as libssh currently
1101          * does not handle multiple requests on its own.
1102          */
1103         request_read_size = MIN(end_of_vec - buf, 16384);
1104         trace_ssh_read_buf(buf, end_of_vec - buf, request_read_size);
1105         r = sftp_read(s->sftp_handle, buf, request_read_size);
1106         trace_ssh_read_return(r, sftp_get_error(s->sftp));
1107
1108         if (r == SSH_AGAIN) {
1109             co_yield(s, bs);
1110             goto again;
1111         }
1112         if (r == SSH_EOF || (r == 0 && sftp_get_error(s->sftp) == SSH_FX_EOF)) {
1113             /* EOF: Short read so pad the buffer with zeroes and return it. */
1114             qemu_iovec_memset(qiov, got, 0, size - got);
1115             return 0;
1116         }
1117         if (r <= 0) {
1118             sftp_error_trace(s, "read");
1119             return -EIO;
1120         }
1121
1122         got += r;
1123         buf += r;
1124         if (buf >= end_of_vec && got < size) {
1125             i++;
1126             buf = i->iov_base;
1127             end_of_vec = i->iov_base + i->iov_len;
1128         }
1129     }
1130
1131     return 0;
1132 }
1133
1134 static coroutine_fn int ssh_co_readv(BlockDriverState *bs,
1135                                      int64_t sector_num,
1136                                      int nb_sectors, QEMUIOVector *qiov)
1137 {
1138     BDRVSSHState *s = bs->opaque;
1139     int ret;
1140
1141     qemu_co_mutex_lock(&s->lock);
1142     ret = ssh_read(s, bs, sector_num * BDRV_SECTOR_SIZE,
1143                    nb_sectors * BDRV_SECTOR_SIZE, qiov);
1144     qemu_co_mutex_unlock(&s->lock);
1145
1146     return ret;
1147 }
1148
1149 static int ssh_write(BDRVSSHState *s, BlockDriverState *bs,
1150                      int64_t offset, size_t size,
1151                      QEMUIOVector *qiov)
1152 {
1153     ssize_t r;
1154     size_t written;
1155     char *buf, *end_of_vec;
1156     struct iovec *i;
1157
1158     trace_ssh_write(offset, size);
1159
1160     trace_ssh_seek(offset);
1161     sftp_seek64(s->sftp_handle, offset);
1162
1163     /* This keeps track of the current iovec element ('i'), where we
1164      * will read from next ('buf'), and the end of the current iovec
1165      * ('end_of_vec').
1166      */
1167     i = &qiov->iov[0];
1168     buf = i->iov_base;
1169     end_of_vec = i->iov_base + i->iov_len;
1170
1171     for (written = 0; written < size; ) {
1172         size_t request_write_size;
1173     again:
1174         /*
1175          * Avoid too large data packets, as libssh currently does not
1176          * handle multiple requests on its own.
1177          */
1178         request_write_size = MIN(end_of_vec - buf, 131072);
1179         trace_ssh_write_buf(buf, end_of_vec - buf, request_write_size);
1180         r = sftp_write(s->sftp_handle, buf, request_write_size);
1181         trace_ssh_write_return(r, sftp_get_error(s->sftp));
1182
1183         if (r == SSH_AGAIN) {
1184             co_yield(s, bs);
1185             goto again;
1186         }
1187         if (r < 0) {
1188             sftp_error_trace(s, "write");
1189             return -EIO;
1190         }
1191
1192         written += r;
1193         buf += r;
1194         if (buf >= end_of_vec && written < size) {
1195             i++;
1196             buf = i->iov_base;
1197             end_of_vec = i->iov_base + i->iov_len;
1198         }
1199
1200         if (offset + written > s->attrs->size) {
1201             s->attrs->size = offset + written;
1202         }
1203     }
1204
1205     return 0;
1206 }
1207
1208 static coroutine_fn int ssh_co_writev(BlockDriverState *bs,
1209                                       int64_t sector_num,
1210                                       int nb_sectors, QEMUIOVector *qiov,
1211                                       int flags)
1212 {
1213     BDRVSSHState *s = bs->opaque;
1214     int ret;
1215
1216     assert(!flags);
1217     qemu_co_mutex_lock(&s->lock);
1218     ret = ssh_write(s, bs, sector_num * BDRV_SECTOR_SIZE,
1219                     nb_sectors * BDRV_SECTOR_SIZE, qiov);
1220     qemu_co_mutex_unlock(&s->lock);
1221
1222     return ret;
1223 }
1224
1225 static void unsafe_flush_warning(BDRVSSHState *s, const char *what)
1226 {
1227     if (!s->unsafe_flush_warning) {
1228         warn_report("ssh server %s does not support fsync",
1229                     s->inet->host);
1230         if (what) {
1231             error_report("to support fsync, you need %s", what);
1232         }
1233         s->unsafe_flush_warning = true;
1234     }
1235 }
1236
1237 #ifdef HAVE_LIBSSH_0_8
1238
1239 static coroutine_fn int ssh_flush(BDRVSSHState *s, BlockDriverState *bs)
1240 {
1241     int r;
1242
1243     trace_ssh_flush();
1244
1245     if (!sftp_extension_supported(s->sftp, "[email protected]", "1")) {
1246         unsafe_flush_warning(s, "OpenSSH >= 6.3");
1247         return 0;
1248     }
1249  again:
1250     r = sftp_fsync(s->sftp_handle);
1251     if (r == SSH_AGAIN) {
1252         co_yield(s, bs);
1253         goto again;
1254     }
1255     if (r < 0) {
1256         sftp_error_trace(s, "fsync");
1257         return -EIO;
1258     }
1259
1260     return 0;
1261 }
1262
1263 static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1264 {
1265     BDRVSSHState *s = bs->opaque;
1266     int ret;
1267
1268     qemu_co_mutex_lock(&s->lock);
1269     ret = ssh_flush(s, bs);
1270     qemu_co_mutex_unlock(&s->lock);
1271
1272     return ret;
1273 }
1274
1275 #else /* !HAVE_LIBSSH_0_8 */
1276
1277 static coroutine_fn int ssh_co_flush(BlockDriverState *bs)
1278 {
1279     BDRVSSHState *s = bs->opaque;
1280
1281     unsafe_flush_warning(s, "libssh >= 0.8.0");
1282     return 0;
1283 }
1284
1285 #endif /* !HAVE_LIBSSH_0_8 */
1286
1287 static int64_t ssh_getlength(BlockDriverState *bs)
1288 {
1289     BDRVSSHState *s = bs->opaque;
1290     int64_t length;
1291
1292     /* Note we cannot make a libssh call here. */
1293     length = (int64_t) s->attrs->size;
1294     trace_ssh_getlength(length);
1295
1296     return length;
1297 }
1298
1299 static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
1300                                         bool exact, PreallocMode prealloc,
1301                                         BdrvRequestFlags flags, Error **errp)
1302 {
1303     BDRVSSHState *s = bs->opaque;
1304
1305     if (prealloc != PREALLOC_MODE_OFF) {
1306         error_setg(errp, "Unsupported preallocation mode '%s'",
1307                    PreallocMode_str(prealloc));
1308         return -ENOTSUP;
1309     }
1310
1311     if (offset < s->attrs->size) {
1312         error_setg(errp, "ssh driver does not support shrinking files");
1313         return -ENOTSUP;
1314     }
1315
1316     if (offset == s->attrs->size) {
1317         return 0;
1318     }
1319
1320     return ssh_grow_file(s, offset, errp);
1321 }
1322
1323 static void ssh_refresh_filename(BlockDriverState *bs)
1324 {
1325     BDRVSSHState *s = bs->opaque;
1326     const char *path, *host_key_check;
1327     int ret;
1328
1329     /*
1330      * None of these options can be represented in a plain "host:port"
1331      * format, so if any was given, we have to abort.
1332      */
1333     if (s->inet->has_ipv4 || s->inet->has_ipv6 || s->inet->has_to ||
1334         s->inet->has_numeric)
1335     {
1336         return;
1337     }
1338
1339     path = qdict_get_try_str(bs->full_open_options, "path");
1340     assert(path); /* mandatory option */
1341
1342     host_key_check = qdict_get_try_str(bs->full_open_options, "host_key_check");
1343
1344     ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
1345                    "ssh://%s@%s:%s%s%s%s",
1346                    s->user, s->inet->host, s->inet->port, path,
1347                    host_key_check ? "?host_key_check=" : "",
1348                    host_key_check ?: "");
1349     if (ret >= sizeof(bs->exact_filename)) {
1350         /* An overflow makes the filename unusable, so do not report any */
1351         bs->exact_filename[0] = '\0';
1352     }
1353 }
1354
1355 static char *ssh_bdrv_dirname(BlockDriverState *bs, Error **errp)
1356 {
1357     if (qdict_haskey(bs->full_open_options, "host_key_check")) {
1358         /*
1359          * We cannot generate a simple prefix if we would have to
1360          * append a query string.
1361          */
1362         error_setg(errp,
1363                    "Cannot generate a base directory with host_key_check set");
1364         return NULL;
1365     }
1366
1367     if (bs->exact_filename[0] == '\0') {
1368         error_setg(errp, "Cannot generate a base directory for this ssh node");
1369         return NULL;
1370     }
1371
1372     return path_combine(bs->exact_filename, "");
1373 }
1374
1375 static const char *const ssh_strong_runtime_opts[] = {
1376     "host",
1377     "port",
1378     "path",
1379     "user",
1380     "host_key_check",
1381     "server.",
1382
1383     NULL
1384 };
1385
1386 static BlockDriver bdrv_ssh = {
1387     .format_name                  = "ssh",
1388     .protocol_name                = "ssh",
1389     .instance_size                = sizeof(BDRVSSHState),
1390     .bdrv_parse_filename          = ssh_parse_filename,
1391     .bdrv_file_open               = ssh_file_open,
1392     .bdrv_co_create               = ssh_co_create,
1393     .bdrv_co_create_opts          = ssh_co_create_opts,
1394     .bdrv_close                   = ssh_close,
1395     .bdrv_has_zero_init           = ssh_has_zero_init,
1396     .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
1397     .bdrv_co_readv                = ssh_co_readv,
1398     .bdrv_co_writev               = ssh_co_writev,
1399     .bdrv_getlength               = ssh_getlength,
1400     .bdrv_co_truncate             = ssh_co_truncate,
1401     .bdrv_co_flush_to_disk        = ssh_co_flush,
1402     .bdrv_refresh_filename        = ssh_refresh_filename,
1403     .bdrv_dirname                 = ssh_bdrv_dirname,
1404     .create_opts                  = &ssh_create_opts,
1405     .strong_runtime_opts          = ssh_strong_runtime_opts,
1406 };
1407
1408 static void bdrv_ssh_init(void)
1409 {
1410     int r;
1411
1412     r = ssh_init();
1413     if (r != 0) {
1414         fprintf(stderr, "libssh initialization failed, %d\n", r);
1415         exit(EXIT_FAILURE);
1416     }
1417
1418 #if TRACE_LIBSSH != 0
1419     ssh_set_log_level(TRACE_LIBSSH);
1420 #endif
1421
1422     bdrv_register(&bdrv_ssh);
1423 }
1424
1425 block_init(bdrv_ssh_init);