[thirdparty/git.git] / git-clone.sh

#!/bin/sh
#
# Copyright (c) 2005, Linus Torvalds
# Copyright (c) 2005, Junio C Hamano
#
# Clone a repository into a different directory that does not yet exist.

# See git-sh-setup why.
unset CDPATH

OPTIONS_SPEC="\
git-clone [options] [--] <repo> [<dir>]
--
n,no-checkout        don't create a checkout
bare                 create a bare repository
naked                create a bare repository
l,local              to clone from a local repository
no-hardlinks         don't use local hardlinks, always copy
s,shared             setup as a shared repository
template=            path to the template directory
q,quiet              be quiet
reference=           reference repository
o,origin=            use <name> instead of 'origin' to track upstream
u,upload-pack=       path to git-upload-pack on the remote
depth=               create a shallow clone of that depth

use-separate-remote  compatibility, do not use
no-separate-remote   compatibility, do not use"

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

usage() {
	exec "$0" -h
}

eval "$(echo "$OPTIONS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"

get_repo_base() {
	(
		cd "`/bin/pwd`" &&
		cd "$1" || cd "$1.git" &&
		{
			cd .git
			pwd
		}
	) 2>/dev/null
}

if [ -n "$GIT_SSL_NO_VERIFY" -o \
	"`git config --bool http.sslVerify`" = false ]; then
    curl_extra_args="-k"
fi

http_fetch () {
	# $1 = Remote, $2 = Local
	curl -nsfL $curl_extra_args "$1" >"$2"
	curl_exit_status=$?
	case $curl_exit_status in
	126|127) exit ;;
	*)	 return $curl_exit_status ;;
	esac
}

clone_dumb_http () {
	# $1 - remote, $2 - local
	cd "$2" &&
	clone_tmp="$GIT_DIR/clone-tmp" &&
	mkdir -p "$clone_tmp" || exit 1
	if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
		"`git config --bool http.noEPSV`" = true ]; then
		curl_extra_args="${curl_extra_args} --disable-epsv"
	fi
	http_fetch "$1/info/refs" "$clone_tmp/refs" ||
		die "Cannot get remote repository information.
Perhaps git-update-server-info needs to be run there?"
	test "z$quiet" = z && v=-v || v=
	while read sha1 refname
	do
		name=`expr "z$refname" : 'zrefs/\(.*\)'` &&
		case "$name" in
		*^*)	continue;;
		esac
		case "$bare,$name" in
		yes,* | ,heads/* | ,tags/*) ;;
		*)	continue ;;
		esac
		if test -n "$use_separate_remote" &&
		   branch_name=`expr "z$name" : 'zheads/\(.*\)'`
		then
			tname="remotes/$origin/$branch_name"
		else
			tname=$name
		fi
		git-http-fetch $v -a -w "$tname" "$sha1" "$1" || exit 1
	done <"$clone_tmp/refs"
	rm -fr "$clone_tmp"
	http_fetch "$1/HEAD" "$GIT_DIR/REMOTE_HEAD" ||
	rm -f "$GIT_DIR/REMOTE_HEAD"
	if test -f "$GIT_DIR/REMOTE_HEAD"; then
		head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
		case "$head_sha1" in
		'ref: refs/'*)
			;;
		*)
			git-http-fetch $v -a "$head_sha1" "$1" ||
			rm -f "$GIT_DIR/REMOTE_HEAD"
			;;
		esac
	fi
}

quiet=
local=no
use_local_hardlink=yes
local_shared=no
unset template
no_checkout=
upload_pack=
bare=
reference=
origin=
origin_override=
use_separate_remote=t
depth=
no_progress=
local_explicitly_asked_for=
test -t 1 || no_progress=--no-progress

while test $# != 0
do
	case "$1" in
	-n|--no-checkout)
		no_checkout=yes ;;
	--naked|--bare)
		bare=yes ;;
	-l|--local)
		local_explicitly_asked_for=yes
		use_local_hardlink=yes
		;;
	--no-hardlinks)
		use_local_hardlink=no ;;
	-s|--shared)
		local_shared=yes ;;
	--template)
		shift; template="--template=$1" ;;
	-q|--quiet)
		quiet=-q ;;
	--use-separate-remote|--no-separate-remote)
		die "clones are always made with separate-remote layout" ;;
	--reference)
		shift; reference="$1" ;;
	-o|--origin)
		shift;
		case "$1" in
		'')
		    usage ;;
		*/*)
		    die "'$1' is not suitable for an origin name"
		esac
		git check-ref-format "heads/$1" ||
		    die "'$1' is not suitable for a branch name"
		test -z "$origin_override" ||
		    die "Do not give more than one --origin options."
		origin_override=yes
		origin="$1"
		;;
	-u|--upload-pack)
		shift
		upload_pack="--upload-pack=$1" ;;
	--depth)
		shift
		depth="--depth=$1" ;;
	--)
		shift
		break ;;
	*)
		usage ;;
	esac
	shift
done

