X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/720b47f2611d277684b2ec35d11dc3feedb207fe..a76a0039fc6f02f88dd1aba866c03ceefa7fafec:/util.c diff --git a/util.c b/util.c index df60d0a0..6537717d 100644 --- a/util.c +++ b/util.c @@ -31,16 +31,77 @@ int num_waiting(int fd) return(len); } -char *map_file(int fd,off_t len) + +struct map_struct *map_file(int fd,off_t len) { - char *ret = (char *)mmap(NULL,len,PROT_READ,MAP_SHARED,fd,0); + struct map_struct *ret; + ret = (struct map_struct *)malloc(sizeof(*ret)); + if (!ret) out_of_memory("map_file"); + + ret->map = NULL; + ret->fd = fd; + ret->size = len; + ret->p = NULL; + ret->p_size = 0; + ret->p_offset = 0; + ret->p_len = 0; + +#ifdef HAVE_MMAP + if (len < MAX_MAP_SIZE) + ret->map = (char *)mmap(NULL,len,PROT_READ,MAP_SHARED,fd,0); +#endif return ret; } -void unmap_file(char *buf,off_t len) +char *map_ptr(struct map_struct *map,off_t offset,int len) { - if (len > 0 && buf) - munmap(buf,len); + int nread = -2; + + if (map->map) + return map->map+offset; + + if (len == 0) + return NULL; + + len = MIN(len,map->size-offset); + + if (offset >= map->p_offset && + offset+len <= map->p_offset+map->p_len) { + return (map->p + (offset - map->p_offset)); + } + + len = MAX(len,CHUNK_SIZE); + len = MIN(len,map->size - offset); + + if (len > map->p_size) { + if (map->p) free(map->p); + map->p = (char *)malloc(len); + if (!map->p) out_of_memory("map_ptr"); + map->p_size = len; + } + + if (lseek(map->fd,offset,SEEK_SET) != offset || + (nread=read(map->fd,map->p,len)) != len) { + fprintf(FERROR,"EOF in map_ptr! (offset=%d len=%d nread=%d errno=%d)\n", + (int)offset, len, nread, errno); + exit_cleanup(1); + } + + map->p_offset = offset; + map->p_len = len; + + return map->p; +} + + +void unmap_file(struct map_struct *map) +{ +#ifdef HAVE_MMAP + if (map->map) + munmap(map->map,map->size); +#endif + if (map->p) free(map->p); + free(map); } @@ -53,36 +114,40 @@ int piped_child(char **command,int *f_in,int *f_out) if (pipe(to_child_pipe) < 0 || pipe(from_child_pipe) < 0) { - fprintf(stderr,"pipe: %s\n",strerror(errno)); - exit(1); + fprintf(FERROR,"pipe: %s\n",strerror(errno)); + exit_cleanup(1); } - pid = fork(); + pid = do_fork(); if (pid < 0) { - fprintf(stderr,"fork: %s\n",strerror(errno)); - exit(1); + fprintf(FERROR,"fork: %s\n",strerror(errno)); + exit_cleanup(1); } if (pid == 0) { + extern int orig_umask; if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 || close(to_child_pipe[1]) < 0 || close(from_child_pipe[0]) < 0 || dup2(from_child_pipe[1], STDOUT_FILENO) < 0) { - fprintf(stderr,"Failed to dup/close : %s\n",strerror(errno)); - exit(1); + fprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno)); + exit_cleanup(1); } + if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]); + if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]); + umask(orig_umask); execvp(command[0], command); - fprintf(stderr,"Failed to exec %s : %s\n", + fprintf(FERROR,"Failed to exec %s : %s\n", command[0],strerror(errno)); - exit(1); + exit_cleanup(1); } if (close(from_child_pipe[1]) < 0 || close(to_child_pipe[0]) < 0) { - fprintf(stderr,"Failed to close : %s\n",strerror(errno)); - exit(1); + fprintf(FERROR,"Failed to close : %s\n",strerror(errno)); + exit_cleanup(1); } *f_in = from_child_pipe[0]; @@ -94,26 +159,15 @@ int piped_child(char **command,int *f_in,int *f_out) void out_of_memory(char *str) { - fprintf(stderr,"out of memory in %s\n",str); - exit(1); + fprintf(FERROR,"out of memory in %s\n",str); + exit_cleanup(1); } -#ifndef HAVE_STRDUP - char *strdup(char *s) -{ - int l = strlen(s) + 1; - char *ret = (char *)malloc(l); - if (ret) - strcpy(ret,s); - return ret; -} -#endif - int set_modtime(char *fname,time_t modtime) { -#ifdef HAVE_UTIME_H +#ifdef HAVE_UTIMBUF struct utimbuf tbuf; tbuf.actime = time(NULL); tbuf.modtime = modtime; @@ -163,3 +217,163 @@ int set_blocking(int fd, int set) return fcntl( fd, F_SETFL, val); #undef FLAG_TO_SET } + +/**************************************************************************** +create any necessary directories in fname. Unfortunately we don't know +what perms to give the directory when this is called so we need to rely +on the umask +****************************************************************************/ +int create_directory_path(char *fname) +{ + extern int orig_umask; + char *p; + + while (*fname == '/') fname++; + while (strncmp(fname,"./",2)==0) fname += 2; + + p = fname; + while ((p=strchr(p,'/'))) { + *p = 0; + mkdir(fname,0777 & ~orig_umask); + *p = '/'; + p++; + } + return 0; +} + + +/* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted. + Return LEN upon success, write's (negative) error code otherwise. + + derived from GNU C's cccp.c. +*/ +int full_write(int desc, char *ptr, int len) +{ + int total_written; + + total_written = 0; + while (len > 0) { + int written = write (desc, ptr, len); + if (written < 0) { +#ifdef EINTR + if (errno == EINTR) + continue; +#endif + return written; + } + total_written += written; + ptr += written; + len -= written; + } + return total_written; +} + +/* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted. + Return the actual number of bytes read, zero for EOF, or negative + for an error. + + derived from GNU C's cccp.c. */ +int safe_read(int desc, char *ptr, int len) +{ + int n_chars; + + if (len <= 0) + return len; + +#ifdef EINTR + do { + n_chars = read(desc, ptr, len); + } while (n_chars < 0 && errno == EINTR); +#else + n_chars = read(desc, ptr, len); +#endif + + return n_chars; +} + + +/* copy a file - this is used in conjunction with the --temp-dir option */ +int copy_file(char *source, char *dest, mode_t mode) +{ + int ifd; + int ofd; + char buf[1024 * 8]; + int len; /* Number of bytes read into `buf'. */ + + ifd = open(source, O_RDONLY); + if (ifd == -1) { + fprintf(FERROR,"open %s: %s\n", + source,strerror(errno)); + return -1; + } + + if (unlink(dest) && errno != ENOENT) { + fprintf(FERROR,"unlink %s: %s\n", + dest,strerror(errno)); + return -1; + } + + ofd = open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode); + if (ofd < 0) { + fprintf(FERROR,"open %s: %s\n", + dest,strerror(errno)); + close(ifd); + return -1; + } + + while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) { + if (full_write(ofd, buf, len) < 0) { + fprintf(FERROR,"write %s: %s\n", + dest,strerror(errno)); + close(ifd); + close(ofd); + return -1; + } + } + + close(ifd); + close(ofd); + + if (len < 0) { + fprintf(FERROR,"read %s: %s\n", + source,strerror(errno)); + return -1; + } + + return 0; +} + +/* sleep for a while via select */ +void u_sleep(int usec) +{ + struct timeval tv; + + tv.tv_sec = 0; + tv.tv_usec = usec; + select(0, NULL, NULL, NULL, &tv); +} + + +static pid_t all_pids[10]; +static int num_pids; + +/* fork and record the pid of the child */ +pid_t do_fork(void) +{ + pid_t newpid = fork(); + + if (newpid) { + all_pids[num_pids++] = newpid; + } + return newpid; +} + +/* kill all children */ +void kill_all(int sig) +{ + int i; + for (i=0;i