nbd/client.c

   1 /*
   2  *  Copyright (C) 2016-2018 Red Hat, Inc.
   3  *  Copyright (C) 2005  Anthony Liguori <[email protected]>
   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     NBDOption 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                                     NBDOptionReply *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     reply->magic = be64_to_cpu(reply->magic);
 121     reply->option = be32_to_cpu(reply->option);
 122     reply->type = be32_to_cpu(reply->type);
 123     reply->length = be32_to_cpu(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 %u (%s), expected %u (%s)",
 136                    reply->option, nbd_opt_lookup(reply->option),
 137                    opt, nbd_opt_lookup(opt));
 138         nbd_send_opt_abort(ioc);
 139         return -1;
 140     }
 141     return 0;
 142 }
 143
 144 /* If reply represents success, return 1 without further action.
 145  * If reply represents an error, consume the optional payload of
 146  * the packet on ioc.  Then return 0 for unsupported (so the client
 147  * can fall back to other approaches), or -1 with errp set for other
 148  * errors.
 149  */
 150 static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply,
 151                                 Error **errp)
 152 {
 153     char *msg = NULL;
 154     int result = -1;
 155
 156     if (!(reply->type & (1 << 31))) {
 157         return 1;
 158     }
 159
 160     if (reply->length) {
 161         if (reply->length > NBD_MAX_BUFFER_SIZE) {
 162             error_setg(errp, "server error %" PRIu32
 163                        " (%s) message is too long",
 164                        reply->type, nbd_rep_lookup(reply->type));
 165             goto cleanup;
 166         }
 167         msg = g_malloc(reply->length + 1);
 168         if (nbd_read(ioc, msg, reply->length, errp) < 0) {
 169             error_prepend(errp, "failed to read option error %" PRIu32
 170                           " (%s) message: ",
 171                           reply->type, nbd_rep_lookup(reply->type));
 172             goto cleanup;
 173         }
 174         msg[reply->length] = '\0';
 175         trace_nbd_server_error_msg(reply->type,
 176                                    nbd_reply_type_lookup(reply->type), msg);
 177     }
 178
 179     switch (reply->type) {
 180     case NBD_REP_ERR_UNSUP:
 181         trace_nbd_reply_err_unsup(reply->option, nbd_opt_lookup(reply->option));
 182         result = 0;
 183         goto cleanup;
 184
 185     case NBD_REP_ERR_POLICY:
 186         error_setg(errp, "Denied by server for option %" PRIu32 " (%s)",
 187                    reply->option, nbd_opt_lookup(reply->option));
 188         break;
 189
 190     case NBD_REP_ERR_INVALID:
 191         error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)",
 192                    reply->option, nbd_opt_lookup(reply->option));
 193         break;
 194
 195     case NBD_REP_ERR_PLATFORM:
 196         error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)",
 197                    reply->option, nbd_opt_lookup(reply->option));
 198         break;
 199
 200     case NBD_REP_ERR_TLS_REQD:
 201         error_setg(errp, "TLS negotiation required before option %" PRIu32
 202                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 203         break;
 204
 205     case NBD_REP_ERR_UNKNOWN:
 206         error_setg(errp, "Requested export not available");
 207         break;
 208
 209     case NBD_REP_ERR_SHUTDOWN:
 210         error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)",
 211                    reply->option, nbd_opt_lookup(reply->option));
 212         break;
 213
 214     case NBD_REP_ERR_BLOCK_SIZE_REQD:
 215         error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
 216                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 217         break;
 218
 219     default:
 220         error_setg(errp, "Unknown error code when asking for option %" PRIu32
 221                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 222         break;
 223     }
 224
 225     if (msg) {
 226         error_append_hint(errp, "server reported: %s\n", msg);
 227     }
 228
 229  cleanup:
 230     g_free(msg);
 231     if (result < 0) {
 232         nbd_send_opt_abort(ioc);
 233     }
 234     return result;
 235 }
 236
 237 /* nbd_receive_list:
 238  * Process another portion of the NBD_OPT_LIST reply, populating any
 239  * name received into *@name. If @description is non-NULL, and the
 240  * server provided a description, that is also populated. The caller
 241  * must eventually call g_free() on success.
 242  * Returns 1 if name and description were set and iteration must continue,
 243  *         0 if iteration is complete (including if OPT_LIST unsupported),
 244  *         -1 with @errp set if an unrecoverable error occurred.
 245  */
 246 static int nbd_receive_list(QIOChannel *ioc, char **name, char **description,
 247                             Error **errp)
 248 {
 249     int ret = -1;
 250     NBDOptionReply reply;
 251     uint32_t len;
 252     uint32_t namelen;
 253     char *local_name = NULL;
 254     char *local_desc = NULL;
 255     int error;
 256
 257     if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
 258         return -1;
 259     }
 260     error = nbd_handle_reply_err(ioc, &reply, errp);
 261     if (error <= 0) {
 262         return error;
 263     }
 264     len = reply.length;
 265
 266     if (reply.type == NBD_REP_ACK) {
 267         if (len != 0) {
 268             error_setg(errp, "length too long for option end");
 269             nbd_send_opt_abort(ioc);
 270             return -1;
 271         }
 272         return 0;
 273     } else if (reply.type != NBD_REP_SERVER) {
 274         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 275                    reply.type, nbd_rep_lookup(reply.type),
 276                    NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER));
 277         nbd_send_opt_abort(ioc);
 278         return -1;
 279     }
 280
 281     if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
 282         error_setg(errp, "incorrect option length %" PRIu32, len);
 283         nbd_send_opt_abort(ioc);
 284         return -1;
 285     }
 286     if (nbd_read(ioc, &namelen, sizeof(namelen), errp) < 0) {
 287         error_prepend(errp, "failed to read option name length: ");
 288         nbd_send_opt_abort(ioc);
 289         return -1;
 290     }
 291     namelen = be32_to_cpu(namelen);
 292     len -= sizeof(namelen);
 293     if (len < namelen) {
 294         error_setg(errp, "incorrect option name length");
 295         nbd_send_opt_abort(ioc);
 296         return -1;
 297     }
 298
 299     local_name = g_malloc(namelen + 1);
 300     if (nbd_read(ioc, local_name, namelen, errp) < 0) {
 301         error_prepend(errp, "failed to read export name: ");
 302         nbd_send_opt_abort(ioc);
 303         goto out;
 304     }
 305     local_name[namelen] = '\0';
 306     len -= namelen;
 307     if (len) {
 308         local_desc = g_malloc(len + 1);
 309         if (nbd_read(ioc, local_desc, len, errp) < 0) {
 310             error_prepend(errp, "failed to read export description: ");
 311             nbd_send_opt_abort(ioc);
 312             goto out;
 313         }
 314         local_desc[len] = '\0';
 315     }
 316
 317     trace_nbd_receive_list(local_name, local_desc ?: "");
 318     *name = local_name;
 319     local_name = NULL;
 320     if (description) {
 321         *description = local_desc;
 322         local_desc = NULL;
 323     }
 324     ret = 1;
 325
 326  out:
 327     g_free(local_name);
 328     g_free(local_desc);
 329     return ret;
 330 }
 331
 332
 333 /*
 334  * nbd_opt_info_or_go:
 335  * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.
 336  * Returns -1 if the option proves the export @info->name cannot be
 337  * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and
 338  * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
 339  * go (with the rest of @info populated).
 340  */
 341 static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt,
 342                               NBDExportInfo *info, Error **errp)
 343 {
 344     NBDOptionReply reply;
 345     uint32_t len = strlen(info->name);
 346     uint16_t type;
 347     int error;
 348     char *buf;
 349
 350     /* The protocol requires that the server send NBD_INFO_EXPORT with
 351      * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
 352      * flags still 0 is a witness of a broken server. */
 353     info->flags = 0;
 354
 355     assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO);
 356     trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name);
 357     buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
 358     stl_be_p(buf, len);
 359     memcpy(buf + 4, info->name, len);
 360     /* At most one request, everything else up to server */
 361     stw_be_p(buf + 4 + len, info->request_sizes);
 362     if (info->request_sizes) {
 363         stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
 364     }
 365     error = nbd_send_option_request(ioc, opt,
 366                                     4 + len + 2 + 2 * info->request_sizes,
 367                                     buf, errp);
 368     g_free(buf);
 369     if (error < 0) {
 370         return -1;
 371     }
 372
 373     while (1) {
 374         if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 375             return -1;
 376         }
 377         error = nbd_handle_reply_err(ioc, &reply, errp);
 378         if (error <= 0) {
 379             return error;
 380         }
 381         len = reply.length;
 382
 383         if (reply.type == NBD_REP_ACK) {
 384             /*
 385              * Server is done sending info, and moved into transmission
 386              * phase for NBD_OPT_GO, but make sure it sent flags
 387              */
 388             if (len) {
 389                 error_setg(errp, "server sent invalid NBD_REP_ACK");
 390                 return -1;
 391             }
 392             if (!info->flags) {
 393                 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
 394                 return -1;
 395             }
 396             trace_nbd_opt_info_go_success(nbd_opt_lookup(opt));
 397             return 1;
 398         }
 399         if (reply.type != NBD_REP_INFO) {
 400             error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",
 401                        reply.type, nbd_rep_lookup(reply.type),
 402                        NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));
 403             nbd_send_opt_abort(ioc);
 404             return -1;
 405         }
 406         if (len < sizeof(type)) {
 407             error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
 408                        len);
 409             nbd_send_opt_abort(ioc);
 410             return -1;
 411         }
 412         if (nbd_read(ioc, &type, sizeof(type), errp) < 0) {
 413             error_prepend(errp, "failed to read info type: ");
 414             nbd_send_opt_abort(ioc);
 415             return -1;
 416         }
 417         len -= sizeof(type);
 418         type = be16_to_cpu(type);
 419         switch (type) {
 420         case NBD_INFO_EXPORT:
 421             if (len != sizeof(info->size) + sizeof(info->flags)) {
 422                 error_setg(errp, "remaining export info len %" PRIu32
 423                            " is unexpected size", len);
 424                 nbd_send_opt_abort(ioc);
 425                 return -1;
 426             }
 427             if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 428                 error_prepend(errp, "failed to read info size: ");
 429                 nbd_send_opt_abort(ioc);
 430                 return -1;
 431             }
 432             info->size = be64_to_cpu(info->size);
 433             if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 434                 error_prepend(errp, "failed to read info flags: ");
 435                 nbd_send_opt_abort(ioc);
 436                 return -1;
 437             }
 438             info->flags = be16_to_cpu(info->flags);
 439             trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 440             break;
 441
 442         case NBD_INFO_BLOCK_SIZE:
 443             if (len != sizeof(info->min_block) * 3) {
 444                 error_setg(errp, "remaining export info len %" PRIu32
 445                            " is unexpected size", len);
 446                 nbd_send_opt_abort(ioc);
 447                 return -1;
 448             }
 449             if (nbd_read(ioc, &info->min_block, sizeof(info->min_block),
 450                          errp) < 0) {
 451                 error_prepend(errp, "failed to read info minimum block size: ");
 452                 nbd_send_opt_abort(ioc);
 453                 return -1;
 454             }
 455             info->min_block = be32_to_cpu(info->min_block);
 456             if (!is_power_of_2(info->min_block)) {
 457                 error_setg(errp, "server minimum block size %" PRIu32
 458                            " is not a power of two", info->min_block);
 459                 nbd_send_opt_abort(ioc);
 460                 return -1;
 461             }
 462             if (nbd_read(ioc, &info->opt_block, sizeof(info->opt_block),
 463                          errp) < 0) {
 464                 error_prepend(errp,
 465                               "failed to read info preferred block size: ");
 466                 nbd_send_opt_abort(ioc);
 467                 return -1;
 468             }
 469             info->opt_block = be32_to_cpu(info->opt_block);
 470             if (!is_power_of_2(info->opt_block) ||
 471                 info->opt_block < info->min_block) {
 472                 error_setg(errp, "server preferred block size %" PRIu32
 473                            " is not valid", info->opt_block);
 474                 nbd_send_opt_abort(ioc);
 475                 return -1;
 476             }
 477             if (nbd_read(ioc, &info->max_block, sizeof(info->max_block),
 478                          errp) < 0) {
 479                 error_prepend(errp, "failed to read info maximum block size: ");
 480                 nbd_send_opt_abort(ioc);
 481                 return -1;
 482             }
 483             info->max_block = be32_to_cpu(info->max_block);
 484             if (info->max_block < info->min_block) {
 485                 error_setg(errp, "server maximum block size %" PRIu32
 486                            " is not valid", info->max_block);
 487                 nbd_send_opt_abort(ioc);
 488                 return -1;
 489             }
 490             trace_nbd_opt_info_block_size(info->min_block, info->opt_block,
 491                                           info->max_block);
 492             break;
 493
 494         default:
 495             trace_nbd_opt_info_unknown(type, nbd_info_lookup(type));
 496             if (nbd_drop(ioc, len, errp) < 0) {
 497                 error_prepend(errp, "Failed to read info payload: ");
 498                 nbd_send_opt_abort(ioc);
 499                 return -1;
 500             }
 501             break;
 502         }
 503     }
 504 }
 505
 506 /* Return -1 on failure, 0 if wantname is an available export. */
 507 static int nbd_receive_query_exports(QIOChannel *ioc,
 508                                      const char *wantname,
 509                                      Error **errp)
 510 {
 511     bool list_empty = true;
 512     bool found_export = false;
 513
 514     trace_nbd_receive_query_exports_start(wantname);
 515     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 516         return -1;
 517     }
 518
 519     while (1) {
 520         char *name;
 521         int ret = nbd_receive_list(ioc, &name, NULL, errp);
 522
 523         if (ret < 0) {
 524             /* Server gave unexpected reply */
 525             return -1;
 526         } else if (ret == 0) {
 527             /* Done iterating. */
 528             if (list_empty) {
 529                 /*
 530                  * We don't have enough context to tell a server that
 531                  * sent an empty list apart from a server that does
 532                  * not support the list command; but as this function
 533                  * is just used to trigger a nicer error message
 534                  * before trying NBD_OPT_EXPORT_NAME, assume the
 535                  * export is available.
 536                  */
 537                 return 0;
 538             } else if (!found_export) {
 539                 error_setg(errp, "No export with name '%s' available",
 540                            wantname);
 541                 nbd_send_opt_abort(ioc);
 542                 return -1;
 543             }
 544             trace_nbd_receive_query_exports_success(wantname);
 545             return 0;
 546         }
 547         list_empty = false;
 548         if (!strcmp(name, wantname)) {
 549             found_export = true;
 550         }
 551         g_free(name);
 552     }
 553 }
 554
 555 /* nbd_request_simple_option: Send an option request, and parse the reply
 556  * return 1 for successful negotiation,
 557  *        0 if operation is unsupported,
 558  *        -1 with errp set for any other error
 559  */
 560 static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp)
 561 {
 562     NBDOptionReply reply;
 563     int error;
 564
 565     if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
 566         return -1;
 567     }
 568
 569     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 570         return -1;
 571     }
 572     error = nbd_handle_reply_err(ioc, &reply, errp);
 573     if (error <= 0) {
 574         return error;
 575     }
 576
 577     if (reply.type != NBD_REP_ACK) {
 578         error_setg(errp, "Server answered option %d (%s) with unexpected "
 579                    "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),
 580                    reply.type, nbd_rep_lookup(reply.type));
 581         nbd_send_opt_abort(ioc);
 582         return -1;
 583     }
 584
 585     if (reply.length != 0) {
 586         error_setg(errp, "Option %d ('%s') response length is %" PRIu32
 587                    " (it should be zero)", opt, nbd_opt_lookup(opt),
 588                    reply.length);
 589         nbd_send_opt_abort(ioc);
 590         return -1;
 591     }
 592
 593     return 1;
 594 }
 595
 596 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 597                                         QCryptoTLSCreds *tlscreds,
 598                                         const char *hostname, Error **errp)
 599 {
 600     int ret;
 601     QIOChannelTLS *tioc;
 602     struct NBDTLSHandshakeData data = { 0 };
 603
 604     ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp);
 605     if (ret <= 0) {
 606         if (ret == 0) {
 607             error_setg(errp, "Server don't support STARTTLS option");
 608             nbd_send_opt_abort(ioc);
 609         }
 610         return NULL;
 611     }
 612
 613     trace_nbd_receive_starttls_new_client();
 614     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 615     if (!tioc) {
 616         return NULL;
 617     }
 618     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 619     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 620     trace_nbd_receive_starttls_tls_handshake();
 621     qio_channel_tls_handshake(tioc,
 622                               nbd_tls_handshake,
 623                               &data,
 624                               NULL,
 625                               NULL);
 626
 627     if (!data.complete) {
 628         g_main_loop_run(data.loop);
 629     }
 630     g_main_loop_unref(data.loop);
 631     if (data.error) {
 632         error_propagate(errp, data.error);
 633         object_unref(OBJECT(tioc));
 634         return NULL;
 635     }
 636
 637     return QIO_CHANNEL(tioc);
 638 }
 639
 640 /*
 641  * nbd_send_meta_query:
 642  * Send 0 or 1 set/list meta context queries.
 643  * Return 0 on success, -1 with errp set for any error
 644  */
 645 static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt,
 646                                const char *export, const char *query,
 647                                Error **errp)
 648 {
 649     int ret;
 650     uint32_t export_len = strlen(export);
 651     uint32_t queries = !!query;
 652     uint32_t query_len = 0;
 653     uint32_t data_len;
 654     char *data;
 655     char *p;
 656
 657     data_len = sizeof(export_len) + export_len + sizeof(queries);
 658     if (query) {
 659         query_len = strlen(query);
 660         data_len += sizeof(query_len) + query_len;
 661     } else {
 662         assert(opt == NBD_OPT_LIST_META_CONTEXT);
 663     }
 664     p = data = g_malloc(data_len);
 665
 666     trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export);
 667     stl_be_p(p, export_len);
 668     memcpy(p += sizeof(export_len), export, export_len);
 669     stl_be_p(p += export_len, queries);
 670     if (query) {
 671         stl_be_p(p += sizeof(queries), query_len);
 672         memcpy(p += sizeof(query_len), query, query_len);
 673     }
 674
 675     ret = nbd_send_option_request(ioc, opt, data_len, data, errp);
 676     g_free(data);
 677     return ret;
 678 }
 679
 680 /*
 681  * nbd_receive_one_meta_context:
 682  * Called in a loop to receive and trace one set/list meta context reply.
 683  * Pass non-NULL @name or @id to collect results back to the caller, which
 684  * must eventually call g_free().
 685  * return 1 if name is set and iteration must continue,
 686  *        0 if iteration is complete (including if option is unsupported),
 687  *        -1 with errp set for any error
 688  */
 689 static int nbd_receive_one_meta_context(QIOChannel *ioc,
 690                                         uint32_t opt,
 691                                         char **name,
 692                                         uint32_t *id,
 693                                         Error **errp)
 694 {
 695     int ret;
 696     NBDOptionReply reply;
 697     char *local_name = NULL;
 698     uint32_t local_id;
 699
 700     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 701         return -1;
 702     }
 703
 704     ret = nbd_handle_reply_err(ioc, &reply, errp);
 705     if (ret <= 0) {
 706         return ret;
 707     }
 708
 709     if (reply.type == NBD_REP_ACK) {
 710         if (reply.length != 0) {
 711             error_setg(errp, "Unexpected length to ACK response");
 712             nbd_send_opt_abort(ioc);
 713             return -1;
 714         }
 715         return 0;
 716     } else if (reply.type != NBD_REP_META_CONTEXT) {
 717         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 718                    reply.type, nbd_rep_lookup(reply.type),
 719                    NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT));
 720         nbd_send_opt_abort(ioc);
 721         return -1;
 722     }
 723
 724     if (reply.length <= sizeof(local_id) ||
 725         reply.length > NBD_MAX_BUFFER_SIZE) {
 726         error_setg(errp, "Failed to negotiate meta context, server "
 727                    "answered with unexpected length %" PRIu32,
 728                    reply.length);
 729         nbd_send_opt_abort(ioc);
 730         return -1;
 731     }
 732
 733     if (nbd_read(ioc, &local_id, sizeof(local_id), errp) < 0) {
 734         return -1;
 735     }
 736     local_id = be32_to_cpu(local_id);
 737
 738     reply.length -= sizeof(local_id);
 739     local_name = g_malloc(reply.length + 1);
 740     if (nbd_read(ioc, local_name, reply.length, errp) < 0) {
 741         g_free(local_name);
 742         return -1;
 743     }
 744     local_name[reply.length] = '\0';
 745     trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id);
 746
 747     if (name) {
 748         *name = local_name;
 749     } else {
 750         g_free(local_name);
 751     }
 752     if (id) {
 753         *id = local_id;
 754     }
 755     return 1;
 756 }
 757
 758 /*
 759  * nbd_negotiate_simple_meta_context:
 760  * Request the server to set the meta context for export @info->name
 761  * using @info->x_dirty_bitmap with a fallback to "base:allocation",
 762  * setting @info->context_id to the resulting id. Fail if the server
 763  * responds with more than one context or with a context different
 764  * than the query.
 765  * return 1 for successful negotiation,
 766  *        0 if operation is unsupported,
 767  *        -1 with errp set for any other error
 768  */
 769 static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,
 770                                              NBDExportInfo *info,
 771                                              Error **errp)
 772 {
 773     /*
 774      * TODO: Removing the x_dirty_bitmap hack will mean refactoring
 775      * this function to request and store ids for multiple contexts
 776      * (both base:allocation and a dirty bitmap), at which point this
 777      * function should lose the term _simple.
 778      */
 779     int ret;
 780     const char *context = info->x_dirty_bitmap ?: "base:allocation";
 781     bool received = false;
 782     char *name = NULL;
 783
 784     if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT,
 785                             info->name, context, errp) < 0) {
 786         return -1;
 787     }
 788
 789     ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 790                                        &name, &info->context_id, errp);
 791     if (ret < 0) {
 792         return -1;
 793     }
 794     if (ret == 1) {
 795         if (strcmp(context, name)) {
 796             error_setg(errp, "Failed to negotiate meta context '%s', server "
 797                        "answered with different context '%s'", context,
 798                        name);
 799             g_free(name);
 800             nbd_send_opt_abort(ioc);
 801             return -1;
 802         }
 803         g_free(name);
 804         received = true;
 805
 806         ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 807                                            NULL, NULL, errp);
 808         if (ret < 0) {
 809             return -1;
 810         }
 811     }
 812     if (ret != 0) {
 813         error_setg(errp, "Server answered with more than one context");
 814         nbd_send_opt_abort(ioc);
 815         return -1;
 816     }
 817     return received;
 818 }
 819
 820 /*
 821  * nbd_start_negotiate:
 822  * Start the handshake to the server.  After a positive return, the server
 823  * is ready to accept additional NBD_OPT requests.
 824  * Returns: negative errno: failure talking to server
 825  *          0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
 826  *          1: server is newstyle, but can only accept EXPORT_NAME
 827  *          2: server is newstyle, but lacks structured replies
 828  *          3: server is newstyle and set up for structured replies
 829  */
 830 static int nbd_start_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
 831                                const char *hostname, QIOChannel **outioc,
 832                                bool structured_reply, bool *zeroes,
 833                                Error **errp)
 834 {
 835     uint64_t magic;
 836
 837     trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>");
 838
 839     if (zeroes) {
 840         *zeroes = true;
 841     }
 842     if (outioc) {
 843         *outioc = NULL;
 844     }
 845     if (tlscreds && !outioc) {
 846         error_setg(errp, "Output I/O channel required for TLS");
 847         return -EINVAL;
 848     }
 849
 850     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 851         error_prepend(errp, "Failed to read initial magic: ");
 852         return -EINVAL;
 853     }
 854     magic = be64_to_cpu(magic);
 855     trace_nbd_receive_negotiate_magic(magic);
 856
 857     if (magic != NBD_INIT_MAGIC) {
 858         error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);
 859         return -EINVAL;
 860     }
 861
 862     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 863         error_prepend(errp, "Failed to read server magic: ");
 864         return -EINVAL;
 865     }
 866     magic = be64_to_cpu(magic);
 867     trace_nbd_receive_negotiate_magic(magic);
 868
 869     if (magic == NBD_OPTS_MAGIC) {
 870         uint32_t clientflags = 0;
 871         uint16_t globalflags;
 872         bool fixedNewStyle = false;
 873
 874         if (nbd_read(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
 875             error_prepend(errp, "Failed to read server flags: ");
 876             return -EINVAL;
 877         }
 878         globalflags = be16_to_cpu(globalflags);
 879         trace_nbd_receive_negotiate_server_flags(globalflags);
 880         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 881             fixedNewStyle = true;
 882             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 883         }
 884         if (globalflags & NBD_FLAG_NO_ZEROES) {
 885             if (zeroes) {
 886                 *zeroes = false;
 887             }
 888             clientflags |= NBD_FLAG_C_NO_ZEROES;
 889         }
 890         /* client requested flags */
 891         clientflags = cpu_to_be32(clientflags);
 892         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 893             error_prepend(errp, "Failed to send clientflags field: ");
 894             return -EINVAL;
 895         }
 896         if (tlscreds) {
 897             if (fixedNewStyle) {
 898                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 899                 if (!*outioc) {
 900                     return -EINVAL;
 901                 }
 902                 ioc = *outioc;
 903             } else {
 904                 error_setg(errp, "Server does not support STARTTLS");
 905                 return -EINVAL;
 906             }
 907         }
 908         if (fixedNewStyle) {
 909             int result = 0;
 910
 911             if (structured_reply) {
 912                 result = nbd_request_simple_option(ioc,
 913                                                    NBD_OPT_STRUCTURED_REPLY,
 914                                                    errp);
 915                 if (result < 0) {
 916                     return -EINVAL;
 917                 }
 918             }
 919             return 2 + result;
 920         } else {
 921             return 1;
 922         }
 923     } else if (magic == NBD_CLIENT_MAGIC) {
 924         if (tlscreds) {
 925             error_setg(errp, "Server does not support STARTTLS");
 926             return -EINVAL;
 927         }
 928         return 0;
 929     } else {
 930         error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);
 931         return -EINVAL;
 932     }
 933 }
 934
 935 /*
 936  * nbd_negotiate_finish_oldstyle:
 937  * Populate @info with the size and export flags from an oldstyle server,
 938  * but does not consume 124 bytes of reserved zero padding.
 939  * Returns 0 on success, -1 with @errp set on failure
 940  */
 941 static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info,
 942                                          Error **errp)
 943 {
 944     uint32_t oldflags;
 945
 946     if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 947         error_prepend(errp, "Failed to read export length: ");
 948         return -EINVAL;
 949     }
 950     info->size = be64_to_cpu(info->size);
 951
 952     if (nbd_read(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
 953         error_prepend(errp, "Failed to read export flags: ");
 954         return -EINVAL;
 955     }
 956     oldflags = be32_to_cpu(oldflags);
 957     if (oldflags & ~0xffff) {
 958         error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 959         return -EINVAL;
 960     }
 961     info->flags = oldflags;
 962     return 0;
 963 }
 964
 965 /*
 966  * nbd_receive_negotiate:
 967  * Connect to server, complete negotiation, and move into transmission phase.
 968  * Returns: negative errno: failure talking to server
 969  *          0: server is connected
 970  */
 971 int nbd_receive_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
 972                           const char *hostname, QIOChannel **outioc,
 973                           NBDExportInfo *info, Error **errp)
 974 {
 975     int result;
 976     bool zeroes;
 977     bool base_allocation = info->base_allocation;
 978
 979     assert(info->name);
 980     trace_nbd_receive_negotiate_name(info->name);
 981
 982     result = nbd_start_negotiate(ioc, tlscreds, hostname, outioc,
 983                                  info->structured_reply, &zeroes, errp);
 984
 985     info->structured_reply = false;
 986     info->base_allocation = false;
 987     if (tlscreds && *outioc) {
 988         ioc = *outioc;
 989     }
 990
 991     switch (result) {
 992     case 3: /* newstyle, with structured replies */
 993         info->structured_reply = true;
 994         if (base_allocation) {
 995             result = nbd_negotiate_simple_meta_context(ioc, info, errp);
 996             if (result < 0) {
 997                 return -EINVAL;
 998             }
 999             info->base_allocation = result == 1;
1000         }
1001         /* fall through */
1002     case 2: /* newstyle, try OPT_GO */
1003         /* Try NBD_OPT_GO first - if it works, we are done (it
1004          * also gives us a good message if the server requires
1005          * TLS).  If it is not available, fall back to
1006          * NBD_OPT_LIST for nicer error messages about a missing
1007          * export, then use NBD_OPT_EXPORT_NAME.  */
1008         result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp);
1009         if (result < 0) {
1010             return -EINVAL;
1011         }
1012         if (result > 0) {
1013             return 0;
1014         }
1015         /* Check our desired export is present in the
1016          * server export list. Since NBD_OPT_EXPORT_NAME
1017          * cannot return an error message, running this
1018          * query gives us better error reporting if the
1019          * export name is not available.
1020          */
1021         if (nbd_receive_query_exports(ioc, info->name, errp) < 0) {
1022             return -EINVAL;
1023         }
1024         /* fall through */
1025     case 1: /* newstyle, but limited to EXPORT_NAME */
1026         /* write the export name request */
1027         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name,
1028                                     errp) < 0) {
1029             return -EINVAL;
1030         }
1031
1032         /* Read the response */
1033         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
1034             error_prepend(errp, "Failed to read export length: ");
1035             return -EINVAL;
1036         }
1037         info->size = be64_to_cpu(info->size);
1038
1039         if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
1040             error_prepend(errp, "Failed to read export flags: ");
1041             return -EINVAL;
1042         }
1043         info->flags = be16_to_cpu(info->flags);
1044         break;
1045     case 0: /* oldstyle, parse length and flags */
1046         if (*info->name) {
1047             error_setg(errp, "Server does not support non-empty export names");
1048             return -EINVAL;
1049         }
1050         if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) {
1051             return -EINVAL;
1052         }
1053         break;
1054     default:
1055         return result;
1056     }
1057
1058     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
1059     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
1060         error_prepend(errp, "Failed to read reserved block: ");
1061         return -EINVAL;
1062     }
1063     return 0;
1064 }
1065
1066 /* Clean up result of nbd_receive_export_list */
1067 void nbd_free_export_list(NBDExportInfo *info, int count)
1068 {
1069     int i;
1070
1071     if (!info) {
1072         return;
1073     }
1074
1075     for (i = 0; i < count; i++) {
1076         g_free(info[i].name);
1077         g_free(info[i].description);
1078     }
1079     g_free(info);
1080 }
1081
1082 /*
1083  * nbd_receive_export_list:
1084  * Query details about a server's exports, then disconnect without
1085  * going into transmission phase. Return a count of the exports listed
1086  * in @info by the server, or -1 on error. Caller must free @info using
1087  * nbd_free_export_list().
1088  */
1089 int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
1090                             const char *hostname, NBDExportInfo **info,
1091                             Error **errp)
1092 {
1093     int result;
1094     int count = 0;
1095     int i;
1096     int rc;
1097     int ret = -1;
1098     NBDExportInfo *array = NULL;
1099     QIOChannel *sioc = NULL;
1100
1101     *info = NULL;
1102     result = nbd_start_negotiate(ioc, tlscreds, hostname, &sioc, true, NULL,
1103                                  errp);
1104     if (tlscreds && sioc) {
1105         ioc = sioc;
1106     }
1107
1108     switch (result) {
1109     case 2:
1110     case 3:
1111         /* newstyle - use NBD_OPT_LIST to populate array, then try
1112          * NBD_OPT_INFO on each array member. If structured replies
1113          * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */
1114         if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
1115             goto out;
1116         }
1117         while (1) {
1118             char *name;
1119             char *desc;
1120
1121             rc = nbd_receive_list(ioc, &name, &desc, errp);
1122             if (rc < 0) {
1123                 goto out;
1124             } else if (rc == 0) {
1125                 break;
1126             }
1127             array = g_renew(NBDExportInfo, array, ++count);
1128             memset(&array[count - 1], 0, sizeof(*array));
1129             array[count - 1].name = name;
1130             array[count - 1].description = desc;
1131             array[count - 1].structured_reply = result == 3;
1132         }
1133
1134         for (i = 0; i < count; i++) {
1135             array[i].request_sizes = true;
1136             rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp);
1137             if (rc < 0) {
1138                 goto out;
1139             } else if (rc == 0) {
1140                 /*
1141                  * Pointless to try rest of loop. If OPT_INFO doesn't work,
1142                  * it's unlikely that meta contexts work either
1143                  */
1144                 break;
1145             }
1146
1147             /* TODO: Grab meta contexts */
1148         }
1149
1150         /* Send NBD_OPT_ABORT as a courtesy before hanging up */
1151         nbd_send_opt_abort(ioc);
1152         break;
1153     case 1: /* newstyle, but limited to EXPORT_NAME */
1154         error_setg(errp, "Server does not support export lists");
1155         /* We can't even send NBD_OPT_ABORT, so merely hang up */
1156         goto out;
1157     case 0: /* oldstyle, parse length and flags */
1158         array = g_new0(NBDExportInfo, 1);
1159         array->name = g_strdup("");
1160         count = 1;
1161
1162         if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) {
1163             goto out;
1164         }
1165
1166         /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all
1167          * errors now that we have the information we wanted. */
1168         if (nbd_drop(ioc, 124, NULL) == 0) {
1169             NBDRequest request = { .type = NBD_CMD_DISC };
1170
1171             nbd_send_request(ioc, &request);
1172         }
1173         break;
1174     default:
1175         goto out;
1176     }
1177
1178     *info = array;
1179     array = NULL;
1180     ret = count;
1181
1182  out:
1183     qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
1184     qio_channel_close(ioc, NULL);
1185     object_unref(OBJECT(sioc));
1186     nbd_free_export_list(array, count);
1187     return ret;
1188 }
1189
1190 #ifdef __linux__
1191 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
1192              Error **errp)
1193 {
1194     unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
1195     unsigned long sectors = info->size / sector_size;
1196
1197     /* FIXME: Once the kernel module is patched to honor block sizes,
1198      * and to advertise that fact to user space, we should update the
1199      * hand-off to the kernel to use any block sizes we learned. */
1200     assert(!info->request_sizes);
1201     if (info->size / sector_size != sectors) {
1202         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
1203                    info->size);
1204         return -E2BIG;
1205     }
1206
1207     trace_nbd_init_set_socket();
1208
1209     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
1210         int serrno = errno;
1211         error_setg(errp, "Failed to set NBD socket");
1212         return -serrno;
1213     }
1214
1215     trace_nbd_init_set_block_size(sector_size);
1216
1217     if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
1218         int serrno = errno;
1219         error_setg(errp, "Failed setting NBD block size");
1220         return -serrno;
1221     }
1222
1223     trace_nbd_init_set_size(sectors);
1224     if (info->size % sector_size) {
1225         trace_nbd_init_trailing_bytes(info->size % sector_size);
1226     }
1227
1228     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
1229         int serrno = errno;
1230         error_setg(errp, "Failed setting size (in blocks)");
1231         return -serrno;
1232     }
1233
1234     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
1235         if (errno == ENOTTY) {
1236             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
1237             trace_nbd_init_set_readonly();
1238
1239             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
1240                 int serrno = errno;
1241                 error_setg(errp, "Failed setting read-only attribute");
1242                 return -serrno;
1243             }
1244         } else {
1245             int serrno = errno;
1246             error_setg(errp, "Failed setting flags");
1247             return -serrno;
1248         }
1249     }
1250
1251     trace_nbd_init_finish();
1252
1253     return 0;
1254 }
1255
1256 int nbd_client(int fd)
1257 {
1258     int ret;
1259     int serrno;
1260
1261     trace_nbd_client_loop();
1262
1263     ret = ioctl(fd, NBD_DO_IT);
1264     if (ret < 0 && errno == EPIPE) {
1265         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1266          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
1267          * that case.
1268          */
1269         ret = 0;
1270     }
1271     serrno = errno;
1272
1273     trace_nbd_client_loop_ret(ret, strerror(serrno));
1274
1275     trace_nbd_client_clear_queue();
1276     ioctl(fd, NBD_CLEAR_QUE);
1277
1278     trace_nbd_client_clear_socket();
1279     ioctl(fd, NBD_CLEAR_SOCK);
1280
1281     errno = serrno;
1282     return ret;
1283 }
1284
1285 int nbd_disconnect(int fd)
1286 {
1287     ioctl(fd, NBD_CLEAR_QUE);
1288     ioctl(fd, NBD_DISCONNECT);
1289     ioctl(fd, NBD_CLEAR_SOCK);
1290     return 0;
1291 }
1292
1293 #endif /* __linux__ */
1294
1295 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
1296 {
1297     uint8_t buf[NBD_REQUEST_SIZE];
1298
1299     trace_nbd_send_request(request->from, request->len, request->handle,
1300                            request->flags, request->type,
1301                            nbd_cmd_lookup(request->type));
1302
1303     stl_be_p(buf, NBD_REQUEST_MAGIC);
1304     stw_be_p(buf + 4, request->flags);
1305     stw_be_p(buf + 6, request->type);
1306     stq_be_p(buf + 8, request->handle);
1307     stq_be_p(buf + 16, request->from);
1308     stl_be_p(buf + 24, request->len);
1309
1310     return nbd_write(ioc, buf, sizeof(buf), NULL);
1311 }
1312
1313 /* nbd_receive_simple_reply
1314  * Read simple reply except magic field (which should be already read).
1315  * Payload is not read (payload is possible for CMD_READ, but here we even
1316  * don't know whether it take place or not).
1317  */
1318 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
1319                                     Error **errp)
1320 {
1321     int ret;
1322
1323     assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
1324
1325     ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
1326                    sizeof(*reply) - sizeof(reply->magic), errp);
1327     if (ret < 0) {
1328         return ret;
1329     }
1330
1331     reply->error = be32_to_cpu(reply->error);
1332     reply->handle = be64_to_cpu(reply->handle);
1333
1334     return 0;
1335 }
1336
1337 /* nbd_receive_structured_reply_chunk
1338  * Read structured reply chunk except magic field (which should be already
1339  * read).
1340  * Payload is not read.
1341  */
1342 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
1343                                               NBDStructuredReplyChunk *chunk,
1344                                               Error **errp)
1345 {
1346     int ret;
1347
1348     assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
1349
1350     ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
1351                    sizeof(*chunk) - sizeof(chunk->magic), errp);
1352     if (ret < 0) {
1353         return ret;
1354     }
1355
1356     chunk->flags = be16_to_cpu(chunk->flags);
1357     chunk->type = be16_to_cpu(chunk->type);
1358     chunk->handle = be64_to_cpu(chunk->handle);
1359     chunk->length = be32_to_cpu(chunk->length);
1360
1361     return 0;
1362 }
1363
1364 /* nbd_receive_reply
1365  * Returns 1 on success
1366  *         0 on eof, when no data was read (errp is not set)
1367  *         negative errno on failure (errp is set)
1368  */
1369 int nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
1370 {
1371     int ret;
1372     const char *type;
1373
1374     ret = nbd_read_eof(ioc, &reply->magic, sizeof(reply->magic), errp);
1375     if (ret <= 0) {
1376         return ret;
1377     }
1378
1379     reply->magic = be32_to_cpu(reply->magic);
1380
1381     switch (reply->magic) {
1382     case NBD_SIMPLE_REPLY_MAGIC:
1383         ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
1384         if (ret < 0) {
1385             break;
1386         }
1387         trace_nbd_receive_simple_reply(reply->simple.error,
1388                                        nbd_err_lookup(reply->simple.error),
1389                                        reply->handle);
1390         break;
1391     case NBD_STRUCTURED_REPLY_MAGIC:
1392         ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
1393         if (ret < 0) {
1394             break;
1395         }
1396         type = nbd_reply_type_lookup(reply->structured.type);
1397         trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
1398                                                  reply->structured.type, type,
1399                                                  reply->structured.handle,
1400                                                  reply->structured.length);
1401         break;
1402     default:
1403         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
1404         return -EINVAL;
1405     }
1406     if (ret < 0) {
1407         return ret;
1408     }
1409
1410     return 1;
1411 }
1412