[rsync/rsync.git] / util.c

/* 
   Copyright (C) Andrew Tridgell 1996
   Copyright (C) Paul Mackerras 1996
   
   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.
*/

/*
  Utilities used in rsync 

  tridge, June 1996
  */
#include "rsync.h"

/****************************************************************************
Set a fd into nonblocking mode. Uses POSIX O_NONBLOCK if available,
else
if SYSV use O_NDELAY
if BSD use FNDELAY
****************************************************************************/
int set_nonblocking(int fd)
{
	int val;
#ifdef O_NONBLOCK
#define FLAG_TO_SET O_NONBLOCK
#else
#ifdef SYSV
#define FLAG_TO_SET O_NDELAY
#else /* BSD */
#define FLAG_TO_SET FNDELAY
#endif
#endif
	
	if((val = fcntl(fd, F_GETFL, 0)) == -1)
		return -1;
	val |= FLAG_TO_SET;
	return fcntl( fd, F_SETFL, val);
#undef FLAG_TO_SET
}


/* this is taken from CVS */
int piped_child(char **command,int *f_in,int *f_out)
{
  int pid;
  int to_child_pipe[2];
  int from_child_pipe[2];

  if (pipe(to_child_pipe) < 0 ||
      pipe(from_child_pipe) < 0) {
    rprintf(FERROR,"pipe: %s\n",strerror(errno));
    exit_cleanup(1);
  }


  pid = do_fork();
  if (pid < 0) {
    rprintf(FERROR,"fork: %s\n",strerror(errno));
    exit_cleanup(1);
  }

  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(1);
      }
      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);
      execvp(command[0], command);
      rprintf(FERROR,"Failed to exec %s : %s\n",
	      command[0],strerror(errno));
      exit_cleanup(1);
    }

  if (close(from_child_pipe[1]) < 0 ||
      close(to_child_pipe[0]) < 0) {
    rprintf(FERROR,"Failed to close : %s\n",strerror(errno));   
    exit_cleanup(1);
  }

  *f_in = from_child_pipe[0];
  *f_out = to_child_pipe[1];

  set_nonblocking(*f_in);
  set_nonblocking(*f_out);
  
  return pid;
}

int local_child(int argc, char **argv,int *f_in,int *f_out)
{
	int pid;
	int to_child_pipe[2];
	int from_child_pipe[2];

	if (pipe(to_child_pipe) < 0 ||
	    pipe(from_child_pipe) < 0) {
		rprintf(FERROR,"pipe: %s\n",strerror(errno));
		exit_cleanup(1);
	}


	pid = do_fork();
	if (pid < 0) {
		rprintf(FERROR,"fork: %s\n",strerror(errno));
		exit_cleanup(1);
	}

	if (pid == 0) {
		extern int am_sender;
		extern int am_server;

		am_sender = !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(1);
		}
		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(1);
	}

	*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);
  exit_cleanup(1);
}

void overflow(char *str)
{
  rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
  exit_cleanup(1);
}


int set_modtime(char *fname,time_t modtime)
{
	extern int dry_run;
	if (dry_run) return 0;
	{
#ifdef HAVE_UTIMBUF
		struct utimbuf tbuf;  
		tbuf.actime = time(NULL);
		tbuf.modtime = modtime;
		return utime(fname,&tbuf);
#elif defined(HAVE_UTIME)
		time_t t[2];
		t[0] = time(NULL);
		t[1] = modtime;
		return utime(fname,t);
#else
		struct timeval t[2];
		t[0].tv_sec = time(NULL);
		t[0].tv_usec = 0;
		t[1].tv_sec = modtime;
		t[1].tv_usec = 0;
		return utimes(fname,t);
#endif
	}
}


/****************************************************************************
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)
{
	extern int orig_umask;
	char *p;

	while (*fname == '/') fname++;
	while (strncmp(fname,"./",2)==0) fname += 2;

	p = fname;
	while ((p=strchr(p,'/'))) {
		*p = 0;
		do_mkdir(fname,0777 & ~orig_umask); 
		*p = '/';
		p++;
	}
	return 0;
}


/* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
   Return LEN upon success, write's (negative) error code otherwise.  

   derived from GNU C's cccp.c.
*/
static int full_write(int desc, char *ptr, int len)
{
	int total_written;
	
	total_written = 0;
	while (len > 0) {
		int written = write (desc, ptr, len);
		if (written < 0)  {
#ifdef EINTR
			if (errno == EINTR)
				continue;
#endif
			return written;
		}
		total_written += written;
		ptr += written;
		len -= written;
	}
	return total_written;
}

/* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
   Return the actual number of bytes read, zero for EOF, or negative
   for an error.  

   derived from GNU C's cccp.c. */
static int safe_read(int desc, char *ptr, int 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;
}


/* copy a file - this is used in conjunction with the --temp-dir option */
int copy_file(char *source, char *dest, mode_t mode)
{
	int ifd;
	int ofd;
	char buf[1024 * 8];
	int len;   /* Number of bytes read into `buf'. */

	ifd = open(source, O_RDONLY);
	if (ifd == -1) {
		rprintf(FERROR,"open %s: %s\n",
			source,strerror(errno));
		return -1;
	}

	if (do_unlink(dest) && errno != ENOENT) {
		rprintf(FERROR,"unlink %s: %s\n",
			dest,strerror(errno));
		return -1;
	}

	ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
	if (ofd == -1) {
		rprintf(FERROR,"open %s: %s\n",
			dest,strerror(errno));
		close(ifd);
		return -1;
	}

	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));
			close(ifd);
			close(ofd);
			return -1;
		}
	}

	close(ifd);
	close(ofd);

	if (len < 0) {
		rprintf(FERROR,"read %s: %s\n",
			source,strerror(errno));
		return -1;
	}

	return 0;
}

/* sleep for a while via select */
void u_sleep(int usec)
{
	struct timeval tv;

	tv.tv_sec = 0;
	tv.tv_usec = usec;
	select(0, NULL, NULL, NULL, &tv);
}


static pid_t all_pids[10];
static int num_pids;

/* fork and record the pid of the child */
pid_t do_fork(void)
{
	pid_t newpid = fork();
	
	if (newpid) {
		all_pids[num_pids++] = newpid;
	}
	return newpid;
}

/* kill all children */
void kill_all(int sig)
{
	int i;
	for (i=0;i<num_pids;i++) {
		if (all_pids[i] != getpid())
			kill(all_pids[i], sig);
	}
}

/* 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)
{
	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;
}


/* 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;
}


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
	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
}

void glob_expand(char *base1, char **argv, int *argc, int maxargs)
{
	char *s = argv[*argc];
	char *p, *q;
	char *base = base1;

	if (!s || !*s) return;

	if (strncmp(s, base, strlen(base)) == 0) {
		s += strlen(base);
	}

	s = strdup(s);
	if (!s) out_of_memory("glob_expand");

	base = (char *)malloc(strlen(base1)+3);
	if (!base) out_of_memory("glob_expand");

	sprintf(base," %s/", base1);

	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);
	}

	if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);

	free(s);
	free(base);
}

/*******************************************************************
  convert a string to lower case
********************************************************************/
void strlower(char *s)
{
	while (*s) {
		if (isupper(*s)) *s = tolower(*s);
		s++;
	}
}

/* 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);
		}
	}

	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;
}


void *Realloc(void *p, int size)
{
	if (!p) return (void *)malloc(size);
	return (void *)realloc(p, size);
}


void clean_fname(char *name)
{
	char *p;
	int l;
	int modified = 1;

	if (!name) return;

	while (modified) {
		modified = 0;

		if ((p=strstr(name,"/./"))) {
			modified = 1;
			while (*p) {
				p[0] = p[2];
				p++;
			}
		}

		if ((p=strstr(name,"//"))) {
			modified = 1;
			while (*p) {
				p[0] = p[1];
				p++;
			}
		}

		if (strncmp(p=name,"./",2) == 0) {      
			modified = 1;
			do {
				p[0] = p[2];
			} while (*p++);
		}

		l = strlen(p=name);
		if (l > 1 && p[l-1] == '/') {
			modified = 1;
			p[l-1] = 0;
		}
	}
}


static char curr_dir[MAXPATHLEN];

/* 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)
{
	char *ret = curr_dir;
	static int initialised;

	if (!initialised) {
		initialised = 1;
		getcwd(curr_dir, sizeof(curr_dir)-1);
	}

	if (chdir(dir)) return NULL;

	if (save) {
		ret = strdup(curr_dir);
	}

	if (*dir == '/') {
		strlcpy(curr_dir, dir, sizeof(curr_dir)-1);
	} else {
		strlcat(curr_dir,"/", sizeof(curr_dir)-1);
		strlcat(curr_dir,dir, sizeof(curr_dir)-1);
	}

	clean_fname(curr_dir);

	return ret;
}

/* reverse a push_dir call */
int pop_dir(char *dir)
{
	int ret;

	ret = chdir(dir);
	if (ret) {
		free(dir);
		return ret;
	}

	strlcpy(curr_dir, dir, sizeof(curr_dir)-1);

	free(dir);

	return 0;
}

