nbd.c

   1 /*
   2  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   3  *
   4  *  Network Block Device
   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 "nbd.h"
  20 #include "block.h"
  21
  22 #include <errno.h>
  23 #include <string.h>
  24 #ifndef _WIN32
  25 #include <sys/ioctl.h>
  26 #endif
  27 #if defined(__sun__) || defined(__HAIKU__)
  28 #include <sys/ioccom.h>
  29 #endif
  30 #include <ctype.h>
  31 #include <inttypes.h>
  32
  33 #ifdef __linux__
  34 #include <linux/fs.h>
  35 #endif
  36
  37 #include "qemu_socket.h"
  38
  39 //#define DEBUG_NBD
  40
  41 #ifdef DEBUG_NBD
  42 #define TRACE(msg, ...) do { \
  43     LOG(msg, ## __VA_ARGS__); \
  44 } while(0)
  45 #else
  46 #define TRACE(msg, ...) \
  47     do { } while (0)
  48 #endif
  49
  50 #define LOG(msg, ...) do { \
  51     fprintf(stderr, "%s:%s():L%d: " msg "\n", \
  52             __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
  53 } while(0)
  54
  55 /* This is all part of the "official" NBD API */
  56
  57 #define NBD_REPLY_SIZE          (4 + 4 + 8)
  58 #define NBD_REQUEST_MAGIC       0x25609513
  59 #define NBD_REPLY_MAGIC         0x67446698
  60
  61 #define NBD_SET_SOCK            _IO(0xab, 0)
  62 #define NBD_SET_BLKSIZE         _IO(0xab, 1)
  63 #define NBD_SET_SIZE            _IO(0xab, 2)
  64 #define NBD_DO_IT               _IO(0xab, 3)
  65 #define NBD_CLEAR_SOCK          _IO(0xab, 4)
  66 #define NBD_CLEAR_QUE           _IO(0xab, 5)
  67 #define NBD_PRINT_DEBUG         _IO(0xab, 6)
  68 #define NBD_SET_SIZE_BLOCKS     _IO(0xab, 7)
  69 #define NBD_DISCONNECT          _IO(0xab, 8)
  70 #define NBD_SET_TIMEOUT         _IO(0xab, 9)
  71 #define NBD_SET_FLAGS           _IO(0xab, 10)
  72
  73 #define NBD_OPT_EXPORT_NAME     (1 << 0)
  74
  75 /* That's all folks */
  76
  77 #define read_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, true)
  78 #define write_sync(fd, buffer, size) nbd_wr_sync(fd, buffer, size, false)
  79
  80 size_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read)
  81 {
  82     size_t offset = 0;
  83
  84     if (qemu_in_coroutine()) {
  85         if (do_read) {
  86             return qemu_co_recv(fd, buffer, size);
  87         } else {
  88             return qemu_co_send(fd, buffer, size);
  89         }
  90     }
  91
  92     while (offset < size) {
  93         ssize_t len;
  94
  95         if (do_read) {
  96             len = qemu_recv(fd, buffer + offset, size - offset, 0);
  97         } else {
  98             len = send(fd, buffer + offset, size - offset, 0);
  99         }
 100
 101         if (len == -1)
 102             errno = socket_error();
 103
 104         /* recoverable error */
 105         if (len == -1 && (errno == EAGAIN || errno == EINTR)) {
 106             continue;
 107         }
 108
 109         /* eof */
 110         if (len == 0) {
 111             break;
 112         }
 113
 114         /* unrecoverable error */
 115         if (len == -1) {
 116             return 0;
 117         }
 118
 119         offset += len;
 120     }
 121
 122     return offset;
 123 }
 124
 125 static void combine_addr(char *buf, size_t len, const char* address,
 126                          uint16_t port)
 127 {
 128     /* If the address-part contains a colon, it's an IPv6 IP so needs [] */
 129     if (strstr(address, ":")) {
 130         snprintf(buf, len, "[%s]:%u", address, port);
 131     } else {
 132         snprintf(buf, len, "%s:%u", address, port);
 133     }
 134 }
 135
 136 int tcp_socket_outgoing(const char *address, uint16_t port)
 137 {
 138     char address_and_port[128];
 139     combine_addr(address_and_port, 128, address, port);
 140     return tcp_socket_outgoing_spec(address_and_port);
 141 }
 142
 143 int tcp_socket_outgoing_spec(const char *address_and_port)
 144 {
 145     return inet_connect(address_and_port, SOCK_STREAM);
 146 }
 147
 148 int tcp_socket_incoming(const char *address, uint16_t port)
 149 {
 150     char address_and_port[128];
 151     combine_addr(address_and_port, 128, address, port);
 152     return tcp_socket_incoming_spec(address_and_port);
 153 }
 154
 155 int tcp_socket_incoming_spec(const char *address_and_port)
 156 {
 157     char *ostr  = NULL;
 158     int olen = 0;
 159     return inet_listen(address_and_port, ostr, olen, SOCK_STREAM, 0);
 160 }
 161
 162 int unix_socket_incoming(const char *path)
 163 {
 164     char *ostr = NULL;
 165     int olen = 0;
 166
 167     return unix_listen(path, ostr, olen);
 168 }
 169
 170 int unix_socket_outgoing(const char *path)
 171 {
 172     return unix_connect(path);
 173 }
 174
 175 /* Basic flow
 176
 177    Server         Client
 178
 179    Negotiate
 180                   Request
 181    Response
 182                   Request
 183    Response
 184                   ...
 185    ...
 186                   Request (type == 2)
 187 */
 188
 189 int nbd_negotiate(int csock, off_t size, uint32_t flags)
 190 {
 191     char buf[8 + 8 + 8 + 128];
 192
 193     /* Negotiate
 194         [ 0 ..   7]   passwd   ("NBDMAGIC")
 195         [ 8 ..  15]   magic    (0x00420281861253)
 196         [16 ..  23]   size
 197         [24 ..  27]   flags
 198         [28 .. 151]   reserved (0)
 199      */
 200
 201     TRACE("Beginning negotiation.");
 202     memcpy(buf, "NBDMAGIC", 8);
 203     cpu_to_be64w((uint64_t*)(buf + 8), 0x00420281861253LL);
 204     cpu_to_be64w((uint64_t*)(buf + 16), size);
 205     cpu_to_be32w((uint32_t*)(buf + 24), flags | NBD_FLAG_HAS_FLAGS);
 206     memset(buf + 28, 0, 124);
 207
 208     if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 209         LOG("write failed");
 210         errno = EINVAL;
 211         return -1;
 212     }
 213
 214     TRACE("Negotiation succeeded.");
 215
 216     return 0;
 217 }
 218
 219 int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
 220                           off_t *size, size_t *blocksize)
 221 {
 222     char buf[256];
 223     uint64_t magic, s;
 224     uint16_t tmp;
 225
 226     TRACE("Receiving negotiation.");
 227
 228     if (read_sync(csock, buf, 8) != 8) {
 229         LOG("read failed");
 230         errno = EINVAL;
 231         return -1;
 232     }
 233
 234     buf[8] = '\0';
 235     if (strlen(buf) == 0) {
 236         LOG("server connection closed");
 237         errno = EINVAL;
 238         return -1;
 239     }
 240
 241     TRACE("Magic is %c%c%c%c%c%c%c%c",
 242           qemu_isprint(buf[0]) ? buf[0] : '.',
 243           qemu_isprint(buf[1]) ? buf[1] : '.',
 244           qemu_isprint(buf[2]) ? buf[2] : '.',
 245           qemu_isprint(buf[3]) ? buf[3] : '.',
 246           qemu_isprint(buf[4]) ? buf[4] : '.',
 247           qemu_isprint(buf[5]) ? buf[5] : '.',
 248           qemu_isprint(buf[6]) ? buf[6] : '.',
 249           qemu_isprint(buf[7]) ? buf[7] : '.');
 250
 251     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
 252         LOG("Invalid magic received");
 253         errno = EINVAL;
 254         return -1;
 255     }
 256
 257     if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 258         LOG("read failed");
 259         errno = EINVAL;
 260         return -1;
 261     }
 262     magic = be64_to_cpu(magic);
 263     TRACE("Magic is 0x%" PRIx64, magic);
 264
 265     if (name) {
 266         uint32_t reserved = 0;
 267         uint32_t opt;
 268         uint32_t namesize;
 269
 270         TRACE("Checking magic (opts_magic)");
 271         if (magic != 0x49484156454F5054LL) {
 272             LOG("Bad magic received");
 273             errno = EINVAL;
 274             return -1;
 275         }
 276         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 277             LOG("flags read failed");
 278             errno = EINVAL;
 279             return -1;
 280         }
 281         *flags = be16_to_cpu(tmp) << 16;
 282         /* reserved for future use */
 283         if (write_sync(csock, &reserved, sizeof(reserved)) !=
 284             sizeof(reserved)) {
 285             LOG("write failed (reserved)");
 286             errno = EINVAL;
 287             return -1;
 288         }
 289         /* write the export name */
 290         magic = cpu_to_be64(magic);
 291         if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 292             LOG("write failed (magic)");
 293             errno = EINVAL;
 294             return -1;
 295         }
 296         opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
 297         if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) {
 298             LOG("write failed (opt)");
 299             errno = EINVAL;
 300             return -1;
 301         }
 302         namesize = cpu_to_be32(strlen(name));
 303         if (write_sync(csock, &namesize, sizeof(namesize)) !=
 304             sizeof(namesize)) {
 305             LOG("write failed (namesize)");
 306             errno = EINVAL;
 307             return -1;
 308         }
 309         if (write_sync(csock, (char*)name, strlen(name)) != strlen(name)) {
 310             LOG("write failed (name)");
 311             errno = EINVAL;
 312             return -1;
 313         }
 314     } else {
 315         TRACE("Checking magic (cli_magic)");
 316
 317         if (magic != 0x00420281861253LL) {
 318             LOG("Bad magic received");
 319             errno = EINVAL;
 320             return -1;
 321         }
 322     }
 323
 324     if (read_sync(csock, &s, sizeof(s)) != sizeof(s)) {
 325         LOG("read failed");
 326         errno = EINVAL;
 327         return -1;
 328     }
 329     *size = be64_to_cpu(s);
 330     *blocksize = 1024;
 331     TRACE("Size is %" PRIu64, *size);
 332
 333     if (!name) {
 334         if (read_sync(csock, flags, sizeof(*flags)) != sizeof(*flags)) {
 335             LOG("read failed (flags)");
 336             errno = EINVAL;
 337             return -1;
 338         }
 339         *flags = be32_to_cpup(flags);
 340     } else {
 341         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 342             LOG("read failed (tmp)");
 343             errno = EINVAL;
 344             return -1;
 345         }
 346         *flags |= be32_to_cpu(tmp);
 347     }
 348     if (read_sync(csock, &buf, 124) != 124) {
 349         LOG("read failed (buf)");
 350         errno = EINVAL;
 351         return -1;
 352     }
 353         return 0;
 354 }
 355
 356 #ifdef __linux__
 357 int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
 358 {
 359     TRACE("Setting block size to %lu", (unsigned long)blocksize);
 360
 361     if (ioctl(fd, NBD_SET_BLKSIZE, blocksize) == -1) {
 362         int serrno = errno;
 363         LOG("Failed setting NBD block size");
 364         errno = serrno;
 365         return -1;
 366     }
 367
 368         TRACE("Setting size to %zd block(s)", (size_t)(size / blocksize));
 369
 370     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, size / blocksize) == -1) {
 371         int serrno = errno;
 372         LOG("Failed setting size (in blocks)");
 373         errno = serrno;
 374         return -1;
 375     }
 376
 377     if (flags & NBD_FLAG_READ_ONLY) {
 378         int read_only = 1;
 379         TRACE("Setting readonly attribute");
 380
 381         if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 382             int serrno = errno;
 383             LOG("Failed setting read-only attribute");
 384             errno = serrno;
 385             return -1;
 386         }
 387     }
 388
 389     if (ioctl(fd, NBD_SET_FLAGS, flags) < 0
 390         && errno != ENOTTY) {
 391         int serrno = errno;
 392         LOG("Failed setting flags");
 393         errno = serrno;
 394         return -1;
 395     }
 396
 397     TRACE("Clearing NBD socket");
 398
 399     if (ioctl(fd, NBD_CLEAR_SOCK) == -1) {
 400         int serrno = errno;
 401         LOG("Failed clearing NBD socket");
 402         errno = serrno;
 403         return -1;
 404     }
 405
 406     TRACE("Setting NBD socket");
 407
 408     if (ioctl(fd, NBD_SET_SOCK, csock) == -1) {
 409         int serrno = errno;
 410         LOG("Failed to set NBD socket");
 411         errno = serrno;
 412         return -1;
 413     }
 414
 415     TRACE("Negotiation ended");
 416
 417     return 0;
 418 }
 419
 420 int nbd_disconnect(int fd)
 421 {
 422     ioctl(fd, NBD_CLEAR_QUE);
 423     ioctl(fd, NBD_DISCONNECT);
 424     ioctl(fd, NBD_CLEAR_SOCK);
 425     return 0;
 426 }
 427
 428 int nbd_client(int fd)
 429 {
 430     int ret;
 431     int serrno;
 432
 433     TRACE("Doing NBD loop");
 434
 435     ret = ioctl(fd, NBD_DO_IT);
 436     if (ret == -1 && errno == EPIPE) {
 437         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 438          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
 439          * that case.
 440          */
 441         ret = 0;
 442     }
 443     serrno = errno;
 444
 445     TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
 446
 447     TRACE("Clearing NBD queue");
 448     ioctl(fd, NBD_CLEAR_QUE);
 449
 450     TRACE("Clearing NBD socket");
 451     ioctl(fd, NBD_CLEAR_SOCK);
 452
 453     errno = serrno;
 454     return ret;
 455 }
 456 #else
 457 int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
 458 {
 459     errno = ENOTSUP;
 460     return -1;
 461 }
 462
 463 int nbd_disconnect(int fd)
 464 {
 465     errno = ENOTSUP;
 466     return -1;
 467 }
 468
 469 int nbd_client(int fd)
 470 {
 471     errno = ENOTSUP;
 472     return -1;
 473 }
 474 #endif
 475
 476 int nbd_send_request(int csock, struct nbd_request *request)
 477 {
 478     uint8_t buf[4 + 4 + 8 + 8 + 4];
 479
 480     cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
 481     cpu_to_be32w((uint32_t*)(buf + 4), request->type);
 482     cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
 483     cpu_to_be64w((uint64_t*)(buf + 16), request->from);
 484     cpu_to_be32w((uint32_t*)(buf + 24), request->len);
 485
 486     TRACE("Sending request to client: "
 487           "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}",
 488           request->from, request->len, request->handle, request->type);
 489
 490     if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 491         LOG("writing to socket failed");
 492         errno = EINVAL;
 493         return -1;
 494     }
 495     return 0;
 496 }
 497
 498 static int nbd_receive_request(int csock, struct nbd_request *request)
 499 {
 500     uint8_t buf[4 + 4 + 8 + 8 + 4];
 501     uint32_t magic;
 502
 503     if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 504         LOG("read failed");
 505         errno = EINVAL;
 506         return -1;
 507     }
 508
 509     /* Request
 510        [ 0 ..  3]   magic   (NBD_REQUEST_MAGIC)
 511        [ 4 ..  7]   type    (0 == READ, 1 == WRITE)
 512        [ 8 .. 15]   handle
 513        [16 .. 23]   from
 514        [24 .. 27]   len
 515      */
 516
 517     magic = be32_to_cpup((uint32_t*)buf);
 518     request->type  = be32_to_cpup((uint32_t*)(buf + 4));
 519     request->handle = be64_to_cpup((uint64_t*)(buf + 8));
 520     request->from  = be64_to_cpup((uint64_t*)(buf + 16));
 521     request->len   = be32_to_cpup((uint32_t*)(buf + 24));
 522
 523     TRACE("Got request: "
 524           "{ magic = 0x%x, .type = %d, from = %" PRIu64" , len = %u }",
 525           magic, request->type, request->from, request->len);
 526
 527     if (magic != NBD_REQUEST_MAGIC) {
 528         LOG("invalid magic (got 0x%x)", magic);
 529         errno = EINVAL;
 530         return -1;
 531     }
 532     return 0;
 533 }
 534
 535 int nbd_receive_reply(int csock, struct nbd_reply *reply)
 536 {
 537     uint8_t buf[NBD_REPLY_SIZE];
 538     uint32_t magic;
 539
 540     memset(buf, 0xAA, sizeof(buf));
 541
 542     if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 543         LOG("read failed");
 544         errno = EINVAL;
 545         return -1;
 546     }
 547
 548     /* Reply
 549        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 550        [ 4 ..  7]    error   (0 == no error)
 551        [ 7 .. 15]    handle
 552      */
 553
 554     magic = be32_to_cpup((uint32_t*)buf);
 555     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
 556     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
 557
 558     TRACE("Got reply: "
 559           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
 560           magic, reply->error, reply->handle);
 561
 562     if (magic != NBD_REPLY_MAGIC) {
 563         LOG("invalid magic (got 0x%x)", magic);
 564         errno = EINVAL;
 565         return -1;
 566     }
 567     return 0;
 568 }
 569
 570 static int nbd_send_reply(int csock, struct nbd_reply *reply)
 571 {
 572     uint8_t buf[4 + 4 + 8];
 573
 574     /* Reply
 575        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 576        [ 4 ..  7]    error   (0 == no error)
 577        [ 7 .. 15]    handle
 578      */
 579     cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC);
 580     cpu_to_be32w((uint32_t*)(buf + 4), reply->error);
 581     cpu_to_be64w((uint64_t*)(buf + 8), reply->handle);
 582
 583     TRACE("Sending response to client");
 584
 585     if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 586         LOG("writing to socket failed");
 587         errno = EINVAL;
 588         return -1;
 589     }
 590     return 0;
 591 }
 592
 593 int nbd_trip(BlockDriverState *bs, int csock, off_t size, uint64_t dev_offset,
 594              off_t *offset, uint32_t nbdflags, uint8_t *data, int data_size)
 595 {
 596     struct nbd_request request;
 597     struct nbd_reply reply;
 598     int ret;
 599
 600     TRACE("Reading request.");
 601
 602     if (nbd_receive_request(csock, &request) == -1)
 603         return -1;
 604
 605     if (request.len + NBD_REPLY_SIZE > data_size) {
 606         LOG("len (%u) is larger than max len (%u)",
 607             request.len + NBD_REPLY_SIZE, data_size);
 608         errno = EINVAL;
 609         return -1;
 610     }
 611
 612     if ((request.from + request.len) < request.from) {
 613         LOG("integer overflow detected! "
 614             "you're probably being attacked");
 615         errno = EINVAL;
 616         return -1;
 617     }
 618
 619     if ((request.from + request.len) > size) {
 620             LOG("From: %" PRIu64 ", Len: %u, Size: %" PRIu64
 621             ", Offset: %" PRIu64 "\n",
 622                     request.from, request.len, (uint64_t)size, dev_offset);
 623         LOG("requested operation past EOF--bad client?");
 624         errno = EINVAL;
 625         return -1;
 626     }
 627
 628     TRACE("Decoding type");
 629
 630     reply.handle = request.handle;
 631     reply.error = 0;
 632
 633     switch (request.type) {
 634     case NBD_CMD_READ:
 635         TRACE("Request type is READ");
 636
 637         ret = bdrv_read(bs, (request.from + dev_offset) / 512,
 638                         data + NBD_REPLY_SIZE,
 639                         request.len / 512);
 640         if (ret < 0) {
 641             LOG("reading from file failed");
 642             reply.error = -ret;
 643             request.len = 0;
 644         }
 645         *offset += request.len;
 646
 647         TRACE("Read %u byte(s)", request.len);
 648
 649         /* Reply
 650            [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 651            [ 4 ..  7]    error   (0 == no error)
 652            [ 7 .. 15]    handle
 653          */
 654
 655         cpu_to_be32w((uint32_t*)data, NBD_REPLY_MAGIC);
 656         cpu_to_be32w((uint32_t*)(data + 4), reply.error);
 657         cpu_to_be64w((uint64_t*)(data + 8), reply.handle);
 658
 659         TRACE("Sending data to client");
 660
 661         if (write_sync(csock, data,
 662                    request.len + NBD_REPLY_SIZE) !=
 663                    request.len + NBD_REPLY_SIZE) {
 664             LOG("writing to socket failed");
 665             errno = EINVAL;
 666             return -1;
 667         }
 668         break;
 669     case NBD_CMD_WRITE:
 670         TRACE("Request type is WRITE");
 671
 672         TRACE("Reading %u byte(s)", request.len);
 673
 674         if (read_sync(csock, data, request.len) != request.len) {
 675             LOG("reading from socket failed");
 676             errno = EINVAL;
 677             return -1;
 678         }
 679
 680         if (nbdflags & NBD_FLAG_READ_ONLY) {
 681             TRACE("Server is read-only, return error");
 682             reply.error = 1;
 683         } else {
 684             TRACE("Writing to device");
 685
 686             ret = bdrv_write(bs, (request.from + dev_offset) / 512,
 687                              data, request.len / 512);
 688             if (ret < 0) {
 689                 LOG("writing to file failed");
 690                 reply.error = -ret;
 691                 request.len = 0;
 692             }
 693
 694             *offset += request.len;
 695         }
 696
 697         if (nbd_send_reply(csock, &reply) == -1)
 698             return -1;
 699         break;
 700     case NBD_CMD_DISC:
 701         TRACE("Request type is DISCONNECT");
 702         errno = 0;
 703         return 1;
 704     default:
 705         LOG("invalid request type (%u) received", request.type);
 706         errno = EINVAL;
 707         return -1;
 708     }
 709
 710     TRACE("Request/Reply complete");
 711
 712     return 0;
 713 }