util.c

Utilities used in rsync [詳細]

ソースコードを見る。

データ構造
struct	bitbag
関数
void	set_nonblocking (int fd)
	Set a fd into nonblocking mode
void	set_blocking (int fd)
	Set a fd into blocking mode
int	fd_pair (int fd[2])
	Create a file descriptor pair - like pipe() but use socketpair if possible (because of blocking issues on pipes).
void	print_child_argv (char **cmd)
void	out_of_memory (char *str)
void	overflow_exit (char *str)
int	set_modtime (char *fname, time_t modtime, mode_t mode)
int	mkdir_defmode (char *fname)
int	create_directory_path (char *fname)
int	full_write (int desc, char *ptr, size_t len)
	Write len bytes at ptr to descriptor desc, retrying if interrupted.
static int	safe_read (int desc, char *ptr, size_t len)
	Read len bytes at ptr from descriptor desc, retrying if interrupted.
int	copy_file (const char *source, const char *dest, mode_t mode)
	Copy a file.
int	robust_unlink (const char *fname)
	Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so rename to <path>/.rsyncNNN instead.
int	robust_rename (char *from, char *to, char *partialptr, int mode)
pid_t	do_fork (void)
	Fork and record the pid of the child.
void	kill_all (int sig)
	Kill all children.
int	name_to_uid (char *name, uid_t *uid)
	Turn a user name into a uid
int	name_to_gid (char *name, gid_t *gid)
	Turn a group name into a gid
int	lock_range (int fd, int offset, int len)
	Lock a byte range in a open file
static int	filter_server_path (char *arg)
static void	glob_expand_one (char *s, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
void	glob_expand (char *base1, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
void	strlower (char *s)
	Convert a string to lower case
size_t	pathjoin (char *dest, size_t destsize, const char *p1, const char *p2)
size_t	stringjoin (char *dest, size_t destsize,...)
int	count_dir_elements (const char *p)
unsigned int	clean_fname (char *name, BOOL collapse_dot_dot)
char *	sanitize_path (char *dest, const char *p, const char *rootdir, int depth)
int	push_dir (char *dir)
	Like chdir(), but it keeps track of the current directory (in the global "curr_dir"), and ensures that the path size doesn't overflow.
int	pop_dir (char *dir)
	Reverse a push_dir() call.
char *	full_fname (const char *fn)
	Return a quoted string with the full pathname of the indicated filename.
char *	partial_dir_fname (const char *fname)
int	handle_partial_dir (const char *fname, int create)
int	unsafe_symlink (const char *dest, const char *src)
	Determine if a symlink points outside the current directory tree.
char *	human_num (int64 num)
char *	human_dnum (double dnum, int decimal_digits)
char *	timestring (time_t t)
	Return the date and time as a string
int	msleep (int t)
	Sleep for a specified number of milliseconds.
int	cmp_time (time_t file1, time_t file2)
int	_Insure_trap_error (int a1, int a2, int a3, int a4, int a5, int a6)
	This routine is a trick to immediately catch errors when debugging with insure.
void *	_new_array (unsigned int size, unsigned long num)
void *	_realloc_array (void *ptr, unsigned int size, unsigned long num)
const char *	find_filename_suffix (const char *fn, int fn_len, int *len_ptr)
uint32	fuzzy_distance (const char *s1, int len1, const char *s2, int len2)
bitbag *	bitbag_create (int max_ndx)
void	bitbag_set_bit (struct bitbag *bb, int ndx)
void	bitbag_clear_bit (struct bitbag *bb, int ndx)
int	bitbag_check_bit (struct bitbag *bb, int ndx)
int	bitbag_next_bit (struct bitbag *bb, int after)
変数
int	verbose
int	dry_run
int	module_id
int	modify_window
int	relative_paths
int	human_readable
mode_t	orig_umask
char *	partial_dir
filter_list_struct	server_filter_list
int	sanitize_paths = 0
static pid_t	all_pids [10]
static int	num_pids
char	curr_dir [MAXPATHLEN]
unsigned int	curr_dir_len
static char	partial_fname [MAXPATHLEN]

---

説明

Utilities used in rsync

util.c で定義されています。

---

関数

void set_nonblocking

(

int

fd

)

Set a fd into nonblocking mode

util.c の 47 行で定義されています。

{
        int val;

        if ((val = fcntl(fd, F_GETFL, 0)) == -1)
                return;
        if (!(val & NONBLOCK_FLAG)) {
                val |= NONBLOCK_FLAG;
                fcntl(fd, F_SETFL, val);
        }
}

void set_blocking

(

int

fd

)

Set a fd into blocking mode

util.c の 62 行で定義されています。

{
        int val;

        if ((val = fcntl(fd, F_GETFL, 0)) == -1)
                return;
        if (val & NONBLOCK_FLAG) {
                val &= ~NONBLOCK_FLAG;
                fcntl(fd, F_SETFL, val);
        }
}

int fd_pair

(

int

fd[2]

)

Create a file descriptor pair - like pipe() but use socketpair if possible (because of blocking issues on pipes).

Always set non-blocking.

util.c の 80 行で定義されています。

参照先 set_nonblocking().

参照元 do_cmd()・do_recv()・local_child()・piped_child().

{
        int ret;

#ifdef HAVE_SOCKETPAIR
        ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
#else
        ret = pipe(fd);
#endif

        if (ret == 0) {
                set_nonblocking(fd[0]);
                set_nonblocking(fd[1]);
        }

        return ret;
}

void print_child_argv

(

char **

cmd

)

util.c の 98 行で定義されています。

参照先 FINFO・rprintf().

参照元 piped_child()・start_inband_exchange().

{
        rprintf(FINFO, "opening connection using ");
        for (; *cmd; cmd++) {
                /* Look for characters that ought to be quoted.  This
                * is not a great quoting algorithm, but it's
                * sufficient for a log message. */
                if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
                           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                           "0123456789"
                           ",.-_=+@/") != strlen(*cmd)) {
                        rprintf(FINFO, "\"%s\" ", *cmd);
                } else {
                        rprintf(FINFO, "%s ", *cmd);
                }
        }
        rprintf(FINFO, "\n");
}

