#include "rsync.h"

#include "ifuncs.h"

#include "itypes.h"

#include "inums.h"

extern int module_id;

extern int modify_window;

extern int relative_paths;

extern int preserve_times;

extern int preserve_xattrs;

extern char *module_dir;

extern unsigned int module_dirlen;

extern char *partial_dir;

extern filter_rule_list daemon_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. */

void set_nonblocking(int fd)

{

int val;

if ((val = fcntl(fd, F_GETFL)) == -1)

return;

if (!(val & NONBLOCK_FLAG)) {

val |= NONBLOCK_FLAG;

fcntl(fd, F_SETFL, val);

}

}

void set_blocking(int fd)

{

int val;

if ((val = fcntl(fd, F_GETFL)) == -1)

return;

if (val & NONBLOCK_FLAG) {

val &= ~NONBLOCK_FLAG;

fcntl(fd, F_SETFL, val);

}

}

int fd_pair(int fd[2])

{

int ret;

#ifdef HAVE_SOCKETPAIR

ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);

ret = pipe(fd);

if (ret == 0) {

set_nonblocking(fd[0]);

set_nonblocking(fd[1]);

}

return ret;

}

void print_child_argv(const char *prefix, char **cmd)

{

rprintf(FCLIENT, "%s ", prefix);

for (; *cmd; cmd++) {

/* Look for characters that ought to be quoted. This

if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"

"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

"0123456789"

",.-_=+@/") != strlen(*cmd)) {

rprintf(FCLIENT, "\"%s\" ", *cmd);

} else {

rprintf(FCLIENT, "%s ", *cmd);

}

}

rprintf(FCLIENT, "\n");

}

NORETURN void out_of_memory(const char *str)

{

rprintf(FERROR, "ERROR: out of memory in %s [%s]\n", str, who_am_i());

exit_cleanup(RERR_MALLOC);

}

NORETURN void overflow_exit(const char *str)

{

rprintf(FERROR, "ERROR: buffer overflow in %s [%s]\n", str, who_am_i());

exit_cleanup(RERR_MALLOC);

}

int set_modtime(const char *fname, time_t modtime, uint32 mod_nsec, mode_t mode)

{

static int switch_step = 0;

if (DEBUG_GTE(TIME, 1)) {

rprintf(FINFO, "set modtime of %s to (%ld) %s",

fname, (long)modtime,

asctime(localtime(&modtime)));

}

switch (switch_step) {

#ifdef HAVE_UTIMENSAT

#include "case_N.h"

if (do_utimensat(fname, modtime, mod_nsec) == 0)

break;

if (errno != ENOSYS)

return -1;

switch_step++;

/* FALLTHROUGH */

#ifdef HAVE_LUTIMES

#include "case_N.h"

if (do_lutimes(fname, modtime, mod_nsec) == 0)

break;

if (errno != ENOSYS)

return -1;

switch_step++;

/* FALLTHROUGH */

#include "case_N.h"

switch_step++;

if (preserve_times & PRESERVE_LINK_TIMES) {

preserve_times &= ~PRESERVE_LINK_TIMES;

if (S_ISLNK(mode))

return 1;

}

/* FALLTHROUGH */

#include "case_N.h"

#ifdef HAVE_UTIMES

if (do_utimes(fname, modtime, mod_nsec) == 0)

break;

if (do_utime(fname, modtime, mod_nsec) == 0)

break;

return -1;

}

return 0;

}

int make_path(char *fname, int flags)