repo="$1"
test -n "$repo" ||
    die 'you must specify a repository to clone.'

# --bare implies --no-checkout and --no-separate-remote
if test yes = "$bare"
then
	if test yes = "$origin_override"
	then
		die '--bare and --origin $origin options are incompatible.'
	fi
	no_checkout=yes
	use_separate_remote=
fi

if test -z "$origin"
then
	origin=origin
fi

# Turn the source into an absolute path if
# it is local
if base=$(get_repo_base "$repo"); then
	repo="$base"
	if test -z "$depth"
	then
		local=yes
	fi
elif test -f "$repo"
then
	case "$repo" in /*) ;; *) repo="$PWD/$repo" ;; esac
fi

# Decide the directory name of the new repository
if test -n "$2"
then
	dir="$2"
	test $# = 2 || die "excess parameter to git-clone"
else
	# Derive one from the repository name
	# Try using "humanish" part of source repo if user didn't specify one
	if test -f "$repo"
	then
		# Cloning from a bundle
		dir=$(echo "$repo" | sed -e 's|/*\.bundle$||' -e 's|.*/||g')
	else
		dir=$(echo "$repo" |
			sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
	fi
fi

[ -e "$dir" ] && die "destination directory '$dir' already exists."
[ yes = "$bare" ] && unset GIT_WORK_TREE
[ -n "$GIT_WORK_TREE" ] && [ -e "$GIT_WORK_TREE" ] &&
die "working tree '$GIT_WORK_TREE' already exists."
D=
W=
cleanup() {
	err=$?
	test -z "$D" && rm -rf "$dir"
	test -z "$W" && test -n "$GIT_WORK_TREE" && rm -rf "$GIT_WORK_TREE"
	cd ..
	test -n "$D" && rm -rf "$D"
	test -n "$W" && rm -rf "$W"
	exit $err
}
trap cleanup 0
mkdir -p "$dir" && D=$(cd "$dir" && pwd) || usage
test -n "$GIT_WORK_TREE" && mkdir -p "$GIT_WORK_TREE" &&
W=$(cd "$GIT_WORK_TREE" && pwd) && GIT_WORK_TREE="$W" && export GIT_WORK_TREE
if test yes = "$bare" || test -n "$GIT_WORK_TREE"; then
	GIT_DIR="$D"
else
	GIT_DIR="$D/.git"
fi &&
export GIT_DIR &&
GIT_CONFIG="$GIT_DIR/config" git-init $quiet ${template+"$template"} || usage

if test -n "$bare"
then
	GIT_CONFIG="$GIT_DIR/config" git config core.bare true
fi

if test -n "$reference"
then
	ref_git=
	if test -d "$reference"
	then
		if test -d "$reference/.git/objects"
		then
			ref_git="$reference/.git"
		elif test -d "$reference/objects"
		then
			ref_git="$reference"
		fi
	fi
	if test -n "$ref_git"
	then
		ref_git=$(cd "$ref_git" && pwd)
		echo "$ref_git/objects" >"$GIT_DIR/objects/info/alternates"
		(
			GIT_DIR="$ref_git" git for-each-ref \
				--format='%(objectname) %(*objectname)'
		) |
		while read a b
		do
			test -z "$a" ||
			git update-ref "refs/reference-tmp/$a" "$a"
			test -z "$b" ||
			git update-ref "refs/reference-tmp/$b" "$b"
		done
	else
		die "reference repository '$reference' is not a local directory."
	fi
fi

rm -f "$GIT_DIR/CLONE_HEAD"

# We do local magic only when the user tells us to.
case "$local" in
yes)
	( cd "$repo/objects" ) ||
		die "cannot chdir to local '$repo/objects'."

	if test "$local_shared" = yes
	then
		mkdir -p "$GIT_DIR/objects/info"
		echo "$repo/objects" >>"$GIT_DIR/objects/info/alternates"
	else
		cpio_quiet_flag=""
		cpio --help 2>&1 | grep -- --quiet >/dev/null && \
			cpio_quiet_flag=--quiet
		l= &&
		if test "$use_local_hardlink" = yes
		then
			# See if we can hardlink and drop "l" if not.
			sample_file=$(cd "$repo" && \
				      find objects -type f -print | sed -e 1q)
			# objects directory should not be empty because
			# we are cloning!
			test -f "$repo/$sample_file" ||
				die "fatal: cannot clone empty repository"
			if ln "$repo/$sample_file" "$GIT_DIR/objects/sample" 2>/dev/null
			then
				rm -f "$GIT_DIR/objects/sample"
				l=l
			elif test -n "$local_explicitly_asked_for"
			then
				echo >&2 "Warning: -l asked but cannot hardlink to $repo"
			fi
		fi &&
		cd "$repo" &&
		find objects -depth -print | cpio $cpio_quiet_flag -pumd$l "$GIT_DIR/" || \
			exit 1
	fi
	git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" || exit 1
	;;
