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

diff --git a/nbd-server.c b/nbd-server.c
index 122d2fe..f07a29f 100644
--- a/nbd-server.c
+++ b/nbd-server.c
@@ -49,6 +49,10 @@
  * 11/02/2004 - Doxygenified the source, modularized it a bit. Needs a 
  * 	lot more work, but this is a start. Wouter Verhelst
  * 	<wouter@debian.org>
+ * 16/03/2010 - Add IPv6 support.
+ *	Kitt Tientanopajai <kitt@kitty.in.th>
+ *	Neutron Soutmun <neo.neutron@gmail.com>
+ *	Suriya Soutmun <darksolar@gmail.com>
  */
 
 /* Includes LFS defines, which defines behaviours of some of the following
@@ -70,8 +74,8 @@
 #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* */
+#include <netinet/in.h>
+#include <netdb.h>
 #include <syslog.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -155,6 +159,13 @@ 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 */
 
+int modernsock=0;	  /**< Socket for the modern handler. Not used
+			       if a client was only specified on the
+			       command line; only port used if
+			       oldstyle is set to false (and then the
+			       command-line client isn't used, gna gna) */
+char* modern_listen;	  /**< listenaddr value for modernsock */
+
 /**
  * Types of virtuatlization
  **/
@@ -178,6 +189,7 @@ typedef struct {
 	char* authname;      /**< filename of the authorization file */
 	int flags;           /**< flags associated with this exported file */
 	int socket;	     /**< The socket of this server. */
+	int socket_family;   /**< family of the socket */
 	VIRT_STYLE virtstyle;/**< The style of virtualization, if any */
 	uint8_t cidrlen;     /**< The length of the mask when we use
 				  CIDR-style virtualization */
@@ -185,6 +197,7 @@ typedef struct {
 				  but before starting to serve */
 	gchar* postrun;	     /**< command that will be ran after the client
 				  disconnects */
+	gchar* servename;    /**< name of the export as selected by nbd-client */
 } SERVER;
 
 /**
@@ -210,6 +223,7 @@ typedef struct {
 			       make -m and -c mutually exclusive */
 	u32 difffilelen;     /**< number of pages in difffile */
 	u32 *difmap;	     /**< see comment on the global difmap for this one */
+	gboolean modern;     /**< client was negotiated using modern negotiation protocol */
 } CLIENT;
 
 /**
@@ -269,7 +283,7 @@ int authorized_client(CLIENT *opts) {
 				return 0;
 			}
 			*(tmp++)=0;
-			if(inet_aton(line,&addr)) {
+			if(!inet_aton(line,&addr)) {
 				msg4(LOG_CRIT, ERRMSG, line, opts->server->authname);
 				return 0;
 			}
@@ -338,7 +352,7 @@ inline void writeit(int f, void *buf, size_t len) {
  */
 void usage() {
 	printf("This is nbd-server version " VERSION "\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"
+	printf("Usage: [ip:|ip6@]port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-C configuration file] [-p PID file name] [-o section name]\n"
 	       "\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"
@@ -417,12 +431,24 @@ SERVER* cmdline(int argc, char *argv[]) {
 			/* non-option argument */
 			switch(nonspecial++) {
 			case 0:
-				addr_port=g_strsplit(optarg, ":", 2);
+				if(strchr(optarg, ':') == strrchr(optarg, ':')) {
+					addr_port=g_strsplit(optarg, ":", 2);
+
+					/* Check for "@" - maybe user using this separator
+						 for IPv4 address */
+					if(!addr_port[1]) {
+						g_strfreev(addr_port);
+						addr_port=g_strsplit(optarg, "@", 2);
+					}
+				} else {
+					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->listenaddr=NULL;
 					serve->port=strtol(addr_port[0], NULL, 0);
 				}
 				g_strfreev(addr_port);
@@ -508,8 +534,10 @@ typedef enum {
 	CFILE_VALUE_INVALID,	/**< A value is syntactically invalid */
 	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
+	CFILE_NO_EXPORTS,	/**< A config file was specified that does not
 				     define any exports */
+	CFILE_INCORRECT_PORT,	/**< The reserved port was specified for an
+				     old-style export. */
 } CFILE_ERRORS;
 
 /**
@@ -522,10 +550,121 @@ void remove_server(gpointer s) {
 	g_free(server->exportname);
 	if(server->authname)
 		g_free(server->authname);
+	if(server->listenaddr)
+		g_free(server->listenaddr);
+	if(server->prerun)
+		g_free(server->prerun);
+	if(server->postrun)
+		g_free(server->postrun);
 	g_free(server);
 }
 
 /**
+ * duplicate server
+ * @param s the old server we want to duplicate
+ * @return new duplicated server
+ **/
+SERVER* dup_serve(SERVER *s) {
+	SERVER *serve = NULL;
+
+	serve=g_new0(SERVER, 1);
+	if (serve == NULL)
+		return NULL;
+
+	if (s->exportname)
+		serve->exportname = g_strdup(s->exportname);
+
+	serve->expected_size = s->expected_size;
+
+	if (s->listenaddr)
+		serve->listenaddr = g_strdup(s->listenaddr);
+
+	serve->port = s->port;
+
+	if (s->authname)
+		serve->authname = strdup(s->authname);
+
+	serve->flags = s->flags;
+	serve->socket = serve->socket;
+	serve->socket_family = serve->socket_family;
+	serve->cidrlen = s->cidrlen;
+
+	if (s->prerun)
+		serve->prerun = g_strdup(s->prerun);
+
+	if (s->postrun)
+		serve->postrun = g_strdup(s->postrun);
+
+	return serve;
+}
+
+/**
+ * append new server to array
+ * @param s server
+ * @param a server array
+ * @return 0 success, -1 error
+ */
+int append_serve(SERVER *s, GArray *a) {
+	SERVER *ns = NULL;
+	struct addrinfo hints;
+	struct addrinfo *ai = NULL;
+	struct addrinfo *rp = NULL;
+	char   host[NI_MAXHOST];
+	gchar  *port = NULL;
+	int e;
+	int ret;
+
+	if(!s) {
+		err("Invalid parsing server");
+		return -1;
+	}
+
+	port = g_strdup_printf("%d", s->port);
+
+	memset(&hints,'\0',sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	e = getaddrinfo(s->listenaddr, port, &hints, &ai);
+
+	if (port)
+		g_free(port);
+
+	if(e == 0) {
+		for (rp = ai; rp != NULL; rp = rp->ai_next) {
+			e = getnameinfo(rp->ai_addr, rp->ai_addrlen, host, sizeof(host), NULL, 0, NI_NUMERICHOST);
+
+			if (e != 0) { // error
+				fprintf(stderr, "getnameinfo: %s\n", gai_strerror(e));
+				continue;
+			}
+
+			// duplicate server and set listenaddr to resolved IP address
+			ns = dup_serve (s);
+			if (ns) {
+				ns->listenaddr = g_strdup(host);
+				ns->socket_family = rp->ai_family;
+				g_array_append_val(a, *ns);
+				free(ns);
+				ns = NULL;
+			}
+		}
+
+		ret = 0;
+	} else {
+		fprintf(stderr, "getaddrinfo failed on listen host/address: %s (%s)\n", s->listenaddr ? s->listenaddr : "any", gai_strerror(e));
+		ret = -1;
+	}
+
+	if (ai)
+		freeaddrinfo(ai);
+
+	return ret;
+}
+
+/**
  * Parse the config file.
  *
  * @param f the name of the config file
@@ -557,9 +696,12 @@ GArray* parse_cfile(gchar* f, GError** e) {
 		{ "listenaddr", FALSE,  PARAM_STRING,   NULL, 0 },
 	};
 	const int lp_size=sizeof(lp)/sizeof(PARAM);
+	int do_oldstyle;
 	PARAM gp[] = {
 		{ "user",	FALSE, PARAM_STRING,	&runuser,	0 },
 		{ "group",	FALSE, PARAM_STRING,	&rungroup,	0 },
+		{ "oldstyle",	FALSE, PARAM_BOOL,	&do_oldstyle,	1 },
+		{ "listenaddr", FALSE, PARAM_STRING,	&modern_listen, 0 },
 	};
 	PARAM* p=gp;
 	int p_size=sizeof(gp)/sizeof(PARAM);
@@ -640,6 +782,11 @@ GArray* parse_cfile(gchar* f, GError** e) {
 					}
 					break;
 			}
+			if(!strcmp(p[j].paramname, "port") && !strcmp(p[j].target, NBD_DEFAULT_PORT)) {
+				g_set_error(e, errdomain, CFILE_INCORRECT_PORT, "Config file specifies default port for oldstyle export");
+				g_key_file_free(cfile);
+				return NULL;
+			}
 			if(err) {
 				if(err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
 					if(!p[j].required) {
@@ -688,10 +835,14 @@ 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");
+			s.socket_family = AF_UNSPEC;
+			s.servename = groups[i];
+
+			append_serve(&s, retval);
+		} else {
+			if(!do_oldstyle) {
+				lp[1].required = 0;
 			}
-			g_array_append_val(retval, s);
 		}
 #ifndef WITH_SDP
 		if(s.flags & F_SDP) {
@@ -783,7 +934,7 @@ off_t size_autodetect(int fhandle) {
 #ifdef HAVE_SYS_IOCTL_H
 #ifdef BLKGETSIZE64
 	DEBUG("looking for export size with ioctl BLKGETSIZE64\n");
-	if (!ioctl(fhandle, BLKGETSIZE64, bytes) && bytes) {
+	if (!ioctl(fhandle, BLKGETSIZE64, &bytes) && bytes) {
 		return (off_t)bytes;
 	}
 #endif /* BLKGETSIZE64 */
@@ -1062,19 +1213,69 @@ int expwrite(off_t a, char *buf, size_t len, CLIENT *client) {
  *
  * @param client The client we're negotiating with.
  **/
-void negotiate(CLIENT *client) {
+CLIENT* negotiate(int net, CLIENT *client, GArray* servers) {
 	char zeros[128];
-	u64 size_host;
-	u32 flags = NBD_FLAG_HAS_FLAGS;
+	uint64_t size_host;
+	uint32_t flags = NBD_FLAG_HAS_FLAGS;
+	uint16_t smallflags = 0;
 
 	memset(zeros, '\0', sizeof(zeros));
-	if (write(client->net, INIT_PASSWD, 8) < 0)
-		err("Negotiation failed: %m");
-	cliserv_magic = htonll(cliserv_magic);
-	if (write(client->net, &cliserv_magic, sizeof(cliserv_magic)) < 0)
-		err("Negotiation failed: %m");
+	if(!client || !client->modern) {
+		if (write(net, INIT_PASSWD, 8) < 0) {
+			err_nonfatal("Negotiation failed: %m");
+			if(client)
+				exit(EXIT_FAILURE);
+		}
+		cliserv_magic = htonll(cliserv_magic);
+		if (write(net, &cliserv_magic, sizeof(cliserv_magic)) < 0) {
+			err_nonfatal("Negotiation failed: %m");
+			if(client)
+				exit(EXIT_FAILURE);
+		}
+	}
+	if(!client) {
+		uint64_t reserved;
+		uint64_t magic;
+		uint32_t opt;
+		uint64_t namelen;
+		char* name;
+		int i;
+
+		if(!servers)
+			err("programmer error");
+		write(net, &smallflags, sizeof(uint16_t));
+		read(net, &reserved, sizeof(reserved));
+		read(net, &magic, sizeof(magic));
+		magic = ntohll(magic);
+		if(magic != cliserv_magic) {
+			close(net);
+			return NULL;
+		}
+		read(net, &opt, sizeof(opt));
+		opt = ntohl(opt);
+		if(opt != NBD_OPT_EXPORT_NAME) {
+			close(net);
+			return NULL;
+		}
+		read(net, &namelen, sizeof(namelen));
+		namelen = ntohll(namelen);
+		name = malloc(namelen+1);
+		name[namelen+1]=0;
+		read(net, &name, namelen);
+		for(i=0; i<servers->len; i++) {
+			SERVER* serve = &(g_array_index(servers, SERVER, i));
+			if(!strcmp(serve->servename, name)) {
+				CLIENT* client = g_new0(CLIENT, 1);
+				client->server = serve;
+				client->exportsize = OFFT_MAX;
+				client->net = net;
+				client->modern = TRUE;
+				return client;
+			}
+		}
+	}
 	size_host = htonll((u64)(client->exportsize));
-	if (write(client->net, &size_host, 8) < 0)
+	if (write(net, &size_host, 8) < 0)
 		err("Negotiation failed: %m");
 	if (client->server->flags & F_READONLY)
 		flags |= NBD_FLAG_READ_ONLY;
@@ -1083,6 +1284,7 @@ void negotiate(CLIENT *client) {
 		err("Negotiation failed: %m");
 	if (write(client->net, zeros, 124) < 0)
 		err("Negotiation failed: %m");
+	return NULL;
 }
 
 /** sending macro. */
@@ -1105,7 +1307,7 @@ int mainloop(CLIENT *client) {
 #ifdef DODBG
 	int i = 0;
 #endif
-	negotiate(client);
+	negotiate(client->net, client, NULL);
 	DEBUG("Entering request loop!\n");
 	reply.magic = htonl(NBD_REPLY_MAGIC);
 	reply.error = 0;
@@ -1344,17 +1546,36 @@ void serveconnection(CLIENT *client) {
  * stored in client->clientname.
  **/
 void set_peername(int net, CLIENT *client) {
-	struct sockaddr_in addrin;
-	struct sockaddr_in netaddr;
+	struct sockaddr_storage addrin;
+	struct sockaddr_storage netaddr;
+	struct sockaddr_in  *netaddr4 = NULL;
+	struct sockaddr_in6 *netaddr6 = NULL;
 	size_t addrinlen = sizeof( addrin );
-	char *peername;
-	char *netname;
-	char *tmp;
+	struct addrinfo hints;
+	struct addrinfo *ai = NULL;
+	char peername[NI_MAXHOST];
+	char netname[NI_MAXHOST];
+	char *tmp = NULL;
 	int i;
+	int e;
+	int shift;
 
 	if (getpeername(net, (struct sockaddr *) &addrin, (socklen_t *)&addrinlen) < 0)
 		err("getsockname failed: %m");
-	peername = g_strdup(inet_ntoa(addrin.sin_addr));
+
+	getnameinfo((struct sockaddr *)&addrin, (socklen_t)addrinlen,
+		peername, sizeof (peername), NULL, 0, NI_NUMERICHOST);
+
+	memset(&hints, '\0', sizeof (hints));
+	hints.ai_flags = AI_ADDRCONFIG;
+	e = getaddrinfo(peername, NULL, &hints, &ai);
+
+	if(e != 0) {
+		fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
+		freeaddrinfo(ai);
+		return;
+	}
+
 	switch(client->server->virtstyle) {
 		case VIRT_NONE:
 			client->exportname=g_strdup(client->server->exportname);
@@ -1370,18 +1591,42 @@ void set_peername(int net, CLIENT *client) {
 			break;
 		case VIRT_CIDR:
 			memcpy(&netaddr, &addrin, addrinlen);
-			netaddr.sin_addr.s_addr>>=32-(client->server->cidrlen);
-			netaddr.sin_addr.s_addr<<=32-(client->server->cidrlen);
-			netname = inet_ntoa(netaddr.sin_addr);
-			tmp=g_strdup_printf("%s/%s", netname, peername);
-			client->exportname=g_strdup_printf(client->server->exportname, tmp);
+			if(ai->ai_family == AF_INET) {
+				netaddr4 = (struct sockaddr_in *)&netaddr;
+				(netaddr4->sin_addr).s_addr>>=32-(client->server->cidrlen);
+				(netaddr4->sin_addr).s_addr<<=32-(client->server->cidrlen);
+
+				getnameinfo((struct sockaddr *) netaddr4, (socklen_t) addrinlen,
+							netname, sizeof (netname), NULL, 0, NI_NUMERICHOST);
+				tmp=g_strdup_printf("%s/%s", netname, peername);
+			}else if(ai->ai_family == AF_INET6) {
+				netaddr6 = (struct sockaddr_in6 *)&netaddr;
+
+				shift = 128-(client->server->cidrlen);
+				i = 3;
+				while(shift >= 32) {
+					((netaddr6->sin6_addr).s6_addr32[i])=0;
+					shift-=32;
+					i--;
+				}
+				(netaddr6->sin6_addr).s6_addr32[i]>>=shift;
+				(netaddr6->sin6_addr).s6_addr32[i]<<=shift;
+
+				getnameinfo((struct sockaddr *)netaddr6, (socklen_t)addrinlen,
+					    netname, sizeof(netname), NULL, 0, NI_NUMERICHOST);
+				tmp=g_strdup_printf("%s/%s", netname, peername);
+			}
+
+			if(tmp != NULL)
+			  client->exportname=g_strdup_printf(client->server->exportname, tmp);
+
 			break;
 	}
 
+	freeaddrinfo(ai);
 	msg4(LOG_INFO, "connect from %s, assigned file is %s", 
 	     peername, client->exportname);
 	client->clientname=g_strdup(peername);
-	g_free(peername);
 }
 
 /**
@@ -1396,9 +1641,8 @@ void destroy_pid_t(gpointer data) {
  * Loop through the available servers, and serve them. Never returns.
  **/
 int serveloop(GArray* servers) {
-	struct sockaddr_in addrin;
+	struct sockaddr_storage addrin;
 	socklen_t addrinlen=sizeof(addrin);
-	SERVER *serve;
 	int i;
 	int max;
 	int sock;
@@ -1419,142 +1663,210 @@ int serveloop(GArray* servers) {
 		FD_SET(sock, &mset);
 		max=sock>max?sock:max;
 	}
+	if(modernsock) {
+		FD_SET(modernsock, &mset);
+		max=modernsock>max?sock:max;
+	}
 	for(;;) {
-		CLIENT *client;
-		int net;
+		CLIENT *client = NULL;
 		pid_t *pid;
 
 		memcpy(&rset, &mset, sizeof(fd_set));
 		if(select(max+1, &rset, NULL, NULL, NULL)>0) {
+			int net = 0;
+			SERVER* serve;
+
 			DEBUG("accept, ");
-			for(i=0;i<servers->len;i++) {
+			if(FD_ISSET(modernsock, &rset)) {
+				if((net=accept(modernsock, (struct sockaddr *) &addrin, &addrinlen)) < 0)
+					err("accept: %m");
+				client = negotiate(net, NULL, servers);
+				if(!client) {
+					err_nonfatal("negotiation failed");
+					close(net);
+				}
+			}
+			for(i=0;i<servers->len && !net;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(net) {
+				int sock_flags;
 
-					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));
+				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");
+				}
+				if(!client) {
+					client = g_new0(CLIENT, 1);
 					client->server=serve;
 					client->exportsize=OFFT_MAX;
 					client->net=net;
-					set_peername(net, client);
-					if (!authorized_client(client)) {
-						msg2(LOG_INFO,"Unauthorized client") ;
-						close(net);
-						continue;
-					}
-					msg2(LOG_INFO,"Authorized client") ;
-					pid=g_malloc(sizeof(pid_t));
+				}
+				set_peername(net, client);
+				if (!authorized_client(client)) {
+					msg2(LOG_INFO,"Unauthorized client") ;
+					close(net);
+					continue;
+				}
+				msg2(LOG_INFO,"Authorized client") ;
+				pid=g_malloc(sizeof(pid_t));
 #ifndef NOFORK
-					if ((*pid=fork())<0) {
-						msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
-						close(net);
-						continue;
-					}
-					if (*pid>0) { /* parent */
-						close(net);
-						g_hash_table_insert(children, pid, pid);
-						continue;
-					}
-					/* child */
-					g_hash_table_destroy(children);
-					for(i=0;i<servers->len;i++) {
-						serve=&g_array_index(servers, SERVER, i);
-						close(serve->socket);
-					}
-					/* FALSE does not free the
-					actual data. This is required,
-					because the client has a
-					direct reference into that
-					data, and otherwise we get a
-					segfault... */
-					g_array_free(servers, FALSE);
-#endif // NOFORK
-					msg2(LOG_INFO,"Starting to serve");
-					serveconnection(client);
-					exit(EXIT_SUCCESS);
+				if ((*pid=fork())<0) {
+					msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ;
+					close(net);
+					continue;
 				}
+				if (*pid>0) { /* parent */
+					close(net);
+					g_hash_table_insert(children, pid, pid);
+					continue;
+				}
+				/* child */
+				g_hash_table_destroy(children);
+				for(i=0;i<servers->len;i++) {
+					serve=&g_array_index(servers, SERVER, i);
+					close(serve->socket);
+				}
+				/* FALSE does not free the
+				actual data. This is required,
+				because the client has a
+				direct reference into that
+				data, and otherwise we get a
+				segfault... */
+				g_array_free(servers, FALSE);
+#endif // NOFORK
+				msg2(LOG_INFO,"Starting to serve");
+				serveconnection(client);
+				exit(EXIT_SUCCESS);
 			}
 		}
 	}
 }
 
-/**
- * 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;
+void dosockopts(int socket) {
 #ifndef sun
 	int yes=1;
 #else
 	char yes='1';
 #endif /* sun */
-	struct hostent* he;
-
-	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");
+	int sock_flags;
 
 	/* lose the pesky "Address already in use" error message */
-	if (setsockopt(serve->socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
+	if (setsockopt(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) {
+	if (setsockopt(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) {
+	if ((sock_flags = fcntl(socket, F_GETFL, 0)) == -1) {
 		err("fcntl F_GETFL");
 	}
-	if (fcntl(serve->socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
+	if (fcntl(socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
 		err("fcntl F_SETFL O_NONBLOCK");
 	}
+}
+
+/**
+ * Connect a server's socket.
+ *
+ * @param serve the server we want to connect.
+ **/
+int setup_serve(SERVER *serve) {
+	struct addrinfo hints;
+	struct addrinfo *ai = NULL;
+	gchar *port = NULL;
+	int e;
+
+	memset(&hints,'\0',sizeof(hints));
+	hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG | AI_NUMERICSERV;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_family = serve->socket_family;
+
+	port = g_strdup_printf ("%d", serve->port);
+	if (port == NULL)
+		return 0;
+
+	e = getaddrinfo(serve->listenaddr,port,&hints,&ai);
+
+	g_free(port);
+
+	if(e != 0) {
+		fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
+		serve->socket = -1;
+		freeaddrinfo(ai);
+		exit(EXIT_FAILURE);
+	}
+
+	if(serve->socket_family == AF_UNSPEC)
+		serve->socket_family = ai->ai_family;
 
-	DEBUG("Waiting for connections... bind, ");
-	addrin.sin_family = AF_INET;
 #ifdef WITH_SDP
-	if(serve->flags & F_SDP) {
-		addrin.sin_family = AF_INET_SDP;
+	if ((serve->flags) && F_SDP) {
+		if (ai->ai_family == AF_INET)
+			ai->ai_family = AF_INET_SDP;
+		else (ai->ai_family == AF_INET6)
+			ai->ai_family = AF_INET6_SDP;
 	}
 #endif
-	addrin.sin_port = htons(serve->port);
-	if(!(he = gethostbyname(serve->listenaddr)))
-		err("could not parse listen address");
-        addrin.sin_addr = he->h_addr_list[0];
-	if (bind(serve->socket, (struct sockaddr *) &addrin, addrinlen) < 0)
+	if ((serve->socket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) < 0)
+		err("socket: %m");
+
+	dosockopts(serve->socket);
+
+	DEBUG("Waiting for connections... bind, ");
+	e = bind(serve->socket, ai->ai_addr, ai->ai_addrlen);
+	if (e != 0 && errno != EADDRINUSE)
 		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");
+
+	freeaddrinfo (ai);
+	if(serve->servename) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+void open_modern(void) {
+	struct addrinfo hints;
+	struct addrinfo* ai = NULL;
+	struct sock_flags;
+	int e;
+
+	memset(&hints, '\0', sizeof(hints));
+	hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_protocol = IPPROTO_TCP;
+	e = getaddrinfo(modern_listen, NBD_DEFAULT_PORT, &hints, &ai);
+	if(e != 0) {
+		fprintf(stderr, "getaddrinfo failed: %s\n", gai_strerror(e));
+		exit(EXIT_FAILURE);
+	}
+	if((modernsock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol))<0) {
+		err("socket: %m");
+	}
+
+	dosockopts(modernsock);
+
+	if(bind(modernsock, ai->ai_addr, ai->ai_addrlen)) {
+		err("bind: %m");
+	}
+	if(listen(modernsock, 10) <0) {
+		err("listen: %m");
+	}
+
+	freeaddrinfo(ai);
 }
 
 /**
@@ -1562,11 +1874,27 @@ void setup_serve(SERVER *serve) {
  **/
 void setup_servers(GArray* servers) {
 	int i;
+	struct sigaction sa;
+	int want_modern=0;
 
 	for(i=0;i<servers->len;i++) {
-		setup_serve(&(g_array_index(servers, SERVER, i)));
+		want_modern |= setup_serve(&(g_array_index(servers, SERVER, i)));
+	}
+	if(want_modern) {
+		open_modern();
 	}
 	children=g_hash_table_new_full(g_int_hash, g_int_equal, NULL, destroy_pid_t);
+
+	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");
 }
 
 /**
@@ -1701,7 +2029,9 @@ int main(int argc, char *argv[]) {
 	servers = parse_cfile(config_file_pos, &err);
 	
 	if(serve) {
-		g_array_append_val(servers, *serve);
+		serve->socket_family = AF_UNSPEC;
+
+		append_serve(serve, servers);
      
 		if (!(serve->port)) {
 			CLIENT *client;
@@ -1726,11 +2056,15 @@ int main(int argc, char *argv[]) {
 		}
 	}
     
-    if(!servers || !servers->len) {
+	if(!servers || !servers->len) {
 		g_warning("Could not parse config file: %s", 
 				err ? err->message : "Unknown error");
 	}
-    
+	if(serve) {
+		g_warning("Specifying an export on the command line is deprecated.");
+		g_warning("Please use a configuration file instead.");
+	}
+
 	if((!serve) && (!servers||!servers->len)) {
 		g_message("Nothing to do! Bye!");
 		exit(EXIT_FAILURE);