nbd/client.c

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