/* we need to supply our own strcmp function for file list comparisons
   to ensure that signed/unsigned usage is consistent between machines. */
int u_strcmp(const char *cs1, const char *cs2)
{
	const uchar *s1 = (uchar *)cs1;
	const uchar *s2 = (uchar *)cs2;

	while (*s1 && *s2 && (*s1 == *s2)) {
		s1++; s2++;
	}
	
	return (int)*s1 - (int)*s2;
}

static OFF_T last_ofs;

void end_progress(void)
{
	extern int do_progress, am_server;

	if (do_progress && !am_server) {
		rprintf(FINFO,"\n");
	}
	last_ofs = 0;
}

void show_progress(OFF_T ofs, OFF_T size)
{
	extern int do_progress, am_server;

	if (do_progress && !am_server) {
		if (ofs > last_ofs + 1000) {
			int pct = (int)((100.0*ofs)/size);
			rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
			last_ofs = ofs;
		}
	}
}

/* determine if a symlink points outside the current directory tree */
int unsafe_symlink(char *dest, char *src)
{
	char *tok;
	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");

	/* find out what our safety margin is */
	for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
		if (strcmp(tok,"..") == 0) {
			depth=0;
		} else if (strcmp(tok,".") == 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) {
			/* nothing */
		} else {
			depth++;
		}
		/* if at any point we go outside the current directory then
		   stop - it is unsafe */
		if (depth < 0) break;
	}

	free(dest);
	return (depth < 0);
}
Commit	Line	Data
c627d613 AT	1	/*
	2	Copyright (C) Andrew Tridgell 1996
	3	Copyright (C) Paul Mackerras 1996
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	18	*/
	19
	20	/*
	21	Utilities used in rsync
	22
	23	tridge, June 1996
	24	*/
	25	#include "rsync.h"
	26
a5343e76 AT	27	/****************************************************************************
	28	Set a fd into nonblocking mode. Uses POSIX O_NONBLOCK if available,
	29	else
	30	if SYSV use O_NDELAY
	31	if BSD use FNDELAY
	32	****************************************************************************/
	33	int set_nonblocking(int fd)
94481d91	34	{
a5343e76 AT	35	int val;
	36	#ifdef O_NONBLOCK
	37	#define FLAG_TO_SET O_NONBLOCK
	38	#else
	39	#ifdef SYSV
	40	#define FLAG_TO_SET O_NDELAY
	41	#else /* BSD */
	42	#define FLAG_TO_SET FNDELAY
	43	#endif
	44	#endif
	45
	46	if((val = fcntl(fd, F_GETFL, 0)) == -1)
	47	return -1;
	48	val \|= FLAG_TO_SET;
	49	return fcntl( fd, F_SETFL, val);
	50	#undef FLAG_TO_SET
94481d91 AT	51	}
94481d91 AT	52
d9bea2dd	53
c627d613 AT	54	/* this is taken from CVS */
	55	int piped_child(char *command,int f_in,int *f_out)
	56	{
	57	int pid;
	58	int to_child_pipe[2];
	59	int from_child_pipe[2];
	60
	61	if (pipe(to_child_pipe) < 0 \|\|
	62	pipe(from_child_pipe) < 0) {
9486289c	63	rprintf(FERROR,"pipe: %s\n",strerror(errno));
34ccb63e	64	exit_cleanup(1);
c627d613 AT	65	}
	66
	67
3ba62a83	68	pid = do_fork();
c627d613	69	if (pid < 0) {
9486289c	70	rprintf(FERROR,"fork: %s\n",strerror(errno));
34ccb63e	71	exit_cleanup(1);
c627d613 AT	72	}
	73
	74	if (pid == 0)
	75	{
6574b4f7	76	extern int orig_umask;
c627d613 AT	77	if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 \|\|
	78	close(to_child_pipe[1]) < 0 \|\|
	79	close(from_child_pipe[0]) < 0 \|\|
	80	dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
9486289c	81	rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
34ccb63e	82	exit_cleanup(1);
c627d613	83	}
773f2bd4 AT	84	if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
773f2bd4 AT	85	if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
6574b4f7	86	umask(orig_umask);
c627d613	87	execvp(command[0], command);
9486289c	88	rprintf(FERROR,"Failed to exec %s : %s\n",
c627d613	89	command[0],strerror(errno));
34ccb63e	90	exit_cleanup(1);
c627d613 AT	91	}
	92
	93	if (close(from_child_pipe[1]) < 0 \|\|
	94	close(to_child_pipe[0]) < 0) {
9486289c	95	rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
34ccb63e	96	exit_cleanup(1);
c627d613 AT	97	}
	98
	99	*f_in = from_child_pipe[0];
	100	*f_out = to_child_pipe[1];