void out_of_memory

(

char *

str

)

util.c の 117 行で定義されています。

参照先 FERROR・rprintf().

参照元 access_match()・add_rule()・add_to_list()・auth_server()・bitbag_create()・bitbag_set_bit()・build_hash_table()・do_cmd()・expand_file_acl_index_list()・expand_ida_list()・expand_rsync_acl_list()・expand_smb_acl_list()・finish_pre_exec()・flist_expand()・flist_ndx_push()・flist_new()・get_checksum2()・glob_expand()・glob_expand_one()・init_hard_links()・io_start_buffering_in()・io_start_buffering_out()・is_in_group()・link_idev_data()・make_file()・map_file()・map_ptr()・msg_list_add()・open_socket_in()・parse_size_arg()・push_local_filters()・readfd_unbuffered()・receive_sums()・receive_xattr()・recv_deflated_token()・recv_file_list()・recv_uid_list()・rsync_module()・rsync_xal_get()・rsync_xal_store()・sanitize_path()・send_deflated_token()・server_options()・set_compression()・set_socket_options()・simple_recv_token()・write_file().

{
        rprintf(FERROR, "ERROR: out of memory in %s\n", str);
        exit_cleanup(RERR_MALLOC);
}

void overflow_exit

(

char *

str

)

util.c の 123 行で定義されています。

参照先 FERROR・rprintf().

参照元 receive_file_entry()・recv_filter_list()・send_file_list().

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

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

util.c の 129 行で定義されています。

参照先 dry_run・FINFO・rprintf()・verbose.

参照元 set_file_attrs().

{
#if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
        if (S_ISLNK(mode))
                return 1;
#endif

        if (verbose > 2) {
                rprintf(FINFO, "set modtime of %s to (%ld) %s",
                        fname, (long)modtime,
                        asctime(localtime(&modtime)));
        }

        if (dry_run)
                return 0;

        {
#ifdef HAVE_UTIMES
                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;
# ifdef HAVE_LUTIMES
                if (S_ISLNK(mode))
                        return lutimes(fname, t);
# endif
                return utimes(fname, t);
#elif defined 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
#error No file-time-modification routine found!
#endif
        }
}

int mkdir_defmode

(

char *

fname

)

util.c の 176 行で定義されています。

参照先 do_mkdir()・orig_umask.

参照元 get_local_name()・make_bak_dir().

{
        int ret;

        umask(orig_umask);
        ret = do_mkdir(fname, ACCESSPERMS);
        umask(0);

        return ret;
}

int create_directory_path

(

char *

fname

)

util.c の 189 行で定義されています。

参照先 do_mkdir()・errno・orig_umask.

参照元 recv_files()・recv_generator().

