-/* -*- c-file-style: "linux" -*-
+/*
+ * Utility routines used in rsync.
*
- * Copyright (C) 1996-2000 by Andrew Tridgell
- * Copyright (C) Paul Mackerras 1996
- * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+ * Copyright (C) 1996-2000 Andrew Tridgell
+ * Copyright (C) 1996 Paul Mackerras
+ * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
+ * Copyright (C) 2003-2007 Wayne Davison
*
* 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.
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * 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.,
+ * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
-/**
- * @file
- *
- * Utilities used in rsync
- **/
-
#include "rsync.h"
extern int verbose;
extern int modify_window;
extern int relative_paths;
extern int human_readable;
+extern unsigned int module_dirlen;
+extern mode_t orig_umask;
extern char *partial_dir;
extern struct filter_list_struct server_filter_list;
int sanitize_paths = 0;
+char curr_dir[MAXPATHLEN];
+unsigned int curr_dir_len;
+int curr_dir_depth; /* This is only set for a sanitizing daemon. */
-
-/**
- * Set a fd into nonblocking mode
- **/
+/* Set a fd into nonblocking mode. */
void set_nonblocking(int fd)
{
int val;
- if ((val = fcntl(fd, F_GETFL, 0)) == -1)
+ if ((val = fcntl(fd, F_GETFL)) == -1)
return;
if (!(val & NONBLOCK_FLAG)) {
val |= NONBLOCK_FLAG;
}
}
-/**
- * Set a fd into blocking mode
- **/
+/* Set a fd into blocking mode. */
void set_blocking(int fd)
{
int val;
- if ((val = fcntl(fd, F_GETFL, 0)) == -1)
+ if ((val = fcntl(fd, F_GETFL)) == -1)
return;
if (val & NONBLOCK_FLAG) {
val &= ~NONBLOCK_FLAG;
}
}
-
/**
* Create a file descriptor pair - like pipe() but use socketpair if
* possible (because of blocking issues on pipes).
return ret;
}
-
void print_child_argv(char **cmd)
{
- rprintf(FINFO, "opening connection using ");
+ rprintf(FCLIENT, "opening connection using ");
for (; *cmd; cmd++) {
/* Look for characters that ought to be quoted. This
* is not a great quoting algorithm, but it's
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789"
",.-_=+@/") != strlen(*cmd)) {
- rprintf(FINFO, "\"%s\" ", *cmd);
+ rprintf(FCLIENT, "\"%s\" ", *cmd);
} else {
- rprintf(FINFO, "%s ", *cmd);
+ rprintf(FCLIENT, "%s ", *cmd);
}
}
- rprintf(FINFO, "\n");
+ rprintf(FCLIENT, "\n");
}
-
-void out_of_memory(char *str)
+NORETURN void out_of_memory(const char *str)
{
- rprintf(FERROR, "ERROR: out of memory in %s\n", str);
+ rprintf(FERROR, "ERROR: out of memory in %s [%s]\n", str, who_am_i());
exit_cleanup(RERR_MALLOC);
}
-void overflow_exit(char *str)
+NORETURN void overflow_exit(const char *str)
{
- rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
+ rprintf(FERROR, "ERROR: buffer overflow in %s [%s]\n", str, who_am_i());
exit_cleanup(RERR_MALLOC);
}
-
-
-int set_modtime(char *fname, time_t modtime, mode_t mode)
+int set_modtime(const char *fname, time_t modtime, mode_t mode)
{
#if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
if (S_ISLNK(mode))
t[1].tv_sec = modtime;
t[1].tv_usec = 0;
# ifdef HAVE_LUTIMES
- if (S_ISLNK(mode))
- return lutimes(fname, t);
+ if (S_ISLNK(mode)) {
+ lutimes(fname, t);
+ return 0; /* ignore errors */
+ }
# endif
return utimes(fname, t);
#elif defined HAVE_UTIMBUF
}
}
+/* This creates a new directory with default permissions. Since there
+ * might be some directory-default permissions affecting this, we can't
+ * force the permissions directly using the original umask and mkdir(). */
+int mkdir_defmode(char *fname)
+{
+ int ret;
+
+ umask(orig_umask);
+ ret = do_mkdir(fname, ACCESSPERMS);
+ umask(0);
-/**
- 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, int base_umask)
+ return ret;
+}
+
+/* Create any necessary directories in fname. Any missing directories are
+ * created with default permissions. */
+int create_directory_path(char *fname)
{
char *p;
+ int ret = 0;
while (*fname == '/')
fname++;
while (strncmp(fname, "./", 2) == 0)
fname += 2;
+ umask(orig_umask);
p = fname;
while ((p = strchr(p,'/')) != NULL) {
- *p = 0;
- do_mkdir(fname, 0777 & ~base_umask);
- *p = '/';
- p++;
+ *p = '\0';
+ if (do_mkdir(fname, ACCESSPERMS) < 0 && errno != EEXIST)
+ ret = -1;
+ *p++ = '/';
}
- return 0;
-}
+ umask(0);
+ return ret;
+}
/**
* Write @p len bytes at @p ptr to descriptor @p desc, retrying if
*
* Derived from GNU C's cccp.c.
*/
-int full_write(int desc, char *ptr, size_t len)
+int full_write(int desc, const char *ptr, size_t len)
{
int total_written;
return total_written;
}
-
/**
* Read @p len bytes at @p ptr from descriptor @p desc, retrying if
* interrupted.
return n_chars;
}
-
/** Copy a file.
*
* This is used in conjunction with the --temp-dir, --backup, and
/* start where the last one left off to reduce chance of clashes */
start = counter;
do {
- sprintf(&path[pos], "%03d", counter);
+ snprintf(&path[pos], MAX_RENAMES_DIGITS+1, "%03d", counter);
if (++counter >= MAX_RENAMES)
counter = 1;
} while ((rc = access(path, 0)) == 0 && counter != start);
* across filesystems, -2 if copy_file() failed, and -1 on other errors.
* If partialptr is not NULL and we need to do a copy, copy the file into
* the active partial-dir instead of over the destination file. */
-int robust_rename(char *from, char *to, char *partialptr,
+int robust_rename(const char *from, const char *to, const char *partialptr,
int mode)
{
int tries = 4;
return -1;
}
-
static pid_t all_pids[10];
static int num_pids;
}
}
-
/** Turn a user name into a uid */
-int name_to_uid(char *name, uid_t *uid)
+int name_to_uid(const char *name, uid_t *uid)
{
struct passwd *pass;
if (!name || !*name)
}
/** Turn a group name into a gid */
-int name_to_gid(char *name, gid_t *gid)
+int name_to_gid(const char *name, gid_t *gid)
{
struct group *grp;
if (!name || !*name)
return 0;
}
-
/** Lock a byte range in a open file */
int lock_range(int fd, int offset, int len)
{
s = ".";
if (sanitize_paths)
- s = sanitize_path(NULL, s, "", 0);
+ s = sanitize_path(NULL, s, "", 0, NULL);
else
s = strdup(s);
void strlower(char *s)
{
while (*s) {
- if (isupper(*(unsigned char *)s))
- *s = tolower(*(unsigned char *)s);
+ if (isUpper(s))
+ *s = toLower(s);
s++;
}
}
int cnt = 0, new_component = 1;
while (*p) {
if (*p++ == '/')
- new_component = 1;
+ new_component = (*p != '.' || (p[1] != '/' && p[1] != '\0'));
else if (new_component) {
new_component = 0;
cnt++;
* The rootdir string contains a value to use in place of a leading slash.
* Specify NULL to get the default of lp_path(module_id).
*
- * If depth is >= 0, it is a count of how many '..'s to allow at the start
- * of the path. Use -1 to allow unlimited depth.
+ * The depth var is a count of how many '..'s to allow at the start of the
+ * path. If symlink is set, combine its value with the "p" value to get
+ * the target path, and **return NULL if any '..'s try to escape**.
*
* We also clean the path in a manner similar to clean_fname() but with a
- * few differences:
+ * few differences:
*
* Turns multiple adjacent slashes into a single slash, gets rid of "." dir
* elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
* ALWAYS collapses ".." elements (except for those at the start of the
* string up to "depth" deep). If the resulting name would be empty,
* change it into a ".". */
-char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth)
+char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth,
+ const char *symlink)
{
- char *start, *sanp;
+ char *start, *sanp, *save_dest = dest;
int rlen = 0, leave_one_dotdir = relative_paths;
+ if (symlink && *symlink == '/') {
+ p = symlink;
+ symlink = "";
+ }
+
if (dest != p) {
int plen = strlen(p);
if (*p == '/') {
}
start = sanp = dest + rlen;
- while (*p != '\0') {
+ while (1) {
+ if (*p == '\0') {
+ if (!symlink || !*symlink)
+ break;
+ while (sanp != start && sanp[-1] != '/') {
+ /* strip last element */
+ sanp--;
+ }
+ /* Append a relative symlink */
+ p = symlink;
+ symlink = "";
+ }
/* discard leading or extra slashes */
if (*p == '/') {
p++;
if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
/* ".." component followed by slash or end */
if (depth <= 0 || sanp != start) {
+ if (symlink && sanp == start) {
+ if (!save_dest)
+ free(dest);
+ return NULL;
+ }
p += 2;
if (sanp != start) {
/* back up sanp one level */
return dest;
}
-char curr_dir[MAXPATHLEN];
-unsigned int curr_dir_len;
-
-/**
- * Like chdir(), but it keeps track of the current directory (in the
+/* Like chdir(), but it keeps track of the current directory (in the
* global "curr_dir"), and ensures that the path size doesn't overflow.
- * Also cleans the path using the clean_fname() function.
- **/
-int push_dir(char *dir)
+ * Also cleans the path using the clean_fname() function. */
+int push_dir(const char *dir, int set_path_only)
{
static int initialised;
unsigned int len;
if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
return 0;
- if (chdir(dir))
+ if (!set_path_only && chdir(dir))
return 0;
if (*dir == '/') {
}
curr_dir_len = clean_fname(curr_dir, 1);
+ if (sanitize_paths) {
+ if (module_dirlen > curr_dir_len)
+ module_dirlen = curr_dir_len;
+ curr_dir_depth = count_dir_elements(curr_dir + module_dirlen);
+ }
return 1;
}
* Reverse a push_dir() call. You must pass in an absolute path
* that was copied from a prior value of "curr_dir".
**/
-int pop_dir(char *dir)
+int pop_dir(const char *dir)
{
if (chdir(dir))
return 0;
curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
if (curr_dir_len >= sizeof curr_dir)
curr_dir_len = sizeof curr_dir - 1;
+ if (sanitize_paths)
+ curr_dir_depth = count_dir_elements(curr_dir + module_dirlen);
return 1;
}
if (*fn == '/')
p1 = p2 = "";
else {
- p1 = curr_dir;
+ p1 = curr_dir + module_dirlen;
for (p2 = p1; *p2 == '/'; p2++) {}
if (*p2)
p2 = "/";
m1 = " (in ";
m2 = lp_name(module_id);
m3 = ")";
- if (p1 == curr_dir) {
- if (!lp_use_chroot(module_id)) {
- char *p = lp_path(module_id);
- if (*p != '/' || p[1])
- p1 += strlen(p);
- }
- }
} else
m1 = m2 = m3 = "";
- asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
+ if (asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3) <= 0)
+ out_of_memory("full_fname");
return result;
}
if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
return NULL;
if (server_filter_list.head) {
- static int len;
- if (!len)
- len = strlen(partial_dir);
- t[len] = '\0';
+ t = strrchr(partial_fname, '/');
+ *t = '\0';
if (check_filter(&server_filter_list, partial_fname, 1) < 0)
return NULL;
- t[len] = '/';
+ *t = '/';
if (check_filter(&server_filter_list, partial_fname, 0) < 0)
return NULL;
}
if (human_readable) {
char units = '\0';
- int mult = human_readable == 1 ? 1024 : 1000;
+ int mult = human_readable == 1 ? 1000 : 1024;
double dnum = 0;
if (num > mult*mult*mult) {
dnum = (double)num / (mult*mult*mult);
units = 'K';
}
if (units) {
- sprintf(bufs[n], "%.2f%c", dnum, units);
+ snprintf(bufs[n], sizeof bufs[0], "%.2f%c", dnum, units);
return bufs[n];
}
}
if (!num)
*--s = '0';
while (num) {
- *--s = (num % 10) + '0';
+ *--s = (char)(num % 10) + '0';
num /= 10;
}
return s;
{
char *buf = human_num(dnum);
int len = strlen(buf);
- if (isdigit(*(uchar*)(buf+len-1))) {
+ if (isDigit(buf + len - 1)) {
/* There's extra room in buf prior to the start of the num. */
buf -= decimal_digits + 1;
snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
return buf;
}
-/**
- * Return the date and time as a string
- **/
+/* Return the date and time as a string. Some callers tweak returned buf. */
char *timestring(time_t t)
{
static char TimeBuf[200];
struct tm *tm = localtime(&t);
+ char *p;
#ifdef HAVE_STRFTIME
strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
#endif
- if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
- TimeBuf[strlen(TimeBuf)-1] = 0;
- }
+ if ((p = strchr(TimeBuf, '\n')) != NULL)
+ *p = '\0';
- return(TimeBuf);
+ return TimeBuf;
}
-
/**
* Sleep for a specified number of milliseconds.
*
return True;
}
-
-/**
- * Determine if two file modification times are equivalent (either
- * exact or in the modification timestamp window established by
- * --modify-window).
+/* Determine if two time_t values are equivalent (either exact, or in
+ * the modification timestamp window established by --modify-window).
*
* @retval 0 if the times should be treated as the same
*
*
* @retval -1 if the 2nd is later
**/
-int cmp_modtime(time_t file1, time_t file2)
+int cmp_time(time_t file1, time_t file2)
{
if (file2 > file1) {
if (file2 - file1 <= modify_window)
}
#endif
-
#define MALLOC_MAX 0x40000000
void *_new_array(unsigned int size, unsigned long num)
{
if (num >= MALLOC_MAX/size)
return NULL;
- /* No realloc should need this, but just in case... */
if (!ptr)
return malloc(size * num);
return realloc(ptr, size * num);
if (strcmp(s+1, "orig") == 0)
continue;
} else if (s_len > 2 && had_tilde
- && s[1] == '~' && isdigit(*(uchar*)(s+2)))
+ && s[1] == '~' && isDigit(s + 2))
continue;
*len_ptr = s_len;
suf = s;
break;
/* Determine if the suffix is all digits. */
for (s++, s_len--; s_len > 0; s++, s_len--) {
- if (!isdigit(*(uchar*)s))
+ if (!isDigit(s))
return suf;
}
/* An all-digit suffix may not be that signficant. */
return a[len2-1];
}
+
+#define BB_SLOT_SIZE (16*1024) /* Desired size in bytes */
+#define BB_PER_SLOT_BITS (BB_SLOT_SIZE * 8) /* Number of bits per slot */
+#define BB_PER_SLOT_INTS (BB_SLOT_SIZE / 4) /* Number of int32s per slot */
+
+struct bitbag {
+ uint32 **bits;
+ int slot_cnt;
+};
+
+struct bitbag *bitbag_create(int max_ndx)
+{
+ struct bitbag *bb = new(struct bitbag);
+ bb->slot_cnt = (max_ndx + BB_PER_SLOT_BITS - 1) / BB_PER_SLOT_BITS;
+
+ if (!(bb->bits = (uint32**)calloc(bb->slot_cnt, sizeof (uint32*))))
+ out_of_memory("bitbag_create");
+
+ return bb;
+}
+
+void bitbag_set_bit(struct bitbag *bb, int ndx)
+{
+ int slot = ndx / BB_PER_SLOT_BITS;
+ ndx %= BB_PER_SLOT_BITS;
+
+ if (!bb->bits[slot]) {
+ if (!(bb->bits[slot] = (uint32*)calloc(BB_PER_SLOT_INTS, 4)))
+ out_of_memory("bitbag_set_bit");
+ }
+
+ bb->bits[slot][ndx/32] |= 1u << (ndx % 32);
+}
+
+#if 0 /* not needed yet */
+void bitbag_clear_bit(struct bitbag *bb, int ndx)
+{
+ int slot = ndx / BB_PER_SLOT_BITS;
+ ndx %= BB_PER_SLOT_BITS;
+
+ if (!bb->bits[slot])
+ return;
+
+ bb->bits[slot][ndx/32] &= ~(1u << (ndx % 32));
+}
+
+int bitbag_check_bit(struct bitbag *bb, int ndx)
+{
+ int slot = ndx / BB_PER_SLOT_BITS;
+ ndx %= BB_PER_SLOT_BITS;
+
+ if (!bb->bits[slot])
+ return 0;
+
+ return bb->bits[slot][ndx/32] & (1u << (ndx % 32)) ? 1 : 0;
+}
+#endif
+
+/* Call this with -1 to start checking from 0. Returns -1 at the end. */
+int bitbag_next_bit(struct bitbag *bb, int after)
+{
+ uint32 bits, mask;
+ int i, ndx = after + 1;
+ int slot = ndx / BB_PER_SLOT_BITS;
+ ndx %= BB_PER_SLOT_BITS;
+
+ mask = (1u << (ndx % 32)) - 1;
+ for (i = ndx / 32; slot < bb->slot_cnt; slot++, i = mask = 0) {
+ if (!bb->bits[slot])
+ continue;
+ for ( ; i < BB_PER_SLOT_INTS; i++, mask = 0) {
+ if (!(bits = bb->bits[slot][i] & ~mask))
+ continue;
+ /* The xor magic figures out the lowest enabled bit in
+ * bits, and the switch quickly computes log2(bit). */
+ switch (bits ^ (bits & (bits-1))) {
+#define LOG2(n) case 1u << n: return slot*BB_PER_SLOT_BITS + i*32 + n
+ LOG2(0); LOG2(1); LOG2(2); LOG2(3);
+ LOG2(4); LOG2(5); LOG2(6); LOG2(7);
+ LOG2(8); LOG2(9); LOG2(10); LOG2(11);
+ LOG2(12); LOG2(13); LOG2(14); LOG2(15);
+ LOG2(16); LOG2(17); LOG2(18); LOG2(19);
+ LOG2(20); LOG2(21); LOG2(22); LOG2(23);
+ LOG2(24); LOG2(25); LOG2(26); LOG2(27);
+ LOG2(28); LOG2(29); LOG2(30); LOG2(31);
+ }
+ return -1; /* impossible... */
+ }
+ }
+
+ return -1;
+}