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 /* Returns -1 if NBD_OPT_GO proves the export @info->name cannot be
 334  * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
 335  * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
 336  * go (with the rest of @info populated). */
 337 static int nbd_opt_go(QIOChannel *ioc, NBDExportInfo *info, Error **errp)
 338 {
 339     NBDOptionReply reply;
 340     uint32_t len = strlen(info->name);
 341     uint16_t type;
 342     int error;
 343     char *buf;
 344
 345     /* The protocol requires that the server send NBD_INFO_EXPORT with
 346      * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
 347      * flags still 0 is a witness of a broken server. */
 348     info->flags = 0;
 349
 350     trace_nbd_opt_go_start(info->name);
 351     buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
 352     stl_be_p(buf, len);
 353     memcpy(buf + 4, info->name, len);
 354     /* At most one request, everything else up to server */
 355     stw_be_p(buf + 4 + len, info->request_sizes);
 356     if (info->request_sizes) {
 357         stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
 358     }
 359     error = nbd_send_option_request(ioc, NBD_OPT_GO,
 360                                     4 + len + 2 + 2 * info->request_sizes,
 361                                     buf, errp);
 362     g_free(buf);
 363     if (error < 0) {
 364         return -1;
 365     }
 366
 367     while (1) {
 368         if (nbd_receive_option_reply(ioc, NBD_OPT_GO, &reply, errp) < 0) {
 369             return -1;
 370         }
 371         error = nbd_handle_reply_err(ioc, &reply, errp);
 372         if (error <= 0) {
 373             return error;
 374         }
 375         len = reply.length;
 376
 377         if (reply.type == NBD_REP_ACK) {
 378             /* Server is done sending info and moved into transmission
 379                phase, but make sure it sent flags */
 380             if (len) {
 381                 error_setg(errp, "server sent invalid NBD_REP_ACK");
 382                 return -1;
 383             }
 384             if (!info->flags) {
 385                 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
 386                 return -1;
 387             }
 388             trace_nbd_opt_go_success();
 389             return 1;
 390         }
 391         if (reply.type != NBD_REP_INFO) {
 392             error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",
 393                        reply.type, nbd_rep_lookup(reply.type),
 394                        NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));
 395             nbd_send_opt_abort(ioc);
 396             return -1;
 397         }
 398         if (len < sizeof(type)) {
 399             error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
 400                        len);
 401             nbd_send_opt_abort(ioc);
 402             return -1;
 403         }
 404         if (nbd_read(ioc, &type, sizeof(type), errp) < 0) {
 405             error_prepend(errp, "failed to read info type: ");
 406             nbd_send_opt_abort(ioc);
 407             return -1;
 408         }
 409         len -= sizeof(type);
 410         type = be16_to_cpu(type);
 411         switch (type) {
 412         case NBD_INFO_EXPORT:
 413             if (len != sizeof(info->size) + sizeof(info->flags)) {
 414                 error_setg(errp, "remaining export info len %" PRIu32
 415                            " is unexpected size", len);
 416                 nbd_send_opt_abort(ioc);
 417                 return -1;
 418             }
 419             if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 420                 error_prepend(errp, "failed to read info size: ");
 421                 nbd_send_opt_abort(ioc);
 422                 return -1;
 423             }
 424             info->size = be64_to_cpu(info->size);
 425             if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 426                 error_prepend(errp, "failed to read info flags: ");
 427                 nbd_send_opt_abort(ioc);
 428                 return -1;
 429             }
 430             info->flags = be16_to_cpu(info->flags);
 431             trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 432             break;
 433
 434         case NBD_INFO_BLOCK_SIZE:
 435             if (len != sizeof(info->min_block) * 3) {
 436                 error_setg(errp, "remaining export info len %" PRIu32
 437                            " is unexpected size", len);
 438                 nbd_send_opt_abort(ioc);
 439                 return -1;
 440             }
 441             if (nbd_read(ioc, &info->min_block, sizeof(info->min_block),
 442                          errp) < 0) {
 443                 error_prepend(errp, "failed to read info minimum block size: ");
 444                 nbd_send_opt_abort(ioc);
 445                 return -1;
 446             }
 447             info->min_block = be32_to_cpu(info->min_block);
 448             if (!is_power_of_2(info->min_block)) {
 449                 error_setg(errp, "server minimum block size %" PRIu32
 450                            " is not a power of two", info->min_block);
 451                 nbd_send_opt_abort(ioc);
 452                 return -1;
 453             }
 454             if (nbd_read(ioc, &info->opt_block, sizeof(info->opt_block),
 455                          errp) < 0) {
 456                 error_prepend(errp,
 457                               "failed to read info preferred block size: ");
 458                 nbd_send_opt_abort(ioc);
 459                 return -1;
 460             }
 461             info->opt_block = be32_to_cpu(info->opt_block);
 462             if (!is_power_of_2(info->opt_block) ||
 463                 info->opt_block < info->min_block) {
 464                 error_setg(errp, "server preferred block size %" PRIu32
 465                            " is not valid", info->opt_block);
 466                 nbd_send_opt_abort(ioc);
 467                 return -1;
 468             }
 469             if (nbd_read(ioc, &info->max_block, sizeof(info->max_block),
 470                          errp) < 0) {
 471                 error_prepend(errp, "failed to read info maximum block size: ");
 472                 nbd_send_opt_abort(ioc);
 473                 return -1;
 474             }
 475             info->max_block = be32_to_cpu(info->max_block);
 476             if (info->max_block < info->min_block) {
 477                 error_setg(errp, "server maximum block size %" PRIu32
 478                            " is not valid", info->max_block);
 479                 nbd_send_opt_abort(ioc);
 480                 return -1;
 481             }
 482             trace_nbd_opt_go_info_block_size(info->min_block, info->opt_block,
 483                                              info->max_block);
 484             break;
 485
 486         default:
 487             trace_nbd_opt_go_info_unknown(type, nbd_info_lookup(type));
 488             if (nbd_drop(ioc, len, errp) < 0) {
 489                 error_prepend(errp, "Failed to read info payload: ");
 490                 nbd_send_opt_abort(ioc);
 491                 return -1;
 492             }
 493             break;
 494         }
 495     }
 496 }
 497
 498 /* Return -1 on failure, 0 if wantname is an available export. */
 499 static int nbd_receive_query_exports(QIOChannel *ioc,
 500                                      const char *wantname,
 501                                      Error **errp)
 502 {
 503     bool list_empty = true;
 504     bool found_export = false;
 505
 506     trace_nbd_receive_query_exports_start(wantname);
 507     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 508         return -1;
 509     }
 510
 511     while (1) {
 512         char *name;
 513         int ret = nbd_receive_list(ioc, &name, NULL, errp);
 514
 515         if (ret < 0) {
 516             /* Server gave unexpected reply */
 517             return -1;
 518         } else if (ret == 0) {
 519             /* Done iterating. */
 520             if (list_empty) {
 521                 /*
 522                  * We don't have enough context to tell a server that
 523                  * sent an empty list apart from a server that does
 524                  * not support the list command; but as this function
 525                  * is just used to trigger a nicer error message
 526                  * before trying NBD_OPT_EXPORT_NAME, assume the
 527                  * export is available.
 528                  */
 529                 return 0;
 530             } else if (!found_export) {
 531                 error_setg(errp, "No export with name '%s' available",
 532                            wantname);
 533                 nbd_send_opt_abort(ioc);
 534                 return -1;
 535             }
 536             trace_nbd_receive_query_exports_success(wantname);
 537             return 0;
 538         }
 539         list_empty = false;
 540         if (!strcmp(name, wantname)) {
 541             found_export = true;
 542         }
 543         g_free(name);
 544     }
 545 }
 546
 547 /* nbd_request_simple_option: Send an option request, and parse the reply
 548  * return 1 for successful negotiation,
 549  *        0 if operation is unsupported,
 550  *        -1 with errp set for any other error
 551  */
 552 static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp)
 553 {
 554     NBDOptionReply reply;
 555     int error;
 556
 557     if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
 558         return -1;
 559     }
 560
 561     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 562         return -1;
 563     }
 564     error = nbd_handle_reply_err(ioc, &reply, errp);
 565     if (error <= 0) {
 566         return error;
 567     }
 568
 569     if (reply.type != NBD_REP_ACK) {
 570         error_setg(errp, "Server answered option %d (%s) with unexpected "
 571                    "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),
 572                    reply.type, nbd_rep_lookup(reply.type));
 573         nbd_send_opt_abort(ioc);
 574         return -1;
 575     }
 576
 577     if (reply.length != 0) {
 578         error_setg(errp, "Option %d ('%s') response length is %" PRIu32
 579                    " (it should be zero)", opt, nbd_opt_lookup(opt),
 580                    reply.length);
 581         nbd_send_opt_abort(ioc);
 582         return -1;
 583     }
 584
 585     return 1;
 586 }
 587
 588 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 589                                         QCryptoTLSCreds *tlscreds,
 590                                         const char *hostname, Error **errp)
 591 {
 592     int ret;
 593     QIOChannelTLS *tioc;
 594     struct NBDTLSHandshakeData data = { 0 };
 595
 596     ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp);
 597     if (ret <= 0) {
 598         if (ret == 0) {
 599             error_setg(errp, "Server don't support STARTTLS option");
 600             nbd_send_opt_abort(ioc);
 601         }
 602         return NULL;
 603     }
 604
 605     trace_nbd_receive_starttls_new_client();
 606     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 607     if (!tioc) {
 608         return NULL;
 609     }
 610     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 611     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 612     trace_nbd_receive_starttls_tls_handshake();
 613     qio_channel_tls_handshake(tioc,
 614                               nbd_tls_handshake,
 615                               &data,
 616                               NULL,
 617                               NULL);
 618
 619     if (!data.complete) {
 620         g_main_loop_run(data.loop);
 621     }
 622     g_main_loop_unref(data.loop);
 623     if (data.error) {
 624         error_propagate(errp, data.error);
 625         object_unref(OBJECT(tioc));
 626         return NULL;
 627     }
 628
 629     return QIO_CHANNEL(tioc);
 630 }
 631
 632 /*
 633  * nbd_send_meta_query:
 634  * Send 0 or 1 set/list meta context queries.
 635  * Return 0 on success, -1 with errp set for any error
 636  */
 637 static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt,
 638                                const char *export, const char *query,
 639                                Error **errp)
 640 {
 641     int ret;
 642     uint32_t export_len = strlen(export);
 643     uint32_t queries = !!query;
 644     uint32_t query_len = 0;
 645     uint32_t data_len;
 646     char *data;
 647     char *p;
 648
 649     data_len = sizeof(export_len) + export_len + sizeof(queries);
 650     if (query) {
 651         query_len = strlen(query);
 652         data_len += sizeof(query_len) + query_len;
 653     } else {
 654         assert(opt == NBD_OPT_LIST_META_CONTEXT);
 655     }
 656     p = data = g_malloc(data_len);
 657
 658     trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export);
 659     stl_be_p(p, export_len);
 660     memcpy(p += sizeof(export_len), export, export_len);
 661     stl_be_p(p += export_len, queries);
 662     if (query) {
 663         stl_be_p(p += sizeof(queries), query_len);
 664         memcpy(p += sizeof(query_len), query, query_len);
 665     }
 666
 667     ret = nbd_send_option_request(ioc, opt, data_len, data, errp);
 668     g_free(data);
 669     return ret;
 670 }
 671
 672 /*
 673  * nbd_receive_one_meta_context:
 674  * Called in a loop to receive and trace one set/list meta context reply.
 675  * Pass non-NULL @name or @id to collect results back to the caller, which
 676  * must eventually call g_free().
 677  * return 1 if name is set and iteration must continue,
 678  *        0 if iteration is complete (including if option is unsupported),
 679  *        -1 with errp set for any error
 680  */
 681 static int nbd_receive_one_meta_context(QIOChannel *ioc,
 682                                         uint32_t opt,
 683                                         char **name,
 684                                         uint32_t *id,
 685                                         Error **errp)
 686 {
 687     int ret;
 688     NBDOptionReply reply;
 689     char *local_name = NULL;
 690     uint32_t local_id;
 691
 692     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 693         return -1;
 694     }
 695
 696     ret = nbd_handle_reply_err(ioc, &reply, errp);
 697     if (ret <= 0) {
 698         return ret;
 699     }
 700
 701     if (reply.type == NBD_REP_ACK) {
 702         if (reply.length != 0) {
 703             error_setg(errp, "Unexpected length to ACK response");
 704             nbd_send_opt_abort(ioc);
 705             return -1;
 706         }
 707         return 0;
 708     } else if (reply.type != NBD_REP_META_CONTEXT) {
 709         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 710                    reply.type, nbd_rep_lookup(reply.type),
 711                    NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT));
 712         nbd_send_opt_abort(ioc);
 713         return -1;
 714     }
 715
 716     if (reply.length <= sizeof(local_id) ||
 717         reply.length > NBD_MAX_BUFFER_SIZE) {
 718         error_setg(errp, "Failed to negotiate meta context, server "
 719                    "answered with unexpected length %" PRIu32,
 720                    reply.length);
 721         nbd_send_opt_abort(ioc);
 722         return -1;
 723     }
 724
 725     if (nbd_read(ioc, &local_id, sizeof(local_id), errp) < 0) {
 726         return -1;
 727     }
 728     local_id = be32_to_cpu(local_id);
 729
 730     reply.length -= sizeof(local_id);
 731     local_name = g_malloc(reply.length + 1);
 732     if (nbd_read(ioc, local_name, reply.length, errp) < 0) {
 733         g_free(local_name);
 734         return -1;
 735     }
 736     local_name[reply.length] = '\0';
 737     trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id);
 738
 739     if (name) {
 740         *name = local_name;
 741     } else {
 742         g_free(local_name);
 743     }
 744     if (id) {
 745         *id = local_id;
 746     }
 747     return 1;
 748 }
 749
 750 /*
 751  * nbd_negotiate_simple_meta_context:
 752  * Request the server to set the meta context for export @info->name
 753  * using @info->x_dirty_bitmap with a fallback to "base:allocation",
 754  * setting @info->context_id to the resulting id. Fail if the server
 755  * responds with more than one context or with a context different
 756  * than the query.
 757  * return 1 for successful negotiation,
 758  *        0 if operation is unsupported,
 759  *        -1 with errp set for any other error
 760  */
 761 static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,
 762                                              NBDExportInfo *info,
 763                                              Error **errp)
 764 {
 765     /*
 766      * TODO: Removing the x_dirty_bitmap hack will mean refactoring
 767      * this function to request and store ids for multiple contexts
 768      * (both base:allocation and a dirty bitmap), at which point this
 769      * function should lose the term _simple.
 770      */
 771     int ret;
 772     const char *context = info->x_dirty_bitmap ?: "base:allocation";
 773     bool received = false;
 774     char *name = NULL;
 775
 776     if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT,
 777                             info->name, context, errp) < 0) {
 778         return -1;
 779     }
 780
 781     ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 782                                        &name, &info->context_id, errp);
 783     if (ret < 0) {
 784         return -1;
 785     }
 786     if (ret == 1) {
 787         if (strcmp(context, name)) {
 788             error_setg(errp, "Failed to negotiate meta context '%s', server "
 789                        "answered with different context '%s'", context,
 790                        name);
 791             g_free(name);
 792             nbd_send_opt_abort(ioc);
 793             return -1;
 794         }
 795         g_free(name);
 796         received = true;
 797
 798         ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 799                                            NULL, NULL, errp);
 800         if (ret < 0) {
 801             return -1;
 802         }
 803     }
 804     if (ret != 0) {
 805         error_setg(errp, "Server answered with more than one context");
 806         nbd_send_opt_abort(ioc);
 807         return -1;
 808     }
 809     return received;
 810 }
 811
 812 /*
 813  * nbd_start_negotiate:
 814  * Start the handshake to the server.  After a positive return, the server
 815  * is ready to accept additional NBD_OPT requests.
 816  * Returns: negative errno: failure talking to server
 817  *          0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
 818  *          1: server is newstyle, but can only accept EXPORT_NAME
 819  *          2: server is newstyle, but lacks structured replies
 820  *          3: server is newstyle and set up for structured replies
 821  */
 822 static int nbd_start_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
 823                                const char *hostname, QIOChannel **outioc,
 824                                bool structured_reply, bool *zeroes,
 825                                Error **errp)
 826 {
 827     uint64_t magic;
 828
 829     trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>");
 830
 831     *zeroes = true;
 832     if (outioc) {
 833         *outioc = NULL;
 834     }
 835     if (tlscreds && !outioc) {
 836         error_setg(errp, "Output I/O channel required for TLS");
 837         return -EINVAL;
 838     }
 839
 840     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 841         error_prepend(errp, "Failed to read initial magic: ");
 842         return -EINVAL;
 843     }
 844     magic = be64_to_cpu(magic);
 845     trace_nbd_receive_negotiate_magic(magic);
 846
 847     if (magic != NBD_INIT_MAGIC) {
 848         error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);
 849         return -EINVAL;
 850     }
 851
 852     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 853         error_prepend(errp, "Failed to read server magic: ");
 854         return -EINVAL;
 855     }
 856     magic = be64_to_cpu(magic);
 857     trace_nbd_receive_negotiate_magic(magic);
 858
 859     if (magic == NBD_OPTS_MAGIC) {
 860         uint32_t clientflags = 0;
 861         uint16_t globalflags;
 862         bool fixedNewStyle = false;
 863
 864         if (nbd_read(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
 865             error_prepend(errp, "Failed to read server flags: ");
 866             return -EINVAL;
 867         }
 868         globalflags = be16_to_cpu(globalflags);
 869         trace_nbd_receive_negotiate_server_flags(globalflags);
 870         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 871             fixedNewStyle = true;
 872             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 873         }
 874         if (globalflags & NBD_FLAG_NO_ZEROES) {
 875             *zeroes = false;
 876             clientflags |= NBD_FLAG_C_NO_ZEROES;
 877         }
 878         /* client requested flags */
 879         clientflags = cpu_to_be32(clientflags);
 880         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 881             error_prepend(errp, "Failed to send clientflags field: ");
 882             return -EINVAL;
 883         }
 884         if (tlscreds) {
 885             if (fixedNewStyle) {
 886                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 887                 if (!*outioc) {
 888                     return -EINVAL;
 889                 }
 890                 ioc = *outioc;
 891             } else {
 892                 error_setg(errp, "Server does not support STARTTLS");
 893                 return -EINVAL;
 894             }
 895         }
 896         if (fixedNewStyle) {
 897             int result = 0;
 898
 899             if (structured_reply) {
 900                 result = nbd_request_simple_option(ioc,
 901                                                    NBD_OPT_STRUCTURED_REPLY,
 902                                                    errp);
 903                 if (result < 0) {
 904                     return -EINVAL;
 905                 }
 906             }
 907             return 2 + result;
 908         } else {
 909             return 1;
 910         }
 911     } else if (magic == NBD_CLIENT_MAGIC) {
 912         if (tlscreds) {
 913             error_setg(errp, "Server does not support STARTTLS");
 914             return -EINVAL;
 915         }
 916         return 0;
 917     } else {
 918         error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);
 919         return -EINVAL;
 920     }
 921 }
 922
 923 /*
 924  * nbd_negotiate_finish_oldstyle:
 925  * Populate @info with the size and export flags from an oldstyle server,
 926  * but does not consume 124 bytes of reserved zero padding.
 927  * Returns 0 on success, -1 with @errp set on failure
 928  */
 929 static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info,
 930                                          Error **errp)
 931 {
 932     uint32_t oldflags;
 933
 934     if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 935         error_prepend(errp, "Failed to read export length: ");
 936         return -EINVAL;
 937     }
 938     info->size = be64_to_cpu(info->size);
 939
 940     if (nbd_read(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
 941         error_prepend(errp, "Failed to read export flags: ");
 942         return -EINVAL;
 943     }
 944     oldflags = be32_to_cpu(oldflags);
 945     if (oldflags & ~0xffff) {
 946         error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 947         return -EINVAL;
 948     }
 949     info->flags = oldflags;
 950     return 0;
 951 }
 952
 953 /*
 954  * nbd_receive_negotiate:
 955  * Connect to server, complete negotiation, and move into transmission phase.
 956  * Returns: negative errno: failure talking to server
 957  *          0: server is connected
 958  */
 959 int nbd_receive_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
 960                           const char *hostname, QIOChannel **outioc,
 961                           NBDExportInfo *info, Error **errp)
 962 {
 963     int result;
 964     bool zeroes;
 965     bool base_allocation = info->base_allocation;
 966
 967     assert(info->name);
 968     trace_nbd_receive_negotiate_name(info->name);
 969
 970     result = nbd_start_negotiate(ioc, tlscreds, hostname, outioc,
 971                                  info->structured_reply, &zeroes, errp);
 972
 973     info->structured_reply = false;
 974     info->base_allocation = false;
 975     if (tlscreds && *outioc) {
 976         ioc = *outioc;
 977     }
 978
 979     switch (result) {
 980     case 3: /* newstyle, with structured replies */
 981         info->structured_reply = true;
 982         if (base_allocation) {
 983             result = nbd_negotiate_simple_meta_context(ioc, info, errp);
 984             if (result < 0) {
 985                 return -EINVAL;
 986             }
 987             info->base_allocation = result == 1;
 988         }
 989         /* fall through */
 990     case 2: /* newstyle, try OPT_GO */
 991         /* Try NBD_OPT_GO first - if it works, we are done (it
 992          * also gives us a good message if the server requires
 993          * TLS).  If it is not available, fall back to
 994          * NBD_OPT_LIST for nicer error messages about a missing
 995          * export, then use NBD_OPT_EXPORT_NAME.  */
 996         result = nbd_opt_go(ioc, info, errp);
 997         if (result < 0) {
 998             return -EINVAL;
 999         }
1000         if (result > 0) {
1001             return 0;
1002         }
1003         /* Check our desired export is present in the
1004          * server export list. Since NBD_OPT_EXPORT_NAME
1005          * cannot return an error message, running this
1006          * query gives us better error reporting if the
1007          * export name is not available.
1008          */
1009         if (nbd_receive_query_exports(ioc, info->name, errp) < 0) {
1010             return -EINVAL;
1011         }
1012         /* fall through */
1013     case 1: /* newstyle, but limited to EXPORT_NAME */
1014         /* write the export name request */
1015         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name,
1016                                     errp) < 0) {
1017             return -EINVAL;
1018         }
1019
1020         /* Read the response */
1021         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
1022             error_prepend(errp, "Failed to read export length: ");
1023             return -EINVAL;
1024         }
1025         info->size = be64_to_cpu(info->size);
1026
1027         if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
1028             error_prepend(errp, "Failed to read export flags: ");
1029             return -EINVAL;
1030         }
1031         info->flags = be16_to_cpu(info->flags);
1032         break;
1033     case 0: /* oldstyle, parse length and flags */
1034         if (*info->name) {
1035             error_setg(errp, "Server does not support non-empty export names");
1036             return -EINVAL;
1037         }
1038         if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) {
1039             return -EINVAL;
1040         }
1041         break;
1042     default:
1043         return result;
1044     }
1045
1046     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
1047     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
1048         error_prepend(errp, "Failed to read reserved block: ");
1049         return -EINVAL;
1050     }
1051     return 0;
1052 }
1053
1054 #ifdef __linux__
1055 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
1056              Error **errp)
1057 {
1058     unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
1059     unsigned long sectors = info->size / sector_size;
1060
1061     /* FIXME: Once the kernel module is patched to honor block sizes,
1062      * and to advertise that fact to user space, we should update the
1063      * hand-off to the kernel to use any block sizes we learned. */
1064     assert(!info->request_sizes);
1065     if (info->size / sector_size != sectors) {
1066         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
1067                    info->size);
1068         return -E2BIG;
1069     }
1070
1071     trace_nbd_init_set_socket();
1072
1073     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
1074         int serrno = errno;
1075         error_setg(errp, "Failed to set NBD socket");
1076         return -serrno;
1077     }
1078
1079     trace_nbd_init_set_block_size(sector_size);
1080
1081     if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
1082         int serrno = errno;
1083         error_setg(errp, "Failed setting NBD block size");
1084         return -serrno;
1085     }
1086
1087     trace_nbd_init_set_size(sectors);
1088     if (info->size % sector_size) {
1089         trace_nbd_init_trailing_bytes(info->size % sector_size);
1090     }
1091
1092     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
1093         int serrno = errno;
1094         error_setg(errp, "Failed setting size (in blocks)");
1095         return -serrno;
1096     }
1097
1098     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
1099         if (errno == ENOTTY) {
1100             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
1101             trace_nbd_init_set_readonly();
1102
1103             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
1104                 int serrno = errno;
1105                 error_setg(errp, "Failed setting read-only attribute");
1106                 return -serrno;
1107             }
1108         } else {
1109             int serrno = errno;
1110             error_setg(errp, "Failed setting flags");
1111             return -serrno;
1112         }
1113     }
1114
1115     trace_nbd_init_finish();
1116
1117     return 0;
1118 }
1119
1120 int nbd_client(int fd)
1121 {
1122     int ret;
1123     int serrno;
1124
1125     trace_nbd_client_loop();
1126
1127     ret = ioctl(fd, NBD_DO_IT);
1128     if (ret < 0 && errno == EPIPE) {
1129         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1130          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
1131          * that case.
1132          */
1133         ret = 0;
1134     }
1135     serrno = errno;
1136
1137     trace_nbd_client_loop_ret(ret, strerror(serrno));
1138
1139     trace_nbd_client_clear_queue();
1140     ioctl(fd, NBD_CLEAR_QUE);
1141
1142     trace_nbd_client_clear_socket();
1143     ioctl(fd, NBD_CLEAR_SOCK);
1144
1145     errno = serrno;
1146     return ret;
1147 }
1148
1149 int nbd_disconnect(int fd)
1150 {
1151     ioctl(fd, NBD_CLEAR_QUE);
1152     ioctl(fd, NBD_DISCONNECT);
1153     ioctl(fd, NBD_CLEAR_SOCK);
1154     return 0;
1155 }
1156
1157 #endif /* __linux__ */
1158
1159 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
1160 {
1161     uint8_t buf[NBD_REQUEST_SIZE];
1162
1163     trace_nbd_send_request(request->from, request->len, request->handle,
1164                            request->flags, request->type,
1165                            nbd_cmd_lookup(request->type));
1166
1167     stl_be_p(buf, NBD_REQUEST_MAGIC);
1168     stw_be_p(buf + 4, request->flags);
1169     stw_be_p(buf + 6, request->type);
1170     stq_be_p(buf + 8, request->handle);
1171     stq_be_p(buf + 16, request->from);
1172     stl_be_p(buf + 24, request->len);
1173
1174     return nbd_write(ioc, buf, sizeof(buf), NULL);
1175 }
1176
1177 /* nbd_receive_simple_reply
1178  * Read simple reply except magic field (which should be already read).
1179  * Payload is not read (payload is possible for CMD_READ, but here we even
1180  * don't know whether it take place or not).
1181  */
1182 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
1183                                     Error **errp)
1184 {
1185     int ret;
1186
1187     assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
1188
1189     ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
1190                    sizeof(*reply) - sizeof(reply->magic), errp);
1191     if (ret < 0) {
1192         return ret;
1193     }
1194
1195     reply->error = be32_to_cpu(reply->error);
1196     reply->handle = be64_to_cpu(reply->handle);
1197
1198     return 0;
1199 }
1200
1201 /* nbd_receive_structured_reply_chunk
1202  * Read structured reply chunk except magic field (which should be already
1203  * read).
1204  * Payload is not read.
1205  */
1206 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
1207                                               NBDStructuredReplyChunk *chunk,
1208                                               Error **errp)
1209 {
1210     int ret;
1211
1212     assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
1213
1214     ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
1215                    sizeof(*chunk) - sizeof(chunk->magic), errp);
1216     if (ret < 0) {
1217         return ret;
1218     }
1219
1220     chunk->flags = be16_to_cpu(chunk->flags);
1221     chunk->type = be16_to_cpu(chunk->type);
1222     chunk->handle = be64_to_cpu(chunk->handle);
1223     chunk->length = be32_to_cpu(chunk->length);
1224
1225     return 0;
1226 }
1227
1228 /* nbd_receive_reply
1229  * Returns 1 on success
1230  *         0 on eof, when no data was read (errp is not set)
1231  *         negative errno on failure (errp is set)
1232  */
1233 int nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
1234 {
1235     int ret;
1236     const char *type;
1237
1238     ret = nbd_read_eof(ioc, &reply->magic, sizeof(reply->magic), errp);
1239     if (ret <= 0) {
1240         return ret;
1241     }
1242
1243     reply->magic = be32_to_cpu(reply->magic);
1244
1245     switch (reply->magic) {
1246     case NBD_SIMPLE_REPLY_MAGIC:
1247         ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
1248         if (ret < 0) {
1249             break;
1250         }
1251         trace_nbd_receive_simple_reply(reply->simple.error,
1252                                        nbd_err_lookup(reply->simple.error),
1253                                        reply->handle);
1254         break;
1255     case NBD_STRUCTURED_REPLY_MAGIC:
1256         ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
1257         if (ret < 0) {
1258             break;
1259         }
1260         type = nbd_reply_type_lookup(reply->structured.type);
1261         trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
1262                                                  reply->structured.type, type,
1263                                                  reply->structured.handle,
1264                                                  reply->structured.length);
1265         break;
1266     default:
1267         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
1268         return -EINVAL;
1269     }
1270     if (ret < 0) {
1271         return ret;
1272     }
1273
1274     return 1;
1275 }
1276