{
        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';
                if (do_mkdir(fname, ACCESSPERMS) < 0 && errno != EEXIST)
                    ret = -1;
                *p++ = '/';
        }
        umask(0);

        return ret;
}

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

Write len bytes at ptr to descriptor desc, retrying if interrupted.

戻り値:

	len	upon success
	<0	write's (negative) error code

Derived from GNU C's cccp.c.

util.c の 222 行で定義されています。

参照先 errno・total_written.

参照元 copy_file()・generate_and_send_sums().

{
        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
	)			[static]

Read len bytes at ptr from descriptor desc, retrying if interrupted.

戻り値:

	>0	the actual number of bytes read
	0	for EOF
	<0	for an error.

Derived from GNU C's cccp.c.

util.c の 252 行で定義されています。

参照先 errno.

参照元 copy_file().

{
        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,
		mode_t	mode
	)

Copy a file.

This is used in conjunction with the --temp-dir, --backup, and --copy-dest options.

util.c の 270 行で定義されています。

参照先 buf・do_open()・errno・FERROR・FINFO・full_fname()・full_write()・robust_unlink()・rsyserr()・safe_read().

参照元 robust_rename()・try_dests_reg().

{
        int ifd;
        int ofd;
        char buf[1024 * 8];
        int len;   /* Number of bytes read into `buf'. */

        ifd = do_open(source, O_RDONLY, 0);
        if (ifd == -1) {
                rsyserr(FERROR, errno, "open %s", full_fname(source));
                return -1;
        }

        if (robust_unlink(dest) && errno != ENOENT) {
                rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
                return -1;
        }

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

        while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
                if (full_write(ofd, buf, len) < 0) {
                        rsyserr(FERROR, errno, "write %s", full_fname(dest));
                        close(ifd);
                        close(ofd);
                        return -1;
                }
        }

        if (len < 0) {
                rsyserr(FERROR, errno, "read %s", full_fname(source));
                close(ifd);
                close(ofd);
                return -1;
        }

        if (close(ifd) < 0) {
                rsyserr(FINFO, errno, "close failed on %s",
                        full_fname(source));
        }

        if (close(ofd) < 0) {
                rsyserr(FERROR, errno, "close failed on %s",
                        full_fname(dest));
                return -1;
        }

        return 0;
}

int robust_unlink

(

const char *

fname

)

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.

util.c の 339 行で定義されています。

参照先 do_rename()・do_unlink()・errno・FINFO・rprintf()・sprintf()・strlcpy()・verbose.

参照元 copy_file()・delete_item()・keep_backup()・maybe_hard_link()・recv_generator()・robust_rename().

