nbd-client.c

   1 /*
   2  * Open connection for network block device
   3  *
   4  * Copyright 1997,1998 Pavel Machek, distribute under GPL
   5  *  <pavel@atrey.karlin.mff.cuni.cz>
   6  * Copyright (c) 2002 - 2011 Wouter Verhelst <w@uter.be>
   7  *
   8  * Version 1.0 - 64bit issues should be fixed, now
   9  * Version 1.1 - added bs (blocksize) option (Alexey Guzeev, aga@permonline.ru)
  10  * Version 1.2 - I added new option '-d' to send the disconnect request
  11  * Version 2.0 - Version synchronised with server
  12  * Version 2.1 - Check for disconnection before INIT_PASSWD is received
  13  *      to make errormsg a bit more helpful in case the server can't
  14  *      open the exported file.
  15  * 16/03/2010 - Add IPv6 support.
  16  *      Kitt Tientanopajai <kitt@kitty.in.th>
  17  *      Neutron Soutmun <neo.neutron@gmail.com>
  18  *      Suriya Soutmun <darksolar@gmail.com>
  19  */
  20
  21 #include "config.h"
  22 #include "lfs.h"
  23
  24 #include <sys/ioctl.h>
  25 #include <sys/socket.h>
  26 #include <sys/un.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29 #include <netinet/tcp.h>
  30 #include <netinet/in.h>
  31 #include <netdb.h>
  32 #include "netdb-compat.h"
  33 #include <inttypes.h>
  34 #include <stdio.h>
  35 #include <fcntl.h>
  36 #include <syslog.h>
  37 #include <stdlib.h>
  38 #include <sys/mount.h>
  39 #include <sys/mman.h>
  40 #include <signal.h>
  41 #include <errno.h>
  42 #include <getopt.h>
  43 #include <stdarg.h>
  44 #include <stdbool.h>
  45 #include <time.h>
  46
  47 #include <linux/ioctl.h>
  48
  49 #if HAVE_NETLINK
  50 #include "nbd-netlink.h"
  51 #include <netlink/netlink.h>
  52 #include <netlink/genl/genl.h>
  53 #include <netlink/genl/ctrl.h>
  54 #endif
  55
  56 #define MY_NAME "nbd_client"
  57 #include "cliserv.h"
  58
  59 #if HAVE_GNUTLS && !defined(NOTLS)
  60 #include "crypto-gnutls.h"
  61 #endif
  62
  63 #ifdef WITH_SDP
  64 #include <sdp_inet.h>
  65 #endif
  66
  67 #define NBDC_DO_LIST 1
  68
  69 #if HAVE_NETLINK
  70 static int callback(struct nl_msg *msg, void *arg) {
  71         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
  72         struct nlattr *msg_attr[NBD_ATTR_MAX + 1];
  73         int ret;
  74         uint32_t index;
  75
  76         ret = nla_parse(msg_attr, NBD_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
  77                         genlmsg_attrlen(gnlh, 0), NULL);
  78         if (ret)
  79                 err("Invalid response from the kernel\n");
  80         if (!msg_attr[NBD_ATTR_INDEX])
  81                 err("Did not receive index from the kernel\n");
  82         index = nla_get_u32(msg_attr[NBD_ATTR_INDEX]);
  83         printf("Connected /dev/nbd%d\n", (int)index);
  84         return NL_OK;
  85 }
  86
  87 static struct nl_sock *get_nbd_socket(int *driver_id) {
  88         struct nl_sock *socket;
  89
  90         socket = nl_socket_alloc();
  91         if (!socket)
  92                 err("Couldn't allocate netlink socket\n");
  93
  94         if (genl_connect(socket))
  95                 err("Couldn't connect to the generic netlink socket\n");
  96         *driver_id = genl_ctrl_resolve(socket, "nbd");
  97         if (*driver_id < 0)
  98                 err("Couldn't resolve the nbd netlink family, make sure the nbd module is loaded and your nbd driver supports the netlink interface.\n");
  99         return socket;
 100 }
 101
 102 static void netlink_configure(int index, int *sockfds, int num_connects,
 103                               u64 size64, int blocksize, uint16_t flags,
 104                               int timeout) {
 105         struct nl_sock *socket;
 106         struct nlattr *sock_attr;
 107         struct nl_msg *msg;
 108         int driver_id, i;
 109
 110         socket = get_nbd_socket(&driver_id);
 111         nl_socket_modify_cb(socket, NL_CB_VALID, NL_CB_CUSTOM, callback, NULL);
 112
 113         msg = nlmsg_alloc();
 114         if (!msg)
 115                 err("Couldn't allocate netlink message\n");
 116         genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ, driver_id, 0, 0,
 117                     NBD_CMD_CONNECT, 0);
 118         if (index >= 0)
 119                 NLA_PUT_U32(msg, NBD_ATTR_INDEX, index);
 120         NLA_PUT_U64(msg, NBD_ATTR_SIZE_BYTES, size64);
 121         NLA_PUT_U64(msg, NBD_ATTR_BLOCK_SIZE_BYTES, blocksize);
 122         NLA_PUT_U64(msg, NBD_ATTR_SERVER_FLAGS, flags);
 123         NLA_PUT_U64(msg, NBD_ATTR_TIMEOUT, timeout);
 124
 125         sock_attr = nla_nest_start(msg, NBD_ATTR_SOCKETS);
 126         if (!sock_attr)
 127                 err("Couldn't nest the sockets for our connection\n");
 128         for (i = 0; i < num_connects; i++) {
 129                 struct nlattr *sock_opt;
 130                 sock_opt = nla_nest_start(msg, NBD_SOCK_ITEM);
 131                 if (!sock_opt)
 132                         err("Couldn't nest the sockets for our connection\n");
 133                 NLA_PUT_U32(msg, NBD_SOCK_FD, sockfds[i]);
 134                 nla_nest_end(msg, sock_opt);
 135         }
 136         nla_nest_end(msg, sock_attr);
 137
 138         if (nl_send_sync(socket, msg) < 0)
 139                 err("Failed to setup device, check dmesg\n");
 140         return;
 141 nla_put_failure:
 142         err("Failed to create netlink message\n");
 143 }
 144
 145 static void netlink_disconnect(char *nbddev) {
 146         struct nl_sock *socket;
 147         struct nl_msg *msg;
 148         int driver_id;
 149
 150         int index = -1;
 151         if (nbddev) {
 152                 if (sscanf(nbddev, "/dev/nbd%d", &index) != 1)
 153                         err("Invalid nbd device target\n");
 154         }
 155         if (index < 0)
 156                 err("Invalid nbd device target\n");
 157
 158         socket = get_nbd_socket(&driver_id);
 159
 160         msg = nlmsg_alloc();
 161         if (!msg)
 162                 err("Couldn't allocate netlink message\n");
 163         genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ, driver_id, 0, 0,
 164                     NBD_CMD_DISCONNECT, 0);
 165         NLA_PUT_U32(msg, NBD_ATTR_INDEX, index);
 166         if (nl_send_sync(socket, msg) < 0)
 167                 err("Failed to disconnect device, check dmsg\n");
 168         nl_socket_free(socket);
 169         return;
 170 nla_put_failure:
 171         err("Failed to create netlink message\n");
 172 }
 173 #else
 174 static void netlink_configure(int index, int *sockfds, int num_connects,
 175                               u64 size64, int blocksize, uint16_t flags,
 176                               int timeout)
 177 {
 178 }
 179
 180 static void netlink_disconnect(char *nbddev)
 181 {
 182 }
 183 #endif /* HAVE_NETLINK */
 184
 185 int check_conn(char* devname, int do_print) {
 186         char buf[256];
 187         char* p;
 188         int fd;
 189         int len;
 190
 191         if( (p=strrchr(devname, '/')) ) {
 192                 devname=p+1;
 193         }
 194         if((p=strchr(devname, 'p'))) {
 195                 /* We can't do checks on partitions. */
 196                 *p='\0';
 197         }
 198         snprintf(buf, 256, "/sys/block/%s/pid", devname);
 199         if((fd=open(buf, O_RDONLY))<0) {
 200                 if(errno==ENOENT) {
 201                         return 1;
 202                 } else {
 203                         return 2;
 204                 }
 205         }
 206         len=read(fd, buf, 256);
 207         if(len < 0) {
 208                 perror("could not read from server");
 209                 close(fd);
 210                 return 2;
 211         }
 212         buf[(len < 256) ? len : 255]='\0';
 213         if(do_print) printf("%s\n", buf);
 214         close(fd);
 215         return 0;
 216 }
 217
 218 int opennet(char *name, char* portstr, int sdp) {
 219         int sock;
 220         struct addrinfo hints;
 221         struct addrinfo *ai = NULL;
 222         struct addrinfo *rp = NULL;
 223         int e;
 224
 225         memset(&hints,'\0',sizeof(hints));
 226         hints.ai_family = AF_UNSPEC;
 227         hints.ai_socktype = SOCK_STREAM;
 228         hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
 229         hints.ai_protocol = IPPROTO_TCP;
 230
 231         e = getaddrinfo(name, portstr, &hints, &ai);
 232
 233         if(e != 0) {
 234                 fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
 235                 freeaddrinfo(ai);
 236                 return -1;
 237         }
 238
 239         if(sdp) {
 240 #ifdef WITH_SDP
 241                 if (ai->ai_family == AF_INET)
 242                         ai->ai_family = AF_INET_SDP;
 243                 else (ai->ai_family == AF_INET6)
 244                         ai->ai_family = AF_INET6_SDP;
 245 #else
 246                 err("Can't do SDP: I was not compiled with SDP support!");
 247 #endif
 248         }
 249
 250         for(rp = ai; rp != NULL; rp = rp->ai_next) {
 251                 sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
 252
 253                 if(sock == -1)
 254                         continue;       /* error */
 255
 256                 if(connect(sock, rp->ai_addr, rp->ai_addrlen) != -1)
 257                         break;          /* success */
 258
 259                 close(sock);
 260         }
 261
 262         if (rp == NULL) {
 263                 err_nonfatal("Socket failed: %m");
 264                 sock = -1;
 265                 goto err;
 266         }
 267
 268         setmysockopt(sock);
 269 err:
 270         freeaddrinfo(ai);
 271         return sock;
 272 }
 273
 274 int openunix(const char *path) {
 275         int sock;
 276         struct sockaddr_un un_addr;
 277         memset(&un_addr, 0, sizeof(un_addr));
 278
 279         un_addr.sun_family = AF_UNIX;
 280         if (strnlen(path, sizeof(un_addr.sun_path)) == sizeof(un_addr.sun_path)) {
 281                 err_nonfatal("UNIX socket path too long");
 282                 return -1;
 283         }
 284
 285         strncpy(un_addr.sun_path, path, sizeof(un_addr.sun_path) - 1);
 286
 287         if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
 288                 err_nonfatal("SOCKET failed");
 289                 return -1;
 290         };
 291
 292         if (connect(sock, &un_addr, sizeof(un_addr)) == -1) {
 293                 err_nonfatal("CONNECT failed");
 294                 close(sock);
 295                 return -1;
 296         }
 297         return sock;
 298 }
 299
 300 void send_request(int sock, uint32_t opt, ssize_t datasize, void* data) {
 301         struct {
 302                 uint64_t magic;
 303                 uint32_t opt;
 304                 uint32_t datasize;
 305         } __attribute__((packed)) header = {
 306                 ntohll(opts_magic),
 307                 ntohl(opt),
 308                 ntohl(datasize),
 309         };
 310         if(datasize < 0) {
 311                 datasize = strlen((char*)data);
 312                 header.datasize = htonl(datasize);
 313         }
 314         writeit(sock, &header, sizeof(header));
 315         if(data != NULL) {
 316                 writeit(sock, data, datasize);
 317         }
 318 }
 319
 320 void send_info_request(int sock, uint32_t opt, int n_reqs, uint16_t* reqs, char* name) {
 321         uint16_t rlen = htons(n_reqs);
 322         uint32_t nlen = htonl(strlen(name));
 323
 324         send_request(sock, opt, sizeof(uint32_t) + strlen(name) + sizeof(uint16_t) + n_reqs * sizeof(uint16_t), NULL);
 325         writeit(sock, &nlen, sizeof(nlen));
 326         writeit(sock, name, strlen(name));
 327         writeit(sock, &rlen, sizeof(rlen));
 328         if(n_reqs > 0) {
 329                 writeit(sock, reqs, n_reqs * sizeof(uint16_t));
 330         }
 331 }
 332
 333 struct reply {
 334         uint64_t magic;
 335         uint32_t opt;
 336         uint32_t reply_type;
 337         uint32_t datasize;
 338         char data[];
 339 } __attribute__((packed));
 340
 341 struct reply* read_reply(int sock) {
 342         struct reply *retval = malloc(sizeof(struct reply));
 343         readit(sock, retval, sizeof(*retval));
 344         retval->magic = ntohll(retval->magic);
 345         retval->opt = ntohl(retval->opt);
 346         retval->reply_type = ntohl(retval->reply_type);
 347         retval->datasize = ntohl(retval->datasize);
 348         if (retval->magic != rep_magic) {
 349                 fprintf(stderr, "E: received invalid negotiation magic %" PRIu64 " (expected %" PRIu64 ")", retval->magic, rep_magic);
 350                 exit(EXIT_FAILURE);
 351         }
 352         if (retval->datasize > 0) {
 353                 retval = realloc(retval, sizeof(struct reply) + retval->datasize);
 354                 readit(sock, &(retval->data), retval->datasize);
 355         }
 356         return retval;
 357 }
 358
 359 void ask_list(int sock) {
 360         uint32_t opt_server;
 361         uint32_t len;
 362         uint32_t lenn;
 363         uint32_t reptype;
 364         uint64_t magic;
 365         int rlen;
 366         const int BUF_SIZE = 1024;
 367         char buf[BUF_SIZE];
 368
 369         send_request(sock, NBD_OPT_LIST, 0, NULL);
 370         /* newline, move away from the "Negotiation:" line */
 371         printf("\n");
 372         do {
 373                 memset(buf, 0, 1024);
 374                 if(read(sock, &magic, sizeof(magic)) < 0) {
 375                         err("Reading magic from server: %m");
 376                 }
 377                 if(read(sock, &opt_server, sizeof(opt_server)) < 0) {
 378                         err("Reading option: %m");
 379                 }
 380                 if(read(sock, &reptype, sizeof(reptype)) <0) {
 381                         err("Reading reply from server: %m");
 382                 }
 383                 if(read(sock, &len, sizeof(len)) < 0) {
 384                         err("Reading length from server: %m");
 385                 }
 386                 magic=ntohll(magic);
 387                 len=ntohl(len);
 388                 reptype=ntohl(reptype);
 389                 if(magic != rep_magic) {
 390                         err("Not enough magic from server");
 391                 }
 392                 if(reptype & NBD_REP_FLAG_ERROR) {
 393                         switch(reptype) {
 394                                 case NBD_REP_ERR_POLICY:
 395                                         fprintf(stderr, "\nE: listing not allowed by server.\n");
 396                                         break;
 397                                 default:
 398                                         fprintf(stderr, "\nE: unexpected error from server.\n");
 399                                         break;
 400                         }
 401                         if(len > 0 && len < BUF_SIZE) {
 402                                 if((rlen=read(sock, buf, len)) < 0) {
 403                                         fprintf(stderr, "\nE: could not read error message from server\n");
 404                                 } else {
 405                                         buf[rlen] = '\0';
 406                                         fprintf(stderr, "Server said: %s\n", buf);
 407                                 }
 408                         }
 409                         exit(EXIT_FAILURE);
 410                 } else {
 411                         if(reptype != NBD_REP_ACK) {
 412                                 if(reptype != NBD_REP_SERVER) {
 413                                         err("Server sent us a reply we don't understand!");
 414                                 }
 415                                 if(read(sock, &lenn, sizeof(lenn)) < 0) {
 416                                         fprintf(stderr, "\nE: could not read export name length from server\n");
 417                                         exit(EXIT_FAILURE);
 418                                 }
 419                                 lenn=ntohl(lenn);
 420                                 if (lenn >= BUF_SIZE) {
 421                                         fprintf(stderr, "\nE: export name on server too long\n");
 422                                         exit(EXIT_FAILURE);
 423                                 }
 424                                 if(read(sock, buf, lenn) < 0) {
 425                                         fprintf(stderr, "\nE: could not read export name from server\n");
 426                                         exit(EXIT_FAILURE);
 427                                 }
 428                                 buf[lenn] = 0;
 429                                 printf("%s", buf);
 430                                 len -= lenn;
 431                                 len -= sizeof(lenn);
 432                                 if(len > 0) {
 433                                         if(read(sock, buf, len) < 0) {
 434                                                 fprintf(stderr, "\nE: could not read export description from server\n");
 435                                                 exit(EXIT_FAILURE);
 436                                         }
 437                                         buf[len] = 0;
 438                                         printf(": %s\n", buf);
 439                                 } else {
 440                                         printf("\n");
 441                                 }
 442                         }
 443                 }
 444         } while(reptype != NBD_REP_ACK);
 445         send_request(sock, NBD_OPT_ABORT, 0, NULL);
 446 }
 447
 448 void parse_sizes(char *buf, uint64_t *size, uint16_t *flags) {
 449         memcpy(size, buf, sizeof(*size));
 450         *size = ntohll(*size);
 451         buf += sizeof(*size);
 452         memcpy(flags, buf, sizeof(*flags));
 453         *flags = ntohs(*flags);
 454
 455         if ((*size>>12) > (uint64_t)~0UL) {
 456                 printf("size = %luMB", (unsigned long)(*size>>20));
 457                 err("Exported device is too big for me. Get 64-bit machine :-(\n");
 458         } else {
 459                 printf("size = %luMB", (unsigned long)(*size>>20));
 460         }
 461         printf("\n");
 462 }
 463
 464 void negotiate(int *sockp, u64 *rsize64, uint16_t *flags, char* name, uint32_t needed_flags, uint32_t client_flags, uint32_t do_opts, char *certfile, char *keyfile, char *cacertfile, char *tlshostname, bool tls) {
 465         u64 magic;
 466         uint16_t tmp;
 467         uint16_t global_flags;
 468         char buf[256] = "\0\0\0\0\0\0\0\0\0";
 469         int sock = *sockp;
 470
 471         printf("Negotiation: ");
 472         readit(sock, buf, 8);
 473         if (strcmp(buf, INIT_PASSWD))
 474                 err("INIT_PASSWD bad");
 475         printf(".");
 476         readit(sock, &magic, sizeof(magic));
 477         magic = ntohll(magic);
 478         if (magic != opts_magic) {
 479                 if(magic == cliserv_magic) {
 480                         err("It looks like you're trying to connect to an oldstyle server. This is no longer supported since nbd 3.10.");
 481                 }
 482         }
 483         printf(".");
 484         readit(sock, &tmp, sizeof(uint16_t));
 485         global_flags = ntohs(tmp);
 486         if((needed_flags & global_flags) != needed_flags) {
 487                 /* There's currently really only one reason why this
 488                  * check could possibly fail, but we may need to change
 489                  * this error message in the future... */
 490                 fprintf(stderr, "\nE: Server does not support listing exports\n");
 491                 exit(EXIT_FAILURE);
 492         }
 493
 494         if (global_flags & NBD_FLAG_NO_ZEROES) {
 495                 client_flags |= NBD_FLAG_C_NO_ZEROES;
 496         }
 497         client_flags = htonl(client_flags);
 498         if (write(sock, &client_flags, sizeof(client_flags)) < 0)
 499                 err("Failed/2.1: %m");
 500
 501 #if HAVE_GNUTLS && !defined(NOTLS)
 502         /* TLS */
 503         if (tls) {
 504                 int plainfd[2]; // [0] is used by the proxy, [1] is used by NBD
 505                 tlssession_t *s = NULL;
 506                 int ret;
 507                 uint32_t tmp32;
 508                 uint64_t tmp64;
 509
 510                 send_request(sock, NBD_OPT_STARTTLS, 0, NULL);
 511
 512                 if (read(sock, &tmp64, sizeof(tmp64)) < 0)
 513                         err("Could not read cliserv_magic: %m");
 514                 tmp64 = ntohll(tmp64);
 515                 if (tmp64 != NBD_OPT_REPLY_MAGIC) {
 516                         err("reply magic does not match");
 517                 }
 518                 if (read(sock, &tmp32, sizeof(tmp32)) < 0)
 519                         err("Could not read option type: %m");
 520                 tmp32 = ntohl(tmp32);
 521                 if (tmp32 != NBD_OPT_STARTTLS)
 522                         err("Reply to wrong option");
 523                 if (read(sock, &tmp32, sizeof(tmp32)) < 0)
 524                         err("Could not read option reply type: %m");
 525                 tmp32 = ntohl(tmp32);
 526                 if (tmp32 != NBD_REP_ACK) {
 527                         err("Option reply type != NBD_REP_ACK");
 528                 }
 529                 if (read(sock, &tmp32, sizeof(tmp32)) < 0) err(
 530                         "Could not read option data length: %m");
 531                 tmp32 = ntohl(tmp32);
 532                 if (tmp32 != 0) {
 533                         err("Option reply data length != 0");
 534                 }
 535                 s = tlssession_new(0,
 536                                    keyfile,
 537                                    certfile,
 538                                    cacertfile,
 539                                    tlshostname,
 540                                    !cacertfile || !tlshostname, // insecure flag
 541 #ifdef DODBG
 542                                    1, // debug
 543 #else
 544                                    0, // debug
 545 #endif
 546                                    NULL, // quitfn
 547                                    NULL, // erroutfn
 548                                    NULL // opaque
 549                         );
 550                 if (!s)
 551                         err("Cannot establish TLS session");
 552
 553                 if (socketpair(AF_UNIX, SOCK_STREAM, 0, plainfd) < 0)
 554                         err("Cannot get socket pair");
 555
 556                 if (set_nonblocking(plainfd[0], 0) <0 ||
 557                     set_nonblocking(plainfd[1], 0) <0 ||
 558                     set_nonblocking(sock, 0) <0) {
 559                         close(plainfd[0]);
 560                         close(plainfd[1]);
 561                         err("Cannot set socket options");
 562                 }
 563
 564                 ret = fork();
 565                 if (ret < 0)
 566                         err("Could not fork");
 567                 else if (ret == 0) {
 568                         // we are the child
 569                         if (daemon(0, 0) < 0) {
 570                                 /* no one will see this */
 571                                 fprintf(stderr, "Can't detach from the terminal");
 572                                 exit(1);
 573                         }
 574                         signal (SIGPIPE, SIG_IGN);
 575                         close(plainfd[1]);
 576                         tlssession_mainloop(sock, plainfd[0], s);
 577                         close(sock);
 578                         close(plainfd[0]);
 579                         exit(0);
 580                 }
 581                 close(plainfd[0]);
 582                 close(sock);
 583                 sock = plainfd[1]; /* use the decrypted FD from now on */
 584                 *sockp = sock;
 585         }
 586 #else
 587         if (keyfile) {
 588                 err("TLS requested but support not compiled in");
 589         }
 590 #endif
 591
 592         if(do_opts & NBDC_DO_LIST) {
 593                 ask_list(sock);
 594                 exit(EXIT_SUCCESS);
 595         }
 596
 597         send_info_request(sock, NBD_OPT_GO, 0, NULL, name);
 598
 599         struct reply *rep = NULL;
 600
 601         do {
 602                 if(rep != NULL) free(rep);
 603                 rep = read_reply(sock);
 604                 if(rep->reply_type & NBD_REP_FLAG_ERROR) {
 605                         if(rep->reply_type == NBD_REP_ERR_UNSUP) {
 606                                 free(rep);
 607                                 /* server doesn't support NBD_OPT_GO or NBD_OPT_INFO,
 608                                  * fall back to NBD_OPT_EXPORT_NAME */
 609                                 send_request(sock, NBD_OPT_EXPORT_NAME, -1, name);
 610                                 char b[sizeof(*flags) + sizeof(*rsize64)];
 611                                 readit(sock, b, sizeof(b));
 612                                 parse_sizes(b, rsize64, flags);
 613                                 if(!(global_flags & NBD_FLAG_NO_ZEROES)) {
 614                                         readit(sock, buf, 124);
 615                                 }
 616                                 return;
 617                         } else {
 618                                 err("Unknown error in reply to NBD_OPT_GO; cannot continue");
 619                                 exit(EXIT_FAILURE);
 620                         }
 621                 }
 622                 uint16_t info_type;
 623                 switch(rep->reply_type) {
 624                         case NBD_REP_INFO:
 625                                 memcpy(&info_type, rep->data, 2);
 626                                 info_type = htons(info_type);
 627                                 switch(info_type) {
 628                                         case NBD_INFO_EXPORT:
 629                                                 parse_sizes(rep->data + 2, rsize64, flags);
 630                                                 break;
 631                                         default:
 632                                                 // ignore these, don't need them
 633                                                 break;
 634                                 }
 635                                 break;
 636                         case NBD_REP_ACK:
 637                                 break;
 638                         default:
 639                                 err_nonfatal("Unknown reply to NBD_OPT_GO received");
 640                 }
 641         } while(rep->reply_type != NBD_REP_ACK);
 642         free(rep);
 643 }
 644
 645 bool get_from_config(char* cfgname, char** name_ptr, char** dev_ptr, char** hostn_ptr, int* bs, int* timeout, int* persist, int* swap, int* sdp, int* b_unix, char**port, int* num_conns, char **certfile, char **keyfile, char **cacertfile, char **tlshostname) {
 646         int fd = open(SYSCONFDIR "/nbdtab", O_RDONLY);
 647         bool retval = false;
 648         if(fd < 0) {
 649                 fprintf(stderr, "while opening %s: ", SYSCONFDIR "/nbdtab");
 650                 perror("could not open config file");
 651                 goto out;
 652         }
 653         off_t size = lseek(fd, 0, SEEK_END);
 654         lseek(fd, 0, SEEK_SET);
 655         void *data = NULL;
 656         char *fsep = "\n\t# ";
 657         char *lsep = "\n#";
 658
 659         if(size < 0) {
 660                 perror("E: mmap'ing nbdtab");
 661                 exit(EXIT_FAILURE);
 662         }
 663
 664         data = mmap(NULL, (size_t)size, PROT_READ, MAP_SHARED, fd, 0);
 665         if(!strncmp(cfgname, "/dev/", 5)) {
 666                 cfgname += 5;
 667         }
 668         char *loc = strstr((const char*)data, cfgname);
 669         if(!loc) {
 670                 goto out;
 671         }
 672         size_t l = strlen(cfgname) + 6;
 673         *dev_ptr = malloc(l);
 674         snprintf(*dev_ptr, l, "/dev/%s", cfgname);
 675
 676         size_t line_len, field_len, ws_len;
 677 #define CHECK_LEN field_len = strcspn(loc, fsep); ws_len = strspn(loc+field_len, fsep); if(field_len > line_len || line_len <= 0) { goto out; }
 678 #define MOVE_NEXT line_len -= field_len + ws_len; loc += field_len + ws_len
 679         // find length of line
 680         line_len = strcspn(loc, lsep);
 681         // first field is the device node name, which we already know, so skip it
 682         CHECK_LEN;
 683         MOVE_NEXT;
 684         // next field is the hostname
 685         CHECK_LEN;
 686         *hostn_ptr = strndup(loc, field_len);
 687         MOVE_NEXT;
 688         // third field is the export name
 689         CHECK_LEN;
 690         *name_ptr = strndup(loc, field_len);
 691         if(ws_len + field_len > line_len) {
 692                 // optional last field is not there, so return success
 693                 retval = true;
 694                 goto out;
 695         }
 696         MOVE_NEXT;
 697         CHECK_LEN;
 698 #undef CHECK_LEN
 699 #undef MOVE_NEXT
 700         // fourth field is the options field, a comma-separated field of options
 701         do {
 702                 if(!strncmp(loc, "conns=", 6)) {
 703                         *num_conns = (int)strtol(loc+6, &loc, 0);
 704                         goto next;
 705                 }
 706                 if(!strncmp(loc, "bs=", 3)) {
 707                         *bs = (int)strtol(loc+3, &loc, 0);
 708                         goto next;
 709                 }
 710                 if(!strncmp(loc, "timeout=", 8)) {
 711                         *timeout = (int)strtol(loc+8, &loc, 0);
 712                         goto next;
 713                 }
 714                 if(!strncmp(loc, "port=", 5)) {
 715                         *port = strndup(loc+5, strcspn(loc+5, ","));
 716                         goto next;
 717                 }
 718                 if(!strncmp(loc, "persist", 7)) {
 719                         loc += 7;
 720                         *persist = 1;
 721                         goto next;
 722                 }
 723                 if(!strncmp(loc, "swap", 4)) {
 724                         *swap = 1;
 725                         loc += 4;
 726                         goto next;
 727                 }
 728                 if(!strncmp(loc, "sdp", 3)) {
 729                         *sdp = 1;
 730                         loc += 3;
 731                         goto next;
 732                 }
 733                 if(!strncmp(loc, "unix", 4)) {
 734                         *b_unix = 1;
 735                         loc += 4;
 736                         goto next;
 737                 }
 738                 if(!strncmp(loc, "certfile=", 9)) {
 739                         *certfile = strndup(loc+9, strcspn(loc+9, ","));
 740                         goto next;
 741                 }
 742                 if(!strncmp(loc, "keyfile=", 8)) {
 743                         *keyfile = strndup(loc+8, strcspn(loc+8, ","));
 744                         goto next;
 745                 }
 746                 if(!strncmp(loc, "cacertfile=", 11)) {
 747                         *cacertfile = strndup(loc+11, strcspn(loc+11, ","));
 748                         goto next;
 749                 }
 750                 if(!strncmp(loc, "tlshostname=", 9)) {
 751                         *tlshostname = strndup(loc+9, strcspn(loc+9, ","));
 752                         goto next;
 753                 }
 754                 // skip unknown options, with a warning unless they start with a '_'
 755                 l = strcspn(loc, ",");
 756                 if(*loc != '_') {
 757                         char* s = strndup(loc, l);
 758                         fprintf(stderr, "Warning: unknown option '%s' found in nbdtab file", s);
 759                         free(s);
 760                 }
 761                 loc += l;
 762 next:
 763                 if(*loc == ',') {
 764                         loc++;
 765                 }
 766         } while(strcspn(loc, lsep) > 0);
 767         retval = true;
 768 out:
 769         if(data != NULL) {
 770                 munmap(data, size);
 771         }
 772         if(fd >= 0) {
 773                 close(fd);
 774         }
 775         return retval;
 776 }
 777
 778 void setsizes(int nbd, u64 size64, int blocksize, u32 flags) {
 779         unsigned long size;
 780         int read_only = (flags & NBD_FLAG_READ_ONLY) ? 1 : 0;
 781
 782         if (size64>>12 > (uint64_t)~0UL)
 783                 err("Device too large.\n");
 784         else {
 785                 int tmp_blocksize = 4096;
 786                 if (size64 / (u64)blocksize <= (uint64_t)~0UL)
 787                         tmp_blocksize = blocksize;
 788                 if (ioctl(nbd, NBD_SET_BLKSIZE, tmp_blocksize) < 0) {
 789                         fprintf(stderr, "Failed to set blocksize %d\n",
 790                                 tmp_blocksize);
 791                         err("Ioctl/1.1a failed: %m\n");
 792                 }
 793                 size = (unsigned long)(size64 / (u64)tmp_blocksize);
 794                 if (ioctl(nbd, NBD_SET_SIZE_BLOCKS, size) < 0)
 795                         err("Ioctl/1.1b failed: %m\n");
 796                 if (tmp_blocksize != blocksize) {
 797                         if (ioctl(nbd, NBD_SET_BLKSIZE, (unsigned long)blocksize) < 0) {
 798                                 fprintf(stderr, "Failed to set blocksize %d\n",
 799                                         blocksize);
 800                                 err("Ioctl/1.1c failed: %m\n");
 801                         }
 802                 }
 803                 fprintf(stderr, "bs=%d, sz=%" PRIu64 " bytes\n", blocksize, (u64)tmp_blocksize * size);
 804         }
 805
 806         ioctl(nbd, NBD_CLEAR_SOCK);
 807
 808         /* ignore error as kernel may not support */
 809         ioctl(nbd, NBD_SET_FLAGS, (unsigned long) flags);
 810
 811         if (ioctl(nbd, BLKROSET, (unsigned long) &read_only) < 0)
 812                 err("Unable to set read-only attribute for device");
 813 }
 814
 815 void set_timeout(int nbd, int timeout) {
 816         if (timeout) {
 817                 if (ioctl(nbd, NBD_SET_TIMEOUT, (unsigned long)timeout) < 0)
 818                         err("Ioctl NBD_SET_TIMEOUT failed: %m\n");
 819                 fprintf(stderr, "timeout=%d\n", timeout);
 820         }
 821 }
 822
 823 void finish_sock(int sock, int nbd, int swap) {
 824         if (ioctl(nbd, NBD_SET_SOCK, sock) < 0) {
 825                 if (errno == EBUSY)
 826                         err("Kernel doesn't support multiple connections\n");
 827                 else
 828                         err("Ioctl NBD_SET_SOCK failed: %m\n");
 829         }
 830
 831 #ifndef __ANDROID__
 832         if (swap)
 833                 mlockall(MCL_CURRENT | MCL_FUTURE);
 834 #endif
 835 }
 836
 837 static int
 838 oom_adjust(const char *file, const char *value)
 839 {
 840         int fd, rc;
 841         size_t len;
 842
 843         fd = open(file, O_WRONLY);
 844         if (fd < 0)
 845                 return -1;
 846         len = strlen(value);
 847         rc = write(fd, value, len) != (ssize_t) len;
 848         close(fd);
 849         return rc ? -1 : 0;
 850 }
 851
 852 void usage(char* errmsg, ...) {
 853         if(errmsg) {
 854                 char tmp[256];
 855                 va_list ap;
 856                 va_start(ap, errmsg);
 857                 snprintf(tmp, 256, "ERROR: %s\n\n", errmsg);
 858                 vfprintf(stderr, tmp, ap);
 859                 va_end(ap);
 860         } else {
 861                 fprintf(stderr, "%s version %s\n", PROG_NAME, PACKAGE_VERSION);
 862         }
 863 #if HAVE_NETLINK
 864         fprintf(stderr, "Usage: nbd-client -name|-N name host [port] nbd_device\n\t[-block-size|-b block size] [-timeout|-t timeout] [-swap|-s] [-sdp|-S]\n\t[-persist|-p] [-nofork|-n] [-systemd-mark|-m] -L\n");
 865 #else
 866         fprintf(stderr, "Usage: nbd-client -name|-N name host [port] nbd_device\n\t[-block-size|-b block size] [-timeout|-t timeout] [-swap|-s] [-sdp|-S]\n\t[-persist|-p] [-nofork|-n] [-systemd-mark|-m]\n");
 867 #endif
 868         fprintf(stderr, "Or   : nbd-client -u (with same arguments as above)\n");
 869         fprintf(stderr, "Or   : nbd-client nbdX\n");
 870         fprintf(stderr, "Or   : nbd-client -d nbd_device\n");
 871         fprintf(stderr, "Or   : nbd-client -c nbd_device\n");
 872         fprintf(stderr, "Or   : nbd-client -h|--help\n");
 873         fprintf(stderr, "Or   : nbd-client -l|--list host\n");
 874         fprintf(stderr, "Or   : nbd-client -V|--version\n");
 875 #if HAVE_GNUTLS && !defined(NOTLS)
 876         fprintf(stderr, "All commands that connect to a host also take:\n\t[-F|-certfile certfile] [-K|-keyfile keyfile]\n\t[-A|-cacertfile cacertfile] [-H|-tlshostname hostname] [-x|-enable-tls]\n");
 877 #endif
 878         fprintf(stderr, "Default value for blocksize is 1024 (recommended for ethernet)\n");
 879         fprintf(stderr, "Allowed values for blocksize are 512,1024,2048,4096\n"); /* will be checked in kernel :) */
 880         fprintf(stderr, "Note, that kernel 2.4.2 and older ones do not work correctly with\n");
 881         fprintf(stderr, "blocksizes other than 1024 without patches\n");
 882         fprintf(stderr, "Default value for port is 10809. Note that port must always be numeric\n");
 883         fprintf(stderr, "Bug reports and general discussion should go to %s\n", PACKAGE_BUGREPORT);
 884 }
 885
 886 void disconnect(char* device) {
 887         int nbd = open(device, O_RDWR);
 888
 889         if (nbd < 0)
 890                 err("Cannot open NBD: %m\nPlease ensure the 'nbd' module is loaded.");
 891         printf("disconnect, ");
 892         if (ioctl(nbd, NBD_DISCONNECT)<0)
 893                 err("Ioctl failed: %m\n");
 894         printf("sock, ");
 895         if (ioctl(nbd, NBD_CLEAR_SOCK)<0)
 896                 err("Ioctl failed: %m\n");
 897         printf("done\n");
 898 }
 899
 900 #if HAVE_NETLINK
 901 static const char *short_opts = "-A:b:c:C:d:H:hK:LlnN:pSst:uVx";
 902 #else
 903 static const char *short_opts = "-A:b:c:C:d:H:hK:lnN:pSst:uVx";
 904 #endif
 905
 906 int main(int argc, char *argv[]) {
 907         char* port=NBD_DEFAULT_PORT;
 908         int sock, nbd;
 909         int blocksize=1024;
 910         char *hostname=NULL;
 911         char *nbddev=NULL;
 912         int swap=0;
 913         int cont=0;
 914         int timeout=0;
 915         int sdp=0;
 916         int G_GNUC_UNUSED nofork=0; // if -dNOFORK
 917         pid_t main_pid;
 918         u64 size64;
 919         uint16_t flags = 0;
 920         int c;
 921         int nonspecial=0;
 922         int b_unix=0;
 923         char* name="";
 924         uint16_t needed_flags=0;
 925         uint32_t cflags=NBD_FLAG_C_FIXED_NEWSTYLE;
 926         uint32_t opts=0;
 927         sigset_t block, old;
 928         char *certfile = NULL;
 929         char *keyfile = NULL;
 930         char *cacertfile = NULL;
 931         char *tlshostname = NULL;
 932         bool tls = false;
 933         struct sigaction sa;
 934         int num_connections = 1;
 935         int netlink = 0;
 936         int need_disconnect = 0;
 937         int *sockfds;
 938         struct option long_options[] = {
 939                 { "block-size", required_argument, NULL, 'b' },
 940                 { "check", required_argument, NULL, 'c' },
 941                 { "connections", required_argument, NULL, 'C'},
 942                 { "disconnect", required_argument, NULL, 'd' },
 943                 { "help", no_argument, NULL, 'h' },
 944                 { "list", no_argument, NULL, 'l' },
 945                 { "name", required_argument, NULL, 'N' },
 946 #if HAVE_NETLINK
 947                 { "netlink", no_argument, NULL, 'L' },
 948 #endif
 949                 { "nofork", no_argument, NULL, 'n' },
 950                 { "persist", no_argument, NULL, 'p' },
 951                 { "sdp", no_argument, NULL, 'S' },
 952                 { "swap", no_argument, NULL, 's' },
 953                 { "systemd-mark", no_argument, NULL, 'm' },
 954                 { "timeout", required_argument, NULL, 't' },
 955                 { "unix", no_argument, NULL, 'u' },
 956                 { "certfile", required_argument, NULL, 'F' },
 957                 { "keyfile", required_argument, NULL, 'K' },
 958                 { "cacertfile", required_argument, NULL, 'A' },
 959                 { "tlshostname", required_argument, NULL, 'H' },
 960                 { "enable-tls", no_argument, NULL, 'x' },
 961                 { "version", no_argument, NULL, 'V' },
 962                 { 0, 0, 0, 0 },
 963         };
 964         int i;
 965
 966         logging(MY_NAME);
 967
 968 #if HAVE_GNUTLS && !defined(NOTLS)
 969         tlssession_init();
 970 #endif
 971
 972         while((c=getopt_long_only(argc, argv, short_opts, long_options, NULL))>=0) {
 973                 switch(c) {
 974                 case 1:
 975                         // non-option argument
 976                         if(strchr(optarg, '=')) {
 977                                 // old-style 'bs=' or 'timeout='
 978                                 // argument
 979                                 fprintf(stderr, "WARNING: old-style command-line argument encountered. This is deprecated.\n");
 980                                 if(!strncmp(optarg, "bs=", 3)) {
 981                                         optarg+=3;
 982                                         goto blocksize;
 983                                 }
 984                                 if(!strncmp(optarg, "timeout=", 8)) {
 985                                         optarg+=8;
 986                                         goto timeout;
 987                                 }
 988                                 usage("unknown option %s encountered", optarg);
 989                                 exit(EXIT_FAILURE);
 990                         }
 991                         switch(nonspecial++) {
 992                                 case 0:
 993                                         // host
 994                                         hostname=optarg;
 995                                         break;
 996                                 case 1:
 997                                         // port
 998                                         if(!strtol(optarg, NULL, 0)) {
 999                                                 // not parseable as a number, assume it's the device
1000                                                 nbddev = optarg;
1001                                                 nonspecial++;
1002                                         } else {
1003                                                 port = optarg;
1004                                         }
1005                                         break;
1006                                 case 2:
1007                                         // device
1008                                         nbddev = optarg;
1009                                         break;
1010                                 default:
1011                                         usage("too many non-option arguments specified");
1012                                         exit(EXIT_FAILURE);
1013                         }
1014                         break;
1015                 case 'b':
1016                       blocksize:
1017                         blocksize=(int)strtol(optarg, NULL, 0);
1018                         break;
1019                 case 'c':
1020                         return check_conn(optarg, 1);
1021                 case 'C':
1022                         num_connections = (int)strtol(optarg, NULL, 0);
1023                         break;
1024                 case 'd':
1025                         need_disconnect = 1;
1026                         nbddev = strdup(optarg);
1027                         break;
1028                 case 'h':
1029                         usage(NULL);
1030                         exit(EXIT_SUCCESS);
1031                 case 'l':
1032                         needed_flags |= NBD_FLAG_FIXED_NEWSTYLE;
1033                         opts |= NBDC_DO_LIST;
1034                         nbddev="";
1035                         break;
1036 #if HAVE_NETLINK
1037                 case 'L':
1038                         netlink = 1;
1039                         break;
1040 #endif
1041                 case 'm':
1042                         argv[0][0] = '@';
1043                         break;
1044                 case 'n':
1045                         nofork=1;
1046                         break;
1047                 case 'N':
1048                         name=optarg;
1049                         break;
1050                 case 'p':
1051                         cont=1;
1052                         break;
1053                 case 's':
1054                         swap=1;
1055                         break;
1056                 case 'S':
1057                         sdp=1;
1058                         break;
1059                 case 't':
1060                       timeout:
1061                         timeout=strtol(optarg, NULL, 0);
1062                         break;
1063                 case 'u':
1064                         b_unix = 1;
1065                         break;
1066                 case 'V':
1067                         printf("This is %s, from %s\n", PROG_NAME, PACKAGE_STRING);
1068                         return 0;
1069 #if HAVE_GNUTLS && !defined(NOTLS)
1070                 case 'x':
1071                         tls = true;
1072                         break;
1073                 case 'F':
1074                         certfile=strdup(optarg);
1075                         break;
1076                 case 'K':
1077                         keyfile=strdup(optarg);
1078                         break;
1079                 case 'A':
1080                         cacertfile=strdup(optarg);
1081                         break;
1082                 case 'H':
1083                         tlshostname=strdup(optarg);
1084                         break;
1085 #else
1086                 case 'F':
1087                 case 'K':
1088                 case 'H':
1089                 case 'A':
1090                         fprintf(stderr, "E: TLS support not compiled in\n");
1091                         exit(EXIT_FAILURE);
1092 #endif
1093                 default:
1094                         fprintf(stderr, "E: option eaten by 42 mice\n");
1095                         exit(EXIT_FAILURE);
1096                 }
1097         }
1098
1099         if (need_disconnect) {
1100                 if (netlink)
1101                         netlink_disconnect(nbddev);
1102                 else
1103                         disconnect(nbddev);
1104                 exit(EXIT_SUCCESS);
1105         }
1106 #ifdef __ANDROID__
1107   if (swap)
1108     err("swap option unsupported on Android because mlockall is unsupported.");
1109 #endif
1110         if(hostname) {
1111                 if((!name || !nbddev) && !(opts & NBDC_DO_LIST)) {
1112                         if(!strncmp(hostname, "nbd", 3) || !strncmp(hostname, "/dev/nbd", 8)) {
1113                                 if(!get_from_config(hostname, &name, &nbddev, &hostname, &blocksize, &timeout, &cont, &swap, &sdp, &b_unix, &port, &num_connections, &certfile, &keyfile, &cacertfile, &hostname)) {
1114                                         usage("no valid configuration for specified device found", hostname);
1115                                         exit(EXIT_FAILURE);
1116                                 }
1117                         } else if (!netlink) {
1118                                 usage("not enough information specified, and argument didn't look like an nbd device");
1119                                 exit(EXIT_FAILURE);
1120                         }
1121                 }
1122         } else {
1123                 usage("no information specified");
1124                 exit(EXIT_FAILURE);
1125         }
1126
1127         if (keyfile && !certfile)
1128                 certfile = strdup(keyfile);
1129
1130         if (certfile != NULL || keyfile != NULL || cacertfile != NULL || tlshostname != NULL) {
1131                 tls = true;
1132         }
1133
1134         if (!tlshostname && hostname)
1135                 tlshostname = strdup(hostname);
1136
1137         if (netlink)
1138                 nofork = 1;
1139
1140         if(strlen(name)==0 && !(opts & NBDC_DO_LIST)) {
1141                 printf("Warning: the oldstyle protocol is no longer supported.\nThis method now uses the newstyle protocol with a default export\n");
1142         }
1143
1144         if(!(opts & NBDC_DO_LIST) && !netlink) {
1145                 nbd = open(nbddev, O_RDWR);
1146                 if (nbd < 0)
1147                         err("Cannot open NBD: %m\nPlease ensure the 'nbd' module is loaded.");
1148         }
1149
1150         if (netlink) {
1151                 sockfds = malloc(sizeof(int) * num_connections);
1152                 if (!sockfds)
1153                         err("Cannot allocate the socket fd's array");
1154         }
1155
1156         for (i = 0; i < num_connections; i++) {
1157                 if (b_unix)
1158                         sock = openunix(hostname);
1159                 else
1160                         sock = opennet(hostname, port, sdp);
1161                 if (sock < 0)
1162                         exit(EXIT_FAILURE);
1163
1164                 negotiate(&sock, &size64, &flags, name, needed_flags, cflags, opts, certfile, keyfile, cacertfile, tlshostname, tls);
1165                 if (netlink) {
1166                         sockfds[i] = sock;
1167                         continue;
1168                 }
1169
1170                 if (i == 0) {
1171                         setsizes(nbd, size64, blocksize, flags);
1172                         set_timeout(nbd, timeout);
1173                 }
1174                 finish_sock(sock, nbd, swap);
1175                 if (swap) {
1176                         if (keyfile)
1177                                 fprintf(stderr, "Warning: using swap and TLS is prone to deadlock\n");
1178                         /* try linux >= 2.6.36 interface first */
1179                         if (oom_adjust("/proc/self/oom_score_adj", "-1000")) {
1180                                 /* fall back to linux <= 2.6.35 interface */
1181                                 oom_adjust("/proc/self/oom_adj", "-17");
1182                         }
1183                 }
1184         }
1185
1186         if (netlink) {
1187                 int index = -1;
1188                 if (nbddev) {
1189                         if (sscanf(nbddev, "/dev/nbd%d", &index) != 1)
1190                                 err("Invalid nbd device target\n");
1191                 }
1192                 netlink_configure(index, sockfds, num_connections,
1193                                   size64, blocksize, flags, timeout);
1194                 return 0;
1195         }
1196         /* Go daemon */
1197
1198 #ifndef NOFORK
1199         if(!nofork) {
1200                 if (daemon(0,0) < 0)
1201                         err("Cannot detach from terminal");
1202         }
1203
1204         memset(&sa, 0, sizeof(sa));
1205         sa.sa_handler = SIG_IGN;
1206         sigaction(SIGCHLD, &sa, NULL);
1207 #endif
1208         /* For child to check its parent */
1209         main_pid = getpid();
1210         do {
1211 #ifndef NOFORK
1212
1213                 sigfillset(&block);
1214                 sigdelset(&block, SIGKILL);
1215                 sigdelset(&block, SIGTERM);
1216                 sigdelset(&block, SIGPIPE);
1217                 sigprocmask(SIG_SETMASK, &block, &old);
1218
1219                 if (!fork()) {
1220                         /* Due to a race, the kernel NBD driver cannot
1221                          * call for a reread of the partition table
1222                          * in the handling of the NBD_DO_IT ioctl().
1223                          * Therefore, this is done in the first open()
1224                          * of the device. We therefore make sure that
1225                          * the device is opened at least once after the
1226                          * connection was made. This has to be done in a
1227                          * separate process, since the NBD_DO_IT ioctl()
1228                          * does not return until the NBD device has
1229                          * disconnected.
1230                          */
1231                         struct timespec req = {
1232                                 .tv_sec = 0,
1233                                 .tv_nsec = 100000000,
1234                         };
1235                         while(check_conn(nbddev, 0)) {
1236                                 if (main_pid != getppid()) {
1237                                         /* check_conn() will not return 0 when nbd disconnected
1238                                          * and parent exited during this loop. So the child has to
1239                                          * explicitly check parent identity and exit if parent
1240                                          * exited */
1241                                         exit(0);
1242                                 }
1243                                 nanosleep(&req, NULL);
1244                         }
1245                         if(open(nbddev, O_RDONLY) < 0) {
1246                                 perror("could not open device for updating partition table");
1247                         }
1248                         exit(0);
1249                 }
1250 #endif
1251
1252                 if (ioctl(nbd, NBD_DO_IT) < 0) {
1253                         int error = errno;
1254                         fprintf(stderr, "nbd,%d: Kernel call returned: %d", main_pid, error);
1255                         if(error==EBADR) {
1256                                 /* The user probably did 'nbd-client -d' on us.
1257                                  * quit */
1258                                 cont=0;
1259                         } else {
1260                                 if(cont) {
1261                                         u64 new_size;
1262                                         uint16_t new_flags;
1263
1264                                         close(sock); close(nbd);
1265                                         for (;;) {
1266                                                 fprintf(stderr, " Reconnecting\n");
1267                                                 if (b_unix)
1268                                                         sock = openunix(hostname);
1269                                                 else
1270                                                         sock = opennet(hostname, port, sdp);
1271                                                 if (sock >= 0)
1272                                                         break;
1273                                                 sleep (1);
1274                                         }
1275                                         nbd = open(nbddev, O_RDWR);
1276                                         if (nbd < 0)
1277                                                 err("Cannot open NBD: %m");
1278                                         negotiate(&sock, &new_size, &new_flags, name, needed_flags, cflags, opts, certfile, keyfile, cacertfile, tlshostname, tls);
1279                                         if (size64 != new_size) {
1280                                                 err("Size of the device changed. Bye");
1281                                         }
1282                                         setsizes(nbd, size64, blocksize,
1283                                                                 new_flags);
1284
1285                                         set_timeout(nbd, timeout);
1286                                         finish_sock(sock,nbd,swap);
1287                                 }
1288                         }
1289                 } else {
1290                         /* We're on 2.4. It's not clearly defined what exactly
1291                          * happened at this point. Probably best to quit, now
1292                          */
1293                         fprintf(stderr, "Kernel call returned.");
1294                         cont=0;
1295                 }
1296         } while(cont);
1297         printf("sock, ");
1298         ioctl(nbd, NBD_CLEAR_SOCK);
1299         printf("done\n");
1300         return 0;
1301 }