3eb38818 AT	101
	102	set_nonblocking(*f_in);
	103	set_nonblocking(*f_out);
c627d613 AT	104
	105	return pid;
	106	}
	107
366345fe AT	108	int local_child(int argc, char *argv,int f_in,int *f_out)
	109	{
	110	int pid;
	111	int to_child_pipe[2];
	112	int from_child_pipe[2];
	113
	114	if (pipe(to_child_pipe) < 0 \|\|
	115	pipe(from_child_pipe) < 0) {
9486289c	116	rprintf(FERROR,"pipe: %s\n",strerror(errno));
366345fe AT	117	exit_cleanup(1);
	118	}
	119
	120
	121	pid = do_fork();
	122	if (pid < 0) {
9486289c	123	rprintf(FERROR,"fork: %s\n",strerror(errno));
366345fe AT	124	exit_cleanup(1);
	125	}
	126
	127	if (pid == 0) {
	128	extern int am_sender;
	129	extern int am_server;
	130
	131	am_sender = !am_sender;
	132	am_server = 1;
	133
	134	if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 \|\|
	135	close(to_child_pipe[1]) < 0 \|\|
	136	close(from_child_pipe[0]) < 0 \|\|
	137	dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
9486289c	138	rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
366345fe AT	139	exit_cleanup(1);
	140	}
	141	if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
	142	if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
9486289c	143	start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
366345fe AT	144	}
	145
	146	if (close(from_child_pipe[1]) < 0 \|\|
	147	close(to_child_pipe[0]) < 0) {
9486289c	148	rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
366345fe AT	149	exit_cleanup(1);
	150	}
	151
	152	*f_in = from_child_pipe[0];
	153	*f_out = to_child_pipe[1];
	154
	155	return pid;
	156	}
	157
	158
c627d613 AT	159
	160	void out_of_memory(char *str)
	161	{
9486289c	162	rprintf(FERROR,"ERROR: out of memory in %s\n",str);
575f2fca AT	163	exit_cleanup(1);
	164	}
	165
	166	void overflow(char *str)
	167	{
9486289c	168	rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
34ccb63e	169	exit_cleanup(1);
c627d613 AT	170	}
	171
	172
c627d613 AT	173
	174	int set_modtime(char *fname,time_t modtime)
	175	{
31e12522 AT	176	extern int dry_run;
	177	if (dry_run) return 0;
	178	{
1e9f155a	179	#ifdef HAVE_UTIMBUF
31e12522 AT	180	struct utimbuf tbuf;
	181	tbuf.actime = time(NULL);
	182	tbuf.modtime = modtime;
	183	return utime(fname,&tbuf);
c627d613	184	#elif defined(HAVE_UTIME)
31e12522 AT	185	time_t t[2];
	186	t[0] = time(NULL);
	187	t[1] = modtime;
	188	return utime(fname,t);
c627d613	189	#else
31e12522 AT	190	struct timeval t[2];
	191	t[0].tv_sec = time(NULL);
	192	t[0].tv_usec = 0;
	193	t[1].tv_sec = modtime;
	194	t[1].tv_usec = 0;
	195	return utimes(fname,t);
c627d613	196	#endif
31e12522	197	}
c627d613	198	}
94481d91	199
720b47f2	200
6574b4f7 AT	201	/****************************************************************************
	202	create any necessary directories in fname. Unfortunately we don't know
	203	what perms to give the directory when this is called so we need to rely
	204	on the umask
	205	****************************************************************************/
	206	int create_directory_path(char *fname)
	207	{
	208	extern int orig_umask;
	209	char *p;
	210
	211	while (*fname == '/') fname++;
	212	while (strncmp(fname,"./",2)==0) fname += 2;
	213
	214	p = fname;
	215	while ((p=strchr(p,'/'))) {
	216	*p = 0;
1b2d733a	217	do_mkdir(fname,0777 & ~orig_umask);
6574b4f7 AT	218	*p = '/';
	219	p++;
	220	}
	221	return 0;
	222	}
