X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/9486289ce452ab82ca8b3f16fae8c2ef5247a923..2b6b4d539b0aab98b1cbb9d8c639cb12473aae94:/util.c

diff --git a/util.c b/util.c
index 59f94182..f54acd2c 100644
--- a/util.c
+++ b/util.c
@@ -34,81 +34,127 @@ int num_waiting(int fd)
 
 struct map_struct *map_file(int fd,OFF_T len)
 {
-  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);
-	  if (ret->map == (char *)-1) {
-		  ret->map = NULL;
-	  }
-  }
+	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 USE_MMAP
+	len = MIN(len, MAX_MAP_SIZE);
+	ret->map = (char *)do_mmap(NULL,len,PROT_READ,MAP_SHARED,fd,0);
+	if (ret->map == (char *)-1) {
+		ret->map = NULL;
+	} else {
+		ret->p_len = len;
+	}
 #endif
-  return ret;
+	return ret;
 }
 
 
 char *map_ptr(struct map_struct *map,OFF_T offset,int len)
 {
-  int nread = -2;
+	int nread;
 
-  if (map->map)
-    return map->map+offset;
+	if (len == 0) 
+		return NULL;
 
-  if (len == 0) 
-    return NULL;
+	if (len > (map->size-offset))
+		len = map->size-offset;
 
-  if (len > (map->size-offset))
-      len = map->size-offset;
+#ifdef USE_MMAP
+	if (map->map) {
+		if (offset >= map->p_offset && 
+		    offset+len <= map->p_offset+map->p_len) {
+			return (map->map + (offset - map->p_offset));
+		}
+		if (munmap(map->map, map->p_len) != 0) {
+			rprintf(FERROR,"munmap failed : %s\n", strerror(errno));
+			exit_cleanup(1);
+		}
 
-  if (offset >= map->p_offset && 
-      offset+len <= map->p_offset+map->p_len) {
-    return (map->p + (offset - map->p_offset));
-  }
+		/* align the mmap region on a nice boundary back a bit from
+		   where it is asked for to allow for some seeking */
+		if (offset > 2*CHUNK_SIZE) {
+			map->p_offset = offset - 2*CHUNK_SIZE;
+			map->p_offset &= ~((OFF_T)(CHUNK_SIZE-1));
+		} else {
+			map->p_offset = 0;
+		}
+		
+		/* map up to MAX_MAP_SIZE */
+		map->p_len = MAX(len, MAX_MAP_SIZE);
+		map->p_len = MIN(map->p_len, map->size - map->p_offset);
+
+		map->map = (char *)do_mmap(NULL,map->p_len,PROT_READ,
+					   MAP_SHARED,map->fd,map->p_offset);
+
+		if (map->map == (char *)-1) {
+			map->map = NULL;
+			map->p_len = 0;
+			map->p_offset = 0;
+		} else {
+			return (map->map + (offset - map->p_offset));
+		}
+	}
+#endif
 
-  len = MAX(len,CHUNK_SIZE);
-  if (len > (map->size-offset))
-      len = map->size-offset;
+	if (offset >= map->p_offset && 
+	    offset+len <= map->p_offset+map->p_len) {
+		return (map->p + (offset - map->p_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;
-  }
+	len = MAX(len,CHUNK_SIZE);
+	if (len > (map->size-offset))
+		len = map->size-offset;
 
-  if (do_lseek(map->fd,offset,SEEK_SET) != offset ||
-      (nread=read(map->fd,map->p,len)) != len) {
-	  rprintf(FERROR,"EOF in map_ptr! (offset=%d len=%d nread=%d errno=%d)\n",
-		  (int)offset, len, nread, errno);
-	  exit_cleanup(1);
-  }
+	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;
+	}
+
+	map->p_offset = offset;
+	map->p_len = len;
 
-  map->p_offset = offset;
-  map->p_len = len;
+	if (do_lseek(map->fd,offset,SEEK_SET) != offset) {
+		rprintf(FERROR,"lseek failed in map_ptr\n");
+		exit_cleanup(1);
+	}
 
-  return map->p; 
+	if ((nread=read(map->fd,map->p,len)) != len) {		
+		if (nread < 0) nread = 0;
+		/* the best we can do is zero the buffer - the file
+                   has changed mid transfer! */
+		memset(map->p+nread, 0, len - nread);
+	}
+  
+	return map->p; 
 }
 
 
 void unmap_file(struct map_struct *map)
 {
-#ifdef HAVE_MMAP
-  if (map->map)
-    munmap(map->map,map->size);
+#ifdef USE_MMAP
+	if (map->map) {
+		munmap(map->map,map->p_len);
+		map->map = NULL;
+	}
 #endif
-  if (map->p) free(map->p);
-  free(map);
+	if (map->p) {
+		free(map->p);
+		map->p = NULL;
+	}
+	memset(map, 0, sizeof(*map));
+	free(map);
 }
 
 
@@ -446,58 +492,219 @@ void kill_all(int sig)
 	}
 }
 