*)
	case "$repo" in
	rsync://*)
		case "$depth" in
		"") ;;
		*) die "shallow over rsync not supported" ;;
		esac
		rsync $quiet -av --ignore-existing  \
			--exclude info "$repo/objects/" "$GIT_DIR/objects/" ||
		exit
		# Look at objects/info/alternates for rsync -- http will
		# support it natively and git native ones will do it on the
		# remote end.  Not having that file is not a crime.
		rsync -q "$repo/objects/info/alternates" \
			"$GIT_DIR/TMP_ALT" 2>/dev/null ||
			rm -f "$GIT_DIR/TMP_ALT"
		if test -f "$GIT_DIR/TMP_ALT"
		then
		    ( cd "$D" &&
		      . git-parse-remote &&
		      resolve_alternates "$repo" <"$GIT_DIR/TMP_ALT" ) |
		    while read alt
		    do
			case "$alt" in 'bad alternate: '*) die "$alt";; esac
			case "$quiet" in
			'')	echo >&2 "Getting alternate: $alt" ;;
			esac
			rsync $quiet -av --ignore-existing  \
			    --exclude info "$alt" "$GIT_DIR/objects" || exit
		    done
		    rm -f "$GIT_DIR/TMP_ALT"
		fi
		git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" || exit 1
		;;
	https://*|http://*|ftp://*)
		case "$depth" in
		"") ;;
		*) die "shallow over http or ftp not supported" ;;
		esac
		if test -z "@@NO_CURL@@"
		then
			clone_dumb_http "$repo" "$D"
		else
			die "http transport not supported, rebuild Git with curl support"
		fi
		;;
	*)
		if [ -f "$repo" ] ; then
			git bundle unbundle "$repo" > "$GIT_DIR/CLONE_HEAD" ||
			die "unbundle from '$repo' failed."
		else
			case "$upload_pack" in
			'') git-fetch-pack --all -k $quiet $depth $no_progress "$repo";;
			*) git-fetch-pack --all -k \
				$quiet "$upload_pack" $depth $no_progress "$repo" ;;
			esac >"$GIT_DIR/CLONE_HEAD" ||
			die "fetch-pack from '$repo' failed."
		fi
		;;
	esac
	;;
esac
test -d "$GIT_DIR/refs/reference-tmp" && rm -fr "$GIT_DIR/refs/reference-tmp"