950ab32d AT	223
	224
	225	/* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
	226	Return LEN upon success, write's (negative) error code otherwise.
	227
	228	derived from GNU C's cccp.c.
	229	*/
a5343e76	230	static int full_write(int desc, char *ptr, int len)
950ab32d AT	231	{
	232	int total_written;
	233
	234	total_written = 0;
	235	while (len > 0) {
	236	int written = write (desc, ptr, len);
	237	if (written < 0) {
	238	#ifdef EINTR
	239	if (errno == EINTR)
	240	continue;
	241	#endif
	242	return written;
	243	}
	244	total_written += written;
	245	ptr += written;
	246	len -= written;
	247	}
	248	return total_written;
	249	}
	250
	251	/* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
	252	Return the actual number of bytes read, zero for EOF, or negative
	253	for an error.
	254
	255	derived from GNU C's cccp.c. */
6e4fb64e	256	static int safe_read(int desc, char *ptr, int len)
950ab32d AT	257	{
	258	int n_chars;
	259
	260	if (len <= 0)
	261	return len;
	262
	263	#ifdef EINTR
	264	do {
	265	n_chars = read(desc, ptr, len);
	266	} while (n_chars < 0 && errno == EINTR);
	267	#else
	268	n_chars = read(desc, ptr, len);
	269	#endif
	270
	271	return n_chars;
	272	}
	273
	274
	275	/* copy a file - this is used in conjunction with the --temp-dir option */
	276	int copy_file(char source, char dest, mode_t mode)
	277	{
	278	int ifd;
	279	int ofd;
	280	char buf[1024 * 8];
	281	int len; /* Number of bytes read into `buf'. */
	282
	283	ifd = open(source, O_RDONLY);
	284	if (ifd == -1) {
9486289c	285	rprintf(FERROR,"open %s: %s\n",
950ab32d AT	286	source,strerror(errno));
	287	return -1;
	288	}
	289
31e12522	290	if (do_unlink(dest) && errno != ENOENT) {
9486289c	291	rprintf(FERROR,"unlink %s: %s\n",
950ab32d AT	292	dest,strerror(errno));
	293	return -1;
	294	}
	295
31e12522	296	ofd = do_open(dest, O_WRONLY \| O_CREAT \| O_TRUNC \| O_EXCL, mode);
c46ded46	297	if (ofd == -1) {
9486289c	298	rprintf(FERROR,"open %s: %s\n",
950ab32d AT	299	dest,strerror(errno));
	300	close(ifd);
	301	return -1;
	302	}
	303
	304	while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
	305	if (full_write(ofd, buf, len) < 0) {
9486289c	306	rprintf(FERROR,"write %s: %s\n",
950ab32d AT	307	dest,strerror(errno));
	308	close(ifd);
	309	close(ofd);
	310	return -1;
	311	}
	312	}
	313
	314	close(ifd);
	315	close(ofd);
	316
	317	if (len < 0) {
9486289c	318	rprintf(FERROR,"read %s: %s\n",
950ab32d AT	319	source,strerror(errno));
	320	return -1;
	321	}
	322
	323	return 0;
	324	}
feaa89c4 AT	325
	326	/* sleep for a while via select */
	327	void u_sleep(int usec)
	328	{
	329	struct timeval tv;
	330
	331	tv.tv_sec = 0;
	332	tv.tv_usec = usec;
	333	select(0, NULL, NULL, NULL, &tv);
	334	}
