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[256]; /**< 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         DEBUG("looking for export size with ioctl BLKGETSIZE\n");
 413         if (!ioctl(export, BLKGETSIZE, &es32) && es32) {
 414                 es = (off_t)es32 * (off_t)512;
 415                 return es;
 416         }
 417 #endif
 418 #endif
 419
 420         DEBUG("looking for export size with fstat\n");
 421         stat_buf.st_size = 0;
 422         error = fstat(export, &stat_buf);
 423         if (!error && stat_buf.st_size > 0) {
 424                 return (off_t)stat_buf.st_size;
 425         } else {
 426                 err("fstat failed: %m");
 427         }
 428
 429         DEBUG("looking for export size with lseek SEEK_END\n");
 430         es = lseek(export, (off_t)0, SEEK_END);
 431         if (es > ((off_t)0)) {
 432                 return es;
 433         } else {
 434                 DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4)));
 435         }
 436
 437         err("Could not find size of exported block device: %m");
 438         return OFFT_MAX;
 439 }
 440
 441 /**
 442  * Seek to a position in a file, unless we're already there.
 443  * @param handle a filedescriptor
 444  * @param a position to seek to
 445  **/
 446 void maybeseek(int handle, off_t a) {
 447         if (a < 0 || a > exportsize) {
 448                 err("Can not happen\n");
 449         }
 450         if (lastpoint != a) {
 451                 if (lseek(handle, a, SEEK_SET) < 0) {
 452                         err("Can not seek locally!\n");
 453                 }
 454                 lastpoint = a;
 455         } else {
 456                 DEBUG("S");
 457         }
 458 }
 459
 460 /**
 461  * Write an amount of bytes at a given offset to the right file. This
 462  * abstracts the write-side of the multiple file option.
 463  *
 464  * @param a The offset where the write should start
 465  * @param buf The buffer to write from
 466  * @param len The length of buf
 467  * @return The number of bytes actually written, or -1 in case of an error
 468  **/
 469 int rawexpwrite(off_t a, char *buf, size_t len)
 470 {
 471         ssize_t res;
 472
 473         maybeseek(export[a/hunksize], a%hunksize);
 474         res = write(export[a/hunksize], buf, len);
 475         return (res < 0 || (size_t)res != len);
 476 }
 477
 478 /**
 479  * seek to a position in a file, no matter what. Used when using maybeseek is a
 480  * bad idea (for instance, because we're reading the copyonwrite file instead
 481  * of the exported file).
 482  * @param handle a filedescriptor
 483  * @param a position to seek to
 484  * @todo get rid of this; lastpoint is a global variable right now, but it
 485  * shouldn't be. If we pass it on as a parameter, that makes things a *lot*
 486  * easier.
 487  **/
 488 void myseek(int handle,off_t a) {
 489         if (lseek(handle, a, SEEK_SET) < 0) {
 490                 err("Can not seek locally!\n");
 491         }
 492 }
 493
 494 /**
 495  * Read an amount of bytes at a given offset from the right file. This
 496  * abstracts the read-side of the multiple files option.
 497  *
 498  * @param a The offset where the read should start
 499  * @param buf A buffer to read into
 500  * @param len The size of buf
 501  * @return The number of bytes actually read, or -1 in case of an
 502  * error.
 503  **/
 504 int rawexpread(off_t a, char *buf, size_t len)
 505 {
 506         ssize_t res;
 507
 508         maybeseek(export[a/hunksize], a%hunksize);
 509         res = read(export[a/hunksize], buf, len);
 510         return (res < 0 || (size_t)res != len);
 511 }
 512
 513 /**
 514  * Read an amount of bytes at a given offset from the right file. This
 515  * abstracts the read-side of the copyonwrite stuff, and calls
 516  * rawexpread() with the right parameters to do the actual work.
 517  * @param a The offset where the read should start
 518  * @param buf A buffer to read into
 519  * @param len The size of buf
 520  * @return The number of bytes actually read, or -1 in case of an error
 521  **/
 522 int expread(off_t a, char *buf, size_t len)
 523 {
 524         off_t rdlen, offset;
 525         off_t mapcnt, mapl, maph, pagestart;
 526
 527         if (!(flags & F_COPYONWRITE))
 528                 return rawexpread(a, buf, len);
 529         DEBUG3("Asked to read %d bytes at %Lu.\n", len, (unsigned long long)a);
 530
 531         mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE;
 532
 533         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 534                 pagestart=mapcnt*DIFFPAGESIZE;
 535                 offset=a-pagestart;
 536                 rdlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 537                         len : (size_t)DIFFPAGESIZE-offset;
 538                 if (difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 539                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 540                                (unsigned long)difmap[mapcnt]);
 541                         myseek(difffile, difmap[mapcnt]*DIFFPAGESIZE+offset);
 542                         if (read(difffile, buf, rdlen) != rdlen) return -1;
 543                 } else { /* the block is not there */
 544                         DEBUG2("Page %Lu is not here, we read the original one\n",
 545                                (unsigned long long)mapcnt);
 546                         return rawexpread(a, buf, rdlen);
 547                 }
 548                 len-=rdlen; a+=rdlen; buf+=rdlen;
 549         }
 550         return 0;
 551 }
 552
 553 /**
 554  * Write an amount of bytes at a given offset to the right file. This
 555  * abstracts the write-side of the copyonwrite option, and calls
 556  * rawexpwrite() with the right parameters to do the actual work.
 557  *
 558  * @param a The offset where the write should start
 559  * @param buf The buffer to write from
 560  * @param len The length of buf
 561  * @return The number of bytes actually written, or -1 in case of an error
 562  **/
 563 int expwrite(off_t a, char *buf, size_t len)
 564 {
 565         off_t mapcnt,mapl,maph ;
 566         off_t wrlen,rdlen ;
 567         off_t pagestart ;
 568         off_t offset ;
 569
 570         if (!(flags & F_COPYONWRITE))
 571                 return(rawexpwrite(a,buf,len));
 572         DEBUG3("Asked to write %d bytes at %Lu.\n", len, (unsigned long long)a);
 573
 574         mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ;
 575
 576         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 577                 pagestart=mapcnt*DIFFPAGESIZE ;
 578                 offset=a-pagestart ;
 579                 wrlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 580                         len : (size_t)DIFFPAGESIZE-offset;
 581
 582                 if (difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 583                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 584                                (unsigned long)difmap[mapcnt]) ;
 585                         myseek(difffile,difmap[mapcnt]*DIFFPAGESIZE+offset) ;
 586                         if (write(difffile, buf, wrlen) != wrlen) return -1 ;
 587                 } else { /* the block is not there */
 588                         myseek(difffile,difffilelen*DIFFPAGESIZE) ;
 589                         difmap[mapcnt]=difffilelen++ ;
 590                         DEBUG3("Page %Lu is not here, we put it at %lu\n",
 591                                (unsigned long long)mapcnt,
 592                                (unsigned long)difmap[mapcnt]);
 593                         rdlen=DIFFPAGESIZE ;
 594                         if (rdlen+pagestart%hunksize>hunksize)
 595                                 rdlen=hunksize-(pagestart%hunksize) ;
 596                         if (rawexpread(pagestart,pagebuf,rdlen)) return -1 ;
 597                         memcpy(pagebuf+offset,buf,wrlen) ;
 598                         if (write(difffile,pagebuf,DIFFPAGESIZE)!=DIFFPAGESIZE) return -1 ;
 599                 }
 600                 len-=wrlen ; a+=wrlen ; buf+=wrlen ;
 601         }
 602         return 0;
 603 }
 604
 605 /**
 606  * Do the initial negotiation.
 607  *
 608  * @param net A socket to do the negotiation over
 609  **/
 610 void negotiate(int net) {
 611         char zeros[300];
 612         u64 size_host;
 613
 614         memset(zeros, 0, 290);
 615         if (write(net, INIT_PASSWD, 8) < 0)
 616                 err("Negotiation failed: %m");
 617         cliserv_magic = htonll(cliserv_magic);
 618         if (write(net, &cliserv_magic, sizeof(cliserv_magic)) < 0)
 619                 err("Negotiation failed: %m");
 620         size_host = htonll((u64)exportsize);
 621         if (write(net, &size_host, 8) < 0)
 622                 err("Negotiation failed: %m");
 623         if (write(net, zeros, 128) < 0)
 624                 err("Negotiation failed: %m");
 625 }
 626
 627 /** sending macro; not really required. Uses variables in the local
 628  * scope of mainloop(). Get rid of it. */
 629 #define SEND writeit( net, &reply, sizeof( reply ));
 630 /** error macro; not sure whether we really need this. Uses variables
 631  * in the local scope of mainloop(). Get rid of this beast. */
 632 #define ERROR { reply.error = htonl(-1); SEND; reply.error = 0; lastpoint = -1; }
 633 /**
 634  * Serve a file to a single client.
 635  *
 636  * @todo This beast needs to be split up in many tiny little manageable
 637  * pieces. Preferably with a chainsaw.
 638  *
 639  * @param net A network socket, connected to an nbd client
 640  * @return never
 641  **/
 642 int mainloop(int net)
 643 {
 644         struct nbd_request request;
 645         struct nbd_reply reply;
 646 #ifdef DODBG
 647         int i = 0;
 648 #endif
 649         negotiate(net);
 650         DEBUG("Entering request loop!\n");
 651         reply.magic = htonl(NBD_REPLY_MAGIC);
 652         reply.error = 0;
 653         while (1) {
 654                 char buf[BUFSIZE];
 655                 size_t len;
 656 #ifdef DODBG
 657                 i++;
 658                 printf("%d: ", i);
 659 #endif
 660                 if (timeout)
 661                         alarm(timeout);
 662                 readit(net, &request, sizeof(request));
 663                 request.from = ntohll(request.from);
 664                 request.type = ntohl(request.type);
 665
 666                 if (request.type==NBD_CMD_DISC) { /* Disconnect request */
 667                   if (difmap) free(difmap) ;
 668                   if (difffile>=0) {
 669                      close(difffile) ; unlink(difffilename) ; }
 670                   err("Disconnect request received.") ;
 671                 }
 672
 673                 len = ntohl(request.len);
 674
 675                 if (request.magic != htonl(NBD_REQUEST_MAGIC))
 676                         err("Not enough magic.");
 677                 if (len > BUFSIZE)
 678                         err("Request too big!");
 679 #ifdef DODBG
 680                 printf("%s from %Lu (%Lu) len %d, ", request.type ? "WRITE" :
 681                                 "READ", (unsigned long long)request.from,
 682                                 (unsigned long long)request.from / 512, len);
 683 #endif
 684                 memcpy(reply.handle, request.handle, sizeof(reply.handle));
 685                 if ((request.from + len) > (OFFT_MAX)) {
 686                   DEBUG("[Number too large!]");
 687                   ERROR;
 688                   continue;
 689                 }
 690
 691                 if (((ssize_t)((off_t)request.from + len) > exportsize) ||
 692                     ((flags & F_READONLY) && request.type)) {
 693                         DEBUG("[RANGE!]");
 694                         ERROR;
 695                         continue;
 696                 }
 697
 698                 if (request.type==1) {  /* WRITE */
 699                         DEBUG("wr: net->buf, ");
 700                         readit(net, buf, len);
 701                         DEBUG("buf->exp, ");
 702                         if ((autoreadonly == 1) || expwrite(request.from, buf, len)) {
 703                                 DEBUG("Write failed: %m" );
 704                                 ERROR;
 705                                 continue;
 706                         }
 707                         lastpoint += len;
 708                         SEND;
 709                         DEBUG("OK!\n");
 710                         continue;
 711                 }
 712                 /* READ */
 713
 714                 DEBUG("exp->buf, ");
 715                 if (expread(request.from, buf + sizeof(struct nbd_reply), len)) {
 716                         lastpoint = -1;
 717                         DEBUG("Read failed: %m");
 718                         ERROR;
 719                         continue;
 720                 }
 721                 lastpoint += len;
 722
 723                 DEBUG("buf->net, ");
 724                 memcpy(buf, &reply, sizeof(struct nbd_reply));
 725                 writeit(net, buf, len + sizeof(struct nbd_reply));
 726                 DEBUG("OK!\n");
 727         }
 728 }
 729
 730 /**
 731  * Split a single exportfile into multiple ones, if that was asked.
 732  * @return 0 on success, -1 on failure
 733  **/
 734 int splitexport(void) {
 735         off_t i ;
 736
 737         for (i=0; i<exportsize; i+=hunksize) {
 738                 char exportname3[1024];
 739
 740                 sprintf(exportname3, exportname2, i/hunksize);
 741                 printf( "Opening %s\n", exportname3 );
 742                 if ((export[i/hunksize] = open(exportname3, (flags & F_READONLY) ? O_RDONLY : O_RDWR)) == -1) {
 743                         /* Read WRITE ACCESS was requested by media is only read only */
 744                         autoreadonly = 1;
 745                         flags |= F_READONLY;
 746                         if ((export[i/hunksize] = open(exportname3, O_RDONLY)) == -1)
 747                                 err("Could not open exported file: %m");
 748                 }
 749         }
 750
 751         if (flags & F_COPYONWRITE) {
 752                 sprintf(difffilename,"%s-%s-%d.diff",exportname2,clientname,
 753                         (int)getpid()) ;
 754                 msg3(LOG_INFO,"About to create map and diff file %s",difffilename) ;
 755                 difffile=open(difffilename,O_RDWR | O_CREAT | O_TRUNC,0600) ;
 756                 if (difffile<0) err("Could not create diff file (%m)") ;
 757                 if ((difmap=calloc(exportsize/DIFFPAGESIZE,sizeof(u32)))==NULL)
 758                         err("Could not allocate memory") ;
 759                 for (i=0;i<exportsize/DIFFPAGESIZE;i++) difmap[i]=(u32)-1 ;
 760         }
 761
 762         return 0;
 763 }
 764
 765 /**
 766  * Serve a connection.
 767  *
 768  * @todo allow for multithreading, perhaps use libevent.
 769  *
 770  * @param net A network socket connected to an nbd client
 771  **/
 772 void serveconnection(int net) {
 773         splitexport();
 774         if (exportsize == OFFT_MAX) {
 775                 exportsize = size_autodetect(export[0]);
 776         }
 777         if (exportsize > OFFT_MAX) {
 778                 err("Size of exported file is too big\n");
 779         }
 780         else
 781                 msg3(LOG_INFO, "size of exported file/device is %Lu",
 782                      (unsigned long long)exportsize);
 783
 784         setmysockopt(net);
 785
 786         mainloop(net);
 787 }
 788
 789 /**
 790  * Find the name of the file we have to serve. This will use sprintf()
 791  * to put the IP address of the client inside a filename containing
 792  * "%s". That name is then written to exportname2
 793  *
 794  * @param net A socket connected to an nbd client
 795  * @param clientname a buffer which must be at least 255+1 bytes long;
 796  * the IP address (in human-readable format) will be copied in there.
 797  **/
 798 void set_peername(int net,char *clientname)
 799 {
 800         struct sockaddr_in addrin;
 801         int addrinlen = sizeof( addrin );
 802         char *peername ;
 803
 804         if (getpeername( net, (struct sockaddr *) &addrin, &addrinlen ) < 0)
 805                 err("getsockname failed: %m");
 806         peername = inet_ntoa(addrin.sin_addr);
 807         sprintf(exportname2, exportname, peername);
 808
 809         msg4(LOG_INFO, "connect from %s, assigned file is %s",
 810              peername, exportname2);
 811         strncpy(clientname,peername,255) ;
 812 }
 813
 814 /**
 815  * Connect the socket, and start to serve. This function will fork()
 816  * if a connection from an authorized client is received, and will
 817  * start mainloop().
 818  *
 819  * @todo modularize this giant beast. Preferably with a chainsaw. Also,
 820  * it has no business starting mainloop(); it should connect, and be
 821  * done with it.
 822  *
 823  * @param port the port where we will listen
 824  **/
 825 void connectme(unsigned int port)
 826 {
 827         struct sockaddr_in addrin;
 828         struct sigaction sa;
 829         int addrinlen = sizeof(addrin);
 830         int net, sock, newpid, i;
 831 #ifndef sun
 832         int yes=1;
 833 #else
 834         char yes='1';
 835 #endif /* sun */
 836 #ifndef NODAEMON
 837 #ifndef NOFORK
 838         FILE*pidf;
 839
 840         if(port) {
 841                 if(daemon(0,0)<0) {
 842                         err("daemon");
 843                 }
 844                 snprintf(pidfname, sizeof(char)*255, "/var/run/nbd-server.%d.pid", port);
 845                 pidf=fopen(pidfname, "w");
 846                 if(pidf) {
 847                         fprintf(pidf,"%d", (int)getpid());
 848                         fclose(pidf);
 849                 } else {
 850                         perror("fopen");
 851                         fprintf(stderr, "Not fatal; continuing");
 852                 }
 853         }
 854 #endif /* NOFORK */
 855 #endif /* NODAEMON */
 856
 857         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 858                 err("socket: %m");
 859
 860         /* lose the pesky "Address already in use" error message */
 861         if (setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
 862                 err("setsockopt SO_REUSEADDR");
 863         }
 864         if (setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
 865                 err("setsockopt SO_KEEPALIVE");
 866         }
 867
 868         DEBUG("Waiting for connections... bind, ");
 869         addrin.sin_family = AF_INET;
 870         addrin.sin_port = htons(port);
 871         addrin.sin_addr.s_addr = 0;
 872         if (bind(sock, (struct sockaddr *) &addrin, addrinlen) < 0)
 873                 err("bind: %m");
 874         DEBUG("listen, ");
 875         if (listen(sock, 1) < 0)
 876                 err("listen: %m");
 877         DEBUG("accept, ");
 878         sa.sa_handler = sigchld_handler;
 879         sigemptyset(&sa.sa_mask);
 880         sa.sa_flags = SA_RESTART;
 881         if(sigaction(SIGCHLD, &sa, NULL) == -1)
 882                 err("sigaction: %m");
 883         sa.sa_handler = sigterm_handler;
 884         sigemptyset(&sa.sa_mask);
 885         sa.sa_flags = SA_RESTART;
 886         if(sigaction(SIGTERM, &sa, NULL) == -1)
 887                 err("sigaction: %m");
 888         children=malloc(sizeof(pid_t)*child_arraysize);
 889         memset(children, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY);
 890         for(;;) { /* infinite loop */
 891                 if ((net = accept(sock, (struct sockaddr *) &addrin, &addrinlen)) < 0)
 892                         err("accept: %m");
 893
 894                 set_peername(net,clientname);
 895                 if (!authorized_client(clientname)) {
 896                         msg2(LOG_INFO,"Unauthorized client") ;
 897                         close(net) ;
 898                         continue ;
 899                 }
 900                 msg2(LOG_INFO,"Authorized client") ;
 901                 for(i=0;children[i]&&i<child_arraysize;i++);
 902                 if(i>=child_arraysize) {
 903                         pid_t*ptr;
 904
 905                         ptr=realloc(children, sizeof(pid_t)*child_arraysize);
 906                         if(ptr) {
 907                                 children=ptr;
 908                                 memset(children+child_arraysize, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY);
 909                                 i=child_arraysize+1;
 910                                 child_arraysize+=DEFAULT_CHILD_ARRAY;
 911                         } else {
 912                                 msg2(LOG_INFO,"Not enough memory to store child PID");
 913                                 close(net);
 914                                 continue;
 915                         }
 916                 }
 917 #ifndef NOFORK
 918                 if ((children[i]=fork())<0) {
 919                         msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
 920                         close(net) ;
 921                         continue ;
 922                 }
 923                 if (children[i]>0) { /* parent */
 924                         close(net) ; continue ; }
 925                 /* child */
 926                 realloc(children,0);
 927                 child_arraysize=0;
 928                 close(sock) ;
 929 #endif // NOFORK
 930                 msg2(LOG_INFO,"Starting to serve") ;
 931                 serveconnection(net) ;
 932         }
 933 }
 934
 935 /**
 936  * Main entry point...
 937  **/
 938 int main(int argc, char *argv[])
 939 {
 940         if (sizeof( struct nbd_request )!=28) {
 941                 fprintf(stderr,"Bad size of structure. Alignment problems?\n");
 942                 exit(-1) ;
 943         }
 944         logging();
 945         cmdline(argc, argv);
 946
 947         if (!port) return 1 ;
 948         connectme(port); /* serve infinitely */
 949         return 0 ;
 950 }
 951