if test -f "$GIT_DIR/CLONE_HEAD"
then
	# Read git-fetch-pack -k output and store the remote branches.
	if [ -n "$use_separate_remote" ]
	then
		branch_top="remotes/$origin"
	else
		branch_top="heads"
	fi
	tag_top="tags"
	while read sha1 name
	do
		case "$name" in
		*'^{}')
			continue ;;
		HEAD)
			destname="REMOTE_HEAD" ;;
		refs/heads/*)
			destname="refs/$branch_top/${name#refs/heads/}" ;;
		refs/tags/*)
			destname="refs/$tag_top/${name#refs/tags/}" ;;
		*)
			continue ;;
		esac
		git update-ref -m "clone: from $repo" "$destname" "$sha1" ""
	done < "$GIT_DIR/CLONE_HEAD"
fi

if test -n "$W"; then
	cd "$W" || exit
else
	cd "$D" || exit
fi

if test -z "$bare"
then
	# a non-bare repository is always in separate-remote layout
	remote_top="refs/remotes/$origin"
	head_sha1=
	test ! -r "$GIT_DIR/REMOTE_HEAD" || head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
	case "$head_sha1" in
	'ref: refs/'*)
		# Uh-oh, the remote told us (http transport done against
		# new style repository with a symref HEAD).
		# Ideally we should skip the guesswork but for now
		# opt for minimum change.
		head_sha1=`expr "z$head_sha1" : 'zref: refs/heads/\(.*\)'`
		head_sha1=`cat "$GIT_DIR/$remote_top/$head_sha1"`
		;;
	esac

	# The name under $remote_top the remote HEAD seems to point at.
	head_points_at=$(
		(
			test -f "$GIT_DIR/$remote_top/master" && echo "master"
			cd "$GIT_DIR/$remote_top" &&
			find . -type f -print | sed -e 's/^\.\///'
		) | (
		done=f
		while read name
		do
			test t = $done && continue
			branch_tip=`cat "$GIT_DIR/$remote_top/$name"`
			if test "$head_sha1" = "$branch_tip"
			then
				echo "$name"
				done=t
			fi
		done
		)
	)

	# Upstream URL
	git config remote."$origin".url "$repo" &&

	# Set up the mappings to track the remote branches.
	git config remote."$origin".fetch \
		"+refs/heads/*:$remote_top/*" '^$' &&

	# Write out remote.$origin config, and update our "$head_points_at".
	case "$head_points_at" in
	?*)
		# Local default branch
		git symbolic-ref HEAD "refs/heads/$head_points_at" &&

		# Tracking branch for the primary branch at the remote.
		git update-ref HEAD "$head_sha1" &&

		rm -f "refs/remotes/$origin/HEAD"
		git symbolic-ref "refs/remotes/$origin/HEAD" \
			"refs/remotes/$origin/$head_points_at" &&

		git config branch."$head_points_at".remote "$origin" &&
		git config branch."$head_points_at".merge "refs/heads/$head_points_at"
		;;
	'')
		if test -z "$head_sha1"
		then
			# Source had nonexistent ref in HEAD
			echo >&2 "Warning: Remote HEAD refers to nonexistent ref, unable to checkout."
			no_checkout=t
		else
			# Source had detached HEAD pointing nowhere
			git update-ref --no-deref HEAD "$head_sha1" &&
			rm -f "refs/remotes/$origin/HEAD"
		fi
		;;
	esac

	case "$no_checkout" in
	'')
		test "z$quiet" = z -a "z$no_progress" = z && v=-v || v=
		git read-tree -m -u $v HEAD HEAD
	esac
fi
rm -f "$GIT_DIR/CLONE_HEAD" "$GIT_DIR/REMOTE_HEAD"

trap - 0
Commit	Line	Data
3f571e0b	1	#!/bin/sh
e95ab1ed JH	2	#
	3	# Copyright (c) 2005, Linus Torvalds
	4	# Copyright (c) 2005, Junio C Hamano
a6080a0a	5	#
e95ab1ed JH	6	# Clone a repository into a different directory that does not yet exist.
e95ab1ed JH	7
365527ad JH	8	# See git-sh-setup why.
	9	unset CDPATH
	10
94362599 PH	11	OPTIONS_SPEC="\
	12	git-clone [options] [--] <repo> [<dir>]
	13	--
	14	n,no-checkout don't create a checkout
	15	bare create a bare repository
	16	naked create a bare repository
	17	l,local to clone from a local repository
	18	no-hardlinks don't use local hardlinks, always copy
	19	s,shared setup as a shared repository
	20	template= path to the template directory
	21	q,quiet be quiet
	22	reference= reference repository
	23	o,origin= use <name> instead of 'origin' to track upstream
	24	u,upload-pack= path to git-upload-pack on the remote
	25	depth= create a shallow clone of that depth
	26
	27	use-separate-remote compatibility, do not use
	28	no-separate-remote compatibility, do not use"
	29
87b787ac DL	30	die() {
87b787ac DL	31	echo >&2 "$@"
e95ab1ed JH	32	exit 1
	33	}
	34
87b787ac	35	usage() {
94362599	36	exec "$0" -h
87b787ac DL	37	}
87b787ac DL	38
e817e3e8	39	eval "$(echo "$OPTIONS_SPEC" \| git rev-parse --parseopt -- "$@" \|\| echo exit $?)"
94362599	40
ba375acf	41	get_repo_base() {
c2f599e0 JH	42	(
c2f599e0 JH	43	cd "`/bin/pwd`" &&
defe13a2	44	cd "$1" \|\| cd "$1.git" &&
c2f599e0	45	{
223fa327	46	cd .git
c2f599e0 JH	47	pwd
c2f599e0 JH	48	}
223fa327	49	) 2>/dev/null
ba375acf LT	50	}
ba375acf LT	51
1c1f79a1 AB	52	if [ -n "$GIT_SSL_NO_VERIFY" -o \
1c1f79a1 AB	53	"`git config --bool http.sslVerify`" = false ]; then
0516de30 JH	54	curl_extra_args="-k"
	55	fi
	56
	57	http_fetch () {
	58	# $1 = Remote, $2 = Local
6851162a JK	59	curl -nsfL $curl_extra_args "$1" >"$2"
	60	curl_exit_status=$?
	61	case $curl_exit_status in
	62	126\|127) exit ;;
	63	*) return $curl_exit_status ;;
	64	esac
0516de30 JH	65	}
	66
	67	clone_dumb_http () {
	68	# $1 - remote, $2 - local
	69	cd "$2" &&
5e3a620c	70	clone_tmp="$GIT_DIR/clone-tmp" &&
0516de30	71	mkdir -p "$clone_tmp" \|\| exit 1
3ea099d4	72	if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
5be60078	73	"`git config --bool http.noEPSV`" = true ]; then
3ea099d4 SK	74	curl_extra_args="${curl_extra_args} --disable-epsv"
3ea099d4 SK	75	fi
87b787ac DL	76	http_fetch "$1/info/refs" "$clone_tmp/refs" \|\|
87b787ac DL	77	die "Cannot get remote repository information.
0516de30	78	Perhaps git-update-server-info needs to be run there?"
7e8c8255	79	test "z$quiet" = z && v=-v \|\| v=
0516de30 JH	80	while read sha1 refname
0516de30 JH	81	do
f327dbce	82	name=`expr "z$refname" : 'zrefs/\(.*\)'` &&
cdb39508	83	case "$name" in
dfeff66e	84	^) continue;;
cdb39508	85	esac
983d2ee2 JH	86	case "$bare,$name" in
	87	yes,* \| ,heads/* \| ,tags/*) ;;
	88	*) continue ;;
	89	esac
dfeff66e	90	if test -n "$use_separate_remote" &&
f327dbce	91	branch_name=`expr "z$name" : 'zheads/\(.*\)'`
dfeff66e	92	then
5ceb05f8	93	tname="remotes/$origin/$branch_name"
dfeff66e JH	94	else
	95	tname=$name
	96	fi
928c210a	97	git-http-fetch $v -a -w "$tname" "$sha1" "$1" \|\| exit 1
0516de30 JH	98	done <"$clone_tmp/refs"
0516de30 JH	99	rm -fr "$clone_tmp"
c72112e6 JH	100	http_fetch "$1/HEAD" "$GIT_DIR/REMOTE_HEAD" \|\|
c72112e6 JH	101	rm -f "$GIT_DIR/REMOTE_HEAD"
59c93929 SV	102	if test -f "$GIT_DIR/REMOTE_HEAD"; then
	103	head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
	104	case "$head_sha1" in
	105	'ref: refs/'*)
	106	;;
	107	*)
	108	git-http-fetch $v -a "$head_sha1" "$1" \|\|
	109	rm -f "$GIT_DIR/REMOTE_HEAD"
	110	;;
	111	esac
	112	fi
dfeff66e JH	113	}
dfeff66e JH	114
167a4a33	115	quiet=
ef5b4eab	116	local=no
3d5c418f	117	use_local_hardlink=yes
aae4f42c	118	local_shared=no
a57c8bac	119	unset template
036a72d8	120	no_checkout=
6ec311da	121	upload_pack=
87e80c4b	122	bare=
dfeff66e JH	123	reference=
dfeff66e JH	124	origin=
e6489a1b	125	origin_override=
71821351	126	use_separate_remote=t
016e6ccb	127	depth=
83a5ad61	128	no_progress=
23d53358	129	local_explicitly_asked_for=
83a5ad61	130	test -t 1 \|\| no_progress=--no-progress
94362599 PH	131
	132	while test $# != 0
	133	do
	134	case "$1" in
	135	-n\|--no-checkout)
	136	no_checkout=yes ;;
	137	--naked\|--bare)
	138	bare=yes ;;
	139	-l\|--local)
	140	local_explicitly_asked_for=yes
	141	use_local_hardlink=yes
	142	;;
	143	--no-hardlinks)
	144	use_local_hardlink=no ;;
	145	-s\|--shared)
	146	local_shared=yes ;;
	147	--template)
a57c8bac	148	shift; template="--template=$1" ;;
94362599 PH	149	-q\|--quiet)
	150	quiet=-q ;;
	151	--use-separate-remote\|--no-separate-remote)
63085fab	152	die "clones are always made with separate-remote layout" ;;
94362599	153	--reference)
dfeff66e	154	shift; reference="$1" ;;
9d81e03b	155	-o\|--origin)
94362599 PH	156	shift;
94362599 PH	157	case "$1" in
98a4fef3 YS	158	'')
98a4fef3 YS	159	usage ;;
47874d6d	160	/)
94362599	161	die "'$1' is not suitable for an origin name"
47874d6d	162	esac
94362599 PH	163	git check-ref-format "heads/$1" \|\|
94362599 PH	164	die "'$1' is not suitable for a branch name"
87b787ac DL	165	test -z "$origin_override" \|\|
87b787ac DL	166	die "Do not give more than one --origin options."
e6489a1b	167	origin_override=yes
94362599	168	origin="$1"
e6c310fd	169	;;
94362599	170	-u\|--upload-pack)
6ec311da	171	shift
ae1dffcb	172	upload_pack="--upload-pack=$1" ;;
94362599	173	--depth)
016e6ccb	174	shift
94362599 PH	175	depth="--depth=$1" ;;
94362599 PH	176	--)
19391c37 HO	177	shift
19391c37 HO	178	break ;;
94362599 PH	179	*)
94362599 PH	180	usage ;;
e95ab1ed	181	esac
e95ab1ed JH	182	shift
	183	done
	184
ef5b4eab	185	repo="$1"
87b787ac DL	186	test -n "$repo" \|\|
87b787ac DL	187	die 'you must specify a repository to clone.'
ef5b4eab	188
b360cca0	189	# --bare implies --no-checkout and --no-separate-remote
e6489a1b JH	190	if test yes = "$bare"
	191	then
	192	if test yes = "$origin_override"
	193	then
87b787ac	194	die '--bare and --origin $origin options are incompatible.'
e6489a1b JH	195	fi
e6489a1b JH	196	no_checkout=yes
71821351	197	use_separate_remote=
e6489a1b	198	fi
8a1a120c	199
47874d6d	200	if test -z "$origin"
dfeff66e	201	then
47874d6d	202	origin=origin
dfeff66e JH	203	fi
dfeff66e JH	204
ba375acf LT	205	# Turn the source into an absolute path if
ba375acf LT	206	# it is local
ba375acf LT	207	if base=$(get_repo_base "$repo"); then
ba375acf LT	208	repo="$base"
d4110a97 CB	209	if test -z "$depth"
	210	then
	211	local=yes
	212	fi
c6fef0bb SB	213	elif test -f "$repo"
	214	then
	215	case "$repo" in /) ;; ) repo="$PWD/$repo" ;; esac
	216	fi
	217
	218	# Decide the directory name of the new repository
	219	if test -n "$2"
	220	then
	221	dir="$2"
e42251a2	222	test $# = 2 \|\| die "excess parameter to git-clone"
c6fef0bb SB	223	else
	224	# Derive one from the repository name
	225	# Try using "humanish" part of source repo if user didn't specify one
	226	if test -f "$repo"
	227	then
	228	# Cloning from a bundle
	229	dir=$(echo "$repo" \| sed -e 's\|/\.bundle$\|\|' -e 's\|./\|\|g')
	230	else
	231	dir=$(echo "$repo" \|
	232	sed -e 's\|/$\|\|' -e 's\|:/\.git$\|\|' -e 's\|.*[/:]\|\|g')
	233	fi
ba375acf LT	234	fi
ba375acf LT	235
87b787ac	236	[ -e "$dir" ] && die "destination directory '$dir' already exists."
20ccef49 ML	237	[ yes = "$bare" ] && unset GIT_WORK_TREE
	238	[ -n "$GIT_WORK_TREE" ] && [ -e "$GIT_WORK_TREE" ] &&
	239	die "working tree '$GIT_WORK_TREE' already exists."
68ad8910	240	D=
20ccef49	241	W=
68ad8910 ML	242	cleanup() {
	243	err=$?
	244	test -z "$D" && rm -rf "$dir"
20ccef49	245	test -z "$W" && test -n "$GIT_WORK_TREE" && rm -rf "$GIT_WORK_TREE"
68ad8910 ML	246	cd ..
68ad8910 ML	247	test -n "$D" && rm -rf "$D"
20ccef49	248	test -n "$W" && rm -rf "$W"
68ad8910 ML	249	exit $err
	250	}
	251	trap cleanup 0
	252	mkdir -p "$dir" && D=$(cd "$dir" && pwd) \|\| usage
20ccef49	253	test -n "$GIT_WORK_TREE" && mkdir -p "$GIT_WORK_TREE" &&
3addc94a	254	W=$(cd "$GIT_WORK_TREE" && pwd) && GIT_WORK_TREE="$W" && export GIT_WORK_TREE
20ccef49 ML	255	if test yes = "$bare" \|\| test -n "$GIT_WORK_TREE"; then
	256	GIT_DIR="$D"
	257	else
	258	GIT_DIR="$D/.git"
	259	fi &&
68ad8910	260	export GIT_DIR &&
312efe9b JH	261	GIT_CONFIG="$GIT_DIR/config" git-init $quiet ${template+"$template"} \|\| usage
	262
	263	if test -n "$bare"
	264	then
	265	GIT_CONFIG="$GIT_DIR/config" git config core.bare true
	266	fi
e95ab1ed	267
dfeff66e JH	268	if test -n "$reference"
dfeff66e JH	269	then
099c7837	270	ref_git=
dfeff66e JH	271	if test -d "$reference"
	272	then
	273	if test -d "$reference/.git/objects"
	274	then
099c7837 JH	275	ref_git="$reference/.git"
	276	elif test -d "$reference/objects"
	277	then
	278	ref_git="$reference"
dfeff66e	279	fi
099c7837 JH	280	fi
	281	if test -n "$ref_git"
	282	then
	283	ref_git=$(cd "$ref_git" && pwd)
	284	echo "$ref_git/objects" >"$GIT_DIR/objects/info/alternates"
	285	(
	286	GIT_DIR="$ref_git" git for-each-ref \
	287	--format='%(objectname) %(*objectname)'
	288	) \|
	289	while read a b
	290	do
	291	test -z "$a" \|\|
	292	git update-ref "refs/reference-tmp/$a" "$a"
	293	test -z "$b" \|\|
	294	git update-ref "refs/reference-tmp/$b" "$b"
	295	done
dfeff66e	296	else
87b787ac	297	die "reference repository '$reference' is not a local directory."
dfeff66e JH	298	fi
	299	fi
	300
	301	rm -f "$GIT_DIR/CLONE_HEAD"
	302
e95ab1ed	303	# We do local magic only when the user tells us to.
3d5c418f JH	304	case "$local" in
3d5c418f JH	305	yes)
87b787ac	306	( cd "$repo/objects" ) \|\|
3d5c418f	307	die "cannot chdir to local '$repo/objects'."
e95ab1ed	308
3d5c418f JH	309	if test "$local_shared" = yes
	310	then
	311	mkdir -p "$GIT_DIR/objects/info"
	312	echo "$repo/objects" >>"$GIT_DIR/objects/info/alternates"
	313	else
c20711d2 BD	314	cpio_quiet_flag=""
	315	cpio --help 2>&1 \| grep -- --quiet >/dev/null && \
	316	cpio_quiet_flag=--quiet
3d5c418f JH	317	l= &&
	318	if test "$use_local_hardlink" = yes
	319	then
	320	# See if we can hardlink and drop "l" if not.
	321	sample_file=$(cd "$repo" && \
	322	find objects -type f -print \| sed -e 1q)
	323	# objects directory should not be empty because
	324	# we are cloning!
ef4cffde JK	325	test -f "$repo/$sample_file" \|\|
ef4cffde JK	326	die "fatal: cannot clone empty repository"
3d5c418f JH	327	if ln "$repo/$sample_file" "$GIT_DIR/objects/sample" 2>/dev/null
	328	then
	329	rm -f "$GIT_DIR/objects/sample"
	330	l=l
23d53358 JH	331	elif test -n "$local_explicitly_asked_for"
23d53358 JH	332	then
3d5c418f JH	333	echo >&2 "Warning: -l asked but cannot hardlink to $repo"
	334	fi
	335	fi &&
	336	cd "$repo" &&
c20711d2 BD	337	find objects -depth -print \| cpio $cpio_quiet_flag -pumd$l "$GIT_DIR/" \|\| \
c20711d2 BD	338	exit 1
3d5c418f	339	fi
57a39690	340	git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" \|\| exit 1
7558ef89 LT	341	;;
7558ef89 LT	342	*)
1cadb5a2 JH	343	case "$repo" in
1cadb5a2 JH	344	rsync://*)
016e6ccb JS	345	case "$depth" in
	346	"") ;;
	347	*) die "shallow over rsync not supported" ;;
	348	esac
4447badc	349	rsync $quiet -av --ignore-existing \
dfeff66e JH	350	--exclude info "$repo/objects/" "$GIT_DIR/objects/" \|\|
dfeff66e JH	351	exit
4447badc JH	352	# Look at objects/info/alternates for rsync -- http will
	353	# support it natively and git native ones will do it on the
	354	# remote end. Not having that file is not a crime.
89d844d0	355	rsync -q "$repo/objects/info/alternates" \
8a1a120c JH	356	"$GIT_DIR/TMP_ALT" 2>/dev/null \|\|
	357	rm -f "$GIT_DIR/TMP_ALT"
	358	if test -f "$GIT_DIR/TMP_ALT"
4447badc	359	then
0e9ab02d	360	( cd "$D" &&
4447badc	361	. git-parse-remote &&
8a1a120c	362	resolve_alternates "$repo" <"$GIT_DIR/TMP_ALT" ) \|
4447badc JH	363	while read alt
	364	do
	365	case "$alt" in 'bad alternate: '*) die "$alt";; esac
	366	case "$quiet" in
	367	'') echo >&2 "Getting alternate: $alt" ;;
	368	esac
	369	rsync $quiet -av --ignore-existing \
8a1a120c	370	--exclude info "$alt" "$GIT_DIR/objects" \|\| exit
4447badc	371	done
8a1a120c	372	rm -f "$GIT_DIR/TMP_ALT"
4447badc	373	fi
57a39690	374	git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" \|\| exit 1
1cadb5a2	375	;;
38529e28	376	https://\|http://\|ftp://*)
016e6ccb JS	377	case "$depth" in
	378	"") ;;
	379	*) die "shallow over http or ftp not supported" ;;
	380	esac
6c5c62f3 FP	381	if test -z "@@NO_CURL@@"
	382	then
	383	clone_dumb_http "$repo" "$D"
	384	else
87b787ac	385	die "http transport not supported, rebuild Git with curl support"
6c5c62f3	386	fi
1cadb5a2 JH	387	;;
1cadb5a2 JH	388	*)
c6fef0bb SB	389	if [ -f "$repo" ] ; then
	390	git bundle unbundle "$repo" > "$GIT_DIR/CLONE_HEAD" \|\|
	391	die "unbundle from '$repo' failed."
	392	else
	393	case "$upload_pack" in
	394	'') git-fetch-pack --all -k $quiet $depth $no_progress "$repo";;
	395	*) git-fetch-pack --all -k \
	396	$quiet "$upload_pack" $depth $no_progress "$repo" ;;
	397	esac >"$GIT_DIR/CLONE_HEAD" \|\|
87b787ac	398	die "fetch-pack from '$repo' failed."
c6fef0bb	399	fi
1cadb5a2	400	;;
6ec311da	401	esac
7558ef89 LT	402	;;
7558ef89 LT	403	esac
dfeff66e JH	404	test -d "$GIT_DIR/refs/reference-tmp" && rm -fr "$GIT_DIR/refs/reference-tmp"
	405
	406	if test -f "$GIT_DIR/CLONE_HEAD"
	407	then
c72112e6	408	# Read git-fetch-pack -k output and store the remote branches.
def2747d SS	409	if [ -n "$use_separate_remote" ]
	410	then
	411	branch_top="remotes/$origin"
	412	else
	413	branch_top="heads"
	414	fi
	415	tag_top="tags"
	416	while read sha1 name
	417	do
	418	case "$name" in
	419	*'^{}')
	420	continue ;;
	421	HEAD)
	422	destname="REMOTE_HEAD" ;;
	423	refs/heads/*)
	424	destname="refs/$branch_top/${name#refs/heads/}" ;;
	425	refs/tags/*)
	426	destname="refs/$tag_top/${name#refs/tags/}" ;;
	427	*)
	428	continue ;;
	429	esac
5be60078	430	git update-ref -m "clone: from $repo" "$destname" "$sha1" ""
def2747d	431	done < "$GIT_DIR/CLONE_HEAD"
dfeff66e	432	fi
1cadb5a2	433
20ccef49 ML	434	if test -n "$W"; then
	435	cd "$W" \|\| exit
	436	else
	437	cd "$D" \|\| exit
	438	fi
036a72d8	439
5274ba69	440	if test -z "$bare"
036a72d8	441	then
63085fab JH	442	# a non-bare repository is always in separate-remote layout
63085fab JH	443	remote_top="refs/remotes/$origin"
5274ba69 GP	444	head_sha1=
5274ba69 GP	445	test ! -r "$GIT_DIR/REMOTE_HEAD" \|\| head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
c72112e6 JH	446	case "$head_sha1" in
	447	'ref: refs/'*)
	448	# Uh-oh, the remote told us (http transport done against
	449	# new style repository with a symref HEAD).
	450	# Ideally we should skip the guesswork but for now
	451	# opt for minimum change.
f327dbce	452	head_sha1=`expr "z$head_sha1" : 'zref: refs/heads/\(.*\)'`
c72112e6 JH	453	head_sha1=`cat "$GIT_DIR/$remote_top/$head_sha1"`
	454	;;
	455	esac
47874d6d	456
c72112e6	457	# The name under $remote_top the remote HEAD seems to point at.
dfeff66e JH	458	head_points_at=$(
dfeff66e JH	459	(
3fe71f3a	460	test -f "$GIT_DIR/$remote_top/master" && echo "master"
dfeff66e JH	461	cd "$GIT_DIR/$remote_top" &&
	462	find . -type f -print \| sed -e 's/^\.\///'
	463	) \| (
	464	done=f
	465	while read name
	466	do
	467	test t = $done && continue
	468	branch_tip=`cat "$GIT_DIR/$remote_top/$name"`
	469	if test "$head_sha1" = "$branch_tip"
	470	then
	471	echo "$name"
	472	done=t
	473	fi
	474	done
	475	)
	476	)
47874d6d	477
6762079a	478	# Upstream URL
5be60078	479	git config remote."$origin".url "$repo" &&
6762079a NS	480
6762079a NS	481	# Set up the mappings to track the remote branches.
5be60078	482	git config remote."$origin".fetch \
6762079a NS	483	"+refs/heads/:$remote_top/" '^$' &&
6762079a NS	484
61dde8f9	485	# Write out remote.$origin config, and update our "$head_points_at".
e125c1a7	486	case "$head_points_at" in
dfeff66e	487	?*)
61dde8f9	488	# Local default branch
5be60078	489	git symbolic-ref HEAD "refs/heads/$head_points_at" &&
61dde8f9 JH	490
61dde8f9 JH	491	# Tracking branch for the primary branch at the remote.
5be60078	492	git update-ref HEAD "$head_sha1" &&
61dde8f9	493
63085fab	494	rm -f "refs/remotes/$origin/HEAD"
5be60078	495	git symbolic-ref "refs/remotes/$origin/HEAD" \
63085fab	496	"refs/remotes/$origin/$head_points_at" &&
61dde8f9	497
5be60078 JH	498	git config branch."$head_points_at".remote "$origin" &&
5be60078 JH	499	git config branch."$head_points_at".merge "refs/heads/$head_points_at"
6762079a NS	500	;;
6762079a NS	501	'')
5274ba69 GP	502	if test -z "$head_sha1"
	503	then
	504	# Source had nonexistent ref in HEAD
	505	echo >&2 "Warning: Remote HEAD refers to nonexistent ref, unable to checkout."
	506	no_checkout=t
	507	else
	508	# Source had detached HEAD pointing nowhere
	509	git update-ref --no-deref HEAD "$head_sha1" &&
	510	rm -f "refs/remotes/$origin/HEAD"
	511	fi
6762079a	512	;;
e125c1a7 JH	513	esac
e125c1a7 JH	514
036a72d8 JH	515	case "$no_checkout" in
036a72d8 JH	516	'')
b0e90897	517	test "z$quiet" = z -a "z$no_progress" = z && v=-v \|\| v=
5be60078	518	git read-tree -m -u $v HEAD HEAD
036a72d8 JH	519	esac
036a72d8 JH	520	fi
dfeff66e	521	rm -f "$GIT_DIR/CLONE_HEAD" "$GIT_DIR/REMOTE_HEAD"
41ff7a10	522
f803eec5	523	trap - 0