#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* */
**/
#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 */
#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 */
GHashTable *children;
char pidfname[256]; /**< name of our PID file */
char pidftemplate[256]; /**< template to be used for the filename of the PID file */
**/
typedef struct {
gchar* exportname; /**< (unprocessed) filename of the file we're exporting */
+ gchar* cowname; /**< template for the filename of the copy-on-write file */
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 */
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;
/**
*/
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] [-p PID file name] [-o section name]\n"
+ printf("Usage: [ip:]port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-a timeout_sec] [-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-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);
}
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");
size_t last;
char suffix;
gboolean do_output=FALSE;
- gchar* section_header;
+ gchar* section_header="";
+ gchar** addr_port;
if(argc==1) {
return NULL;
}
serve=g_new0(SERVER, 1);
serve->authname = g_strdup(default_authname);
+ 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);
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_VALUE_UNSUPPORTED,/**< A value is not supported in this build */
CFILE_PROGERR /**< Programmer error */
} CFILE_ERRORS;
{ "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 },
+ { "listenaddr", FALSE, PARAM_STRING, NULL, 0 },
+ { "cowname", 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;
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[6].target=&(s.prerun);
+ lp[7].target=&(s.postrun);
+ lp[8].target=lp[9].target=lp[10].target=
+ lp[11].target=lp[12].target=&(s.flags);
+ lp[13].target=&(s.listenaddr);
+ lp[14].target=&(s.cowname);
+
+ s.cowname = "$F-$I-$P.diff";
+
/* After the [generic] group, start parsing exports */
if(i==1) {
p=lp;
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
}
return retval;
}
unlink(pidfname);
}
- exit(0);
+ exit(EXIT_SUCCESS);
}
/**
* @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;
* @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;
* @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);
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.
*
* 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;
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;
}
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);
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;
}
/* 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) {
}
/**
+ * 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;
* @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) {
setmysockopt(client->net);
mainloop(client);
+ do_run(client->server->postrun, client->exportname);
}
/**
}
/**
- * 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.<port>.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/server.%d.pid", 255);
- } else {
- strncpy(pidftemplate, "/var/run/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) */
-
-/**
- * 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");
-}
-
-/**
- * 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);
-}
-
-/**
- * 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;
int sock;
fd_set mset;
fd_set rset;
- struct timeval tv;
/*
* Set up the master fd_set. The set of descriptors we need
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));
}
/* 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
#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;
+#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.<port>.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);
+ }
}
}
if (sizeof( struct nbd_request )!=28) {
fprintf(stderr,"Bad size of structure. Alignment problems?\n");
- exit(-1) ;
+ exit(EXIT_FAILURE) ;
}
memset(pidftemplate, '\0', 256);
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);
+ g_warning("Could not parse config file: %s",
+ err ? err->message : "Unknown error");
}
if(serve) {
g_array_append_val(servers, *serve);
projects / nbd.git / blobdiff