**/
#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_AUTOREADONLY 8 /**< flag to tell us a file is set to autoreadonly */
#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 */
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
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;
+ }
}
}
*/
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] [-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");
printf("\tcopyonwrite = true\n");
}
if(serve->expected_size) {
- printf("\tfilesize = %Ld\n", (long long int)serve->expected_size);
+ printf("\tfilesize = %lld\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);
}
size_t last;
char suffix;
gboolean do_output=FALSE;
- gchar* section_header;
+ gchar* section_header="";
+ gchar** addr_port;
if(argc==1) {
return NULL;
/* 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);
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;
g_free(serve->authname);
serve->authname=g_strdup(optarg);
break;
- case 'a':
- serve->timeout=strtol(optarg, NULL, 0);
- break;
default:
usage();
exit(EXIT_FAILURE);
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_PROGERR, /**< Programmer error */
+ CFILE_NO_EXPORTS /**< A config file was specified that does not
+ define any exports */
} CFILE_ERRORS;
/**
{ "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 },
{ "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=14;
+ 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;
GArray *retval=NULL;
gchar **groups;
gboolean value;
+ gchar* startgroup;
gint i;
gint j;
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;
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=&(s.prerun);
- lp[7].target=&(s.postrun);
- lp[8].target=lp[9].target=lp[10].target=
- lp[11].target=lp[12].target=
- lp[13].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) {
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
}
#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;
}
unlink(pidfname);
}
- exit(0);
+ exit(EXIT_SUCCESS);
}
/**
**/
off_t size_autodetect(int fhandle) {
off_t es;
- unsigned long sectors;
+ u64 bytes;
struct stat stat_buf;
int error;
#ifdef HAVE_SYS_MOUNT_H
#ifdef HAVE_SYS_IOCTL_H
-#ifdef BLKGETSIZE
- DEBUG("looking for export size with ioctl BLKGETSIZE\n");
- if (!ioctl(fhandle, BLKGETSIZE, §ors) && sectors) {
- es = (off_t)sectors * (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 */
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;
}
/**
* @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;
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);
* @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;
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;
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;
}
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 ;
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);
} 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 ;
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);
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
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) {
/* 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);
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);
}
}
/**
- * 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.
+ * Loop through the available servers, and serve them. Never returns.
**/
-#if !defined(NODAEMON) && !defined(NOFORK)
-void daemonize(SERVER* serve) {
- FILE*pidf;
+int serveloop(GArray* servers) {
+ struct sockaddr_in addrin;
+ socklen_t addrinlen=sizeof(addrin);
+ SERVER *serve;
+ int i;
+ int max;
+ int sock;
+ fd_set mset;
+ fd_set rset;
- if(serve && !(serve->port)) {
- return;
- }
- if(daemon(0,0)<0) {
- err("daemon");
+ /*
+ * Set up the master fd_set. The set of descriptors we need
+ * to select() for never changes anyway and it buys us a *lot*
+ * of time to only build this once. However, if we ever choose
+ * to not fork() for clients anymore, we may have to revisit
+ * this.
+ */
+ max=0;
+ FD_ZERO(&mset);
+ for(i=0;i<servers->len;i++) {
+ sock=(g_array_index(servers, SERVER, i)).socket;
+ FD_SET(sock, &mset);
+ max=sock>max?sock:max;
}
- if(!*pidftemplate) {
- if(serve) {
- strncpy(pidftemplate, "/var/run/server.%d.pid", 255);
- } else {
- strncpy(pidftemplate, "/var/run/server.pid", 255);
+ for(;;) {
+ CLIENT *client;
+ int net;
+ pid_t *pid;
+
+ memcpy(&rset, &mset, sizeof(fd_set));
+ 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;
+ 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));
+#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);
+ }
+ }
}
}
- 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.
}
#endif
addrin.sin_port = htons(serve->port);
- addrin.sin_addr.s_addr = 0;
+ 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, ");
}
/**
- * Loop through the available servers, and serve them.
+ * 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.
**/
-int serveloop(GArray* servers) {
- struct sockaddr_in addrin;
- socklen_t addrinlen=sizeof(addrin);
- SERVER *serve;
- int i;
- int max;
- int sock;
- fd_set mset;
- fd_set rset;
- struct timeval tv;
+#if !defined(NODAEMON) && !defined(NOFORK)
+void daemonize(SERVER* serve) {
+ FILE*pidf;
- /*
- * Set up the master fd_set. The set of descriptors we need
- * to select() for never changes anyway and it buys us a *lot*
- * of time to only build this once. However, if we ever choose
- * to not fork() for clients anymore, we may have to revisit
- * this.
- */
- max=0;
- FD_ZERO(&mset);
- for(i=0;i<servers->len;i++) {
- sock=(g_array_index(servers, SERVER, i)).socket;
- FD_SET(sock, &mset);
- max=sock>max?sock:max;
+ if(serve && !(serve->port)) {
+ return;
}
- for(;;) {
- CLIENT *client;
- int net;
- 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) {
- DEBUG("accept, ");
- for(i=0;i<servers->len;i++) {
- serve=&(g_array_index(servers, SERVER, i));
- if(FD_ISSET(serve->socket, &rset)) {
- 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;
- 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));
-#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(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);
}
/**
g_message("Invalid group name: %s", rungroup);
exit(EXIT_FAILURE);
}
- if(setgid(gr->gr_gid)<0)
- msg3(LOG_DEBUG, "Could not set GID: %s", strerror(errno));
+ if(setgid(gr->gr_gid)<0) {
+ g_message("Could not set GID: %s", strerror(errno));
+ exit(EXIT_FAILURE);
+ }
}
if(runuser) {
pw=getpwnam(runuser);
g_message("Invalid user name: %s", runuser);
exit(EXIT_FAILURE);
}
- if(setuid(pw->pw_uid)<0)
- msg3(LOG_DEBUG, "Could not set UID: %s", strerror(errno));
+ 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...
**/
if (sizeof( struct nbd_request )!=28) {
fprintf(stderr,"Bad size of structure. Alignment problems?\n");
- exit(-1) ;
+ exit(EXIT_FAILURE) ;
}
memset(pidftemplate, '\0', 256);
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 ? err->message : "Unknown error");
- }
+
if(serve) {
g_array_append_val(servers, *serve);
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;
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);
projects / nbd.git / blobdiff