-/* this is the rsync debugging function. Call it with FINFO or FERROR */
-void rprintf(int fd, const char *format, ...)
+/* like strncpy but does not 0 fill the buffer and always null 
+   terminates (thus it can use maxlen+1 space in d) */
+void strlcpy(char *d, char *s, int maxlen)
 {
-	va_list ap;  
-	char buf[1024];
-	int len;
-	FILE *f=NULL;
+	int len = strlen(s);
+	if (len > maxlen) len = maxlen;
+	memcpy(d, s, len);
+	d[len] = 0;
+}
 
-	va_start(ap, format);
+/* like strncat but does not 0 fill the buffer and always null 
+   terminates (thus it can use maxlen+1 space in d) */
+void strlcat(char *d, char *s, int maxlen)
+{
+	int len1 = strlen(d);
+	int len2 = strlen(s);
+	if (len1+len2 > maxlen) {
+		len2 = maxlen-len1;
+	}
+	if (len2 > 0) {
+		memcpy(d+len1, s, len2);
+		d[len1+len2] = 0;
+	}
+}
+
+/* turn a user name into a uid */
+int name_to_uid(char *name, uid_t *uid)
+{
+	struct passwd *pass;
+	if (!name || !*name) return 0;
+	pass = getpwnam(name);
+	if (pass) {
+		*uid = pass->pw_uid;
+		return 1;
+	}
+	return 0;
+}
+
+/* turn a group name into a gid */
+int name_to_gid(char *name, gid_t *gid)
+{
+	struct group *grp;
+	if (!name || !*name) return 0;
+	grp = getgrnam(name);
+	if (grp) {
+		*gid = grp->gr_gid;
+		return 1;
+	}
+	return 0;
+}
+
+
+/****************************************************************************
+check if a process exists. 
+****************************************************************************/
+int process_exists(int pid)
+{
+	return(kill(pid,0) == 0 || errno != ESRCH);
+}
+
+/* lock a byte range in a open file */
+int lock_range(int fd, int offset, int len)
+{
+	struct flock lock;
 
-#if HAVE_VSNPRINTF
-	len = vsnprintf(buf, sizeof(buf)-1, format, ap);
+	lock.l_type = F_WRLCK;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = offset;
+	lock.l_len = len;
+	lock.l_pid = 0;
+	
+	return fcntl(fd,F_SETLK,&lock) == 0;
+}
+
+
+static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
+{
+#ifndef HAVE_GLOB
+	if (!*s) s = ".";
+	argv[*argc] = strdup(s);
+	(*argc)++;
+	return;
 #else
-	len = vsprintf(buf, format, ap);
+	glob_t globbuf;
+	int i;
+
+	if (!*s) s = ".";
+
+	argv[*argc] = strdup(s);
+
+	memset(&globbuf, 0, sizeof(globbuf));
+	glob(argv[*argc], 0, NULL, &globbuf);
+	if (globbuf.gl_pathc == 0) {
+		(*argc)++;
+		globfree(&globbuf);
+		return;
+	}
+	for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
+		if (i == 0) free(argv[*argc]);
+		argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
+		if (!argv[(*argc) + i]) out_of_memory("glob_expand");
+	}
+	globfree(&globbuf);
+	(*argc) += i;
 #endif
