extern int modify_window;
extern int relative_paths;
extern int human_readable;
+extern mode_t orig_umask;
extern char *partial_dir;
extern struct filter_list_struct server_filter_list;
}
}
-
/**
* 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(FINFO, "\n");
}
-
void out_of_memory(char *str)
{
rprintf(FERROR, "ERROR: out of memory in %s\n", str);
exit_cleanup(RERR_MALLOC);
}
-
-
int set_modtime(char *fname, time_t modtime, mode_t mode)
{
#if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
}
}
+/* 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;
-/**
- 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)
+ umask(orig_umask);
+ ret = do_mkdir(fname, ACCESSPERMS);
+ umask(0);
+
+ 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
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
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)
{
return 0;
}
-
/** Lock a byte range in a open file */
int lock_range(int fd, int offset, int len)
{
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);
{
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)
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;
+}