{

char *end, *p;

int ret = 0;

if (flags & MKP_SKIP_SLASH) {

while (*fname == '/')

fname++;

}

while (*fname == '.' && fname[1] == '/')

fname += 2;

if (flags & MKP_DROP_NAME) {

end = strrchr(fname, '/');

if (!end)

return 0;

*end = '\0';

} else

end = fname + strlen(fname);

/* Try to find an existing dir, starting from the deepest dir. */

for (p = end; ; ) {

if (do_mkdir(fname, ACCESSPERMS) == 0) {

ret++;

break;

}

if (errno != ENOENT) {

if (errno != EEXIST)

ret = -ret - 1;

break;

}

while (1) {

if (p == fname) {

ret = -ret - 1;

goto double_break;

}

if (*--p == '/') {

if (p == fname) {

ret = -ret - 1; /* impossible... */

goto double_break;

}

*p = '\0';

break;

}

}

}

double_break:

/* Make all the dirs that we didn't find on the way here. */

while (p != end) {

*p = '/';

p += strlen(p);

if (ret < 0) /* Skip mkdir on error, but keep restoring the path. */

continue;

if (do_mkdir(fname, ACCESSPERMS) < 0)

ret = -ret - 1;

else

ret++;

}

if (flags & MKP_DROP_NAME)

*end = '/';

return ret;

}

int full_write(int desc, const char *ptr, size_t len)

{

int total_written;

total_written = 0;

while (len > 0) {

int written = write(desc, ptr, len);

if (written < 0) {

if (errno == EINTR)

continue;

return written;

}

total_written += written;

ptr += written;

len -= written;

}

return total_written;

}

static int safe_read(int desc, char *ptr, size_t len)

{

int n_chars;

if (len == 0)

return len;

do {

n_chars = read(desc, ptr, len);

} while (n_chars < 0 && errno == EINTR);

return n_chars;

}

int copy_file(const char *source, const char *dest, int ofd, mode_t mode)

{

int ifd;

char buf[1024 * 8];

int len; /* Number of bytes read into `buf'. */

if ((ifd = do_open(source, O_RDONLY, 0)) < 0) {

int save_errno = errno;

rsyserr(FERROR_XFER, errno, "open %s", full_fname(source));

errno = save_errno;

return -1;

}

if (ofd < 0) {

if (robust_unlink(dest) && errno != ENOENT) {

int save_errno = errno;

rsyserr(FERROR_XFER, errno, "unlink %s", full_fname(dest));

errno = save_errno;

return -1;

}

#ifdef SUPPORT_XATTRS

if (preserve_xattrs)

mode |= S_IWUSR;

mode &= INITACCESSPERMS;

if ((ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0) {

int save_errno = errno;

rsyserr(FERROR_XFER, save_errno, "open %s", full_fname(dest));

close(ifd);

errno = save_errno;

return -1;

}

}

while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {

if (full_write(ofd, buf, len) < 0) {

int save_errno = errno;

rsyserr(FERROR_XFER, errno, "write %s", full_fname(dest));

close(ifd);

close(ofd);

errno = save_errno;

return -1;

}

}

if (len < 0) {

int save_errno = errno;

rsyserr(FERROR_XFER, errno, "read %s", full_fname(source));

close(ifd);

close(ofd);

errno = save_errno;

return -1;

}

if (close(ifd) < 0) {

rsyserr(FWARNING, errno, "close failed on %s",

full_fname(source));

}

if (close(ofd) < 0) {

int save_errno = errno;

rsyserr(FERROR_XFER, errno, "close failed on %s",

full_fname(dest));

errno = save_errno;

return -1;

}

#ifdef SUPPORT_XATTRS

if (preserve_xattrs)

copy_xattrs(source, dest);

return 0;

}

#define MAX_RENAMES_DIGITS 3

#define MAX_RENAMES 1000

int robust_unlink(const char *fname)

{

#ifndef ETXTBSY

return do_unlink(fname);

static int counter = 1;

int rc, pos, start;

char path[MAXPATHLEN];

rc = do_unlink(fname);

if (rc == 0 || errno != ETXTBSY)

return rc;

if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)

pos = MAXPATHLEN - 1;

while (pos > 0 && path[pos-1] != '/')

pos--;

pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);

if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {

errno = ETXTBSY;

return -1;

}

/* start where the last one left off to reduce chance of clashes */

start = counter;

do {

snprintf(&path[pos], MAX_RENAMES_DIGITS+1, "%03d", counter);

if (++counter >= MAX_RENAMES)

counter = 1;

} while ((rc = access(path, 0)) == 0 && counter != start);

if (INFO_GTE(MISC, 1)) {

rprintf(FWARNING, "renaming %s to %s because of text busy\n",

fname, path);

}

