/* -*- c-file-style: "linux" -*-
-
- Copyright (C) 1996-2000 by Andrew Tridgell
- Copyright (C) Paul Mackerras 1996
- Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
-
- 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.
-
- 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.
-*/
+ *
+ * Copyright (C) 1996-2000 by Andrew Tridgell
+ * Copyright (C) Paul Mackerras 1996
+ * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+ *
+ * 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.
+ *
+ * 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.
+ */
/**
+ * @file
*
- * @file util.c
- *
- * Utilities used in rsync
+ * Utilities used in rsync
**/
#include "rsync.h"
extern int verbose;
+int sanitize_paths = 0;
+
+
/**
- 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, 0)) == -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, 0)) == -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).
-
- Always set non-blocking.
+ * Create a file descriptor pair - like pipe() but use socketpair if
+ * possible (because of blocking issues on pipes).
+ *
+ * Always set non-blocking.
*/
int fd_pair(int fd[2])
{
set_nonblocking(fd[0]);
set_nonblocking(fd[1]);
}
-
+
return ret;
}
-static void print_child_argv(char **cmd)
+void print_child_argv(char **cmd)
{
rprintf(FINFO, "opening connection using ");
for (; *cmd; cmd++) {
}
-/**
- * Create a child connected to use on stdin/stdout.
- *
- * This is derived from CVS code
- *
- * Note that in the child STDIN is set to blocking and STDOUT
- * is set to non-blocking. This is necessary as rsh relies on stdin being blocking
- * and ssh relies on stdout being non-blocking
- *
- * If blocking_io is set then use blocking io on both fds. That can be
- * used to cope with badly broken rsh implementations like the one on
- * Solaris.
- **/
-pid_t piped_child(char **command, int *f_in, int *f_out)
-{
- pid_t pid;
- int to_child_pipe[2];
- int from_child_pipe[2];
- extern int blocking_io;
-
- if (verbose >= 2) {
- print_child_argv(command);
- }
-
- if (fd_pair(to_child_pipe) < 0 || fd_pair(from_child_pipe) < 0) {
- rprintf(FERROR, "pipe: %s\n", strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
-
- pid = do_fork();
- if (pid == -1) {
- rprintf(FERROR, "fork: %s\n", strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
- if (pid == 0) {
- extern int orig_umask;
- if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
- close(to_child_pipe[1]) < 0 ||
- close(from_child_pipe[0]) < 0 ||
- dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
- rprintf(FERROR, "Failed to dup/close : %s\n",
- strerror(errno));
- exit_cleanup(RERR_IPC);
- }
- if (to_child_pipe[0] != STDIN_FILENO)
- close(to_child_pipe[0]);
- if (from_child_pipe[1] != STDOUT_FILENO)
- close(from_child_pipe[1]);
- umask(orig_umask);
- set_blocking(STDIN_FILENO);
- if (blocking_io) {
- set_blocking(STDOUT_FILENO);
- }
- execvp(command[0], command);
- rprintf(FERROR, "Failed to exec %s : %s\n",
- command[0], strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
- if (close(from_child_pipe[1]) < 0 || close(to_child_pipe[0]) < 0) {
- rprintf(FERROR, "Failed to close : %s\n", strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
- *f_in = from_child_pipe[0];
- *f_out = to_child_pipe[1];
-
- return pid;
-}
-
-pid_t local_child(int argc, char **argv,int *f_in,int *f_out)
-{
- pid_t pid;
- int to_child_pipe[2];
- int from_child_pipe[2];
- extern int read_batch; /* dw */
-
- if (fd_pair(to_child_pipe) < 0 ||
- fd_pair(from_child_pipe) < 0) {
- rprintf(FERROR,"pipe: %s\n",strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
-
- pid = do_fork();
- if (pid == -1) {
- rprintf(FERROR,"fork: %s\n",strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
- if (pid == 0) {
- extern int am_sender;
- extern int am_server;
-
- am_sender = read_batch ? 0 : !am_sender;
- am_server = 1;
-
- if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
- close(to_child_pipe[1]) < 0 ||
- close(from_child_pipe[0]) < 0 ||
- dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
- rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
- exit_cleanup(RERR_IPC);
- }
- if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
- if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
- start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
- }
-
- if (close(from_child_pipe[1]) < 0 ||
- close(to_child_pipe[0]) < 0) {
- rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
- exit_cleanup(RERR_IPC);
- }
-
- *f_in = from_child_pipe[0];
- *f_out = to_child_pipe[1];
-
- return pid;
-}
-
-
-
void out_of_memory(char *str)
{
rprintf(FERROR,"ERROR: out of memory in %s\n",str);
fname, (long) modtime,
asctime(localtime(&modtime)));
}
-
+
{
#ifdef HAVE_UTIMBUF
- struct utimbuf tbuf;
+ struct utimbuf tbuf;
tbuf.actime = time(NULL);
tbuf.modtime = modtime;
return utime(fname,&tbuf);
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 create_directory_path(char *fname, int base_umask)
{
- extern int orig_umask;
char *p;
while (*fname == '/') fname++;
p = fname;
while ((p=strchr(p,'/'))) {
*p = 0;
- do_mkdir(fname,0777 & ~orig_umask);
+ do_mkdir(fname, 0777 & ~base_umask);
*p = '/';
p++;
}
static int full_write(int desc, char *ptr, size_t len)
{
int total_written;
-
+
total_written = 0;
while (len > 0) {
- int written = write (desc, ptr, len);
+ int written = write(desc, ptr, len);
if (written < 0) {
-#ifdef EINTR
if (errno == EINTR)
continue;
-#endif
return written;
}
total_written += written;
static int safe_read(int desc, char *ptr, size_t len)
{
int n_chars;
-
+
if (len == 0)
return len;
-
-#ifdef EINTR
+
do {
n_chars = read(desc, ptr, len);
} while (n_chars < 0 && errno == EINTR);
-#else
- n_chars = read(desc, ptr, len);
-#endif
-
+
return n_chars;
}
return -1;
}
- while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
+ while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
if (full_write(ofd, buf, len) < 0) {
rprintf(FERROR,"write %s: %s\n",
dest,strerror(errno));
#define MAX_RENAMES 1000
/**
- *
- Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
- rename to <path>/.rsyncNNN instead.
-
- Note that successive rsync runs will shuffle the filenames around a
- bit as long as the file is still busy; this is because this function
- does not know if the unlink call is due to a new file coming in, or
- --delete trying to remove old .rsyncNNN files, hence it renames it
- each time.
-*/
+ * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
+ * rename to <path>/.rsyncNNN instead.
+ *
+ * Note that successive rsync runs will shuffle the filenames around a
+ * bit as long as the file is still busy; this is because this function
+ * does not know if the unlink call is due to a new file coming in, or
+ * --delete trying to remove old .rsyncNNN files, hence it renames it
+ * each time.
+ **/
int robust_unlink(char *fname)
{
#ifndef ETXTBSY
while((path[--pos] != '/') && (pos >= 0))
;
++pos;
- strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
- pos += sizeof(".rsync")-1;
+ pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
errno = ETXTBSY;
counter = 1;
} while (((rc = access(path, 0)) == 0) && (counter != start));
- if (verbose > 0)
+ if (verbose > 0) {
rprintf(FINFO,"renaming %s to %s because of text busy\n",
- fname, path);
+ fname, path);
+ }
/* maybe we should return rename()'s exit status? Nah. */
if (do_rename(fname, path) != 0) {
pid_t do_fork(void)
{
pid_t newpid = fork();
-
+
if (newpid != 0 && newpid != -1) {
all_pids[num_pids++] = newpid;
}
lock.l_start = offset;
lock.l_len = len;
lock.l_pid = 0;
-
+
return fcntl(fd,F_SETLK,&lock) == 0;
}
+static int exclude_server_path(char *arg)
+{
+ char *s;
+ extern struct exclude_struct **server_exclude_list;
+
+ if (server_exclude_list) {
+ for (s = arg; (s = strchr(s, '/')) != NULL; ) {
+ *s = '\0';
+ if (check_exclude(server_exclude_list, arg, 1)) {
+ /* We must leave arg truncated! */
+ return 1;
+ }
+ *s++ = '/';
+ }
+ }
+ return 0;
+}
static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
{
#if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
if (!*s) s = ".";
- argv[*argc] = strdup(s);
+ s = argv[*argc] = strdup(s);
+ exclude_server_path(s);
(*argc)++;
- return;
#else
extern int sanitize_paths;
glob_t globbuf;
if (!*s) s = ".";
- argv[*argc] = strdup(s);
+ s = argv[*argc] = strdup(s);
if (sanitize_paths) {
- sanitize_path(argv[*argc], NULL);
+ sanitize_path(s, NULL);
}
- memset(&globbuf, 0, sizeof(globbuf));
- glob(argv[*argc], 0, NULL, &globbuf);
+ memset(&globbuf, 0, sizeof globbuf);
+ if (!exclude_server_path(s))
+ glob(s, 0, NULL, &globbuf);
if (globbuf.gl_pathc == 0) {
(*argc)++;
globfree(&globbuf);
return;
}
for (i=0; i<(maxargs - (*argc)) && i < (int) globbuf.gl_pathc;i++) {
- if (i == 0) free(argv[*argc]);
+ if (i == 0) free(s);
argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
if (!argv[(*argc) + i]) out_of_memory("glob_expand");
}
#endif
}
+/* This routine is only used in daemon mode. */
void glob_expand(char *base1, char **argv, int *argc, int maxargs)
{
char *s = argv[*argc];
char *p, *q;
char *base = base1;
+ int base_len = strlen(base);
if (!s || !*s) return;
- if (strncmp(s, base, strlen(base)) == 0) {
- s += strlen(base);
- }
+ if (strncmp(s, base, base_len) == 0)
+ s += base_len;
s = strdup(s);
if (!s) out_of_memory("glob_expand");
if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
+ base_len++;
q = s;
while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
/* split it at this point */
*p = 0;
glob_expand_one(q, argv, argc, maxargs);
- q = p+strlen(base);
+ q = p + base_len;
}
if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
void strlower(char *s)
{
while (*s) {
- if (isupper(*s)) *s = tolower(*s);
+ if (isupper(* (unsigned char *) s))
+ *s = tolower(* (unsigned char *) s);
s++;
}
}
-void *Realloc(void *p, int size)
+/* Join strings p1 & p2 into "dest" with a guaranteed '/' between them. (If
+ * p1 ends with a '/', no extra '/' is inserted.) Returns the length of both
+ * strings + 1 (if '/' was inserted), regardless of whether the whole thing
+ * fits into destsize (including the terminating '\0'). */
+size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
{
- if (!p) return (void *)malloc(size);
- return (void *)realloc(p, size);
+ 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;
}
+/* Join any number of strings together, putting them in "dest". The return
+ * value is the length of all the strings, regardless of whether they fit in
+ * destsize (including the terminating '\0'). Your list of string pointers
+ * should end with a NULL to indicate the end of the list. */
+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;
+}
void clean_fname(char *name)
{
}
}
- if (strncmp(p=name,"./",2) == 0) {
+ if (strncmp(p=name,"./",2) == 0) {
modified = 1;
do {
p[0] = p[2];
/**
* Make path appear as if a chroot had occurred:
*
- * 1. remove leading "/" (or replace with "." if at end)
- * 2. remove leading ".." components (except those allowed by "reldir")
- * 3. delete any other "<dir>/.." (recursively)
+ * @li 1. remove leading "/" (or replace with "." if at end)
+ *
+ * @li 2. remove leading ".." components (except those allowed by @p reldir)
+ *
+ * @li 3. delete any other "<dir>/.." (recursively)
*
* Can only shrink paths, so sanitizes in place.
*
* While we're at it, remove double slashes and "." components like
- * clean_fname does(), but DON'T remove a trailing slash because that
+ * clean_fname() does, but DON'T remove a trailing slash because that
* is sometimes significant on command line arguments.
*
- * If "reldir" is non-null, it is a sanitized directory that the path will be
+ * If @p reldir is non-null, it is a sanitized directory that the path will be
* relative to, so allow as many ".." at the beginning of the path as
* there are components in reldir. This is used for symbolic link targets.
* If reldir is non-null and the path began with "/", to be completely like
}
allowdotdot = 0;
if ((*p == '.') && (*(p+1) == '.') &&
- ((*(p+2) == '/') || (*(p+2) == '\0'))) {
+ ((*(p+2) == '/') || (*(p+2) == '\0'))) {
/* ".." component followed by slash or end */
if ((depth > 0) && (sanp == start)) {
/* allow depth levels of .. at the beginning */
}
-static char curr_dir[MAXPATHLEN];
+char curr_dir[MAXPATHLEN];
+unsigned int curr_dir_len;
-/** like chdir() but can be reversed with pop_dir() if save is set. It
- is also much faster as it remembers where we have been */
-char *push_dir(char *dir, int save)
+/**
+ * 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)
{
- char *ret = curr_dir;
static int initialised;
+ unsigned int len;
if (!initialised) {
initialised = 1;
- getcwd(curr_dir, sizeof(curr_dir)-1);
+ getcwd(curr_dir, sizeof curr_dir - 1);
+ curr_dir_len = strlen(curr_dir);
}
- if (!dir) return NULL; /* this call was probably just to initialize */
+ if (!dir) /* this call was probably just to initialize */
+ return 0;
- if (chdir(dir)) return NULL;
+ len = strlen(dir);
+ if (len == 1 && *dir == '.')
+ return 1;
- if (save) {
- ret = strdup(curr_dir);
- }
+ if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
+ return 0;
+
+ if (chdir(dir))
+ return 0;
if (*dir == '/') {
- strlcpy(curr_dir, dir, sizeof(curr_dir));
+ memcpy(curr_dir, dir, len + 1);
+ curr_dir_len = len;
} else {
- strlcat(curr_dir,"/", sizeof(curr_dir));
- strlcat(curr_dir,dir, sizeof(curr_dir));
+ curr_dir[curr_dir_len++] = '/';
+ memcpy(curr_dir + curr_dir_len, dir, len + 1);
+ curr_dir_len += len;
}
clean_fname(curr_dir);
- return ret;
+ return 1;
}
-/** Reverse a push_dir call */
+/**
+ * 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 ret;
+ if (chdir(dir))
+ return 0;
- ret = chdir(dir);
- if (ret) {
- free(dir);
- return ret;
- }
+ curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
+ if (curr_dir_len >= sizeof curr_dir)
+ curr_dir_len = sizeof curr_dir - 1;
+
+ return 1;
+}
- strlcpy(curr_dir, dir, sizeof(curr_dir));
+/**
+ * Return a quoted string with the full pathname of the indicated filename.
+ * The string " (in MODNAME)" may also be appended. The returned pointer
+ * remains valid until the next time full_fname() is called.
+ **/
+char *full_fname(char *fn)
+{
+ extern int module_id;
+ static char *result = NULL;
+ char *m1, *m2, *m3;
+ char *p1, *p2;
+
+ if (result)
+ free(result);
+
+ if (*fn == '/')
+ p1 = p2 = "";
+ else {
+ p1 = curr_dir;
+ p2 = "/";
+ }
+ if (module_id >= 0) {
+ m1 = " (in ";
+ m2 = lp_name(module_id);
+ m3 = ")";
+ if (*p1) {
+ if (!lp_use_chroot(module_id)) {
+ char *p = lp_path(module_id);
+ if (*p != '/' || p[1])
+ p1 += strlen(p);
+ }
+ if (!*p1)
+ p2++;
+ else
+ p1++;
+ }
+ else
+ fn++;
+ } else
+ m1 = m2 = m3 = "";
- free(dir);
+ asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
- return 0;
+ return result;
}
/** We need to supply our own strcmp function for file list comparisons
while (*s1 && *s2 && (*s1 == *s2)) {
s1++; s2++;
}
-
- return (int)*s1 - (int)*s2;
-}
-
-static OFF_T last_ofs;
-static struct timeval print_time;
-static struct timeval start_time;
-static OFF_T start_ofs;
-
-static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
-{
- return (t2->tv_sec - t1->tv_sec) * 1000
- + (t2->tv_usec - t1->tv_usec) / 1000;
-}
-
-
-/**
- * @param ofs Current position in file
- * @param size Total size of file
- * @param is_last True if this is the last time progress will be
- * printed for this file, so we should output a newline. (Not
- * necessarily the same as all bytes being received.)
- **/
-static void rprint_progress(OFF_T ofs, OFF_T size, struct timeval *now,
- int is_last)
-{
- int pct = (ofs == size) ? 100 : (int)((100.0*ofs)/size);
- unsigned long diff = msdiff(&start_time, now);
- double rate = diff ? (double) (ofs-start_ofs) * 1000.0 / diff / 1024.0 : 0;
- const char *units;
- /* If we've finished transferring this file, show the time taken;
- * otherwise show expected time to complete. That's kind of
- * inconsistent, but people can probably cope. Hopefully we'll
- * get more consistent and complete progress reporting soon. --
- * mbp */
- double remain = is_last
- ? (double) diff / 1000.0
- : rate ? (double) (size-ofs) / rate / 1000.0 : 0.0;
- int remain_h, remain_m, remain_s;
-
- if (rate > 1024*1024) {
- rate /= 1024.0 * 1024.0;
- units = "GB/s";
- } else if (rate > 1024) {
- rate /= 1024.0;
- units = "MB/s";
- } else {
- units = "kB/s";
- }
-
- remain_s = (int) remain % 60;
- remain_m = (int) (remain / 60.0) % 60;
- remain_h = (int) (remain / 3600.0);
-
- rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
- (double) ofs, pct, rate, units,
- remain_h, remain_m, remain_s,
- is_last ? "\n" : "\r");
-}
-void end_progress(OFF_T size)
-{
- extern int do_progress, am_server;
-
- if (do_progress && !am_server) {
- struct timeval now;
- gettimeofday(&now, NULL);
- rprint_progress(size, size, &now, True);
- }
- last_ofs = 0;
- start_ofs = 0;
- print_time.tv_sec = print_time.tv_usec = 0;
- start_time.tv_sec = start_time.tv_usec = 0;
+ return (int)*s1 - (int)*s2;
}
-void show_progress(OFF_T ofs, OFF_T size)
-{
- extern int do_progress, am_server;
- struct timeval now;
-
- gettimeofday(&now, NULL);
-
- if (!start_time.tv_sec && !start_time.tv_usec) {
- start_time.tv_sec = now.tv_sec;
- start_time.tv_usec = now.tv_usec;
- start_ofs = ofs;
- }
-
- if (do_progress
- && !am_server
- && ofs > last_ofs + 1000
- && msdiff(&print_time, &now) > 250) {
- rprint_progress(ofs, size, &now, False);
- last_ofs = ofs;
- print_time.tv_sec = now.tv_sec;
- print_time.tv_usec = now.tv_usec;
- }
-}
/**
* else's machine it might allow them to establish a symlink to
* /etc/passwd, and then read it through a web server.
*
+ * Null symlinks and absolute symlinks are always unsafe.
+ *
+ * Basically here we are concerned with symlinks whose target contains
+ * "..", because this might cause us to walk back up out of the
+ * transferred directory. We are not allowed to go back up and
+ * reenter.
+ *
* @param dest Target of the symlink in question.
*
- * @src src Top source directory currently applicable. Basically this
+ * @param src Top source directory currently applicable. Basically this
* is the first parameter to rsync in a simple invocation, but it's
- * modified as topsrcname in slightly complex ways.
+ * modified by flist.c in slightly complex ways.
*
* @retval True if unsafe
* @retval False is unsafe
+ *
+ * @sa t_unsafe.c
**/
-int unsafe_symlink(char *dest, char *src)
+int unsafe_symlink(const char *dest, const char *src)
{
- char *tok;
+ const char *name, *slash;
int depth = 0;
/* all absolute and null symlinks are unsafe */
- if (!dest || !(*dest) || (*dest == '/')) return 1;
-
- src = strdup(src);
- if (!src) out_of_memory("unsafe_symlink");
+ if (!dest || !*dest || *dest == '/') return 1;
/* find out what our safety margin is */
- for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
- if (strcmp(tok,"..") == 0) {
+ for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
+ if (strncmp(name, "../", 3) == 0) {
depth=0;
- } else if (strcmp(tok,".") == 0) {
+ } else if (strncmp(name, "./", 2) == 0) {
/* nothing */
} else {
depth++;
}
}
- free(src);
-
- /* drop by one to account for the filename portion */
- depth--;
-
- dest = strdup(dest);
- if (!dest) out_of_memory("unsafe_symlink");
-
- for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
- if (strcmp(tok,"..") == 0) {
- depth--;
- } else if (strcmp(tok,".") == 0) {
+ if (strcmp(name, "..") == 0)
+ depth = 0;
+
+ for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
+ if (strncmp(name, "../", 3) == 0) {
+ /* if at any point we go outside the current directory
+ then stop - it is unsafe */
+ if (--depth < 0)
+ return 1;
+ } else if (strncmp(name, "./", 2) == 0) {
/* nothing */
} else {
depth++;
}
- /* if at any point we go outside the current directory then
- stop - it is unsafe */
- if (depth < 0) break;
}
+ if (strcmp(name, "..") == 0)
+ depth--;
- free(dest);
return (depth < 0);
}
/**
- Return the date and time as a string
-*/
+ * Return the date and time as a string
+ **/
char *timestring(time_t t)
{
static char TimeBuf[200];
struct tm *tm = localtime(&t);
#ifdef HAVE_STRFTIME
- strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
+ strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
#else
- strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
+ strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
#endif
if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
int msleep(int t)
{
int tdiff=0;
- struct timeval tval,t1,t2;
+ struct timeval tval,t1,t2;
gettimeofday(&t1, NULL);
gettimeofday(&t2, NULL);
-
+
while (tdiff < t) {
tval.tv_sec = (t-tdiff)/1000;
tval.tv_usec = 1000*((t-tdiff)%1000);
-
+
errno = 0;
select(0,NULL,NULL, NULL, &tval);
gettimeofday(&t2, NULL);
- tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
+ tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
(t2.tv_usec - t1.tv_usec)/1000;
}
int ret;
char *cmd;
- asprintf(&cmd, "/usr/X11R6/bin/xterm -display :0 -T Panic -n Panic -e /bin/sh -c 'cat /tmp/ierrs.*.%d ; gdb /proc/%d/exe %d'",
+ asprintf(&cmd, "/usr/X11R6/bin/xterm -display :0 -T Panic -n Panic -e /bin/sh -c 'cat /tmp/ierrs.*.%d ; gdb /proc/%d/exe %d'",
getpid(), getpid(), getpid());
if (!fn) {
return ret;
}
#endif
+
+
+#define MALLOC_MAX 0x40000000
+
+void *_new_array(unsigned int size, unsigned long num)
+{
+ if (num >= MALLOC_MAX/size)
+ return NULL;
+ return malloc(size * num);
+}
+
+void *_realloc_array(void *ptr, 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);
+}
Matt McCutchen's Web Site / rsync / rsync.git / blobdiff