-	va_end(ap);
+}
 
-	if (len < 0) exit_cleanup(1);
+void glob_expand(char *base1, char **argv, int *argc, int maxargs)
+{
+	char *s = argv[*argc];
+	char *p, *q;
+	char *base = base1;
 
-	if (fd == FERROR) {
-		f = stderr;
-	} 
+	if (!s || !*s) return;
 
-	if (fd == FINFO) {
-		extern int am_server;
-		if (am_server) 
-			f = stderr;
-		else
-			f = stdout;
-	} 
+	if (strncmp(s, base, strlen(base)) == 0) {
+		s += strlen(base);
+	}
+
+	s = strdup(s);
+	if (!s) out_of_memory("glob_expand");
+
+	base = (char *)malloc(strlen(base1)+3);
+	if (!base) out_of_memory("glob_expand");
+
+	sprintf(base," %s/", base1);
+
+	q = s;
+	while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
+		/* split it at this point */
+		*p = 0;
+		glob_expand_one(q, argv, argc, maxargs);
+		q = p+strlen(base);
+	}
+
+	if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
 
-	if (!f) exit_cleanup(1);
+	free(s);
+	free(base);
+}
 
-	if (fwrite(buf, len, 1, f) != 1) exit_cleanup(1);
+/*******************************************************************
+  convert a string to lower case
+********************************************************************/
+void strlower(char *s)
+{
+	while (*s) {
+		if (isupper(*s)) *s = tolower(*s);
+		s++;
+	}
 }
 
-void rflush(int fd)
+/* this is like vsnprintf but the 'n' limit does not include
+   the terminating null. So if you have a 1024 byte buffer then
+   pass 1023 for n */
+int vslprintf(char *str, int n, const char *format, va_list ap)
 {
-	FILE *f = NULL;
+#ifdef HAVE_VSNPRINTF
+	int ret = vsnprintf(str, n, format, ap);
+	if (ret > n || ret < 0) {
+		str[n] = 0;
+		return -1;
+	}
+	str[ret] = 0;
+	return ret;
+#else
+	static char *buf;
+	static int len=MAXPATHLEN*8;
+	int ret;
+
+	/* this code is NOT a proper vsnprintf() implementation. It
+	   relies on the fact that all calls to slprintf() in rsync
+	   pass strings which have already been checked to be less
+	   than MAXPATHLEN in length and never more than 2 strings are
+	   concatenated. This means the above buffer is absolutely
+	   ample and can never be overflowed.
+
+	   In the future we would like to replace this with a proper
+	   vsnprintf() implementation but right now we need a solution
+	   that is secure and portable. This is it.  */
+
+	if (!buf) {
+		buf = malloc(len);
+		if (!buf) {
+			/* can't call debug or we would recurse */
+			exit_cleanup(1);
+		}
+	}
 
-	if (fd == FERROR) {
-		f = stderr;
-	} 
+	vsprintf(buf, format, ap);
+	ret = strlen(buf);
+	if (ret > n) {
+		/* yikes! */
+		exit_cleanup(1);
+	}
+	buf[ret] = 0;
+	
+	memcpy(str, buf, ret+1);
 
-	if (fd == FINFO) {
-		extern int am_server;
-		if (am_server) 
-			f = stderr;
-		else
-			f = stdout;
-	} 
-
-	if (!f) exit_cleanup(1);
-	fflush(f);
+	return ret;
+#endif
 }
+
+
+/* like snprintf but always null terminates */
+int slprintf(char *str, int n, char *format, ...)
+{
+	va_list ap;  
+	int ret;
+
+	va_start(ap, format);
+	ret = vslprintf(str,n,format,ap);
+	va_end(ap);
+	return ret;
+}
+