nbd/client.c

   1 /*
   2  *  Copyright (C) 2016-2017 Red Hat, Inc.
   3  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   4  *
   5  *  Network Block Device Client Side
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; under version 2 of the License.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "qapi/error.h"
  22 #include "trace.h"
  23 #include "nbd-internal.h"
  24
  25 /* Definitions for opaque data types */
  26
  27 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
  28
  29 /* That's all folks */
  30
  31 /* Basic flow for negotiation
  32
  33    Server         Client
  34    Negotiate
  35
  36    or
  37
  38    Server         Client
  39    Negotiate #1
  40                   Option
  41    Negotiate #2
  42
  43    ----
  44
  45    followed by
  46
  47    Server         Client
  48                   Request
  49    Response
  50                   Request
  51    Response
  52                   ...
  53    ...
  54                   Request (type == 2)
  55
  56 */
  57
  58 /* Send an option request.
  59  *
  60  * The request is for option @opt, with @data containing @len bytes of
  61  * additional payload for the request (@len may be -1 to treat @data as
  62  * a C string; and @data may be NULL if @len is 0).
  63  * Return 0 if successful, -1 with errp set if it is impossible to
  64  * continue. */
  65 static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt,
  66                                    uint32_t len, const char *data,
  67                                    Error **errp)
  68 {
  69     nbd_option req;
  70     QEMU_BUILD_BUG_ON(sizeof(req) != 16);
  71
  72     if (len == -1) {
  73         req.length = len = strlen(data);
  74     }
  75     trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len);
  76
  77     stq_be_p(&req.magic, NBD_OPTS_MAGIC);
  78     stl_be_p(&req.option, opt);
  79     stl_be_p(&req.length, len);
  80
  81     if (nbd_write(ioc, &req, sizeof(req), errp) < 0) {
  82         error_prepend(errp, "Failed to send option request header");
  83         return -1;
  84     }
  85
  86     if (len && nbd_write(ioc, (char *) data, len, errp) < 0) {
  87         error_prepend(errp, "Failed to send option request data");
  88         return -1;
  89     }
  90
  91     return 0;
  92 }
  93
  94 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
  95  * not going to attempt further negotiation. */
  96 static void nbd_send_opt_abort(QIOChannel *ioc)
  97 {
  98     /* Technically, a compliant server is supposed to reply to us; but
  99      * older servers disconnected instead. At any rate, we're allowed
 100      * to disconnect without waiting for the server reply, so we don't
 101      * even care if the request makes it to the server, let alone
 102      * waiting around for whether the server replies. */
 103     nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL);
 104 }
 105
 106
 107 /* Receive the header of an option reply, which should match the given
 108  * opt.  Read through the length field, but NOT the length bytes of
 109  * payload. Return 0 if successful, -1 with errp set if it is
 110  * impossible to continue. */
 111 static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,
 112                                     nbd_opt_reply *reply, Error **errp)
 113 {
 114     QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);
 115     if (nbd_read(ioc, reply, sizeof(*reply), errp) < 0) {
 116         error_prepend(errp, "failed to read option reply");
 117         nbd_send_opt_abort(ioc);
 118         return -1;
 119     }
 120     be64_to_cpus(&reply->magic);
 121     be32_to_cpus(&reply->option);
 122     be32_to_cpus(&reply->type);
 123     be32_to_cpus(&reply->length);
 124
 125     trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option),
 126                                    reply->type, nbd_rep_lookup(reply->type),
 127                                    reply->length);
 128
 129     if (reply->magic != NBD_REP_MAGIC) {
 130         error_setg(errp, "Unexpected option reply magic");
 131         nbd_send_opt_abort(ioc);
 132         return -1;
 133     }
 134     if (reply->option != opt) {
 135         error_setg(errp, "Unexpected option type %x expected %x",
 136                    reply->option, opt);
 137         nbd_send_opt_abort(ioc);
 138         return -1;
 139     }
 140     return 0;
 141 }
 142
 143 /* If reply represents success, return 1 without further action.
 144  * If reply represents an error, consume the optional payload of
 145  * the packet on ioc.  Then return 0 for unsupported (so the client
 146  * can fall back to other approaches), or -1 with errp set for other
 147  * errors.
 148  */
 149 static int nbd_handle_reply_err(QIOChannel *ioc, nbd_opt_reply *reply,
 150                                 Error **errp)
 151 {
 152     char *msg = NULL;
 153     int result = -1;
 154
 155     if (!(reply->type & (1 << 31))) {
 156         return 1;
 157     }
 158
 159     if (reply->length) {
 160         if (reply->length > NBD_MAX_BUFFER_SIZE) {
 161             error_setg(errp, "server error 0x%" PRIx32
 162                        " (%s) message is too long",
 163                        reply->type, nbd_rep_lookup(reply->type));
 164             goto cleanup;
 165         }
 166         msg = g_malloc(reply->length + 1);
 167         if (nbd_read(ioc, msg, reply->length, errp) < 0) {
 168             error_prepend(errp, "failed to read option error 0x%" PRIx32
 169                           " (%s) message",
 170                           reply->type, nbd_rep_lookup(reply->type));
 171             goto cleanup;
 172         }
 173         msg[reply->length] = '\0';
 174     }
 175
 176     switch (reply->type) {
 177     case NBD_REP_ERR_UNSUP:
 178         trace_nbd_reply_err_unsup(reply->option, nbd_opt_lookup(reply->option));
 179         result = 0;
 180         goto cleanup;
 181
 182     case NBD_REP_ERR_POLICY:
 183         error_setg(errp, "Denied by server for option %" PRIx32 " (%s)",
 184                    reply->option, nbd_opt_lookup(reply->option));
 185         break;
 186
 187     case NBD_REP_ERR_INVALID:
 188         error_setg(errp, "Invalid data length for option %" PRIx32 " (%s)",
 189                    reply->option, nbd_opt_lookup(reply->option));
 190         break;
 191
 192     case NBD_REP_ERR_PLATFORM:
 193         error_setg(errp, "Server lacks support for option %" PRIx32 " (%s)",
 194                    reply->option, nbd_opt_lookup(reply->option));
 195         break;
 196
 197     case NBD_REP_ERR_TLS_REQD:
 198         error_setg(errp, "TLS negotiation required before option %" PRIx32
 199                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 200         break;
 201
 202     case NBD_REP_ERR_UNKNOWN:
 203         error_setg(errp, "Requested export not available");
 204         break;
 205
 206     case NBD_REP_ERR_SHUTDOWN:
 207         error_setg(errp, "Server shutting down before option %" PRIx32 " (%s)",
 208                    reply->option, nbd_opt_lookup(reply->option));
 209         break;
 210
 211     case NBD_REP_ERR_BLOCK_SIZE_REQD:
 212         error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIx32
 213                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 214         break;
 215
 216     default:
 217         error_setg(errp, "Unknown error code when asking for option %" PRIx32
 218                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 219         break;
 220     }
 221
 222     if (msg) {
 223         error_append_hint(errp, "server reported: %s\n", msg);
 224     }
 225
 226  cleanup:
 227     g_free(msg);
 228     if (result < 0) {
 229         nbd_send_opt_abort(ioc);
 230     }
 231     return result;
 232 }
 233
 234 /* Process another portion of the NBD_OPT_LIST reply.  Set *@match if
 235  * the current reply matches @want or if the server does not support
 236  * NBD_OPT_LIST, otherwise leave @match alone.  Return 0 if iteration
 237  * is complete, positive if more replies are expected, or negative
 238  * with @errp set if an unrecoverable error occurred. */
 239 static int nbd_receive_list(QIOChannel *ioc, const char *want, bool *match,
 240                             Error **errp)
 241 {
 242     nbd_opt_reply reply;
 243     uint32_t len;
 244     uint32_t namelen;
 245     char name[NBD_MAX_NAME_SIZE + 1];
 246     int error;
 247
 248     if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
 249         return -1;
 250     }
 251     error = nbd_handle_reply_err(ioc, &reply, errp);
 252     if (error <= 0) {
 253         /* The server did not support NBD_OPT_LIST, so set *match on
 254          * the assumption that any name will be accepted.  */
 255         *match = true;
 256         return error;
 257     }
 258     len = reply.length;
 259
 260     if (reply.type == NBD_REP_ACK) {
 261         if (len != 0) {
 262             error_setg(errp, "length too long for option end");
 263             nbd_send_opt_abort(ioc);
 264             return -1;
 265         }
 266         return 0;
 267     } else if (reply.type != NBD_REP_SERVER) {
 268         error_setg(errp, "Unexpected reply type %" PRIx32 " expected %x",
 269                    reply.type, NBD_REP_SERVER);
 270         nbd_send_opt_abort(ioc);
 271         return -1;
 272     }
 273
 274     if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
 275         error_setg(errp, "incorrect option length %" PRIu32, len);
 276         nbd_send_opt_abort(ioc);
 277         return -1;
 278     }
 279     if (nbd_read(ioc, &namelen, sizeof(namelen), errp) < 0) {
 280         error_prepend(errp, "failed to read option name length");
 281         nbd_send_opt_abort(ioc);
 282         return -1;
 283     }
 284     namelen = be32_to_cpu(namelen);
 285     len -= sizeof(namelen);
 286     if (len < namelen) {
 287         error_setg(errp, "incorrect option name length");
 288         nbd_send_opt_abort(ioc);
 289         return -1;
 290     }
 291     if (namelen != strlen(want)) {
 292         if (nbd_drop(ioc, len, errp) < 0) {
 293             error_prepend(errp, "failed to skip export name with wrong length");
 294             nbd_send_opt_abort(ioc);
 295             return -1;
 296         }
 297         return 1;
 298     }
 299
 300     assert(namelen < sizeof(name));
 301     if (nbd_read(ioc, name, namelen, errp) < 0) {
 302         error_prepend(errp, "failed to read export name");
 303         nbd_send_opt_abort(ioc);
 304         return -1;
 305     }
 306     name[namelen] = '\0';
 307     len -= namelen;
 308     if (nbd_drop(ioc, len, errp) < 0) {
 309         error_prepend(errp, "failed to read export description");
 310         nbd_send_opt_abort(ioc);
 311         return -1;
 312     }
 313     if (!strcmp(name, want)) {
 314         *match = true;
 315     }
 316     return 1;
 317 }
 318
 319
 320 /* Returns -1 if NBD_OPT_GO proves the export @wantname cannot be
 321  * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
 322  * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
 323  * go (with @info populated). */
 324 static int nbd_opt_go(QIOChannel *ioc, const char *wantname,
 325                       NBDExportInfo *info, Error **errp)
 326 {
 327     nbd_opt_reply reply;
 328     uint32_t len = strlen(wantname);
 329     uint16_t type;
 330     int error;
 331     char *buf;
 332
 333     /* The protocol requires that the server send NBD_INFO_EXPORT with
 334      * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
 335      * flags still 0 is a witness of a broken server. */
 336     info->flags = 0;
 337
 338     trace_nbd_opt_go_start(wantname);
 339     buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
 340     stl_be_p(buf, len);
 341     memcpy(buf + 4, wantname, len);
 342     /* At most one request, everything else up to server */
 343     stw_be_p(buf + 4 + len, info->request_sizes);
 344     if (info->request_sizes) {
 345         stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
 346     }
 347     error = nbd_send_option_request(ioc, NBD_OPT_GO,
 348                                     4 + len + 2 + 2 * info->request_sizes,
 349                                     buf, errp);
 350     g_free(buf);
 351     if (error < 0) {
 352         return -1;
 353     }
 354
 355     while (1) {
 356         if (nbd_receive_option_reply(ioc, NBD_OPT_GO, &reply, errp) < 0) {
 357             return -1;
 358         }
 359         error = nbd_handle_reply_err(ioc, &reply, errp);
 360         if (error <= 0) {
 361             return error;
 362         }
 363         len = reply.length;
 364
 365         if (reply.type == NBD_REP_ACK) {
 366             /* Server is done sending info and moved into transmission
 367                phase, but make sure it sent flags */
 368             if (len) {
 369                 error_setg(errp, "server sent invalid NBD_REP_ACK");
 370                 return -1;
 371             }
 372             if (!info->flags) {
 373                 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
 374                 return -1;
 375             }
 376             trace_nbd_opt_go_success();
 377             return 1;
 378         }
 379         if (reply.type != NBD_REP_INFO) {
 380             error_setg(errp, "unexpected reply type %" PRIx32
 381                        " (%s), expected %x",
 382                        reply.type, nbd_rep_lookup(reply.type), NBD_REP_INFO);
 383             nbd_send_opt_abort(ioc);
 384             return -1;
 385         }
 386         if (len < sizeof(type)) {
 387             error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
 388                        len);
 389             nbd_send_opt_abort(ioc);
 390             return -1;
 391         }
 392         if (nbd_read(ioc, &type, sizeof(type), errp) < 0) {
 393             error_prepend(errp, "failed to read info type");
 394             nbd_send_opt_abort(ioc);
 395             return -1;
 396         }
 397         len -= sizeof(type);
 398         be16_to_cpus(&type);
 399         switch (type) {
 400         case NBD_INFO_EXPORT:
 401             if (len != sizeof(info->size) + sizeof(info->flags)) {
 402                 error_setg(errp, "remaining export info len %" PRIu32
 403                            " is unexpected size", len);
 404                 nbd_send_opt_abort(ioc);
 405                 return -1;
 406             }
 407             if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 408                 error_prepend(errp, "failed to read info size");
 409                 nbd_send_opt_abort(ioc);
 410                 return -1;
 411             }
 412             be64_to_cpus(&info->size);
 413             if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 414                 error_prepend(errp, "failed to read info flags");
 415                 nbd_send_opt_abort(ioc);
 416                 return -1;
 417             }
 418             be16_to_cpus(&info->flags);
 419             trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 420             break;
 421
 422         case NBD_INFO_BLOCK_SIZE:
 423             if (len != sizeof(info->min_block) * 3) {
 424                 error_setg(errp, "remaining export info len %" PRIu32
 425                            " is unexpected size", len);
 426                 nbd_send_opt_abort(ioc);
 427                 return -1;
 428             }
 429             if (nbd_read(ioc, &info->min_block, sizeof(info->min_block),
 430                          errp) < 0) {
 431                 error_prepend(errp, "failed to read info minimum block size");
 432                 nbd_send_opt_abort(ioc);
 433                 return -1;
 434             }
 435             be32_to_cpus(&info->min_block);
 436             if (!is_power_of_2(info->min_block)) {
 437                 error_setg(errp, "server minimum block size %" PRId32
 438                            "is not a power of two", info->min_block);
 439                 nbd_send_opt_abort(ioc);
 440                 return -1;
 441             }
 442             if (nbd_read(ioc, &info->opt_block, sizeof(info->opt_block),
 443                          errp) < 0) {
 444                 error_prepend(errp, "failed to read info preferred block size");
 445                 nbd_send_opt_abort(ioc);
 446                 return -1;
 447             }
 448             be32_to_cpus(&info->opt_block);
 449             if (!is_power_of_2(info->opt_block) ||
 450                 info->opt_block < info->min_block) {
 451                 error_setg(errp, "server preferred block size %" PRId32
 452                            "is not valid", info->opt_block);
 453                 nbd_send_opt_abort(ioc);
 454                 return -1;
 455             }
 456             if (nbd_read(ioc, &info->max_block, sizeof(info->max_block),
 457                          errp) < 0) {
 458                 error_prepend(errp, "failed to read info maximum block size");
 459                 nbd_send_opt_abort(ioc);
 460                 return -1;
 461             }
 462             be32_to_cpus(&info->max_block);
 463             trace_nbd_opt_go_info_block_size(info->min_block, info->opt_block,
 464                                              info->max_block);
 465             break;
 466
 467         default:
 468             trace_nbd_opt_go_info_unknown(type, nbd_info_lookup(type));
 469             if (nbd_drop(ioc, len, errp) < 0) {
 470                 error_prepend(errp, "Failed to read info payload");
 471                 nbd_send_opt_abort(ioc);
 472                 return -1;
 473             }
 474             break;
 475         }
 476     }
 477 }
 478
 479 /* Return -1 on failure, 0 if wantname is an available export. */
 480 static int nbd_receive_query_exports(QIOChannel *ioc,
 481                                      const char *wantname,
 482                                      Error **errp)
 483 {
 484     bool foundExport = false;
 485
 486     trace_nbd_receive_query_exports_start(wantname);
 487     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 488         return -1;
 489     }
 490
 491     while (1) {
 492         int ret = nbd_receive_list(ioc, wantname, &foundExport, errp);
 493
 494         if (ret < 0) {
 495             /* Server gave unexpected reply */
 496             return -1;
 497         } else if (ret == 0) {
 498             /* Done iterating. */
 499             if (!foundExport) {
 500                 error_setg(errp, "No export with name '%s' available",
 501                            wantname);
 502                 nbd_send_opt_abort(ioc);
 503                 return -1;
 504             }
 505             trace_nbd_receive_query_exports_success(wantname);
 506             return 0;
 507         }
 508     }
 509 }
 510
 511 /* nbd_request_simple_option: Send an option request, and parse the reply
 512  * return 1 for successful negotiation,
 513  *        0 if operation is unsupported,
 514  *        -1 with errp set for any other error
 515  */
 516 static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp)
 517 {
 518     nbd_opt_reply reply;
 519     int error;
 520
 521     if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
 522         return -1;
 523     }
 524
 525     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 526         return -1;
 527     }
 528     error = nbd_handle_reply_err(ioc, &reply, errp);
 529     if (error <= 0) {
 530         return error;
 531     }
 532
 533     if (reply.type != NBD_REP_ACK) {
 534         error_setg(errp, "Server answered option %d (%s) with unexpected "
 535                    "reply %" PRIx32 " (%s)", opt, nbd_opt_lookup(opt),
 536                    reply.type, nbd_rep_lookup(reply.type));
 537         nbd_send_opt_abort(ioc);
 538         return -1;
 539     }
 540
 541     if (reply.length != 0) {
 542         error_setg(errp, "Option %d ('%s') response length is %" PRIu32
 543                    " (it should be zero)", opt, nbd_opt_lookup(opt),
 544                    reply.length);
 545         nbd_send_opt_abort(ioc);
 546         return -1;
 547     }
 548
 549     return 1;
 550 }
 551
 552 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 553                                         QCryptoTLSCreds *tlscreds,
 554                                         const char *hostname, Error **errp)
 555 {
 556     int ret;
 557     QIOChannelTLS *tioc;
 558     struct NBDTLSHandshakeData data = { 0 };
 559
 560     ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp);
 561     if (ret <= 0) {
 562         if (ret == 0) {
 563             error_setg(errp, "Server don't support STARTTLS option");
 564             nbd_send_opt_abort(ioc);
 565         }
 566         return NULL;
 567     }
 568
 569     trace_nbd_receive_starttls_new_client();
 570     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 571     if (!tioc) {
 572         return NULL;
 573     }
 574     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 575     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 576     trace_nbd_receive_starttls_tls_handshake();
 577     qio_channel_tls_handshake(tioc,
 578                               nbd_tls_handshake,
 579                               &data,
 580                               NULL);
 581
 582     if (!data.complete) {
 583         g_main_loop_run(data.loop);
 584     }
 585     g_main_loop_unref(data.loop);
 586     if (data.error) {
 587         error_propagate(errp, data.error);
 588         object_unref(OBJECT(tioc));
 589         return NULL;
 590     }
 591
 592     return QIO_CHANNEL(tioc);
 593 }
 594
 595
 596 int nbd_receive_negotiate(QIOChannel *ioc, const char *name,
 597                           QCryptoTLSCreds *tlscreds, const char *hostname,
 598                           QIOChannel **outioc, NBDExportInfo *info,
 599                           Error **errp)
 600 {
 601     char buf[256];
 602     uint64_t magic;
 603     int rc;
 604     bool zeroes = true;
 605
 606     trace_nbd_receive_negotiate(tlscreds, hostname ? hostname : "<null>");
 607
 608     rc = -EINVAL;
 609
 610     if (outioc) {
 611         *outioc = NULL;
 612     }
 613     if (tlscreds && !outioc) {
 614         error_setg(errp, "Output I/O channel required for TLS");
 615         goto fail;
 616     }
 617
 618     if (nbd_read(ioc, buf, 8, errp) < 0) {
 619         error_prepend(errp, "Failed to read data");
 620         goto fail;
 621     }
 622
 623     buf[8] = '\0';
 624     if (strlen(buf) == 0) {
 625         error_setg(errp, "Server connection closed unexpectedly");
 626         goto fail;
 627     }
 628
 629     magic = ldq_be_p(buf);
 630     trace_nbd_receive_negotiate_magic(magic);
 631
 632     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
 633         error_setg(errp, "Invalid magic received");
 634         goto fail;
 635     }
 636
 637     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 638         error_prepend(errp, "Failed to read magic");
 639         goto fail;
 640     }
 641     magic = be64_to_cpu(magic);
 642     trace_nbd_receive_negotiate_magic(magic);
 643
 644     if (magic == NBD_OPTS_MAGIC) {
 645         uint32_t clientflags = 0;
 646         uint16_t globalflags;
 647         bool fixedNewStyle = false;
 648
 649         if (nbd_read(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
 650             error_prepend(errp, "Failed to read server flags");
 651             goto fail;
 652         }
 653         globalflags = be16_to_cpu(globalflags);
 654         trace_nbd_receive_negotiate_server_flags(globalflags);
 655         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 656             fixedNewStyle = true;
 657             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 658         }
 659         if (globalflags & NBD_FLAG_NO_ZEROES) {
 660             zeroes = false;
 661             clientflags |= NBD_FLAG_C_NO_ZEROES;
 662         }
 663         /* client requested flags */
 664         clientflags = cpu_to_be32(clientflags);
 665         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 666             error_prepend(errp, "Failed to send clientflags field");
 667             goto fail;
 668         }
 669         if (tlscreds) {
 670             if (fixedNewStyle) {
 671                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 672                 if (!*outioc) {
 673                     goto fail;
 674                 }
 675                 ioc = *outioc;
 676             } else {
 677                 error_setg(errp, "Server does not support STARTTLS");
 678                 goto fail;
 679             }
 680         }
 681         if (!name) {
 682             trace_nbd_receive_negotiate_default_name();
 683             name = "";
 684         }
 685         if (fixedNewStyle) {
 686             int result;
 687
 688             /* Try NBD_OPT_GO first - if it works, we are done (it
 689              * also gives us a good message if the server requires
 690              * TLS).  If it is not available, fall back to
 691              * NBD_OPT_LIST for nicer error messages about a missing
 692              * export, then use NBD_OPT_EXPORT_NAME.  */
 693             result = nbd_opt_go(ioc, name, info, errp);
 694             if (result < 0) {
 695                 goto fail;
 696             }
 697             if (result > 0) {
 698                 return 0;
 699             }
 700             /* Check our desired export is present in the
 701              * server export list. Since NBD_OPT_EXPORT_NAME
 702              * cannot return an error message, running this
 703              * query gives us better error reporting if the
 704              * export name is not available.
 705              */
 706             if (nbd_receive_query_exports(ioc, name, errp) < 0) {
 707                 goto fail;
 708             }
 709         }
 710         /* write the export name request */
 711         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, name,
 712                                     errp) < 0) {
 713             goto fail;
 714         }
 715
 716         /* Read the response */
 717         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 718             error_prepend(errp, "Failed to read export length");
 719             goto fail;
 720         }
 721         be64_to_cpus(&info->size);
 722
 723         if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 724             error_prepend(errp, "Failed to read export flags");
 725             goto fail;
 726         }
 727         be16_to_cpus(&info->flags);
 728     } else if (magic == NBD_CLIENT_MAGIC) {
 729         uint32_t oldflags;
 730
 731         if (name) {
 732             error_setg(errp, "Server does not support export names");
 733             goto fail;
 734         }
 735         if (tlscreds) {
 736             error_setg(errp, "Server does not support STARTTLS");
 737             goto fail;
 738         }
 739
 740         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 741             error_prepend(errp, "Failed to read export length");
 742             goto fail;
 743         }
 744         be64_to_cpus(&info->size);
 745
 746         if (nbd_read(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
 747             error_prepend(errp, "Failed to read export flags");
 748             goto fail;
 749         }
 750         be32_to_cpus(&oldflags);
 751         if (oldflags & ~0xffff) {
 752             error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 753             goto fail;
 754         }
 755         info->flags = oldflags;
 756     } else {
 757         error_setg(errp, "Bad magic received");
 758         goto fail;
 759     }
 760
 761     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 762     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
 763         error_prepend(errp, "Failed to read reserved block");
 764         goto fail;
 765     }
 766     rc = 0;
 767
 768 fail:
 769     return rc;
 770 }
 771
 772 #ifdef __linux__
 773 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
 774              Error **errp)
 775 {
 776     unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
 777     unsigned long sectors = info->size / sector_size;
 778
 779     /* FIXME: Once the kernel module is patched to honor block sizes,
 780      * and to advertise that fact to user space, we should update the
 781      * hand-off to the kernel to use any block sizes we learned. */
 782     assert(!info->request_sizes);
 783     if (info->size / sector_size != sectors) {
 784         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
 785                    info->size);
 786         return -E2BIG;
 787     }
 788
 789     trace_nbd_init_set_socket();
 790
 791     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
 792         int serrno = errno;
 793         error_setg(errp, "Failed to set NBD socket");
 794         return -serrno;
 795     }
 796
 797     trace_nbd_init_set_block_size(sector_size);
 798
 799     if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
 800         int serrno = errno;
 801         error_setg(errp, "Failed setting NBD block size");
 802         return -serrno;
 803     }
 804
 805     trace_nbd_init_set_size(sectors);
 806     if (info->size % sector_size) {
 807         trace_nbd_init_trailing_bytes(info->size % sector_size);
 808     }
 809
 810     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
 811         int serrno = errno;
 812         error_setg(errp, "Failed setting size (in blocks)");
 813         return -serrno;
 814     }
 815
 816     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
 817         if (errno == ENOTTY) {
 818             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
 819             trace_nbd_init_set_readonly();
 820
 821             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 822                 int serrno = errno;
 823                 error_setg(errp, "Failed setting read-only attribute");
 824                 return -serrno;
 825             }
 826         } else {
 827             int serrno = errno;
 828             error_setg(errp, "Failed setting flags");
 829             return -serrno;
 830         }
 831     }
 832
 833     trace_nbd_init_finish();
 834
 835     return 0;
 836 }
 837
 838 int nbd_client(int fd)
 839 {
 840     int ret;
 841     int serrno;
 842
 843     trace_nbd_client_loop();
 844
 845     ret = ioctl(fd, NBD_DO_IT);
 846     if (ret < 0 && errno == EPIPE) {
 847         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 848          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
 849          * that case.
 850          */
 851         ret = 0;
 852     }
 853     serrno = errno;
 854
 855     trace_nbd_client_loop_ret(ret, strerror(serrno));
 856
 857     trace_nbd_client_clear_queue();
 858     ioctl(fd, NBD_CLEAR_QUE);
 859
 860     trace_nbd_client_clear_socket();
 861     ioctl(fd, NBD_CLEAR_SOCK);
 862
 863     errno = serrno;
 864     return ret;
 865 }
 866
 867 int nbd_disconnect(int fd)
 868 {
 869     ioctl(fd, NBD_CLEAR_QUE);
 870     ioctl(fd, NBD_DISCONNECT);
 871     ioctl(fd, NBD_CLEAR_SOCK);
 872     return 0;
 873 }
 874
 875 #else
 876 int nbd_init(int fd, QIOChannelSocket *ioc, NBDExportInfo *info,
 877              Error **errp)
 878 {
 879     error_setg(errp, "nbd_init is only supported on Linux");
 880     return -ENOTSUP;
 881 }
 882
 883 int nbd_client(int fd)
 884 {
 885     return -ENOTSUP;
 886 }
 887 int nbd_disconnect(int fd)
 888 {
 889     return -ENOTSUP;
 890 }
 891 #endif
 892
 893 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
 894 {
 895     uint8_t buf[NBD_REQUEST_SIZE];
 896
 897     trace_nbd_send_request(request->from, request->len, request->handle,
 898                            request->flags, request->type,
 899                            nbd_cmd_lookup(request->type));
 900
 901     stl_be_p(buf, NBD_REQUEST_MAGIC);
 902     stw_be_p(buf + 4, request->flags);
 903     stw_be_p(buf + 6, request->type);
 904     stq_be_p(buf + 8, request->handle);
 905     stq_be_p(buf + 16, request->from);
 906     stl_be_p(buf + 24, request->len);
 907
 908     return nbd_write(ioc, buf, sizeof(buf), NULL);
 909 }
 910
 911 /* nbd_receive_simple_reply
 912  * Read simple reply except magic field (which should be already read).
 913  * Payload is not read (payload is possible for CMD_READ, but here we even
 914  * don't know whether it take place or not).
 915  */
 916 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
 917                                     Error **errp)
 918 {
 919     int ret;
 920
 921     assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
 922
 923     ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
 924                    sizeof(*reply) - sizeof(reply->magic), errp);
 925     if (ret < 0) {
 926         return ret;
 927     }
 928
 929     be32_to_cpus(&reply->error);
 930     be64_to_cpus(&reply->handle);
 931
 932     return 0;
 933 }
 934
 935 /* nbd_receive_structured_reply_chunk
 936  * Read structured reply chunk except magic field (which should be already
 937  * read).
 938  * Payload is not read.
 939  */
 940 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
 941                                               NBDStructuredReplyChunk *chunk,
 942                                               Error **errp)
 943 {
 944     int ret;
 945
 946     assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
 947
 948     ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
 949                    sizeof(*chunk) - sizeof(chunk->magic), errp);
 950     if (ret < 0) {
 951         return ret;
 952     }
 953
 954     be16_to_cpus(&chunk->flags);
 955     be16_to_cpus(&chunk->type);
 956     be64_to_cpus(&chunk->handle);
 957     be32_to_cpus(&chunk->length);
 958
 959     return 0;
 960 }
 961
 962 /* nbd_receive_reply
 963  * Returns 1 on success
 964  *         0 on eof, when no data was read (errp is not set)
 965  *         negative errno on failure (errp is set)
 966  */
 967 int nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
 968 {
 969     int ret;
 970
 971     ret = nbd_read_eof(ioc, &reply->magic, sizeof(reply->magic), errp);
 972     if (ret <= 0) {
 973         return ret;
 974     }
 975
 976     be32_to_cpus(&reply->magic);
 977
 978     switch (reply->magic) {
 979     case NBD_SIMPLE_REPLY_MAGIC:
 980         ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
 981         if (ret < 0) {
 982             break;
 983         }
 984
 985         trace_nbd_receive_simple_reply(reply->simple.error,
 986                                        nbd_err_lookup(reply->simple.error),
 987                                        reply->handle);
 988         if (reply->simple.error == NBD_ESHUTDOWN) {
 989             /* This works even on mingw which lacks a native ESHUTDOWN */
 990             error_setg(errp, "server shutting down");
 991             return -EINVAL;
 992         }
 993         break;
 994     case NBD_STRUCTURED_REPLY_MAGIC:
 995         ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
 996         if (ret < 0) {
 997             break;
 998         }
 999         trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
1000                                                  reply->structured.type,
1001                                                  reply->structured.handle,
1002                                                  reply->structured.length);
1003         break;
1004     default:
1005         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
1006         return -EINVAL;
1007     }
1008     if (ret < 0) {
1009         return ret;
1010     }
1011
1012     return 1;
1013 }
1014