X-Git-Url: http://git.alex.org.uk

diff --git a/nbd-server.c b/nbd-server.c
index 3d43cb2..4d01e37 100644
--- a/nbd-server.c
+++ b/nbd-server.c
@@ -68,6 +68,7 @@
 #include <sys/mount.h>		/* For BLKGETSIZE */
 #endif
 #include <signal.h>		/* sigaction */
+#include <errno.h>
 #include <netinet/tcp.h>
 #include <netinet/in.h>		/* sockaddr_in, htons, in_addr */
 #include <netdb.h>		/* hostent, gethostby*, getservby* */
@@ -138,7 +139,7 @@ gchar* rungroup=NULL;
  **/
 #define OFFT_MAX ~((off_t)1<<(sizeof(off_t)*8-1))
 #define LINELEN 256	  /**< Size of static buffer used to read the
-			    authorization file (yuck) */
+			       authorization file (yuck) */
 #define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */
 #define DIFFPAGESIZE 4096 /**< diff file uses those chunks */
 #define F_READONLY 1      /**< flag to tell us a file is readonly */
@@ -146,9 +147,12 @@ gchar* rungroup=NULL;
 #define F_COPYONWRITE 4	  /**< flag to tell us a file is exported using
 			    copyonwrite */
 #define F_AUTOREADONLY 8  /**< flag to tell us a file is set to autoreadonly */
-#define F_SPARSE 16
+#define F_SPARSE 16	  /**< flag to tell us copyronwrite should use a sparse file */
+#define F_SDP 32	  /**< flag to tell us the export should be done using the Socket Direct Protocol for RDMA */
+#define F_SYNC 64	  /**< Whether to fsync() after a write */
 GHashTable *children;
 char pidfname[256]; /**< name of our PID file */
+char pidftemplate[256]; /**< template to be used for the filename of the PID file */
 char default_authname[] = SYSCONFDIR "/nbd-server/allow"; /**< default name of allow file */
 
 /**
@@ -169,15 +173,18 @@ typedef struct {
 	gchar* exportname;    /**< (unprocessed) filename of the file we're exporting */
 	off_t expected_size; /**< size of the exported file as it was told to
 			       us through configuration */
+	gchar* listenaddr;   /**< The IP address we're listening on */
 	unsigned int port;   /**< port we're exporting this file at */
 	char* authname;      /**< filename of the authorization file */
 	int flags;           /**< flags associated with this exported file */
-	unsigned int timeout;/**< how long a connection may be idle
-			       (0=forever) */
 	int socket;	     /**< The socket of this server. */
 	VIRT_STYLE virtstyle;/**< The style of virtualization, if any */
 	uint8_t cidrlen;     /**< The length of the mask when we use
 				  CIDR-style virtualization */
+	gchar* prerun;	     /**< command to be ran after connecting a client,
+				  but before starting to serve */
+	gchar* postrun;	     /**< command that will be ran after the client
+				  disconnects */
 } SERVER;
 
 /**
@@ -296,10 +303,14 @@ inline void readit(int f, void *buf, size_t len) {
 	ssize_t res;
 	while (len > 0) {
 		DEBUG("*");
-		if ((res = read(f, buf, len)) <= 0)
-			err("Read failed: %m");
-		len -= res;
-		buf += res;
+		if ((res = read(f, buf, len)) <= 0) {
+			if(errno != EAGAIN) {
+				err("Read failed: %m");
+			}
+		} else {
+			len -= res;
+			buf += res;
+		}
 	}
 }
 
@@ -327,19 +338,46 @@ inline void writeit(int f, void *buf, size_t len) {
  */
 void usage() {
 	printf("This is nbd-server version " VERSION "\n");
-	printf("Usage: port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-a timeout_sec] [-C configuration file]\n"
+	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"
 	       "\t-r|--read-only\t\tread only\n"
 	       "\t-m|--multi-file\t\tmultiple file\n"
 	       "\t-c|--copy-on-write\tcopy on write\n"
-	       "\t-C|--config-file\tspecify an alternat configuration file\n"
+	       "\t-C|--config-file\tspecify an alternate configuration file\n"
 	       "\t-l|--authorize-file\tfile with list of hosts that are allowed to\n\t\t\t\tconnect.\n"
-	       "\t-a|--idle-time\t\tmaximum idle seconds; server terminates when\n\t\t\t\tidle time exceeded\n\n"
+	       "\t-a|--idle-time\t\tmaximum idle seconds; server terminates when\n\t\t\t\tidle time exceeded\n"
+	       "\t-p|--pid-file\t\tspecify a filename to write our PID to\n"
+	       "\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"
 	       "\tif port is set to 0, stdin is used (for running from inetd)\n"
 	       "\tif file_to_export contains '%%s', it is substituted with the IP\n"
-	       "\t\taddress of the machine trying to connect\n" );
+	       "\t\taddress of the machine trying to connect\n" 
+	       "\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");
 	printf("Using configuration file %s\n", CFILE);
 }
 