/* maybe we should return rename()'s exit status? Nah. */

if (do_rename(fname, path) != 0) {

errno = ETXTBSY;

return -1;

}

return 0;

}

int robust_rename(const char *from, const char *to, const char *partialptr,

int mode)

{

int tries = 4;

while (tries--) {

if (do_rename(from, to) == 0)

return 0;

switch (errno) {

#ifdef ETXTBSY

case ETXTBSY:

if (robust_unlink(to) != 0) {

errno = ETXTBSY;

return -1;

}

errno = ETXTBSY;

break;

case EXDEV:

if (partialptr) {

if (!handle_partial_dir(partialptr,PDIR_CREATE))

return -2;

to = partialptr;

}

if (copy_file(from, to, -1, mode) != 0)

return -2;

do_unlink(from);

return 1;

default:

return -1;

}

}

return -1;

}

static pid_t all_pids[10];

static int num_pids;

pid_t do_fork(void)

{

pid_t newpid = fork();

if (newpid != 0 && newpid != -1) {

all_pids[num_pids++] = newpid;

}

return newpid;

}

void kill_all(int sig)

{

int i;

for (i = 0; i < num_pids; i++) {

/* Let's just be a little careful where we

pid_t p = all_pids[i];

if (p == getpid())

continue;

if (p <= 0)

continue;

kill(p, sig);

}

}

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;

}

#define ENSURE_MEMSPACE(buf, type, sz, req) \

if ((req) > sz && !(buf = realloc_array(buf, type, sz = MAX(sz * 2, req)))) \

out_of_memory("glob_expand")

static inline void call_glob_match(const char *name, int len, int from_glob,

char *arg, int abpos, int fbpos);

static struct glob_data {

char *arg_buf, *filt_buf, **argv;

int absize, fbsize, maxargs, argc;

} glob;

static void glob_match(char *arg, int abpos, int fbpos)

{

int len;

char *slash;

while (*arg == '.' && arg[1] == '/') {

if (fbpos < 0) {

ENSURE_MEMSPACE(glob.filt_buf, char, glob.fbsize, glob.absize);

memcpy(glob.filt_buf, glob.arg_buf, abpos + 1);

fbpos = abpos;

}

ENSURE_MEMSPACE(glob.arg_buf, char, glob.absize, abpos + 3);

glob.arg_buf[abpos++] = *arg++;

glob.arg_buf[abpos++] = *arg++;

glob.arg_buf[abpos] = '\0';

}

if ((slash = strchr(arg, '/')) != NULL) {

*slash = '\0';

len = slash - arg;

} else

len = strlen(arg);

if (strpbrk(arg, "*?[")) {

struct dirent *di;

DIR *d;

if (!(d = opendir(abpos ? glob.arg_buf : ".")))

return;

while ((di = readdir(d)) != NULL) {

char *dname = d_name(di);

if (dname[0] == '.' && (dname[1] == '\0'

|| (dname[1] == '.' && dname[2] == '\0')))

continue;

if (!wildmatch(arg, dname))

continue;

call_glob_match(dname, strlen(dname), 1,

slash ? arg + len + 1 : NULL,

abpos, fbpos);

}

closedir(d);

} else {

call_glob_match(arg, len, 0,

slash ? arg + len + 1 : NULL,

abpos, fbpos);

}

if (slash)

*slash = '/';

}

static inline void call_glob_match(const char *name, int len, int from_glob,

char *arg, int abpos, int fbpos)

{

char *use_buf;

ENSURE_MEMSPACE(glob.arg_buf, char, glob.absize, abpos + len + 2);

memcpy(glob.arg_buf + abpos, name, len);

abpos += len;

glob.arg_buf[abpos] = '\0';

if (fbpos >= 0) {

ENSURE_MEMSPACE(glob.filt_buf, char, glob.fbsize, fbpos + len + 2);

memcpy(glob.filt_buf + fbpos, name, len);

fbpos += len;

glob.filt_buf[fbpos] = '\0';

use_buf = glob.filt_buf;

} else

use_buf = glob.arg_buf;

if (from_glob || (arg && len)) {

STRUCT_STAT st;

int is_dir;

if (do_stat(glob.arg_buf, &st) != 0)

return;

is_dir = S_ISDIR(st.st_mode) != 0;

if (arg && !is_dir)

return;

if (daemon_filter_list.head

&& check_filter(&daemon_filter_list, FLOG, use_buf, is_dir) < 0)

return;

}

if (arg) {

glob.arg_buf[abpos++] = '/';

glob.arg_buf[abpos] = '\0';

if (fbpos >= 0) {

glob.filt_buf[fbpos++] = '/';

glob.filt_buf[fbpos] = '\0';

}

glob_match(arg, abpos, fbpos);

} else {

ENSURE_MEMSPACE(glob.argv, char *, glob.maxargs, glob.argc + 1);

if (!(glob.argv[glob.argc++] = strdup(glob.arg_buf)))

out_of_memory("glob_match");

}

}

int glob_expand(const char *arg, char ***argv_p, int *argc_p, int *maxargs_p)

{

int ret, save_argc;

char *s;

if (!arg) {

if (glob.filt_buf)

free(glob.filt_buf);

free(glob.arg_buf);

memset(&glob, 0, sizeof glob);

return -1;

}

if (sanitize_paths)

s = sanitize_path(NULL, arg, "", 0, SP_KEEP_DOT_DIRS);

else {

s = strdup(arg);

if (!s)

out_of_memory("glob_expand");

clean_fname(s, CFN_KEEP_DOT_DIRS

| CFN_KEEP_TRAILING_SLASH

| CFN_COLLAPSE_DOT_DOT_DIRS);

}

ENSURE_MEMSPACE(glob.arg_buf, char, glob.absize, MAXPATHLEN);

*glob.arg_buf = '\0';

glob.argc = save_argc = *argc_p;

glob.argv = *argv_p;

glob.maxargs = *maxargs_p;

ENSURE_MEMSPACE(glob.argv, char *, glob.maxargs, 100);

glob_match(s, 0, -1);

/* The arg didn't match anything, so add the failed arg to the list. */

if (glob.argc == save_argc) {

ENSURE_MEMSPACE(glob.argv, char *, glob.maxargs, glob.argc + 1);

glob.argv[glob.argc++] = s;

ret = 0;

} else {

free(s);

ret = 1;

}

*maxargs_p = glob.maxargs;

*argv_p = glob.argv;

*argc_p = glob.argc;

return ret;

}

void glob_expand_module(char *base1, char *arg, char ***argv_p, int *argc_p, int *maxargs_p)

{

char *p, *s;

char *base = base1;

int base_len = strlen(base);

if (!arg || !*arg)

return;

if (strncmp(arg, base, base_len) == 0)

arg += base_len;

if (!(arg = strdup(arg)))

out_of_memory("glob_expand_module");

if (asprintf(&base," %s/", base1) <= 0)

out_of_memory("glob_expand_module");

base_len++;

for (s = arg; *s; s = p + base_len) {

if ((p = strstr(s, base)) != NULL)

*p = '\0'; /* split it at this point */

glob_expand(s, argv_p, argc_p, maxargs_p);

if (!p)

break;

}

free(arg);

free(base);

}

void strlower(char *s)

{

while (*s) {

if (isUpper(s))

*s = toLower(s);

s++;

}

}

size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)