3ba62a83 AT	335
	336
	337	static pid_t all_pids[10];
	338	static int num_pids;
	339
	340	/* fork and record the pid of the child */
	341	pid_t do_fork(void)
	342	{
	343	pid_t newpid = fork();
	344
	345	if (newpid) {
	346	all_pids[num_pids++] = newpid;
	347	}
	348	return newpid;
	349	}
	350
	351	/* kill all children */
	352	void kill_all(int sig)
	353	{
	354	int i;
	355	for (i=0;i<num_pids;i++) {
	356	if (all_pids[i] != getpid())
	357	kill(all_pids[i], sig);
	358	}
	359	}
9486289c	360
7a6421fa AT	361	/* like strncpy but does not 0 fill the buffer and always null
	362	terminates (thus it can use maxlen+1 space in d) */
	363	void strlcpy(char d, char s, int maxlen)
	364	{
	365	int len = strlen(s);
	366	if (len > maxlen) len = maxlen;
	367	memcpy(d, s, len);
	368	d[len] = 0;
	369	}
8ef4ffd6	370
e42c9458 AT	371	/* like strncat but does not 0 fill the buffer and always null
	372	terminates (thus it can use maxlen+1 space in d) */
	373	void strlcat(char d, char s, int maxlen)
	374	{
	375	int len1 = strlen(d);
	376	int len2 = strlen(s);
	377	if (len1+len2 > maxlen) {
	378	len2 = maxlen-len1;
	379	}
	380	if (len2 > 0) {
	381	memcpy(d+len1, s, len2);
	382	d[len1+len2] = 0;
	383	}
	384	}
	385
8ef4ffd6 AT	386	/* turn a user name into a uid */
	387	int name_to_uid(char name, uid_t uid)
	388	{
	389	struct passwd *pass;
	390	if (!name \|\| !*name) return 0;
	391	pass = getpwnam(name);
	392	if (pass) {
	393	*uid = pass->pw_uid;
	394	return 1;
	395	}
	396	return 0;
	397	}
	398
	399	/* turn a group name into a gid */
	400	int name_to_gid(char name, gid_t gid)
	401	{
	402	struct group *grp;
	403	if (!name \|\| !*name) return 0;
	404	grp = getgrnam(name);
	405	if (grp) {
	406	*gid = grp->gr_gid;
	407	return 1;
	408	}
	409	return 0;
	410	}
	411
ff8b29b8	412
31593dd6 AT	413	/* lock a byte range in a open file */
31593dd6 AT	414	int lock_range(int fd, int offset, int len)
0c515f17	415	{
31593dd6	416	struct flock lock;
0c515f17	417
31593dd6 AT	418	lock.l_type = F_WRLCK;
	419	lock.l_whence = SEEK_SET;
	420	lock.l_start = offset;
	421	lock.l_len = len;
	422	lock.l_pid = 0;
	423
	424	return fcntl(fd,F_SETLK,&lock) == 0;
0c515f17	425	}
874895d5 AT	426
874895d5 AT	427
087bf010	428	static void glob_expand_one(char s, char argv, int argc, int maxargs)
874895d5 AT	429	{
874895d5 AT	430	#ifndef HAVE_GLOB
e42c9458	431	if (!*s) s = ".";
087bf010	432	argv[*argc] = strdup(s);
874895d5 AT	433	(*argc)++;
	434	return;
	435	#else
	436	glob_t globbuf;
	437	int i;
	438
e42c9458 AT	439	if (!*s) s = ".";
e42c9458 AT	440
087bf010 AT	441	argv[*argc] = strdup(s);
087bf010 AT	442
874895d5 AT	443	memset(&globbuf, 0, sizeof(globbuf));
	444	glob(argv[*argc], 0, NULL, &globbuf);
	445	if (globbuf.gl_pathc == 0) {
	446	(*argc)++;
	447	globfree(&globbuf);
	448	return;
	449	}
	450	for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
	451	if (i == 0) free(argv[*argc]);
	452	argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
	453	if (!argv[(*argc) + i]) out_of_memory("glob_expand");
	454	}
	455	globfree(&globbuf);
	456	(*argc) += i;
	457	#endif
	458	}