+/* Dumps a config file section of the given SERVER*, and exits. */
+void dump_section(SERVER* serve, gchar* section_header) {
+	printf("[%s]\n", section_header);
+	printf("\texportname = %s\n", serve->exportname);
+	printf("\tlistenaddr = %s\n", serve->listenaddr);
+	printf("\tport = %d\n", serve->port);
+	if(serve->flags & F_READONLY) {
+		printf("\treadonly = true\n");
+	}
+	if(serve->flags & F_MULTIFILE) {
+		printf("\tmultifile = true\n");
+	}
+	if(serve->flags & F_COPYONWRITE) {
+		printf("\tcopyonwrite = true\n");
+	}
+	if(serve->expected_size) {
+		printf("\tfilesize = %lld\n", (long long int)serve->expected_size);
+	}
+	if(serve->authname) {
+		printf("\tauthfile = %s\n", serve->authname);
+	}
+	exit(EXIT_SUCCESS);
+}
+
 /**
  * Parse the command line.
  *
@@ -357,25 +395,39 @@ SERVER* cmdline(int argc, char *argv[]) {
 		{"authorize-file", required_argument, NULL, 'l'},
 		{"idle-time", required_argument, NULL, 'a'},
 		{"config-file", required_argument, NULL, 'C'},
+		{"pid-file", required_argument, NULL, 'p'},
+		{"output-config", required_argument, NULL, 'o'},
 		{0,0,0,0}
 	};
 	SERVER *serve;
 	off_t es;
 	size_t last;
 	char suffix;
+	gboolean do_output=FALSE;
+	gchar* section_header="";
+	gchar** addr_port;
 
 	if(argc==1) {
 		return NULL;
 	}
 	serve=g_new0(SERVER, 1);
 	serve->authname = g_strdup(default_authname);
-	while((c=getopt_long(argc, argv, "-a:C:cl:mr", long_options, &i))>=0) {
+	serve->virtstyle=VIRT_IPLIT;
+	while((c=getopt_long(argc, argv, "-a:C:cl:mo:rp:", long_options, &i))>=0) {
 		switch (c) {
 		case 1:
 			/* non-option argument */
 			switch(nonspecial++) {
 			case 0:
-				serve->port=strtol(optarg, NULL, 0);
+				addr_port=g_strsplit(optarg, ":", 2);
+				if(addr_port[1]) {
+					serve->port=strtol(addr_port[1], NULL, 0);
+					serve->listenaddr=g_strdup(addr_port[0]);
+				} else {
+					serve->listenaddr=g_strdup("0.0.0.0");
+					serve->port=strtol(addr_port[0], NULL, 0);
+				}
+				g_strfreev(addr_port);
 				break;
 			case 1:
 				serve->exportname = g_strdup(optarg);
@@ -390,7 +442,7 @@ SERVER* cmdline(int argc, char *argv[]) {
 				if (suffix == 'k' || suffix == 'K' ||
 				    suffix == 'm' || suffix == 'M')
 					optarg[last] = '\0';
-				es = (off_t)atol(optarg);
+				es = (off_t)atoll(optarg);
 				switch (suffix) {
 					case 'm':
 					case 'M':  es <<= 10;
@@ -408,6 +460,13 @@ SERVER* cmdline(int argc, char *argv[]) {
 		case 'm':
 			serve->flags |= F_MULTIFILE;
 			break;
+		case 'o':
+			do_output = TRUE;
+			section_header = g_strdup(optarg);
+			break;
+		case 'p':
+			strncpy(pidftemplate, optarg, 256);
+			break;
 		case 'c': 
 			serve->flags |=F_COPYONWRITE;
 		        break;
@@ -419,9 +478,6 @@ SERVER* cmdline(int argc, char *argv[]) {
 			g_free(serve->authname);
 			serve->authname=g_strdup(optarg);
 			break;
-		case 'a': 
-			serve->timeout=strtol(optarg, NULL, 0);
-			break;
 		default:
 			usage();
 			exit(EXIT_FAILURE);
@@ -434,6 +490,13 @@ SERVER* cmdline(int argc, char *argv[]) {
 		g_free(serve);
 		serve=NULL;
 	}
+	if(do_output) {
+		if(!serve) {
+			g_critical("Need a complete configuration on the command line to output a config file section!");
+			exit(EXIT_FAILURE);
+		}
+		dump_section(serve, section_header);
+	}
 	return serve;
 }
 
@@ -445,7 +508,10 @@ typedef enum {
 	CFILE_MISSING_GENERIC,	/**< The (required) group "generic" is missing */
 	CFILE_KEY_MISSING,	/**< A (required) key is missing */
 	CFILE_VALUE_INVALID,	/**< A value is syntactically invalid */
-	CFILE_PROGERR		/**< Programmer error */
+	CFILE_VALUE_UNSUPPORTED,/**< A value is not supported in this build */
+	CFILE_PROGERR,		/**< Programmer error */
+	CFILE_NO_EXPORTS	/**< A config file was specified that does not
+				     define any exports */
 } CFILE_ERRORS;
 
 /**
@@ -480,22 +546,25 @@ GArray* parse_cfile(gchar* f, GError** e) {
 		{ "exportname", TRUE,	PARAM_STRING, 	NULL, 0 },
 		{ "port", 	TRUE,	PARAM_INT, 	NULL, 0 },
 		{ "authfile",	FALSE,	PARAM_STRING,	NULL, 0 },
-		{ "timeout",	FALSE,	PARAM_INT,	NULL, 0 },
 		{ "filesize",	FALSE,	PARAM_INT,	NULL, 0 },
 		{ "virtstyle",	FALSE,	PARAM_STRING,	NULL, 0 },
+		{ "prerun",	FALSE,	PARAM_STRING,	NULL, 0 },
+		{ "postrun",	FALSE,	PARAM_STRING,	NULL, 0 },
 		{ "readonly",	FALSE,	PARAM_BOOL,	NULL, F_READONLY },
 		{ "multifile",	FALSE,	PARAM_BOOL,	NULL, F_MULTIFILE },
 		{ "copyonwrite", FALSE,	PARAM_BOOL,	NULL, F_COPYONWRITE },
-		{ "autoreadonly", FALSE, PARAM_BOOL,	NULL, F_AUTOREADONLY },
 		{ "sparse_cow",	FALSE,	PARAM_BOOL,	NULL, F_SPARSE },
+		{ "sdp",	FALSE,	PARAM_BOOL,	NULL, F_SDP },
+		{ "sync",	FALSE,  PARAM_BOOL,	NULL, F_SYNC },
+		{ "listenaddr", FALSE,  PARAM_STRING,   NULL, 0 },
 	};
-	const int lp_size=11;
+	const int lp_size=sizeof(lp)/sizeof(PARAM);
 	PARAM gp[] = {
 		{ "user",	FALSE, PARAM_STRING,	&runuser,	0 },
 		{ "group",	FALSE, PARAM_STRING,	&rungroup,	0 },
 	};
 	PARAM* p=gp;
-	int p_size=2;
+	int p_size=sizeof(gp)/sizeof(PARAM);
 	GKeyFile *cfile;
 	GError *err = NULL;
 	const char *err_msg=NULL;
@@ -503,6 +572,7 @@ GArray* parse_cfile(gchar* f, GError** e) {
 	GArray *retval=NULL;
 	gchar **groups;
 	gboolean value;
+	gchar* startgroup;
 	gint i;
 	gint j;
 
@@ -511,11 +581,12 @@ GArray* parse_cfile(gchar* f, GError** e) {
 	retval = g_array_new(FALSE, TRUE, sizeof(SERVER));
 	if(!g_key_file_load_from_file(cfile, f, G_KEY_FILE_KEEP_COMMENTS |
 			G_KEY_FILE_KEEP_TRANSLATIONS, &err)) {
-		g_set_error(e, errdomain, CFILE_NOTFOUND, "Could not open config file.");
+		g_set_error(e, errdomain, CFILE_NOTFOUND, "Could not open config file.", f);
 		g_key_file_free(cfile);
 		return retval;
 	}
-	if(strcmp(g_key_file_get_start_group(cfile), "generic")) {
+	startgroup = g_key_file_get_start_group(cfile);
+	if(!startgroup || strcmp(startgroup, "generic")) {
 		g_set_error(e, errdomain, CFILE_MISSING_GENERIC, "Config file does not contain the [generic] group!");
 		g_key_file_free(cfile);
 		return NULL;
@@ -526,11 +597,15 @@ GArray* parse_cfile(gchar* f, GError** e) {
 		lp[0].target=&(s.exportname);
 		lp[1].target=&(s.port);
 		lp[2].target=&(s.authname);
-		lp[3].target=&(s.timeout);
-		lp[4].target=&(s.expected_size);
-		lp[5].target=&(virtstyle);
-		lp[6].target=lp[7].target=lp[8].target=
-				lp[9].target=lp[10].target=&(s.flags);
+		lp[3].target=&(s.expected_size);
+		lp[4].target=&(virtstyle);
+		lp[5].target=&(s.prerun);
+		lp[6].target=&(s.postrun);
+		lp[7].target=lp[8].target=lp[9].target=
+				lp[10].target=lp[11].target=
+				lp[12].target=&(s.flags);
+		lp[13].target=&(s.listenaddr);
+
 		/* After the [generic] group, start parsing exports */
 		if(i==1) {
 			p=lp;
@@ -615,9 +690,24 @@ GArray* parse_cfile(gchar* f, GError** e) {
 		virtstyle=NULL;
 		/* Don't append values for the [generic] group */
 		if(i>0) {
+			if(!s.listenaddr) {
+				s.listenaddr = g_strdup("0.0.0.0");
+			}
 			g_array_append_val(retval, s);
 		}
+#ifndef WITH_SDP
+		if(s.flags & F_SDP) {
+			g_set_error(e, errdomain, CFILE_VALUE_UNSUPPORTED, "This nbd-server was built without support for SDP, yet group %s uses it", groups[i]);
+			g_array_free(retval, TRUE);
+			g_key_file_free(cfile);
+			return NULL;
+		}
+#endif
 	}
+	if(i==1) {
+		g_set_error(e, errdomain, CFILE_NO_EXPORTS, "The config file does not specify any exports");
+	}
+	g_key_file_free(cfile);
 	return retval;
 }
 
@@ -632,7 +722,7 @@ void sigchld_handler(int s) {
 	pid_t pid;
 
 	while((pid=waitpid(-1, &status, WNOHANG)) > 0) {
-		if(WIFEXITED(&status)) {
+		if(WIFEXITED(status)) {
 			msg3(LOG_INFO, "Child exited with %d", WEXITSTATUS(status));
 		}
 		i=g_hash_table_lookup(children, &pid);
@@ -675,7 +765,7 @@ void sigterm_handler(int s) {
 		unlink(pidfname);
 	}
 
-	exit(0);
+	exit(EXIT_SUCCESS);
 }
 
 /**
@@ -687,19 +777,18 @@ void sigterm_handler(int s) {
  **/
 off_t size_autodetect(int fhandle) {
 	off_t es;
-	u32 es32;
+	u64 bytes;
 	struct stat stat_buf;
 	int error;
 
 #ifdef HAVE_SYS_MOUNT_H
 #ifdef HAVE_SYS_IOCTL_H
-#ifdef BLKGETSIZE
-	DEBUG("looking for fhandle size with ioctl BLKGETSIZE\n");
-	if (!ioctl(fhandle, BLKGETSIZE, &es32) && es32) {
-		es = (off_t)es32 * (off_t)512;
-		return es;
+#ifdef BLKGETSIZE64
+	DEBUG("looking for export size with ioctl BLKGETSIZE64\n");
+	if (!ioctl(fhandle, BLKGETSIZE64, bytes) && bytes) {
+		return (off_t)bytes;
 	}
-#endif /* BLKGETSIZE */
+#endif /* BLKGETSIZE64 */
 #endif /* HAVE_SYS_IOCTL_H */
 #endif /* HAVE_SYS_MOUNT_H */
 
@@ -801,16 +890,21 @@ ssize_t rawexpwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 	int fhandle;
 	off_t foffset;
 	size_t maxbytes;
+	ssize_t retval;
 
 	if(get_filepos(client->export, a, &fhandle, &foffset, &maxbytes))
 		return -1;
 	if(maxbytes && len > maxbytes)
 		len = maxbytes;
 
-	DEBUG4("(WRITE to fd %d offset %Lu len %u), ", fhandle, foffset, len);
+	DEBUG4("(WRITE to fd %d offset %llu len %u), ", fhandle, foffset, len);
 
 	myseek(fhandle, foffset);
-	return write(fhandle, buf, len);
+	retval = write(fhandle, buf, len);
+	if(client->server->flags & F_SYNC) {
+		fsync(fhandle);
+	}
+	return retval;
 }
 
 /**
@@ -818,7 +912,7 @@ ssize_t rawexpwrite(off_t a, char *buf, size_t len, CLIENT *client) {
  * @return 0 on success, nonzero on failure
  **/
 int rawexpwrite_fully(off_t a, char *buf, size_t len, CLIENT *client) {
-	ssize_t ret;
+	ssize_t ret=0;
 
 	while(len > 0 && (ret=rawexpwrite(a, buf, len, client)) > 0 ) {
 		a += ret;
@@ -849,7 +943,7 @@ ssize_t rawexpread(off_t a, char *buf, size_t len, CLIENT *client) {
 	if(maxbytes && len > maxbytes)
 		len = maxbytes;
 
-	DEBUG4("(READ from fd %d offset %Lu len %u), ", fhandle, foffset, len);
+	DEBUG4("(READ from fd %d offset %llu len %u), ", fhandle, foffset, len);
 
 	myseek(fhandle, foffset);
 	return read(fhandle, buf, len);
@@ -860,7 +954,7 @@ ssize_t rawexpread(off_t a, char *buf, size_t len, CLIENT *client) {
  * @return 0 on success, nonzero on failure
  **/
 int rawexpread_fully(off_t a, char *buf, size_t len, CLIENT *client) {
-	ssize_t ret;
+	ssize_t ret=0;
 
 	while(len > 0 && (ret=rawexpread(a, buf, len, client)) > 0 ) {
 		a += ret;
@@ -886,7 +980,7 @@ int expread(off_t a, char *buf, size_t len, CLIENT *client) {
 
 	if (!(client->server->flags & F_COPYONWRITE))
 		return(rawexpread_fully(a, buf, len, client));
-	DEBUG3("Asked to read %d bytes at %Lu.\n", len, (unsigned long long)a);
+	DEBUG3("Asked to read %d bytes at %llu.\n", len, (unsigned long long)a);
 
 	mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE;
 
@@ -896,12 +990,12 @@ int expread(off_t a, char *buf, size_t len, CLIENT *client) {
 		rdlen=(0<DIFFPAGESIZE-offset && len<(size_t)(DIFFPAGESIZE-offset)) ?
 			len : (size_t)DIFFPAGESIZE-offset;
 		if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
-			DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
+			DEBUG3("Page %llu is at %lu\n", (unsigned long long)mapcnt,
 			       (unsigned long)(client->difmap[mapcnt]));
 			myseek(client->difffile, client->difmap[mapcnt]*DIFFPAGESIZE+offset);
 			if (read(client->difffile, buf, rdlen) != rdlen) return -1;
 		} else { /* the block is not there */
-			DEBUG2("Page %Lu is not here, we read the original one\n",
+			DEBUG2("Page %llu is not here, we read the original one\n",
 			       (unsigned long long)mapcnt);
 			if(rawexpread_fully(a, buf, rdlen, client)) return -1;
 		}
@@ -930,7 +1024,7 @@ int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 
 	if (!(client->server->flags & F_COPYONWRITE))
 		return(rawexpwrite_fully(a, buf, len, client)); 
-	DEBUG3("Asked to write %d bytes at %Lu.\n", len, (unsigned long long)a);
+	DEBUG3("Asked to write %d bytes at %llu.\n", len, (unsigned long long)a);
 
 	mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ;
 
@@ -941,7 +1035,7 @@ int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 			len : (size_t)DIFFPAGESIZE-offset;
 
 		if (client->difmap[mapcnt]!=(u32)(-1)) { /* the block is already there */
-			DEBUG3("Page %Lu is at %lu\n", (unsigned long long)mapcnt,
+			DEBUG3("Page %llu is at %lu\n", (unsigned long long)mapcnt,
 			       (unsigned long)(client->difmap[mapcnt])) ;
 			myseek(client->difffile,
 					client->difmap[mapcnt]*DIFFPAGESIZE+offset);
@@ -949,7 +1043,7 @@ int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
 		} else { /* the block is not there */
 			myseek(client->difffile,client->difffilelen*DIFFPAGESIZE) ;
 			client->difmap[mapcnt]=(client->server->flags&F_SPARSE)?mapcnt:client->difffilelen++;
-			DEBUG3("Page %Lu is not here, we put it at %lu\n",
+			DEBUG3("Page %llu is not here, we put it at %lu\n",
 			       (unsigned long long)mapcnt,
 			       (unsigned long)(client->difmap[mapcnt]));
 			rdlen=DIFFPAGESIZE ;
@@ -971,10 +1065,11 @@ int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
  * @param client The client we're negotiating with.
  **/
 void negotiate(CLIENT *client) {
-	char zeros[300];
+	char zeros[128];
 	u64 size_host;
+	u32 flags = NBD_FLAG_HAS_FLAGS;
 
-	memset(zeros, '\0', 290);
+	memset(zeros, '\0', sizeof(zeros));
 	if (write(client->net, INIT_PASSWD, 8) < 0)
 		err("Negotiation failed: %m");
 	cliserv_magic = htonll(cliserv_magic);
@@ -983,14 +1078,19 @@ void negotiate(CLIENT *client) {
 	size_host = htonll((u64)(client->exportsize));
 	if (write(client->net, &size_host, 8) < 0)
 		err("Negotiation failed: %m");
-	if (write(client->net, zeros, 128) < 0)
+	if (client->server->flags & F_READONLY)
+		flags |= NBD_FLAG_READ_ONLY;
+	flags = htonl(flags);
+	if (write(client->net, &flags, 4) < 0)
+		err("Negotiation failed: %m");
+	if (write(client->net, zeros, 124) < 0)
 		err("Negotiation failed: %m");
 }
 
 /** sending macro. */
 #define SEND(net,reply) writeit( net, &reply, sizeof( reply ));
 /** error macro. */
-#define ERROR(client,reply) { reply.error = htonl(-1); SEND(client->net,reply); reply.error = 0; }
+#define ERROR(client,reply,errcode) { reply.error = htonl(errcode); SEND(client->net,reply); reply.error = 0; }
 /**
  * Serve a file to a single client.
  *
@@ -998,7 +1098,7 @@ void negotiate(CLIENT *client) {
  * pieces. Preferably with a chainsaw.
  *
  * @param client The client we're going to serve to.
- * @return never
+ * @return when the client disconnects
  **/
 int mainloop(CLIENT *client) {
 	struct nbd_request request;
@@ -1018,8 +1118,6 @@ int mainloop(CLIENT *client) {
 		i++;
 		printf("%d: ", i);
 #endif
-		if (client->server->timeout) 
-			alarm(client->server->timeout);
 		readit(client->net, &request, sizeof(request));
 		request.from = ntohll(request.from);
 		request.type = ntohl(request.type);
@@ -1043,20 +1141,20 @@ int mainloop(CLIENT *client) {
 		if (len > BUFSIZE + sizeof(struct nbd_reply))
 			err("Request too big!");
 #ifdef DODBG
-		printf("%s from %Lu (%Lu) len %d, ", request.type ? "WRITE" :
+		printf("%s from %llu (%llu) len %d, ", request.type ? "WRITE" :
 				"READ", (unsigned long long)request.from,
 				(unsigned long long)request.from / 512, len);
 #endif
 		memcpy(reply.handle, request.handle, sizeof(reply.handle));
 		if ((request.from + len) > (OFFT_MAX)) {
 			DEBUG("[Number too large!]");
-			ERROR(client, reply);
+			ERROR(client, reply, EINVAL);
 			continue;
 		}
 
 		if (((ssize_t)((off_t)request.from + len) > client->exportsize)) {
 			DEBUG("[RANGE!]");
-			ERROR(client, reply);
+			ERROR(client, reply, EINVAL);
 			continue;
 		}
 
@@ -1067,12 +1165,12 @@ int mainloop(CLIENT *client) {
 			if ((client->server->flags & F_READONLY) ||
 			    (client->server->flags & F_AUTOREADONLY)) {
 				DEBUG("[WRITE to READONLY!]");
-				ERROR(client, reply);
+				ERROR(client, reply, EPERM);
 				continue;
 			}
 			if (expwrite(request.from, buf, len, client)) {
 				DEBUG("Write failed: %m" );
-				ERROR(client, reply);
+				ERROR(client, reply, errno);
 				continue;
 			}
 			SEND(client->net, reply);
@@ -1084,7 +1182,7 @@ int mainloop(CLIENT *client) {
 		DEBUG("exp->buf, ");
 		if (expread(request.from, buf + sizeof(struct nbd_reply), len, client)) {
 			DEBUG("Read failed: %m");
-			ERROR(client, reply);
+			ERROR(client, reply, errno);
 			continue;
 		}
 
@@ -1114,6 +1212,7 @@ void setupexport(CLIENT* client) {
 	for(i=0; ; i++) {
 		FILE_INFO fi;
 		gchar *tmpname;
+		gchar* error_string;
 		mode_t mode = (client->server->flags & F_READONLY) ? O_RDONLY : O_RDWR;
 
 		if(multifile) {
@@ -1127,14 +1226,21 @@ void setupexport(CLIENT* client) {
 			/* Try again because maybe media was read-only */
 			fi.fhandle = open(tmpname, O_RDONLY);
 			if(fi.fhandle != -1) {
-				client->server->flags |= F_AUTOREADONLY;
-				client->server->flags |= F_READONLY;
+				/* Opening the base file in copyonwrite mode is
+				 * okay */
+				if(!(client->server->flags & F_COPYONWRITE)) {
+					client->server->flags |= F_AUTOREADONLY;
+					client->server->flags |= F_READONLY;
+				}
 			}
 		}
 		if(fi.fhandle == -1) {
 			if(multifile && i>0)
 				break;
-			err("Could not open exported file: %m");
+			error_string=g_strdup_printf(
+				"Could not open exported file %s: %%m",
+				tmpname);
+			err(error_string);
 		}
 		fi.startoff = laststartoff + lastsize;
 		g_array_append_val(client->export, fi);
@@ -1162,7 +1268,7 @@ void setupexport(CLIENT* client) {
 		client->exportsize = client->server->expected_size;
 	}
 
-	msg3(LOG_INFO, "Size of exported file/device is %Lu", (unsigned long long)client->exportsize);
+	msg3(LOG_INFO, "Size of exported file/device is %llu", (unsigned long long)client->exportsize);
 	if(multifile) {
 		msg3(LOG_INFO, "Total number of files: %d", i);
 	}
@@ -1186,6 +1292,25 @@ int copyonwrite_prepare(CLIENT* client) {
 }
 
 /**
+ * Run a command. This is used for the ``prerun'' and ``postrun'' config file
+ * options
+ *
+ * @param command the command to be ran. Read from the config file
+ * @param file the file name we're about to export
+ **/
+int do_run(gchar* command, gchar* file) {
+	gchar* cmd;
+	int retval=0;
+
+	if(command && *command) {
+		cmd = g_strdup_printf(command, file);
+		retval=system(cmd);
+		g_free(cmd);
+	}
+	return retval;
+}
+
+/**
  * Serve a connection. 
  *
  * @todo allow for multithreading, perhaps use libevent. Not just yet, though;
@@ -1194,6 +1319,9 @@ int copyonwrite_prepare(CLIENT* client) {
  * @param client a connected client
  **/
 void serveconnection(CLIENT *client) {
+	if(do_run(client->server->prerun, client->exportname)) {
+		exit(EXIT_FAILURE);
+	}
 	setupexport(client);
 
 	if (client->server->flags & F_COPYONWRITE) {
@@ -1203,6 +1331,7 @@ void serveconnection(CLIENT *client) {
 	setmysockopt(client->net);
 
 	mainloop(client);
+	do_run(client->server->postrun, client->exportname);
 }
 
 /**
@@ -1251,10 +1380,10 @@ void set_peername(int net, CLIENT *client) {
 			break;
 	}
 
-	g_free(peername);
 	msg4(LOG_INFO, "connect from %s, assigned file is %s", 
 	     peername, client->exportname);
 	client->clientname=g_strdup(peername);
+	g_free(peername);
 }
 
 /**
@@ -1266,106 +1395,7 @@ void destroy_pid_t(gpointer data) {
 }
 
 /**
- * Go daemon (unless we specified at compile time that we didn't want this)
- * @param serve the first server of our configuration. If its port is zero,
- * 	then do not daemonize, because we're doing inetd then. This parameter
- * 	is only used to create a PID file of the form
- * 	/var/run/nbd-server.&lt;port&gt;.pid; it's not modified in any way.
- **/
-#if !defined(NODAEMON) && !defined(NOFORK)
-void daemonize(SERVER* serve) {
-	FILE*pidf;
-
-	if(daemon(0,0)<0) {
-		err("daemon");
-	}
-	if(serve) {
-		snprintf(pidfname, sizeof(char)*255, "/var/run/nbd-server.%d.pid", serve->port);
-	} else {
-		strncpy(pidfname, "/var/run/nbd-server.pid", sizeof(char)*255);
-	}
-	pidf=fopen(pidfname, "w");
-	if(pidf) {
-		fprintf(pidf,"%d\n", (int)getpid());
-		fclose(pidf);
-	} else {
-		perror("fopen");
-		fprintf(stderr, "Not fatal; continuing");
-	}
-}
-#else
-#define daemonize(serve)
-#endif /* !defined(NODAEMON) && !defined(NOFORK) */
-
-/**
- * Connect a server's socket.
- *
- * @param serve the server we want to connect.
- **/
-void setup_serve(SERVER *serve) {
-	struct sockaddr_in addrin;
-	struct sigaction sa;
-	int addrinlen = sizeof(addrin);
-	int sock_flags;
-#ifndef sun
-	int yes=1;
-#else
-	char yes='1';
-#endif /* sun */
-	if ((serve->socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
-		err("socket: %m");
-
-	/* lose the pesky "Address already in use" error message */
-	if (setsockopt(serve->socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
-	        err("setsockopt SO_REUSEADDR");
-	}
-	if (setsockopt(serve->socket,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
-		err("setsockopt SO_KEEPALIVE");
-	}
-
-	/* make the listening socket non-blocking */
-	if ((sock_flags = fcntl(serve->socket, F_GETFL, 0)) == -1) {
-		err("fcntl F_GETFL");
-	}
-	if (fcntl(serve->socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
-		err("fcntl F_SETFL O_NONBLOCK");
-	}
-
-	DEBUG("Waiting for connections... bind, ");
-	addrin.sin_family = AF_INET;
-	addrin.sin_port = htons(serve->port);
-	addrin.sin_addr.s_addr = 0;
-	if (bind(serve->socket, (struct sockaddr *) &addrin, addrinlen) < 0)
-		err("bind: %m");
-	DEBUG("listen, ");
-	if (listen(serve->socket, 1) < 0)
-		err("listen: %m");
-	sa.sa_handler = sigchld_handler;
-	sigemptyset(&sa.sa_mask);
-	sa.sa_flags = SA_RESTART;
-	if(sigaction(SIGCHLD, &sa, NULL) == -1)
-		err("sigaction: %m");
-	sa.sa_handler = sigterm_handler;
-	sigemptyset(&sa.sa_mask);
-	sa.sa_flags = SA_RESTART;
-	if(sigaction(SIGTERM, &sa, NULL) == -1)
-		err("sigaction: %m");
-	children=g_hash_table_new_full(g_int_hash, g_int_equal, NULL, destroy_pid_t);
-}
-
-/**
- * Connect our servers.
- **/
-void setup_servers(GArray* servers) {
-	int i;
-
-	for(i=0;i<servers->len;i++) {
-		setup_serve(&(g_array_index(servers, SERVER, i)));
-	}
-}
-
-/**
- * Loop through the available servers, and serve them.
+ * Loop through the available servers, and serve them. Never returns.
  **/
 int serveloop(GArray* servers) {
 	struct sockaddr_in addrin;
@@ -1376,7 +1406,6 @@ int serveloop(GArray* servers) {
 	int sock;
 	fd_set mset;
 	fd_set rset;
-	struct timeval tv;
 
 	/* 
 	 * Set up the master fd_set. The set of descriptors we need
@@ -1398,16 +1427,21 @@ int serveloop(GArray* servers) {
 		pid_t *pid;
 
 		memcpy(&rset, &mset, sizeof(fd_set));
-		tv.tv_sec=0;
-		tv.tv_usec=500;
-		if(select(max+1, &rset, NULL, NULL, &tv)>0) {
+		if(select(max+1, &rset, NULL, NULL, NULL)>0) {
 			DEBUG("accept, ");
 			for(i=0;i<servers->len;i++) {
 				serve=&(g_array_index(servers, SERVER, i));
 				if(FD_ISSET(serve->socket, &rset)) {
+					int sock_flags;
 					if ((net=accept(serve->socket, (struct sockaddr *) &addrin, &addrinlen)) < 0)
 						err("accept: %m");
 
+					if((sock_flags = fcntl(net, F_GETFL, 0))==-1) {
+						err("fcntl F_GETFL");
+					}
+					if(fcntl(net, F_SETFL, sock_flags &~O_NONBLOCK)==-1) {
+						err("fcntl F_SETFL ~O_NONBLOCK");
+					}
 					client = g_malloc(sizeof(CLIENT));
 					client->server=serve;
 					client->exportsize=OFFT_MAX;
@@ -1433,7 +1467,8 @@ int serveloop(GArray* servers) {
 					}
 					/* child */
 					g_hash_table_destroy(children);
-					for(i=0;i<servers->len,serve=(g_array_index(servers, SERVER*, i));i++) {
+					for(i=0;i<servers->len;i++) {
+						serve=&g_array_index(servers, SERVER, i);
 						close(serve->socket);
 					}
 					/* FALSE does not free the
@@ -1446,6 +1481,7 @@ int serveloop(GArray* servers) {
 #endif // NOFORK
 					msg2(LOG_INFO,"Starting to serve");
 					serveconnection(client);
+					exit(EXIT_SUCCESS);
 				}
 			}
 		}
@@ -1453,23 +1489,196 @@ int serveloop(GArray* servers) {
 }
 
 /**
+ * Connect a server's socket.
+ *
+ * @param serve the server we want to connect.
+ **/
+void setup_serve(SERVER *serve) {
+	struct sockaddr_in addrin;
+	struct sigaction sa;
+	int addrinlen = sizeof(addrin);
+	int sock_flags;
+	int af;
+#ifndef sun
+	int yes=1;
+#else
+	char yes='1';
+#endif /* sun */
+
+	af = AF_INET;
+#ifdef WITH_SDP
+	if ((serve->flags) && F_SDP) {
+		af = AF_INET_SDP;
+	}
+#endif
+	if ((serve->socket = socket(af, SOCK_STREAM, IPPROTO_TCP)) < 0)
+		err("socket: %m");
+
+	/* lose the pesky "Address already in use" error message */
+	if (setsockopt(serve->socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
+	        err("setsockopt SO_REUSEADDR");
+	}
+	if (setsockopt(serve->socket,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) {
+		err("setsockopt SO_KEEPALIVE");
+	}
+
+	/* make the listening socket non-blocking */
+	if ((sock_flags = fcntl(serve->socket, F_GETFL, 0)) == -1) {
+		err("fcntl F_GETFL");
+	}
+	if (fcntl(serve->socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
+		err("fcntl F_SETFL O_NONBLOCK");
+	}
+
+	DEBUG("Waiting for connections... bind, ");
+	addrin.sin_family = AF_INET;
+#ifdef WITH_SDP
+	if(serve->flags & F_SDP) {
+		addrin.sin_family = AF_INET_SDP;
+	}
+#endif
+	addrin.sin_port = htons(serve->port);
+	if(!inet_aton(serve->listenaddr, &(addrin.sin_addr)))
+		err("could not parse listen address");
+	if (bind(serve->socket, (struct sockaddr *) &addrin, addrinlen) < 0)
+		err("bind: %m");
+	DEBUG("listen, ");
+	if (listen(serve->socket, 1) < 0)
+		err("listen: %m");
+	sa.sa_handler = sigchld_handler;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESTART;
+	if(sigaction(SIGCHLD, &sa, NULL) == -1)
+		err("sigaction: %m");
+	sa.sa_handler = sigterm_handler;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESTART;
+	if(sigaction(SIGTERM, &sa, NULL) == -1)
+		err("sigaction: %m");
+}
+
+/**
+ * Connect our servers.
+ **/
+void setup_servers(GArray* servers) {
+	int i;
+
+	for(i=0;i<servers->len;i++) {
+		setup_serve(&(g_array_index(servers, SERVER, i)));
+	}
+	children=g_hash_table_new_full(g_int_hash, g_int_equal, NULL, destroy_pid_t);
+}
+
+/**
+ * Go daemon (unless we specified at compile time that we didn't want this)
+ * @param serve the first server of our configuration. If its port is zero,
+ * 	then do not daemonize, because we're doing inetd then. This parameter
+ * 	is only used to create a PID file of the form
+ * 	/var/run/nbd-server.&lt;port&gt;.pid; it's not modified in any way.
+ **/
+#if !defined(NODAEMON) && !defined(NOFORK)
+void daemonize(SERVER* serve) {
+	FILE*pidf;
+
+	if(serve && !(serve->port)) {
+		return;
+	}
+	if(daemon(0,0)<0) {
+		err("daemon");
+	}
+	if(!*pidftemplate) {
+		if(serve) {
+			strncpy(pidftemplate, "/var/run/nbd-server.%d.pid", 255);
+		} else {
+			strncpy(pidftemplate, "/var/run/nbd-server.pid", 255);
+		}
+	}
+	snprintf(pidfname, 255, pidftemplate, serve ? serve->port : 0);
+	pidf=fopen(pidfname, "w");
+	if(pidf) {
+		fprintf(pidf,"%d\n", (int)getpid());
+		fclose(pidf);
+	} else {
+		perror("fopen");
+		fprintf(stderr, "Not fatal; continuing");
+	}
+}
+#else
+#define daemonize(serve)
+#endif /* !defined(NODAEMON) && !defined(NOFORK) */
+
+/*
+ * Everything beyond this point (in the file) is run in non-daemon mode.
+ * The stuff above daemonize() isn't.
+ */
+
+void serve_err(SERVER* serve, const char* msg) G_GNUC_NORETURN;
+
+void serve_err(SERVER* serve, const char* msg) {
+	g_message("Export of %s on port %d failed:", serve->exportname,
+			serve->port);
+	err(msg);
+}
+
+/**
  * Set up user-ID and/or group-ID
  **/
 void dousers(void) {
 	struct passwd *pw;
 	struct group *gr;
-	if(runuser) {
-		pw=getpwnam(runuser);
-		if(setuid(pw->pw_uid)<0)
-			msg3(LOG_DEBUG, "Could not set UID: %s", strerror(errno));
-	}
 	if(rungroup) {
 		gr=getgrnam(rungroup);
-		if(setgid(gr->gr_gid)<0)
-			msg3(LOG_DEBUG, "Could not set GID: %s", strerror(errno));
+		if(!gr) {
+			g_message("Invalid group name: %s", rungroup);
+			exit(EXIT_FAILURE);
+		}
+		if(setgid(gr->gr_gid)<0) {
+			g_message("Could not set GID: %s", strerror(errno));
+			exit(EXIT_FAILURE);
+		}
+	}
+	if(runuser) {
+		pw=getpwnam(runuser);
+		if(!pw) {
+			g_message("Invalid user name: %s", runuser);
+			exit(EXIT_FAILURE);
+		}
+		if(setuid(pw->pw_uid)<0) {
+			g_message("Could not set UID: %s", strerror(errno));
+			exit(EXIT_FAILURE);
+		}
 	}
 }
 
+#ifndef ISSERVER
+void glib_message_syslog_redirect(const gchar *log_domain,
+                                  GLogLevelFlags log_level,
+                                  const gchar *message,
+                                  gpointer user_data)
+{
+    int level=LOG_DEBUG;
+    
+    switch( log_level )
+    {
+      case G_LOG_FLAG_FATAL:
+      case G_LOG_LEVEL_CRITICAL:
+      case G_LOG_LEVEL_ERROR:    
+        level=LOG_ERR; 
+        break;
+      case G_LOG_LEVEL_WARNING:
+        level=LOG_WARNING;
+        break;
+      case G_LOG_LEVEL_MESSAGE:
+      case G_LOG_LEVEL_INFO:
+        level=LOG_INFO;
+        break;
+      case G_LOG_LEVEL_DEBUG:
+        level=LOG_DEBUG;
+    }
+    syslog(level, message);
+}
+#endif
+
 /**
  * Main entry point...
  **/
@@ -1480,43 +1689,47 @@ int main(int argc, char *argv[]) {
 
 	if (sizeof( struct nbd_request )!=28) {
 		fprintf(stderr,"Bad size of structure. Alignment problems?\n");
-		exit(-1) ;
+		exit(EXIT_FAILURE) ;
 	}
 
+	memset(pidftemplate, '\0', 256);
+
 	logging();
 	config_file_pos = g_strdup(CFILE);
 	serve=cmdline(argc, argv);
 	servers = parse_cfile(config_file_pos, &err);
-	if(!servers || !servers->len) {
-		g_warning("Could not parse config file: %s", err->message);
-	}
+	
 	if(serve) {
 		g_array_append_val(servers, *serve);
-	}
-
-/* We don't support this at this time */
-#if 0
-	if (!(serve->port)) {
-	  	CLIENT *client;
+     
+		if (!(serve->port)) {
+			CLIENT *client;
 #ifndef ISSERVER
-		/* You really should define ISSERVER if you're going to use
-		 * inetd mode, but if you don't, closing stdout and stderr
-		 * (which inetd had connected to the client socket) will let it
-		 * work. */
-          	close(1);
-          	close(2);
-          	open("/dev/null", O_WRONLY);
-          	open("/dev/null", O_WRONLY);
-#endif
-		client=g_malloc(sizeof(CLIENT));
-		client->server=serve;
-		client->net=0;
-		client->exportsize=OFFT_MAX;
-          	set_peername(0,client);
-          	serveconnection(client);
-          	return 0;
-        }
+			/* You really should define ISSERVER if you're going to use
+			 * inetd mode, but if you don't, closing stdout and stderr
+			 * (which inetd had connected to the client socket) will let it
+			 * work. */
+			close(1);
+			close(2);
+			open("/dev/null", O_WRONLY);
+			open("/dev/null", O_WRONLY);
+			g_log_set_default_handler( glib_message_syslog_redirect, NULL );
 #endif
+			client=g_malloc(sizeof(CLIENT));
+			client->server=serve;
+			client->net=0;
+			client->exportsize=OFFT_MAX;
+			set_peername(0,client);
+			serveconnection(client);
+			return 0;
+		}
+	}
+    
+    if(!servers || !servers->len) {
+		g_warning("Could not parse config file: %s", 
+				err ? err->message : "Unknown error");
+	}
+    
 	if((!serve) && (!servers||!servers->len)) {
 		g_message("Nothing to do! Bye!");
 		exit(EXIT_FAILURE);