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  * 16/03/2010 - Add IPv6 support.
  53  *      Kitt Tientanopajai <kitt@kitty.in.th>
  54  *      Neutron Soutmun <neo.neutron@gmail.com>
  55  *      Suriya Soutmun <darksolar@gmail.com>
  56  */
  57
  58 /* Includes LFS defines, which defines behaviours of some of the following
  59  * headers, so must come before those */
  60 #include "lfs.h"
  61
  62 #include <sys/types.h>
  63 #include <sys/socket.h>
  64 #include <sys/stat.h>
  65 #include <sys/select.h>         /* select */
  66 #include <sys/wait.h>           /* wait */
  67 #ifdef HAVE_SYS_IOCTL_H
  68 #include <sys/ioctl.h>
  69 #endif
  70 #include <sys/param.h>
  71 #ifdef HAVE_SYS_MOUNT_H
  72 #include <sys/mount.h>          /* For BLKGETSIZE */
  73 #endif
  74 #include <signal.h>             /* sigaction */
  75 #include <errno.h>
  76 #include <netinet/tcp.h>
  77 #include <netinet/in.h>
  78 #include <netdb.h>
  79 #include <syslog.h>
  80 #include <unistd.h>
  81 #include <stdio.h>
  82 #include <stdlib.h>
  83 #include <string.h>
  84 #include <fcntl.h>
  85 #include <arpa/inet.h>
  86 #include <strings.h>
  87 #include <dirent.h>
  88 #include <unistd.h>
  89 #include <getopt.h>
  90 #include <pwd.h>
  91 #include <grp.h>
  92
  93 #include <glib.h>
  94
  95 /* used in cliserv.h, so must come first */
  96 #define MY_NAME "nbd_server"
  97 #include "cliserv.h"
  98
  99 /** Default position of the config file */
 100 #ifndef SYSCONFDIR
 101 #define SYSCONFDIR "/etc"
 102 #endif
 103 #define CFILE SYSCONFDIR "/nbd-server/config"
 104
 105 /** Where our config file actually is */
 106 gchar* config_file_pos;
 107
 108 /** What user we're running as */
 109 gchar* runuser=NULL;
 110 /** What group we're running as */
 111 gchar* rungroup=NULL;
 112
 113 /** Logging macros, now nothing goes to syslog unless you say ISSERVER */
 114 #ifdef ISSERVER
 115 #define msg2(a,b) syslog(a,b)
 116 #define msg3(a,b,c) syslog(a,b,c)
 117 #define msg4(a,b,c,d) syslog(a,b,c,d)
 118 #else
 119 #define msg2(a,b) g_message(b)
 120 #define msg3(a,b,c) g_message(b,c)
 121 #define msg4(a,b,c,d) g_message(b,c,d)
 122 #endif
 123
 124 /* Debugging macros */
 125 //#define DODBG
 126 #ifdef DODBG
 127 #define DEBUG( a ) printf( a )
 128 #define DEBUG2( a,b ) printf( a,b )
 129 #define DEBUG3( a,b,c ) printf( a,b,c )
 130 #define DEBUG4( a,b,c,d ) printf( a,b,c,d )
 131 #else
 132 #define DEBUG( a )
 133 #define DEBUG2( a,b )
 134 #define DEBUG3( a,b,c )
 135 #define DEBUG4( a,b,c,d )
 136 #endif
 137 #ifndef PACKAGE_VERSION
 138 #define PACKAGE_VERSION ""
 139 #endif
 140 /**
 141  * The highest value a variable of type off_t can reach. This is a signed
 142  * integer, so set all bits except for the leftmost one.
 143  **/
 144 #define OFFT_MAX ~((off_t)1<<(sizeof(off_t)*8-1))
 145 #define LINELEN 256       /**< Size of static buffer used to read the
 146                                authorization file (yuck) */
 147 #define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */
 148 #define DIFFPAGESIZE 4096 /**< diff file uses those chunks */
 149 #define F_READONLY 1      /**< flag to tell us a file is readonly */
 150 #define F_MULTIFILE 2     /**< flag to tell us a file is exported using -m */
 151 #define F_COPYONWRITE 4   /**< flag to tell us a file is exported using
 152                             copyonwrite */
 153 #define F_AUTOREADONLY 8  /**< flag to tell us a file is set to autoreadonly */
 154 #define F_SPARSE 16       /**< flag to tell us copyronwrite should use a sparse file */
 155 #define F_SDP 32          /**< flag to tell us the export should be done using the Socket Direct Protocol for RDMA */
 156 #define F_SYNC 64         /**< Whether to fsync() after a write */
 157 GHashTable *children;
 158 char pidfname[256]; /**< name of our PID file */
 159 char pidftemplate[256]; /**< template to be used for the filename of the PID file */
 160 char default_authname[] = SYSCONFDIR "/nbd-server/allow"; /**< default name of allow file */
 161
 162 /**
 163  * Types of virtuatlization
 164  **/
 165 typedef enum {
 166         VIRT_NONE=0,    /**< No virtualization */
 167         VIRT_IPLIT,     /**< Literal IP address as part of the filename */
 168         VIRT_IPHASH,    /**< Replacing all dots in an ip address by a / before
 169                              doing the same as in IPLIT */
 170         VIRT_CIDR,      /**< Every subnet in its own directory */
 171 } VIRT_STYLE;
 172
 173 /**
 174  * Variables associated with a server.
 175  **/
 176 typedef struct {
 177         gchar* exportname;    /**< (unprocessed) filename of the file we're exporting */
 178         off_t expected_size; /**< size of the exported file as it was told to
 179                                us through configuration */
 180         gchar* listenaddr;   /**< The IP address we're listening on */
 181         unsigned int port;   /**< port we're exporting this file at */
 182         char* authname;      /**< filename of the authorization file */
 183         int flags;           /**< flags associated with this exported file */
 184         int socket;          /**< The socket of this server. */
 185         int socket_family;   /**< family of the socket */
 186         VIRT_STYLE virtstyle;/**< The style of virtualization, if any */
 187         uint8_t cidrlen;     /**< The length of the mask when we use
 188                                   CIDR-style virtualization */
 189         gchar* prerun;       /**< command to be ran after connecting a client,
 190                                   but before starting to serve */
 191         gchar* postrun;      /**< command that will be ran after the client
 192                                   disconnects */
 193 } SERVER;
 194
 195 /**
 196  * Variables associated with a client socket.
 197  **/
 198 typedef struct {
 199         int fhandle;      /**< file descriptor */
 200         off_t startoff;   /**< starting offset of this file */
 201 } FILE_INFO;
 202
 203 typedef struct {
 204         off_t exportsize;    /**< size of the file we're exporting */
 205         char *clientname;    /**< peer */
 206         char *exportname;    /**< (processed) filename of the file we're exporting */
 207         GArray *export;    /**< array of FILE_INFO of exported files;
 208                                array size is always 1 unless we're
 209                                doing the multiple file option */
 210         int net;             /**< The actual client socket */
 211         SERVER *server;      /**< The server this client is getting data from */
 212         char* difffilename;  /**< filename of the copy-on-write file, if any */
 213         int difffile;        /**< filedescriptor of copyonwrite file. @todo
 214                                shouldn't this be an array too? (cfr export) Or
 215                                make -m and -c mutually exclusive */
 216         u32 difffilelen;     /**< number of pages in difffile */
 217         u32 *difmap;         /**< see comment on the global difmap for this one */
 218 } CLIENT;
 219
 220 /**
 221  * Type of configuration file values
 222  **/
 223 typedef enum {
 224         PARAM_INT,              /**< This parameter is an integer */
 225         PARAM_STRING,           /**< This parameter is a string */
 226         PARAM_BOOL,             /**< This parameter is a boolean */
 227 } PARAM_TYPE;
 228
 229 /**
 230  * Configuration file values
 231  **/
 232 typedef struct {
 233         gchar *paramname;       /**< Name of the parameter, as it appears in
 234                                   the config file */
 235         gboolean required;      /**< Whether this is a required (as opposed to
 236                                   optional) parameter */
 237         PARAM_TYPE ptype;       /**< Type of the parameter. */
 238         gpointer target;        /**< Pointer to where the data of this
 239                                   parameter should be written. If ptype is
 240                                   PARAM_BOOL, the data is or'ed rather than
 241                                   overwritten. */
 242         gint flagval;           /**< Flag mask for this parameter in case ptype
 243                                   is PARAM_BOOL. */
 244 } PARAM;
 245
 246 /**
 247  * Check whether a client is allowed to connect. Works with an authorization
 248  * file which contains one line per machine, no wildcards.
 249  *
 250  * @param opts The client who's trying to connect.
 251  * @return 0 - authorization refused, 1 - OK
 252  **/
 253 int authorized_client(CLIENT *opts) {
 254         const char *ERRMSG="Invalid entry '%s' in authfile '%s', so, refusing all connections.";
 255         FILE *f ;
 256         char line[LINELEN];
 257         char *tmp;
 258         struct in_addr addr;
 259         struct in_addr client;
 260         struct in_addr cltemp;
 261         int len;
 262
 263         if ((f=fopen(opts->server->authname,"r"))==NULL) {
 264                 msg4(LOG_INFO,"Can't open authorization file %s (%s).",
 265                      opts->server->authname,strerror(errno)) ;
 266                 return 1 ;
 267         }
 268
 269         inet_aton(opts->clientname, &client);
 270         while (fgets(line,LINELEN,f)!=NULL) {
 271                 if((tmp=index(line, '/'))) {
 272                         if(strlen(line)<=tmp-line) {
 273                                 msg4(LOG_CRIT, ERRMSG, line, opts->server->authname);
 274                                 return 0;
 275                         }
 276                         *(tmp++)=0;
 277                         if(inet_aton(line,&addr)) {
 278                                 msg4(LOG_CRIT, ERRMSG, line, opts->server->authname);
 279                                 return 0;
 280                         }
 281                         len=strtol(tmp, NULL, 0);
 282                         addr.s_addr>>=32-len;
 283                         addr.s_addr<<=32-len;
 284                         memcpy(&cltemp,&client,sizeof(client));
 285                         cltemp.s_addr>>=32-len;
 286                         cltemp.s_addr<<=32-len;
 287                         if(addr.s_addr == cltemp.s_addr) {
 288                                 return 1;
 289                         }
 290                 }
 291                 if (strncmp(line,opts->clientname,strlen(opts->clientname))==0) {
 292                         fclose(f);
 293                         return 1;
 294                 }
 295         }
 296         fclose(f);
 297         return 0;
 298 }
 299
 300 /**
 301  * Read data from a file descriptor into a buffer
 302  *
 303  * @param f a file descriptor
 304  * @param buf a buffer
 305  * @param len the number of bytes to be read
 306  **/
 307 inline void readit(int f, void *buf, size_t len) {
 308         ssize_t res;
 309         while (len > 0) {
 310                 DEBUG("*");
 311                 if ((res = read(f, buf, len)) <= 0) {
 312                         if(errno != EAGAIN) {
 313                                 err("Read failed: %m");
 314                         }
 315                 } else {
 316                         len -= res;
 317                         buf += res;
 318                 }
 319         }
 320 }
 321
 322 /**
 323  * Write data from a buffer into a filedescriptor
 324  *
 325  * @param f a file descriptor
 326  * @param buf a buffer containing data
 327  * @param len the number of bytes to be written
 328  **/
 329 inline void writeit(int f, void *buf, size_t len) {
 330         ssize_t res;
 331         while (len > 0) {
 332                 DEBUG("+");
 333                 if ((res = write(f, buf, len)) <= 0)
 334                         err("Send failed: %m");
 335                 len -= res;
 336                 buf += res;
 337         }
 338 }
 339
 340 /**
 341  * Print out a message about how to use nbd-server. Split out to a separate
 342  * function so that we can call it from multiple places
 343  */
 344 void usage() {
 345         printf("This is nbd-server version " VERSION "\n");
 346         printf("Usage: [ip:|ip6@]port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-C configuration file] [-p PID file name] [-o section name]\n"
 347                "\t-r|--read-only\t\tread only\n"
 348                "\t-m|--multi-file\t\tmultiple file\n"
 349                "\t-c|--copy-on-write\tcopy on write\n"
 350                "\t-C|--config-file\tspecify an alternate configuration file\n"
 351                "\t-l|--authorize-file\tfile with list of hosts that are allowed to\n\t\t\t\tconnect.\n"
 352                "\t-p|--pid-file\t\tspecify a filename to write our PID to\n"
 353                "\t-o|--output-config\toutput a config file section for what you\n\t\t\t\tspecified on the command line, with the\n\t\t\t\tspecified section name\n\n"
 354                "\tif port is set to 0, stdin is used (for running from inetd)\n"
 355                "\tif file_to_export contains '%%s', it is substituted with the IP\n"
 356                "\t\taddress of the machine trying to connect\n"
 357                "\tif ip is set, it contains the local IP address on which we're listening.\n\tif not, the server will listen on all local IP addresses\n");
 358         printf("Using configuration file %s\n", CFILE);
 359 }
 360
 361 /* Dumps a config file section of the given SERVER*, and exits. */
 362 void dump_section(SERVER* serve, gchar* section_header) {
 363         printf("[%s]\n", section_header);
 364         printf("\texportname = %s\n", serve->exportname);
 365         printf("\tlistenaddr = %s\n", serve->listenaddr);
 366         printf("\tport = %d\n", serve->port);
 367         if(serve->flags & F_READONLY) {
 368                 printf("\treadonly = true\n");
 369         }
 370         if(serve->flags & F_MULTIFILE) {
 371                 printf("\tmultifile = true\n");
 372         }
 373         if(serve->flags & F_COPYONWRITE) {
 374                 printf("\tcopyonwrite = true\n");
 375         }
 376         if(serve->expected_size) {
 377                 printf("\tfilesize = %lld\n", (long long int)serve->expected_size);
 378         }
 379         if(serve->authname) {
 380                 printf("\tauthfile = %s\n", serve->authname);
 381         }
 382         exit(EXIT_SUCCESS);
 383 }
 384
 385 /**
 386  * Parse the command line.
 387  *
 388  * @param argc the argc argument to main()
 389  * @param argv the argv argument to main()
 390  **/
 391 SERVER* cmdline(int argc, char *argv[]) {
 392         int i=0;
 393         int nonspecial=0;
 394         int c;
 395         struct option long_options[] = {
 396                 {"read-only", no_argument, NULL, 'r'},
 397                 {"multi-file", no_argument, NULL, 'm'},
 398                 {"copy-on-write", no_argument, NULL, 'c'},
 399                 {"authorize-file", required_argument, NULL, 'l'},
 400                 {"config-file", required_argument, NULL, 'C'},
 401                 {"pid-file", required_argument, NULL, 'p'},
 402                 {"output-config", required_argument, NULL, 'o'},
 403                 {0,0,0,0}
 404         };
 405         SERVER *serve;
 406         off_t es;
 407         size_t last;
 408         char suffix;
 409         gboolean do_output=FALSE;
 410         gchar* section_header="";
 411         gchar** addr_port;
 412
 413         if(argc==1) {
 414                 return NULL;
 415         }
 416         serve=g_new0(SERVER, 1);
 417         serve->authname = g_strdup(default_authname);
 418         serve->virtstyle=VIRT_IPLIT;
 419         while((c=getopt_long(argc, argv, "-C:cl:mo:rp:", long_options, &i))>=0) {
 420                 switch (c) {
 421                 case 1:
 422                         /* non-option argument */
 423                         switch(nonspecial++) {
 424                         case 0:
 425                                 if(strchr(optarg, ':') == strrchr(optarg, ':')) {
 426                                         addr_port=g_strsplit(optarg, ":", 2);
 427
 428                                         /* Check for "@" - maybe user using this separator
 429                                                  for IPv4 address */
 430                                         if(!addr_port[1]) {
 431                                                 g_strfreev(addr_port);
 432                                                 addr_port=g_strsplit(optarg, "@", 2);
 433                                         }
 434                                 } else {
 435                                         addr_port=g_strsplit(optarg, "@", 2);
 436                                 }
 437
 438                                 if(addr_port[1]) {
 439                                         serve->port=strtol(addr_port[1], NULL, 0);
 440                                         serve->listenaddr=g_strdup(addr_port[0]);
 441                                 } else {
 442                                         serve->listenaddr=NULL;
 443                                         serve->port=strtol(addr_port[0], NULL, 0);
 444                                 }
 445                                 g_strfreev(addr_port);
 446                                 break;
 447                         case 1:
 448                                 serve->exportname = g_strdup(optarg);
 449                                 if(serve->exportname[0] != '/') {
 450                                         fprintf(stderr, "E: The to be exported file needs to be an absolute filename!\n");
 451                                         exit(EXIT_FAILURE);
 452                                 }
 453                                 break;
 454                         case 2:
 455                                 last=strlen(optarg)-1;
 456                                 suffix=optarg[last];
 457                                 if (suffix == 'k' || suffix == 'K' ||
 458                                     suffix == 'm' || suffix == 'M')
 459                                         optarg[last] = '\0';
 460                                 es = (off_t)atoll(optarg);
 461                                 switch (suffix) {
 462                                         case 'm':
 463                                         case 'M':  es <<= 10;
 464                                         case 'k':
 465                                         case 'K':  es <<= 10;
 466                                         default :  break;
 467                                 }
 468                                 serve->expected_size = es;
 469                                 break;
 470                         }
 471                         break;
 472                 case 'r':
 473                         serve->flags |= F_READONLY;
 474                         break;
 475                 case 'm':
 476                         serve->flags |= F_MULTIFILE;
 477                         break;
 478                 case 'o':
 479                         do_output = TRUE;
 480                         section_header = g_strdup(optarg);
 481                         break;
 482                 case 'p':
 483                         strncpy(pidftemplate, optarg, 256);
 484                         break;
 485                 case 'c':
 486                         serve->flags |=F_COPYONWRITE;
 487                         break;
 488                 case 'C':
 489                         g_free(config_file_pos);
 490                         config_file_pos=g_strdup(optarg);
 491                         break;
 492                 case 'l':
 493                         g_free(serve->authname);
 494                         serve->authname=g_strdup(optarg);
 495                         break;
 496                 default:
 497                         usage();
 498                         exit(EXIT_FAILURE);
 499                         break;
 500                 }
 501         }
 502         /* What's left: the port to export, the name of the to be exported
 503          * file, and, optionally, the size of the file, in that order. */
 504         if(nonspecial<2) {
 505                 g_free(serve);
 506                 serve=NULL;
 507         }
 508         if(do_output) {
 509                 if(!serve) {
 510                         g_critical("Need a complete configuration on the command line to output a config file section!");
 511                         exit(EXIT_FAILURE);
 512                 }
 513                 dump_section(serve, section_header);
 514         }
 515         return serve;
 516 }
 517
 518 /**
 519  * Error codes for config file parsing
 520  **/
 521 typedef enum {
 522         CFILE_NOTFOUND,         /**< The configuration file is not found */
 523         CFILE_MISSING_GENERIC,  /**< The (required) group "generic" is missing */
 524         CFILE_KEY_MISSING,      /**< A (required) key is missing */
 525         CFILE_VALUE_INVALID,    /**< A value is syntactically invalid */
 526         CFILE_VALUE_UNSUPPORTED,/**< A value is not supported in this build */
 527         CFILE_PROGERR,          /**< Programmer error */
 528         CFILE_NO_EXPORTS        /**< A config file was specified that does not
 529                                      define any exports */
 530 } CFILE_ERRORS;
 531
 532 /**
 533  * Remove a SERVER from memory. Used from the hash table
 534  **/
 535 void remove_server(gpointer s) {
 536         SERVER *server;
 537
 538         server=(SERVER*)s;
 539         g_free(server->exportname);
 540         if(server->authname)
 541                 g_free(server->authname);
 542         if(server->listenaddr)
 543                 g_free(server->listenaddr);
 544         if(server->prerun)
 545                 g_free(server->prerun);
 546         if(server->postrun)
 547                 g_free(server->postrun);
 548         g_free(server);
 549 }
 550
 551 /**
 552  * duplicate server
 553  * @param s the old server we want to duplicate
 554  * @return new duplicated server
 555  **/
 556 SERVER* dup_serve(SERVER *s) {
 557         SERVER *serve = NULL;
 558
 559         serve=g_new0(SERVER, 1);
 560         if (serve == NULL)
 561                 return NULL;
 562
 563         if (s->exportname)
 564                 serve->exportname = g_strdup(s->exportname);
 565
 566         serve->expected_size = s->expected_size;
 567
 568         if (s->listenaddr)
 569                 serve->listenaddr = g_strdup(s->listenaddr);
 570
 571         serve->port = s->port;
 572
 573         if (s->authname)
 574                 serve->authname = strdup(s->authname);
 575
 576         serve->flags = s->flags;
 577         serve->socket = serve->socket;
 578         serve->socket_family = serve->socket_family;
 579         serve->cidrlen = s->cidrlen;
 580
 581         if (s->prerun)
 582                 serve->prerun = g_strdup(s->prerun);
 583
 584         if (s->postrun)
 585                 serve->postrun = g_strdup(s->postrun);
 586
 587         return serve;
 588 }
 589
 590 /**
 591  * append new server to array
 592  * @param s server
 593  * @param a server array
 594  * @return 0 success, -1 error
 595  */
 596 int append_serve(SERVER *s, GArray *a)
 597 {
 598         SERVER *ns = NULL;
 599         struct addrinfo hints;
 600         struct addrinfo *ai = NULL;
 601         struct addrinfo *rp = NULL;
 602         char   host[NI_MAXHOST];
 603         gchar  *port = NULL;
 604         int e;
 605         int ret;
 606
 607         if(!s) {
 608                 err("Invalid parsing server");
 609                 return -1;
 610         }
 611
 612         port = g_strdup_printf("%d", s->port);
 613
 614         memset(&hints,'\0',sizeof(hints));
 615         hints.ai_family = AF_UNSPEC;
 616         hints.ai_socktype = SOCK_STREAM;
 617         hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
 618         hints.ai_protocol = IPPROTO_TCP;
 619
 620         e = getaddrinfo(s->listenaddr, port, &hints, &ai);
 621
 622         if (port)
 623                 g_free(port);
 624
 625         if(e == 0) {
 626                 for (rp = ai; rp != NULL; rp = rp->ai_next) {
 627                         e = getnameinfo(rp->ai_addr, rp->ai_addrlen, host, sizeof(host), NULL, 0, NI_NUMERICHOST);
 628
 629                         if (e != 0) { // error
 630                                 fprintf(stderr, "getnameinfo: %s\n", gai_strerror(e));
 631                                 continue;
 632                         }
 633
 634                         // duplicate server and set listenaddr to resolved IP address
 635                         ns = dup_serve (s);
 636                         if (ns) {
 637                                 ns->listenaddr = g_strdup(host);
 638                                 ns->socket_family = rp->ai_family;
 639                                 g_array_append_val(a, *ns);
 640                                 free(ns);
 641                                 ns = NULL;
 642                         }
 643                 }
 644
 645                 ret = 0;
 646         } else {
 647                 fprintf(stderr, "getaddrinfo failed on listen host/address: %s (%s)\n", s->listenaddr ? s->listenaddr : "any", gai_strerror(e));
 648                 ret = -1;
 649         }
 650
 651         if (ai)
 652                 freeaddrinfo(ai);
 653
 654         return ret;
 655 }
 656
 657 /**
 658  * Parse the config file.
 659  *
 660  * @param f the name of the config file
 661  * @param e a GError. @see CFILE_ERRORS for what error values this function can
 662  *      return.
 663  * @return a Array of SERVER* pointers, If the config file is empty or does not
 664  *      exist, returns an empty GHashTable; if the config file contains an
 665  *      error, returns NULL, and e is set appropriately
 666  **/
 667 GArray* parse_cfile(gchar* f, GError** e) {
 668         const char* DEFAULT_ERROR = "Could not parse %s in group %s: %s";
 669         const char* MISSING_REQUIRED_ERROR = "Could not find required value %s in group %s: %s";
 670         SERVER s;
 671         gchar *virtstyle=NULL;
 672         PARAM lp[] = {
 673                 { "exportname", TRUE,   PARAM_STRING,   NULL, 0 },
 674                 { "port",       TRUE,   PARAM_INT,      NULL, 0 },
 675                 { "authfile",   FALSE,  PARAM_STRING,   NULL, 0 },
 676                 { "filesize",   FALSE,  PARAM_INT,      NULL, 0 },
 677                 { "virtstyle",  FALSE,  PARAM_STRING,   NULL, 0 },
 678                 { "prerun",     FALSE,  PARAM_STRING,   NULL, 0 },
 679                 { "postrun",    FALSE,  PARAM_STRING,   NULL, 0 },
 680                 { "readonly",   FALSE,  PARAM_BOOL,     NULL, F_READONLY },
 681                 { "multifile",  FALSE,  PARAM_BOOL,     NULL, F_MULTIFILE },
 682                 { "copyonwrite", FALSE, PARAM_BOOL,     NULL, F_COPYONWRITE },
 683                 { "sparse_cow", FALSE,  PARAM_BOOL,     NULL, F_SPARSE },
 684                 { "sdp",        FALSE,  PARAM_BOOL,     NULL, F_SDP },
 685                 { "sync",       FALSE,  PARAM_BOOL,     NULL, F_SYNC },
 686                 { "listenaddr", FALSE,  PARAM_STRING,   NULL, 0 },
 687         };
 688         const int lp_size=sizeof(lp)/sizeof(PARAM);
 689         PARAM gp[] = {
 690                 { "user",       FALSE, PARAM_STRING,    &runuser,       0 },
 691                 { "group",      FALSE, PARAM_STRING,    &rungroup,      0 },
 692         };
 693         PARAM* p=gp;
 694         int p_size=sizeof(gp)/sizeof(PARAM);
 695         GKeyFile *cfile;
 696         GError *err = NULL;
 697         const char *err_msg=NULL;
 698         GQuark errdomain;
 699         GArray *retval=NULL;
 700         gchar **groups;
 701         gboolean value;
 702         gchar* startgroup;
 703         gint i;
 704         gint j;
 705
 706         errdomain = g_quark_from_string("parse_cfile");
 707         cfile = g_key_file_new();
 708         retval = g_array_new(FALSE, TRUE, sizeof(SERVER));
 709         if(!g_key_file_load_from_file(cfile, f, G_KEY_FILE_KEEP_COMMENTS |
 710                         G_KEY_FILE_KEEP_TRANSLATIONS, &err)) {
 711                 g_set_error(e, errdomain, CFILE_NOTFOUND, "Could not open config file %s.", f);
 712                 g_key_file_free(cfile);
 713                 return retval;
 714         }
 715         startgroup = g_key_file_get_start_group(cfile);
 716         if(!startgroup || strcmp(startgroup, "generic")) {
 717                 g_set_error(e, errdomain, CFILE_MISSING_GENERIC, "Config file does not contain the [generic] group!");
 718                 g_key_file_free(cfile);
 719                 return NULL;
 720         }
 721         groups = g_key_file_get_groups(cfile, NULL);
 722         for(i=0;groups[i];i++) {
 723                 memset(&s, '\0', sizeof(SERVER));
 724                 lp[0].target=&(s.exportname);
 725                 lp[1].target=&(s.port);
 726                 lp[2].target=&(s.authname);
 727                 lp[3].target=&(s.expected_size);
 728                 lp[4].target=&(virtstyle);
 729                 lp[5].target=&(s.prerun);
 730                 lp[6].target=&(s.postrun);
 731                 lp[7].target=lp[8].target=lp[9].target=
 732                                 lp[10].target=lp[11].target=
 733                                 lp[12].target=&(s.flags);
 734                 lp[13].target=&(s.listenaddr);
 735
 736                 /* After the [generic] group, start parsing exports */
 737                 if(i==1) {
 738                         p=lp;
 739                         p_size=lp_size;
 740                 }
 741                 for(j=0;j<p_size;j++) {
 742                         g_assert(p[j].target != NULL);
 743                         g_assert(p[j].ptype==PARAM_INT||p[j].ptype==PARAM_STRING||p[j].ptype==PARAM_BOOL);
 744                         switch(p[j].ptype) {
 745                                 case PARAM_INT:
 746                                         *((gint*)p[j].target) =
 747                                                 g_key_file_get_integer(cfile,
 748                                                                 groups[i],
 749                                                                 p[j].paramname,
 750                                                                 &err);
 751                                         break;
 752                                 case PARAM_STRING:
 753                                         *((gchar**)p[j].target) =
 754                                                 g_key_file_get_string(cfile,
 755                                                                 groups[i],
 756                                                                 p[j].paramname,
 757                                                                 &err);
 758                                         break;
 759                                 case PARAM_BOOL:
 760                                         value = g_key_file_get_boolean(cfile,
 761                                                         groups[i],
 762                                                         p[j].paramname, &err);
 763                                         if(!err) {
 764                                                 if(value) {
 765                                                         *((gint*)p[j].target) |= p[j].flagval;
 766                                                 } else {
 767                                                         *((gint*)p[j].target) &= ~(p[j].flagval);
 768                                                 }
 769                                         }
 770                                         break;
 771                         }
 772                         if(err) {
 773                                 if(err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
 774                                         if(!p[j].required) {
 775                                                 /* Ignore not-found error for optional values */
 776                                                 g_clear_error(&err);
 777                                                 continue;
 778                                         } else {
 779                                                 err_msg = MISSING_REQUIRED_ERROR;
 780                                         }
 781                                 } else {
 782                                         err_msg = DEFAULT_ERROR;
 783                                 }
 784                                 g_set_error(e, errdomain, CFILE_VALUE_INVALID, err_msg, p[j].paramname, groups[i], err->message);
 785                                 g_array_free(retval, TRUE);
 786                                 g_error_free(err);
 787                                 g_key_file_free(cfile);
 788                                 return NULL;
 789                         }
 790                 }
 791                 if(virtstyle) {
 792                         if(!strncmp(virtstyle, "none", 4)) {
 793                                 s.virtstyle=VIRT_NONE;
 794                         } else if(!strncmp(virtstyle, "ipliteral", 9)) {
 795                                 s.virtstyle=VIRT_IPLIT;
 796                         } else if(!strncmp(virtstyle, "iphash", 6)) {
 797                                 s.virtstyle=VIRT_IPHASH;
 798                         } else if(!strncmp(virtstyle, "cidrhash", 8)) {
 799                                 s.virtstyle=VIRT_CIDR;
 800                                 if(strlen(virtstyle)<10) {
 801                                         g_set_error(e, errdomain, CFILE_VALUE_INVALID, "Invalid value %s for parameter virtstyle in group %s: missing length", virtstyle, groups[i]);
 802                                         g_array_free(retval, TRUE);
 803                                         g_key_file_free(cfile);
 804                                         return NULL;
 805                                 }
 806                                 s.cidrlen=strtol(virtstyle+8, NULL, 0);
 807                         } else {
 808                                 g_set_error(e, errdomain, CFILE_VALUE_INVALID, "Invalid value %s for parameter virtstyle in group %s", virtstyle, groups[i]);
 809                                 g_array_free(retval, TRUE);
 810                                 g_key_file_free(cfile);
 811                                 return NULL;
 812                         }
 813                 } else {
 814                         s.virtstyle=VIRT_IPLIT;
 815                 }
 816                 /* Don't need to free this, it's not our string */
 817                 virtstyle=NULL;
 818                 /* Don't append values for the [generic] group */
 819                 if(i>0) {
 820                         s.socket_family = AF_UNSPEC;
 821
 822                         append_serve(&s, retval);
 823                 }
 824 #ifndef WITH_SDP
 825                 if(s.flags & F_SDP) {
 826                         g_set_error(e, errdomain, CFILE_VALUE_UNSUPPORTED, "This nbd-server was built without support for SDP, yet group %s uses it", groups[i]);
 827                         g_array_free(retval, TRUE);
 828                         g_key_file_free(cfile);
 829                         return NULL;
 830                 }
 831 #endif
 832         }
 833         if(i==1) {
 834                 g_set_error(e, errdomain, CFILE_NO_EXPORTS, "The config file does not specify any exports");
 835         }
 836         g_key_file_free(cfile);
 837         return retval;
 838 }
 839
 840 /**
 841  * Signal handler for SIGCHLD
 842  * @param s the signal we're handling (must be SIGCHLD, or something
 843  * is severely wrong)
 844  **/
 845 void sigchld_handler(int s) {
 846         int status;
 847         int* i;
 848         pid_t pid;
 849
 850         while((pid=waitpid(-1, &status, WNOHANG)) > 0) {
 851                 if(WIFEXITED(status)) {
 852                         msg3(LOG_INFO, "Child exited with %d", WEXITSTATUS(status));
 853                 }
 854                 i=g_hash_table_lookup(children, &pid);
 855                 if(!i) {
 856                         msg3(LOG_INFO, "SIGCHLD received for an unknown child with PID %ld", (long)pid);
 857                 } else {
 858                         DEBUG2("Removing %d from the list of children", pid);
 859                         g_hash_table_remove(children, &pid);
 860                 }
 861         }
 862 }
 863
 864 /**
 865  * Kill a child. Called from sigterm_handler::g_hash_table_foreach.
 866  *
 867  * @param key the key
 868  * @param value the value corresponding to the above key
 869  * @param user_data a pointer which we always set to 1, so that we know what
 870  * will happen next.
 871  **/
 872 void killchild(gpointer key, gpointer value, gpointer user_data) {
 873         pid_t *pid=value;
 874         int *parent=user_data;
 875
 876         kill(*pid, SIGTERM);
 877         *parent=1;
 878 }
 879
 880 /**
 881  * Handle SIGTERM and dispatch it to our children
 882  * @param s the signal we're handling (must be SIGTERM, or something
 883  * is severely wrong).
 884  **/
 885 void sigterm_handler(int s) {
 886         int parent=0;
 887
 888         g_hash_table_foreach(children, killchild, &parent);
 889
 890         if(parent) {
 891                 unlink(pidfname);
 892         }
 893
 894         exit(EXIT_SUCCESS);
 895 }
 896
 897 /**
 898  * Detect the size of a file.
 899  *
 900  * @param fhandle An open filedescriptor
 901  * @return the size of the file, or OFFT_MAX if detection was
 902  * impossible.
 903  **/
 904 off_t size_autodetect(int fhandle) {
 905         off_t es;
 906         u64 bytes;
 907         struct stat stat_buf;
 908         int error;
 909
 910 #ifdef HAVE_SYS_MOUNT_H
 911 #ifdef HAVE_SYS_IOCTL_H
 912 #ifdef BLKGETSIZE64
 913         DEBUG("looking for export size with ioctl BLKGETSIZE64\n");
 914         if (!ioctl(fhandle, BLKGETSIZE64, bytes) && bytes) {
 915                 return (off_t)bytes;
 916         }
 917 #endif /* BLKGETSIZE64 */
 918 #endif /* HAVE_SYS_IOCTL_H */
 919 #endif /* HAVE_SYS_MOUNT_H */
 920
 921         DEBUG("looking for fhandle size with fstat\n");
 922         stat_buf.st_size = 0;
 923         error = fstat(fhandle, &stat_buf);
 924         if (!error) {
 925                 if(stat_buf.st_size > 0)
 926                         return (off_t)stat_buf.st_size;
 927         } else {
 928                 err("fstat failed: %m");
 929         }
 930
 931         DEBUG("looking for fhandle size with lseek SEEK_END\n");
 932         es = lseek(fhandle, (off_t)0, SEEK_END);
 933         if (es > ((off_t)0)) {
 934                 return es;
 935         } else {
 936                 DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4)));
 937         }
 938
 939         err("Could not find size of exported block device: %m");
 940         return OFFT_MAX;
 941 }
 942
 943 /**
 944  * Get the file handle and offset, given an export offset.
 945  *
 946  * @param export An array of export files
 947  * @param a The offset to get corresponding file/offset for
 948  * @param fhandle [out] File descriptor
 949  * @param foffset [out] Offset into fhandle
 950  * @param maxbytes [out] Tells how many bytes can be read/written
 951  * from fhandle starting at foffset (0 if there is no limit)
 952  * @return 0 on success, -1 on failure
 953  **/
 954 int get_filepos(GArray* export, off_t a, int* fhandle, off_t* foffset, size_t* maxbytes ) {
 955         /* Negative offset not allowed */
 956         if(a < 0)
 957                 return -1;
 958
 959         /* Binary search for last file with starting offset <= a */
 960         FILE_INFO fi;
 961         int start = 0;
 962         int end = export->len - 1;
 963         while( start <= end ) {
 964                 int mid = (start + end) / 2;
 965                 fi = g_array_index(export, FILE_INFO, mid);
 966                 if( fi.startoff < a ) {
 967                         start = mid + 1;
 968                 } else if( fi.startoff > a ) {
 969                         end = mid - 1;
 970                 } else {
 971                         start = end = mid;
 972                         break;
 973                 }
 974         }
 975
 976         /* end should never go negative, since first startoff is 0 and a >= 0 */
 977         g_assert(end >= 0);
 978
 979         fi = g_array_index(export, FILE_INFO, end);
 980         *fhandle = fi.fhandle;
 981         *foffset = a - fi.startoff;
 982         *maxbytes = 0;
 983         if( end+1 < export->len ) {
 984                 FILE_INFO fi_next = g_array_index(export, FILE_INFO, end+1);
 985                 *maxbytes = fi_next.startoff - a;
 986         }
 987
 988         return 0;
 989 }
 990
 991 /**
 992  * seek to a position in a file, with error handling.
 993  * @param handle a filedescriptor
 994  * @param a position to seek to
 995  * @todo get rid of this; lastpoint is a global variable right now, but it
 996  * shouldn't be. If we pass it on as a parameter, that makes things a *lot*
 997  * easier.
 998  **/
 999 void myseek(int handle,off_t a) {
1000         if (lseek(handle, a, SEEK_SET) < 0) {
1001                 err("Can not seek locally!\n");
1002         }
1003 }
1004
1005 /**
1006  * Write an amount of bytes at a given offset to the right file. This
1007  * abstracts the write-side of the multiple file option.
1008  *
1009  * @param a The offset where the write should start
1010  * @param buf The buffer to write from
1011  * @param len The length of buf
1012  * @param client The client we're serving for
1013  * @return The number of bytes actually written, or -1 in case of an error
1014  **/
1015 ssize_t rawexpwrite(off_t a, char *buf, size_t len, CLIENT *client) {
1016         int fhandle;
1017         off_t foffset;
1018         size_t maxbytes;
1019         ssize_t retval;
1020
1021         if(get_filepos(client->export, a, &fhandle, &foffset, &maxbytes))
1022                 return -1;
1023         if(maxbytes && len > maxbytes)
1024                 len = maxbytes;
1025
1026         DEBUG4("(WRITE to fd %d offset %llu len %u), ", fhandle, foffset, len);
1027
1028         myseek(fhandle, foffset);
1029         retval = write(fhandle, buf, len);
1030         if(client->server->flags & F_SYNC) {
1031                 fsync(fhandle);
1032         }
1033         return retval;
1034 }
1035
1036 /**
1037  * Call rawexpwrite repeatedly until all data has been written.
1038  * @return 0 on success, nonzero on failure
1039  **/
1040 int rawexpwrite_fully(off_t a, char *buf, size_t len, CLIENT *client) {
1041         ssize_t ret=0;
1042
1043         while(len > 0 && (ret=rawexpwrite(a, buf, len, client)) > 0 ) {
1044                 a += ret;
1045                 buf += ret;
1046                 len -= ret;
1047         }
1048         return (ret < 0 || len != 0);
1049 }
1050
1051 /**
1052  * Read an amount of bytes at a given offset from the right file. This
1053  * abstracts the read-side of the multiple files option.
1054  *
1055  * @param a The offset where the read should start
1056  * @param buf A buffer to read into
1057  * @param len The size of buf
1058  * @param client The client we're serving for
1059  * @return The number of bytes actually read, or -1 in case of an
1060  * error.
1061  **/
1062 ssize_t rawexpread(off_t a, char *buf, size_t len, CLIENT *client) {
1063         int fhandle;
1064         off_t foffset;
1065         size_t maxbytes;
1066
1067         if(get_filepos(client->export, a, &fhandle, &foffset, &maxbytes))
1068                 return -1;
1069         if(maxbytes && len > maxbytes)
1070                 len = maxbytes;
1071
1072         DEBUG4("(READ from fd %d offset %llu len %u), ", fhandle, foffset, len);
1073
1074         myseek(fhandle, foffset);
1075         return read(fhandle, buf, len);
1076 }
1077
1078 /**
1079  * Call rawexpread repeatedly until all data has been read.
1080  * @return 0 on success, nonzero on failure
1081  **/
1082 int rawexpread_fully(off_t a, char *buf, size_t len, CLIENT *client) {
1083         ssize_t ret=0;
1084
1085         while(len > 0 && (ret=rawexpread(a, buf, len, client)) > 0 ) {
1086                 a += ret;
1087                 buf += ret;
1088                 len -= ret;
1089         }
1090         return (ret < 0 || len != 0);
1091 }
1092
1093 /**
1094  * Read an amount of bytes at a given offset from the right file. This
1095  * abstracts the read-side of the copyonwrite stuff, and calls
1096  * rawexpread() with the right parameters to do the actual work.
1097  * @param a The offset where the read should start
1098  * @param buf A buffer to read into
1099  * @param len The size of buf
1100  * @param client The client we're going to read for
1101  * @return 0 on success, nonzero on failure
1102  **/
1103 int expread(off_t a, char *buf, size_t len, CLIENT *client) {
1104         off_t rdlen, offset;
1105         off_t mapcnt, mapl, maph, pagestart;
1106
1107         if (!(client->server->flags & F_COPYONWRITE))
1108                 return(rawexpread_fully(a, buf, len, client));
1109         DEBUG3("Asked to read %d bytes at %llu.\n", len, (unsigned long long)a);
1110
1111         mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE;
1112
1113         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
1114                 pagestart=mapcnt*DIFFPAGESIZE;
1115                 offset=a-pagestart;
1116                 rdlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
1117                         len : (size_t)DIFFPAGESIZE-offset;
1118                 if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
1119                         DEBUG3("Page %llu is at %lu\n", (unsigned long long)mapcnt,
1120                                (unsigned long)(client->difmap[mapcnt]));
1121                         myseek(client->difffile, client->difmap[mapcnt]*DIFFPAGESIZE+offset);
1122                         if (read(client->difffile, buf, rdlen) != rdlen) return -1;
1123                 } else { /* the block is not there */
1124                         DEBUG2("Page %llu is not here, we read the original one\n",
1125                                (unsigned long long)mapcnt);
1126                         if(rawexpread_fully(a, buf, rdlen, client)) return -1;
1127                 }
1128                 len-=rdlen; a+=rdlen; buf+=rdlen;
1129         }
1130         return 0;
1131 }
1132
1133 /**
1134  * Write an amount of bytes at a given offset to the right file. This
1135  * abstracts the write-side of the copyonwrite option, and calls
1136  * rawexpwrite() with the right parameters to do the actual work.
1137  *
1138  * @param a The offset where the write should start
1139  * @param buf The buffer to write from
1140  * @param len The length of buf
1141  * @param client The client we're going to write for.
1142  * @return 0 on success, nonzero on failure
1143  **/
1144 int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
1145         char pagebuf[DIFFPAGESIZE];
1146         off_t mapcnt,mapl,maph;
1147         off_t wrlen,rdlen;
1148         off_t pagestart;
1149         off_t offset;
1150
1151         if (!(client->server->flags & F_COPYONWRITE))
1152                 return(rawexpwrite_fully(a, buf, len, client));
1153         DEBUG3("Asked to write %d bytes at %llu.\n", len, (unsigned long long)a);
1154
1155         mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ;
1156
1157         for (mapcnt=mapl;mapcnt<=maph;mapcnt++) {
1158                 pagestart=mapcnt*DIFFPAGESIZE ;
1159                 offset=a-pagestart ;
1160                 wrlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
1161                         len : (size_t)DIFFPAGESIZE-offset;
1162
1163                 if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
1164                         DEBUG3("Page %llu is at %lu\n", (unsigned long long)mapcnt,
1165                                (unsigned long)(client->difmap[mapcnt])) ;
1166                         myseek(client->difffile,
1167                                         client->difmap[mapcnt]*DIFFPAGESIZE+offset);
1168                         if (write(client->difffile, buf, wrlen) != wrlen) return -1 ;
1169                 } else { /* the block is not there */
1170                         myseek(client->difffile,client->difffilelen*DIFFPAGESIZE) ;
1171                         client->difmap[mapcnt]=(client->server->flags&F_SPARSE)?mapcnt:client->difffilelen++;
1172                         DEBUG3("Page %llu is not here, we put it at %lu\n",
1173                                (unsigned long long)mapcnt,
1174                                (unsigned long)(client->difmap[mapcnt]));
1175                         rdlen=DIFFPAGESIZE ;
1176                         if (rawexpread_fully(pagestart, pagebuf, rdlen, client))
1177                                 return -1;
1178                         memcpy(pagebuf+offset,buf,wrlen) ;
1179                         if (write(client->difffile, pagebuf, DIFFPAGESIZE) !=
1180                                         DIFFPAGESIZE)
1181                                 return -1;
1182                 }
1183                 len-=wrlen ; a+=wrlen ; buf+=wrlen ;
1184         }
1185         return 0;
1186 }
1187
1188 /**
1189  * Do the initial negotiation.
1190  *
1191  * @param client The client we're negotiating with.
1192  **/
1193 void negotiate(CLIENT *client) {
1194         char zeros[128];
1195         u64 size_host;
1196         u32 flags = NBD_FLAG_HAS_FLAGS;
1197
1198         memset(zeros, '\0', sizeof(zeros));
1199         if (write(client->net, INIT_PASSWD, 8) < 0)
1200                 err("Negotiation failed: %m");
1201         cliserv_magic = htonll(cliserv_magic);
1202         if (write(client->net, &cliserv_magic, sizeof(cliserv_magic)) < 0)
1203                 err("Negotiation failed: %m");
1204         size_host = htonll((u64)(client->exportsize));
1205         if (write(client->net, &size_host, 8) < 0)
1206                 err("Negotiation failed: %m");
1207         if (client->server->flags & F_READONLY)
1208                 flags |= NBD_FLAG_READ_ONLY;
1209         flags = htonl(flags);
1210         if (write(client->net, &flags, 4) < 0)
1211                 err("Negotiation failed: %m");
1212         if (write(client->net, zeros, 124) < 0)
1213                 err("Negotiation failed: %m");
1214 }
1215
1216 /** sending macro. */
1217 #define SEND(net,reply) writeit( net, &reply, sizeof( reply ));
1218 /** error macro. */
1219 #define ERROR(client,reply,errcode) { reply.error = htonl(errcode); SEND(client->net,reply); reply.error = 0; }
1220 /**
1221  * Serve a file to a single client.
1222  *
1223  * @todo This beast needs to be split up in many tiny little manageable
1224  * pieces. Preferably with a chainsaw.
1225  *
1226  * @param client The client we're going to serve to.
1227  * @return when the client disconnects
1228  **/
1229 int mainloop(CLIENT *client) {
1230         struct nbd_request request;
1231         struct nbd_reply reply;
1232         gboolean go_on=TRUE;
1233 #ifdef DODBG
1234         int i = 0;
1235 #endif
1236         negotiate(client);
1237         DEBUG("Entering request loop!\n");
1238         reply.magic = htonl(NBD_REPLY_MAGIC);
1239         reply.error = 0;
1240         while (go_on) {
1241                 char buf[BUFSIZE];
1242                 size_t len;
1243 #ifdef DODBG
1244                 i++;
1245                 printf("%d: ", i);
1246 #endif
1247                 readit(client->net, &request, sizeof(request));
1248                 request.from = ntohll(request.from);
1249                 request.type = ntohl(request.type);
1250
1251                 if (request.type==NBD_CMD_DISC) {
1252                         msg2(LOG_INFO, "Disconnect request received.");
1253                         if (client->server->flags & F_COPYONWRITE) {
1254                                 if (client->difmap) g_free(client->difmap) ;
1255                                 close(client->difffile);
1256                                 unlink(client->difffilename);
1257                                 free(client->difffilename);
1258                         }
1259                         go_on=FALSE;
1260                         continue;
1261                 }
1262
1263                 len = ntohl(request.len);
1264
1265                 if (request.magic != htonl(NBD_REQUEST_MAGIC))
1266                         err("Not enough magic.");
1267                 if (len > BUFSIZE + sizeof(struct nbd_reply))
1268                         err("Request too big!");
1269 #ifdef DODBG
1270                 printf("%s from %llu (%llu) len %d, ", request.type ? "WRITE" :
1271                                 "READ", (unsigned long long)request.from,
1272                                 (unsigned long long)request.from / 512, len);
1273 #endif
1274                 memcpy(reply.handle, request.handle, sizeof(reply.handle));
1275                 if ((request.from + len) > (OFFT_MAX)) {
1276                         DEBUG("[Number too large!]");
1277                         ERROR(client, reply, EINVAL);
1278                         continue;
1279                 }
1280
1281                 if (((ssize_t)((off_t)request.from + len) > client->exportsize)) {
1282                         DEBUG("[RANGE!]");
1283                         ERROR(client, reply, EINVAL);
1284                         continue;
1285                 }
1286
1287                 if (request.type==NBD_CMD_WRITE) {
1288                         DEBUG("wr: net->buf, ");
1289                         readit(client->net, buf, len);
1290                         DEBUG("buf->exp, ");
1291                         if ((client->server->flags & F_READONLY) ||
1292                             (client->server->flags & F_AUTOREADONLY)) {
1293                                 DEBUG("[WRITE to READONLY!]");
1294                                 ERROR(client, reply, EPERM);
1295                                 continue;
1296                         }
1297                         if (expwrite(request.from, buf, len, client)) {
1298                                 DEBUG("Write failed: %m" );
1299                                 ERROR(client, reply, errno);
1300                                 continue;
1301                         }
1302                         SEND(client->net, reply);
1303                         DEBUG("OK!\n");
1304                         continue;
1305                 }
1306                 /* READ */
1307
1308                 DEBUG("exp->buf, ");
1309                 if (expread(request.from, buf + sizeof(struct nbd_reply), len, client)) {
1310                         DEBUG("Read failed: %m");
1311                         ERROR(client, reply, errno);
1312                         continue;
1313                 }
1314
1315                 DEBUG("buf->net, ");
1316                 memcpy(buf, &reply, sizeof(struct nbd_reply));
1317                 writeit(client->net, buf, len + sizeof(struct nbd_reply));
1318                 DEBUG("OK!\n");
1319         }
1320         return 0;
1321 }
1322
1323 /**
1324  * Set up client export array, which is an array of FILE_INFO.
1325  * Also, split a single exportfile into multiple ones, if that was asked.
1326  * @param client information on the client which we want to setup export for
1327  **/
1328 void setupexport(CLIENT* client) {
1329         int i;
1330         off_t laststartoff = 0, lastsize = 0;
1331         int multifile = (client->server->flags & F_MULTIFILE);
1332
1333         client->export = g_array_new(TRUE, TRUE, sizeof(FILE_INFO));
1334
1335         /* If multi-file, open as many files as we can.
1336          * If not, open exactly one file.
1337          * Calculate file sizes as we go to get total size. */
1338         for(i=0; ; i++) {
1339                 FILE_INFO fi;
1340                 gchar *tmpname;
1341                 gchar* error_string;
1342                 mode_t mode = (client->server->flags & F_READONLY) ? O_RDONLY : O_RDWR;
1343
1344                 if(multifile) {
1345                         tmpname=g_strdup_printf("%s.%d", client->exportname, i);
1346                 } else {
1347                         tmpname=g_strdup(client->exportname);
1348                 }
1349                 DEBUG2( "Opening %s\n", tmpname );
1350                 fi.fhandle = open(tmpname, mode);
1351                 if(fi.fhandle == -1 && mode == O_RDWR) {
1352                         /* Try again because maybe media was read-only */
1353                         fi.fhandle = open(tmpname, O_RDONLY);
1354                         if(fi.fhandle != -1) {
1355                                 /* Opening the base file in copyonwrite mode is
1356                                  * okay */
1357                                 if(!(client->server->flags & F_COPYONWRITE)) {
1358                                         client->server->flags |= F_AUTOREADONLY;
1359                                         client->server->flags |= F_READONLY;
1360                                 }
1361                         }
1362                 }
1363                 if(fi.fhandle == -1) {
1364                         if(multifile && i>0)
1365                                 break;
1366                         error_string=g_strdup_printf(
1367                                 "Could not open exported file %s: %%m",
1368                                 tmpname);
1369                         err(error_string);
1370                 }
1371                 fi.startoff = laststartoff + lastsize;
1372                 g_array_append_val(client->export, fi);
1373                 g_free(tmpname);
1374
1375                 /* Starting offset and size of this file will be used to
1376                  * calculate starting offset of next file */
1377                 laststartoff = fi.startoff;
1378                 lastsize = size_autodetect(fi.fhandle);
1379
1380                 if(!multifile)
1381                         break;
1382         }
1383
1384         /* Set export size to total calculated size */
1385         client->exportsize = laststartoff + lastsize;
1386
1387         /* Export size may be overridden */
1388         if(client->server->expected_size) {
1389                 /* desired size must be <= total calculated size */
1390                 if(client->server->expected_size > client->exportsize) {
1391                         err("Size of exported file is too big\n");
1392                 }
1393
1394                 client->exportsize = client->server->expected_size;
1395         }
1396
1397         msg3(LOG_INFO, "Size of exported file/device is %llu", (unsigned long long)client->exportsize);
1398         if(multifile) {
1399                 msg3(LOG_INFO, "Total number of files: %d", i);
1400         }
1401 }
1402
1403 int copyonwrite_prepare(CLIENT* client) {
1404         off_t i;
1405         if ((client->difffilename = malloc(1024))==NULL)
1406                 err("Failed to allocate string for diff file name");
1407         snprintf(client->difffilename, 1024, "%s-%s-%d.diff",client->exportname,client->clientname,
1408                 (int)getpid()) ;
1409         client->difffilename[1023]='\0';
1410         msg3(LOG_INFO,"About to create map and diff file %s",client->difffilename) ;
1411         client->difffile=open(client->difffilename,O_RDWR | O_CREAT | O_TRUNC,0600) ;
1412         if (client->difffile<0) err("Could not create diff file (%m)") ;
1413         if ((client->difmap=calloc(client->exportsize/DIFFPAGESIZE,sizeof(u32)))==NULL)
1414                 err("Could not allocate memory") ;
1415         for (i=0;i<client->exportsize/DIFFPAGESIZE;i++) client->difmap[i]=(u32)-1 ;
1416
1417         return 0;
1418 }
1419
1420 /**
1421  * Run a command. This is used for the ``prerun'' and ``postrun'' config file
1422  * options
1423  *
1424  * @param command the command to be ran. Read from the config file
1425  * @param file the file name we're about to export
1426  **/
1427 int do_run(gchar* command, gchar* file) {
1428         gchar* cmd;
1429         int retval=0;
1430
1431         if(command && *command) {
1432                 cmd = g_strdup_printf(command, file);
1433                 retval=system(cmd);
1434                 g_free(cmd);
1435         }
1436         return retval;
1437 }
1438
1439 /**
1440  * Serve a connection.
1441  *
1442  * @todo allow for multithreading, perhaps use libevent. Not just yet, though;
1443  * follow the road map.
1444  *
1445  * @param client a connected client
1446  **/
1447 void serveconnection(CLIENT *client) {
1448         if(do_run(client->server->prerun, client->exportname)) {
1449                 exit(EXIT_FAILURE);
1450         }
1451         setupexport(client);
1452
1453         if (client->server->flags & F_COPYONWRITE) {
1454                 copyonwrite_prepare(client);
1455         }
1456
1457         setmysockopt(client->net);
1458
1459         mainloop(client);
1460         do_run(client->server->postrun, client->exportname);
1461 }
1462
1463 /**
1464  * Find the name of the file we have to serve. This will use g_strdup_printf
1465  * to put the IP address of the client inside a filename containing
1466  * "%s" (in the form as specified by the "virtstyle" option). That name
1467  * is then written to client->exportname.
1468  *
1469  * @param net A socket connected to an nbd client
1470  * @param client information about the client. The IP address in human-readable
1471  * format will be written to a new char* buffer, the address of which will be
1472  * stored in client->clientname.
1473  **/
1474 void set_peername(int net, CLIENT *client) {
1475         struct sockaddr_storage addrin;
1476         struct sockaddr_storage netaddr;
1477         struct sockaddr_in  *netaddr4 = NULL;
1478         struct sockaddr_in6 *netaddr6 = NULL;
1479         size_t addrinlen = sizeof( addrin );
1480         struct addrinfo hints;
1481         struct addrinfo *ai = NULL;
1482         char peername[NI_MAXHOST];
1483         char netname[NI_MAXHOST];
1484         char *tmp = NULL;
1485         int i;
1486         int e;
1487         int shift;
1488
1489         if (getpeername(net, (struct sockaddr *) &addrin, (socklen_t *)&addrinlen) < 0)
1490                 err("getsockname failed: %m");
1491
1492         getnameinfo((struct sockaddr *)&addrin, (socklen_t)addrinlen,
1493                 peername, sizeof (peername), NULL, 0, NI_NUMERICHOST);
1494
1495         memset(&hints, '\0', sizeof (hints));
1496         hints.ai_flags = AI_ADDRCONFIG;
1497         e = getaddrinfo(peername, NULL, &hints, &ai);
1498
1499         if(e != 0) {
1500                 fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
1501                 freeaddrinfo(ai);
1502                 return;
1503         }
1504
1505         switch(client->server->virtstyle) {
1506                 case VIRT_NONE:
1507                         client->exportname=g_strdup(client->server->exportname);
1508                         break;
1509                 case VIRT_IPHASH:
1510                         for(i=0;i<strlen(peername);i++) {
1511                                 if(peername[i]=='.') {
1512                                         peername[i]='/';
1513                                 }
1514                         }
1515                 case VIRT_IPLIT:
1516                         client->exportname=g_strdup_printf(client->server->exportname, peername);
1517                         break;
1518                 case VIRT_CIDR:
1519                         memcpy(&netaddr, &addrin, addrinlen);
1520                         if(ai->ai_family == AF_INET) {
1521                                 netaddr4 = (struct sockaddr_in *)&netaddr;
1522                                 (netaddr4->sin_addr).s_addr>>=32-(client->server->cidrlen);
1523                                 (netaddr4->sin_addr).s_addr<<=32-(client->server->cidrlen);
1524
1525                                 getnameinfo((struct sockaddr *) netaddr4, (socklen_t) addrinlen,
1526                                                         netname, sizeof (netname), NULL, 0, NI_NUMERICHOST);
1527                                 tmp=g_strdup_printf("%s/%s", netname, peername);
1528                         }else if(ai->ai_family == AF_INET6) {
1529                                 netaddr6 = (struct sockaddr_in6 *)&netaddr;
1530
1531                                 shift = 128-(client->server->cidrlen);
1532                                 i = 3;
1533                                 while(shift >= 32) {
1534                                         ((netaddr6->sin6_addr).s6_addr32[i])=0;
1535                                         shift-=32;
1536                                         i--;
1537                                 }
1538                                 (netaddr6->sin6_addr).s6_addr32[i]>>=shift;
1539                                 (netaddr6->sin6_addr).s6_addr32[i]<<=shift;
1540
1541                                 getnameinfo((struct sockaddr *)netaddr6, (socklen_t)addrinlen,
1542                                             netname, sizeof(netname), NULL, 0, NI_NUMERICHOST);
1543                                 tmp=g_strdup_printf("%s/%s", netname, peername);
1544                         }
1545
1546                         if(tmp != NULL)
1547                           client->exportname=g_strdup_printf(client->server->exportname, tmp);
1548
1549                         break;
1550         }
1551
1552         freeaddrinfo(ai);
1553         msg4(LOG_INFO, "connect from %s, assigned file is %s",
1554              peername, client->exportname);
1555         client->clientname=g_strdup(peername);
1556 }
1557
1558 /**
1559  * Destroy a pid_t*
1560  * @param data a pointer to pid_t which should be freed
1561  **/
1562 void destroy_pid_t(gpointer data) {
1563         g_free(data);
1564 }
1565
1566 /**
1567  * Loop through the available servers, and serve them. Never returns.
1568  **/
1569 int serveloop(GArray* servers) {
1570         struct sockaddr_storage addrin;
1571         socklen_t addrinlen=sizeof(addrin);
1572         SERVER *serve;
1573         int i;
1574         int max;
1575         int sock;
1576         fd_set mset;
1577         fd_set rset;
1578
1579         /*
1580          * Set up the master fd_set. The set of descriptors we need
1581          * to select() for never changes anyway and it buys us a *lot*
1582          * of time to only build this once. However, if we ever choose
1583          * to not fork() for clients anymore, we may have to revisit
1584          * this.
1585          */
1586         max=0;
1587         FD_ZERO(&mset);
1588         for(i=0;i<servers->len;i++) {
1589                 sock=(g_array_index(servers, SERVER, i)).socket;
1590                 FD_SET(sock, &mset);
1591                 max=sock>max?sock:max;
1592         }
1593         for(;;) {
1594                 CLIENT *client;
1595                 int net;
1596                 pid_t *pid;
1597
1598                 memcpy(&rset, &mset, sizeof(fd_set));
1599                 if(select(max+1, &rset, NULL, NULL, NULL)>0) {
1600                         DEBUG("accept, ");
1601                         for(i=0;i<servers->len;i++) {
1602                                 serve=&(g_array_index(servers, SERVER, i));
1603                                 if(FD_ISSET(serve->socket, &rset)) {
1604                                         int sock_flags;
1605                                         if ((net=accept(serve->socket, (struct sockaddr *) &addrin, &addrinlen)) < 0)
1606                                                 err("accept: %m");
1607
1608                                         if((sock_flags = fcntl(net, F_GETFL, 0))==-1) {
1609                                                 err("fcntl F_GETFL");
1610                                         }
1611                                         if(fcntl(net, F_SETFL, sock_flags &~O_NONBLOCK)==-1) {
1612                                                 err("fcntl F_SETFL ~O_NONBLOCK");
1613                                         }
1614                                         client = g_malloc(sizeof(CLIENT));
1615                                         client->server=serve;
1616                                         client->exportsize=OFFT_MAX;
1617                                         client->net=net;
1618                                         set_peername(net, client);
1619                                         if (!authorized_client(client)) {
1620                                                 msg2(LOG_INFO,"Unauthorized client") ;
1621                                                 close(net);
1622                                                 continue;
1623                                         }
1624                                         msg2(LOG_INFO,"Authorized client") ;
1625                                         pid=g_malloc(sizeof(pid_t));
1626 #ifndef NOFORK
1627                                         if ((*pid=fork())<0) {
1628                                                 msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
1629                                                 close(net);
1630                                                 continue;
1631                                         }
1632                                         if (*pid>0) { /* parent */
1633                                                 close(net);
1634                                                 g_hash_table_insert(children, pid, pid);
1635                                                 continue;
1636                                         }
1637                                         /* child */
1638                                         g_hash_table_destroy(children);
1639                                         for(i=0;i<servers->len;i++) {
1640                                                 serve=&g_array_index(servers, SERVER, i);
1641                                                 close(serve->socket);
1642                                         }
1643                                         /* FALSE does not free the
1644                                         actual data. This is required,
1645                                         because the client has a
1646                                         direct reference into that
1647                                         data, and otherwise we get a
1648                                         segfault... */
1649                                         g_array_free(servers, FALSE);
1650 #endif // NOFORK
1651                                         msg2(LOG_INFO,"Starting to serve");
1652                                         serveconnection(client);
1653                                         exit(EXIT_SUCCESS);
1654                                 }
1655                         }
1656                 }
1657         }
1658 }
1659
1660 /**
1661  * Connect a server's socket.
1662  *
1663  * @param serve the server we want to connect.
1664  **/
1665 void setup_serve(SERVER *serve) {
1666         struct sockaddr_storage addrin;
1667         struct addrinfo hints;
1668         struct addrinfo *ai = NULL;
1669         struct sigaction sa;
1670         int addrinlen = sizeof(addrin);
1671         int sock_flags;
1672 #ifndef sun
1673         int yes=1;
1674 #else
1675         char yes='1';
1676 #endif /* sun */
1677         gchar *port = NULL;
1678         int e;
1679
1680         memset(&hints,'\0',sizeof(hints));
1681         hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG | AI_NUMERICSERV;
1682         hints.ai_socktype = SOCK_STREAM;
1683         hints.ai_family = serve->socket_family;
1684
1685         port = g_strdup_printf ("%d", serve->port);
1686         if (port == NULL)
1687                 return;
1688
1689         e = getaddrinfo(serve->listenaddr,port,&hints,&ai);
1690
1691         g_free(port);
1692
1693         if(e != 0) {
1694                 fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
1695                 serve->socket = -1;
1696                 freeaddrinfo(ai);
1697                 exit(EXIT_FAILURE);
1698         }
1699
1700         if(serve->socket_family == AF_UNSPEC)
1701                 serve->socket_family = ai->ai_family;
1702
1703 #ifdef WITH_SDP
1704         if ((serve->flags) && F_SDP) {
1705                 if (ai->ai_family == AF_INET)
1706                         ai->ai_family = AF_INET_SDP;
1707                 else (ai->ai_family == AF_INET6)
1708                         ai->ai_family = AF_INET6_SDP;
1709         }
1710 #endif
1711         if ((serve->socket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) < 0)
1712                 err("socket: %m");
1713
1714         /* lose the pesky "Address already in use" error message */
1715         if (setsockopt(serve->socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
1716                 err("setsockopt SO_REUSEADDR");
1717         }
1718         if (setsockopt(serve->socket,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
1719                 err("setsockopt SO_KEEPALIVE");
1720         }
1721
1722         /* make the listening socket non-blocking */
1723         if ((sock_flags = fcntl(serve->socket, F_GETFL, 0)) == -1) {
1724                 err("fcntl F_GETFL");
1725         }
1726         if (fcntl(serve->socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
1727                 err("fcntl F_SETFL O_NONBLOCK");
1728         }
1729
1730         DEBUG("Waiting for connections... bind, ");
1731         e = bind(serve->socket, ai->ai_addr, ai->ai_addrlen);
1732         if (e != 0 && errno != EADDRINUSE)
1733                 err("bind: %m");
1734         DEBUG("listen, ");
1735         if (listen(serve->socket, 1) < 0)
1736                 err("listen: %m");
1737
1738         freeaddrinfo (ai);
1739
1740         sa.sa_handler = sigchld_handler;
1741         sigemptyset(&sa.sa_mask);
1742         sa.sa_flags = SA_RESTART;
1743         if(sigaction(SIGCHLD, &sa, NULL) == -1)
1744                 err("sigaction: %m");
1745         sa.sa_handler = sigterm_handler;
1746         sigemptyset(&sa.sa_mask);
1747         sa.sa_flags = SA_RESTART;
1748         if(sigaction(SIGTERM, &sa, NULL) == -1)
1749                 err("sigaction: %m");
1750 }
1751
1752 /**
1753  * Connect our servers.
1754  **/
1755 void setup_servers(GArray* servers) {
1756         int i;
1757
1758         for(i=0;i<servers->len;i++) {
1759                 setup_serve(&(g_array_index(servers, SERVER, i)));
1760         }
1761         children=g_hash_table_new_full(g_int_hash, g_int_equal, NULL, destroy_pid_t);
1762 }
1763
1764 /**
1765  * Go daemon (unless we specified at compile time that we didn't want this)
1766  * @param serve the first server of our configuration. If its port is zero,
1767  *      then do not daemonize, because we're doing inetd then. This parameter
1768  *      is only used to create a PID file of the form
1769  *      /var/run/nbd-server.&lt;port&gt;.pid; it's not modified in any way.
1770  **/
1771 #if !defined(NODAEMON) && !defined(NOFORK)
1772 void daemonize(SERVER* serve) {
1773         FILE*pidf;
1774
1775         if(serve && !(serve->port)) {
1776                 return;
1777         }
1778         if(daemon(0,0)<0) {
1779                 err("daemon");
1780         }
1781         if(!*pidftemplate) {
1782                 if(serve) {
1783                         strncpy(pidftemplate, "/var/run/nbd-server.%d.pid", 255);
1784                 } else {
1785                         strncpy(pidftemplate, "/var/run/nbd-server.pid", 255);
1786                 }
1787         }
1788         snprintf(pidfname, 255, pidftemplate, serve ? serve->port : 0);
1789         pidf=fopen(pidfname, "w");
1790         if(pidf) {
1791                 fprintf(pidf,"%d\n", (int)getpid());
1792                 fclose(pidf);
1793         } else {
1794                 perror("fopen");
1795                 fprintf(stderr, "Not fatal; continuing");
1796         }
1797 }
1798 #else
1799 #define daemonize(serve)
1800 #endif /* !defined(NODAEMON) && !defined(NOFORK) */
1801
1802 /*
1803  * Everything beyond this point (in the file) is run in non-daemon mode.
1804  * The stuff above daemonize() isn't.
1805  */
1806
1807 void serve_err(SERVER* serve, const char* msg) G_GNUC_NORETURN;
1808
1809 void serve_err(SERVER* serve, const char* msg) {
1810         g_message("Export of %s on port %d failed:", serve->exportname,
1811                         serve->port);
1812         err(msg);
1813 }
1814
1815 /**
1816  * Set up user-ID and/or group-ID
1817  **/
1818 void dousers(void) {
1819         struct passwd *pw;
1820         struct group *gr;
1821         gchar* str;
1822         if(rungroup) {
1823                 gr=getgrnam(rungroup);
1824                 if(!gr) {
1825                         str = g_strdup_printf("Invalid group name: %s", rungroup);
1826                         err(str);
1827                 }
1828                 if(setgid(gr->gr_gid)<0) {
1829                         err("Could not set GID: %m");
1830                 }
1831         }
1832         if(runuser) {
1833                 pw=getpwnam(runuser);
1834                 if(!pw) {
1835                         str = g_strdup_printf("Invalid user name: %s", runuser);
1836                         err(str);
1837                 }
1838                 if(setuid(pw->pw_uid)<0) {
1839                         err("Could not set UID: %m");
1840                 }
1841         }
1842 }
1843
1844 #ifndef ISSERVER
1845 void glib_message_syslog_redirect(const gchar *log_domain,
1846                                   GLogLevelFlags log_level,
1847                                   const gchar *message,
1848                                   gpointer user_data)
1849 {
1850     int level=LOG_DEBUG;
1851
1852     switch( log_level )
1853     {
1854       case G_LOG_FLAG_FATAL:
1855       case G_LOG_LEVEL_CRITICAL:
1856       case G_LOG_LEVEL_ERROR:
1857         level=LOG_ERR;
1858         break;
1859       case G_LOG_LEVEL_WARNING:
1860         level=LOG_WARNING;
1861         break;
1862       case G_LOG_LEVEL_MESSAGE:
1863       case G_LOG_LEVEL_INFO:
1864         level=LOG_INFO;
1865         break;
1866       case G_LOG_LEVEL_DEBUG:
1867         level=LOG_DEBUG;
1868       default:
1869         level=LOG_ERR;
1870     }
1871     syslog(level, message);
1872 }
1873 #endif
1874
1875 /**
1876  * Main entry point...
1877  **/
1878 int main(int argc, char *argv[]) {
1879         SERVER *serve;
1880         GArray *servers;
1881         GError *err=NULL;
1882
1883         if (sizeof( struct nbd_request )!=28) {
1884                 fprintf(stderr,"Bad size of structure. Alignment problems?\n");
1885                 exit(EXIT_FAILURE) ;
1886         }
1887
1888         memset(pidftemplate, '\0', 256);
1889
1890         logging();
1891         config_file_pos = g_strdup(CFILE);
1892         serve=cmdline(argc, argv);
1893         servers = parse_cfile(config_file_pos, &err);
1894
1895         if(serve) {
1896                 serve->socket_family = AF_UNSPEC;
1897
1898                 append_serve(serve, servers);
1899
1900                 if (!(serve->port)) {
1901                         CLIENT *client;
1902 #ifndef ISSERVER
1903                         /* You really should define ISSERVER if you're going to use
1904                          * inetd mode, but if you don't, closing stdout and stderr
1905                          * (which inetd had connected to the client socket) will let it
1906                          * work. */
1907                         close(1);
1908                         close(2);
1909                         open("/dev/null", O_WRONLY);
1910                         open("/dev/null", O_WRONLY);
1911                         g_log_set_default_handler( glib_message_syslog_redirect, NULL );
1912 #endif
1913                         client=g_malloc(sizeof(CLIENT));
1914                         client->server=serve;
1915                         client->net=0;
1916                         client->exportsize=OFFT_MAX;
1917                         set_peername(0,client);
1918                         serveconnection(client);
1919                         return 0;
1920                 }
1921         }
1922
1923         if(!servers || !servers->len) {
1924                 g_warning("Could not parse config file: %s",
1925                                 err ? err->message : "Unknown error");
1926         }
1927
1928         if((!serve) && (!servers||!servers->len)) {
1929                 g_message("Nothing to do! Bye!");
1930                 exit(EXIT_FAILURE);
1931         }
1932         daemonize(serve);
1933         setup_servers(servers);
1934         dousers();
1935         serveloop(servers);
1936         return 0 ;
1937 }