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