nbd/client.c

   1 /*
   2  *  Copyright (C) 2005  Anthony Liguori <[email protected]>
   3  *
   4  *  Network Block Device Client Side
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; under version 2 of the License.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include "qapi/error.h"
  21 #include "nbd-internal.h"
  22
  23 static int nbd_errno_to_system_errno(int err)
  24 {
  25     switch (err) {
  26     case NBD_SUCCESS:
  27         return 0;
  28     case NBD_EPERM:
  29         return EPERM;
  30     case NBD_EIO:
  31         return EIO;
  32     case NBD_ENOMEM:
  33         return ENOMEM;
  34     case NBD_ENOSPC:
  35         return ENOSPC;
  36     case NBD_EINVAL:
  37     default:
  38         return EINVAL;
  39     }
  40 }
  41
  42 /* Definitions for opaque data types */
  43
  44 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
  45
  46 /* That's all folks */
  47
  48 /* Basic flow for negotiation
  49
  50    Server         Client
  51    Negotiate
  52
  53    or
  54
  55    Server         Client
  56    Negotiate #1
  57                   Option
  58    Negotiate #2
  59
  60    ----
  61
  62    followed by
  63
  64    Server         Client
  65                   Request
  66    Response
  67                   Request
  68    Response
  69                   ...
  70    ...
  71                   Request (type == 2)
  72
  73 */
  74
  75
  76 static int nbd_handle_reply_err(uint32_t opt, uint32_t type, Error **errp)
  77 {
  78     if (!(type & (1 << 31))) {
  79         return 0;
  80     }
  81
  82     switch (type) {
  83     case NBD_REP_ERR_UNSUP:
  84         error_setg(errp, "Unsupported option type %x", opt);
  85         break;
  86
  87     case NBD_REP_ERR_POLICY:
  88         error_setg(errp, "Denied by server for option %x", opt);
  89         break;
  90
  91     case NBD_REP_ERR_INVALID:
  92         error_setg(errp, "Invalid data length for option %x", opt);
  93         break;
  94
  95     case NBD_REP_ERR_TLS_REQD:
  96         error_setg(errp, "TLS negotiation required before option %x", opt);
  97         break;
  98
  99     default:
 100         error_setg(errp, "Unknown error code when asking for option %x", opt);
 101         break;
 102     }
 103
 104     return -1;
 105 }
 106
 107 static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp)
 108 {
 109     uint64_t magic;
 110     uint32_t opt;
 111     uint32_t type;
 112     uint32_t len;
 113     uint32_t namelen;
 114
 115     *name = NULL;
 116     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 117         error_setg(errp, "failed to read list option magic");
 118         return -1;
 119     }
 120     magic = be64_to_cpu(magic);
 121     if (magic != NBD_REP_MAGIC) {
 122         error_setg(errp, "Unexpected option list magic");
 123         return -1;
 124     }
 125     if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
 126         error_setg(errp, "failed to read list option");
 127         return -1;
 128     }
 129     opt = be32_to_cpu(opt);
 130     if (opt != NBD_OPT_LIST) {
 131         error_setg(errp, "Unexpected option type %x expected %x",
 132                    opt, NBD_OPT_LIST);
 133         return -1;
 134     }
 135
 136     if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
 137         error_setg(errp, "failed to read list option type");
 138         return -1;
 139     }
 140     type = be32_to_cpu(type);
 141     if (type == NBD_REP_ERR_UNSUP) {
 142         return 0;
 143     }
 144     if (nbd_handle_reply_err(opt, type, errp) < 0) {
 145         return -1;
 146     }
 147
 148     if (read_sync(ioc, &len, sizeof(len)) != sizeof(len)) {
 149         error_setg(errp, "failed to read option length");
 150         return -1;
 151     }
 152     len = be32_to_cpu(len);
 153
 154     if (type == NBD_REP_ACK) {
 155         if (len != 0) {
 156             error_setg(errp, "length too long for option end");
 157             return -1;
 158         }
 159     } else if (type == NBD_REP_SERVER) {
 160         if (read_sync(ioc, &namelen, sizeof(namelen)) != sizeof(namelen)) {
 161             error_setg(errp, "failed to read option name length");
 162             return -1;
 163         }
 164         namelen = be32_to_cpu(namelen);
 165         if (len != (namelen + sizeof(namelen))) {
 166             error_setg(errp, "incorrect option mame length");
 167             return -1;
 168         }
 169         if (namelen > 255) {
 170             error_setg(errp, "export name length too long %d", namelen);
 171             return -1;
 172         }
 173
 174         *name = g_new0(char, namelen + 1);
 175         if (read_sync(ioc, *name, namelen) != namelen) {
 176             error_setg(errp, "failed to read export name");
 177             g_free(*name);
 178             *name = NULL;
 179             return -1;
 180         }
 181         (*name)[namelen] = '\0';
 182     } else {
 183         error_setg(errp, "Unexpected reply type %x expected %x",
 184                    type, NBD_REP_SERVER);
 185         return -1;
 186     }
 187     return 1;
 188 }
 189
 190
 191 static int nbd_receive_query_exports(QIOChannel *ioc,
 192                                      const char *wantname,
 193                                      Error **errp)
 194 {
 195     uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
 196     uint32_t opt = cpu_to_be32(NBD_OPT_LIST);
 197     uint32_t length = 0;
 198     bool foundExport = false;
 199
 200     TRACE("Querying export list");
 201     if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 202         error_setg(errp, "Failed to send list option magic");
 203         return -1;
 204     }
 205
 206     if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
 207         error_setg(errp, "Failed to send list option number");
 208         return -1;
 209     }
 210
 211     if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
 212         error_setg(errp, "Failed to send list option length");
 213         return -1;
 214     }
 215
 216     TRACE("Reading available export names");
 217     while (1) {
 218         char *name = NULL;
 219         int ret = nbd_receive_list(ioc, &name, errp);
 220
 221         if (ret < 0) {
 222             g_free(name);
 223             name = NULL;
 224             return -1;
 225         }
 226         if (ret == 0) {
 227             /* Server doesn't support export listing, so
 228              * we will just assume an export with our
 229              * wanted name exists */
 230             foundExport = true;
 231             break;
 232         }
 233         if (name == NULL) {
 234             TRACE("End of export name list");
 235             break;
 236         }
 237         if (g_str_equal(name, wantname)) {
 238             foundExport = true;
 239             TRACE("Found desired export name '%s'", name);
 240         } else {
 241             TRACE("Ignored export name '%s'", name);
 242         }
 243         g_free(name);
 244     }
 245
 246     if (!foundExport) {
 247         error_setg(errp, "No export with name '%s' available", wantname);
 248         return -1;
 249     }
 250
 251     return 0;
 252 }
 253
 254 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 255                                         QCryptoTLSCreds *tlscreds,
 256                                         const char *hostname, Error **errp)
 257 {
 258     uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
 259     uint32_t opt = cpu_to_be32(NBD_OPT_STARTTLS);
 260     uint32_t length = 0;
 261     uint32_t type;
 262     QIOChannelTLS *tioc;
 263     struct NBDTLSHandshakeData data = { 0 };
 264
 265     TRACE("Requesting TLS from server");
 266     if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 267         error_setg(errp, "Failed to send option magic");
 268         return NULL;
 269     }
 270
 271     if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
 272         error_setg(errp, "Failed to send option number");
 273         return NULL;
 274     }
 275
 276     if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
 277         error_setg(errp, "Failed to send option length");
 278         return NULL;
 279     }
 280
 281     TRACE("Getting TLS reply from server1");
 282     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 283         error_setg(errp, "failed to read option magic");
 284         return NULL;
 285     }
 286     magic = be64_to_cpu(magic);
 287     if (magic != NBD_REP_MAGIC) {
 288         error_setg(errp, "Unexpected option magic");
 289         return NULL;
 290     }
 291     TRACE("Getting TLS reply from server2");
 292     if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
 293         error_setg(errp, "failed to read option");
 294         return NULL;
 295     }
 296     opt = be32_to_cpu(opt);
 297     if (opt != NBD_OPT_STARTTLS) {
 298         error_setg(errp, "Unexpected option type %x expected %x",
 299                    opt, NBD_OPT_STARTTLS);
 300         return NULL;
 301     }
 302
 303     TRACE("Getting TLS reply from server");
 304     if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
 305         error_setg(errp, "failed to read option type");
 306         return NULL;
 307     }
 308     type = be32_to_cpu(type);
 309     if (type != NBD_REP_ACK) {
 310         error_setg(errp, "Server rejected request to start TLS %x",
 311                    type);
 312         return NULL;
 313     }
 314
 315     TRACE("Getting TLS reply from server");
 316     if (read_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
 317         error_setg(errp, "failed to read option length");
 318         return NULL;
 319     }
 320     length = be32_to_cpu(length);
 321     if (length != 0) {
 322         error_setg(errp, "Start TLS reponse was not zero %x",
 323                    length);
 324         return NULL;
 325     }
 326
 327     TRACE("TLS request approved, setting up TLS");
 328     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 329     if (!tioc) {
 330         return NULL;
 331     }
 332     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 333     TRACE("Starting TLS hanshake");
 334     qio_channel_tls_handshake(tioc,
 335                               nbd_tls_handshake,
 336                               &data,
 337                               NULL);
 338
 339     if (!data.complete) {
 340         g_main_loop_run(data.loop);
 341     }
 342     g_main_loop_unref(data.loop);
 343     if (data.error) {
 344         error_propagate(errp, data.error);
 345         object_unref(OBJECT(tioc));
 346         return NULL;
 347     }
 348
 349     return QIO_CHANNEL(tioc);
 350 }
 351
 352
 353 int nbd_receive_negotiate(QIOChannel *ioc, const char *name, uint32_t *flags,
 354                           QCryptoTLSCreds *tlscreds, const char *hostname,
 355                           QIOChannel **outioc,
 356                           off_t *size, Error **errp)
 357 {
 358     char buf[256];
 359     uint64_t magic, s;
 360     int rc;
 361
 362     TRACE("Receiving negotiation tlscreds=%p hostname=%s.",
 363           tlscreds, hostname ? hostname : "<null>");
 364
 365     rc = -EINVAL;
 366
 367     if (outioc) {
 368         *outioc = NULL;
 369     }
 370     if (tlscreds && !outioc) {
 371         error_setg(errp, "Output I/O channel required for TLS");
 372         goto fail;
 373     }
 374
 375     if (read_sync(ioc, buf, 8) != 8) {
 376         error_setg(errp, "Failed to read data");
 377         goto fail;
 378     }
 379
 380     buf[8] = '\0';
 381     if (strlen(buf) == 0) {
 382         error_setg(errp, "Server connection closed unexpectedly");
 383         goto fail;
 384     }
 385
 386     TRACE("Magic is %c%c%c%c%c%c%c%c",
 387           qemu_isprint(buf[0]) ? buf[0] : '.',
 388           qemu_isprint(buf[1]) ? buf[1] : '.',
 389           qemu_isprint(buf[2]) ? buf[2] : '.',
 390           qemu_isprint(buf[3]) ? buf[3] : '.',
 391           qemu_isprint(buf[4]) ? buf[4] : '.',
 392           qemu_isprint(buf[5]) ? buf[5] : '.',
 393           qemu_isprint(buf[6]) ? buf[6] : '.',
 394           qemu_isprint(buf[7]) ? buf[7] : '.');
 395
 396     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
 397         error_setg(errp, "Invalid magic received");
 398         goto fail;
 399     }
 400
 401     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 402         error_setg(errp, "Failed to read magic");
 403         goto fail;
 404     }
 405     magic = be64_to_cpu(magic);
 406     TRACE("Magic is 0x%" PRIx64, magic);
 407
 408     if (magic == NBD_OPTS_MAGIC) {
 409         uint32_t clientflags = 0;
 410         uint32_t opt;
 411         uint32_t namesize;
 412         uint16_t globalflags;
 413         uint16_t exportflags;
 414         bool fixedNewStyle = false;
 415
 416         if (read_sync(ioc, &globalflags, sizeof(globalflags)) !=
 417             sizeof(globalflags)) {
 418             error_setg(errp, "Failed to read server flags");
 419             goto fail;
 420         }
 421         globalflags = be16_to_cpu(globalflags);
 422         *flags = globalflags << 16;
 423         TRACE("Global flags are %x", globalflags);
 424         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 425             fixedNewStyle = true;
 426             TRACE("Server supports fixed new style");
 427             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 428         }
 429         /* client requested flags */
 430         clientflags = cpu_to_be32(clientflags);
 431         if (write_sync(ioc, &clientflags, sizeof(clientflags)) !=
 432             sizeof(clientflags)) {
 433             error_setg(errp, "Failed to send clientflags field");
 434             goto fail;
 435         }
 436         if (tlscreds) {
 437             if (fixedNewStyle) {
 438                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 439                 if (!*outioc) {
 440                     goto fail;
 441                 }
 442                 ioc = *outioc;
 443             } else {
 444                 error_setg(errp, "Server does not support STARTTLS");
 445                 goto fail;
 446             }
 447         }
 448         if (!name) {
 449             TRACE("Using default NBD export name \"\"");
 450             name = "";
 451         }
 452         if (fixedNewStyle) {
 453             /* Check our desired export is present in the
 454              * server export list. Since NBD_OPT_EXPORT_NAME
 455              * cannot return an error message, running this
 456              * query gives us good error reporting if the
 457              * server required TLS
 458              */
 459             if (nbd_receive_query_exports(ioc, name, errp) < 0) {
 460                 goto fail;
 461             }
 462         }
 463         /* write the export name */
 464         magic = cpu_to_be64(magic);
 465         if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
 466             error_setg(errp, "Failed to send export name magic");
 467             goto fail;
 468         }
 469         opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
 470         if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
 471             error_setg(errp, "Failed to send export name option number");
 472             goto fail;
 473         }
 474         namesize = cpu_to_be32(strlen(name));
 475         if (write_sync(ioc, &namesize, sizeof(namesize)) !=
 476             sizeof(namesize)) {
 477             error_setg(errp, "Failed to send export name length");
 478             goto fail;
 479         }
 480         if (write_sync(ioc, (char *)name, strlen(name)) != strlen(name)) {
 481             error_setg(errp, "Failed to send export name");
 482             goto fail;
 483         }
 484
 485         if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
 486             error_setg(errp, "Failed to read export length");
 487             goto fail;
 488         }
 489         *size = be64_to_cpu(s);
 490         TRACE("Size is %" PRIu64, *size);
 491
 492         if (read_sync(ioc, &exportflags, sizeof(exportflags)) !=
 493             sizeof(exportflags)) {
 494             error_setg(errp, "Failed to read export flags");
 495             goto fail;
 496         }
 497         exportflags = be16_to_cpu(exportflags);
 498         *flags |= exportflags;
 499         TRACE("Export flags are %x", exportflags);
 500     } else if (magic == NBD_CLIENT_MAGIC) {
 501         if (name) {
 502             error_setg(errp, "Server does not support export names");
 503             goto fail;
 504         }
 505         if (tlscreds) {
 506             error_setg(errp, "Server does not support STARTTLS");
 507             goto fail;
 508         }
 509
 510         if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
 511             error_setg(errp, "Failed to read export length");
 512             goto fail;
 513         }
 514         *size = be64_to_cpu(s);
 515         TRACE("Size is %" PRIu64, *size);
 516
 517         if (read_sync(ioc, flags, sizeof(*flags)) != sizeof(*flags)) {
 518             error_setg(errp, "Failed to read export flags");
 519             goto fail;
 520         }
 521         *flags = be32_to_cpup(flags);
 522     } else {
 523         error_setg(errp, "Bad magic received");
 524         goto fail;
 525     }
 526
 527     if (read_sync(ioc, &buf, 124) != 124) {
 528         error_setg(errp, "Failed to read reserved block");
 529         goto fail;
 530     }
 531     rc = 0;
 532
 533 fail:
 534     return rc;
 535 }
 536
 537 #ifdef __linux__
 538 int nbd_init(int fd, QIOChannelSocket *sioc, uint32_t flags, off_t size)
 539 {
 540     TRACE("Setting NBD socket");
 541
 542     if (ioctl(fd, NBD_SET_SOCK, sioc->fd) < 0) {
 543         int serrno = errno;
 544         LOG("Failed to set NBD socket");
 545         return -serrno;
 546     }
 547
 548     TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE);
 549
 550     if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) {
 551         int serrno = errno;
 552         LOG("Failed setting NBD block size");
 553         return -serrno;
 554     }
 555
 556     TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE));
 557
 558     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) {
 559         int serrno = errno;
 560         LOG("Failed setting size (in blocks)");
 561         return -serrno;
 562     }
 563
 564     if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) {
 565         if (errno == ENOTTY) {
 566             int read_only = (flags & NBD_FLAG_READ_ONLY) != 0;
 567             TRACE("Setting readonly attribute");
 568
 569             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 570                 int serrno = errno;
 571                 LOG("Failed setting read-only attribute");
 572                 return -serrno;
 573             }
 574         } else {
 575             int serrno = errno;
 576             LOG("Failed setting flags");
 577             return -serrno;
 578         }
 579     }
 580
 581     TRACE("Negotiation ended");
 582
 583     return 0;
 584 }
 585
 586 int nbd_client(int fd)
 587 {
 588     int ret;
 589     int serrno;
 590
 591     TRACE("Doing NBD loop");
 592
 593     ret = ioctl(fd, NBD_DO_IT);
 594     if (ret < 0 && errno == EPIPE) {
 595         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 596          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
 597          * that case.
 598          */
 599         ret = 0;
 600     }
 601     serrno = errno;
 602
 603     TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
 604
 605     TRACE("Clearing NBD queue");
 606     ioctl(fd, NBD_CLEAR_QUE);
 607
 608     TRACE("Clearing NBD socket");
 609     ioctl(fd, NBD_CLEAR_SOCK);
 610
 611     errno = serrno;
 612     return ret;
 613 }
 614 #else
 615 int nbd_init(int fd, QIOChannelSocket *ioc, uint32_t flags, off_t size)
 616 {
 617     return -ENOTSUP;
 618 }
 619
 620 int nbd_client(int fd)
 621 {
 622     return -ENOTSUP;
 623 }
 624 #endif
 625
 626 ssize_t nbd_send_request(QIOChannel *ioc, struct nbd_request *request)
 627 {
 628     uint8_t buf[NBD_REQUEST_SIZE];
 629     ssize_t ret;
 630
 631     cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
 632     cpu_to_be32w((uint32_t*)(buf + 4), request->type);
 633     cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
 634     cpu_to_be64w((uint64_t*)(buf + 16), request->from);
 635     cpu_to_be32w((uint32_t*)(buf + 24), request->len);
 636
 637     TRACE("Sending request to server: "
 638           "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}",
 639           request->from, request->len, request->handle, request->type);
 640
 641     ret = write_sync(ioc, buf, sizeof(buf));
 642     if (ret < 0) {
 643         return ret;
 644     }
 645
 646     if (ret != sizeof(buf)) {
 647         LOG("writing to socket failed");
 648         return -EINVAL;
 649     }
 650     return 0;
 651 }
 652
 653 ssize_t nbd_receive_reply(QIOChannel *ioc, struct nbd_reply *reply)
 654 {
 655     uint8_t buf[NBD_REPLY_SIZE];
 656     uint32_t magic;
 657     ssize_t ret;
 658
 659     ret = read_sync(ioc, buf, sizeof(buf));
 660     if (ret < 0) {
 661         return ret;
 662     }
 663
 664     if (ret != sizeof(buf)) {
 665         LOG("read failed");
 666         return -EINVAL;
 667     }
 668
 669     /* Reply
 670        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 671        [ 4 ..  7]    error   (0 == no error)
 672        [ 7 .. 15]    handle
 673      */
 674
 675     magic = be32_to_cpup((uint32_t*)buf);
 676     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
 677     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
 678
 679     reply->error = nbd_errno_to_system_errno(reply->error);
 680
 681     TRACE("Got reply: "
 682           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
 683           magic, reply->error, reply->handle);
 684
 685     if (magic != NBD_REPLY_MAGIC) {
 686         LOG("invalid magic (got 0x%x)", magic);
 687         return -EINVAL;
 688     }
 689     return 0;
 690 }
 691