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