Rather than literally "nobody", try using uid/gid = 65534 as

[rsync/rsync.git] / testsuite / rsync.fns

#! /bin/sh

# Copyright (C) 2001 by Martin Pool <mbp@samba.org>

# General-purpose test functions for rsync.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version
# 2 as published by the Free Software Foundation.
#
# 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
# Lesser General Public License for more details.
# 
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


TMP="$scratchdir"
FROM=${TMP}/from
TO=${TMP}/to
LOG=${TMP}/log
RSYNC="$rsync_bin"

# Berkley's nice.
PATH="$PATH:/usr/ucb"

runtest() {
    echo $ECHO_N "Test $1: $ECHO_C"
    if eval "$2"
    then
	echo "${ECHO_T}	done."
	return 0
    else
	echo "${ECHO_T} failed!"
	return 1
    fi
}

printmsg() {
    echo "$1"
}


rsync_ls_lR() {
    find "$@" -print | sort | xargs $TLS
}


####################
# Build test directories TO and FROM, with FROM full of files.

hands_setup() {
    # Clean before creation
    rm -rf $FROM
    rm -rf $TO

    [ -d $TMP ] || mkdir $TMP
    [ -d $FROM ] || mkdir $FROM
    [ -d $TO ] || mkdir $TO

    # On some BSD systems, the umask affects the mode of created
    # symlinks, even though the mode apparently has no effect on how
    # the links behave in the future, and it cannot be changed using
    # chmod!  rsync always sets its umask to 000 so that it can
    # accurately recreate permissions, but this script is probably run
    # with a different umask. 

    # This causes a little problem that "ls -l" of the two will not be
    # the same.  So, we need to set our umask before doing any creations.

    # set up test data
    touch ${FROM}/empty
    mkdir ${FROM}/emptydir

    # a hundred lines of text or so
    rsync_ls_lR "${srcdir}" > ${FROM}/filelist

    # This might fail on systems that don't have -n
    echo $ECHO_N "This file has no trailing lf$ECHO_C" > ${FROM}/nolf
    umask 0
    ln -s nolf ${FROM}/nolf-symlink
    umask 022

    cat $srcdir/*.c > ${FROM}/text
    mkdir ${FROM}/dir
    cp ${FROM}/text ${FROM}/dir
    mkdir ${FROM}/dir/subdir
    mkdir ${FROM}/dir/subdir/subsubdir
    ls -ltr /etc > ${FROM}/dir/subdir/subsubdir/etc-ltr-list
    mkdir ${FROM}/dir/subdir/subsubdir2
    ls -lt /bin > ${FROM}/dir/subdir/subsubdir2/bin-lt-list

#      echo testing head:
#      ls -lR ${srcdir} | head -10 || echo failed
}


hands_cleanup() {
    rm -r "$TMP"
}




####################
# Many machines do not have "mkdir -p", so we have to build up long paths.
# How boring.  
makepath () {
    echo "        makepath $1"
    p="$1"
    (
	# Absolut Unix.
	if echo $p | grep '^/' >/dev/null
	then
	    cd /
	fi
    
	# This will break if $1 contains a space.
	for c in `echo $p | tr '/' ' '`
	do 
	    if [ -d "$c" ] || mkdir "$c" 
	    then
		cd "$c" || return $?
	    else
		echo "failed to create $c" >&2; return $?
	    fi
	done
    )
}



###########################
# Run a test (in '$1') then compare directories $2 and $3 to see if
# there are any difference.  If there are, explain them.

# So normally basically $1 should be an rsync command, and $2 and $3
# the source and destination directories.  This is only good when you
# expect to transfer the whole directory exactly as is.  If some files
# should be excluded, you might need to use something else.

checkit() {
    failed=

    # We can just write everything to stdout/stderr, because the
    # wrapper hides it unless there is a problem.

    echo "Running: \"$1\""  
    eval "$1" 
    status=$?
    if [ $status != 0 ]; then
	failed="YES";
    fi

    echo "-------------"
    echo "check how the files compare with diff:"
    echo ""
    for f in `cd "$2"; find . -type f -print `
    do 
        diff -c "$2"/"$f" "$3"/"$f" || failed=YES
    done

    echo "-------------"
    echo "check how the directory listings compare with diff:"
    echo ""
    ( cd "$2" && rsync_ls_lR . ) > ${TMP}/ls-from 
    ( cd "$3" && rsync_ls_lR . ) > ${TMP}/ls-to 
    diff -c ${TMP}/ls-from ${TMP}/ls-to || failed=YES
    if [ -z "${failed}" ] ; then
	return 0
    else
	return 1
    fi
}


# In fact, we need a more general feature of capturing all stderr/log files,
# and dumping them if something goes wrong.

checkforlogs() {
  # skip it if we're under debian-test
  if test -n "${Debian}" ; then return 0 ; fi

  if [ -f $1 -a -s $1 ] ; then
	echo "Failures have occurred.  $1 follows:" >&2
	cat $1 >&2
	exit 1
  fi
}


build_rsyncd_conf() {
    # Build an appropriate configuration file
    conf="$scratchdir/test-rsyncd.conf"
    echo "building configuration $conf"

    port=2612
    pidfile="$scratchdir/rsyncd.pid"
    logfile="$scratchdir/rsyncd.log"

    cat >$conf <<EOF
# rsyncd configuration file autogenerated by $0

pid file = $pidfile
use chroot = no
hosts allow = localhost, 127.0.0.1
log file = $logfile

# We don't know if this machine has "nobody" or "nogroup", so use the quasi-canonical
# values of (uint16_t) -2. 

uid = 65534
gid = 65534

[test-from]
	path = $FROM
	read only = yes

[test-to]
	path = $TO
	read only = no
EOF
}


build_symlinks() {
    fromdir="$scratchdir/from"
    todir="$scratchdir/to"
    mkdir "$fromdir"
    date >"$fromdir/referent"
    ln -s referent "$fromdir/relative"
    ln -s "$fromdir/referent" "$fromdir/absolute"
    ln -s nonexistent "$fromdir/dangling"
    ln -s "$srcdir/rsync.c" "$fromdir/unsafe"
}

test_fail() {
    echo "$@" >&2
    exit 1
}

test_skipped() {
    echo "$@" >&2
    echo "$@" > "$TMP/whyskipped"
    exit 77
}

# It failed, but we expected that.  don't dump out error logs, 
# because most users won't want to see them.  But do leave
# the working directory around.
test_xfail() {
    echo "$@" >&2
    exit 78
}

# Test whether something is a link, allowing for shell peculiarities
is_a_link() {
    test -L "$1" || test -h "$1" || /usr/bin/test -L "$1" || /usr/bin/test -h "$1"
}

# be reproducible
umask 077