/* * Copyright (C) 2005 Roy Keene * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Author Information * Roy Keene * Planning Systems Inc * Slidell, LA * backuppcd-bugs@psislidell.com */ #include "compat.h" #include "backuppcd.h" #include "backuppcd-common.h" #include "backuppcd-auth.h" #include "net.h" #include "sha1.h" #include "md4.h" #include "md5.h" #define DAEMON_RET_SUCCESS 0 #define DAEMON_RET_FAILURE 1 #define BPC_PRIO_MIN 0 #define BPC_PRIO_NORM 1 #define BPC_PRIO_MAX 2 #define LOOP_RUN 0 #define LOOP_STOP 1 #define LOOP_DONE 2 #ifndef SKIPSTARTFILE #define SKIPSTARTFILE SYSCONFDIR "/backuppcd-disable" #endif #ifndef O_BINARY #define O_BINARY 0 #endif #ifndef O_LARGEFILE #define O_LARGEFILE 0 #endif #ifndef SIGPIPE #define SIGPIPE 13 #endif #ifndef BPC_MAXUSERNAME_LEN #define BPC_MAXUSERNAME_LEN 128 #endif #ifndef BPC_MAXPASSWORD_LEN #define BPC_MAXPASSWORD_LEN 256 #endif #ifndef BPC_MAXPATH_LEN #define BPC_MAXPATH_LEN 4096 #endif #ifndef BPC_MAXOUTBUF_LEN #define BPC_MAXOUTBUF_LEN 819200 #endif #ifndef BPC_OUTBUF_LEN #define BPC_OUTBUF_LEN 32768 #endif #ifndef BPC_BUF_LEN #define BPC_BUF_LEN 32768 #endif #ifndef BPC_UPDATE_INTERVAL #define BPC_UPDATE_INTERVAL 300 #endif /* * Default master password: This value will never match any SHA1 hash. * */ #ifndef MASTER_PASSWORD #define MASTER_PASSWORD "7505d64a54e061b7acd54ccd58b49dc43500b63x" #endif /* * This global variable is used to coordinate the shutdown of the main work * loop (backuppc_loop()). */ static int WorkLoopStatus = LOOP_RUN; /* * These variables are global because the configuration is done by a seperate * function. */ static int backuppc_port = BPC_TCP_PORT; static uint32_t backuppc_writeblock_size = 32000; static char *backuppc_updateurl = NULL; static char *backuppc_binfile = NULL; #ifdef _USE_WIN32_ /* * Win32 service stuff. */ static SC_HANDLE manager = NULL; static SC_HANDLE service = NULL; static SERVICE_STATUS backuppcServiceStat; static SERVICE_STATUS_HANDLE backuppcServiceStat_handle = (SERVICE_STATUS_HANDLE) NULL; static char svcName[] = "BackupPC"; #endif /* * These are symbolic names to use to mark when a message datum has been sent. */ typedef enum { BPC_SM_NONE, BPC_SM_HEADER, BPC_SM_PKT_HEADER, BPC_SM_CLEANUP, BPC_SM_PATHNAME, BPC_SM_DATA_CLEANUP, BPC_SM_AUTHSTATUS, _BPC_SM_SIZE /* Must be the last item*/ } backuppc_send_mark_t; /* * These are symbolic names to use to mark when a message datum has been * recieved. */ typedef enum { BPC_RM_NONE, BPC_RM_HEADER, BPC_RM_PKT_HEADER, BPC_RM_PATHNAME, BPC_RM_AUTHDATA, _BPC_RM_SIZE /* Must be the last item. */ } backuppc_recv_mark_t; /* * These define the different data types that backuppc_readvalues() and * backuppc_writevalues() understand. */ typedef enum { BPC_DT_END, BPC_DT_UINT8, BPC_DT_UINT16, BPC_DT_UINT32, BPC_DT_UINT64, BPC_DT_BYTEARRAY, BPC_DT_BYTEARRAY_PTR, BPC_DT_STRING, BPC_DT_STRING_PTR, } backuppc_datatypes_t; /* * Every client that connects is given a node of this type to handle its * buffering. * * The (void *) process_handle entry is for the backuppc_process_client() * call to store data in. It should be filled out by * backuppc_process_client_init() and cleaned by * backuppc_process_client_fini(). */ struct backuppc_client_info; struct backuppc_client_info { struct in_addr addr; unsigned char *buf; unsigned char *buf_s; unsigned long bufsize; unsigned long bufsize_s; unsigned long bufused; unsigned char *outbuf; unsigned char *outbuf_s; unsigned long outbufsize; unsigned long outbufsize_s; unsigned long outbufused; void *process_handle; int outdata_waiting; int tx_error_count; int rx_error_count; int invalid_data; int fd; backuppc_privs_t privs; struct backuppc_client_info *_next; }; /* * backuppc_process_client()'s private data storage, maintains things like * state of the current command and various other items across calls. */ struct backuppc_client_prochandle { struct backuppc_dirent *dent; backuppc_cmd_t cmd; unsigned char *tmpbuf; uint16_t username_len; uint16_t password_len; uint32_t pathname_len; uint32_t excl_sect_len; uint32_t incl_sect_len; uint32_t block_num; uint8_t options; size_t tmpbufsize; size_t tmpbufused; size_t bytes_written; size_t attrlen; char *username; char *password; char *pathname; char *data; char attrdata[4096]; void *dh[256]; int dhidx; int sent_sect[_BPC_SM_SIZE]; int recv_sect[_BPC_RM_SIZE]; int wv_idx; int rv_idx; }; /* * Structure pointed to by the backuppc_readdir() * * Holds information about the file, as well as a file descriptor if opened by * backuppc_openfile(). */ struct backuppc_dirent { backuppc_filetype_t type; unsigned char md5[16]; const char *name; char fullpathname[BPC_MAXPATH_LEN]; char *symlinkdest; char *hrdlinkdest; off_t size; dev_t dev; mode_t mode; #ifndef _USE_WIN32_ uid_t uid; gid_t gid; #else uint32_t uid; uint32_t gid; #endif uint64_t blocks; uint32_t blksize; dev_t rdev; time_t mtime; time_t ctime; int md5_set; int issparse; int fd; }; struct backuppc_inode_list; struct backuppc_inode_list { ino_t inode_num; char *fullpathname; struct backuppc_inode_list *_next; }; /* * Private structure handle used by backuppc_opendir() and backuppc_closedir() */ typedef struct backuppc_dirhandle { struct backuppc_inode_list *ilist[4097]; /* This needs to be moved, otherwise hardlinks are only checked from the same dir.. XXX */ struct backuppc_dirent ret; char *pat_exclude[8192]; char *pat_include[8192]; char *pathname; DIR *handle; int lastdrivecheck; int isfile; } BPC_DIR; static char *sha1sum(char *string) { unsigned char digest[20]; static char ret[(sizeof(digest) * 2) + 1] = {0}; static char hexabet[] = "0123456789abcdef"; SHA1_CTX ctx; int retcnt = 0, i; SHA1Init(&ctx); SHA1Update(&ctx, string, strlen(string)); SHA1Final(digest, &ctx); for (i = 0; i < sizeof(digest); i++) { ret[retcnt++] = hexabet[(digest[i] & 0xf0) >> 4]; ret[retcnt++] = hexabet[digest[i] & 0xf]; } ret[retcnt] = '\0'; return(ret); } static void backuppc_setpriority(int prio) { #ifdef _USE_WIN32_ DWORD prio_class; switch (prio) { case BPC_PRIO_MAX: prio_class = HIGH_PRIORITY_CLASS; break; case BPC_PRIO_NORM: prio_class = NORMAL_PRIORITY_CLASS; break; case BPC_PRIO_MIN: default: prio_class = BELOW_NORMAL_PRIORITY_CLASS; break; } SetPriorityClass(GetCurrentProcess(), prio_class); #else int prio_val; switch (prio) { case BPC_PRIO_MAX: prio_val = -15; break; case BPC_PRIO_NORM: prio_val = 0; break; case BPC_PRIO_MIN: default: prio_val = 10; break; } #ifdef HAVE_SETPRIORITY setpriority(PRIO_PROCESS, 0, prio_val); #else #warning NO WAY TO HANDLE PRIORITY #endif #endif return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * This function compiles to a no-op on platforms that already have a single * unified namespace. * * On Win32 this function changes pathnames containing a drive letter style * pathname to a more sane name including the leading slash. * */ static void backuppc_pathmangle(char *pathname) { #ifdef _USE_WIN32_ char drive_letter; if (strlen(pathname) < 2) { return; } if (pathname[0] == '/' && isalpha(pathname[1])) { return; } if (pathname[1] != ':' || !isalpha(pathname[0])) { return; } drive_letter = pathname[0]; pathname[0] = '/'; pathname[1] = drive_letter; #endif return; } /* * SYNOPSIS: * static void backuppc_pathunmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to unmangle. * * RETURN VALUE: * (none) * * NOTES: * This function compiles to a no-op on platforms that already have a single * unified namespace. * * On Win32 this function changes pathnames containing a sane pathname to * a pathname that contains a drive letter and can be used to open or * otherwise access the file. * */ static void backuppc_pathunmangle(char *pathname) { #ifdef _USE_WIN32_ char drive_letter; if (strlen(pathname) < 2) { return; } if (pathname[1] == ':' && isalpha(pathname[0])) { return; } if (pathname[0] != '/' || !isalpha(pathname[1])) { return; } drive_letter = pathname[1]; pathname[0] = drive_letter; pathname[1] = ':'; #endif return; } /* * SYNOPSIS: * static BPC_DIR *backuppc_opendir( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to the directory to open * * RETURN VALUE: * This function returns a pointer to a handle that can be used with * backuppc_readdir() and backuppc_closedir(). It returns NULL on * error. * * NOTES: * If you backuppc_opendir() a file, you get a handle that when you call * backuppc_readdir() gives you exactly one entry, the pathname specified. * Thus you should not assume that the result of backuppc_readdir() gives * a child-node in the directory heirarchy of the pathname specified when * this function is called. the (struct backuppc_dirent).fullpathname * value should be used instead to get the full path to the relevant node. * */ static BPC_DIR *backuppc_opendir(char *pathname) { BPC_DIR *dh; struct stat stbuf; FILE *directive_fp; char dir_directive_file[BPC_MAXPATH_LEN]; char buf[1024]; int excnt = 0, incnt = 0; int stat_ret; int i; if (pathname[0] != '/') { return(NULL); } dh = malloc(sizeof(*dh)); if (!dh) { return(NULL); } dh->pat_exclude[0] = NULL; dh->pat_include[0] = NULL; dh->isfile = 0; for (i = 0; i < (sizeof(dh->ilist) / sizeof(dh->ilist[0])); i++) { dh->ilist[i] = NULL; } #ifdef _USE_WIN32_ if (strlen(pathname) < 2) { dh->pathname = strdup("/"); dh->handle = NULL; dh->lastdrivecheck = 0; return(dh); } #endif backuppc_pathunmangle(pathname); dh->handle = opendir(pathname); snprintf(dir_directive_file, sizeof(dir_directive_file), "%s/%s", pathname, ".bpc"); backuppc_pathmangle(pathname); if (!dh->handle) { backuppc_pathunmangle(pathname); #ifdef HAVE_LSTAT stat_ret = lstat(pathname, &stbuf); #else stat_ret = stat(pathname, &stbuf); #endif backuppc_pathmangle(pathname); if (stat_ret < 0) { free(dh); dh = NULL; return(dh); } if (S_ISDIR(stbuf.st_mode)) { free(dh); dh = NULL; return(dh); } dh->isfile = 1; } dh->lastdrivecheck = 0; dh->pathname = strdup(pathname); dh->ret.symlinkdest = NULL; dh->ret.hrdlinkdest = NULL; directive_fp = fopen(dir_directive_file, "r"); if (directive_fp) { while (1) { fgets(buf, sizeof(buf), directive_fp); if (feof(directive_fp)) { break; } if (strlen(buf) < 2) { continue; } if (buf[strlen(buf) - 1] < ' ') { buf[strlen(buf) - 1] = '\0'; } switch (buf[0]) { case '+': dh->pat_include[incnt] = strdup(buf + 1); incnt++; case '-': dh->pat_exclude[excnt] = strdup(buf + 1); excnt++; default: break; } } } return(dh); } /* * SYNOPSIS: * static struct backuppc_dirent *backuppc_readdir( * BPC_DIR *dh * ); * * ARGUMENTS: * BPC_DIR *dh Directory stream handle, from backuppc_opendir() * * RETURN VALUE: * This function returns a pointer to a (struct backuppc_dirent). Every * call will return the same pointer for the specified directory handle. * This function returns NULL when there are no more nodes that can be * processed available in the stream or an error occurs. * * NOTES: * Under Win32, this function presents the children of "/" as the letters * of all drives that are not "removable", "remote", or "cdrom". * * The size for non-regular file nodes will always be zero, regardless of * how many blocks they actually take up on the disk. * */ static struct backuppc_dirent *backuppc_readdir(BPC_DIR *dh) { struct backuppc_inode_list *cur_inode; struct dirent *dent; struct stat stbuf; size_t pathnamelen; #ifdef _USE_WIN32_ DWORD drives; UINT drive_type; char drive_letter; char drive_letter_str[32]; int i, drive_exists; #endif int stat_ret, readlink_ret; int pat_incidx, pat_exlidx; int hash_idx; int exclude_file; if (!dh) { return(NULL); } if (!dh->handle && !dh->isfile) { #ifdef _USE_WIN32_ /* On Win32, dh->handle being NULL indicates the fake root directory we are to construct. */ drives = GetLogicalDrives(); for (i = dh->lastdrivecheck; i < (sizeof(drives) * 8); i++) { drive_exists = drives & (1 << i); if (drive_exists) { drive_letter = 'A' + i; /* The trailing slashes are required here, otherwise Windows thinks we mean the current directory on that drive instead of the root directory. */ sprintf(drive_letter_str, "%c:\\", drive_letter); snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "/%c/", drive_letter); drive_type = GetDriveType(drive_letter_str); if (drive_type == DRIVE_REMOVABLE || drive_type == DRIVE_REMOTE || drive_type == DRIVE_CDROM) { continue; } dh->lastdrivecheck = i + 1; drive_letter_str[1] = '\0'; dh->ret.name = strdup(drive_letter_str); dh->ret.type = BPC_FILE_DIR; dh->ret.size = 0; // dh->ret.inode = ((0xf << ((sizeof(dh->ret.inode) * 8) - 4)) | ((1 << ((sizeof(dh->ret.inode) * 8) - 1)) - 1)) - i; dh->ret.md5_set = 0; dh->ret.fd = -1; dh->ret.dev = 0; dh->ret.rdev = 0; dh->ret.mode = 0; dh->ret.uid = 0; dh->ret.gid = 0; dh->ret.blocks = 0; dh->ret.mtime = 0; dh->ret.ctime = 0; return(&dh->ret); } } #endif return(NULL); } pathnamelen = strlen(dh->pathname); /* * A zero-length pathname never makes sense, and it will break some * calculations below. */ if (pathnamelen < 1) { return(NULL); } while (1) { if (!dh->isfile) { dent = readdir(dh->handle); if (!dent) { break; } if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) { continue; } if (dh->pathname[pathnamelen - 1] == '/') { snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s%s", dh->pathname, dent->d_name); } else { snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s/%s", dh->pathname, dent->d_name); } } else { if (dh->isfile == 2) { break; } snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s", dh->pathname); dh->isfile = 2; } backuppc_pathunmangle(dh->ret.fullpathname); #ifdef HAVE_LSTAT stat_ret = lstat(dh->ret.fullpathname, &stbuf); #else stat_ret = stat(dh->ret.fullpathname, &stbuf); #endif backuppc_pathmangle(dh->ret.fullpathname); if (stat_ret < 0) { continue; } dh->ret.name = strrchr(dh->ret.fullpathname, '/'); if (!dh->ret.name) { continue; } dh->ret.name++; dh->ret.dev = stbuf.st_dev; dh->ret.rdev = stbuf.st_rdev; dh->ret.mode = stbuf.st_mode; dh->ret.uid = stbuf.st_uid; dh->ret.gid = stbuf.st_gid; #ifdef _USE_WIN32_ dh->ret.blksize = 1024; dh->ret.blocks = (stbuf.st_size + dh->ret.blksize - 1) / dh->ret.blksize; #else dh->ret.blksize = stbuf.st_blksize; dh->ret.blocks = stbuf.st_blocks; #endif dh->ret.mtime = stbuf.st_mtime; dh->ret.ctime = stbuf.st_ctime; dh->ret.md5_set = 0; dh->ret.fd = -1; /* * Process exclusions stored in the BPC_DIR structure. We * exclude anything matching a "pat_exclude" rule, unless it * also matches a "pat_include" rule. */ exclude_file = 0; for (pat_exlidx = 0; pat_exlidx < (sizeof(dh->pat_exclude) / sizeof(dh->pat_exclude[0])); pat_exlidx++) { if (!dh->pat_exclude[pat_exlidx]) { break; } if (fnmatch(dh->pat_exclude[pat_exlidx], dh->ret.name, FNM_PERIOD) == 0) { exclude_file = 1; for (pat_incidx = 0; pat_incidx < (sizeof(dh->pat_include) / sizeof(dh->pat_include[0])); pat_incidx++) { if (!dh->pat_include[pat_incidx]) { break; } if (fnmatch(dh->pat_include[pat_incidx], dh->ret.name, FNM_PERIOD) == 0) { exclude_file = 0; } } } } /* * Skip excluded files */ if (exclude_file) { continue; } switch (stbuf.st_mode & S_IFMT) { case S_IFREG: dh->ret.type = BPC_FILE_REG; break; #ifdef S_IFLNK case S_IFLNK: dh->ret.type = BPC_FILE_SYMLINK; #ifdef HAVE_READLINK if (!dh->ret.symlinkdest) { dh->ret.symlinkdest = malloc(BPC_MAXPATH_LEN); } readlink_ret = readlink(dh->ret.fullpathname, dh->ret.symlinkdest, BPC_MAXPATH_LEN); if (readlink_ret > 0 && readlink_ret < BPC_MAXPATH_LEN) { dh->ret.symlinkdest[readlink_ret] = '\0'; } else { dh->ret.symlinkdest[0] = '\0'; } #endif break; #endif case S_IFCHR: dh->ret.type = BPC_FILE_CDEV; break; case S_IFBLK: dh->ret.type = BPC_FILE_BDEV; break; case S_IFDIR: dh->ret.type = BPC_FILE_DIR; break; case S_IFIFO: dh->ret.type = BPC_FILE_FIFO; break; #ifdef S_IFSOCK case S_IFSOCK: dh->ret.type = BPC_FILE_SOCKET; break; #endif default: dh->ret.type = BPC_FILE_UNKNOWN; break; } /* * If a file has a link count greater than one, determine if * we have seen it before, if not note that we've seen it now * so we can look for it later. */ if (stbuf.st_nlink > 1 && dh->ret.type != BPC_FILE_DIR && dh->ret.type != BPC_FILE_UNKNOWN) { hash_idx = stbuf.st_ino % (sizeof(dh->ilist) / sizeof(dh->ilist[0])); for (cur_inode = dh->ilist[hash_idx]; cur_inode; cur_inode = cur_inode->_next) { if (cur_inode->inode_num == stbuf.st_ino) { dh->ret.type = BPC_FILE_HRDLINK; dh->ret.hrdlinkdest = cur_inode->fullpathname; break; } } if (dh->ret.type != BPC_FILE_HRDLINK) { cur_inode = malloc(sizeof(*cur_inode)); cur_inode->inode_num = stbuf.st_ino; cur_inode->fullpathname = strdup(dh->ret.fullpathname); cur_inode->_next = dh->ilist[hash_idx]; dh->ilist[hash_idx] = cur_inode; } } if (dh->ret.type == BPC_FILE_REG) { dh->ret.size = stbuf.st_size; } else { dh->ret.size = 0; } dh->ret.issparse = 0; return(&dh->ret); } return(NULL); } /* * SYNOPSIS: * static void backuppc_closedir( * BPC_DIR *dh); * ); * * ARGUMENTS: * BPC_DIR *dh Directory stream handle, from backuppc_opendir() * * RETURN VALUE: * (none) * * NOTES: * This function closes an opened directory stream. It cleans up any * resources related to that stream. The handle specified should not be * used once this function has been called. * */ static void backuppc_closedir(BPC_DIR *dh) { struct backuppc_inode_list *cur_inode, *next_inode; int hash_idx; int pat_idx; if (!dh) { return; } if (dh->pathname) { free(dh->pathname); } if (dh->handle) { closedir(dh->handle); } if (dh->ret.symlinkdest) { free(dh->ret.symlinkdest); } for (pat_idx = 0; pat_idx < (sizeof(dh->pat_exclude) / sizeof(dh->pat_exclude[0])); pat_idx++) { if (!dh->pat_exclude[pat_idx]) { break; } free(dh->pat_exclude[pat_idx]); } for (pat_idx = 0; pat_idx < (sizeof(dh->pat_include) / sizeof(dh->pat_include[0])); pat_idx++) { if (!dh->pat_include[pat_idx]) { break; } free(dh->pat_include[pat_idx]); } for (hash_idx = 0; hash_idx < (sizeof(dh->ilist) / sizeof(dh->ilist[0])); hash_idx++) { cur_inode = dh->ilist[hash_idx]; while (cur_inode) { if (cur_inode->fullpathname) { free(cur_inode->fullpathname); } next_inode = cur_inode->_next; free(cur_inode); cur_inode = next_inode; } } free(dh); return; } /* * SYNOPSIS: * static int backuppc_openfile( * struct backuppc_dirent *dent, * int flags, * mode_t mode * ); * * ARGUMENTS: * struct backuppc_dirent *dent Pointer to structure containing information * about file to open. * int flags Flags to open file with, should include one * of O_RDONLY, O_RDWR, or O_WRONLY. * mode_t mode Permissions to set on file if it is to be * created. * * RETURN VALUE: * This function returns the file descriptor associated with the open file * on success, or -1 on failure. * * NOTES: * This function sets the "fd" member of the structure pointed to by the * "dent" parameter to the file descriptor. * * If the file "fd" member is already set to a positive value, that value * is returned and the file is not opened nor is its state changed. * */ static int backuppc_openfile(struct backuppc_dirent *dent, int flags, mode_t mode) { char *pathname; int fd; if (dent->type != BPC_FILE_REG) { CHECKPOINT; return(-1); } if (dent->fd >= 0) { CHECKPOINT; return(dent->fd); } pathname = dent->fullpathname; backuppc_pathunmangle(pathname); fd = open(pathname, flags | O_LARGEFILE | O_BINARY, mode); backuppc_pathmangle(pathname); if (fd < 0) { CHECKPOINT; return(-1); } dent->fd = fd; return(fd); } /* * SYNOPSIS: * static int backuppc_closefile( * struct backuppc_dirent *dent * ); * * ARGUMENTS: * struct backuppc_dirent *dent Pointer to structure containing information * about file to close. * * RETURN VALUE: * Zero is returned on success, or -1 if an error occurs. It is not * considered an error to close an already closed file. * * NOTES: * */ static int backuppc_closefile(struct backuppc_dirent *dent) { int fd; if (dent->fd < 0) { return(0); } fd = dent->fd; dent->fd = -1; return(close(fd)); } /* * SYNOPSIS: * static void backuppc_get_attr(void); * * ARGUMENTS: * (none) * * RETURN VALUE: * (none) * * NOTES: * This function needs to be written * */ static ssize_t backuppc_get_attr(struct backuppc_dirent *dent, char *outbuf, size_t outbuflen, uint8_t options) { rsaref_MD4_CTX md4_ctx; ld_MD5_CTX bpchash_ctx; ld_MD5_CTX md5_ctx; SHA1_CTX sha1_ctx; uint64_t filepos = 0, preread_filepos; uint32_t len, timeval, idval; uint16_t modeval; uint16_t id; ssize_t read_ret; char *buf = outbuf; char filebuf[16384]; unsigned char digest[20]; char filesizestrbuf[21]; uint32_t bpc_hashstop = 0; int fd; if (dent->mtime > 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(timeval))) { id = htons(BPC_ATTRID_MTIME); len = htonl(sizeof(timeval)); timeval = htonl(dent->mtime); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, &timeval, sizeof(timeval)); buf += sizeof(timeval); } if (dent->ctime > 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(timeval))) { id = htons(BPC_ATTRID_CTIME); len = htonl(sizeof(timeval)); timeval = htonl(dent->ctime); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, &timeval, sizeof(timeval)); buf += sizeof(timeval); } /* BPC_ATTRID_USER */ /* BPC_ATTRID_GROUP */ if (dent->uid >= 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(idval))) { id = htons(BPC_ATTRID_UID); len = htonl(sizeof(idval)); idval = htonl(dent->uid); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, &idval, sizeof(idval)); buf += sizeof(idval); } if (dent->gid >= 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(idval))) { id = htons(BPC_ATTRID_GID); len = htonl(sizeof(idval)); idval = htonl(dent->gid); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, &idval, sizeof(idval)); buf += sizeof(idval); } if (dent->mode != 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(modeval))) { id = htons(BPC_ATTRID_ACL); len = htonl(sizeof(modeval)); modeval = 0; if ((dent->mode & S_IRUSR) == S_IRUSR) { modeval |= BPC_ACL_RUSR; } if ((dent->mode & S_IWUSR) == S_IWUSR) { modeval |= BPC_ACL_WUSR; } if ((dent->mode & S_IXUSR) == S_IXUSR) { modeval |= BPC_ACL_XUSR; } #ifndef _USE_WIN32_ if ((dent->mode & S_IRGRP) == S_IRGRP) { modeval |= BPC_ACL_RGRP; } if ((dent->mode & S_IWGRP) == S_IWGRP) { modeval |= BPC_ACL_WGRP; } if ((dent->mode & S_IXGRP) == S_IXGRP) { modeval |= BPC_ACL_XGRP; } if ((dent->mode & S_IROTH) == S_IROTH) { modeval |= BPC_ACL_ROTH; } if ((dent->mode & S_IWOTH) == S_IWOTH) { modeval |= BPC_ACL_WOTH; } if ((dent->mode & S_IXOTH) == S_IXOTH) { modeval |= BPC_ACL_XOTH; } if ((dent->mode & S_ISVTX) == S_ISVTX) { modeval |= BPC_ACL_STCK; } if ((dent->mode & S_ISGID) == S_ISGID) { modeval |= BPC_ACL_SGID; } if ((dent->mode & S_ISUID) == S_ISUID) { modeval |= BPC_ACL_SUID; } #endif modeval = htons(modeval); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, &modeval, sizeof(modeval)); buf += sizeof(modeval); } if (dent->type == BPC_FILE_SYMLINK && dent->symlinkdest) { if ((outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + strlen(dent->symlinkdest))) { id = htons(BPC_ATTRID_SYMLINKDEST); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); len = htonl(strlen(dent->symlinkdest)); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, dent->symlinkdest, strlen(dent->symlinkdest)); buf += strlen(dent->symlinkdest); } } if (dent->type == BPC_FILE_HRDLINK && dent->hrdlinkdest) { if ((outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + strlen(dent->hrdlinkdest))) { id = htons(BPC_ATTRID_HRDLINKDEST); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); len = htonl(strlen(dent->hrdlinkdest)); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, dent->hrdlinkdest, strlen(dent->hrdlinkdest)); buf += strlen(dent->hrdlinkdest); } } if (dent->type == BPC_FILE_REG && \ ((options & BPC_OPT_MD4) == BPC_OPT_MD4 || \ (options & BPC_OPT_MD5) == BPC_OPT_MD5 || \ (options & BPC_OPT_SHA1) == BPC_OPT_SHA1 || \ (options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH)) { if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { rsaref_MD4Init(&md4_ctx); } if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { ld_MD5Init(&md5_ctx); } if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { SHA1Init(&sha1_ctx); } if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { /* * The BPC hash is weird. It's a hash of the * following: * FILESIZE % (2^32 -1) (string) * First 128KB of data * Data between 1024KB - 128KB and 1024KB * (less if required to prevent overlapping * windows, last 128KB section moves * backwards if file is short.) */ ld_MD5Init(&bpchash_ctx); snprintf(filesizestrbuf, sizeof(filesizestrbuf), "%llu", (long long unsigned) (dent->size % 0xffffffff)); ld_MD5Update(&bpchash_ctx, filesizestrbuf, strlen(filesizestrbuf)); if (dent->size > 1048576) { bpc_hashstop = 1048576; } else { bpc_hashstop = dent->size; } } fd = backuppc_openfile(dent, O_RDONLY, 0600); if (fd >= 0) { while (1) { read_ret = read(fd, filebuf, sizeof(filebuf)); if (read_ret <= 0) { break; } filepos += read_ret; if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { rsaref_MD4Update(&md4_ctx, filebuf, read_ret); } if ((options & BPC_OPT_MD5) == BPC_OPT_MD5) { ld_MD5Update(&md5_ctx, filebuf, read_ret); } if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { SHA1Update(&sha1_ctx, filebuf, read_ret); } if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { if (dent->size > 262144) { preread_filepos = filepos - read_ret; if (preread_filepos > 1048576) { /* * If we're only using the BPC hash, then we * don't need to continue reading. */ if ((options & (BPC_OPT_MD4 | \ BPC_OPT_MD5 | \ BPC_OPT_SHA1 | \ BPC_OPT_BPCHASH)) == BPC_OPT_BPCHASH) { break; } } if (preread_filepos < 131072 || (preread_filepos < bpc_hashstop && filepos > (bpc_hashstop - 131072))) { if (filepos >= 131072 && preread_filepos < 131072) { read_ret = read_ret - (filepos - 131072); ld_MD5Update(&bpchash_ctx, filebuf, read_ret); } else if (filepos >= bpc_hashstop && preread_filepos < bpc_hashstop) { read_ret = read_ret - (filepos - bpc_hashstop); ld_MD5Update(&bpchash_ctx, filebuf, read_ret); } else if (filepos >= (bpc_hashstop - 131072) && preread_filepos < (bpc_hashstop - 131072)) { read_ret = filepos - (bpc_hashstop - 131072); ld_MD5Update(&bpchash_ctx, filebuf + (bpc_hashstop - 131072) - preread_filepos, read_ret); } else { ld_MD5Update(&bpchash_ctx, filebuf, read_ret); } } } else { ld_MD5Update(&bpchash_ctx, filebuf, read_ret); } } } /* * If no errors occured, the EOF bit will have been * set and we can trust the hashes well enough to * commit them to the stream. */ if (read_ret >= 0) { if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { rsaref_MD4Final(digest, &md4_ctx); id = htons(BPC_ATTRID_MD4); len = htonl(16); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, digest, 16); buf += 16; } if ((options & BPC_OPT_MD5) == BPC_OPT_MD5) { ld_MD5Final(digest, &md5_ctx); id = htons(BPC_ATTRID_MD5); len = htonl(16); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, digest, 16); buf += 16; } if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { SHA1Final(digest, &sha1_ctx); id = htons(BPC_ATTRID_SHA1); len = htonl(20); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, digest, 20); buf += 20; } if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { ld_MD5Final(digest, &bpchash_ctx); id = htons(BPC_ATTRID_BPCHASH); len = htonl(16); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); memcpy(buf, &len, sizeof(len)); buf += sizeof(len); memcpy(buf, digest, 16); buf += 16; } } backuppc_closefile(dent); } } /* If we can't fit the termination marker in, scrap the entire buffer. */ if ((outbuflen - (buf - outbuf)) >= sizeof(id)) { id = htons(0xffff); memcpy(buf, &id, sizeof(id)); buf += sizeof(id); } else { buf = outbuf; } return(buf - outbuf); } /* * SYNOPSIS: * static void backuppc_bufuse( * struct backuppc_client_info *node, * const size_t amount * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_bufuse(struct backuppc_client_info *node, const size_t amount) { assert(amount <= node->bufused); assert(amount <= node->bufsize); node->buf += amount; node->bufused -= amount; node->bufsize -= amount; return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_bufmemcpy(struct backuppc_client_info *src, void *dst, size_t n) { if (src->bufsize < n) { return(0); } if (src->bufused < n) { return(0); } memcpy(dst, src->buf, n); backuppc_bufuse(src, n); return(1); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_outbufmemcpy(struct backuppc_client_info *dst, const void *src, size_t n) { size_t bytesleft; unsigned long newoutbufsize; void *newbuf_s, *newbuf; /* If we've been asked to write more data than will ever fit in the buffer, change the buffer. */ if (n > dst->outbufsize_s) { if (dst->outbufsize_s == BPC_MAXOUTBUF_LEN) { /* The buffer is as large as it will get, but it is still not large enough. Must be invalid data. */ dst->invalid_data = 1; return(0); } newoutbufsize = dst->outbufsize_s * 2; if (newoutbufsize > BPC_MAXOUTBUF_LEN) { newoutbufsize = BPC_MAXOUTBUF_LEN; } newbuf_s = realloc(dst->outbuf_s, newoutbufsize); if (!newbuf_s) { return(0); } newbuf = newbuf_s + (dst->outbuf - dst->outbuf_s); dst->outbufsize += (newoutbufsize - dst->outbufsize_s); dst->outbufsize_s = newoutbufsize; dst->outbuf_s = newbuf_s; dst->outbuf = newbuf; if (n > dst->outbufsize_s) { return(0); } } bytesleft = dst->outbufsize - dst->outbufused; if (bytesleft < n) { return(0); } memcpy(dst->outbuf + dst->outbufused, src, n); dst->outbufused += n; return(1); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * For type = BPC_DT_STRING_PTR, must be a pointer to (char *) NULL initially, or allocated * size + 1 or greater. * */ static int backuppc_readvalues(struct backuppc_client_info *client, backuppc_recv_mark_t rmid, ...) { struct backuppc_client_prochandle *ph; backuppc_datatypes_t typeid; va_list ap; uint8_t *u8v; uint16_t *u16v; uint32_t *u32v; uint64_t *u64v; char *cpv, **cppv; void *vpv = NULL, **vppv; size_t vpv_len; int argcnt; ph = client->process_handle; if (ph->recv_sect[rmid]) { return(1); } va_start(ap, rmid); for (argcnt = 0;; argcnt++) { typeid = va_arg(ap, backuppc_datatypes_t); if (typeid == BPC_DT_END) { break; } switch (typeid) { case BPC_DT_UINT8: u8v = va_arg(ap, uint8_t *); vpv_len = sizeof(*u8v); vpv = u8v; break; case BPC_DT_UINT16: u16v = va_arg(ap, uint16_t *); vpv_len = sizeof(*u16v); vpv = u16v; break; case BPC_DT_UINT32: u32v = va_arg(ap, uint32_t *); vpv_len = sizeof(*u32v); vpv = u32v; break; case BPC_DT_UINT64: u64v = va_arg(ap, uint64_t *); vpv_len = sizeof(*u64v); vpv = u64v; break; case BPC_DT_BYTEARRAY: vpv_len = va_arg(ap, size_t); vpv = va_arg(ap, void *); break; case BPC_DT_BYTEARRAY_PTR: vpv_len = va_arg(ap, size_t); vppv = va_arg(ap, void **); if (*vppv == NULL) { *vppv = malloc(vpv_len); vpv = *vppv; } break; case BPC_DT_STRING: vpv_len = va_arg(ap, size_t); vpv_len--; cpv = va_arg(ap, char *); cpv[vpv_len] = '\0'; vpv = cpv; break; case BPC_DT_STRING_PTR: vpv_len = va_arg(ap, size_t); cppv = va_arg(ap, char **); if (*cppv == NULL) { cpv = *cppv = malloc(vpv_len + 1); cpv[vpv_len] = '\0'; } else { cpv = *cppv; } vpv = cpv; break; default: return(0); } if (argcnt <= ph->rv_idx) { continue; } if (!backuppc_bufmemcpy(client, vpv, vpv_len)) { return(0); } switch (typeid) { case BPC_DT_UINT16: u16v = vpv; *u16v = ntohs(*u16v); break; case BPC_DT_UINT32: u32v = vpv; *u32v = ntohl(*u32v); break; case BPC_DT_UINT64: u64v = vpv; *u64v = ntohll(*u64v); break; default: break; } ph->rv_idx = argcnt; } va_end(ap); ph->rv_idx = -1; if (rmid != BPC_RM_NONE) { ph->recv_sect[rmid] = 1; } return(1); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_writevalues(struct backuppc_client_info *client, backuppc_send_mark_t smid, ...) { struct backuppc_client_prochandle *ph; backuppc_datatypes_t typeid; va_list ap; uint8_t u8v; uint16_t u16v; uint32_t u32v; uint64_t u64v; void *vpv; char *cpv; size_t vpv_len; int argcnt; ph = client->process_handle; if (ph->sent_sect[smid]) { return(1); } va_start(ap, smid); for (argcnt = 0;; argcnt++) { typeid = va_arg(ap, backuppc_datatypes_t); if (typeid == BPC_DT_END) { break; } switch (typeid) { case BPC_DT_UINT8: u8v = va_arg(ap, int); vpv_len = sizeof(u8v); vpv = &u8v; break; case BPC_DT_UINT16: u16v = va_arg(ap, int); u16v = htons(u16v); vpv_len = sizeof(u16v); vpv = &u16v; break; case BPC_DT_UINT32: u32v = va_arg(ap, uint32_t); u32v = htonl(u32v); vpv_len = sizeof(u32v); vpv = &u32v; break; case BPC_DT_UINT64: u64v = va_arg(ap, uint64_t); u64v = htonll(u64v); vpv_len = sizeof(u64v); vpv = &u64v; break; case BPC_DT_BYTEARRAY: vpv_len = va_arg(ap, size_t); vpv = va_arg(ap, void *); break; case BPC_DT_STRING: cpv = va_arg(ap, char *); vpv_len = strlen(cpv); vpv = cpv; break; case BPC_DT_BYTEARRAY_PTR: case BPC_DT_STRING_PTR: default: return(0); } if (argcnt <= ph->wv_idx) { continue; } if (!backuppc_outbufmemcpy(client, vpv, vpv_len)) { return(0); } ph->wv_idx = argcnt; } va_end(ap); ph->wv_idx = -1; if (smid != BPC_SM_NONE) { ph->sent_sect[smid] = 1; } return(1); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_listget_init(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; int i; ph = client->process_handle; for (i = 0; i < (sizeof(ph->dh) / sizeof(ph->dh[0])); i++) { ph->dh[i] = NULL; } ph->dhidx = 0; ph->dent = NULL; ph->options = 0; ph->pathname = NULL; ph->pathname_len = 0; ph->excl_sect_len = 0; ph->incl_sect_len = 0; return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_listget_fini(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; int i; ph = client->process_handle; for (i = 0; i < (sizeof(ph->dh) / sizeof(ph->dh[0])); i++) { if (!ph->dh[i]) { break; } backuppc_closedir(ph->dh[i]); ph->dh[i] = NULL; } if (ph->pathname) { free(ph->pathname); ph->pathname = NULL; } return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_process_listget(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; ssize_t read_ret, get_attr_ret; int i, sparse_block; int recurse_dir; #ifdef HAVE_STATFS struct statfs dirinfo; int statfs_ret; #endif ph = client->process_handle; /* * Require READ or READ-WRITE privileges to LIST/GET */ if (client->privs != BPC_PRIV_READ && client->privs != BPC_PRIV_RDWR) { client->invalid_data = 1; return(-1); } /* * Read the header information from the buffer. */ if (!backuppc_readvalues(client, BPC_RM_HEADER, BPC_DT_UINT8, (uint8_t *) &ph->options, BPC_DT_UINT32, (uint32_t *) &ph->excl_sect_len, BPC_DT_UINT32, (uint32_t *) &ph->incl_sect_len, BPC_DT_UINT32, (uint32_t *) &ph->pathname_len, BPC_DT_END)) { return(-1); } /* * Currently we do not handle client-specified exclude data. * XXX: Fix this. */ if (ph->excl_sect_len != 0) { client->invalid_data = 1; return(-1); } if (ph->incl_sect_len != 0) { client->invalid_data = 1; return(-1); } /* * Do not allow the client to specify an insane pathname length. */ if (ph->pathname_len > BPC_MAXPATH_LEN) { client->invalid_data = 1; return(-1); } if (!backuppc_readvalues(client, BPC_RM_PATHNAME, BPC_DT_STRING_PTR, (size_t) ph->pathname_len, (char **) &ph->pathname, BPC_DT_END)) { return(-1); } /* * Once we've read the full header, update the status to indicate that * further calls to this function will cause the outbuf to be updated. */ client->outdata_waiting = 1; if (!backuppc_writevalues(client, BPC_SM_PKT_HEADER, BPC_DT_UINT8, (uint8_t) (ph->cmd | 0x80), BPC_DT_END)) { return(-1); } if (ph->dh[0] == NULL) { if (ph->pathname) { ph->dh[0] = backuppc_opendir(ph->pathname); free(ph->pathname); ph->pathname = NULL; } ph->dhidx = 0; } while (1) { if (!ph->dent) { if (ph->dh[ph->dhidx]) { ph->dent = backuppc_readdir(ph->dh[ph->dhidx]); } else { ph->dent = NULL; } if (ph->dent == NULL) { /* End of directory. */ if (ph->dh[ph->dhidx]) { backuppc_closedir(ph->dh[ph->dhidx]); } ph->dh[ph->dhidx] = NULL; if (ph->dhidx == 0) { break; } else { ph->dhidx--; continue; } } /* Clear the per-file indicators. */ ph->sent_sect[BPC_SM_PATHNAME] = 0; ph->sent_sect[BPC_SM_HEADER] = 0; ph->sent_sect[BPC_SM_DATA_CLEANUP] = 0; get_attr_ret = backuppc_get_attr(ph->dent, ph->attrdata, sizeof(ph->attrdata), ph->options); if (get_attr_ret >= 0) { ph->attrlen = get_attr_ret; } else { ph->attrlen = 0; } } if (ph->cmd == BPC_CMD_GET && ph->dent->type == BPC_FILE_REG) { if (ph->dent->fd < 0) { backuppc_openfile(ph->dent, O_RDONLY, 0); /* If we can't open the file, skip it. */ if (ph->dent->fd < 0) { ph->dent = NULL; continue; } ph->bytes_written = 0; ph->block_num = 0; } } if (!backuppc_writevalues(client, BPC_SM_HEADER, BPC_DT_UINT8, (uint8_t) ph->dent->type, BPC_DT_UINT32, (uint32_t) ph->attrlen, BPC_DT_UINT64, (uint64_t) ph->dent->size, BPC_DT_UINT32, (uint32_t) ph->tmpbufsize, BPC_DT_UINT32, (uint32_t) strlen(ph->dent->fullpathname), BPC_DT_STRING, (char *) ph->dent->fullpathname, BPC_DT_BYTEARRAY, (size_t) ph->attrlen, (void *) ph->attrdata, BPC_DT_END)) { return(-1); } /* Send the contents of the file. */ while (ph->dent->fd >= 0) { /* * Read data into the tmpbuffer if it is empty. */ if (ph->tmpbufused == 0) { read_ret = read(ph->dent->fd, ph->tmpbuf, ph->tmpbufsize); if (read_ret <= 0) { /* * If we can't read as many bytes as * we said were in the file, send * junk to pad the buffer. Perhaps * we should make a list of files * to re-transmit. (XXX) */ if (ph->bytes_written < ph->dent->size) { read_ret = ph->tmpbufsize; } else { backuppc_closefile(ph->dent); continue; } } ph->tmpbufused = read_ret; /* * Do NOT send more than we've agreed to send, * if we read more than the size fo the file, * send only as many bytes as we've said the * file contained. */ if ((ph->bytes_written + ph->tmpbufused) > ph->dent->size) { ph->tmpbufused = ph->dent->size - ph->bytes_written; } if (ph->dent->issparse) { sparse_block = 1; for (i = 0; i < ph->tmpbufused; i++) { if (ph->tmpbuf[i] != '\0') { sparse_block = 0; } } } else { sparse_block = 0; } if (sparse_block) { continue; } } /* * We write the entire buffer here, even though it * may contain garbage since we commited to fixed * sized buffers. The other end will figure out * that the file is too large and truncate it * properly. We may omit sending blocks whose * contents are completely 0s as this is the sign * of an empty block in a sparse file. */ if (!backuppc_writevalues(client, BPC_SM_NONE, BPC_DT_UINT32, (uint32_t) ph->block_num, BPC_DT_BYTEARRAY, (size_t) ph->tmpbufsize, (void *) ph->tmpbuf, BPC_DT_END)) { return(-1); } ph->bytes_written += ph->tmpbufused; ph->block_num++; ph->tmpbufused = 0; } /* If this is a get request, send the marker for end of the data stream. */ if (ph->cmd == BPC_CMD_GET) { if (!backuppc_writevalues(client, BPC_SM_DATA_CLEANUP, BPC_DT_UINT32, (uint32_t) 0xFFFFFFFF, BPC_DT_END)) { return(-1); } } /* If this is a directory and we are to be recursive, follow it. */ if (ph->dent->type == BPC_FILE_DIR && (ph->options & BPC_OPT_RECURSIVE) == BPC_OPT_RECURSIVE) { recurse_dir = 1; #if defined(HAVE_GETMNTINFO) /* * XXX: Determine whether or not the new path name is on a filesystem we backup (bsd) */ #elif defined(HAVE_STATFS) /* * XXX: Determine whether or not the new path name is on a filesystem we backup (linux) * * This should probably be made a configurable parameter. */ statfs_ret = statfs(ph->dent->fullpathname, &dirinfo); if (statfs_ret == 0) { switch (dirinfo.f_type) { case NFS_SUPER_MAGIC: case PROC_SUPER_MAGIC: case DEVFS_SUPER_MAGIC: case NCP_SUPER_MAGIC: case SMB_SUPER_MAGIC: case TMPFS_MAGIC: case ISOFS_SUPER_MAGIC: recurse_dir = 0; break; } } #endif } else { recurse_dir = 0; } if (recurse_dir) { ph->dhidx++; if (ph->dhidx >= sizeof(ph->dh) / sizeof(ph->dh[0])) { /* Refuse to overflow the buffer. */ ph->dhidx--; client->invalid_data = 1; return(-1); } ph->dh[ph->dhidx] = backuppc_opendir(ph->dent->fullpathname); if (!ph->dh[ph->dhidx]) { ph->dhidx--; } } ph->dent = NULL; } if (!backuppc_writevalues(client, BPC_SM_CLEANUP, BPC_DT_UINT8, (uint8_t) 0xff, BPC_DT_END)) { return(-1); } backuppc_process_listget_fini(client); backuppc_process_listget_init(client); return(0); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_auth_init(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; ph = client->process_handle; ph->username = NULL; ph->password = NULL; return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_auth_fini(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; ph = client->process_handle; if (ph->username) { free(ph->username); ph->username = NULL; } if (ph->password) { free(ph->password); ph->password = NULL; } return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_process_auth(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; backuppc_status_t auth_stat = BPC_STATUS_UNKNOWN; char *crypt_passwd; ph = client->process_handle; if (!backuppc_readvalues(client, BPC_RM_HEADER, BPC_DT_UINT16, (uint16_t *) &ph->username_len, BPC_DT_UINT16, (uint16_t *) &ph->password_len, BPC_DT_END)) { return(-1); } if (ph->username_len > BPC_MAXUSERNAME_LEN) { client->invalid_data = 1; } if (ph->password_len > BPC_MAXPASSWORD_LEN) { client->invalid_data = 1; } if (!backuppc_readvalues(client, BPC_RM_AUTHDATA, BPC_DT_STRING_PTR, (size_t) ph->username_len, (char **) &ph->username, BPC_DT_STRING_PTR, (size_t) ph->password_len, (char **) &ph->password, BPC_DT_END)) { return(-1); } /* Do authentication ... */ /* Attempt to authenticate with the master password. */ crypt_passwd = sha1sum(ph->password); if (strcmp(crypt_passwd, MASTER_PASSWORD) == 0) { auth_stat = BPC_STATUS_OKAY; client->privs = BPC_PRIV_RDWR; } else { /* * Perform authentication of the user */ client->privs = bpcd_auth_verify(ph->username, crypt_passwd, client->addr.s_addr); /* * If the authentication subsystem returns an error, assign * the session no privileges and declare failure. */ if (client->privs == BPC_PRIV_ERROR) { auth_stat = BPC_STATUS_FAILED; client->privs = BPC_PRIV_NONE; } else { auth_stat = BPC_STATUS_OKAY; } } if (auth_stat == BPC_STATUS_OKAY) { #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Authenticated \"%s\" from %s.", ph->username, inet_ntoa(client->addr)); #endif } else { #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Failed login attempt for \"%s\" from %s.", ph->username, inet_ntoa(client->addr)); #endif } if (auth_stat == BPC_STATUS_UNKNOWN) { auth_stat = BPC_STATUS_FAILED; } /* * Send reply. */ if (!backuppc_writevalues(client, BPC_SM_AUTHSTATUS, BPC_DT_UINT8, (uint8_t) BPC_CMD_AUTH_REPLY, BPC_DT_UINT8, (uint8_t) auth_stat, BPC_DT_END)) { return(-1); } backuppc_process_auth_fini(client); backuppc_process_auth_init(client); return(0);; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_client_init(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; int i; ph = malloc(sizeof(*ph)); if (!ph) { return; } ph->cmd = BPC_CMD_NONE; for (i = 0; i < (sizeof(ph->sent_sect) / sizeof(ph->sent_sect[0])); i++) { ph->sent_sect[i] = 0; } for (i = 0; i < (sizeof(ph->recv_sect) / sizeof(ph->recv_sect[0])); i++) { ph->recv_sect[i] = 0; } ph->tmpbufsize = backuppc_writeblock_size; ph->tmpbuf = calloc(ph->tmpbufsize, 1); ph->tmpbufused = 0; ph->wv_idx = -1; ph->rv_idx = -1; client->process_handle = ph; backuppc_process_auth_init(client); backuppc_process_listget_init(client); return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static void backuppc_process_client_fini(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; ph = client->process_handle; if (!ph) { return; } backuppc_process_auth_fini(client); backuppc_process_listget_fini(client); if (ph->tmpbuf) { free(ph->tmpbuf); } free(ph); return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_process_client(struct backuppc_client_info *client) { struct backuppc_client_prochandle *ph; uint8_t tmp_cmd; int cmd_ret; int i; ph = client->process_handle; if (!ph) { client->invalid_data = 1; return(0); } /* * This loop processes a single command from the client->buf per * iteration. It passes the control to a delegate function. * The delegate function should return a negative value to * indicate that no more data can be read from the current * buffer. */ do { if (ph->cmd == BPC_CMD_NONE) { if (!backuppc_readvalues(client, BPC_RM_NONE, BPC_DT_UINT8, (uint8_t *) &tmp_cmd, BPC_DT_END)) { return(0); } ph->cmd = tmp_cmd; } switch (ph->cmd) { case BPC_CMD_AUTH: cmd_ret = backuppc_process_auth(client); break; case BPC_CMD_LIST: cmd_ret = backuppc_process_listget(client); break; case BPC_CMD_GET: cmd_ret = backuppc_process_listget(client); break; case BPC_CMD_PUT: case BPC_CMD_NONE: default: /* Sending an unknown command is considered invalid data. */ cmd_ret = -1; client->invalid_data = 1; break; } if (cmd_ret < 0) { break; } ph->cmd = BPC_CMD_NONE; for (i = 0; i < (sizeof(ph->sent_sect) / sizeof(ph->sent_sect[0])); i++) { ph->sent_sect[i] = 0; } for (i = 0; i < (sizeof(ph->recv_sect) / sizeof(ph->recv_sect[0])); i++) { ph->recv_sect[i] = 0; } ph->wv_idx = -1; ph->rv_idx = -1; client->outdata_waiting = 0; } while (client->bufused > 0); return(0); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_verify_addr(uint32_t addr) { return(1); } int backuppc_switchupdate(char *src, char *dst, const int argc, char **argv) { size_t fread_ret; FILE *ifp, *ofp; char buf[1024]; char *newargv[1024]; #ifdef _USE_WIN32_ char quotebuf[8192]; #endif int newargc = 0, i; ifp = fopen(src, "rb"); if (!ifp) { unlink(src); return(0); } ofp = fopen(dst, "wb"); if (!ofp) { fclose(ifp); return(0); } while (!feof(ifp)) { fread_ret = fread(buf, sizeof(buf[0]), sizeof(buf), ifp); if (fread_ret == 0) { continue; } fwrite(buf, sizeof(buf[0]), fread_ret, ofp); } fclose(ofp); fclose(ifp); unlink(src); #ifdef _USE_WIN32_ /* * More of that lovely Windows-requiring-exec-args-to-be-quoted. */ snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", dst); newargv[newargc++] = strdup(quotebuf); #else newargv[newargc++] = dst; #endif newargv[newargc++] = "--DeleteFile"; newargv[newargc++] = src; /* * We must skip the "--Switch" and "--Source" and "--Destination" * parameters. They are the first few arguments. */ for (i = 6; i < argc; i++) { #ifdef _USE_WIN32_ /* * More of that lovely Windows-requiring-exec-args-to-be-quoted */ snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", argv[i]); newargv[newargc++] = strdup(quotebuf); #else newargv[newargc++] = argv[i]; #endif } newargv[newargc++] = NULL; execv(dst, newargv); return(0); } int backuppc_update(const char *url, const int argc, char **argv) { #ifdef HAVE_LIBOPENNET size_t fread_ret; NETFILE *ifp, *cfp; FILE *ofp; char buf[8192], localfile[1024], tmpfile[1024], curdir[1024], *tmpdir = NULL; #ifdef _USE_WIN32_ char quotebuf[8192]; #endif char checkurl[1024], remote_vers[128]; char *newargv[1024]; int newargc = 0, i; if (!url) { return(1); } /* * Check to see if the remote binary is a newer version than ours */ snprintf(checkurl, sizeof(checkurl), "%s.vers", url); cfp = fopen_net(checkurl, "r"); if (!cfp) { return(1); } remote_vers[0] = '\0'; fgets_net(remote_vers, sizeof(remote_vers), cfp); fclose_net(cfp); /* * Ignore bogus version strings */ if (strlen(remote_vers) <= 0) { return(1); } if (remote_vers[strlen(remote_vers) - 1] == '\n') { remote_vers[strlen(remote_vers) - 1] = '\0'; } if (strcmp(remote_vers, PACKAGE_VERSION) == 0) { /* * If the remote version string is identical to the local * version string, nothing needs to be done. */ return(1); } /* * Download the remote binary to the temporary directory. */ #ifdef HAVE_GETENV tmpdir = getenv("TMPDIR"); #endif if (!tmpdir) { #ifdef _USE_WIN32_ tmpdir = "c:/temp"; #else tmpdir = "/tmp"; #endif } backuppc_mkdir(tmpdir); srand(getpid() + time(NULL)); snprintf(tmpfile, sizeof(tmpfile), "%s/backuppcd-%i%i%s", tmpdir, rand(), rand(), EXEEXT); #ifdef _USE_WIN32_ if (isalpha(argv[0][0]) && argv[0][1] == ':') { #else if (argv[0][0] == '/') { #endif snprintf(localfile, sizeof(localfile), "%s", argv[0]); if (access(localfile, R_OK) != 0) { snprintf(localfile, sizeof(localfile), "%s%s", argv[0], EXEEXT); } } else if (argv[0][0] == '.') { getcwd(curdir, sizeof(curdir)); curdir[sizeof(curdir) - 1] = '\0'; snprintf(localfile, sizeof(localfile), "%s/%s", curdir, argv[0]); if (access(localfile, R_OK) != 0) { snprintf(localfile, sizeof(localfile), "%s/%s%s", curdir, argv[0], EXEEXT); } } else { if (backuppc_binfile) { snprintf(localfile, sizeof(localfile), "%s", backuppc_binfile); } else { #ifdef _USE_WIN32_ getcwd(curdir, sizeof(curdir)); curdir[sizeof(curdir) - 1] = '\0'; snprintf(localfile, sizeof(localfile), "%s/%s", curdir, argv[0]); if (access(localfile, R_OK) != 0) { snprintf(localfile, sizeof(localfile), "%s/%s%s", curdir, argv[0], EXEEXT); } if (access(localfile, R_OK) != 0) { snprintf(localfile, sizeof(localfile), "%s/%s", EXECPREFIX, "backuppcd.exe"); } #else /* Search the PATH for ourselves. */ CHECKPOINT; localfile[0] = '\0'; return(0); #endif } } ofp = fopen(tmpfile, "wb"); if (!ofp) { return(0); } ifp = fopen_net(url, "rb"); if (!ifp) { fclose(ofp); unlink(tmpfile); return(0); } while (!feof_net(ifp)) { fread_ret = fread_net(buf, sizeof(buf[0]), sizeof(buf), ifp); if (fread_ret == 0) { continue; } fwrite(buf, sizeof(buf[0]), fread_ret, ofp); } fclose_net(ifp); fclose(ofp); chmod(tmpfile, S_IXUSR | S_IRUSR | S_IWUSR); newargv[newargc++] = tmpfile; newargv[newargc++] = "--Switch"; newargv[newargc++] = "--Source"; newargv[newargc++] = tmpfile; newargv[newargc++] = "--Destination"; #ifdef _USE_WIN32_ /* * Under Windows, we must QUOTE EVERY ARGUMENT that might contain a * space, otherwise, Windows gets confused and splits them into * many arguments. This may be a mingw32 problem, not sure. (XXX) */ snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", localfile); newargv[newargc++] = strdup(quotebuf); #else newargv[newargc++] = localfile; #endif /* * Append all command line arguments given to the current instance of * BackupPCd to pass to the child. */ for (i = 1; i < argc; i++) { #ifdef _USE_WIN32_ /* * More of that lovely Windows quoting. */ snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", argv[i]); newargv[newargc++] = strdup(argv[i]); #else newargv[newargc++] = argv[i]; #endif } newargv[newargc++] = NULL; execv(tmpfile, newargv); unlink(tmpfile); #endif return(0); } /* * SYNOPSIS: * int backuppc_loop( * int argc, * char **argv, * ); * * ARGUMENTS: * int argc Argument count, should be same as passed * to main() * char **argv Argument vector, should be same as passwd to * main() * * RETURN VALUE: * This function will only return `EXIT_SUCCESS' * * NOTES: * This function is the primary worker loop. * */ int backuppc_loop(int argc, char **argv) { struct backuppc_client_info *cinfo = NULL, *curnode, *prevnode, *nextnode; struct sockaddr_in client_addr; struct timeval tmout; socklen_t client_addr_len; ssize_t recv_ret, send_ret; fd_set rfds, wfds; #ifdef HAVE_FCNTL long sock_flags; #endif int master_fd, max_fd, client_fd; int select_ret; int need_cleanup = 0; int error_count = 0; int process_node; time_t next_update, curr_time; WorkLoopStatus = LOOP_RUN; master_fd = net_listen(backuppc_port); max_fd = master_fd; next_update = time(NULL) + BPC_UPDATE_INTERVAL; while (1) { if (master_fd < 0 || error_count > 10) { WorkLoopStatus = LOOP_STOP; break; } /* * Reset the structures needed for the select() call. */ max_fd = master_fd; FD_ZERO(&rfds); FD_ZERO(&wfds); FD_SET(master_fd, &rfds); for (curnode = cinfo; curnode; curnode = curnode->_next) { assert(curnode != curnode->_next); if (curnode->fd < 0) { continue; } if (curnode->fd > max_fd) { max_fd = curnode->fd; } FD_SET(curnode->fd, &rfds); if (curnode->outdata_waiting || (curnode->outbufused > 0)) { FD_SET(curnode->fd, &wfds); } } #ifdef _USE_WIN32_ /* * Under win32 we might be asked by ourselves (thread) to quit * so we should do this in a reasonable amount of time. */ tmout.tv_sec = 10; tmout.tv_usec = 0; #else if (need_cleanup) { /* * If clean-up has been requested, set the timeout to * a smaller value so we can perform it after a * reasonable amount of idle time. */ tmout.tv_sec = 120; tmout.tv_usec = 0; } else { tmout.tv_sec = 86400; tmout.tv_usec = 0; } #endif select_ret = select(max_fd + 1, &rfds, &wfds, NULL, &tmout); #ifdef _USE_WIN32_ /* * If we've been asked to terminate by a concurrent thread * set our status to LOOP_STOP (not LOOP_DONE) and * terminate the infinite loop. */ if (WorkLoopStatus != LOOP_RUN) { WorkLoopStatus = LOOP_STOP; break; } #endif /* * If select() goes insane, don't get stuck in an endless * loop. */ if (select_ret < 0) { error_count++; continue; } error_count = 0; /* * Time-out section. Handle maintenance taks when there is * idle time. */ if (select_ret == 0) { /* * Perform automatic update if available. */ if (backuppc_updateurl) { curr_time = time(NULL); if (curr_time >= next_update) { backuppc_update(backuppc_updateurl, argc, argv); next_update = curr_time + BPC_UPDATE_INTERVAL; } } /* * If clean-up has been requested, perform it now. */ if (need_cleanup) { prevnode = NULL; curnode = cinfo; while (curnode) { if (curnode->fd == -1) { /* Remove dead sockets from the list. */ if (prevnode) { prevnode->_next = curnode->_next; } else { cinfo = curnode->_next; } /* Perform client de-initialization and maintenance. */ if (curnode->buf_s) { free(curnode->buf_s); } if (curnode->outbuf_s) { free(curnode->outbuf_s); } backuppc_process_client_fini(curnode); #if defined(HAVE_SYSLOG) && defined(DEBUG) syslog(LOG_INFO, "Cleaned connection from %s", inet_ntoa(curnode->addr)); #endif nextnode = curnode->_next; free(curnode); curnode = nextnode; continue; } prevnode = curnode; curnode = curnode->_next; } need_cleanup = 0; } continue; } /* Handle incoming connections first. */ if (FD_ISSET(master_fd, &rfds)) { client_addr_len = sizeof(client_addr); client_fd = accept(master_fd, (struct sockaddr *) &client_addr, &client_addr_len); if (client_fd < 0) { continue; } if (!backuppc_verify_addr(ntohl(client_addr.sin_addr.s_addr))) { #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Closing connection from unauthorized client %s", inet_ntoa(client_addr.sin_addr)); #endif net_close(client_fd); continue; } #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Accepted connection from %s", inet_ntoa(client_addr.sin_addr)); #endif if (client_fd > max_fd) { max_fd = client_fd; } #ifdef HAVE_FCNTL /* Make the socket non-blocking, so partial writes can occur. */ sock_flags = fcntl(client_fd, F_GETFL); if (sock_flags <= 0) { sock_flags |= O_NONBLOCK; fcntl(client_fd, F_SETFL, sock_flags); } #endif curnode = malloc(sizeof(*curnode)); if (curnode == NULL) { net_close(client_fd); continue; } /* * Initialize all members for the node to sane values. */ curnode->buf = NULL; curnode->buf_s = NULL; curnode->bufsize = 0; curnode->bufsize_s = 0; curnode->bufused = 0; curnode->outbufsize = BPC_OUTBUF_LEN; curnode->outbuf = malloc(curnode->outbufsize); curnode->outbuf_s = curnode->outbuf; curnode->outbufsize_s = curnode->outbufsize; curnode->outbufused = 0; curnode->outdata_waiting = 0; curnode->tx_error_count = 0; curnode->rx_error_count = 0; curnode->process_handle = NULL; curnode->privs = BPC_PRIV_NONE; curnode->fd = client_fd; curnode->invalid_data = 0; memcpy(&curnode->addr, &client_addr.sin_addr, sizeof(client_addr.sin_addr)); curnode->_next = cinfo; /* * Ask the "process_client" routine to initialize * its "proc_handle" and related members. */ backuppc_process_client_init(curnode); cinfo = curnode; continue; } /* Process data from any connected clients. */ for (curnode = cinfo; curnode; curnode = curnode->_next) { /* * Skip terminated nodes. */ if (curnode->fd < 0) { continue; } /* * If this node has been generating excessive read * or write errors, terminate it. */ if (curnode->tx_error_count > 10 || curnode->rx_error_count > 10) { #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Closing connection from %s for excessive errors.", inet_ntoa(curnode->addr)); #endif net_close(curnode->fd); curnode->fd = -1; need_cleanup = 1; continue; } process_node = 0; if (FD_ISSET(curnode->fd, &wfds)) { /* * if the socket is writable and we have data * to write to it, attempt to do so. */ if (curnode->outbufused > 0 && curnode->outbuf) { send_ret = send(curnode->fd, curnode->outbuf, curnode->outbufused, 0); if (send_ret > 0) { curnode->outbuf += send_ret; curnode->outbufsize -= send_ret; curnode->outbufused -= send_ret; /* Reset error count on successful transmission. */ curnode->tx_error_count = 0; } else { /* Note errors that occur. */ curnode->tx_error_count++; } } else { /* * If the node was checked for * writability and it was, but we have * no data to write to it, we must be * stalled somewhere, for debugging * we will print out a little message */ PRINTERR_D("Socket writable but no data to write. Stalled."); } /* If there is no data in the buffer, but it has been shrunk, enlarge it. */ if (curnode->outbuf != NULL && curnode->outbufsize != curnode->outbufsize_s && curnode->outbufused ==0) { curnode->outbuf = NULL; } /* If the buffer is uninitialized or emptied, give us a clean slate. */ if (curnode->outbuf == NULL) { if (curnode->outbuf_s) { curnode->outbuf = curnode->outbuf_s; curnode->outbufsize = curnode->outbufsize_s; curnode->outbufused = 0; } else { curnode->outbufsize = BPC_OUTBUF_LEN; curnode->outbuf = malloc(curnode->outbufsize); curnode->outbuf_s = curnode->outbuf; curnode->outbufsize_s = curnode->outbufsize; curnode->outbufused = 0; } } } /* * If there is more data to be written for this * socket, continue processing it. */ if (curnode->outdata_waiting) { process_node = 1; } /* * If the socket has data waiting to be read, attempt * to read it. */ if (FD_ISSET(curnode->fd, &rfds)) { /* * If there is no data in the buffer, but it * has been shrunk, prepare it for * enlargement. **/ if (curnode->buf != NULL && curnode->bufsize != curnode->bufsize_s && curnode->bufused == 0) { curnode->buf = NULL; } /* * If the buffer is uninitialized or emptied, * give us a clean slate. */ if (curnode->buf == NULL) { if (curnode->buf_s) { curnode->buf = curnode->buf_s; curnode->bufsize = curnode->bufsize_s; curnode->bufused = 0; } else { curnode->bufsize = BPC_BUF_LEN; curnode->buf = malloc(curnode->bufsize); curnode->buf_s = curnode->buf; curnode->bufsize_s = curnode->bufsize; curnode->bufused = 0; } } /* * If the buffer is entirely used, but has * been shrunk, move the data around to * make more room. */ if (curnode->bufused == curnode->bufsize && curnode->bufsize != curnode->bufsize_s) { memmove(curnode->buf_s, curnode->buf, curnode->bufused); curnode->bufsize = curnode->bufsize_s; curnode->buf = curnode->buf_s; } /* * If there is space in the buffer, read data into it. */ if ((curnode->bufsize - curnode->bufused) > 0) { recv_ret = recv(curnode->fd, curnode->buf + curnode->bufused, curnode->bufsize - curnode->bufused, 0); if (recv_ret == 0) { /* * A zero return code indicates * end of file, free the * descriptor and cleanup. */ #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Closing connection from %s", inet_ntoa(curnode->addr)); #endif net_close(curnode->fd); curnode->fd = -1; need_cleanup = 1; } else if (recv_ret < 0) { /* * If we had an error reading * from the socket, increase * its error count. */ curnode->rx_error_count++; } else { /* * Mark the newly used space * and ask that the node be * processed. */ curnode->bufused += recv_ret; process_node = 1; /* Reset error count on success. */ curnode->rx_error_count = 0; } } else { /* Consider the buffer filling up an error. */ curnode->rx_error_count++; /* * Attempt to process the node to free * up buffer space. */ process_node = 1; } } if (process_node) { /* * If the output buffer is unallocated at this * point something has gone horribly wrong. * Do not attempt to process a client with * no output buffer. */ if (curnode->outbuf == NULL) { curnode->tx_error_count += 100; curnode->rx_error_count += 100; error_count++; continue; } /* * If the output buffer is completely full, do * not attempt to process more information on * this node, since we'll have nowhere to * write results anyway. Print out a debug * message when this happens. */ if (curnode->outbufused == curnode->outbufsize) { PRINTERR_D("Asked to process node with no buffer space available. Stalled."); continue; } /* * Actually process the node. */ backuppc_process_client(curnode); /* * If the processing indicates that the buffer * has invalid data in it, terminate the client * and ask for cleanup. */ if (curnode->invalid_data) { #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Closing connection from %s for sending invalid data.", inet_ntoa(curnode->addr)); #endif net_close(curnode->fd); curnode->fd = -1; need_cleanup = 1; } } } } if (master_fd >= 0) { net_close(master_fd); } #ifdef _USE_WIN32_ backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; backuppcServiceStat.dwWaitHint = 0; SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); #endif WorkLoopStatus = LOOP_DONE; return(EXIT_SUCCESS); } #ifdef _USE_WIN32_ /* * SYNOPSIS: * VOID WINAPI backuppcServiceControl( * DWORD request * ); * * ARGUMENTS: * DWORD request Action that is requested, only SERVICE_CONTROL_STOP * and SERVICE_CONTROL_SHUTDOWN are acceptable. * * RETURN VALUE: * (none) * * NOTES: * This function should be run in the same process as the primary worker * loop (backuppc_loop()). It will set the Win32 service status * when asked to STOP (or SHUTDOWN). It asks the main worker loop to * terminate, which can take up to 10s (10000ms). When it is called and * the worker thread has finished (i.e., set WorkLoopStatus to LOOP_DONE) * it exits as well. * */ VOID WINAPI backuppcServiceControl(DWORD request) { /* We only handle the `STOP' and `SHUTDOWN' requests. */ if (request != SERVICE_CONTROL_STOP && request != SERVICE_CONTROL_SHUTDOWN) { return; } /* Figure out what we're doing. */ switch (WorkLoopStatus) { case LOOP_RUN: case LOOP_STOP: /* If the loop is running, ask it to stop. */ WorkLoopStatus = LOOP_STOP; /* Tell WIn32 that we're going peacfully. */ backuppcServiceStat.dwCurrentState = SERVICE_STOP_PENDING; backuppcServiceStat.dwWaitHint = 10000; SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); break; case LOOP_DONE: /* The loop has finished and we can go away now. */ backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; backuppcServiceStat.dwWaitHint = 0; SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); exit(EXIT_SUCCESS); break; } return; } /* * SYNOPSIS: * void WINAPI backuppcServiceStart( * DWORD argc * LPTSTR *argv * ); * ARGUMENTS: * DWORD argc Number of arguments * LPTSTR *argv Argument data * * RETURN VALUE: * (none) * * NOTES: * This function is called by `StartServiceCtrlDispatcher'. It registers * the service and updates its status information before and after calling * the main worker loop (backuppc_loop()). * */ void WINAPI backuppcServiceStart(DWORD argc, LPTSTR *argv) { backuppcServiceStat.dwServiceType = SERVICE_WIN32; backuppcServiceStat.dwCurrentState = SERVICE_START_PENDING; backuppcServiceStat.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; backuppcServiceStat.dwWin32ExitCode = 0; backuppcServiceStat.dwServiceSpecificExitCode = 0; backuppcServiceStat.dwCheckPoint = 0; backuppcServiceStat.dwWaitHint = 0; backuppcServiceStat_handle = RegisterServiceCtrlHandler(svcName, backuppcServiceControl); if (backuppcServiceStat_handle == (SERVICE_STATUS_HANDLE) 0) { fprintf(stderr, "Could not register service: %i\n", (int) GetLastError()); return; } SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); backuppcServiceStat.dwCurrentState = SERVICE_RUNNING; backuppcServiceStat.dwCheckPoint = 0; backuppcServiceStat.dwWaitHint = 0; SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); backuppc_loop(argc, argv); backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; backuppcServiceStat.dwCheckPoint = 0; backuppcServiceStat.dwWaitHint = 0; SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); return; } #endif /* _USE_WIN32_ */ /* * SYNOPSIS: * static int daemon_init(void); * * ARGUMENTS: * (none) * * RETURN VALUE: * This function returns `DAEMON_RET_FAILURE' or `DAEMON_RET_SUCCESS'. * If it was able to successfully launch as its own set of processes * SUCCESS is returned, otherwise FAILURE is returned. * * NOTES: * This is the primary daemonizing routine. Under win32 it creates a * service (svcName) and sets its initialization function to the * service start function (backuppcServiceStart). * */ static int daemon_init(void) { /* Default return value is failure, indicating that caller should continue on. */ int retval = DAEMON_RET_FAILURE; #ifndef _USE_WIN32_ #ifdef HAVE_FORK FILE *pidfile_fp = NULL; pid_t pid; unlink(SKIPSTARTFILE); close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); #ifdef HAVE_SETSID setsid(); #endif pid = fork(); if (pid > 0) { /* Write the child PID to a file so we can read it to shutdown. */ pidfile_fp = fopen(BACKUPPC_PIDFILE, "w"); if (pidfile_fp != NULL) { fprintf(pidfile_fp, "%li\n", (long) pid); fclose(pidfile_fp); } /* Tell the parent process that we have created children, indicating that it should terminate. */ return(DAEMON_RET_SUCCESS); } if (pid < 0) { /* On a fork error, terminate everyone immediately. */ exit(EXIT_FAILURE); } /* The child returns FAILURE to indicate that it should not terminate, but rather carry on processing. */ retval = DAEMON_RET_FAILURE; #endif #else DWORD win32Error; SERVICE_TABLE_ENTRY serviceTable[] = { {svcName, backuppcServiceStart}, { NULL, NULL} }; if (!StartServiceCtrlDispatcher(serviceTable)) { win32Error = GetLastError(); switch (win32Error) { case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT: /* Print no error here because we're not being run as a service yet. This will happen later. CreateService() will cause a new process to be created where this will succeed. */ break; default: fprintf(stderr, "Could not start service dispatcher: %i\n", (int) win32Error); break; } } else { /* We were able to start the "Control Dispatcher" so we indicate success. This should tell the caller to terminate since we'll be starting our own set of processes. */ retval = DAEMON_RET_SUCCESS; } #endif return(retval); } /* * SYNOPSIS: * static int daemon_stop(void); * * ARGUMENTS: * (none) * * RETURN VALUE: * Upon sucessfully stopping the running daemon, 0 is returned. Otherwise * -1 is returned. * * NOTES: * This function uses the Service Control functions on Win32. * This function uses a pid file (BACKUPPC_PIDFILE) on POSIX platforms. * */ static int daemon_stop(void) { int retval = -1; #ifndef _USE_WIN32_ FILE *pidfile_fp = NULL; char buf[128]; pid_t pid; int killret, unlinkret; pidfile_fp = fopen(BACKUPPC_PIDFILE, "r"); if (pidfile_fp == NULL) { fprintf(stderr, "Service is not running.\n"); return(-1); } fgets(buf, sizeof(buf), pidfile_fp); pid = strtol(buf, NULL, 10); if (pid <= 0) { fprintf(stderr, "Invalid process ID: %li\n", (long) pid); return(-1); } unlinkret = unlink(BACKUPPC_PIDFILE); if (unlinkret < 0) { fprintf(stderr, "Error removing pid file (\"%s\"): ", BACKUPPC_PIDFILE); perror("unlink"); } killret = kill(pid, 1); if (killret < 0) { perror("kill"); return(-1); } #ifdef HAVE_SYSLOG syslog(LOG_INFO, "Terminating running backuppcd (pid = %lu)", (unsigned long) pid); #endif retval = 0; #else /* Open a connection to the SCM if there isn't one already. */ if (manager == NULL) { manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (manager == NULL) { fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); return(-1); } } /* Connect to our service. */ service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); if (service == NULL) { fprintf(stderr, "Could not open service: %i\n", (int) GetLastError()); return(-1); } /* Ask ourselves to stop through the SCM. */ if (!ControlService(service, SERVICE_CONTROL_STOP, &backuppcServiceStat)) { if (GetLastError() != ERROR_SERVICE_NOT_ACTIVE) { fprintf(stderr, "Could not stop service: %i\n", (int) GetLastError()); return(-1); } } fprintf(stderr, "Service stopped.\n"); retval = 0; #endif return(retval); } /* * SYNOPSIS: * static int daemon_remove(void); * * ARGUMENTS: * (none) * * RETURN VALUE: * Upon sucessfully removing the (possibly running) daemon from startup, 0 * is returned. Otherwise -1 is returned. * * NOTES: * On win32 this does the services thing. * * Otherwise, it cooperates with the supplied "backuppc.init" script to * manage the SKIPSTARTFILE. If this file exists, the "backuppc.init" * script's start action aborts. backuppcd deletes the file upon sucessful * startup. This function creates the file and stops the running daemon. * */ static int daemon_remove(void) { int retval = -1; int stop_ret; stop_ret = daemon_stop(); if (stop_ret < 0) { retval = -1; } #ifndef _USE_WIN32_ creat(SKIPSTARTFILE, 0600); retval = 0; #else if (manager == NULL) { manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (manager == NULL) { fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); return(-1); } } service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); if (service == NULL) { fprintf(stderr, "Could not open service: %i\n", (int) GetLastError()); return(-1); } if (!DeleteService(service)) { fprintf(stderr, "Could not delete service: %i\n", (int) GetLastError()); return(-1); } fprintf(stderr, "Service deleted.\n"); retval = 0; #endif return(retval); } /* * SYNOPSIS: * static void daemon_start( * int argc, * char **argv * ); * * ARGUMENTS: * int argc Number of arguments * char *argv Argument data * * RETURN VALUE: * (none) * * NOTES: * */ static void daemon_start(int argc, char **argv) { #ifdef _USE_WIN32_ /* Create a Win32 Service. */ /* Most of this was taken from "tinc" (src/process.c) */ #ifdef NO_WIN32_NT4 /* Windows NT 4.0 lacks the `ChangeServiceConfig2' call. */ SERVICE_DESCRIPTION description = {"BackupPC Client Daemon"}; #endif char svcCommand[8192], *svcptr; int argind; /* * This whole mess is to construct the "lpBinaryPathName" which needs * quotes and all kinds of other non-sense. */ svcptr = svcCommand; strcpy(svcptr, "\""); svcptr += strlen(svcptr); /* This is not the same as svcptr++. */ /* If the full path wasn't specified, assume it's in the current directory. */ if (strchr(argv[0], '\\') == NULL) { GetCurrentDirectory(sizeof(svcCommand) - (svcptr - svcCommand) - 1, svcptr); svcptr += strlen(svcptr); strncat(svcptr, "\\", sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); } strncat(svcptr, argv[0], sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); strncat(svcptr, "\"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); for (argind = 1; argind < argc; argind++) { strncat(svcptr, " \"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); strncat(svcptr, argv[argind], sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); strncat(svcptr, "\"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); svcptr += strlen(svcptr); } manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (manager == NULL) { fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); exit(EXIT_FAILURE); } /* * This will ultimately spawn another set of processes so we may exit. */ service = CreateService(manager, svcName, svcName, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, svcCommand, "NDIS", NULL, NULL, NULL, NULL); if (service == NULL) { if (GetLastError() == ERROR_SERVICE_EXISTS) { service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); } if (service == NULL) { fprintf(stderr, "Could not create service: %i\n", (int) GetLastError()); exit(EXIT_FAILURE); } } #ifdef NO_WIN32_NT4 /* Windows NT 4.0 lacks this call. */ ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &description); #endif if (!StartService(service, 0, NULL)) { fprintf(stderr, "Could not start service: %i\n", (int) GetLastError()); exit(EXIT_FAILURE); } else { printf("Service started.\n"); } exit(EXIT_SUCCESS); #endif return; } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ); * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_opt_remove_svc(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { if (daemon_remove() < 0) { exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ static int backuppc_opt_stop_svc(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { if (daemon_stop() < 0) { exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); } static int backuppc_opt_showvers(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { printf("%s\n", PACKAGE_VERSION); exit(EXIT_SUCCESS); } static int backuppc_opt_prio(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { char *prio_names[3] = {"min", "max", "normal"}; int prio_vals[3] = {BPC_PRIO_MIN, BPC_PRIO_MAX, BPC_PRIO_NORM}; int prio_val = -1; int i; if (!value) { return(LC_CBRET_ERROR); } if (strlen(value) > 0) { for (i = 0; i < (sizeof(prio_names) / sizeof(*prio_names)); i++) { if (strncasecmp(prio_names[i], value, strlen(value)) == 0) { if (prio_val == -1) { prio_val = prio_vals[i]; } else { fprintf(stderr, "Ambigious priority name: %s, should be Min, Max, or Normal.\n", value); return(LC_CBRET_ERROR); } } } } if (prio_val == -1) { fprintf(stderr, "Invalid priority name: %s, should be Min, Max, or Normal.\n", value); return(LC_CBRET_ERROR); } backuppc_setpriority(prio_val); return(LC_CBRET_OKAY); } /* * SYNOPSIS: * static void backuppc_pathmangle( * char *pathname * ) * * ARGUMENTS: * char *pathname Pathname to mangle. * * RETURN VALUE: * (none) * * NOTES: * */ int main(int argc, char *argv[]) { int lc_p_ret = 0; char *update_source = NULL, *update_dest = NULL, *update_delefile = NULL; char *config_file = NULL; int do_switch = 0; /* * Initialize the authentication subsystem. * * It will add its own set of options to the configuration processor */ bpcd_auth_init(); /* * Register configuration commands and command line arguments. */ lc_register_callback("Remove", 'r', LC_VAR_NONE, backuppc_opt_remove_svc, NULL); lc_register_callback("Stop", 'k', LC_VAR_NONE, backuppc_opt_stop_svc, NULL); lc_register_callback("Version", 'V', LC_VAR_NONE, backuppc_opt_showvers, NULL); lc_register_callback("Priority", 'P', LC_VAR_STRING, backuppc_opt_prio, NULL); lc_register_var("Port", LC_VAR_INT, &backuppc_port, 'p'); lc_register_var("UpdateURL", LC_VAR_STRING, &backuppc_updateurl, 'U'); lc_register_var("Source", LC_VAR_STRING, &update_source, 0); lc_register_var("Destination", LC_VAR_STRING, &update_dest, 0); lc_register_var("Switch", LC_VAR_BOOL_BY_EXISTANCE, &do_switch, 0); lc_register_var("DeleteFile", LC_VAR_STRING, &update_delefile, 0); lc_register_var("BinaryFile", LC_VAR_STRING, &backuppc_binfile, 0); lc_register_var("ConfigFile", LC_VAR_STRING, &config_file, 'C'); /* * Process standard config files, command line arguments, and * environment variables. */ lc_p_ret = lc_process(argc, argv, "backuppcd", LC_CONF_SPACE, SYSCONFDIR "/backuppcd.conf"); if (lc_p_ret < 0) { fprintf(stderr, "Error processing configuration information: %s.\n", lc_geterrstr()); return(EXIT_FAILURE); } /* * If an alternative config file is specified above, process it. */ if (config_file) { lc_p_ret = lc_process_file("backuppcd", config_file, LC_CONF_SPACE); if (lc_p_ret < 0) { fprintf(stderr, "Error processing configuration information: %s.\n", lc_geterrstr()); return(EXIT_FAILURE); } } /* * Finished with configuration. */ lc_cleanup(); /* * If we've been told to delete a file, do so without regard for * failure. */ if (update_delefile) { unlink(update_delefile); } /* * Since you can never open a running executable for writing so to * upgrade ourselves we must: * a. Download the new version to some temporary location * b. Call the new version and tell it to replace the old version * with itself (--Switch argument) * c. Call the copy * d. Delete the file from the temporary location */ if (do_switch) { if (update_source == NULL || update_dest == NULL) { fprintf(stderr, "Error: You must provide a --Source and --Destination to use --Switch\n"); return(EXIT_FAILURE); } backuppc_switchupdate(update_source, update_dest, argc, argv); return(EXIT_SUCCESS); } #ifndef _USE_WIN32_ /* * We cannot check for a new version at start-up on Windows because it * really messes with the "Services" stuff. Bummer, man. */ if (backuppc_updateurl) { backuppc_update(backuppc_updateurl, argc, argv); } #endif #ifndef DEBUG /* * If daemon initialization went well, we're no longer needed. */ if (daemon_init() == DAEMON_RET_SUCCESS) { return(EXIT_SUCCESS); } daemon_start(argc, argv); #endif #ifdef HAVE_SIGNAL /* * We don't care about SIGPIPE, we properly handle read errors. */ signal(SIGPIPE, SIG_IGN); #endif /* * This will be replaced with a proper logging mechanism at some point (XXX) */ #ifdef HAVE_OPENLOG openlog("backuppcd", LOG_PID, LOG_DAEMON); #endif /* * Begin primary processing. */ return(backuppc_loop(argc, argv)); }