5a96ee05	459
ba5e128d	460	void glob_expand(char base1, char argv, int argc, int maxargs)
087bf010 AT	461	{
	462	char s = argv[argc];
	463	char p, q;
ba5e128d	464	char *base = base1;
087bf010 AT	465
	466	if (!s \|\| !*s) return;
	467
e42c9458 AT	468	if (strncmp(s, base, strlen(base)) == 0) {
	469	s += strlen(base);
	470	}
	471
087bf010 AT	472	s = strdup(s);
	473	if (!s) out_of_memory("glob_expand");
	474
ba5e128d AT	475	base = (char *)malloc(strlen(base1)+3);
	476	if (!base) out_of_memory("glob_expand");
	477
	478	sprintf(base," %s/", base1);
	479
087bf010 AT	480	q = s;
087bf010 AT	481	while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
ba5e128d AT	482	/* split it at this point */
	483	*p = 0;
	484	glob_expand_one(q, argv, argc, maxargs);
	485	q = p+strlen(base);
087bf010 AT	486	}
	487
	488	if (q && (argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
	489
	490	free(s);
ba5e128d	491	free(base);
087bf010	492	}
5a96ee05 AT	493
	494	/*******************************************************************
	495	convert a string to lower case
	496	********************************************************************/
	497	void strlower(char *s)
	498	{
	499	while (*s) {
	500	if (isupper(s)) s = tolower(*s);
	501	s++;
	502	}
	503	}
e42c9458 AT	504
	505	/* this is like vsnprintf but the 'n' limit does not include
	506	the terminating null. So if you have a 1024 byte buffer then
	507	pass 1023 for n */
	508	int vslprintf(char str, int n, const char format, va_list ap)
	509	{
	510	#ifdef HAVE_VSNPRINTF
	511	int ret = vsnprintf(str, n, format, ap);
	512	if (ret > n \|\| ret < 0) {
	513	str[n] = 0;
	514	return -1;
	515	}
	516	str[ret] = 0;
	517	return ret;
	518	#else
	519	static char *buf;
	520	static int len=MAXPATHLEN*8;
	521	int ret;
	522
	523	/* this code is NOT a proper vsnprintf() implementation. It
	524	relies on the fact that all calls to slprintf() in rsync
	525	pass strings which have already been checked to be less
	526	than MAXPATHLEN in length and never more than 2 strings are
	527	concatenated. This means the above buffer is absolutely
	528	ample and can never be overflowed.
	529
	530	In the future we would like to replace this with a proper
	531	vsnprintf() implementation but right now we need a solution
	532	that is secure and portable. This is it. */
	533
	534	if (!buf) {
	535	buf = malloc(len);
	536	if (!buf) {
	537	/* can't call debug or we would recurse */
8d9dc9f9	538	exit_cleanup(1);
e42c9458 AT	539	}
	540	}
	541
f72399f8 AT	542	vsprintf(buf, format, ap);
	543	ret = strlen(buf);
	544	if (ret > n) {
	545	/* yikes! */
8d9dc9f9	546	exit_cleanup(1);
e42c9458	547	}
f72399f8	548	buf[ret] = 0;
e42c9458	549
f72399f8	550	memcpy(str, buf, ret+1);
e42c9458 AT	551
	552	return ret;
	553	#endif
	554	}
	555
	556
	557	/* like snprintf but always null terminates */
	558	int slprintf(char str, int n, char format, ...)
	559	{
	560	va_list ap;
	561	int ret;
	562
	563	va_start(ap, format);
	564	ret = vslprintf(str,n,format,ap);
	565	va_end(ap);
	566	return ret;
	567	}
8d9dc9f9	568
fe8c0a98 AT	569
	570	void Realloc(void p, int size)
	571	{
	572	if (!p) return (void *)malloc(size);
	573	return (void *)realloc(p, size);
	574	}
5243c216 AT	575
	576
	577	void clean_fname(char *name)
	578	{
	579	char *p;
	580	int l;
	581	int modified = 1;
	582
	583	if (!name) return;
	584
	585	while (modified) {
	586	modified = 0;
	587
	588	if ((p=strstr(name,"/./"))) {
	589	modified = 1;
	590	while (*p) {
	591	p[0] = p[2];
	592	p++;
	593	}
	594	}
	595
	596	if ((p=strstr(name,"//"))) {
	597	modified = 1;
	598	while (*p) {
	599	p[0] = p[1];
	600	p++;
	601	}
	602	}
	603
	604	if (strncmp(p=name,"./",2) == 0) {
	605	modified = 1;
	606	do {
	607	p[0] = p[2];
	608	} while (*p++);
	609	}
	610
	611	l = strlen(p=name);
	612	if (l > 1 && p[l-1] == '/') {
	613	modified = 1;
	614	p[l-1] = 0;
	615	}
	616	}
	617	}
	618
	619
	620	static char curr_dir[MAXPATHLEN];
	621
	622	/* like chdir() but can be reversed with pop_dir() if save is set. It
	623	is also much faster as it remembers where we have been */
	624	char push_dir(char dir, int save)
	625	{
	626	char *ret = curr_dir;
	627	static int initialised;
	628
	629	if (!initialised) {
	630	initialised = 1;
	631	getcwd(curr_dir, sizeof(curr_dir)-1);
	632	}
	633
	634	if (chdir(dir)) return NULL;
	635
	636	if (save) {
	637	ret = strdup(curr_dir);
	638	}
639
640	if (*dir == '/') {
641	strlcpy(curr_dir, dir, sizeof(curr_dir)-1);
642	} else {
643	strlcat(curr_dir,"/", sizeof(curr_dir)-1);
644	strlcat(curr_dir,dir, sizeof(curr_dir)-1);
645	}
646
647	clean_fname(curr_dir);
648
649	return ret;
650	}
651
652	/* reverse a push_dir call */
653	int pop_dir(char *dir)
654	{
655	int ret;
656
657	ret = chdir(dir);
658	if (ret) {
659	free(dir);
660	return ret;
661	}
662
663	strlcpy(curr_dir, dir, sizeof(curr_dir)-1);
664
665	free(dir);
666
667	return 0;
668	}
aa9b77a5 AT	669
	670	/* we need to supply our own strcmp function for file list comparisons
	671	to ensure that signed/unsigned usage is consistent between machines. */
	672	int u_strcmp(const char cs1, const char cs2)
	673	{
	674	const uchar s1 = (uchar )cs1;
	675	const uchar s2 = (uchar )cs2;
	676
	677	while (s1 && s2 && (s1 == s2)) {
	678	s1++; s2++;
	679	}
	680
	681	return (int)s1 - (int)s2;
	682	}
eb86d661	683
43b06eea	684	static OFF_T last_ofs;
eb86d661 AT	685
	686	void end_progress(void)
	687	{
	688	extern int do_progress, am_server;
	689
	690	if (do_progress && !am_server) {
	691	rprintf(FINFO,"\n");
	692	}
43b06eea	693	last_ofs = 0;
eb86d661 AT	694	}
	695
	696	void show_progress(OFF_T ofs, OFF_T size)
	697	{
	698	extern int do_progress, am_server;
	699
	700	if (do_progress && !am_server) {
43b06eea AT	701	if (ofs > last_ofs + 1000) {
43b06eea AT	702	int pct = (int)((100.0*ofs)/size);
eb86d661	703	rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
43b06eea	704	last_ofs = ofs;
eb86d661 AT	705	}
	706	}
	707	}
4b957c22 AT	708
	709	/* determine if a symlink points outside the current directory tree */
	710	int unsafe_symlink(char dest, char src)
	711	{
	712	char *tok;
	713	int depth = 0;
	714
	715	/* all absolute and null symlinks are unsafe */
	716	if (!dest \|\| !(dest) \|\| (dest == '/')) return 1;
	717
	718	src = strdup(src);
	719	if (!src) out_of_memory("unsafe_symlink");
	720
	721	/* find out what our safety margin is */
	722	for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
	723	if (strcmp(tok,"..") == 0) {
	724	depth=0;
	725	} else if (strcmp(tok,".") == 0) {
	726	/* nothing */
	727	} else {
	728	depth++;
	729	}
	730	}
	731	free(src);
	732
	733	/* drop by one to account for the filename portion */
	734	depth--;
	735
	736	dest = strdup(dest);
	737	if (!dest) out_of_memory("unsafe_symlink");
	738
	739	for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
	740	if (strcmp(tok,"..") == 0) {
	741	depth--;
	742	} else if (strcmp(tok,".") == 0) {
	743	/* nothing */
	744	} else {
	745	depth++;
	746	}
	747	/* if at any point we go outside the current directory then
	748	stop - it is unsafe */
	749	if (depth < 0) break;
	750	}
	751
	752	free(dest);
	753	return (depth < 0);
	754	}