{

size_t len = strlcpy(dest, p1, destsize);

if (len < destsize - 1) {

if (!len || dest[len-1] != '/')

dest[len++] = '/';

if (len < destsize - 1)

len += strlcpy(dest + len, p2, destsize - len);

else {

dest[len] = '\0';

len += strlen(p2);

}

}

else

len += strlen(p2) + 1; /* Assume we'd insert a '/'. */

return len;

}

size_t stringjoin(char *dest, size_t destsize, ...)

{

va_list ap;

size_t len, ret = 0;

const char *src;

va_start(ap, destsize);

while (1) {

if (!(src = va_arg(ap, const char *)))

break;

len = strlen(src);

ret += len;

if (destsize > 1) {

if (len >= destsize)

len = destsize - 1;

memcpy(dest, src, len);

destsize -= len;

dest += len;

}

}

*dest = '\0';

va_end(ap);

return ret;

}

int count_dir_elements(const char *p)

{

int cnt = 0, new_component = 1;

while (*p) {

if (*p++ == '/')

new_component = (*p != '.' || (p[1] != '/' && p[1] != '\0'));

else if (new_component) {

new_component = 0;

cnt++;

}

}

return cnt;

}

unsigned int clean_fname(char *name, int flags)

{

char *limit = name - 1, *t = name, *f = name;

int anchored;

if (!name)

return 0;

if ((anchored = *f == '/') != 0) {

*t++ = *f++;

#ifdef __CYGWIN__

/* If there are exactly 2 slashes at the start, preserve

if (*f == '/' && f[1] != '/')

*t++ = *f++;

} else if (flags & CFN_KEEP_DOT_DIRS && *f == '.' && f[1] == '/') {

*t++ = *f++;

*t++ = *f++;

}

while (*f) {

/* discard extra slashes */

if (*f == '/') {

f++;

continue;

}

if (*f == '.') {

/* discard interior "." dirs */

if (f[1] == '/' && !(flags & CFN_KEEP_DOT_DIRS)) {

f += 2;

continue;

}

if (f[1] == '\0' && flags & CFN_DROP_TRAILING_DOT_DIR)

break;

/* collapse ".." dirs */

if (flags & CFN_COLLAPSE_DOT_DOT_DIRS

&& f[1] == '.' && (f[2] == '/' || !f[2])) {

char *s = t - 1;

if (s == name && anchored) {

f += 2;

continue;

}

while (s > limit && *--s != '/') {}

if (s != t - 1 && (s < name || *s == '/')) {

t = s + 1;

f += 2;

continue;

}

limit = t + 2;

}

}

while (*f && (*t++ = *f++) != '/') {}

}

if (t > name+anchored && t[-1] == '/' && !(flags & CFN_KEEP_TRAILING_SLASH))

t--;

if (t == name)

*t++ = '.';

*t = '\0';

return t - name;

}

