X-Git-Url: http://git.alex.org.uk diff --git a/nbd-server.c b/nbd-server.c index 5803811..58050bc 100644 --- a/nbd-server.c +++ b/nbd-server.c @@ -3,6 +3,8 @@ * * Copyright 1996-1998 Pavel Machek, distribute under GPL * + * Copyright 2001-2004 Wouter Verhelst + * Copyright 2002 Anton Altaparmakov * * Version 1.0 - hopefully 64-bit-clean * Version 1.1 - merging enhancements from Josh Parsons, @@ -13,14 +15,59 @@ * with make FSCHOICE=-DFS_32BIT nbd-server. (I don't have the * original autoconf input file, or I would make it a configure * option.) Ken Yap . + * Version 1.6 - fix autodetection of block device size and really make 64 bit + * clean on 32 bit machines. Anton Altaparmakov + * Version 2.0 - Version synchronised with client + * Version 2.1 - Reap zombie client processes when they exit. Removed + * (uncommented) the _IO magic, it's no longer necessary. Wouter + * Verhelst + * Version 2.2 - Auto switch to read-only mode (usefull for floppies). + * Version 2.3 - Fixed code so that Large File Support works. This + * removes the FS_32BIT compile-time directive; define + * _FILE_OFFSET_BITS=64 and _LARGEFILE_SOURCE if you used to be + * using FS_32BIT. This will allow you to use files >2GB instead of + * having to use the -m option. Wouter Verhelst + * Version 2.4 - Added code to keep track of children, so that we can + * properly kill them from initscripts. Add a call to daemon(), + * so that processes don't think they have to wait for us, which is + * interesting for initscripts as well. Wouter Verhelst + * + * Version 2.5 - Bugfix release: forgot to reset child_arraysize to + * zero after fork()ing, resulting in nbd-server going berserk + * when it receives a signal with at least one child open. Wouter + * Verhelst + * 10/10/2003 - Added socket option SO_KEEPALIVE (sf.net bug 819235); + * rectified type of mainloop::size_host (sf.net bugs 814435 and + * 817385); close the PID file after writing to it, so that the + * daemon can actually be found. Wouter Verhelst + * + * 10/10/2003 - Size of the data "size_host" was wrong and so was not + * correctly put in network endianness. Many types were corrected + * (size_t and off_t instead of int). + * Version 2.6 - Some code cleanup. + * Version 2.7 - Better build system (not released (yet?)). + * 11/02/2004 - Doxygenified the source, modularized it a bit. Needs a + * lot more work, but this is a start. Wouter Verhelst + * */ -#define VERSION "1.5" -#define GIGA (1*1024*1024*1024) +/* Includes LFS defines, which defines behaviours of some of the following + * headers, so must come before those */ +#include "config.h" +#include "lfs.h" #include #include #include +#include /* wait */ +#ifdef HAVE_SYS_IOCTL_H +#include +#endif +#include +#ifdef HAVE_SYS_MOUNT_H +#include /* For BLKGETSIZE */ +#endif +#include /* sigaction */ #include #include /* sockaddr_in, htons, in_addr */ #include /* hostent, gethostby*, getservby* */ @@ -32,45 +79,31 @@ #include #include #include +#include -#define _IO(a,b) -// #define ISSERVER -#define MY_NAME "nbd_server" - -/* Authorization file should contain lines with IP addresses of - clients authorized to use the server. If it does not exist, - access is permitted. */ -#define AUTH_FILE "nbd_server.allow" +#include +/* used in cliserv.h, so must come first */ +#define MY_NAME "nbd_server" #include "cliserv.h" -#undef _IO -/* Deep magic: ioctl.h defines _IO macro (at least on linux) */ +/** how much space for child PIDs we have by default. Dynamically + allocated, and will be realloc()ed if out of space, so this should + probably be fair for most situations. */ +#define DEFAULT_CHILD_ARRAY 256 -/* Debugging macros, now nothing goes to syslog unless you say ISSERVER */ +/** Logging macros, now nothing goes to syslog unless you say ISSERVER */ #ifdef ISSERVER -#define msg2(a,b) syslog(a,b) -#define msg3(a,b,c) syslog(a,b,c) -#define msg4(a,b,c,d) syslog(a,b,c,d) +#define msg2(a,b) syslog(a,"%s", b) +#define msg3(a,b,c) syslog(a,"%s %s", b,c) +#define msg4(a,b,c,d) syslog(a,"%s %s %s", b,c,d) #else -#define msg2(a,b) do { fprintf(stderr,b) ; fputs("\n",stderr) ; } while(0) -#define msg3(a,b,c) do { fprintf(stderr,b,c); fputs("\n",stderr) ; } while(0) -#define msg4(a,b,c,d) do { fprintf(stderr,b,c,d); fputs("\n",stderr) ; } while(0) +#define msg2(a,b) do { fprintf(stderr,"%s\n", b) ; } while(0) +#define msg3(a,b,c) do { fprintf(stderr,"%s %s\n", b,c); } while(0) +#define msg4(a,b,c,d) do { fprintf(stderr,"%s %s %s\n", b,c,d); } while(0) #endif - -#include -#include /* For BLKGETSIZE */ - -#ifdef FS_32BIT -typedef u32 fsoffset_t; -#define htonll htonl -#define ntohll ntohl -#else -typedef u64 fsoffset_t; -#endif - - +/* Debugging macros */ //#define DODBG #ifdef DODBG #define DEBUG( a ) printf( a ) @@ -81,44 +114,133 @@ typedef u64 fsoffset_t; #define DEBUG2( a,b ) #define DEBUG3( a,b,c ) #endif - -#if defined(HAVE_LLSEEK) && !defined(sun) -/* Solaris already has llseek defined in unistd.h */ -extern long long llseek(unsigned int, long long, unsigned int); +#ifndef PACKAGE_VERSION +#define PACKAGE_VERSION "" #endif - -void serveconnection(int net); -void set_peername(int net,char *clientname); - -#define LINELEN 256 -char difffilename[256]; -unsigned int timeout = 0; - +/** + * The highest value a variable of type off_t can reach. + **/ +/* This is starting to get ugly. If someone knows a better way to find + * the maximum value of a signed type *without* relying on overflow + * (doing so breaks on 64bit architectures), that would be nice. + */ +#define OFFT_MAX (((((off_t)1)<<((sizeof(off_t)-1)*8))-1)<<7)+127 +#define LINELEN 256 /**< Size of static buffer used to read the + authorization file (yuck) */ +#define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */ +#define GIGA (1*1024*1024*1024) /**< 1 Gigabyte. Used as hunksize when doing + the multiple file thingy */ +#define DIFFPAGESIZE 4096 /**< diff file uses those chunks */ +#define F_READONLY 1 /**< flag to tell us a file is readonly */ +#define F_MULTIFILE 2 /**< flag to tell us a file is exported using -m */ +#define F_COPYONWRITE 4 /**< flag to tell us a file is exported using copyonwrite */ +char difffilename[1024]; /**< filename of the copy-on-write file. Doesn't belong here! */ +unsigned int timeout = 0; /**< disconnect timeout */ +int autoreadonly = 0; /**< 1 = switch to readonly if opening readwrite isn't + possible */ +char *auth_file="nbd_server.allow"; /**< authorization file */ +char exportname2[1024]; /**< File I'm exporting, with virtualhost resolved */ +off_t lastpoint = (off_t)-1; /**< keep track of where we are in the file, to + avoid an lseek if possible */ +char pagebuf[DIFFPAGESIZE]; /**< when doing copyonwrite, this is + used as a temporary buffer to store + the exported block in. @todo this is + a great example of namespace + pollution. Throw it out. */ +unsigned int port; /**< Port I'm listening at */ +char *exportname; /**< File I'm exporting */ +off_t exportsize = OFFT_MAX; /**< length of file I'm exporting */ +off_t hunksize = OFFT_MAX; /**< size of each exported file in case of -m */ +int flags = 0; /**< flags associated with this exported file */ +int export[1024];/**< array of filedescriptors of exported files; only first is + used unless -m option is activated */ +int difffile=-1; /**< filedescriptor for copyonwrite file */ +u32 difffilelen=0 ; /**< number of pages in difffile */ +u32 *difmap=NULL ; /**< Determine whether a block is in the original file + (difmap[block]==-1) or in the copyonwrite file (in which + case it contains the offset where it is to be found in the + copyonwrite file). @todo the kernel knows about sparse + files, we should use those instead. Should also be off_t + instead of u32; copyonwrite is probably broken wrt LFS */ +char clientname[256] ; +int child_arraysize=DEFAULT_CHILD_ARRAY; /**< number of available slots for + child array */ +pid_t *children; /**< child array */ +char pidfname[256]; /**< name of our PID file */ + +/** + * Variables associated with a copyonwrite server. Not yet used. + **/ +typedef struct { + char* difffilename; /**< filename of the copy-on-write file */ + int difffile; /**< filedescriptor of copyonwrite file. @todo + shouldn't this be an array too? (cfr + nbd_server_opts::export) Or make -m and -c + mutually exclusive */ + u32 difffilelen; /**< number of pages in difffile */ + u32 *difmap; /**< see comment on the global difmap for this one */ +} cow_opts; + +/** + * Variables associated with a server. Not yet used. @todo modify the code to + * use an instance of this struct instead of the heap of global variables. + **/ +typedef struct { + char* exportname; /**< filename of the file we're exporting */ + unsigned int port; /**< port we're exporting this file at */ + char* authname; /**< filename of the authorization file */ + off_t exportsize; /**< size of the file we're exporting */ + off_t hunksize; /**< size of a hunk of an exported file */ + int flags; /**< flags associated with this exported file */ + char* clientname; /**< peer */ + unsigned int timeout;/**< how long a connection may be idle + (0=forever) */ + int export[1024]; /**< array of filedescriptors of exported files; + only the first is actually used unless we're + doing the multiple file option */ + cow_opts* cow; /**< only used if (flags | F_COPYONWRITE) (NULL + otherwise) */ +} nbd_server_opts; + +/** + * Check whether a client is allowed to connect. Works with an authorization + * file which contains one line per machine, no wildcards. + * + * @param name IP address of client trying to connect (in human-readable form) + * @return 0 - authorization refused, 1 - OK + **/ int authorized_client(char *name) -/* 0 - authorization refused, 1 - OK - authorization file contains one line per machine, no wildcards -*/ -{ FILE *f ; +{ + FILE *f ; - char line[LINELEN] ; + char line[LINELEN] ; - if ((f=fopen(AUTH_FILE,"r"))==NULL) - { msg4(LOG_INFO,"Can't open authorization file %s (%s).", - AUTH_FILE,strerror(errno)) ; - return 1 ; - } + if ((f=fopen(auth_file,"r"))==NULL) { + msg4(LOG_INFO,"Can't open authorization file %s (%s).", + auth_file,strerror(errno)) ; + return 1 ; + } - while (fgets(line,LINELEN,f)!=NULL) { - if (strncmp(line,name,strlen(name))==0) { fclose(f) ; return 1 ; } - } - fclose(f) ; - return 0 ; + while (fgets(line,LINELEN,f)!=NULL) { + if (strncmp(line,name,strlen(name))==0) { + fclose(f); + return 1; + } + } + fclose(f) ; + return 0 ; } - -inline void readit(int f, void *buf, int len) +/** + * Read data from a file descriptor into a buffer + * + * @param f a file descriptor + * @param buf a buffer + * @param len the number of bytes to be read + **/ +inline void readit(int f, void *buf, size_t len) { - int res; + ssize_t res; while (len > 0) { DEBUG("*"); if ((res = read(f, buf, len)) <= 0) @@ -128,35 +250,35 @@ inline void readit(int f, void *buf, int len) } } -inline void writeit(int f, void *buf, int len) +/** + * Write data from a buffer into a filedescriptor + * + * @param f a file descriptor + * @param buf a buffer containing data + * @param len the number of bytes to be written + **/ +inline void writeit(int f, void *buf, size_t len) { - int res; + ssize_t res; while (len > 0) { DEBUG("+"); if ((res = write(f, buf, len)) <= 0) - err("Write failed: %m"); + err("Send failed: %m"); len -= res; buf += res; } } -int port; /* Port I'm listening at */ -char *exportname; /* File I'm exporting */ -fsoffset_t exportsize = ~0, hunksize = ~0; /* ...and its length */ -int flags = 0; -int export[1024]; -int difffile=-1 ; -u32 difffilelen=0 ; /* number of pages in difffile */ -u32 *difmap=NULL ; -char clientname[256] ; - - -#define DIFFPAGESIZE 4096 /* diff file uses those chunks */ - -#define F_READONLY 1 -#define F_MULTIFILE 2 -#define F_COPYONWRITE 4 - +/** + * Parse the command line. + * + * @todo getopt() is a great thing, and easy to use. Also, we want to + * create a configuration file which nbd-server will read. Maybe do (as in, + * parse) that here. + * + * @param argc the argc argument to main() + * @param argv the argv argument to main() + **/ void cmdline(int argc, char *argv[]) { int i; @@ -167,6 +289,7 @@ void cmdline(int argc, char *argv[]) " -r read only\n" " -m multiple file\n" " -c copy on write\n" + " -l file with list of hosts that are allowed to connect.\n" " -a maximum idle seconds, terminates when idle time exceeded\n" " if port is set to 0, stdin is used (for running from inetd)\n" " if file_to_export contains '%%s', it is substituted with IP\n" @@ -186,6 +309,14 @@ void cmdline(int argc, char *argv[]) break; case 'c': flags |=F_COPYONWRITE; break; + case 'l': + free(auth_file); + if (i+1 0) { + if(WIFEXITED(status)) { + memset(buf,'\0', 80); + snprintf(buf, 79, "%d", WEXITSTATUS(status)); + msg3(LOG_INFO, "Child exited with ", buf); + } + for(i=0;children[i]!=pid&&i=child_arraysize) { + memset(buf, '\0', 80); + snprintf(buf, 79, "%ld", (long)pid); + msg3(LOG_INFO, "SIGCHLD received for an unknown child with PID ", buf); + } else { + children[i]=(pid_t)0; + DEBUG2("Removing %d from the list of children", pid); + } + } +} - if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) - err("socket: %m"); +/** + * Handle SIGTERM and dispatch it to our children + * @param s the signal we're handling (must be SIGTERM, or something + * is severely wrong). + **/ +void sigterm_handler(int s) { + int i; + int parent=0; - /* lose the pesky "Address already in use" error message */ - if (setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) { - err("setsockopt"); + for(i=0;i0) { /* parent */ - close(net) ; continue ; } - /* child */ - close(sock) ; - msg2(LOG_INFO,"Starting to serve") ; - serveconnection(net) ; + if(parent) { + unlink(pidfname); } + + exit(0); } -#define SEND writeit( net, &reply, sizeof( reply )); -#define ERROR { reply.error = htonl(-1); SEND; reply.error = 0; lastpoint = -1; } +/** + * Detect the size of a file. + * + * @param export An open filedescriptor + * @return the size of the file, or OFFT_MAX if detection was + * impossible. + **/ +off_t size_autodetect(int export) +{ + off_t es; + u32 es32; + struct stat stat_buf; + int error; -fsoffset_t lastpoint = -1; +#ifdef HAVE_SYS_MOUNT_H +#ifdef HAVE_SYS_IOCTL_H +#ifdef BLKGETSIZE + DEBUG("looking for export size with ioctl BLKGETSIZE\n"); + if (!ioctl(export, BLKGETSIZE, &es32) && es32) { + es = (off_t)es32 * (off_t)512; + return es; + } +#endif /* BLKGETSIZE */ +#endif /* HAVE_SYS_IOCTL_H */ +#endif /* HAVE_SYS_MOUNT_H */ + + DEBUG("looking for export size with fstat\n"); + stat_buf.st_size = 0; + error = fstat(export, &stat_buf); + if (!error && stat_buf.st_size > 0) { + return (off_t)stat_buf.st_size; + } else { + err("fstat failed: %m"); + } -void maybeseek(int handle, fsoffset_t a) -{ - if (a > exportsize) + DEBUG("looking for export size with lseek SEEK_END\n"); + es = lseek(export, (off_t)0, SEEK_END); + if (es > ((off_t)0)) { + return es; + } else { + DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4))); + } + + err("Could not find size of exported block device: %m"); + return OFFT_MAX; +} + +/** + * Seek to a position in a file, unless we're already there. + * @param handle a filedescriptor + * @param a position to seek to + **/ +void maybeseek(int handle, off_t a) { + if (a < 0 || a > exportsize) { err("Can not happen\n"); + } if (lastpoint != a) { -#if defined(HAVE_LLSEEK) && !defined(FS_32BIT) - if (llseek(handle, a, SEEK_SET) < 0) -#else - if (lseek(handle, (long)a, SEEK_SET) < 0) -#endif + if (lseek(handle, a, SEEK_SET) < 0) { err("Can not seek locally!\n"); + } lastpoint = a; } else { - DEBUG("@"); + DEBUG("S"); } } -void myseek(int handle,fsoffset_t a) +/** + * Write an amount of bytes at a given offset to the right file. This + * abstracts the write-side of the multiple file option. + * + * @param a The offset where the write should start + * @param buf The buffer to write from + * @param len The length of buf + * @return The number of bytes actually written, or -1 in case of an error + **/ +int rawexpwrite(off_t a, char *buf, size_t len) { -#if HAVE_LLSEEK && !defined(FS_32BIT) - if (llseek(handle, a, SEEK_SET) < 0) -#else - if (lseek(handle, (long)a, SEEK_SET) < 0) -#endif - err("Can not seek locally!\n"); -} + ssize_t res; -char pagebuf[DIFFPAGESIZE] ; - - -int rawexpread(fsoffset_t a, char *buf, int len) -{ - maybeseek(export[a/hunksize], a%hunksize); - return (read(export[a/hunksize], buf, len) != len); + maybeseek(export[a/hunksize], a%hunksize); + res = write(export[a/hunksize], buf, len); + return (res < 0 || (size_t)res != len); } -int expread(fsoffset_t a, char *buf, int len) -{ int rdlen ; fsoffset_t mapcnt,mapl,maph ; - fsoffset_t pagestart; int offset ; - - if (flags & F_COPYONWRITE) { - DEBUG3("Asked to read %d bytes at %lu.\n",len,(unsigned long)a) ; - - mapl=a/DIFFPAGESIZE ; maph=(a+len-1)/DIFFPAGESIZE ; - - for (mapcnt=mapl;mapcnt<=maph;mapcnt++) { - pagestart=mapcnt*DIFFPAGESIZE ; - offset=a-pagestart ; - rdlen=(lenhunksize) - rdlen=hunksize-(pagestart%hunksize) ; - if (rawexpread(pagestart,pagebuf,rdlen)) return -1 ; - memcpy(pagebuf+offset,buf,wrlen) ; - if (write(difffile,pagebuf,DIFFPAGESIZE)!=DIFFPAGESIZE) return -1 ; - } - len-=wrlen ; a+=wrlen ; buf+=wrlen ; - } - } else return(rawexpwrite(a,buf,len)); - return 0 ; +/** + * Read an amount of bytes at a given offset from the right file. This + * abstracts the read-side of the copyonwrite stuff, and calls + * rawexpread() with the right parameters to do the actual work. + * @param a The offset where the read should start + * @param buf A buffer to read into + * @param len The size of buf + * @return The number of bytes actually read, or -1 in case of an error + **/ +int expread(off_t a, char *buf, size_t len) +{ + off_t rdlen, offset; + off_t mapcnt, mapl, maph, pagestart; + + if (!(flags & F_COPYONWRITE)) + return rawexpread(a, buf, len); + DEBUG3("Asked to read %d bytes at %Lu.\n", len, (unsigned long long)a); + + mapl=a/DIFFPAGESIZE; maph=(a+len-1)/DIFFPAGESIZE; + + for (mapcnt=mapl;mapcnt<=maph;mapcnt++) { + pagestart=mapcnt*DIFFPAGESIZE; + offset=a-pagestart; + rdlen=(0hunksize) + rdlen=hunksize-(pagestart%hunksize) ; + if (rawexpread(pagestart,pagebuf,rdlen)) return -1 ; + memcpy(pagebuf+offset,buf,wrlen) ; + if (write(difffile,pagebuf,DIFFPAGESIZE)!=DIFFPAGESIZE) return -1 ; + } + len-=wrlen ; a+=wrlen ; buf+=wrlen ; + } + return 0; +} + +/** + * Do the initial negotiation. + * + * @param net A socket to do the negotiation over + **/ +void negotiate(int net) { char zeros[300]; - int i = 0; - fsoffset_t size_host; + u64 size_host; memset(zeros, 0, 290); if (write(net, INIT_PASSWD, 8) < 0) err("Negotiation failed: %m"); -#ifndef FS_32BIT cliserv_magic = htonll(cliserv_magic); -#endif if (write(net, &cliserv_magic, sizeof(cliserv_magic)) < 0) err("Negotiation failed: %m"); - size_host = htonll(exportsize); -#ifdef FS_32BIT - if (write(net, zeros, 4) < 0 || write(net, &size_host, 4) < 0) -#else + size_host = htonll((u64)exportsize); if (write(net, &size_host, 8) < 0) -#endif err("Negotiation failed: %m"); if (write(net, zeros, 128) < 0) err("Negotiation failed: %m"); +} +/** sending macro; not really required. Uses variables in the local + * scope of mainloop(). Get rid of it. */ +#define SEND writeit( net, &reply, sizeof( reply )); +/** error macro; not sure whether we really need this. Uses variables + * in the local scope of mainloop(). Get rid of this beast. */ +#define ERROR { reply.error = htonl(-1); SEND; reply.error = 0; lastpoint = -1; } +/** + * Serve a file to a single client. + * + * @todo This beast needs to be split up in many tiny little manageable + * pieces. Preferably with a chainsaw. + * + * @param net A network socket, connected to an nbd client + * @return never + **/ +int mainloop(int net) +{ + struct nbd_request request; + struct nbd_reply reply; +#ifdef DODBG + int i = 0; +#endif + negotiate(net); DEBUG("Entering request loop!\n"); reply.magic = htonl(NBD_REPLY_MAGIC); reply.error = 0; while (1) { -#define BUFSIZE (1024*1024) char buf[BUFSIZE]; - int len; - + size_t len; #ifdef DODBG i++; printf("%d: ", i); #endif - if (timeout) alarm(timeout); readit(net, &request, sizeof(request)); request.from = ntohll(request.from); request.type = ntohl(request.type); - if (request.type==2) { /* Disconnect request */ + if (request.type==NBD_CMD_DISC) { /* Disconnect request */ if (difmap) free(difmap) ; if (difffile>=0) { close(difffile) ; unlink(difffilename) ; } @@ -443,27 +687,36 @@ int mainloop(int net) if (len > BUFSIZE) err("Request too big!"); #ifdef DODBG - printf("%s from %d (%d) len %d, ", (request.type ? "WRITE" : "READ"), - (int) request.from, (int) request.from / 512, len); + printf("%s from %Lu (%Lu) 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) > exportsize) || + if ((request.from + len) > (OFFT_MAX)) { + DEBUG("[Number too large!]"); + ERROR; + continue; + } + + if (((ssize_t)((off_t)request.from + len) > exportsize) || ((flags & F_READONLY) && request.type)) { DEBUG("[RANGE!]"); ERROR; continue; } + if (request.type==1) { /* WRITE */ DEBUG("wr: net->buf, "); readit(net, buf, len); DEBUG("buf->exp, "); - if (expwrite(request.from, buf, len)) { + if ((autoreadonly == 1) || expwrite(request.from, buf, len)) { DEBUG("Write failed: %m" ); ERROR; continue; } lastpoint += len; SEND; + DEBUG("OK!\n"); continue; } /* READ */ @@ -484,8 +737,83 @@ int mainloop(int net) } } -char exportname2[1024]; +/** + * Split a single exportfile into multiple ones, if that was asked. + * @return 0 on success, -1 on failure + **/ +int splitexport(void) { + off_t i ; + + for (i=0; i OFFT_MAX) { + err("Size of exported file is too big\n"); + } + else { + memset(buf, '\0', 80); + snprintf(buf, 79, "%Lu", (unsigned long long)exportsize); + msg3(LOG_INFO, "size of exported file/device is ", buf); + } + + setmysockopt(net); + + mainloop(net); +} +/** + * Find the name of the file we have to serve. This will use snprintf() + * to put the IP address of the client inside a filename containing + * "%s". That name is then written to exportname2 + * + * @param net A socket connected to an nbd client + * @param clientname a buffer which must be at least 255+1 bytes long; + * the IP address (in human-readable format) will be copied in there. + **/ void set_peername(int net,char *clientname) { struct sockaddr_in addrin; @@ -495,44 +823,140 @@ void set_peername(int net,char *clientname) if (getpeername( net, (struct sockaddr *) &addrin, &addrinlen ) < 0) err("getsockname failed: %m"); peername = inet_ntoa(addrin.sin_addr); - sprintf(exportname2, exportname, peername); + snprintf(exportname2, 1024, exportname, peername); + exportname2[1023]='\0'; - msg4(LOG_INFO, "connect from %s, assigned file is %s", peername, exportname2); + msg4(LOG_INFO, "connect from %s, assigned file is %s", + peername, exportname2); strncpy(clientname,peername,255) ; } -fsoffset_t size_autodetect(int export) +/** + * Connect the socket, and start to serve. This function will fork() + * if a connection from an authorized client is received, and will + * start mainloop(). + * + * @todo modularize this giant beast. Preferably with a chainsaw. Also, + * it has no business starting mainloop(); it should connect, and be + * done with it. + * + * @param port the port where we will listen + **/ +void connectme(unsigned int port) { - fsoffset_t es; - DEBUG("looking for export size with lseek SEEK_END\n"); - if ((int)(es = lseek(export, 0, SEEK_END)) == -1 || es == 0) { - struct stat stat_buf; - int error; - DEBUG("looking for export size with fstat\n"); - stat_buf.st_size = 0; - if ((error = fstat(export, &stat_buf)) == -1 || stat_buf.st_size == 0 ) { - DEBUG("looking for export size with ioctl BLKGETSIZE\n"); -#ifdef BLKGETSIZE - if(ioctl(export, BLKGETSIZE, &es) || es == 0) { + struct sockaddr_in addrin; + struct sigaction sa; + int addrinlen = sizeof(addrin); + int net, sock, newpid, i; +#ifndef sun + int yes=1; #else - if(1){ -#endif - err("Could not find size of exported block device: %m"); + char yes='1'; +#endif /* sun */ +#ifndef NODAEMON +#ifndef NOFORK + FILE*pidf; + + if(port) { + if(daemon(0,0)<0) { + err("daemon"); + } + snprintf(pidfname, sizeof(char)*255, "/var/run/nbd-server.%d.pid", port); + pidf=fopen(pidfname, "w"); + if(pidf) { + fprintf(pidf,"%d", (int)getpid()); + fclose(pidf); + } else { + perror("fopen"); + fprintf(stderr, "Not fatal; continuing"); + } + } +#endif /* NOFORK */ +#endif /* NODAEMON */ + + if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) + err("socket: %m"); + + /* lose the pesky "Address already in use" error message */ + if (setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) { + err("setsockopt SO_REUSEADDR"); + } + if (setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&yes,sizeof(int)) == -1) { + err("setsockopt SO_KEEPALIVE"); + } + + DEBUG("Waiting for connections... bind, "); + addrin.sin_family = AF_INET; + addrin.sin_port = htons(port); + addrin.sin_addr.s_addr = 0; + if (bind(sock, (struct sockaddr *) &addrin, addrinlen) < 0) + err("bind: %m"); + DEBUG("listen, "); + if (listen(sock, 1) < 0) + err("listen: %m"); + DEBUG("accept, "); + 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=malloc(sizeof(pid_t)*child_arraysize); + memset(children, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY); + for(;;) { /* infinite loop */ + if ((net = accept(sock, (struct sockaddr *) &addrin, &addrinlen)) < 0) + err("accept: %m"); + + set_peername(net,clientname); + if (!authorized_client(clientname)) { + msg2(LOG_INFO,"Unauthorized client") ; + close(net) ; + continue ; + } + msg2(LOG_INFO,"Authorized client") ; + for(i=0;children[i]&&i=child_arraysize) { + pid_t*ptr; + + ptr=realloc(children, sizeof(pid_t)*child_arraysize); + if(ptr) { + children=ptr; + memset(children+child_arraysize, 0, sizeof(pid_t)*DEFAULT_CHILD_ARRAY); + i=child_arraysize+1; + child_arraysize+=DEFAULT_CHILD_ARRAY; } else { - es *= 512; /* assume blocksize 512 */ + msg2(LOG_INFO,"Not enough memory to store child PID"); + close(net); + continue; } - } else { - es = stat_buf.st_size; } +#ifndef NOFORK + if ((children[i]=fork())<0) { + msg3(LOG_INFO,"Could not fork (%s)",strerror(errno)) ; + close(net) ; + continue ; + } + if (children[i]>0) { /* parent */ + close(net) ; continue ; } + /* child */ + realloc(children,0); + child_arraysize=0; + close(sock) ; +#endif // NOFORK + msg2(LOG_INFO,"Starting to serve") ; + serveconnection(net) ; } - return es; } +/** + * Main entry point... + **/ int main(int argc, char *argv[]) { - int net; - fsoffset_t i; - if (sizeof( struct nbd_request )!=28) { fprintf(stderr,"Bad size of structure. Alignment problems?\n"); exit(-1) ; @@ -545,50 +969,3 @@ int main(int argc, char *argv[]) return 0 ; } - -void serveconnection(int net) -{ - u64 i ; - - for (i=0; i (~0UL >> 1)) -#ifdef HAVE_LLSEEK - if ((exportsize >> 10) > (~0UL >> 1)) - msg3(LOG_INFO, "size of exported file/device is %luMB", - (unsigned long)(exportsize >> 20)); - else - msg3(LOG_INFO, "size of exported file/device is %luKB", - (unsigned long)(exportsize >> 10)); -#else - err("Size of exported file is too big\n"); -#endif - else - msg3(LOG_INFO, "size of exported file/device is %lu", - (unsigned long)exportsize); - - if (flags & F_COPYONWRITE) { - sprintf(difffilename,"%s-%s-%d.diff",exportname2,clientname, - (int)getpid()) ; - msg3(LOG_INFO,"About to create map and diff file %s",difffilename) ; - difffile=open(difffilename,O_RDWR | O_CREAT | O_TRUNC,0600) ; - if (difffile<0) err("Could not create diff file (%m)") ; - if ((difmap=calloc(exportsize/DIFFPAGESIZE,sizeof(u32)))==NULL) - err("Could not allocate memory") ; - for (i=0;i