nbd-server.c

   1 /*
   2  * Network Block Device - server
   3  *
   4  * Copyright 1996-1998 Pavel Machek, distribute under GPL
   5  *  <pavel@atrey.karlin.mff.cuni.cz>
   6  * Copyright 2001-2004 Wouter Verhelst <wouter@debian.org>
   7  * Copyright 2002 Anton Altaparmakov <aia21@cam.ac.uk>
   8  *
   9  * Version 1.0 - hopefully 64-bit-clean
  10  * Version 1.1 - merging enhancements from Josh Parsons, <josh@coombs.anu.edu.au>
  11  * Version 1.2 - autodetect size of block devices, thanx to Peter T. Breuer" <ptb@it.uc3m.es>
  12  * Version 1.5 - can compile on Unix systems that don't have 64 bit integer
  13  *      type, or don't have 64 bit file offsets by defining FS_32BIT
  14  *      in compile options for nbd-server *only*. This can be done
  15  *      with make FSCHOICE=-DFS_32BIT nbd-server. (I don't have the
  16  *      original autoconf input file, or I would make it a configure
  17  *      option.) Ken Yap <ken@nlc.net.au>.
  18  * Version 1.6 - fix autodetection of block device size and really make 64 bit
  19  *      clean on 32 bit machines. Anton Altaparmakov <aia21@cam.ac.uk>
  20  * Version 2.0 - Version synchronised with client
  21  * Version 2.1 - Reap zombie client processes when they exit. Removed
  22  *      (uncommented) the _IO magic, it's no longer necessary. Wouter
  23  *      Verhelst <wouter@debian.org>
  24  * Version 2.2 - Auto switch to read-only mode (usefull for floppies).
  25  * Version 2.3 - Fixed code so that Large File Support works. This
  26  *      removes the FS_32BIT compile-time directive; define
  27  *      _FILE_OFFSET_BITS=64 and _LARGEFILE_SOURCE if you used to be
  28  *      using FS_32BIT. This will allow you to use files >2GB instead of
  29  *      having to use the -m option. Wouter Verhelst <wouter@debian.org>
  30  * Version 2.4 - Added code to keep track of children, so that we can
  31  *      properly kill them from initscripts. Add a call to daemon(),
  32  *      so that processes don't think they have to wait for us, which is
  33  *      interesting for initscripts as well. Wouter Verhelst
  34  *      <wouter@debian.org>
  35  * Version 2.5 - Bugfix release: forgot to reset child_arraysize to
  36  *      zero after fork()ing, resulting in nbd-server going berserk
  37  *      when it receives a signal with at least one child open. Wouter
  38  *      Verhelst <wouter@debian.org>
  39  * 10/10/2003 - Added socket option SO_KEEPALIVE (sf.net bug 819235);
  40  *      rectified type of mainloop::size_host (sf.net bugs 814435 and
  41  *      817385); close the PID file after writing to it, so that the
  42  *      daemon can actually be found. Wouter Verhelst
  43  *      <wouter@debian.org>
  44  * 10/10/2003 - Size of the data "size_host" was wrong and so was not
  45  *      correctly put in network endianness. Many types were corrected
  46  *      (size_t and off_t instead of int).  <vspaceg@sourceforge.net>
  47  * Version 2.6 - Some code cleanup.
  48  * Version 2.7 - Better build system (not released (yet?)).
  49  * 11/02/2004 - Doxygenified the source, modularized it a bit. Needs a
  50  *      lot more work, but this is a start. Wouter Verhelst
  51  *      <wouter@debian.org>
  52  */
  53
  54 /* Includes LFS defines, which defines behaviours of some of the following
  55  * headers, so must come before those */
  56 #include "config.h"
  57
  58 #include <sys/types.h>
  59 #include <sys/socket.h>
  60 #include <sys/stat.h>
  61 #include <sys/wait.h>           /* wait */
  62 #ifdef HAVE_SYS_IOCTL_H
  63 #include <sys/ioctl.h>
  64 #endif
  65 #include <sys/param.h>
  66 #ifdef HAVE_SYS_MOUNT_H
  67 #include <sys/mount.h>          /* For BLKGETSIZE */
  68 #endif
  69 #include <signal.h>             /* sigaction */
  70 #include <netinet/tcp.h>
  71 #include <netinet/in.h>         /* sockaddr_in, htons, in_addr */
  72 #include <netdb.h>              /* hostent, gethostby*, getservby* */
  73 #include <syslog.h>
  74 #include <unistd.h>
  75 #include <stdio.h>
  76 #include <stdlib.h>
  77 #include <string.h>
  78 #include <fcntl.h>
  79 #include <arpa/inet.h>
  80 #include <strings.h>
  81 #include <dirent.h>
  82
  83 /* used in cliserv.h, so must come first */
  84 #define MY_NAME "nbd_server"
  85 #include "cliserv.h"
  86
  87 /** how much space for child PIDs we have by default. Dynamically
  88    allocated, and will be realloc()ed if out of space, so this should
  89    probably be fair for most situations. */
  90 #define DEFAULT_CHILD_ARRAY 256
  91
  92 /** Logging macros, now nothing goes to syslog unless you say ISSERVER */
  93 #ifdef ISSERVER
  94 #define msg2(a,b) syslog(a,b)
  95 #define msg3(a,b,c) syslog(a,b,c)
  96 #define msg4(a,b,c,d) syslog(a,b,c,d)
  97 #else
  98 #define msg2(a,b) do { fprintf(stderr,b) ; fputs("\n",stderr) ; } while(0)
  99 #define msg3(a,b,c) do { fprintf(stderr,b,c); fputs("\n",stderr) ; } while(0)
 100 #define msg4(a,b,c,d) do { fprintf(stderr,b,c,d); fputs("\n",stderr) ; } while(0)
 101 #endif
 102
 103 /* Debugging macros */
 104 //#define DODBG
 105 #ifdef DODBG
 106 #define DEBUG( a ) printf( a )
 107 #define DEBUG2( a,b ) printf( a,b )
 108 #define DEBUG3( a,b,c ) printf( a,b,c )
 109 #else
 110 #define DEBUG( a )
 111 #define DEBUG2( a,b )
 112 #define DEBUG3( a,b,c )
 113 #endif
 114 #ifndef PACKAGE_VERSION
 115 #define PACKAGE_VERSION ""
 116 #endif
 117 /**
 118  * The highest value a variable of type off_t can reach.
 119  **/
 120 /* This is starting to get ugly. If someone knows a better way to find
 121  * the maximum value of a signed type *without* relying on overflow
 122  * (doing so breaks on 64bit architectures), that would be nice.
 123  */
 124 #define OFFT_MAX (((((off_t)1)<<((sizeof(off_t)-1)*8))-1)<<7)+127
 125 #define LINELEN 256       /**< Size of static buffer used to read the
 126                             authorization file (yuck) */
 127 #define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */
 128 #define GIGA (1*1024*1024*1024) /**< 1 Gigabyte. Used as hunksize when doing
 129                                   the multiple file thingy */
 130 #define DIFFPAGESIZE 4096 /**< diff file uses those chunks */
 131 #define F_READONLY 1      /**< flag to tell us a file is readonly */
 132 #define F_MULTIFILE 2     /**< flag to tell us a file is exported using -m */
 133 #define F_COPYONWRITE 4   /**< flag to tell us a file is exported using copyonwrite */
 134 char difffilename[1024]; /**< filename of the copy-on-write file. Doesn't belong here! */
 135 unsigned int timeout = 0; /**< disconnect timeout */
 136 int autoreadonly = 0; /**< 1 = switch to readonly if opening readwrite isn't
 137                         possible */
 138 char *auth_file="nbd_server.allow"; /**< authorization file */
 139 char exportname2[1024]; /**< File I'm exporting, with virtualhost resolved */
 140 off_t lastpoint = (off_t)-1;    /**< keep track of where we are in the file, to
 141                                   avoid an lseek if possible */
 142 char pagebuf[DIFFPAGESIZE];     /**< when doing copyonwrite, this is
 143                                   used as a temporary buffer to store
 144                                   the exported block in. @todo this is
 145                                   a great example of namespace
 146                                   pollution. Throw it out. */
 147 unsigned int port;              /**< Port I'm listening at */
 148 char *exportname;               /**< File I'm exporting */
 149 off_t exportsize = OFFT_MAX;    /**< length of file I'm exporting */
 150 off_t hunksize = OFFT_MAX;      /**< size of each exported file in case of -m */
 151 int flags = 0;                  /**< flags associated with this exported file */
 152 int export[1024];/**< array of filedescriptors of exported files; only first is
 153                    used unless -m option is activated */
 154 int difffile=-1; /**< filedescriptor for copyonwrite file */
 155 u32 difffilelen=0 ; /**< number of pages in difffile */
 156 u32 *difmap=NULL ; /**< Determine whether a block is in the original file
 157                      (difmap[block]==-1) or in the copyonwrite file (in which
 158                      case it contains the offset where it is to be found in the
 159                      copyonwrite file). @todo the kernel knows about sparse
 160                      files, we should use those instead. Should also be off_t
 161                      instead of u32; copyonwrite is probably broken wrt LFS */
 162 char clientname[256] ;
 163 int child_arraysize=DEFAULT_CHILD_ARRAY; /**< number of available slots for
 164                                            child array */
 165 pid_t *children; /**< child array */
 166 char pidfname[256]; /**< name of our PID file */
 167
 168 /**
 169  * Variables associated with a copyonwrite server. Not yet used.
 170  **/
 171 typedef struct {
 172         char* difffilename;  /**< filename of the copy-on-write file */
 173         int difffile;        /**< filedescriptor of copyonwrite file. @todo
 174                                shouldn't this be an array too? (cfr
 175                                nbd_server_opts::export) Or make -m and -c
 176                                mutually exclusive */
 177         u32 difffilelen;     /**< number of pages in difffile */
 178         u32 *difmap;         /**< see comment on the global difmap for this one */
 179 } cow_opts;
 180
 181 /**
 182  * Variables associated with a server. Not yet used. @todo modify the code to
 183  * use an instance of this struct instead of the heap of global variables.
 184  **/
 185 typedef struct {
 186         char* exportname;    /**< filename of the file we're exporting */
 187         unsigned int port;            /**< port we're exporting this file at */
 188         char* authname;      /**< filename of the authorization file */
 189         off_t exportsize;    /**< size of the file we're exporting */
 190         off_t hunksize;      /**< size of a hunk of an exported file */
 191         int flags;           /**< flags associated with this exported file */
 192         char* clientname;          /**< peer */
 193         unsigned int timeout;/**< how long a connection may be idle
 194                                (0=forever) */
 195         int export[1024];    /**< array of filedescriptors of exported files;
 196                                only the first is actually used unless we're
 197                                doing the multiple file option */
 198         cow_opts* cow;       /**< only used if (flags | F_COPYONWRITE) (NULL
 199                                otherwise) */
 200 } nbd_server_opts;
 201
 202 /**
 203  * Check whether a client is allowed to connect. Works with an authorization
 204  * file which contains one line per machine, no wildcards.
 205  *
 206  * @param name IP address of client trying to connect (in human-readable form)
 207  * @return 0 - authorization refused, 1 - OK
 208  **/
 209 int authorized_client(char *name)
 210 {
 211         FILE *f ;
 212
 213         char line[LINELEN] ;
 214
 215         if ((f=fopen(auth_file,"r"))==NULL) {
 216                 msg4(LOG_INFO,"Can't open authorization file %s (%s).",
 217                      auth_file,strerror(errno)) ;
 218                 return 1 ;
 219         }
 220
 221         while (fgets(line,LINELEN,f)!=NULL) {
 222                 if (strncmp(line,name,strlen(name))==0) {
 223                         fclose(f);
 224                         return 1;
 225                 }
 226         }
 227         fclose(f) ;
 228         return 0 ;
 229 }
 230
 231 /**
 232  * Read data from a file descriptor into a buffer
 233  *
 234  * @param f a file descriptor
 235  * @param buf a buffer
 236  * @param len the number of bytes to be read
 237  **/
 238 inline void readit(int f, void *buf, size_t len)
 239 {
 240         ssize_t res;
 241         while (len > 0) {
 242                 DEBUG("*");
 243                 if ((res = read(f, buf, len)) <= 0)
 244                         err("Read failed: %m");
 245                 len -= res;
 246                 buf += res;
 247         }
 248 }
 249
 250 /**
 251  * Write data from a buffer into a filedescriptor
 252  *
 253  * @param f a file descriptor
 254  * @param buf a buffer containing data
 255  * @param len the number of bytes to be written
 256  **/
 257 inline void writeit(int f, void *buf, size_t len)
 258 {
 259         ssize_t res;
 260         while (len > 0) {
 261                 DEBUG("+");
 262                 if ((res = write(f, buf, len)) <= 0)
 263                         err("Send failed: %m");
 264                 len -= res;
 265                 buf += res;
 266         }
 267 }
 268
 269 /**
 270  * Parse the command line.
 271  *
 272  * @todo getopt() is a great thing, and easy to use. Also, we want to
 273  * create a configuration file which nbd-server will read. Maybe do (as in,
 274  * parse) that here.
 275  *
 276  * @param argc the argc argument to main()
 277  * @param argv the argv argument to main()
 278  **/
 279 void cmdline(int argc, char *argv[])
 280 {
 281         int i;
 282
 283         if (argc < 3) {
 284                 printf("This is nbd-server version " VERSION "\n");
 285                 printf("Usage: port file_to_export [size][kKmM] [-r] [-m] [-c] [-a timeout_sec]\n"
 286                        "        -r read only\n"
 287                        "        -m multiple file\n"
 288                        "        -c copy on write\n"
 289                        "        -l file with list of hosts that are allowed to connect.\n"
 290                        "        -a maximum idle seconds, terminates when idle time exceeded\n"
 291                        "        if port is set to 0, stdin is used (for running from inetd)\n"
 292                        "        if file_to_export contains '%%s', it is substituted with IP\n"
 293                        "                address of machine trying to connect\n" );
 294                 exit(0);
 295         }
 296         port = atoi(argv[1]);
 297         for (i = 3; i < argc; i++) {
 298                 if (*argv[i] == '-') {
 299                         switch (argv[i][1]) {
 300                         case 'r':
 301                                 flags |= F_READONLY;
 302                                 break;
 303                         case 'm':
 304                                 flags |= F_MULTIFILE;
 305                                 hunksize = 1*GIGA;
 306                                 break;
 307                         case 'c': flags |=F_COPYONWRITE;
 308                                 break;
 309                         case 'l':
 310                                 free(auth_file);
 311                                 if (i+1<argc) {
 312                                         auth_file=argv[++i];
 313                                 } else {
 314                                         fprintf(stderr, "host list file requires an argument");
 315                                 }
 316                                 break;
 317                         case 'a':
 318                                 if (i+1<argc) {
 319                                         timeout = atoi(argv[i+1]);
 320                                         i++;
 321                                 } else {
 322                                         fprintf(stderr, "timeout requires argument\n");
 323                                         exit(1);
 324                                 }
 325                         }
 326                 } else {
 327                         off_t es;
 328                         size_t last = strlen(argv[i])-1;
 329                         char suffix = argv[i][last];
 330                         if (suffix == 'k' || suffix == 'K' ||
 331                             suffix == 'm' || suffix == 'M')
 332                                 argv[i][last] = '\0';
 333                         es = (off_t)atol(argv[i]);
 334                         switch (suffix) {
 335                                 case 'm':
 336                                 case 'M':  es <<= 10;
 337                                 case 'k':
 338                                 case 'K':  es <<= 10;
 339                                 default :  break;
 340                         }
 341                         exportsize = es;
 342                 }
 343         }
 344
 345         exportname = argv[2];
 346 }
 347
 348 /**
 349  * Signal handler for SIGCHLD
 350  * @param s the signal we're handling (must be SIGCHLD, or something
 351  * is severely wrong)
 352  **/
 353 void sigchld_handler(int s)
 354 {
 355         int* status=NULL;
 356         int i;
 357         pid_t pid;
 358
 359         while((pid=wait(status)) > 0) {
 360                 if(WIFEXITED(status)) {
 361                         msg3(LOG_INFO, "Child exited with %d", WEXITSTATUS(status));
 362                 }
 363                 for(i=0;children[i]!=pid&&i<child_arraysize;i++);
 364                 if(i>=child_arraysize) {
 365                         msg3(LOG_INFO, "SIGCHLD received for an unknown child with PID %ld",(long) pid);
 366                 } else {
 367                         children[i]=(pid_t)0;
 368                         DEBUG2("Removing %d from the list of children", pid);
 369                 }
 370         }
 371 }
 372
 373 /**
 374  * Handle SIGTERM and dispatch it to our children
 375  * @param s the signal we're handling (must be SIGTERM, or something
 376  * is severely wrong).
 377  **/
 378 void sigterm_handler(int s) {
 379         int i;
 380         int parent=0;
 381
 382         for(i=0;i<child_arraysize;i++) {
 383                 if(children[i]) {
 384                         kill(children[i], s);
 385                         parent=1;
 386                 }
 387         }
 388
 389         if(parent) {
 390                 unlink(pidfname);
 391         }
 392
 393         exit(0);
 394 }
 395
 396 /**
 397  * Detect the size of a file.
 398  *
 399  * @param export An open filedescriptor
 400  * @return the size of the file, or OFFT_MAX if detection was
 401  * impossible.
 402  **/
 403 off_t size_autodetect(int export)
 404 {
 405         off_t es;
 406         u32 es32;
 407         struct stat stat_buf;
 408         int error;
 409
 410 #ifdef HAVE_SYS_MOUNT_H
 411 #ifdef HAVE_SYS_IOCTL_H
 412 #ifdef BLKGETSIZE
 413         DEBUG("looking for export size with ioctl BLKGETSIZE\n");
 414         if (!ioctl(export, BLKGETSIZE, &es32) && es32) {
 415                 es = (off_t)es32 * (off_t)512;
 416                 return es;
 417         }
 418 #endif /* BLKGETSIZE */
 419 #endif /* HAVE_SYS_IOCTL_H */
 420 #endif /* HAVE_SYS_MOUNT_H */
 421
 422         DEBUG("looking for export size with fstat\n");
 423         stat_buf.st_size = 0;
 424         error = fstat(export, &stat_buf);
 425         if (!error && stat_buf.st_size > 0) {
 426                 return (off_t)stat_buf.st_size;
 427         } else {
 428                 err("fstat failed: %m");
 429         }
 430
 431         DEBUG("looking for export size with lseek SEEK_END\n");
 432         es = lseek(export, (off_t)0, SEEK_END);
 433         if (es > ((off_t)0)) {
 434                 return es;
 435         } else {
 436                 DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4)));
 437         }
 438
 439         err("Could not find size of exported block device: %m");
 440         return OFFT_MAX;
 441 }
 442
 443 /**
 444  * Seek to a position in a file, unless we're already there.
 445  * @param handle a filedescriptor
 446  * @param a position to seek to
 447  **/
 448 void maybeseek(int handle, off_t a) {
 449         if (a < 0 || a > exportsize) {
 450                 err("Can not happen\n");
 451         }
 452         if (lastpoint != a) {
 453                 if (lseek(handle, a, SEEK_SET) < 0) {
 454                         err("Can not seek locally!\n");
 455                 }
 456                 lastpoint = a;
 457         } else {
 458                 DEBUG("S");
 459         }
 460 }
 461
 462 /**
 463  * Write an amount of bytes at a given offset to the right file. This
 464  * abstracts the write-side of the multiple file option.
 465  *
 466  * @param a The offset where the write should start
 467  * @param buf The buffer to write from
 468  * @param len The length of buf
 469  * @return The number of bytes actually written, or -1 in case of an error
 470  **/
 471 int rawexpwrite(off_t a, char *buf, size_t len)
 472 {
 473         ssize_t res;
 474
 475         maybeseek(export[a/hunksize], a%hunksize);
 476         res = write(export[a/hunksize], buf, len);
 477         return (res < 0 || (size_t)res != len);
 478 }
 479
 480 /**
 481  * seek to a position in a file, no matter what. Used when using maybeseek is a
 482  * bad idea (for instance, because we're reading the copyonwrite file instead
 483  * of the exported file).
 484  * @param handle a filedescriptor
 485  * @param a position to seek to
 486  * @todo get rid of this; lastpoint is a global variable right now, but it
 487  * shouldn't be. If we pass it on as a parameter, that makes things a *lot*
 488  * easier.
 489  **/
 490 void myseek(int handle,off_t a) {
 491         if (lseek(handle, a, SEEK_SET) < 0) {
 492                 err("Can not seek locally!\n");
 493         }
 494 }
 495
 496 /**
 497  * Read an amount of bytes at a given offset from the right file. This
 498  * abstracts the read-side of the multiple files option.
 499  *
 500  * @param a The offset where the read should start
 501  * @param buf A buffer to read into
 502  * @param len The size of buf
 503  * @return The number of bytes actually read, or -1 in case of an
 504  * error.
 505  **/
 506 int rawexpread(off_t a, char *buf, size_t len)
 507 {
 508         ssize_t res;
 509
 510         maybeseek(export[a/hunksize], a%hunksize);
 511         res = read(export[a/hunksize], buf, len);
 512         return (res < 0 || (size_t)res != len);
 513 }
 514
 515 /**
 516  * Read an amount of bytes at a given offset from the right file. This
 517  * abstracts the read-side of the copyonwrite stuff, and calls
 518  * rawexpread() with the right parameters to do the actual work.
 519  * @param a The offset where the read should start
 520  * @param buf A buffer to read into
 521  * @param len The size of buf
 522  * @return The number of bytes actually read, or -1 in case of an error
 523  **/
 524 int expread(off_t a, char *buf, size_t len)
 525 {
 526         off_t rdlen, offset;
 527         off_t mapcnt, mapl, maph, pagestart;
 528
 529         if (!(flags & F_COPYONWRITE))
 530                 return rawexpread(a, buf, len);
 531         DEBUG3("Asked to read %d bytes at %Lu.\n", len, (unsigned long long)a);
 532
 533         mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE;
 534
 535         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 536                 pagestart=mapcnt*DIFFPAGESIZE;
 537                 offset=a-pagestart;
 538                 rdlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 539                         len : (size_t)DIFFPAGESIZE-offset;
 540                 if (difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 541                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 542                                (unsigned long)difmap[mapcnt]);
 543                         myseek(difffile, difmap[mapcnt]*DIFFPAGESIZE+offset);
 544                         if (read(difffile, buf, rdlen) != rdlen) return -1;
 545                 } else { /* the block is not there */
 546                         DEBUG2("Page %Lu is not here, we read the original one\n",
 547                                (unsigned long long)mapcnt);
 548                         return rawexpread(a, buf, rdlen);
 549                 }
 550                 len-=rdlen; a+=rdlen; buf+=rdlen;
 551         }
 552         return 0;
 553 }
 554
 555 /**
 556  * Write an amount of bytes at a given offset to the right file. This
 557  * abstracts the write-side of the copyonwrite option, and calls
 558  * rawexpwrite() with the right parameters to do the actual work.
 559  *
 560  * @param a The offset where the write should start
 561  * @param buf The buffer to write from
 562  * @param len The length of buf
 563  * @return The number of bytes actually written, or -1 in case of an error
 564  **/
 565 int expwrite(off_t a, char *buf, size_t len)
 566 {
 567         off_t mapcnt,mapl,maph ;
 568         off_t wrlen,rdlen ;
 569         off_t pagestart ;
 570         off_t offset ;
 571
 572         if (!(flags & F_COPYONWRITE))
 573                 return(rawexpwrite(a,buf,len));
 574         DEBUG3("Asked to write %d bytes at %Lu.\n", len, (unsigned long long)a);
 575
 576         mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ;
 577
 578         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 579                 pagestart=mapcnt*DIFFPAGESIZE ;
 580                 offset=a-pagestart ;
 581                 wrlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 582                         len : (size_t)DIFFPAGESIZE-offset;
 583
 584                 if (difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 585                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 586                                (unsigned long)difmap[mapcnt]) ;
 587                         myseek(difffile,difmap[mapcnt]*DIFFPAGESIZE+offset) ;
 588                         if (write(difffile, buf, wrlen) != wrlen) return -1 ;
 589                 } else { /* the block is not there */
 590                         myseek(difffile,difffilelen*DIFFPAGESIZE) ;
 591                         difmap[mapcnt]=difffilelen++ ;
 592                         DEBUG3("Page %Lu is not here, we put it at %lu\n",
 593                                (unsigned long long)mapcnt,
 594                                (unsigned long)difmap[mapcnt]);
 595                         rdlen=DIFFPAGESIZE ;
 596                         if (rdlen+pagestart%hunksize>hunksize)
 597                                 rdlen=hunksize-(pagestart%hunksize) ;
 598                         if (rawexpread(pagestart,pagebuf,rdlen)) return -1 ;
 599                         memcpy(pagebuf+offset,buf,wrlen) ;
 600                         if (write(difffile,pagebuf,DIFFPAGESIZE)!=DIFFPAGESIZE) return -1 ;
 601                 }
 602                 len-=wrlen ; a+=wrlen ; buf+=wrlen ;
 603         }
 604         return 0;
 605 }
 606
 607 /**
 608  * Do the initial negotiation.
 609  *
 610  * @param net A socket to do the negotiation over
 611  **/
 612 void negotiate(int net) {
 613         char zeros[300];
 614         u64 size_host;
 615
 616         memset(zeros, 0, 290);
 617         if (write(net, INIT_PASSWD, 8) < 0)
 618                 err("Negotiation failed: %m");
 619         cliserv_magic = htonll(cliserv_magic);
 620         if (write(net, &cliserv_magic, sizeof(cliserv_magic)) < 0)
 621                 err("Negotiation failed: %m");
 622         size_host = htonll((u64)exportsize);
 623         if (write(net, &size_host, 8) < 0)
 624                 err("Negotiation failed: %m");
 625         if (write(net, zeros, 128) < 0)
 626                 err("Negotiation failed: %m");
 627 }
 628
 629 /** sending macro; not really required. Uses variables in the local
 630  * scope of mainloop(). Get rid of it. */
 631 #define SEND writeit( net, &reply, sizeof( reply ));
 632 /** error macro; not sure whether we really need this. Uses variables
 633  * in the local scope of mainloop(). Get rid of this beast. */
 634 #define ERROR { reply.error = htonl(-1); SEND; reply.error = 0; lastpoint = -1; }
 635 /**
 636  * Serve a file to a single client.
 637  *
 638  * @todo This beast needs to be split up in many tiny little manageable
 639  * pieces. Preferably with a chainsaw.
 640  *
 641  * @param net A network socket, connected to an nbd client
 642  * @return never
 643  **/
 644 int mainloop(int net)
 645 {
 646         struct nbd_request request;
 647         struct nbd_reply reply;
 648 #ifdef DODBG
 649         int i = 0;
 650 #endif
 651         negotiate(net);
 652         DEBUG("Entering request loop!\n");
 653         reply.magic = htonl(NBD_REPLY_MAGIC);
 654         reply.error = 0;
 655         while (1) {
 656                 char buf[BUFSIZE];
 657                 size_t len;
 658 #ifdef DODBG
 659                 i++;
 660                 printf("%d: ", i);
 661 #endif
 662                 if (timeout)
 663                         alarm(timeout);
 664                 readit(net, &request, sizeof(request));
 665                 request.from = ntohll(request.from);
 666                 request.type = ntohl(request.type);
 667
 668                 if (request.type==NBD_CMD_DISC) { /* Disconnect request */
 669                   if (difmap) free(difmap) ;
 670                   if (difffile>=0) {
 671                      close(difffile) ; unlink(difffilename) ; }
 672                   err("Disconnect request received.") ;
 673                 }
 674
 675                 len = ntohl(request.len);
 676
 677                 if (request.magic != htonl(NBD_REQUEST_MAGIC))
 678                         err("Not enough magic.");
 679                 if (len > BUFSIZE)
 680                         err("Request too big!");
 681 #ifdef DODBG
 682                 printf("%s from %Lu (%Lu) len %d, ", request.type ? "WRITE" :
 683                                 "READ", (unsigned long long)request.from,
 684                                 (unsigned long long)request.from / 512, len);
 685 #endif
 686                 memcpy(reply.handle, request.handle, sizeof(reply.handle));
 687                 if ((request.from + len) > (OFFT_MAX)) {
 688                   DEBUG("[Number too large!]");
 689                   ERROR;
 690                   continue;
 691                 }
 692
 693                 if (((ssize_t)((off_t)request.from + len) > exportsize) ||
 694                     ((flags & F_READONLY) && request.type)) {
 695                         DEBUG("[RANGE!]");
 696                         ERROR;
 697                         continue;
 698                 }
 699
 700                 if (request.type==1) {  /* WRITE */
 701                         DEBUG("wr: net->buf, ");
 702                         readit(net, buf, len);
 703                         DEBUG("buf->exp, ");
 704                         if ((autoreadonly == 1) || expwrite(request.from, buf, len)) {
 705                                 DEBUG("Write failed: %m" );
 706                                 ERROR;
 707                                 continue;
 708                         }
 709                         lastpoint += len;
 710                         SEND;
 711                         DEBUG("OK!\n");
 712                         continue;
 713                 }
 714                 /* READ */
 715
 716                 DEBUG("exp->buf, ");
 717                 if (expread(request.from, buf + sizeof(struct nbd_reply), len)) {
 718                         lastpoint = -1;
 719                         DEBUG("Read failed: %m");
 720                         ERROR;
 721                         continue;
 722                 }
 723                 lastpoint += len;
 724
 725                 DEBUG("buf->net, ");
 726                 memcpy(buf, &reply, sizeof(struct nbd_reply));
 727                 writeit(net, buf, len + sizeof(struct nbd_reply));
 728                 DEBUG("OK!\n");
 729         }
 730 }
 731
 732 /**
 733  * Split a single exportfile into multiple ones, if that was asked.
 734  * @return 0 on success, -1 on failure
 735  **/
 736 int splitexport(void) {
 737         off_t i ;
 738
 739         for (i=0; i<exportsize; i+=hunksize) {
 740                 char exportname3[1024];
 741
 742                 snprintf(exportname3, 1024, "%s.%d", exportname2, (int)i/hunksize);
 743                 exportname3[1023]='\0';
 744                 printf( "Opening %s\n", exportname3 );
 745                 if ((export[i/hunksize] = open(exportname3, (flags & F_READONLY) ? O_RDONLY : O_RDWR)) == -1) {
 746                         /* Read WRITE ACCESS was requested by media is only read only */
 747                         autoreadonly = 1;
 748                         flags |= F_READONLY;
 749                         if ((export[i/hunksize] = open(exportname3, O_RDONLY)) == -1)
 750                                 err("Could not open exported file: %m");
 751                 }
 752         }
 753
 754         if (flags & F_COPYONWRITE) {
 755                 snprintf(difffilename, 1024, "%s-%s-%d.diff",exportname2,clientname,
 756                         (int)getpid()) ;
 757                 difffilename[1023]='\0';
 758                 msg3(LOG_INFO,"About to create map and diff file %s",difffilename) ;
 759                 difffile=open(difffilename,O_RDWR | O_CREAT | O_TRUNC,0600) ;
 760                 if (difffile<0) err("Could not create diff file (%m)") ;
 761                 if ((difmap=calloc(exportsize/DIFFPAGESIZE,sizeof(u32)))==NULL)
 762                         err("Could not allocate memory") ;
 763                 for (i=0;i<exportsize/DIFFPAGESIZE;i++) difmap[i]=(u32)-1 ;
 764         }
 765
 766         return 0;
 767 }
 768
 769 /**
 770  * Serve a connection.
 771  *
 772  * @todo allow for multithreading, perhaps use libevent.
 773  *
 774  * @param net A network socket connected to an nbd client
 775  **/
 776 void serveconnection(int net) {
 777         splitexport();
 778         if (exportsize == OFFT_MAX) {
 779                 exportsize = size_autodetect(export[0]);
 780         }
 781         if (exportsize > OFFT_MAX) {
 782                 err("Size of exported file is too big\n");
 783         }
 784         else
 785                 msg3(LOG_INFO, "size of exported file/device is %Lu",
 786                      (unsigned long long)exportsize);
 787
 788         setmysockopt(net);
 789
 790         mainloop(net);
 791 }
 792
 793 /**
 794  * Find the name of the file we have to serve. This will use snprintf()
 795  * to put the IP address of the client inside a filename containing
 796  * "%s". That name is then written to exportname2
 797  *
 798  * @param net A socket connected to an nbd client
 799  * @param clientname a buffer which must be at least 255+1 bytes long;
 800  * the IP address (in human-readable format) will be copied in there.
 801  **/
 802 void set_peername(int net,char *clientname)
 803 {
 804         struct sockaddr_in addrin;
 805         int addrinlen = sizeof( addrin );
 806         char *peername ;
 807
 808         if (getpeername( net, (struct sockaddr *) &addrin, &addrinlen ) < 0)
 809                 err("getsockname failed: %m");
 810         peername = inet_ntoa(addrin.sin_addr);
 811         snprintf(exportname2, 1024, exportname, peername);
 812         exportname2[1023]='\0';
 813
 814         msg4(LOG_INFO, "connect from %s, assigned file is %s",
 815              peername, exportname2);
 816         strncpy(clientname,peername,255) ;
 817 }
 818
 819 /**
 820  * Connect the socket, and start to serve. This function will fork()
 821  * if a connection from an authorized client is received, and will
 822  * start mainloop().
 823  *
 824  * @todo modularize this giant beast. Preferably with a chainsaw. Also,
 825  * it has no business starting mainloop(); it should connect, and be
 826  * done with it.
 827  *
 828  * @param port the port where we will listen
 829  **/
 830 void connectme(unsigned int port)
 831 {
 832         struct sockaddr_in addrin;
 833         struct sigaction sa;
 834         int addrinlen = sizeof(addrin);
 835         int net, sock, newpid, i;
 836 #ifndef sun
 837         int yes=1;
 838 #else
 839         char yes='1';
 840 #endif /* sun */
 841 #ifndef NODAEMON
 842 #ifndef NOFORK
 843         FILE*pidf;
 844
 845         if(port) {
 846                 if(daemon(0,0)<0) {
 847                         err("daemon");
 848                 }
 849                 snprintf(pidfname, sizeof(char)*255, "/var/run/nbd-server.%d.pid", port);
 850                 pidf=fopen(pidfname, "w");
 851                 if(pidf) {
 852                         fprintf(pidf,"%d", (int)getpid());
 853                         fclose(pidf);
 854                 } else {
 855                         perror("fopen");
 856                         fprintf(stderr, "Not fatal; continuing");
 857                 }
 858         }
 859 #endif /* NOFORK */
 860 #endif /* NODAEMON */
 861
 862         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 863                 err("socket: %m");
 864
 865         /* lose the pesky "Address already in use" error message */
 866         if (setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
 867                 err("setsockopt SO_REUSEADDR");
 868         }
 869         if (setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
 870                 err("setsockopt SO_KEEPALIVE");
 871         }
 872
 873         DEBUG("Waiting for connections... bind, ");
 874         addrin.sin_family = AF_INET;
 875         addrin.sin_port = htons(port);
 876         addrin.sin_addr.s_addr = 0;
 877         if (bind(sock, (struct sockaddr *) &addrin, addrinlen) < 0)
 878                 err("bind: %m");
 879         DEBUG("listen, ");
 880         if (listen(sock, 1) < 0)
 881                 err("listen: %m");
 882         DEBUG("accept, ");
 883         sa.sa_handler = sigchld_handler;
 884         sigemptyset(&sa.sa_mask);
 885         sa.sa_flags = SA_RESTART;
 886         if(sigaction(SIGCHLD, &sa, NULL) == -1)
 887                 err("sigaction: %m");
 888         sa.sa_handler = sigterm_handler;
 889         sigemptyset(&sa.sa_mask);
 890         sa.sa_flags = SA_RESTART;
 891         if(sigaction(SIGTERM, &sa, NULL) == -1)
 892                 err("sigaction: %m");
 893         children=malloc(sizeof(pid_t)*child_arraysize);
 894         memset(children, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY);
 895         for(;;) { /* infinite loop */
 896                 if ((net = accept(sock, (struct sockaddr *) &addrin, &addrinlen)) < 0)
 897                         err("accept: %m");
 898
 899                 set_peername(net,clientname);
 900                 if (!authorized_client(clientname)) {
 901                         msg2(LOG_INFO,"Unauthorized client") ;
 902                         close(net) ;
 903                         continue ;
 904                 }
 905                 msg2(LOG_INFO,"Authorized client") ;
 906                 for(i=0;children[i]&&i<child_arraysize;i++);
 907                 if(i>=child_arraysize) {
 908                         pid_t*ptr;
 909
 910                         ptr=realloc(children, sizeof(pid_t)*child_arraysize);
 911                         if(ptr) {
 912                                 children=ptr;
 913                                 memset(children+child_arraysize, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY);
 914                                 i=child_arraysize+1;
 915                                 child_arraysize+=DEFAULT_CHILD_ARRAY;
 916                         } else {
 917                                 msg2(LOG_INFO,"Not enough memory to store child PID");
 918                                 close(net);
 919                                 continue;
 920                         }
 921                 }
 922 #ifndef NOFORK
 923                 if ((children[i]=fork())<0) {
 924                         msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
 925                         close(net) ;
 926                         continue ;
 927                 }
 928                 if (children[i]>0) { /* parent */
 929                         close(net) ; continue ; }
 930                 /* child */
 931                 realloc(children,0);
 932                 child_arraysize=0;
 933                 close(sock) ;
 934 #endif // NOFORK
 935                 msg2(LOG_INFO,"Starting to serve") ;
 936                 serveconnection(net) ;
 937         }
 938 }
 939
 940 /**
 941  * Main entry point...
 942  **/
 943 int main(int argc, char *argv[])
 944 {
 945         if (sizeof( struct nbd_request )!=28) {
 946                 fprintf(stderr,"Bad size of structure. Alignment problems?\n");
 947                 exit(-1) ;
 948         }
 949         logging();
 950         cmdline(argc, argv);
 951
 952         if (!port) return 1 ;
 953         connectme(port); /* serve infinitely */
 954         return 0 ;
 955 }
 956