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 /* Process another portion of the NBD_OPT_LIST reply.  Set *@match if
 238  * the current reply matches @want or if the server does not support
 239  * NBD_OPT_LIST, otherwise leave @match alone.  Return 0 if iteration
 240  * is complete, positive if more replies are expected, or negative
 241  * with @errp set if an unrecoverable error occurred. */
 242 static int nbd_receive_list(QIOChannel *ioc, const char *want, bool *match,
 243                             Error **errp)
 244 {
 245     NBDOptionReply reply;
 246     uint32_t len;
 247     uint32_t namelen;
 248     char name[NBD_MAX_NAME_SIZE + 1];
 249     int error;
 250
 251     if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
 252         return -1;
 253     }
 254     error = nbd_handle_reply_err(ioc, &reply, errp);
 255     if (error <= 0) {
 256         /* The server did not support NBD_OPT_LIST, so set *match on
 257          * the assumption that any name will be accepted.  */
 258         *match = true;
 259         return error;
 260     }
 261     len = reply.length;
 262
 263     if (reply.type == NBD_REP_ACK) {
 264         if (len != 0) {
 265             error_setg(errp, "length too long for option end");
 266             nbd_send_opt_abort(ioc);
 267             return -1;
 268         }
 269         return 0;
 270     } else if (reply.type != NBD_REP_SERVER) {
 271         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 272                    reply.type, nbd_rep_lookup(reply.type),
 273                    NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER));
 274         nbd_send_opt_abort(ioc);
 275         return -1;
 276     }
 277
 278     if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
 279         error_setg(errp, "incorrect option length %" PRIu32, len);
 280         nbd_send_opt_abort(ioc);
 281         return -1;
 282     }
 283     if (nbd_read(ioc, &namelen, sizeof(namelen), errp) < 0) {
 284         error_prepend(errp, "failed to read option name length: ");
 285         nbd_send_opt_abort(ioc);
 286         return -1;
 287     }
 288     namelen = be32_to_cpu(namelen);
 289     len -= sizeof(namelen);
 290     if (len < namelen) {
 291         error_setg(errp, "incorrect option name length");
 292         nbd_send_opt_abort(ioc);
 293         return -1;
 294     }
 295     if (namelen != strlen(want)) {
 296         if (nbd_drop(ioc, len, errp) < 0) {
 297             error_prepend(errp,
 298                           "failed to skip export name with wrong length: ");
 299             nbd_send_opt_abort(ioc);
 300             return -1;
 301         }
 302         return 1;
 303     }
 304
 305     assert(namelen < sizeof(name));
 306     if (nbd_read(ioc, name, namelen, errp) < 0) {
 307         error_prepend(errp, "failed to read export name: ");
 308         nbd_send_opt_abort(ioc);
 309         return -1;
 310     }
 311     name[namelen] = '\0';
 312     len -= namelen;
 313     if (nbd_drop(ioc, len, errp) < 0) {
 314         error_prepend(errp, "failed to read export description: ");
 315         nbd_send_opt_abort(ioc);
 316         return -1;
 317     }
 318     if (!strcmp(name, want)) {
 319         *match = true;
 320     }
 321     return 1;
 322 }
 323
 324
 325 /* Returns -1 if NBD_OPT_GO proves the export @wantname cannot be
 326  * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
 327  * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
 328  * go (with @info populated). */
 329 static int nbd_opt_go(QIOChannel *ioc, const char *wantname,
 330                       NBDExportInfo *info, Error **errp)
 331 {
 332     NBDOptionReply reply;
 333     uint32_t len = strlen(wantname);
 334     uint16_t type;
 335     int error;
 336     char *buf;
 337
 338     /* The protocol requires that the server send NBD_INFO_EXPORT with
 339      * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
 340      * flags still 0 is a witness of a broken server. */
 341     info->flags = 0;
 342
 343     trace_nbd_opt_go_start(wantname);
 344     buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
 345     stl_be_p(buf, len);
 346     memcpy(buf + 4, wantname, len);
 347     /* At most one request, everything else up to server */
 348     stw_be_p(buf + 4 + len, info->request_sizes);
 349     if (info->request_sizes) {
 350         stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
 351     }
 352     error = nbd_send_option_request(ioc, NBD_OPT_GO,
 353                                     4 + len + 2 + 2 * info->request_sizes,
 354                                     buf, errp);
 355     g_free(buf);
 356     if (error < 0) {
 357         return -1;
 358     }
 359
 360     while (1) {
 361         if (nbd_receive_option_reply(ioc, NBD_OPT_GO, &reply, errp) < 0) {
 362             return -1;
 363         }
 364         error = nbd_handle_reply_err(ioc, &reply, errp);
 365         if (error <= 0) {
 366             return error;
 367         }
 368         len = reply.length;
 369
 370         if (reply.type == NBD_REP_ACK) {
 371             /* Server is done sending info and moved into transmission
 372                phase, but make sure it sent flags */
 373             if (len) {
 374                 error_setg(errp, "server sent invalid NBD_REP_ACK");
 375                 return -1;
 376             }
 377             if (!info->flags) {
 378                 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
 379                 return -1;
 380             }
 381             trace_nbd_opt_go_success();
 382             return 1;
 383         }
 384         if (reply.type != NBD_REP_INFO) {
 385             error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",
 386                        reply.type, nbd_rep_lookup(reply.type),
 387                        NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));
 388             nbd_send_opt_abort(ioc);
 389             return -1;
 390         }
 391         if (len < sizeof(type)) {
 392             error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
 393                        len);
 394             nbd_send_opt_abort(ioc);
 395             return -1;
 396         }
 397         if (nbd_read(ioc, &type, sizeof(type), errp) < 0) {
 398             error_prepend(errp, "failed to read info type: ");
 399             nbd_send_opt_abort(ioc);
 400             return -1;
 401         }
 402         len -= sizeof(type);
 403         type = be16_to_cpu(type);
 404         switch (type) {
 405         case NBD_INFO_EXPORT:
 406             if (len != sizeof(info->size) + sizeof(info->flags)) {
 407                 error_setg(errp, "remaining export info len %" PRIu32
 408                            " is unexpected size", len);
 409                 nbd_send_opt_abort(ioc);
 410                 return -1;
 411             }
 412             if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 413                 error_prepend(errp, "failed to read info size: ");
 414                 nbd_send_opt_abort(ioc);
 415                 return -1;
 416             }
 417             info->size = be64_to_cpu(info->size);
 418             if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 419                 error_prepend(errp, "failed to read info flags: ");
 420                 nbd_send_opt_abort(ioc);
 421                 return -1;
 422             }
 423             info->flags = be16_to_cpu(info->flags);
 424             trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 425             break;
 426
 427         case NBD_INFO_BLOCK_SIZE:
 428             if (len != sizeof(info->min_block) * 3) {
 429                 error_setg(errp, "remaining export info len %" PRIu32
 430                            " is unexpected size", len);
 431                 nbd_send_opt_abort(ioc);
 432                 return -1;
 433             }
 434             if (nbd_read(ioc, &info->min_block, sizeof(info->min_block),
 435                          errp) < 0) {
 436                 error_prepend(errp, "failed to read info minimum block size: ");
 437                 nbd_send_opt_abort(ioc);
 438                 return -1;
 439             }
 440             info->min_block = be32_to_cpu(info->min_block);
 441             if (!is_power_of_2(info->min_block)) {
 442                 error_setg(errp, "server minimum block size %" PRIu32
 443                            " is not a power of two", info->min_block);
 444                 nbd_send_opt_abort(ioc);
 445                 return -1;
 446             }
 447             if (nbd_read(ioc, &info->opt_block, sizeof(info->opt_block),
 448                          errp) < 0) {
 449                 error_prepend(errp,
 450                               "failed to read info preferred block size: ");
 451                 nbd_send_opt_abort(ioc);
 452                 return -1;
 453             }
 454             info->opt_block = be32_to_cpu(info->opt_block);
 455             if (!is_power_of_2(info->opt_block) ||
 456                 info->opt_block < info->min_block) {
 457                 error_setg(errp, "server preferred block size %" PRIu32
 458                            " is not valid", info->opt_block);
 459                 nbd_send_opt_abort(ioc);
 460                 return -1;
 461             }
 462             if (nbd_read(ioc, &info->max_block, sizeof(info->max_block),
 463                          errp) < 0) {
 464                 error_prepend(errp, "failed to read info maximum block size: ");
 465                 nbd_send_opt_abort(ioc);
 466                 return -1;
 467             }
 468             info->max_block = be32_to_cpu(info->max_block);
 469             if (info->max_block < info->min_block) {
 470                 error_setg(errp, "server maximum block size %" PRIu32
 471                            " is not valid", info->max_block);
 472                 nbd_send_opt_abort(ioc);
 473                 return -1;
 474             }
 475             trace_nbd_opt_go_info_block_size(info->min_block, info->opt_block,
 476                                              info->max_block);
 477             break;
 478
 479         default:
 480             trace_nbd_opt_go_info_unknown(type, nbd_info_lookup(type));
 481             if (nbd_drop(ioc, len, errp) < 0) {
 482                 error_prepend(errp, "Failed to read info payload: ");
 483                 nbd_send_opt_abort(ioc);
 484                 return -1;
 485             }
 486             break;
 487         }
 488     }
 489 }
 490
 491 /* Return -1 on failure, 0 if wantname is an available export. */
 492 static int nbd_receive_query_exports(QIOChannel *ioc,
 493                                      const char *wantname,
 494                                      Error **errp)
 495 {
 496     bool foundExport = false;
 497
 498     trace_nbd_receive_query_exports_start(wantname);
 499     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 500         return -1;
 501     }
 502
 503     while (1) {
 504         int ret = nbd_receive_list(ioc, wantname, &foundExport, errp);
 505
 506         if (ret < 0) {
 507             /* Server gave unexpected reply */
 508             return -1;
 509         } else if (ret == 0) {
 510             /* Done iterating. */
 511             if (!foundExport) {
 512                 error_setg(errp, "No export with name '%s' available",
 513                            wantname);
 514                 nbd_send_opt_abort(ioc);
 515                 return -1;
 516             }
 517             trace_nbd_receive_query_exports_success(wantname);
 518             return 0;
 519         }
 520     }
 521 }
 522
 523 /* nbd_request_simple_option: Send an option request, and parse the reply
 524  * return 1 for successful negotiation,
 525  *        0 if operation is unsupported,
 526  *        -1 with errp set for any other error
 527  */
 528 static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp)
 529 {
 530     NBDOptionReply reply;
 531     int error;
 532
 533     if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
 534         return -1;
 535     }
 536
 537     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 538         return -1;
 539     }
 540     error = nbd_handle_reply_err(ioc, &reply, errp);
 541     if (error <= 0) {
 542         return error;
 543     }
 544
 545     if (reply.type != NBD_REP_ACK) {
 546         error_setg(errp, "Server answered option %d (%s) with unexpected "
 547                    "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),
 548                    reply.type, nbd_rep_lookup(reply.type));
 549         nbd_send_opt_abort(ioc);
 550         return -1;
 551     }
 552
 553     if (reply.length != 0) {
 554         error_setg(errp, "Option %d ('%s') response length is %" PRIu32
 555                    " (it should be zero)", opt, nbd_opt_lookup(opt),
 556                    reply.length);
 557         nbd_send_opt_abort(ioc);
 558         return -1;
 559     }
 560
 561     return 1;
 562 }
 563
 564 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 565                                         QCryptoTLSCreds *tlscreds,
 566                                         const char *hostname, Error **errp)
 567 {
 568     int ret;
 569     QIOChannelTLS *tioc;
 570     struct NBDTLSHandshakeData data = { 0 };
 571
 572     ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp);
 573     if (ret <= 0) {
 574         if (ret == 0) {
 575             error_setg(errp, "Server don't support STARTTLS option");
 576             nbd_send_opt_abort(ioc);
 577         }
 578         return NULL;
 579     }
 580
 581     trace_nbd_receive_starttls_new_client();
 582     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 583     if (!tioc) {
 584         return NULL;
 585     }
 586     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 587     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 588     trace_nbd_receive_starttls_tls_handshake();
 589     qio_channel_tls_handshake(tioc,
 590                               nbd_tls_handshake,
 591                               &data,
 592                               NULL,
 593                               NULL);
 594
 595     if (!data.complete) {
 596         g_main_loop_run(data.loop);
 597     }
 598     g_main_loop_unref(data.loop);
 599     if (data.error) {
 600         error_propagate(errp, data.error);
 601         object_unref(OBJECT(tioc));
 602         return NULL;
 603     }
 604
 605     return QIO_CHANNEL(tioc);
 606 }
 607
 608 /* nbd_negotiate_simple_meta_context:
 609  * Set one meta context. Simple means that reply must contain zero (not
 610  * negotiated) or one (negotiated) contexts. More contexts would be considered
 611  * as a protocol error. It's also implied that meta-data query equals queried
 612  * context name, so, if server replies with something different than @context,
 613  * it is considered an error too.
 614  * return 1 for successful negotiation, context_id is set
 615  *        0 if operation is unsupported,
 616  *        -1 with errp set for any other error
 617  */
 618 static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,
 619                                              const char *export,
 620                                              const char *context,
 621                                              uint32_t *context_id,
 622                                              Error **errp)
 623 {
 624     int ret;
 625     NBDOptionReply reply;
 626     uint32_t received_id = 0;
 627     bool received = false;
 628     uint32_t export_len = strlen(export);
 629     uint32_t context_len = strlen(context);
 630     uint32_t data_len = sizeof(export_len) + export_len +
 631                         sizeof(uint32_t) + /* number of queries */
 632                         sizeof(context_len) + context_len;
 633     char *data = g_malloc(data_len);
 634     char *p = data;
 635
 636     trace_nbd_opt_meta_request(context, export);
 637     stl_be_p(p, export_len);
 638     memcpy(p += sizeof(export_len), export, export_len);
 639     stl_be_p(p += export_len, 1);
 640     stl_be_p(p += sizeof(uint32_t), context_len);
 641     memcpy(p += sizeof(context_len), context, context_len);
 642
 643     ret = nbd_send_option_request(ioc, NBD_OPT_SET_META_CONTEXT, data_len, data,
 644                                   errp);
 645     g_free(data);
 646     if (ret < 0) {
 647         return ret;
 648     }
 649
 650     if (nbd_receive_option_reply(ioc, NBD_OPT_SET_META_CONTEXT, &reply,
 651                                  errp) < 0)
 652     {
 653         return -1;
 654     }
 655
 656     ret = nbd_handle_reply_err(ioc, &reply, errp);
 657     if (ret <= 0) {
 658         return ret;
 659     }
 660
 661     if (reply.type == NBD_REP_META_CONTEXT) {
 662         char *name;
 663
 664         if (reply.length != sizeof(received_id) + context_len) {
 665             error_setg(errp, "Failed to negotiate meta context '%s', server "
 666                        "answered with unexpected length %" PRIu32, context,
 667                        reply.length);
 668             nbd_send_opt_abort(ioc);
 669             return -1;
 670         }
 671
 672         if (nbd_read(ioc, &received_id, sizeof(received_id), errp) < 0) {
 673             return -1;
 674         }
 675         received_id = be32_to_cpu(received_id);
 676
 677         reply.length -= sizeof(received_id);
 678         name = g_malloc(reply.length + 1);
 679         if (nbd_read(ioc, name, reply.length, errp) < 0) {
 680             g_free(name);
 681             return -1;
 682         }
 683         name[reply.length] = '\0';
 684         if (strcmp(context, name)) {
 685             error_setg(errp, "Failed to negotiate meta context '%s', server "
 686                        "answered with different context '%s'", context,
 687                        name);
 688             g_free(name);
 689             nbd_send_opt_abort(ioc);
 690             return -1;
 691         }
 692         g_free(name);
 693
 694         trace_nbd_opt_meta_reply(context, received_id);
 695         received = true;
 696
 697         /* receive NBD_REP_ACK */
 698         if (nbd_receive_option_reply(ioc, NBD_OPT_SET_META_CONTEXT, &reply,
 699                                      errp) < 0)
 700         {
 701             return -1;
 702         }
 703
 704         ret = nbd_handle_reply_err(ioc, &reply, errp);
 705         if (ret <= 0) {
 706             return ret;
 707         }
 708     }
 709
 710     if (reply.type != NBD_REP_ACK) {
 711         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 712                    reply.type, nbd_rep_lookup(reply.type),
 713                    NBD_REP_ACK, nbd_rep_lookup(NBD_REP_ACK));
 714         nbd_send_opt_abort(ioc);
 715         return -1;
 716     }
 717     if (reply.length) {
 718         error_setg(errp, "Unexpected length to ACK response");
 719         nbd_send_opt_abort(ioc);
 720         return -1;
 721     }
 722
 723     if (received) {
 724         *context_id = received_id;
 725         return 1;
 726     }
 727
 728     return 0;
 729 }
 730
 731 int nbd_receive_negotiate(QIOChannel *ioc, const char *name,
 732                           QCryptoTLSCreds *tlscreds, const char *hostname,
 733                           QIOChannel **outioc, NBDExportInfo *info,
 734                           Error **errp)
 735 {
 736     uint64_t magic;
 737     int rc;
 738     bool zeroes = true;
 739     bool structured_reply = info->structured_reply;
 740     bool base_allocation = info->base_allocation;
 741
 742     trace_nbd_receive_negotiate(tlscreds, hostname ? hostname : "<null>");
 743
 744     info->structured_reply = false;
 745     info->base_allocation = false;
 746     rc = -EINVAL;
 747
 748     if (outioc) {
 749         *outioc = NULL;
 750     }
 751     if (tlscreds && !outioc) {
 752         error_setg(errp, "Output I/O channel required for TLS");
 753         goto fail;
 754     }
 755
 756     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 757         error_prepend(errp, "Failed to read initial magic: ");
 758         goto fail;
 759     }
 760     magic = be64_to_cpu(magic);
 761     trace_nbd_receive_negotiate_magic(magic);
 762
 763     if (magic != NBD_INIT_MAGIC) {
 764         error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);
 765         goto fail;
 766     }
 767
 768     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 769         error_prepend(errp, "Failed to read server magic: ");
 770         goto fail;
 771     }
 772     magic = be64_to_cpu(magic);
 773     trace_nbd_receive_negotiate_magic(magic);
 774
 775     if (magic == NBD_OPTS_MAGIC) {
 776         uint32_t clientflags = 0;
 777         uint16_t globalflags;
 778         bool fixedNewStyle = false;
 779
 780         if (nbd_read(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
 781             error_prepend(errp, "Failed to read server flags: ");
 782             goto fail;
 783         }
 784         globalflags = be16_to_cpu(globalflags);
 785         trace_nbd_receive_negotiate_server_flags(globalflags);
 786         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 787             fixedNewStyle = true;
 788             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 789         }
 790         if (globalflags & NBD_FLAG_NO_ZEROES) {
 791             zeroes = false;
 792             clientflags |= NBD_FLAG_C_NO_ZEROES;
 793         }
 794         /* client requested flags */
 795         clientflags = cpu_to_be32(clientflags);
 796         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 797             error_prepend(errp, "Failed to send clientflags field: ");
 798             goto fail;
 799         }
 800         if (tlscreds) {
 801             if (fixedNewStyle) {
 802                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 803                 if (!*outioc) {
 804                     goto fail;
 805                 }
 806                 ioc = *outioc;
 807             } else {
 808                 error_setg(errp, "Server does not support STARTTLS");
 809                 goto fail;
 810             }
 811         }
 812         if (!name) {
 813             trace_nbd_receive_negotiate_default_name();
 814             name = "";
 815         }
 816         if (fixedNewStyle) {
 817             int result;
 818
 819             if (structured_reply) {
 820                 result = nbd_request_simple_option(ioc,
 821                                                    NBD_OPT_STRUCTURED_REPLY,
 822                                                    errp);
 823                 if (result < 0) {
 824                     goto fail;
 825                 }
 826                 info->structured_reply = result == 1;
 827             }
 828
 829             if (info->structured_reply && base_allocation) {
 830                 result = nbd_negotiate_simple_meta_context(
 831                         ioc, name, info->x_dirty_bitmap ?: "base:allocation",
 832                         &info->meta_base_allocation_id, errp);
 833                 if (result < 0) {
 834                     goto fail;
 835                 }
 836                 info->base_allocation = result == 1;
 837             }
 838
 839             /* Try NBD_OPT_GO first - if it works, we are done (it
 840              * also gives us a good message if the server requires
 841              * TLS).  If it is not available, fall back to
 842              * NBD_OPT_LIST for nicer error messages about a missing
 843              * export, then use NBD_OPT_EXPORT_NAME.  */
 844             result = nbd_opt_go(ioc, name, info, errp);
 845             if (result < 0) {
 846                 goto fail;
 847             }
 848             if (result > 0) {
 849                 return 0;
 850             }
 851             /* Check our desired export is present in the
 852              * server export list. Since NBD_OPT_EXPORT_NAME
 853              * cannot return an error message, running this
 854              * query gives us better error reporting if the
 855              * export name is not available.
 856              */
 857             if (nbd_receive_query_exports(ioc, name, errp) < 0) {
 858                 goto fail;
 859             }
 860         }
 861         /* write the export name request */
 862         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, name,
 863                                     errp) < 0) {
 864             goto fail;
 865         }
 866
 867         /* Read the response */
 868         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 869             error_prepend(errp, "Failed to read export length: ");
 870             goto fail;
 871         }
 872         info->size = be64_to_cpu(info->size);
 873
 874         if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 875             error_prepend(errp, "Failed to read export flags: ");
 876             goto fail;
 877         }
 878         info->flags = be16_to_cpu(info->flags);
 879     } else if (magic == NBD_CLIENT_MAGIC) {
 880         uint32_t oldflags;
 881
 882         if (name) {
 883             error_setg(errp, "Server does not support export names");
 884             goto fail;
 885         }
 886         if (tlscreds) {
 887             error_setg(errp, "Server does not support STARTTLS");
 888             goto fail;
 889         }
 890
 891         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 892             error_prepend(errp, "Failed to read export length: ");
 893             goto fail;
 894         }
 895         info->size = be64_to_cpu(info->size);
 896
 897         if (nbd_read(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
 898             error_prepend(errp, "Failed to read export flags: ");
 899             goto fail;
 900         }
 901         oldflags = be32_to_cpu(oldflags);
 902         if (oldflags & ~0xffff) {
 903             error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 904             goto fail;
 905         }
 906         info->flags = oldflags;
 907     } else {
 908         error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);
 909         goto fail;
 910     }
 911
 912     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 913     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
 914         error_prepend(errp, "Failed to read reserved block: ");
 915         goto fail;
 916     }
 917     rc = 0;
 918
 919 fail:
 920     return rc;
 921 }
 922
 923 #ifdef __linux__
 924 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
 925              Error **errp)
 926 {
 927     unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
 928     unsigned long sectors = info->size / sector_size;
 929
 930     /* FIXME: Once the kernel module is patched to honor block sizes,
 931      * and to advertise that fact to user space, we should update the
 932      * hand-off to the kernel to use any block sizes we learned. */
 933     assert(!info->request_sizes);
 934     if (info->size / sector_size != sectors) {
 935         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
 936                    info->size);
 937         return -E2BIG;
 938     }
 939
 940     trace_nbd_init_set_socket();
 941
 942     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
 943         int serrno = errno;
 944         error_setg(errp, "Failed to set NBD socket");
 945         return -serrno;
 946     }
 947
 948     trace_nbd_init_set_block_size(sector_size);
 949
 950     if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
 951         int serrno = errno;
 952         error_setg(errp, "Failed setting NBD block size");
 953         return -serrno;
 954     }
 955
 956     trace_nbd_init_set_size(sectors);
 957     if (info->size % sector_size) {
 958         trace_nbd_init_trailing_bytes(info->size % sector_size);
 959     }
 960
 961     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
 962         int serrno = errno;
 963         error_setg(errp, "Failed setting size (in blocks)");
 964         return -serrno;
 965     }
 966
 967     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
 968         if (errno == ENOTTY) {
 969             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
 970             trace_nbd_init_set_readonly();
 971
 972             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 973                 int serrno = errno;
 974                 error_setg(errp, "Failed setting read-only attribute");
 975                 return -serrno;
 976             }
 977         } else {
 978             int serrno = errno;
 979             error_setg(errp, "Failed setting flags");
 980             return -serrno;
 981         }
 982     }
 983
 984     trace_nbd_init_finish();
 985
 986     return 0;
 987 }
 988
 989 int nbd_client(int fd)
 990 {
 991     int ret;
 992     int serrno;
 993
 994     trace_nbd_client_loop();
 995
 996     ret = ioctl(fd, NBD_DO_IT);
 997     if (ret < 0 && errno == EPIPE) {
 998         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 999          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
1000          * that case.
1001          */
1002         ret = 0;
1003     }
1004     serrno = errno;
1005
1006     trace_nbd_client_loop_ret(ret, strerror(serrno));
1007
1008     trace_nbd_client_clear_queue();
1009     ioctl(fd, NBD_CLEAR_QUE);
1010
1011     trace_nbd_client_clear_socket();
1012     ioctl(fd, NBD_CLEAR_SOCK);
1013
1014     errno = serrno;
1015     return ret;
1016 }
1017
1018 int nbd_disconnect(int fd)
1019 {
1020     ioctl(fd, NBD_CLEAR_QUE);
1021     ioctl(fd, NBD_DISCONNECT);
1022     ioctl(fd, NBD_CLEAR_SOCK);
1023     return 0;
1024 }
1025
1026 #endif /* __linux__ */
1027
1028 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
1029 {
1030     uint8_t buf[NBD_REQUEST_SIZE];
1031
1032     trace_nbd_send_request(request->from, request->len, request->handle,
1033                            request->flags, request->type,
1034                            nbd_cmd_lookup(request->type));
1035
1036     stl_be_p(buf, NBD_REQUEST_MAGIC);
1037     stw_be_p(buf + 4, request->flags);
1038     stw_be_p(buf + 6, request->type);
1039     stq_be_p(buf + 8, request->handle);
1040     stq_be_p(buf + 16, request->from);
1041     stl_be_p(buf + 24, request->len);
1042
1043     return nbd_write(ioc, buf, sizeof(buf), NULL);
1044 }
1045
1046 /* nbd_receive_simple_reply
1047  * Read simple reply except magic field (which should be already read).
1048  * Payload is not read (payload is possible for CMD_READ, but here we even
1049  * don't know whether it take place or not).
1050  */
1051 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
1052                                     Error **errp)
1053 {
1054     int ret;
1055
1056     assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
1057
1058     ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
1059                    sizeof(*reply) - sizeof(reply->magic), errp);
1060     if (ret < 0) {
1061         return ret;
1062     }
1063
1064     reply->error = be32_to_cpu(reply->error);
1065     reply->handle = be64_to_cpu(reply->handle);
1066
1067     return 0;
1068 }
1069
1070 /* nbd_receive_structured_reply_chunk
1071  * Read structured reply chunk except magic field (which should be already
1072  * read).
1073  * Payload is not read.
1074  */
1075 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
1076                                               NBDStructuredReplyChunk *chunk,
1077                                               Error **errp)
1078 {
1079     int ret;
1080
1081     assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
1082
1083     ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
1084                    sizeof(*chunk) - sizeof(chunk->magic), errp);
1085     if (ret < 0) {
1086         return ret;
1087     }
1088
1089     chunk->flags = be16_to_cpu(chunk->flags);
1090     chunk->type = be16_to_cpu(chunk->type);
1091     chunk->handle = be64_to_cpu(chunk->handle);
1092     chunk->length = be32_to_cpu(chunk->length);
1093
1094     return 0;
1095 }
1096
1097 /* nbd_receive_reply
1098  * Returns 1 on success
1099  *         0 on eof, when no data was read (errp is not set)
1100  *         negative errno on failure (errp is set)
1101  */
1102 int nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
1103 {
1104     int ret;
1105     const char *type;
1106
1107     ret = nbd_read_eof(ioc, &reply->magic, sizeof(reply->magic), errp);
1108     if (ret <= 0) {
1109         return ret;
1110     }
1111
1112     reply->magic = be32_to_cpu(reply->magic);
1113
1114     switch (reply->magic) {
1115     case NBD_SIMPLE_REPLY_MAGIC:
1116         ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
1117         if (ret < 0) {
1118             break;
1119         }
1120         trace_nbd_receive_simple_reply(reply->simple.error,
1121                                        nbd_err_lookup(reply->simple.error),
1122                                        reply->handle);
1123         break;
1124     case NBD_STRUCTURED_REPLY_MAGIC:
1125         ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
1126         if (ret < 0) {
1127             break;
1128         }
1129         type = nbd_reply_type_lookup(reply->structured.type);
1130         trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
1131                                                  reply->structured.type, type,
1132                                                  reply->structured.handle,
1133                                                  reply->structured.length);
1134         break;
1135     default:
1136         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
1137         return -EINVAL;
1138     }
1139     if (ret < 0) {
1140         return ret;
1141     }
1142
1143     return 1;
1144 }
1145