preparing for release of 2.0.9

[rsync/rsync.git] / util.c

diff --git a/util.c b/util.c
index 1fdeee6..5b16fc4 100644 (file)
--- a/util.c
+++ b/util.c
@@ -60,44 +60,49 @@ struct map_struct *map_file(int fd,OFF_T len)
 
 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 (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;
 
-  if (offset >= map->p_offset && 
-      offset+len <= map->p_offset+map->p_len) {
-    return (map->p + (offset - map->p_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);
-  if (len > (map->size-offset))
-      len = map->size-offset;
+       len = MAX(len,CHUNK_SIZE);
+       if (len > (map->size-offset))
+               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 (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 (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);
-  }
+       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; 
 }
 
 
@@ -456,6 +461,21 @@ void strlcpy(char *d, char *s, int maxlen)
        d[len] = 0;
 }
 
+/* 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)
 {
@@ -509,6 +529,7 @@ int lock_range(int fd, int offset, int len)
 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;
@@ -516,6 +537,8 @@ static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
        glob_t globbuf;
        int i;
 
+       if (!*s) s = ".";
+
        argv[*argc] = strdup(s);
 
        memset(&globbuf, 0, sizeof(globbuf));
@@ -542,6 +565,10 @@ void glob_expand(char *base, char **argv, int *argc, int maxargs)
 
        if (!s || !*s) return;
 
+       if (strncmp(s, base, strlen(base)) == 0) {
+               s += strlen(base);
+       }
+
        s = strdup(s);
        if (!s) out_of_memory("glob_expand");
 
@@ -551,7 +578,7 @@ void glob_expand(char *base, char **argv, int *argc, int maxargs)
                        /* split it at this point */
                        *(p-1) = 0;
                        glob_expand_one(q, argv, argc, maxargs);
-                       q = p+strlen(base);
+                       q = p+strlen(base)+1;
                } else {
                        q++;
                }
@@ -572,3 +599,68 @@ void strlower(char *s)
                s++;
        }
 }
+
+/* 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)
+{
+#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);
+               }
+       }
+
+       vsprintf(buf, format, ap);
+       ret = strlen(buf);
+       if (ret > n) {
+               /* yikes! */
+               exit_cleanup(1);
+       }
+       buf[ret] = 0;
+       
+       memcpy(str, buf, ret+1);
+
+       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;
+}
+