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.
  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 "lfs.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 #include <unistd.h>
  83 #include <getopt.h>
  84
  85 #include <glib.h>
  86
  87 /* used in cliserv.h, so must come first */
  88 #define MY_NAME "nbd_server"
  89 #include "cliserv.h"
  90
  91 /** Default position of the config file */
  92 #ifndef SYSCONFDIR
  93 #define SYSCONFDIR "/etc"
  94 #endif
  95 #define CFILE SYSCONFDIR "/nbd-server/config"
  96
  97 /** Where our config file actually is */
  98 gchar* config_file_pos;
  99
 100 /** how much space for child PIDs we have by default. Dynamically
 101    allocated, and will be realloc()ed if out of space, so this should
 102    probably be fair for most situations. */
 103 #define DEFAULT_CHILD_ARRAY 256
 104
 105 /** Logging macros, now nothing goes to syslog unless you say ISSERVER */
 106 #ifdef ISSERVER
 107 #define msg2(a,b) syslog(a,b)
 108 #define msg3(a,b,c) syslog(a,b,c)
 109 #define msg4(a,b,c,d) syslog(a,b,c,d)
 110 #else
 111 #define msg2(a,b) g_message(b)
 112 #define msg3(a,b,c) g_message(b,c)
 113 #define msg4(a,b,c,d) g_message(b,c,d)
 114 #endif
 115
 116 /* Debugging macros */
 117 //#define DODBG
 118 #ifdef DODBG
 119 #define DEBUG( a ) printf( a )
 120 #define DEBUG2( a,b ) printf( a,b )
 121 #define DEBUG3( a,b,c ) printf( a,b,c )
 122 #else
 123 #define DEBUG( a )
 124 #define DEBUG2( a,b )
 125 #define DEBUG3( a,b,c )
 126 #endif
 127 #ifndef PACKAGE_VERSION
 128 #define PACKAGE_VERSION ""
 129 #endif
 130 /**
 131  * The highest value a variable of type off_t can reach.
 132  **/
 133 /* This is starting to get ugly. If someone knows a better way to find
 134  * the maximum value of a signed type *without* relying on overflow
 135  * (doing so breaks on 64bit architectures), that would be nice.
 136  *
 137  * Actually, do we need this at all? Can't we just say '0 is autodetect', and
 138  * live with it? Or better yet, use an extra flag, or so?
 139  * Answer: yes, we need it, as the hunksize is defined to this when the
 140  * multiple file thingy isn't used.
 141  */
 142 #define OFFT_MAX (((((off_t)1)<<((sizeof(off_t)-1)*8))-1)<<7)+127
 143 #define LINELEN 256       /**< Size of static buffer used to read the
 144                             authorization file (yuck) */
 145 #define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */
 146 #define GIGA (1*1024*1024*1024) /**< 1 Gigabyte. Used as hunksize when doing
 147                                   the multiple file thingy. @todo: make this a
 148                                   configuration option. */
 149 #define DIFFPAGESIZE 4096 /**< diff file uses those chunks */
 150 #define F_READONLY 1      /**< flag to tell us a file is readonly */
 151 #define F_MULTIFILE 2     /**< flag to tell us a file is exported using -m */
 152 #define F_COPYONWRITE 4   /**< flag to tell us a file is exported using
 153                             copyonwrite */
 154 #define F_AUTOREADONLY 8  /**< flag to tell us a file is set to autoreadonly */
 155 GHashTable *children;
 156 char pidfname[256]; /**< name of our PID file */
 157 char default_authname[] = "/etc/nbd_server.allow"; /**< default name of allow file */
 158
 159 /**
 160  * Variables associated with a server.
 161  **/
 162 typedef struct {
 163         gchar* exportname;    /**< (unprocessed) filename of the file we're exporting */
 164         off_t hunksize;      /**< size of a hunk of an exported file */
 165         off_t expected_size; /**< size of the exported file as it was told to
 166                                us through configuration */
 167         unsigned int port;   /**< port we're exporting this file at */
 168         char* authname;      /**< filename of the authorization file */
 169         int flags;           /**< flags associated with this exported file */
 170         unsigned int timeout;/**< how long a connection may be idle
 171                                (0=forever) */
 172         int socket;          /**< The socket of this server. */
 173 } SERVER;
 174
 175 /**
 176  * Variables associated with a client socket.
 177  **/
 178 typedef struct {
 179         off_t exportsize;    /**< size of the file we're exporting */
 180         char *clientname;    /**< peer */
 181         char *exportname;    /**< (processed) filename of the file we're exporting */
 182         GArray *export;    /**< array of filedescriptors of exported files;
 183                                only the first is actually used unless we're
 184                                doing the multiple file option */
 185         int net;             /**< The actual client socket */
 186         SERVER *server;      /**< The server this client is getting data from */
 187         char* difffilename;  /**< filename of the copy-on-write file, if any */
 188         int difffile;        /**< filedescriptor of copyonwrite file. @todo
 189                                shouldn't this be an array too? (cfr export) Or
 190                                make -m and -c mutually exclusive */
 191         u32 difffilelen;     /**< number of pages in difffile */
 192         u32 *difmap;         /**< see comment on the global difmap for this one */
 193 } CLIENT;
 194
 195 /**
 196  * Type of configuration file values
 197  **/
 198 typedef enum {
 199         PARAM_INT,              /**< This parameter is an integer */
 200         PARAM_STRING,           /**< This parameter is a string */
 201         PARAM_BOOL,             /**< This parameter is a boolean */
 202 } PARAM_TYPE;
 203 /**
 204  * Configuration file values
 205  **/
 206 typedef struct {
 207         gchar *paramname;       /**< Name of the parameter, as it appears in
 208                                   the config file */
 209         gboolean required;      /**< Whether this is a required (as opposed to
 210                                   optional) parameter */
 211         PARAM_TYPE ptype;       /**< Type of the parameter. */
 212         gpointer target;        /**< Pointer to where the data of this
 213                                   parameter should be written. If ptype is
 214                                   PARAM_BOOL, the data is or'ed rather than
 215                                   overwritten. */
 216         gint flagval;           /**< Flag mask for this parameter in case ptype
 217                                   is PARAM_BOOL. */
 218 } PARAM;
 219
 220 /**
 221  * Check whether a client is allowed to connect. Works with an authorization
 222  * file which contains one line per machine, no wildcards.
 223  *
 224  * @param opts The client who's trying to connect.
 225  * @return 0 - authorization refused, 1 - OK
 226  **/
 227 int authorized_client(CLIENT *opts) {
 228         FILE *f ;
 229
 230         char line[LINELEN];
 231
 232         if ((f=fopen(opts->server->authname,"r"))==NULL) {
 233                 msg4(LOG_INFO,"Can't open authorization file %s (%s).",
 234                      opts->server->authname,strerror(errno)) ;
 235                 return 1 ;
 236         }
 237
 238         while (fgets(line,LINELEN,f)!=NULL) {
 239                 if (strncmp(line,opts->clientname,strlen(opts->clientname))==0) {
 240                         fclose(f);
 241                         return 1;
 242                 }
 243         }
 244         fclose(f) ;
 245         return 0 ;
 246 }
 247
 248 /**
 249  * Read data from a file descriptor into a buffer
 250  *
 251  * @param f a file descriptor
 252  * @param buf a buffer
 253  * @param len the number of bytes to be read
 254  **/
 255 inline void readit(int f, void *buf, size_t len) {
 256         ssize_t res;
 257         while (len > 0) {
 258                 DEBUG("*");
 259                 if ((res = read(f, buf, len)) <= 0)
 260                         err("Read failed: %m");
 261                 len -= res;
 262                 buf += res;
 263         }
 264 }
 265
 266 /**
 267  * Write data from a buffer into a filedescriptor
 268  *
 269  * @param f a file descriptor
 270  * @param buf a buffer containing data
 271  * @param len the number of bytes to be written
 272  **/
 273 inline void writeit(int f, void *buf, size_t len) {
 274         ssize_t res;
 275         while (len > 0) {
 276                 DEBUG("+");
 277                 if ((res = write(f, buf, len)) <= 0)
 278                         err("Send failed: %m");
 279                 len -= res;
 280                 buf += res;
 281         }
 282 }
 283
 284 /**
 285  * Print out a message about how to use nbd-server. Split out to a separate
 286  * function so that we can call it from multiple places
 287  */
 288 void usage() {
 289         printf("This is nbd-server version " VERSION "\n");
 290         printf("Usage: port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-a timeout_sec]\n"
 291                "\t-r|--read-only\t\tread only\n"
 292                "\t-m|--multi-file\t\tmultiple file\n"
 293                "\t-c|--copy-on-write\tcopy on write\n"
 294                "\t-l|--authorize-file\tfile with list of hosts that are allowed to\n\t\t\t\tconnect.\n"
 295                "\t-a|--idle-time\t\tmaximum idle seconds; server terminates when\n\t\t\t\tidle time exceeded\n\n"
 296                "\tif port is set to 0, stdin is used (for running from inetd)\n"
 297                "\tif file_to_export contains '%%s', it is substituted with the IP\n"
 298                "\t\taddress of the machine trying to connect\n" );
 299         printf("Using configuration file %s\n", CFILE);
 300 }
 301
 302 /**
 303  * Parse the command line.
 304  *
 305  * @param argc the argc argument to main()
 306  * @param argv the argv argument to main()
 307  **/
 308 SERVER* cmdline(int argc, char *argv[]) {
 309         int i=0;
 310         int nonspecial=0;
 311         int c;
 312         struct option long_options[] = {
 313                 {"read-only", no_argument, NULL, 'r'},
 314                 {"multi-file", no_argument, NULL, 'm'},
 315                 {"copy-on-write", no_argument, NULL, 'c'},
 316                 {"authorize-file", required_argument, NULL, 'l'},
 317                 {"idle-time", required_argument, NULL, 'a'},
 318                 {"config-file", required_argument, NULL, 'C'},
 319                 {0,0,0,0}
 320         };
 321         SERVER *serve;
 322         off_t es;
 323         size_t last;
 324         char suffix;
 325
 326         if(argc==1) {
 327                 return NULL;
 328         }
 329         serve=g_new0(SERVER, 1);
 330         serve->hunksize=OFFT_MAX;
 331         serve->authname = g_strdup(default_authname);
 332         while((c=getopt_long(argc, argv, "-a:C:cl:mr", long_options, &i))>=0) {
 333                 switch (c) {
 334                 case 1:
 335                         /* non-option argument */
 336                         switch(nonspecial++) {
 337                         case 0:
 338                                 serve->port=strtol(optarg, NULL, 0);
 339                                 break;
 340                         case 1:
 341                                 serve->exportname = g_strdup(optarg);
 342                                 if(serve->exportname[0] != '/') {
 343                                         fprintf(stderr, "E: The to be exported file needs to be an absolute filename!\n");
 344                                         exit(EXIT_FAILURE);
 345                                 }
 346                                 break;
 347                         case 2:
 348                                 last=strlen(optarg)-1;
 349                                 suffix=optarg[last];
 350                                 if (suffix == 'k' || suffix == 'K' ||
 351                                     suffix == 'm' || suffix == 'M')
 352                                         optarg[last] = '\0';
 353                                 es = (off_t)atol(optarg);
 354                                 switch (suffix) {
 355                                         case 'm':
 356                                         case 'M':  es <<= 10;
 357                                         case 'k':
 358                                         case 'K':  es <<= 10;
 359                                         default :  break;
 360                                 }
 361                                 serve->expected_size = es;
 362                                 break;
 363                         }
 364                         break;
 365                 case 'r':
 366                         serve->flags |= F_READONLY;
 367                         break;
 368                 case 'm':
 369                         serve->flags |= F_MULTIFILE;
 370                         serve->hunksize = 1*GIGA;
 371                         break;
 372                 case 'c':
 373                         serve->flags |=F_COPYONWRITE;
 374                         break;
 375                 case 'C':
 376                         g_free(config_file_pos);
 377                         config_file_pos=g_strdup(optarg);
 378                         break;
 379                 case 'l':
 380                         g_free(serve->authname);
 381                         serve->authname=g_strdup(optarg);
 382                         break;
 383                 case 'a':
 384                         serve->timeout=strtol(optarg, NULL, 0);
 385                         break;
 386                 default:
 387                         usage();
 388                         exit(EXIT_FAILURE);
 389                         break;
 390                 }
 391         }
 392         /* What's left: the port to export, the name of the to be exported
 393          * file, and, optionally, the size of the file, in that order. */
 394         if(nonspecial<2) {
 395                 usage();
 396                 exit(EXIT_FAILURE);
 397         }
 398         return serve;
 399 }
 400
 401 /**
 402  * Error codes for config file parsing
 403  **/
 404 typedef enum {
 405         CFILE_NOTFOUND,         /**< The configuration file is not found */
 406         CFILE_MISSING_GENERIC,  /**< The (required) group "generic" is missing */
 407         CFILE_KEY_MISSING,      /**< A (required) key is missing */
 408         CFILE_VALUE_INVALID,    /**< A value is syntactically invalid */
 409         CFILE_PROGERR           /**< Programmer error */
 410 } CFILE_ERRORS;
 411
 412 /**
 413  * Remove a SERVER from memory. Used from the hash table
 414  **/
 415 void remove_server(gpointer s) {
 416         SERVER *server;
 417
 418         server=(SERVER*)s;
 419         g_free(server->exportname);
 420         if(server->authname)
 421                 g_free(server->authname);
 422         g_free(server);
 423 }
 424
 425 /**
 426  * Parse the config file.
 427  *
 428  * @param f the name of the config file
 429  * @param e a GError. @see CFILE_ERRORS for what error values this function can
 430  *      return.
 431  * @return a GHashTable of SERVER* pointers, with the port number as the hash
 432  *      key. If the config file is empty or does not exist, returns an empty
 433  *      GHashTable; if the config file contains an error, returns NULL, and
 434  *      e is set appropriately
 435  **/
 436 GArray* parse_cfile(gchar* f, GError** e) {
 437         SERVER s;
 438         PARAM p[] = {
 439                 { "exportname", TRUE,   PARAM_STRING,   NULL, 0 },
 440                 { "port",       TRUE,   PARAM_INT,      NULL, 0 },
 441                 { "authfile",   FALSE,  PARAM_STRING,   NULL, 0 },
 442                 { "timeout",    FALSE,  PARAM_INT,      NULL, 0 },
 443                 { "filesize",   FALSE,  PARAM_INT,      NULL, 0 },
 444                 { "readonly",   FALSE,  PARAM_BOOL,     NULL, F_READONLY },
 445                 { "multifile",  FALSE,  PARAM_BOOL,     NULL, F_MULTIFILE },
 446                 { "copyonwrite", FALSE, PARAM_BOOL,     NULL, F_COPYONWRITE },
 447         };
 448         GKeyFile *cfile;
 449         GError *err = NULL;
 450         GQuark errdomain;
 451         GArray *retval;
 452         gchar **groups;
 453         gboolean value;
 454         gint i,j;
 455
 456         errdomain = g_quark_from_string("parse_cfile");
 457         cfile = g_key_file_new();
 458         retval = g_array_new(FALSE, TRUE, sizeof(SERVER));
 459         if(!g_key_file_load_from_file(cfile, f, G_KEY_FILE_KEEP_COMMENTS |
 460                         G_KEY_FILE_KEEP_TRANSLATIONS, &err)) {
 461                 g_set_error(e, errdomain, CFILE_NOTFOUND, "Could not open config file.");
 462                 g_key_file_free(cfile);
 463                 return retval;
 464         }
 465         if(strcmp(g_key_file_get_start_group(cfile), "generic")) {
 466                 g_set_error(e, errdomain, CFILE_MISSING_GENERIC, "Config file does not contain the [generic] group!");
 467                 g_key_file_free(cfile);
 468                 return NULL;
 469         }
 470         groups = g_key_file_get_groups(cfile, NULL);
 471         for(i=0;groups[i];i++) {
 472                 p[0].target=&(s.exportname);
 473                 p[1].target=&(s.port);
 474                 p[2].target=&(s.authname);
 475                 p[3].target=&(s.timeout);
 476                 p[4].target=&(s.expected_size);
 477                 p[5].target=p[6].target=p[7].target=p[8].target=&(s.flags);
 478                 for(j=0;j<9;j++) {
 479                         g_assert(p[j].target != NULL);
 480                         g_assert(p[j].ptype==PARAM_INT||p[j].ptype==PARAM_STRING||p[j].ptype==PARAM_BOOL);
 481                         switch(p[j].ptype) {
 482                                 case PARAM_INT:
 483                                         *((gint*)p[j].target) = g_key_file_get_integer(cfile, groups[i], p[j].paramname, &err);
 484                                         break;
 485                                 case PARAM_STRING:
 486                                         *((gchar**)p[j].target) = g_key_file_get_string(cfile, groups[i], p[j].paramname, &err);
 487                                         break;
 488                                 case PARAM_BOOL:
 489                                         value = g_key_file_get_boolean(cfile, groups[i], p[j].paramname, &err);
 490                                         if(!err) {
 491                                                 *((gint*)p[j].target) |= value;
 492                                         }
 493                                         break;
 494                         }
 495                         if(err) {
 496                                 if(err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
 497                                         if(p[j].required) {
 498                                                 g_set_error(e, errdomain, CFILE_KEY_MISSING, "Could not find required value %s in group %s: %s", p[j].paramname, groups[i], err->message);
 499                                                 g_array_free(retval, TRUE);
 500                                                 g_error_free(err);
 501                                                 g_key_file_free(cfile);
 502                                                 return NULL;
 503                                         } else {
 504                                                 g_error_free(err);
 505                                                 continue;
 506                                         }
 507                                         g_set_error(e, errdomain, CFILE_VALUE_INVALID, "Could not parse %s in group %s: %s", p[j].paramname, groups[i], err->message);
 508                                         g_array_free(retval, TRUE);
 509                                         g_error_free(err);
 510                                         g_key_file_free(cfile);
 511                                         return NULL;
 512                                 }
 513                         }
 514                 }
 515                 g_array_append_val(retval, s);
 516         }
 517         return retval;
 518 }
 519
 520 /**
 521  * Signal handler for SIGCHLD
 522  * @param s the signal we're handling (must be SIGCHLD, or something
 523  * is severely wrong)
 524  **/
 525 void sigchld_handler(int s) {
 526         int* status=NULL;
 527         int* i;
 528         pid_t pid;
 529
 530         while((pid=wait(status)) > 0) {
 531                 if(WIFEXITED(status)) {
 532                         msg3(LOG_INFO, "Child exited with %d", WEXITSTATUS(status));
 533                 }
 534                 i=g_hash_table_lookup(children, &pid);
 535                 if(!i) {
 536                         msg3(LOG_INFO, "SIGCHLD received for an unknown child with PID %ld", (long)pid);
 537                 } else {
 538                         DEBUG2("Removing %d from the list of children", pid);
 539                         g_hash_table_remove(children, &pid);
 540                 }
 541         }
 542 }
 543
 544 /**
 545  * Kill a child. Called from sigterm_handler::g_hash_table_foreach.
 546  *
 547  * @param key the key
 548  * @param value the value corresponding to the above key
 549  * @param user_data a pointer which we always set to 1, so that we know what
 550  * will happen next.
 551  **/
 552 void killchild(gpointer key, gpointer value, gpointer user_data) {
 553         pid_t *pid=value;
 554         int *parent=user_data;
 555
 556         kill(*pid, SIGTERM);
 557         *parent=1;
 558 }
 559
 560 /**
 561  * Handle SIGTERM and dispatch it to our children
 562  * @param s the signal we're handling (must be SIGTERM, or something
 563  * is severely wrong).
 564  **/
 565 void sigterm_handler(int s) {
 566         int parent=0;
 567
 568         g_hash_table_foreach(children, killchild, &parent);
 569
 570         if(parent) {
 571                 unlink(pidfname);
 572         }
 573
 574         exit(0);
 575 }
 576
 577 /**
 578  * Detect the size of a file.
 579  *
 580  * @param export An open filedescriptor
 581  * @return the size of the file, or OFFT_MAX if detection was
 582  * impossible.
 583  **/
 584 off_t size_autodetect(int export) {
 585         off_t es;
 586         u32 es32;
 587         struct stat stat_buf;
 588         int error;
 589
 590 #ifdef HAVE_SYS_MOUNT_H
 591 #ifdef HAVE_SYS_IOCTL_H
 592 #ifdef BLKGETSIZE
 593         DEBUG("looking for export size with ioctl BLKGETSIZE\n");
 594         if (!ioctl(export, BLKGETSIZE, &es32) && es32) {
 595                 es = (off_t)es32 * (off_t)512;
 596                 return es;
 597         }
 598 #endif /* BLKGETSIZE */
 599 #endif /* HAVE_SYS_IOCTL_H */
 600 #endif /* HAVE_SYS_MOUNT_H */
 601
 602         DEBUG("looking for export size with fstat\n");
 603         stat_buf.st_size = 0;
 604         error = fstat(export, &stat_buf);
 605         if (!error) {
 606                 if(stat_buf.st_size > 0)
 607                         return (off_t)stat_buf.st_size;
 608         } else {
 609                 err("fstat failed: %m");
 610         }
 611
 612         DEBUG("looking for export size with lseek SEEK_END\n");
 613         es = lseek(export, (off_t)0, SEEK_END);
 614         if (es > ((off_t)0)) {
 615                 return es;
 616         } else {
 617                 DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4)));
 618         }
 619
 620         err("Could not find size of exported block device: %m");
 621         return OFFT_MAX;
 622 }
 623
 624 /**
 625  * seek to a position in a file, with error handling.
 626  * @param handle a filedescriptor
 627  * @param a position to seek to
 628  * @todo get rid of this; lastpoint is a global variable right now, but it
 629  * shouldn't be. If we pass it on as a parameter, that makes things a *lot*
 630  * easier.
 631  **/
 632 void myseek(int handle,off_t a) {
 633         if (lseek(handle, a, SEEK_SET) < 0) {
 634                 err("Can not seek locally!\n");
 635         }
 636 }
 637
 638 /**
 639  * Write an amount of bytes at a given offset to the right file. This
 640  * abstracts the write-side of the multiple file option.
 641  *
 642  * @param a The offset where the write should start
 643  * @param buf The buffer to write from
 644  * @param len The length of buf
 645  * @param client The client we're serving for
 646  * @return The number of bytes actually written, or -1 in case of an error
 647  **/
 648 int rawexpwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 649         ssize_t res;
 650
 651         myseek(g_array_index(client->export, int, (int)(a/client->server->hunksize)), a%client->server->hunksize);
 652         ;
 653         res = write(g_array_index(client->export, int, (int)((off_t)a/(off_t)(client->server->hunksize))), buf, len);
 654         return (res < 0 || (size_t)res != len);
 655 }
 656
 657 /**
 658  * Read an amount of bytes at a given offset from the right file. This
 659  * abstracts the read-side of the multiple files option.
 660  *
 661  * @param a The offset where the read should start
 662  * @param buf A buffer to read into
 663  * @param len The size of buf
 664  * @param client The client we're serving for
 665  * @return The number of bytes actually read, or -1 in case of an
 666  * error.
 667  **/
 668 int rawexpread(off_t a, char *buf, size_t len, CLIENT *client) {
 669         ssize_t res;
 670
 671         myseek(g_array_index(client->export,int,(int)a/client->server->hunksize),
 672                         a%client->server->hunksize);
 673         res = read(g_array_index(client->export,int,(int)a/client->server->hunksize), buf, len);
 674         return (res < 0 || (size_t)res != len);
 675 }
 676
 677 /**
 678  * Read an amount of bytes at a given offset from the right file. This
 679  * abstracts the read-side of the copyonwrite stuff, and calls
 680  * rawexpread() with the right parameters to do the actual work.
 681  * @param a The offset where the read should start
 682  * @param buf A buffer to read into
 683  * @param len The size of buf
 684  * @param client The client we're going to read for
 685  * @return The number of bytes actually read, or -1 in case of an error
 686  **/
 687 int expread(off_t a, char *buf, size_t len, CLIENT *client) {
 688         off_t rdlen, offset;
 689         off_t mapcnt, mapl, maph, pagestart;
 690
 691         if (!(client->server->flags & F_COPYONWRITE))
 692                 return rawexpread(a, buf, len, client);
 693         DEBUG3("Asked to read %d bytes at %Lu.\n", len, (unsigned long long)a);
 694
 695         mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE;
 696
 697         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 698                 pagestart=mapcnt*DIFFPAGESIZE;
 699                 offset=a-pagestart;
 700                 rdlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 701                         len : (size_t)DIFFPAGESIZE-offset;
 702                 if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 703                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 704                                (unsigned long)(client->difmap[mapcnt]));
 705                         myseek(client->difffile, client->difmap[mapcnt]*DIFFPAGESIZE+offset);
 706                         if (read(client->difffile, buf, rdlen) != rdlen) return -1;
 707                 } else { /* the block is not there */
 708                         DEBUG2("Page %Lu is not here, we read the original one\n",
 709                                (unsigned long long)mapcnt);
 710                         if(rawexpread(a, buf, rdlen, client)) return -1;
 711                 }
 712                 len-=rdlen; a+=rdlen; buf+=rdlen;
 713         }
 714         return 0;
 715 }
 716
 717 /**
 718  * Write an amount of bytes at a given offset to the right file. This
 719  * abstracts the write-side of the copyonwrite option, and calls
 720  * rawexpwrite() with the right parameters to do the actual work.
 721  *
 722  * @param a The offset where the write should start
 723  * @param buf The buffer to write from
 724  * @param len The length of buf
 725  * @param client The client we're going to write for.
 726  * @return The number of bytes actually written, or -1 in case of an error
 727  **/
 728 int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 729         char pagebuf[DIFFPAGESIZE];
 730         off_t mapcnt,mapl,maph;
 731         off_t wrlen,rdlen;
 732         off_t pagestart;
 733         off_t offset;
 734
 735         if (!(client->server->flags & F_COPYONWRITE))
 736                 return(rawexpwrite(a,buf,len, client));
 737         DEBUG3("Asked to write %d bytes at %Lu.\n", len, (unsigned long long)a);
 738
 739         mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ;
 740
 741         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
 742                 pagestart=mapcnt*DIFFPAGESIZE ;
 743                 offset=a-pagestart ;
 744                 wrlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 745                         len : (size_t)DIFFPAGESIZE-offset;
 746
 747                 if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
 748                         DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
 749                                (unsigned long)(client->difmap[mapcnt])) ;
 750                         myseek(client->difffile,
 751                                         client->difmap[mapcnt]*DIFFPAGESIZE+offset);
 752                         if (write(client->difffile, buf, wrlen) != wrlen) return -1 ;
 753                 } else { /* the block is not there */
 754                         myseek(client->difffile,client->difffilelen*DIFFPAGESIZE) ;
 755                         client->difmap[mapcnt]=client->difffilelen++ ;
 756                         DEBUG3("Page %Lu is not here, we put it at %lu\n",
 757                                (unsigned long long)mapcnt,
 758                                (unsigned long)(client->difmap[mapcnt]));
 759                         rdlen=DIFFPAGESIZE ;
 760                         if (rdlen+pagestart%(client->server->hunksize) >
 761                                         (client->server->hunksize))
 762                                 rdlen=client->server->hunksize -
 763                                         (pagestart%client->server->hunksize);
 764                         if (rawexpread(pagestart, pagebuf, rdlen, client))
 765                                 return -1;
 766                         memcpy(pagebuf+offset,buf,wrlen) ;
 767                         if (write(client->difffile, pagebuf, DIFFPAGESIZE) !=
 768                                         DIFFPAGESIZE)
 769                                 return -1;
 770                 }
 771                 len-=wrlen ; a+=wrlen ; buf+=wrlen ;
 772         }
 773         return 0;
 774 }
 775
 776 /**
 777  * Do the initial negotiation.
 778  *
 779  * @param client The client we're negotiating with.
 780  **/
 781 void negotiate(CLIENT *client) {
 782         char zeros[300];
 783         u64 size_host;
 784
 785         memset(zeros, 0, 290);
 786         if (write(client->net, INIT_PASSWD, 8) < 0)
 787                 err("Negotiation failed: %m");
 788         cliserv_magic = htonll(cliserv_magic);
 789         if (write(client->net, &cliserv_magic, sizeof(cliserv_magic)) < 0)
 790                 err("Negotiation failed: %m");
 791         size_host = htonll((u64)(client->exportsize));
 792         if (write(client->net, &size_host, 8) < 0)
 793                 err("Negotiation failed: %m");
 794         if (write(client->net, zeros, 128) < 0)
 795                 err("Negotiation failed: %m");
 796 }
 797
 798 /** sending macro. */
 799 #define SEND(net,reply) writeit( net, &reply, sizeof( reply ));
 800 /** error macro. */
 801 #define ERROR(client,reply) { reply.error = htonl(-1); SEND(client->net,reply); reply.error = 0; }
 802 /**
 803  * Serve a file to a single client.
 804  *
 805  * @todo This beast needs to be split up in many tiny little manageable
 806  * pieces. Preferably with a chainsaw.
 807  *
 808  * @param client The client we're going to serve to.
 809  * @return never
 810  **/
 811 int mainloop(CLIENT *client) {
 812         struct nbd_request request;
 813         struct nbd_reply reply;
 814         gboolean go_on=TRUE;
 815 #ifdef DODBG
 816         int i = 0;
 817 #endif
 818         negotiate(client);
 819         DEBUG("Entering request loop!\n");
 820         reply.magic = htonl(NBD_REPLY_MAGIC);
 821         reply.error = 0;
 822         while (go_on) {
 823                 char buf[BUFSIZE];
 824                 size_t len;
 825 #ifdef DODBG
 826                 i++;
 827                 printf("%d: ", i);
 828 #endif
 829                 if (client->server->timeout)
 830                         alarm(client->server->timeout);
 831                 readit(client->net, &request, sizeof(request));
 832                 request.from = ntohll(request.from);
 833                 request.type = ntohl(request.type);
 834
 835                 if (request.type==NBD_CMD_DISC) {
 836                         msg2(LOG_INFO, "Disconnect request received.");
 837                         if (client->difmap) g_free(client->difmap) ;
 838                         if (client->difffile>=0) {
 839                                 close(client->difffile);
 840                                 unlink(client->difffilename);
 841                                 free(client->difffilename);
 842                         }
 843                         go_on=FALSE;
 844                         continue;
 845                 }
 846
 847                 len = ntohl(request.len);
 848
 849                 if (request.magic != htonl(NBD_REQUEST_MAGIC))
 850                         err("Not enough magic.");
 851                 if (len > BUFSIZE + sizeof(struct nbd_reply))
 852                         err("Request too big!");
 853 #ifdef DODBG
 854                 printf("%s from %Lu (%Lu) len %d, ", request.type ? "WRITE" :
 855                                 "READ", (unsigned long long)request.from,
 856                                 (unsigned long long)request.from / 512, len);
 857 #endif
 858                 memcpy(reply.handle, request.handle, sizeof(reply.handle));
 859                 if ((request.from + len) > (OFFT_MAX)) {
 860                         DEBUG("[Number too large!]");
 861                         ERROR(client, reply);
 862                         continue;
 863                 }
 864
 865                 if (((ssize_t)((off_t)request.from + len) > client->exportsize) ||
 866                     ((client->server->flags & F_READONLY) && request.type)) {
 867                         DEBUG("[RANGE!]");
 868                         ERROR(client, reply);
 869                         continue;
 870                 }
 871
 872                 if (request.type==NBD_CMD_WRITE) {
 873                         DEBUG("wr: net->buf, ");
 874                         readit(client->net, buf, len);
 875                         DEBUG("buf->exp, ");
 876                         if ((client->server->flags & F_AUTOREADONLY) ||
 877                                         expwrite(request.from, buf, len,
 878                                                 client)) {
 879                                 DEBUG("Write failed: %m" );
 880                                 ERROR(client, reply);
 881                                 continue;
 882                         }
 883                         SEND(client->net, reply);
 884                         DEBUG("OK!\n");
 885                         continue;
 886                 }
 887                 /* READ */
 888
 889                 DEBUG("exp->buf, ");
 890                 if (expread(request.from, buf + sizeof(struct nbd_reply), len, client)) {
 891                         DEBUG("Read failed: %m");
 892                         ERROR(client, reply);
 893                         continue;
 894                 }
 895
 896                 DEBUG("buf->net, ");
 897                 memcpy(buf, &reply, sizeof(struct nbd_reply));
 898                 writeit(client->net, buf, len + sizeof(struct nbd_reply));
 899                 DEBUG("OK!\n");
 900         }
 901         return 0;
 902 }
 903
 904 /**
 905  * Split a single exportfile into multiple ones, if that was asked.
 906  * @return 0 on success, -1 on failure
 907  * @param client information on the client which we want to split
 908  **/
 909 int splitexport(CLIENT* client) {
 910         off_t i;
 911         int fhandle;
 912
 913         client->export = g_array_new(TRUE, TRUE, sizeof(int));
 914         for (i=0; i<client->exportsize; i+=client->server->hunksize) {
 915                 gchar *tmpname;
 916
 917                 if(client->server->flags & F_MULTIFILE) {
 918                         tmpname=g_strdup_printf("%s.%d", client->exportname,
 919                                         (int)(i/client->server->hunksize));
 920                 } else {
 921                         tmpname=g_strdup(client->exportname);
 922                 }
 923                 DEBUG2( "Opening %s\n", tmpname );
 924                 if((fhandle = open(tmpname, (client->server->flags & F_READONLY) ? O_RDONLY : O_RDWR)) == -1) {
 925                         /* Read WRITE ACCESS was requested by media is only read only */
 926                         client->server->flags |= F_AUTOREADONLY;
 927                         client->server->flags |= F_READONLY;
 928                         if((fhandle = open(tmpname, O_RDONLY)) == -1)
 929                                 err("Could not open exported file: %m");
 930                 }
 931                 g_array_insert_val(client->export,i/client->server->hunksize,fhandle);
 932                 g_free(tmpname);
 933         }
 934         return 0;
 935 }
 936 int copyonwrite_prepare(CLIENT* client)
 937 {
 938         off_t i;
 939         if ((client->difffilename = malloc(1024))==NULL)
 940                 err("Failed to allocate string for diff file name");
 941         snprintf(client->difffilename, 1024, "%s-%s-%d.diff",client->exportname,client->clientname,
 942                 (int)getpid()) ;
 943         client->difffilename[1023]='\0';
 944         msg3(LOG_INFO,"About to create map and diff file %s",client->difffilename) ;
 945         client->difffile=open(client->difffilename,O_RDWR | O_CREAT | O_TRUNC,0600) ;
 946         if (client->difffile<0) err("Could not create diff file (%m)") ;
 947         if ((client->difmap=calloc(client->exportsize/DIFFPAGESIZE,sizeof(u32)))==NULL)
 948                 err("Could not allocate memory") ;
 949         for (i=0;i<client->exportsize/DIFFPAGESIZE;i++) client->difmap[i]=(u32)-1 ;
 950
 951         return 0;
 952 }
 953
 954 /**
 955  * Serve a connection.
 956  *
 957  * @todo allow for multithreading, perhaps use libevent. Not just yet, though;
 958  * follow the road map.
 959  *
 960  * @param client a connected client
 961  **/
 962 void serveconnection(CLIENT *client) {
 963         splitexport(client);
 964
 965         if (!client->server->expected_size) {
 966                 client->exportsize = size_autodetect(g_array_index(client->export,int,0));
 967         } else {
 968                 /* Perhaps we should check first. Not now. */
 969                 client->exportsize = client->server->expected_size;
 970         }
 971         if (client->exportsize > OFFT_MAX) {
 972                 /* uhm, well... In a parallel universe, this *might* be
 973                  * possible... */
 974                 err("Size of exported file is too big\n");
 975         }
 976         else {
 977                 msg3(LOG_INFO, "size of exported file/device is %Lu", (unsigned long long)client->exportsize);
 978         }
 979
 980         if (client->server->flags & F_COPYONWRITE) {
 981                 copyonwrite_prepare(client);
 982         }
 983
 984         setmysockopt(client->net);
 985
 986         mainloop(client);
 987 }
 988
 989 /**
 990  * Find the name of the file we have to serve. This will use g_strdup_printf
 991  * to put the IP address of the client inside a filename containing
 992  * "%s". That name is then written to client->exportname.
 993  *
 994  * @param net A socket connected to an nbd client
 995  * @param client information about the client. The IP address in human-readable
 996  * format will be written to a new char* buffer, the address of which will be
 997  * stored in client->clientname.
 998  **/
 999 void set_peername(int net, CLIENT *client) {
1000         struct sockaddr_in addrin;
1001         int addrinlen = sizeof( addrin );
1002         char *peername ;
1003
1004         if (getpeername(net, (struct sockaddr *) &addrin, (socklen_t *)&addrinlen) < 0)
1005                 err("getsockname failed: %m");
1006         peername = inet_ntoa(addrin.sin_addr);
1007         client->exportname=g_strdup_printf(client->server->exportname, peername);
1008
1009         msg4(LOG_INFO, "connect from %s, assigned file is %s",
1010              peername, client->exportname);
1011         client->clientname=g_strdup(peername);
1012 }
1013
1014 /**
1015  * Destroy a pid_t*
1016  * @param data a pointer to pid_t which should be freed
1017  **/
1018 void destroy_pid_t(gpointer data) {
1019         g_free(data);
1020 }
1021
1022 /**
1023  * Go daemon (unless we specified at compile time that we didn't want this)
1024  * @param serve the first server of our configuration. If its port is zero,
1025  *      then do not daemonize, because we're doing inetd then. This parameter
1026  *      is only used to create a PID file of the form
1027  *      /var/run/nbd-server.&lt;port&gt;.pid; it's not modified in any way.
1028  **/
1029 #if !defined(NODAEMON) && !defined(NOFORK)
1030 void daemonize(SERVER* serve) {
1031         FILE*pidf;
1032
1033         if(daemon(0,0)<0) {
1034                 err("daemon");
1035         }
1036         if(serve) {
1037                 snprintf(pidfname, sizeof(char)*255, "/var/run/nbd-server.%d.pid", serve->port);
1038         } else {
1039                 strncpy(pidfname, "/var/run/nbd-server.pid", sizeof(char)*255);
1040         }
1041         pidf=fopen(pidfname, "w");
1042         if(pidf) {
1043                 fprintf(pidf,"%d\n", (int)getpid());
1044                 fclose(pidf);
1045         } else {
1046                 perror("fopen");
1047                 fprintf(stderr, "Not fatal; continuing");
1048         }
1049 }
1050 #else
1051 #define daemonize(serve)
1052 #endif /* !defined(NODAEMON) && !defined(NOFORK) */
1053
1054 /**
1055  * Connect a server's socket.
1056  *
1057  * @param serve the server we want to connect.
1058  **/
1059 void setup_serve(SERVER *serve) {
1060         struct sockaddr_in addrin;
1061         struct sigaction sa;
1062         int addrinlen = sizeof(addrin);
1063 #ifndef sun
1064         int yes=1;
1065 #else
1066         char yes='1';
1067 #endif /* sun */
1068         if ((serve->socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
1069                 err("socket: %m");
1070
1071         /* lose the pesky "Address already in use" error message */
1072         if (setsockopt(serve->socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
1073                 err("setsockopt SO_REUSEADDR");
1074         }
1075         if (setsockopt(serve->socket,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
1076                 err("setsockopt SO_KEEPALIVE");
1077         }
1078
1079         DEBUG("Waiting for connections... bind, ");
1080         addrin.sin_family = AF_INET;
1081         addrin.sin_port = htons(serve->port);
1082         addrin.sin_addr.s_addr = 0;
1083         if (bind(serve->socket, (struct sockaddr *) &addrin, addrinlen) < 0)
1084                 err("bind: %m");
1085         DEBUG("listen, ");
1086         if (listen(serve->socket, 1) < 0)
1087                 err("listen: %m");
1088         sa.sa_handler = sigchld_handler;
1089         sigemptyset(&sa.sa_mask);
1090         sa.sa_flags = SA_RESTART;
1091         if(sigaction(SIGCHLD, &sa, NULL) == -1)
1092                 err("sigaction: %m");
1093         sa.sa_handler = sigterm_handler;
1094         sigemptyset(&sa.sa_mask);
1095         sa.sa_flags = SA_RESTART;
1096         if(sigaction(SIGTERM, &sa, NULL) == -1)
1097                 err("sigaction: %m");
1098         children=g_hash_table_new_full(g_int_hash, g_int_equal, NULL, destroy_pid_t);
1099 }
1100
1101 /**
1102  * Connect our servers.
1103  **/
1104 void setup_servers(GArray* servers) {
1105         int i;
1106
1107         for(i=0;i<servers->len;i++) {
1108                 setup_serve(&(g_array_index(servers, SERVER, i)));
1109         }
1110 }
1111
1112 /**
1113  * Loop through the available servers, and serve them.
1114  **/
1115 int serveloop(GArray* servers) {
1116         struct sockaddr_in addrin;
1117         socklen_t addrinlen=sizeof(addrin);
1118         SERVER *serve;
1119         int i, max, sock;
1120         fd_set mset, rset;
1121         struct timeval tv;
1122
1123         /*
1124          * Set up the master fd_set. The set of descriptors we need
1125          * to select() for never changes anyway and it buys us a *lot*
1126          * of time to only build this once. However, if we ever choose
1127          * to not fork() for clients anymore, we may have to revisit
1128          * this.
1129          */
1130         max=0;
1131         FD_ZERO(&mset);
1132         for(i=0;i<servers->len;i++) {
1133                 sock=(g_array_index(servers, SERVER, i)).socket;
1134                 FD_SET(sock, &mset);
1135                 max=sock>max?sock:max;
1136         }
1137         for(;;) {
1138                 CLIENT *client;
1139                 int net;
1140                 pid_t *pid;
1141
1142                 memcpy(&rset, &mset, sizeof(fd_set));
1143                 tv.tv_sec=0;
1144                 tv.tv_usec=500;
1145                 if(select(max+1, &rset, NULL, NULL, &tv)>0) {
1146                         DEBUG("accept, ");
1147                         for(i=0;i<servers->len;i++) {
1148                                 serve=&(g_array_index(servers, SERVER, i));
1149                                 if(FD_ISSET(serve->socket, &rset)) {
1150                                         if ((net=accept(serve->socket, (struct sockaddr *) &addrin, &addrinlen)) < 0)
1151                                                 err("accept: %m");
1152
1153                                         client = g_malloc(sizeof(CLIENT));
1154                                         client->server=serve;
1155                                         client->exportsize=OFFT_MAX;
1156                                         client->net=net;
1157                                         set_peername(net, client);
1158                                         if (!authorized_client(client)) {
1159                                                 msg2(LOG_INFO,"Unauthorized client") ;
1160                                                 close(net);
1161                                                 continue;
1162                                         }
1163                                         msg2(LOG_INFO,"Authorized client") ;
1164                                         pid=g_malloc(sizeof(pid_t));
1165 #ifndef NOFORK
1166                                         if ((*pid=fork())<0) {
1167                                                 msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
1168                                                 close(net);
1169                                                 continue;
1170                                         }
1171                                         if (*pid>0) { /* parent */
1172                                                 close(net);
1173                                                 g_hash_table_insert(children, pid, pid);
1174                                                 continue;
1175                                         }
1176                                         /* child */
1177                                         g_hash_table_destroy(children);
1178                                         for(i=0;i<servers->len,serve=&(g_array_index(servers, SERVER, i)),i++) {
1179                                                 close(serve->socket);
1180                                         }
1181                                         /* FALSE does not free the
1182                                         actual data. This is required,
1183                                         because the client has a
1184                                         direct reference into that
1185                                         data, and otherwise we get a
1186                                         segfault... */
1187                                         g_array_free(servers, FALSE);
1188 #endif // NOFORK
1189                                         msg2(LOG_INFO,"Starting to serve");
1190                                         serveconnection(client);
1191                                 }
1192                         }
1193                 }
1194         }
1195 }
1196
1197 /**
1198  * Main entry point...
1199  **/
1200 int main(int argc, char *argv[]) {
1201         SERVER *serve;
1202         GArray *servers;
1203         GError *err=NULL;
1204
1205         if (sizeof( struct nbd_request )!=28) {
1206                 fprintf(stderr,"Bad size of structure. Alignment problems?\n");
1207                 exit(-1) ;
1208         }
1209
1210         logging();
1211         config_file_pos = g_strdup(CFILE);
1212         serve=cmdline(argc, argv);
1213         servers = parse_cfile(config_file_pos, &err);
1214         if(!servers) {
1215                 g_critical("Could not parse command file: %s", err->message);
1216         }
1217         if(serve) {
1218                 g_array_append_val(servers, *serve);
1219                 g_free(serve);
1220         }
1221
1222 /* We don't support this at this time */
1223 #if 0
1224         if (!(serve->port)) {
1225                 CLIENT *client;
1226 #ifndef ISSERVER
1227                 /* You really should define ISSERVER if you're going to use
1228                  * inetd mode, but if you don't, closing stdout and stderr
1229                  * (which inetd had connected to the client socket) will let it
1230                  * work. */
1231                 close(1);
1232                 close(2);
1233                 open("/dev/null", O_WRONLY);
1234                 open("/dev/null", O_WRONLY);
1235 #endif
1236                 client=g_malloc(sizeof(CLIENT));
1237                 client->server=serve;
1238                 client->net=0;
1239                 client->exportsize=OFFT_MAX;
1240                 set_peername(0,client);
1241                 serveconnection(client);
1242                 return 0;
1243         }
1244 #endif
1245         if((!serve) && (!servers)) {
1246                 g_message("Nothing to do! Bye!");
1247                 exit(EXIT_FAILURE);
1248         }
1249         daemonize(serve);
1250         setup_servers(servers);
1251         serveloop(servers);
1252         return 0 ;
1253 }