Do not feed rev-list an invalid SHA1 expression.
[git.git] / git-fetch.sh
1 #!/bin/sh
2 #
3 . git-sh-setup || die "Not a git archive"
4 . git-parse-remote
5 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
6 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
7
8 LF='
9 '
10 IFS="$LF"
11
12 tags=
13 append=
14 force=
15 update_head_ok=
16 while case "$#" in 0) break ;; esac
17 do
18         case "$1" in
19         -a|--a|--ap|--app|--appe|--appen|--append)
20                 append=t
21                 ;;
22         -f|--f|--fo|--for|--forc|--force)
23                 force=t
24                 ;;
25         -t|--t|--ta|--tag|--tags)
26                 tags=t
27                 ;;
28         -u|--u|--up|--upd|--upda|--updat|--update|--update-|--update-h|\
29         --update-he|--update-hea|--update-head|--update-head-|\
30         --update-head-o|--update-head-ok)
31                 update_head_ok=t
32                 ;;
33         *)
34                 break
35                 ;;
36         esac
37         shift
38 done
39
40 case "$#" in
41 0)
42         test -f "$GIT_DIR/branches/origin" ||
43                 test -f "$GIT_DIR/remotes/origin" ||
44                         die "Where do you want to fetch from today?"
45         set origin ;;
46 esac
47
48 remote_nick="$1"
49 remote=$(get_remote_url "$@")
50 refs=
51 rref=
52 rsync_slurped_objects=
53
54 if test "" = "$append"
55 then
56         : >"$GIT_DIR/FETCH_HEAD"
57 fi
58
59 append_fetch_head () {
60     head_="$1"
61     remote_="$2"
62     remote_name_="$3"
63     remote_nick_="$4"
64     local_name_="$5"
65     case "$6" in
66     t) not_for_merge_='not-for-merge' ;;
67     '') not_for_merge_= ;;
68     esac
69
70     # remote-nick is the URL given on the command line (or a shorthand)
71     # remote-name is the $GIT_DIR relative refs/ path we computed
72     # for this refspec.
73     case "$remote_name_" in
74     HEAD)
75         note_= ;;
76     refs/heads/*)
77         note_="$(expr "$remote_name_" : 'refs/heads/\(.*\)')"
78         note_="branch '$note_' of " ;;
79     refs/tags/*)
80         note_="$(expr "$remote_name_" : 'refs/tags/\(.*\)')"
81         note_="tag '$note_' of " ;;
82     *)
83         note_="$remote_name of " ;;
84     esac
85     remote_1_=$(expr "$remote_" : '\(.*\)\.git/*$') &&
86         remote_="$remote_1_"
87     note_="$note_$remote_"
88
89     # 2.6.11-tree tag would not be happy to be fed to resolve.
90     if git-cat-file commit "$head_" >/dev/null 2>&1
91     then
92         headc_=$(git-rev-parse --verify "$head_^0") || exit
93         echo "$headc_   $not_for_merge_ $note_" >>"$GIT_DIR/FETCH_HEAD"
94         echo >&2 "* committish: $head_"
95         echo >&2 "  $note_"
96     else
97         echo "$head_    not-for-merge   $note_" >>"$GIT_DIR/FETCH_HEAD"
98         echo >&2 "* non-commit: $head_"
99         echo >&2 "  $note_"
100     fi
101     if test "$local_name_" != ""
102     then
103         # We are storing the head locally.  Make sure that it is
104         # a fast forward (aka "reverse push").
105         fast_forward_local "$local_name_" "$head_" "$note_"
106     fi
107 }
108
109 fast_forward_local () {
110     mkdir -p "$(dirname "$GIT_DIR/$1")"
111     case "$1" in
112     refs/tags/*)
113         # Tags need not be pointing at commits so there
114         # is no way to guarantee "fast-forward" anyway.
115         if test -f "$GIT_DIR/$1"
116         then
117                 if now_=$(cat "$GIT_DIR/$1") && test "$now_" = "$2"
118                 then
119                         echo >&2 "* $1: same as $3"
120                 else
121                         echo >&2 "* $1: updating with $3"
122                 fi
123         else
124                 echo >&2 "* $1: storing $3"
125         fi
126         git-update-ref "$1" "$2" 
127         ;;
128
129     refs/heads/*)
130         # $1 is the ref being updated.
131         # $2 is the new value for the ref.
132         local=$(git-rev-parse --verify "$1^0" 2>/dev/null)
133         if test "$local"
134         then
135             # Require fast-forward.
136             mb=$(git-merge-base "$local" "$2") &&
137             case "$2,$mb" in
138             $local,*)
139                 echo >&2 "* $1: same as $3"
140                 ;;
141             *,$local)
142                 echo >&2 "* $1: fast forward to $3"
143                 git-update-ref "$1" "$2" "$local"
144                 ;;
145             *)
146                 false
147                 ;;
148             esac || {
149                 echo >&2 "* $1: does not fast forward to $3;"
150                 case ",$force,$single_force," in
151                 *,t,*)
152                         echo >&2 "  forcing update."
153                         git-update-ref "$1" "$2" "$local"
154                         ;;
155                 *)
156                         echo >&2 "  not updating."
157                         ;;
158                 esac
159             }
160         else
161             echo >&2 "* $1: storing $3"
162             git-update-ref "$1" "$2"
163         fi
164         ;;
165     esac
166 }
167
168 case "$update_head_ok" in
169 '')
170         orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
171         ;;
172 esac
173
174 # If --tags (and later --heads or --all) is specified, then we are
175 # not talking about defaults stored in Pull: line of remotes or
176 # branches file, and just fetch those and refspecs explicitly given.
177 # Otherwise we do what we always did.
178
179 reflist=$(get_remote_refs_for_fetch "$@")
180 if test "$tags"
181 then
182         taglist=$(git-ls-remote --tags "$remote" |
183                 sed -e '
184                         /\^/d
185                         s/^[^   ]*      //
186                         s/.*/&:&/')
187         if test "$#" -gt 1
188         then
189                 # remote URL plus explicit refspecs; we need to merge them.
190                 reflist="$reflist$LF$taglist"
191         else
192                 # No explicit refspecs; fetch tags only.
193                 reflist=$taglist
194         fi
195 fi
196
197 for ref in $reflist
198 do
199     refs="$refs$LF$ref"
200
201     # These are relative path from $GIT_DIR, typically starting at refs/
202     # but may be HEAD
203     if expr "$ref" : '\.' >/dev/null
204     then
205         not_for_merge=t
206         ref=$(expr "$ref" : '\.\(.*\)')
207     else
208         not_for_merge=
209     fi
210     if expr "$ref" : '\+' >/dev/null
211     then
212         single_force=t
213         ref=$(expr "$ref" : '\+\(.*\)')
214     else
215         single_force=
216     fi
217     remote_name=$(expr "$ref" : '\([^:]*\):')
218     local_name=$(expr "$ref" : '[^:]*:\(.*\)')
219
220     rref="$rref$LF$remote_name"
221
222     # There are transports that can fetch only one head at a time...
223     case "$remote" in
224     http://* | https://*)
225         if [ -n "$GIT_SSL_NO_VERIFY" ]; then
226             curl_extra_args="-k"
227         fi
228         remote_name_quoted=$(perl -e '
229             my $u = $ARGV[0];
230             $u =~ s{([^-a-zA-Z0-9/.])}{sprintf"%%%02x",ord($1)}eg;
231             print "$u";
232         ' "$remote_name")
233         head=$(curl -nsf $curl_extra_args "$remote/$remote_name_quoted") &&
234         expr "$head" : "$_x40\$" >/dev/null ||
235                 die "Failed to fetch $remote_name from $remote"
236         echo >&2 Fetching "$remote_name from $remote" using http
237         git-http-fetch -v -a "$head" "$remote/" || exit
238         ;;
239     rsync://*)
240         TMP_HEAD="$GIT_DIR/TMP_HEAD"
241         rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
242         head=$(git-rev-parse --verify TMP_HEAD)
243         rm -f "$TMP_HEAD"
244         test "$rsync_slurped_objects" || {
245             rsync -av --ignore-existing --exclude info \
246                 "$remote/objects/" "$GIT_OBJECT_DIRECTORY/" || exit
247
248             # Look at objects/info/alternates for rsync -- http will
249             # support it natively and git native ones will do it on the remote
250             # end.  Not having that file is not a crime.
251             rsync -q "$remote/objects/info/alternates" \
252                 "$GIT_DIR/TMP_ALT" 2>/dev/null ||
253                 rm -f "$GIT_DIR/TMP_ALT"
254             if test -f "$GIT_DIR/TMP_ALT"
255             then
256                 resolve_alternates "$remote" <"$GIT_DIR/TMP_ALT" |
257                 while read alt
258                 do
259                     case "$alt" in 'bad alternate: '*) die "$alt";; esac
260                     echo >&2 "Getting alternate: $alt"
261                     rsync -av --ignore-existing --exclude info \
262                     "$alt" "$GIT_OBJECT_DIRECTORY/" || exit
263                 done
264                 rm -f "$GIT_DIR/TMP_ALT"
265             fi
266             rsync_slurped_objects=t
267         }
268         ;;
269     *)
270         # We will do git native transport with just one call later.
271         continue ;;
272     esac
273
274     append_fetch_head "$head" "$remote" \
275         "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
276
277 done
278
279 case "$remote" in
280 http://* | https://* | rsync://* )
281     ;; # we are already done.
282 *)
283     IFS="       $LF"
284     (
285         git-fetch-pack "$remote" $rref || echo failed "$remote"
286     ) |
287     while read sha1 remote_name
288     do
289         case "$sha1" in
290         failed)
291                 echo >&2 "Fetch failure: $remote"
292                 exit 1 ;;
293         esac
294         found=
295         single_force=
296         for ref in $refs
297         do
298             case "$ref" in
299             +$remote_name:*)
300                 single_force=t
301                 not_for_merge=
302                 found="$ref"
303                 break ;;
304             .+$remote_name:*)
305                 single_force=t
306                 not_for_merge=t
307                 found="$ref"
308                 break ;;
309             .$remote_name:*)
310                 not_for_merge=t
311                 found="$ref"
312                 break ;;
313             $remote_name:*)
314                 not_for_merge=
315                 found="$ref"
316                 break ;;
317             esac
318         done
319         local_name=$(expr "$found" : '[^:]*:\(.*\)')
320         append_fetch_head "$sha1" "$remote" \
321                 "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
322     done || exit
323     ;;
324 esac
325
326 # If the original head was empty (i.e. no "master" yet), or
327 # if we were told not to worry, we do not have to check.
328 case ",$update_head_ok,$orig_head," in
329 *,, | t,* )
330         ;;
331 *)
332         curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
333         if test "$curr_head" != "$orig_head"
334         then
335                 git-update-ref HEAD "$orig_head"
336                 die "Cannot fetch into the current branch."
337         fi
338         ;;
339 esac