char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth,

int flags)

{

char *start, *sanp;

int rlen = 0, drop_dot_dirs = !relative_paths || !(flags & SP_KEEP_DOT_DIRS);

if (dest != p) {

int plen = strlen(p);

if (*p == '/') {

if (!rootdir)

rootdir = module_dir;

rlen = strlen(rootdir);

depth = 0;

p++;

}

if (dest) {

if (rlen + plen + 1 >= MAXPATHLEN)

return NULL;

} else if (!(dest = new_array(char, rlen + plen + 1)))

out_of_memory("sanitize_path");

if (rlen) {

memcpy(dest, rootdir, rlen);

if (rlen > 1)

dest[rlen++] = '/';

}

}

if (drop_dot_dirs) {

while (*p == '.' && p[1] == '/')

p += 2;

}

start = sanp = dest + rlen;

/* This loop iterates once per filename component in p, pointing at

while (*p) {

/* discard leading or extra slashes */

if (*p == '/') {

p++;

continue;

}

if (drop_dot_dirs) {

if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {

/* skip "." component */

p++;

continue;

}

}

if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {

/* ".." component followed by slash or end */

if (depth <= 0 || sanp != start) {

p += 2;

if (sanp != start) {

/* back up sanp one level */

--sanp; /* now pointing at slash */

while (sanp > start && sanp[-1] != '/')

sanp--;

}

continue;

}

/* allow depth levels of .. at the beginning */

depth--;

/* move the virtual beginning to leave the .. alone */

start = sanp + 3;

}

/* copy one component through next slash */

while (*p && (*sanp++ = *p++) != '/') {}

}

if (sanp == dest) {

/* ended up with nothing, so put in "." component */

*sanp++ = '.';

}

*sanp = '\0';

return dest;

}

int change_dir(const char *dir, int set_path_only)

{

static int initialised;

unsigned int len;

if (!initialised) {