{
#ifndef ETXTBSY
        return do_unlink(fname);
#else
        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 {
                sprintf(&path[pos], "%03d", counter);
                if (++counter >= MAX_RENAMES)
                        counter = 1;
        } while ((rc = access(path, 0)) == 0 && counter != start);

        if (verbose > 0) {
                rprintf(FINFO,"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;
#endif
}

int robust_rename	(	char *	from,
		char *	to,
		char *	partialptr,
		int	mode
	)

util.c の 390 行で定義されています。

参照先 copy_file()・do_rename()・do_unlink()・errno・handle_partial_dir()・robust_unlink().

参照元 finish_transfer()・robust_move().

{
        int tries = 4;

        while (tries--) {
                if (do_rename(from, to) == 0)
                        return 0;

                switch (errno) {
#ifdef ETXTBSY
                case ETXTBSY:
                        if (robust_unlink(to) != 0)
                                return -1;
                        break;
#endif
                case EXDEV:
                        if (partialptr) {
                                if (!handle_partial_dir(partialptr,PDIR_CREATE))
                                        return -1;
                                to = partialptr;
                        }
                        if (copy_file(from, to, mode) != 0)
                                return -2;
                        do_unlink(from);
                        return 1;
                default:
                        return -1;
                }
        }
        return -1;
}

pid_t do_fork

(

void

)

Fork and record the pid of the child.

util.c の 427 行で定義されています。

参照先 all_pids・num_pids.

参照元 do_recv()・local_child()・piped_child().

{
        pid_t newpid = fork();

        if (newpid != 0  &&  newpid != -1) {
                all_pids[num_pids++] = newpid;
        }
        return newpid;
}

void kill_all

(

int

sig

)

Kill all children.

TODO:

It would be kind of nice to make sure that they are actually all our children before we kill them, because their pids may have been recycled by some other process. Perhaps when we wait for a child, we should remove it from this array. Alternatively we could perhaps use process groups, but I think that would not work on ancient Unix versions that don't support them.

util.c の 447 行で定義されています。

参照先 all_pids・num_pids.

参照元 _exit_cleanup().

{
        int i;

        for (i = 0; i < num_pids; i++) {
                /* Let's just be a little careful where we
                 * point that gun, hey?  See kill(2) for the
                 * magic caused by negative values. */
                pid_t p = all_pids[i];

                if (p == getpid())
                        continue;
                if (p <= 0)
                        continue;

                kill(p, sig);
        }
}

int name_to_uid	(	char *	name,
		uid_t *	uid
	)

Turn a user name into a uid

util.c の 467 行で定義されています。

参照元 map_uid()・rsync_module().

{
        struct passwd *pass;
        if (!name || !*name)
                return 0;
        pass = getpwnam(name);
        if (pass) {
                *uid = pass->pw_uid;
                return 1;
        }
        return 0;
}

int name_to_gid	(	char *	name,
		gid_t *	gid
	)

Turn a group name into a gid

util.c の 481 行で定義されています。

参照元 map_gid()・rsync_module().

{
        struct group *grp;
        if (!name || !*name)
                return 0;
        grp = getgrnam(name);
        if (grp) {
                *gid = grp->gr_gid;
                return 1;
        }
        return 0;
}

int lock_range	(	int	fd,
		int	offset,
		int	len
	)

Lock a byte range in a open file

util.c の 495 行で定義されています。

参照元 claim_connection().

{
        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 int filter_server_path

(

char *

arg

)

[static]

util.c の 508 行で定義されています。

参照先 check_filter()・filter_list_struct::head・server_filter_list.

参照元 glob_expand_one().

{
        char *s;

        if (server_filter_list.head) {
                for (s = arg; (s = strchr(s, '/')) != NULL; ) {
                        *s = '\0';
                        if (check_filter(&server_filter_list, arg, 1) < 0) {
                                /* We must leave arg truncated! */
                                return 1;
                        }
                        *s++ = '/';
                }
        }
        return 0;
}

static void glob_expand_one	(	char *	s,
		char ***	argv_ptr,
		int *	argc_ptr,
		int *	maxargs_ptr
	)			[static]

util.c の 525 行で定義されています。

参照先 filter_server_path()・out_of_memory()・sanitize_path()・sanitize_paths・strdup().

参照元 glob_expand().

{
        char **argv = *argv_ptr;
        int argc = *argc_ptr;
        int maxargs = *maxargs_ptr;
#if !defined HAVE_GLOB || !defined HAVE_GLOB_H
        if (argc == maxargs) {
                maxargs += MAX_ARGS;
                if (!(argv = realloc_array(argv, char *, maxargs)))
                        out_of_memory("glob_expand_one");
                *argv_ptr = argv;
                *maxargs_ptr = maxargs;
        }
        if (!*s)
                s = ".";
        s = argv[argc++] = strdup(s);
        filter_server_path(s);
#else
        glob_t globbuf;

        if (maxargs <= argc)
                return;
        if (!*s)
                s = ".";

        if (sanitize_paths)
                s = sanitize_path(NULL, s, "", 0);
        else
                s = strdup(s);

        memset(&globbuf, 0, sizeof globbuf);
        if (!filter_server_path(s))
                glob(s, 0, NULL, &globbuf);
        if (MAX((int)globbuf.gl_pathc, 1) > maxargs - argc) {
                maxargs += globbuf.gl_pathc + MAX_ARGS;
                if (!(argv = realloc_array(argv, char *, maxargs)))
                        out_of_memory("glob_expand_one");
                *argv_ptr = argv;
                *maxargs_ptr = maxargs;
        }
        if (globbuf.gl_pathc == 0)
                argv[argc++] = s;
        else {
                int i;
                free(s);
                for (i = 0; i < (int)globbuf.gl_pathc; i++) {
                        if (!(argv[argc++] = strdup(globbuf.gl_pathv[i])))
                                out_of_memory("glob_expand_one");
                }
        }
        globfree(&globbuf);
#endif
        *argc_ptr = argc;
}

void glob_expand	(	char *	base1,
		char ***	argv_ptr,
		int *	argc_ptr,
		int *	maxargs_ptr
	)

util.c の 582 行で定義されています。

参照先 asprintf()・glob_expand_one()・out_of_memory()・strdup().

参照元 rsync_module().

{
        char *s = (*argv_ptr)[*argc_ptr];
        char *p, *q;
        char *base = base1;
        int base_len = strlen(base);

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

        if (strncmp(s, base, base_len) == 0)
                s += base_len;

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

        if (asprintf(&base," %s/", base1) <= 0)
                out_of_memory("glob_expand");
        base_len++;

        for (q = s; *q; q = p + base_len) {
                if ((p = strstr(q, base)) != NULL)
                        *p = '\0'; /* split it at this point */
                glob_expand_one(q, argv_ptr, argc_ptr, maxargs_ptr);
                if (!p)
                        break;
        }

        free(s);
        free(base);
}

void strlower

(

char *

s

)

Convert a string to lower case

util.c の 617 行で定義されています。

参照元 access_match().

{
        while (*s) {
                if (isupper(*(unsigned char *)s))
                        *s = tolower(*(unsigned char *)s);
                s++;
        }
}

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

util.c の 630 行で定義されています。

参照先 strlcpy().

参照元 get_cvs_excludes()・hard_link_check()・log_formatted()・partial_dir_fname()・recv_files()・setup_merge_file()・try_dests_non()・try_dests_reg().

{
        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,
			...
	)

util.c の 652 行で定義されています。

参照元 establish_proxy_connection()・get_backup_name()・successful_send()・write_batch_shell_file().

{
        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

)

util.c の 678 行で定義されています。

参照元 receive_file_entry()・set_filter_dir().

{
        int cnt = 0, new_component = 1;
        while (*p) {
                if (*p++ == '/')
                        new_component = 1;
                else if (new_component) {
                        new_component = 0;
                        cnt++;
                }
        }
        return cnt;
}

unsigned int clean_fname	(	char *	name,
		BOOL	collapse_dot_dot
	)

util.c の 696 行で定義されています。

参照元 log_formatted()・make_file()・parse_arguments()・parse_filter_file()・parse_merge_name()・push_dir()・receive_file_entry()・set_filter_dir()・setup_merge_file().

{
        char *limit = name - 1, *t = name, *f = name;
        int anchored;

        if (!name)
                return 0;

        if ((anchored = *f == '/') != 0)
                *t++ = *f++;
        while (*f) {
                /* discard extra slashes */
                if (*f == '/') {
                        f++;
                        continue;
                }
                if (*f == '.') {
                        /* discard "." dirs (but NOT a trailing '.'!) */
                        if (f[1] == '/') {
                                f += 2;
                                continue;
                        }
                        /* collapse ".." dirs */
                        if (collapse_dot_dot
                            && 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] == '/')
                t--;
        if (t == name)
                *t++ = '.';
        *t = '\0';

        return t - name;
}

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

util.c の 769 行で定義されています。

参照先 lp_path()・module_id・out_of_memory()・relative_paths.

参照元 glob_expand_one()・make_file()・parse_arguments()・parse_merge_name()・receive_file_entry()・send_file_list().

{
        char *start, *sanp;
        int rlen = 0, leave_one_dotdir = relative_paths;

        if (dest != p) {
                int plen = strlen(p);
                if (*p == '/') {
                        if (!rootdir)
                                rootdir = lp_path(module_id);
                        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++] = '/';
                }
        }

        start = sanp = dest + rlen;
        while (*p != '\0') {
                /* discard leading or extra slashes */
                if (*p == '/') {
                        p++;
                        continue;
                }
                /* this loop iterates once per filename component in p.
                 * both p (and sanp if the original had a slash) should
                 * always be left pointing after a slash
                 */
                if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
                        if (leave_one_dotdir && p[1])
                                leave_one_dotdir = 0;
                        else {
                                /* 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] != '/') {
                                                /* skip back up to slash */
                                                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 push_dir

(

char *

dir

)

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.

util.c の 854 行で定義されています。

参照先 clean_fname()・curr_dir・curr_dir_len・getcwd().

参照元 do_server_recv()・do_server_sender()・get_local_name()・main()・rsync_module()・send_file_list().

{
        static int initialised;
        unsigned int len;

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

        if (!dir)       /* this call was probably just to initialize */
                return 0;

        len = strlen(dir);
        if (len == 1 && *dir == '.')
                return 1;

        if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
                return 0;

        if (chdir(dir))
                return 0;

        if (*dir == '/') {
                memcpy(curr_dir, dir, len + 1);
                curr_dir_len = len;
        } else {
                curr_dir[curr_dir_len++] = '/';
                memcpy(curr_dir + curr_dir_len, dir, len + 1);
                curr_dir_len += len;
        }

        curr_dir_len = clean_fname(curr_dir, 1);

        return 1;
}

int pop_dir

(

char *

dir

)

Reverse a push_dir() call.

You must pass in an absolute path that was copied from a prior value of "curr_dir".

util.c の 896 行で定義されています。

参照先 curr_dir・curr_dir_len・strlcpy().

参照元 send_file_list().

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

        return 1;
}

char* full_fname

(

const char *

fn

)

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.

util.c の 913 行で定義されています。

参照先 asprintf()・curr_dir・lp_name()・lp_path()・lp_use_chroot()・module_id.

参照元 copy_file()・delete_item()・do_server_recv()・do_server_sender()・finish_transfer()・generate_files()・get_local_name()・handle_delayed_updates()・hard_link_check()・hard_link_one()・keep_backup()・main()・make_bak_dir()・make_file()・maybe_hard_link()・receive_data()・recv_files()・recv_generator()・send_directory()・send_file_list()・send_files()・send_if_directory()・set_file_attrs()・try_dests_reg().

{
        static char *result = NULL;
        char *m1, *m2, *m3;
        char *p1, *p2;

        if (result)
                free(result);

        if (*fn == '/')
                p1 = p2 = "";
        else {
                p1 = curr_dir;
                for (p2 = p1; *p2 == '/'; p2++) {}
                if (*p2)
                        p2 = "/";
        }
        if (module_id >= 0) {
                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);

        return result;
}

char* partial_dir_fname

(

const char *

fname

)

util.c の 951 行で定義されています。

参照先 check_filter()・filter_list_struct::head・partial_dir・pathjoin()・server_filter_list.

参照元 handle_delayed_updates()・recv_files()・recv_generator().

{
        char *t = partial_fname;
        int sz = sizeof partial_fname;
        const char *fn;

        if ((fn = strrchr(fname, '/')) != NULL) {
                fn++;
                if (*partial_dir != '/') {
                        int len = fn - fname;
                        strncpy(t, fname, len); /* safe */
                        t += len;
                        sz -= len;
                }
        } else
                fn = fname;
        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';
                if (check_filter(&server_filter_list, partial_fname, 1) < 0)
                        return NULL;
                t[len] = '/';
                if (check_filter(&server_filter_list, partial_fname, 0) < 0)
                        return NULL;
        }

        return partial_fname;
}

int handle_partial_dir	(	const char *	fname,
		int	create
	)

util.c の 986 行で定義されています。

参照先 do_lstat()・do_mkdir()・do_rmdir()・do_unlink()・partial_dir.

参照元 _exit_cleanup()・finish_transfer()・handle_delayed_updates()・recv_files()・recv_generator()・robust_rename().

{
        char *fn, *dir;

        if (fname != partial_fname)
                return 1;
        if (!create && *partial_dir == '/')
                return 1;
        if (!(fn = strrchr(partial_fname, '/')))
                return 1;

        *fn = '\0';
        dir = partial_fname;
        if (create) {
                STRUCT_STAT st;
                int statret = do_lstat(dir, &st);
                if (statret == 0 && !S_ISDIR(st.st_mode)) {
                        if (do_unlink(dir) < 0)
                                return 0;
                        statret = -1;
                }
                if (statret < 0 && do_mkdir(dir, 0700) < 0)
                        return 0;
        } else
                do_rmdir(dir);
        *fn = '/';

        return 1;
}

int unsafe_symlink	(	const char *	dest,
		const char *	src
	)

Determine if a symlink points outside the current directory tree.

This is considered "unsafe" because e.g. when mirroring somebody 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.

引数:

	dest	Target of the symlink in question.
	src	Top source directory currently applicable. Basically this is the first parameter to rsync in a simple invocation, but it's modified by flist.c in slightly complex ways.

戻り値:

	True	if unsafe
	False	is unsafe

参照:

t_unsafe.c

util.c の 1040 行で定義されています。

参照先 name.

参照元 keep_backup()・main()・readlink_stat()・recv_generator().

{
        const char *name, *slash;
        int depth = 0;

        /* all absolute and null symlinks are unsafe */
        if (!dest || !*dest || *dest == '/')
                return 1;

        /* find out what our safety margin is */
        for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
                if (strncmp(name, "../", 3) == 0) {
                        depth = 0;
                } else if (strncmp(name, "./", 2) == 0) {
                        /* nothing */
                } else {
                        depth++;
                }
        }
        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 (strcmp(name, "..") == 0)
                depth--;

        return (depth < 0);
}

char* human_num

(

int64

num

)

util.c の 1083 行で定義されています。

参照先 human_readable・sprintf().

参照元 human_dnum()・output_summary()・rprint_progress().

{
        static char bufs[4][128]; /* more than enough room */
        static unsigned int n;
        char *s;

        n = (n + 1) % (sizeof bufs / sizeof bufs[0]);

        if (human_readable) {
                char units = '\0';
                int mult = human_readable == 1 ? 1000 : 1024;
                double dnum = 0;
                if (num > mult*mult*mult) {
                        dnum = (double)num / (mult*mult*mult);
                        units = 'G';
                } else if (num > mult*mult) {
                        dnum = (double)num / (mult*mult);
                        units = 'M';
                } else if (num > mult) {
                        dnum = (double)num / mult;
                        units = 'K';
                }
                if (units) {
                        sprintf(bufs[n], "%.2f%c", dnum, units);
                        return bufs[n];
                }
        }

        s = bufs[n] + sizeof bufs[0] - 1;
        *s = '\0';

        if (!num)
                *--s = '0';
        while (num) {
                *--s = (num % 10) + '0';
                num /= 10;
        }
        return s;
}

char* human_dnum	(	double	dnum,
		int	decimal_digits
	)

util.c の 1126 行で定義されています。

参照先 buf・human_num()・snprintf().

参照元 output_summary().

{
        char *buf = human_num(dnum);
        int len = strlen(buf);
        if (isdigit(*(uchar*)(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;
}

char* timestring

(

time_t

t

)

Return the date and time as a string

util.c の 1141 行で定義されています。

参照先 strlcpy().

参照元 list_file_entry()・log_formatted()・logit().

{
        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);
#else
        strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
#endif

        if ((p = strchr(TimeBuf, '\n')) != NULL)
                *p = '\0';

        return TimeBuf;
}

int msleep

(

int

t

)

Sleep for a specified number of milliseconds.

Always returns TRUE. (In the future it might return FALSE if interrupted.)

util.c の 1165 行で定義されています。

参照先 errno.

参照元 do_recv()・option_error()・rsync_module()・sig_int()・wait_process_with_flush()・whine_about_eof()・writefd_unbuffered().

{
        int tdiff = 0;
        struct timeval tval, t1, t2;

        gettimeofday(&t1, 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 +
                        (t2.tv_usec - t1.tv_usec)/1000;
        }

        return True;
}

int cmp_time	(	time_t	file1,
		time_t	file2
	)

util.c の 1196 行で定義されています。

参照先 modify_window.

参照元 find_fuzzy()・itemize()・recv_generator()・set_file_attrs()・try_dests_reg()・unchanged_file().

{
        if (file2 > file1) {
                if (file2 - file1 <= modify_window)
                        return 0;
                return -1;
        }
        if (file1 - file2 <= modify_window)
                return 0;
        return 1;
}

int _Insure_trap_error	(	int	a1,
		int	a2,
		int	a3,
		int	a4,
		int	a5,
		int	a6
	)

This routine is a trick to immediately catch errors when debugging with insure.

A xterm with a gdb is popped up when insure catches a error. It is Linux specific.

util.c の 1217 行で定義されています。

参照先 asprintf().

{
        static int (*fn)();
        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'",
                getpid(), getpid(), getpid());

        if (!fn) {
                static void *h;
                h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
                fn = dlsym(h, "_Insure_trap_error");
        }

        ret = fn(a1, a2, a3, a4, a5, a6);

        system(cmd);

        free(cmd);

        return ret;
}

void* _new_array	(	unsigned int	size,
		unsigned long	num
	)

util.c の 1244 行で定義されています。

{
        if (num >= MALLOC_MAX/size)
                return NULL;
        return malloc(size * num);
}

void* _realloc_array	(	void *	ptr,
		unsigned int	size,
		unsigned long	num
	)

util.c の 1251 行で定義されています。

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

const char* find_filename_suffix	(	const char *	fn,
		int	fn_len,
		int *	len_ptr
	)

util.c の 1264 行で定義されています。

参照元 find_fuzzy().

{
        const char *suf, *s;
        BOOL had_tilde;
        int s_len;

        /* One or more dots at the start aren't a suffix. */
        while (fn_len && *fn == '.') fn++, fn_len--;

        /* Ignore the ~ in a "foo~" filename. */
        if (fn_len > 1 && fn[fn_len-1] == '~')
                fn_len--, had_tilde = True;
        else
                had_tilde = False;

        /* Assume we don't find an suffix. */
        suf = "";
        *len_ptr = 0;

        /* Find the last significant suffix. */
        for (s = fn + fn_len; fn_len > 1; ) {
                while (*--s != '.' && s != fn) {}
                if (s == fn)
                        break;
                s_len = fn_len - (s - fn);
                fn_len = s - fn;
                if (s_len == 4) {
                        if (strcmp(s+1, "bak") == 0
                         || strcmp(s+1, "old") == 0)
                                continue;
                } else if (s_len == 5) {
                        if (strcmp(s+1, "orig") == 0)
                                continue;
                } else if (s_len > 2 && had_tilde
                    && s[1] == '~' && isdigit(*(uchar*)(s+2)))
                        continue;
                *len_ptr = s_len;
                suf = s;
                if (s_len == 1)
                        break;
                /* Determine if the suffix is all digits. */
                for (s++, s_len--; s_len > 0; s++, s_len--) {
                        if (!isdigit(*(uchar*)s))
                                return suf;
                }
                /* An all-digit suffix may not be that signficant. */
                s = suf;
        }

        return suf;
}

uint32 fuzzy_distance	(	const char *	s1,
		int	len1,
		const char *	s2,
		int	len2
	)

util.c の 1325 行で定義されています。

参照元 find_fuzzy().

{
        uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
        int32 cost;
        int i1, i2;

        if (!len1 || !len2) {
                if (!len1) {
                        s1 = s2;
                        len1 = len2;
                }
                for (i1 = 0, cost = 0; i1 < len1; i1++)
                        cost += s1[i1];
                return (int32)len1 * UNIT + cost;
        }

        for (i2 = 0; i2 < len2; i2++)
                a[i2] = (i2+1) * UNIT;

        for (i1 = 0; i1 < len1; i1++) {
                diag = i1 * UNIT;
                above = (i1+1) * UNIT;
                for (i2 = 0; i2 < len2; i2++) {
                        left = a[i2];
                        if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
                                if (cost < 0)
                                        cost = UNIT - cost;
                                else
                                        cost = UNIT + cost;
                        }
                        diag_inc = diag + cost;
                        left_inc = left + UNIT + *((uchar*)s1+i1);
                        above_inc = above + UNIT + *((uchar*)s2+i2);
                        a[i2] = above = left < above
                              ? (left_inc < diag_inc ? left_inc : diag_inc)
                              : (above_inc < diag_inc ? above_inc : diag_inc);
                        diag = left;
                }
        }

        return a[len2-1];
}

struct bitbag* bitbag_create

(

int

max_ndx

)

util.c の 1377 行で定義されています。

参照先 bitbag::bits・out_of_memory()・bitbag::slot_cnt.

参照元 recv_files().

{
        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
	)

util.c の 1388 行で定義されています。

参照先 bitbag::bits・out_of_memory().

参照元 recv_files().

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

void bitbag_clear_bit	(	struct bitbag *	bb,
		int	ndx
	)

util.c の 1402 行で定義されています。

参照先 bitbag::bits.

{
        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
	)

util.c の 1413 行で定義されています。

参照先 bitbag::bits.

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

int bitbag_next_bit	(	struct bitbag *	bb,
		int	after
	)

util.c の 1426 行で定義されています。

参照先 bitbag::bits・bitbag::slot_cnt.

参照元 handle_delayed_updates().

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

---

変数

int verbose

options.c の 163 行で定義されています。

int dry_run

options.c の 60 行で定義されています。

int module_id

clientserver.c の 60 行で定義されています。

int modify_window

options.c の 113 行で定義されています。

int relative_paths

options.c の 79 行で定義されています。

int human_readable

options.c の 91 行で定義されています。

mode_t orig_umask

main.c の 65 行で定義されています。

char* partial_dir

options.c の 146 行で定義されています。

struct filter_list_struct server_filter_list

exclude.c の 51 行で定義されています。

int sanitize_paths = 0

util.c の 40 行で定義されています。

pid_t all_pids[10] [static]

util.c の 423 行で定義されています。

参照元 do_fork()・kill_all().

int num_pids [static]

util.c の 424 行で定義されています。

参照元 do_fork()・kill_all().

char curr_dir[MAXPATHLEN]

util.c の 846 行で定義されています。

unsigned int curr_dir_len

util.c の 847 行で定義されています。

参照元 pop_dir()・push_dir()・rule_matches()・set_filter_dir().

char partial_fname[MAXPATHLEN] [static]

util.c の 949 行で定義されています。

---