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;
}
}
}
-/* 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;
+}
+
+/* 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;
+
+ 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;
+}
- va_start(ap, format);
-#if HAVE_VSNPRINTF
- len = vsnprintf(buf, sizeof(buf)-1, format, ap);
+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);
+}
+
+void glob_expand(char *base, char **argv, int *argc, int maxargs)
+{
+ char *s = argv[*argc];
+ char *p, *q;
- if (len < 0) exit_cleanup(1);
+ if (!s || !*s) return;
- if (fd == FERROR) {
- f = stderr;
- }
+ if (strncmp(s, base, strlen(base)) == 0) {
+ s += strlen(base);
+ }
- if (fd == FINFO) {
- extern int am_server;
- if (am_server)
- f = stderr;
- else
- f = stdout;
- }
+ s = strdup(s);
+ if (!s) out_of_memory("glob_expand");
+
+ q = s;
+ while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
+ if (p != q && *(p-1) == ' ' && p[strlen(base)] == '/') {
+ /* split it at this point */
+ *(p-1) = 0;
+ glob_expand_one(q, argv, argc, maxargs);
+ q = p+strlen(base)+1;
+ } else {
+ q++;
+ }
+ }
- if (!f) exit_cleanup(1);
+ if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
- if (fwrite(buf, len, 1, f) != 1) exit_cleanup(1);
+ free(s);
}
-void rflush(int fd)
+/*******************************************************************
+ convert a string to lower case
+********************************************************************/
+void strlower(char *s)
{
- FILE *f = NULL;
+ while (*s) {
+ if (isupper(*s)) *s = tolower(*s);
+ s++;
+ }
+}
- if (fd == FERROR) {
- f = stderr;
- }
+/* 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);
+ }
+ }
- if (fd == FINFO) {
- extern int am_server;
- if (am_server)
- f = stderr;
- else
- f = stdout;
- }
-
- if (!f) exit_cleanup(1);
- fflush(f);
+ 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;
+}
+
Matt McCutchen's Web Site / rsync / rsync.git / blobdiff