#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* */
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;
/**
**/
inline void readit(int f, void *buf, size_t len) {
ssize_t res;
- gboolean tried = FALSE;
-
while (len > 0) {
DEBUG("*");
- if ((res = read(f, buf, len)) <= 0) {
- if(!tried && errno==EAGAIN) {
- /* Assume the connection will work some time in
- * the future, but don't run away with CPU time
- * in case it doesn't */
- fd_set set;
- struct timeval tv;
-
- DEBUG("Read failed, trying again");
- tried=TRUE;
- FD_ZERO(&set);
- FD_SET(f, &set);
- tv.tv_sec=30;
- tv.tv_usec=0;
- select(f+1, &set, NULL, NULL, &tv);
- } else {
- err("Read failed: %m");
- }
- } else {
- len -= res;
- buf += res;
- tried=FALSE;
- }
+ if ((res = read(f, buf, len)) <= 0)
+ err("Read failed: %m");
+ len -= res;
+ buf += res;
}
}
**/
inline void writeit(int f, void *buf, size_t len) {
ssize_t res;
- gboolean tried=FALSE;
-
while (len > 0) {
DEBUG("+");
- if ((res = write(f, buf, len)) <= 0) {
- if(!tried && errno==EAGAIN) {
- /* Assume the connection will work some time in
- * the future, but don't run away with CPU time
- * in case it doesn't */
- fd_set set;
- struct timeval tv;
-
- DEBUG("Write failed, trying again");
- tried=TRUE;
- FD_ZERO(&set);
- FD_SET(f, &set);
- tv.tv_sec=30;
- tv.tv_usec=0;
- select(f+1, NULL, &set, NULL, &tv);
- } else {
- err("Send failed: %m");
- }
- } else {
- len -= res;
- buf += res;
- tried=FALSE;
- }
+ if ((res = write(f, buf, len)) <= 0)
+ err("Send failed: %m");
+ len -= res;
+ buf += res;
}
}
*/
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]\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"
"\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 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"
- "\t-p|--pid-file\t\tspecify a filename to write our PID to\n\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" );
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("\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 = %Ld\n", (long long int)serve->expected_size);
+ }
+ if(serve->authname) {
+ printf("\tauthfile = %s\n", serve->authname);
+ }
+ if(serve->timeout) {
+ printf("\ttimeout = %d\n", serve->timeout);
+ }
+ exit(EXIT_SUCCESS);
+}
+
/**
* Parse the command line.
*
{"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;
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:mrp:", 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 */
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;
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;
}
{ "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 },
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);
+
/* After the [generic] group, start parsing exports */
if(i==1) {
p=lp;
* @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;
}
}
/**
+ * 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);
}
/**
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);
}
/**
void daemonize(SERVER* serve) {
FILE*pidf;
+ if(serve && !(serve->port)) {
+ return;
+ }
if(daemon(0,0)<0) {
err("daemon");
}
err("fcntl F_GETFL");
}
if (fcntl(serve->socket, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
- err("fcntl F_SETFL O_NONBLOCK on server socket");
+ err("fcntl F_SETFL O_NONBLOCK");
}
DEBUG("Waiting for connections... bind, ");
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");
client = g_malloc(sizeof(CLIENT));
client->server=serve;
client->exportsize=OFFT_MAX;
- if ((sock_flags = fcntl(serve->socket, F_GETFL, 0)) == -1) {
- err("fcntl F_GETFL");
- }
- if (fcntl(net, F_SETFL, sock_flags | O_NONBLOCK) == -1) {
- err("fcntl F_SETFL O_NONBLOCK on client socket");
- }
client->net=net;
set_peername(net, client);
if (!authorized_client(client)) {
}
/* 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);
}
}
}
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(runuser) {
+ pw=getpwnam(runuser);
+ if(setuid(pw->pw_uid)<0)
+ msg3(LOG_DEBUG, "Could not set UID: %s", strerror(errno));
+ }
}
/**
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);
- }
-
-/* 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);
#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((!serve) && (!servers||!servers->len)) {
g_message("Nothing to do! Bye!");
exit(EXIT_FAILURE);