+# Avoid unnecessary builds. Unlike the main CI jobs, these are not

+# ci-configurable (but could be).

+concurrency:

+ group: ${{ github.workflow }}-${{ github.ref }}

+ cancel-in-progress: true

+

+ - uses: actions/checkout@v3

+ baseSha=${{github.event.pull_request.base.sha}}

+ problems=()

+ commitText=

+ commitTextmd=

+ goodparent=

+ while read dash sha etc

+ if test -z "${commit}"

+ then

+ goodparent=${sha}

+ fi

+ commit="${sha}"

+ commitText="${sha} ${etc}"

+ commitTextmd="[${sha}](https://github.com/${{ github.repository }}/commit/${sha}) ${etc}"

+ problems+=("1) --- ${commitTextmd}")

+ echo "--- ${commitText}"

+ commit=

+ case "${dash}" in

+ *:[1-9]*:) # contains file and line number information

+ dashend=${dash#*:}

+ problems+=("[${dash}](https://github.com/${{ github.repository }}/blob/${{github.event.pull_request.head.ref}}/${dash%%:*}#L${dashend%:}) ${sha} ${etc}")

+ ;;

+ *)

+ problems+=("\`${dash} ${sha} ${etc}\`")

+ ;;

+ esac

+ echo "${dash} ${sha} ${etc}"

+ done <<< $(git log --check --pretty=format:"---% h% s" ${baseSha}..)

+ if test ${#problems[*]} -gt 0

+ if test -z "${commit}"

+ then

+ goodparent=${baseSha: 0:7}

+ fi

+ echo "🛑 Please review the Summary output for further information."

+ echo "### :x: A whitespace issue was found in one or more of the commits." >$GITHUB_STEP_SUMMARY

+ echo "" >>$GITHUB_STEP_SUMMARY

+ echo "Run these commands to correct the problem:" >>$GITHUB_STEP_SUMMARY

+ echo "1. \`git rebase --whitespace=fix ${goodparent}\`" >>$GITHUB_STEP_SUMMARY

+ echo "1. \`git push --force\`" >>$GITHUB_STEP_SUMMARY

+ echo " " >>$GITHUB_STEP_SUMMARY

+ echo "Errors:" >>$GITHUB_STEP_SUMMARY

+ for i in "${problems[@]}"

+ do

+ echo "${i}" >>$GITHUB_STEP_SUMMARY

+ done

+

+# Avoid unnecessary builds. Unlike the main CI jobs, these are not

+# ci-configurable (but could be).

+concurrency:

+ group: ${{ github.workflow }}-${{ github.ref }}

+ cancel-in-progress: true

+

+ skip_concurrent: ${{ steps.check-ref.outputs.skip_concurrent }}

+

+ skip_concurrent=yes

+ if test -x config-repo/ci/config/skip-concurrent &&

+ ! config-repo/ci/config/skip-concurrent '${{ github.ref }}'

+ then

+ skip_concurrent=no

+ fi

+ echo "skip_concurrent=$skip_concurrent" >>$GITHUB_OUTPUT

+ concurrency:

+ group: windows-build-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ needs: [ci-config, windows-build]

+ concurrency:

+ group: windows-test-${{ matrix.nr }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ if: github.event.repository.owner.login == 'git-for-windows' && needs.ci-config.outputs.enabled == 'yes'

+ concurrency:

+ group: vs-build-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ needs: [ci-config, vs-build]

+ concurrency:

+ group: vs-test-${{ matrix.nr }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: ${{ matrix.vector.jobname }}-${{ matrix.vector.pool }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ - name: print test failures

+ run: ci/print-test-failures.sh

+ concurrency:

+ group: dockerized-${{ matrix.vector.jobname }}-${{ matrix.vector.image }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ - name: print test failures

+ run: ci/print-test-failures.sh

+ concurrency:

+ group: static-analysis-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: sparse-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: documentation-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+Git v2.30.7 Release Notes

+=========================

+

+This release addresses the security issues CVE-2022-41903 and

+CVE-2022-23521.

+

+

+Fixes since v2.30.6

+-------------------

+

+ * CVE-2022-41903:

+

+ git log has the ability to display commits using an arbitrary

+ format with its --format specifiers. This functionality is also

+ exposed to git archive via the export-subst gitattribute.

+

+ When processing the padding operators (e.g., %<(, %<|(, %>(,

+ %>>(, or %><( ), an integer overflow can occur in

+ pretty.c::format_and_pad_commit() where a size_t is improperly

+ stored as an int, and then added as an offset to a subsequent

+ memcpy() call.

+

+ This overflow can be triggered directly by a user running a

+ command which invokes the commit formatting machinery (e.g., git

+ log --format=...). It may also be triggered indirectly through

+ git archive via the export-subst mechanism, which expands format

+ specifiers inside of files within the repository during a git

+ archive.

+

+ This integer overflow can result in arbitrary heap writes, which

+ may result in remote code execution.

+

+* CVE-2022-23521:

+

+ gitattributes are a mechanism to allow defining attributes for

+ paths. These attributes can be defined by adding a `.gitattributes`

+ file to the repository, which contains a set of file patterns and

+ the attributes that should be set for paths matching this pattern.

+

+ When parsing gitattributes, multiple integer overflows can occur

+ when there is a huge number of path patterns, a huge number of

+ attributes for a single pattern, or when the declared attribute

+ names are huge.

+

+ These overflows can be triggered via a crafted `.gitattributes` file

+ that may be part of the commit history. Git silently splits lines

+ longer than 2KB when parsing gitattributes from a file, but not when

+ parsing them from the index. Consequentially, the failure mode

+ depends on whether the file exists in the working tree, the index or

+ both.

+

+ This integer overflow can result in arbitrary heap reads and writes,

+ which may result in remote code execution.

+

+Credit for finding CVE-2022-41903 goes to Joern Schneeweisz of GitLab.

+An initial fix was authored by Markus Vervier of X41 D-Sec. Credit for

+finding CVE-2022-23521 goes to Markus Vervier and Eric Sesterhenn of X41

+D-Sec. This work was sponsored by OSTIF.

+

+The proposed fixes have been polished and extended to cover additional

+findings by Patrick Steinhardt of GitLab, with help from others on the

+Git security mailing list.

+

+Patrick Steinhardt (21):

+ attr: fix overflow when upserting attribute with overly long name

+ attr: fix out-of-bounds read with huge attribute names

+ attr: fix integer overflow when parsing huge attribute names

+ attr: fix out-of-bounds write when parsing huge number of attributes

+ attr: fix out-of-bounds read with unreasonable amount of patterns

+ attr: fix integer overflow with more than INT_MAX macros

+ attr: harden allocation against integer overflows

+ attr: fix silently splitting up lines longer than 2048 bytes

+ attr: ignore attribute lines exceeding 2048 bytes

+ attr: ignore overly large gitattributes files

+ pretty: fix out-of-bounds write caused by integer overflow

+ pretty: fix out-of-bounds read when left-flushing with stealing

+ pretty: fix out-of-bounds read when parsing invalid padding format

+ pretty: fix adding linefeed when placeholder is not expanded

+ pretty: fix integer overflow in wrapping format

+ utf8: fix truncated string lengths in `utf8_strnwidth()`

+ utf8: fix returning negative string width

+ utf8: fix overflow when returning string width

+ utf8: fix checking for glyph width in `strbuf_utf8_replace()`

+ utf8: refactor `strbuf_utf8_replace` to not rely on preallocated buffer

+ pretty: restrict input lengths for padding and wrapping formats

+

+Git v2.31.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.32.5 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+

+In addition, included are additional code for "git fsck" to check

+for questionable .gitattributes files.

+Git v2.33.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.34.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.35.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.36.4 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.37.5 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.38.3 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.39.1 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+ * "git format-patch" learned to honor format.mboxrd even when sending

+ patches to the standard output stream,

+

+ * 'cat-file' gains mailmap support for its '--batch-check' and '-s'

+ options.

+

+ * Conditionally skip the pre-applypatch and applypatch-msg hooks when

+ applying patches with 'git am'.

+

+ * Introduce an optional configuration to allow the trailing hash that

+ protects the index file from bit flipping.

+

+ * Even in a repository with promisor remote, it is useless to

+ attempt to lazily attempt fetching an object that is expected to be

+ commit, because no "filter" mode omits commit objects. Take

+ advantage of this assumption to fail fast on errors.

+

+ * Stop using "git --super-prefix" and narrow the scope of its use to

+ the submodule--helper.

+

+ * Stop running win+VS build by default.

+ (merge a0da6deeec js/ci-disable-cmake-by-default later to maint).

+

+ * CI updates. We probably want a clean-up to move the long shell

+ script embedded in yaml file into a separate file, but that can

+ come later.

+ (merge 4542582e59 cw/ci-whitespace later to maint).

+

+ * Use `git diff --no-index` as a test_cmp on Windows.

+

+ We'd probably need to revisit "do we really want to, and have to,

+ lose CRLF vs LF?" later, at which time we may be able to further

+ clean this up by replacing "git diff --no-index" with "diff -u".

+

+ * Avoid unnecessary builds in CI, with settings configured in

+ ci-config.

+ (merge eb5b03a9c0 tb/ci-concurrency later to maint).

+

+ * When given a pattern that matches an empty string at the end of a

+ line, the code to parse the "git diff" line-ranges fell into an

+ infinite loop, which has been corrected.

+ (merge 4e57c88e02 lk/line-range-parsing-fix later to maint).

+

+ * Fix the sequence to fsync $GIT_DIR/packed-refs file that forgot to

+ flush its output to the disk..

+ (merge ce54672f9b ps/fsync-refs-fix later to maint).

+

+ * Fix to a small regression in 2.38 days.

+ (merge 6d5e9e53aa ab/bundle-wo-args later to maint).

+

+ * "git diff --relative" did not mix well with "git diff --ext-diff",

+ which has been corrected.

+ (merge f034bb1cad jk/ext-diff-with-relative later to maint).

+

+ * The logic to see if we are using the "cone" mode by checking the

+ sparsity patterns has been tightened to avoid mistaking a pattern

+ that names a single file as specifying a cone.

+ (merge 5842710dc2 ws/single-file-cone later to maint).

+

+ * Deal with a few deprecation warning from cURL library.

+ (merge 6c065f72b8 jk/curl-avoid-deprecated-api later to maint).

+

+ (merge 4eb1ccecd4 dh/mingw-ownership-check-typofix later to maint).

+ (merge f95526419b ar/typofix-gitattributes-doc later to maint).

+ (merge 27875aeec9 km/doc-branch-start-point later to maint).

+ (merge 35c194dc57 es/t1509-root-fixes later to maint).

+ (merge 7b341645e3 pw/ci-print-failure-name-fix later to maint).

+* `index.skipHash=true` speeds up index writes by not computing a trailing

+ checksum. Note that this will cause Git versions earlier than 2.13.0 to

+ refuse to parse the index and Git versions earlier than 2.40.0 will report

+ a corrupted index during `git fsck`.

++

+

+format.mboxrd::

+ A boolean value which enables the robust "mboxrd" format when

+ `--stdout` is in use to escape "^>+From " lines.

+

+index.skipHash::

+ When enabled, do not compute the trailing hash for the index file.

+ This accelerates Git commands that manipulate the index, such as

+ `git add`, `git commit`, or `git status`. Instead of storing the

+ checksum, write a trailing set of bytes with value zero, indicating

+ that the computation was skipped.

++

+If you enable `index.skipHash`, then Git clients older than 2.13.0 will

+refuse to parse the index and Git clients older than 2.40.0 will report an

+error during `git fsck`.

+

+transfer.bundleURI::

+ When `true`, local `git clone` commands will request bundle

+ information from the remote server (if advertised) and download

+ bundles before continuing the clone through the Git protocol.

+ Defaults to `false`.

+`gitattributesBlob`::

+ (ERROR) A non-blob found at `.gitattributes`.

+

+`gitattributesLarge`::

+ (ERROR) The `.gitattributes` blob is too large.

+

+`gitattributesLineLength`::

+ (ERROR) The `.gitattributes` blob contains too long lines.

+

+`gitattributesMissing`::

+ (ERROR) Unable to read `.gitattributes` blob.

+

+'git am' [--signoff] [--keep] [--[no-]keep-cr] [--[no-]utf8] [--no-verify]

+-n::

+--no-verify::

+ By default, the pre-applypatch and applypatch-msg hooks are run.

+ When any of `--no-verify` or `-n` is given, these are bypassed.

+ See also linkgit:githooks[5].

+

+ Reset <branchname> to <start-point>, even if <branchname> exists

+ `<object>`. If used with `--use-mailmap` option, will show

+ the size of updated object after replacing idents using the

+ mailmap mechanism.

+ on stdin. May not be combined with any other options or arguments

+ except `--textconv`, `--filters`, or `--use-mailmap`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines

+ must specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ contents part of the output shows the identities replaced using the

+ mailmap mechanism, while the information part of the output shows

+ the size of the object as if it actually recorded the replacement

+ identities.

+ Print object information for each object provided on stdin. May not be

+ combined with any other options or arguments except `--textconv`, `--filters`

+ or `--use-mailmap`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines must

+ specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ printed object information shows the size of the object as if the

+ identities recorded in it were replaced by the mailmap mechanism.

+ only be combined with `--buffer`, `--textconv`, `--use-mailmap` or

+ `--filters`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines must

+ specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ `contents` command shows the identities replaced using the

+ mailmap mechanism, while the `info` command shows the size

+ of the object as if it actually recorded the replacement

+ identities.

+

+ [--config-env=<name>=<envvar>] <command> [<args>]

+ Specify a comma separated list of common whitespace problems to

+bundle-uri

+~~~~~~~~~~

+

+If the 'bundle-uri' capability is advertised, the server supports the

+`bundle-uri' command.

+

+The capability is currently advertised with no value (i.e. not

+"bundle-uri=somevalue"), a value may be added in the future for

+supporting command-wide extensions. Clients MUST ignore any unknown

+capability values and proceed with the 'bundle-uri` dialog they

+support.

+

+The 'bundle-uri' command is intended to be issued before `fetch` to

+get URIs to bundle files (see linkgit:git-bundle[1]) to "seed" and

+inform the subsequent `fetch` command.

+

+The client CAN issue `bundle-uri` before or after any other valid

+command. To be useful to clients it's expected that it'll be issued

+after an `ls-refs` and before `fetch`, but CAN be issued at any time

+in the dialog.

+

+DISCUSSION of bundle-uri

+^^^^^^^^^^^^^^^^^^^^^^^^

+

+The intent of the feature is optimize for server resource consumption

+in the common case by changing the common case of fetching a very

+large PACK during linkgit:git-clone[1] into a smaller incremental

+fetch.

+

+It also allows servers to achieve better caching in combination with

+an `uploadpack.packObjectsHook` (see linkgit:git-config[1]).

+

+By having new clones or fetches be a more predictable and common

+negotiation against the tips of recently produces *.bundle file(s).

+Servers might even pre-generate the results of such negotiations for

+the `uploadpack.packObjectsHook` as new pushes come in.

+

+One way that servers could take advantage of these bundles is that the

+server would anticipate that fresh clones will download a known bundle,

+followed by catching up to the current state of the repository using ref

+tips found in that bundle (or bundles).

+

+PROTOCOL for bundle-uri

+^^^^^^^^^^^^^^^^^^^^^^^

+

+A `bundle-uri` request takes no arguments, and as noted above does not

+currently advertise a capability value. Both may be added in the

+future.

+

+When the client issues a `command=bundle-uri` request, the response is a

+list of key-value pairs provided as packet lines with value

+`<key>=<value>`. Each `<key>` should be interpreted as a config key from

+the `bundle.*` namespace to construct a list of bundles. These keys are

+grouped by a `bundle.<id>.` subsection, where each key corresponding to a

+given `<id>` contributes attributes to the bundle defined by that `<id>`.

+See linkgit:git-config[1] for the specific details of these keys and how

+the Git client will interpret their values.

+

+Clients MUST parse the line according to the above format, lines that do

+not conform to the format SHOULD be discarded. The user MAY be warned in

+such a case.

+

+bundle-uri CLIENT AND SERVER EXPECTATIONS

+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+

+URI CONTENTS::

+The content at the advertised URIs MUST be one of two types.

++

+The advertised URI may contain a bundle file that `git bundle verify`

+would accept. I.e. they MUST contain one or more reference tips for

+use by the client, MUST indicate prerequisites (in any) with standard

+"-" prefixes, and MUST indicate their "object-format", if

+applicable.

++

+The advertised URI may alternatively contain a plaintext file that `git

+config --list` would accept (with the `--file` option). The key-value

+pairs in this list are in the `bundle.*` namespace (see

+linkgit:git-config[1]).

+

+bundle-uri CLIENT ERROR RECOVERY::

+A client MUST above all gracefully degrade on errors, whether that

+error is because of bad missing/data in the bundle URI(s), because

+that client is too dumb to e.g. understand and fully parse out bundle

+headers and their prerequisite relationships, or something else.

++

+Server operators should feel confident in turning on "bundle-uri" and

+not worry if e.g. their CDN goes down that clones or fetches will run

+into hard failures. Even if the server bundle(s) are

+incomplete, or bad in some way the client should still end up with a

+functioning repository, just as if it had chosen not to use this

+protocol extension.

++

+All subsequent discussion on client and server interaction MUST keep

+this in mind.

+

+bundle-uri SERVER TO CLIENT::

+The ordering of the returned bundle uris is not significant. Clients

+MUST parse their headers to discover their contained OIDS and

+prerequisites. A client MUST consider the content of the bundle(s)

+themselves and their header as the ultimate source of truth.

++

+A server MAY even return bundle(s) that don't have any direct

+relationship to the repository being cloned (either through accident,

+or intentional "clever" configuration), and expect a client to sort

+out what data they'd like from the bundle(s), if any.

+

+bundle-uri CLIENT TO SERVER::

+The client SHOULD provide reference tips found in the bundle header(s)

+as 'have' lines in any subsequent `fetch` request. A client MAY also

+ignore the bundle(s) entirely if doing so is deemed worse for some

+reason, e.g. if the bundles can't be downloaded, it doesn't like the

+tips it finds etc.

+

+WHEN ADVERTISED BUNDLE(S) REQUIRE NO FURTHER NEGOTIATION::

+If after issuing `bundle-uri` and `ls-refs`, and getting the header(s)

+of the bundle(s) the client finds that the ref tips it wants can be

+retrieved entirely from advertised bundle(s), the client MAY disconnect

+from the Git server. The results of such a 'clone' or 'fetch' should be

+indistinguishable from the state attained without using bundle-uri.

+

+EARLY CLIENT DISCONNECTIONS AND ERROR RECOVERY::

+A client MAY perform an early disconnect while still downloading the

+bundle(s) (having streamed and parsed their headers). In such a case

+the client MUST gracefully recover from any errors related to

+finishing the download and validation of the bundle(s).

++

+I.e. a client might need to re-connect and issue a 'fetch' command,

+and possibly fall back to not making use of 'bundle-uri' at all.

++

+This "MAY" behavior is specified as such (and not a "SHOULD") on the

+assumption that a server advertising bundle uris is more likely than

+not to be serving up a relatively large repository, and to be pointing

+to URIs that have a good chance of being in working order. A client

+MAY e.g. look at the payload size of the bundles as a heuristic to see

+if an early disconnect is worth it, should falling back on a full

+"fetch" dialog be necessary.

+

+WHEN ADVERTISED BUNDLE(S) REQUIRE FURTHER NEGOTIATION::

+A client SHOULD commence a negotiation of a PACK from the server via

+the "fetch" command using the OID tips found in advertised bundles,

+even if's still in the process of downloading those bundle(s).

++

+This allows for aggressive early disconnects from any interactive

+server dialog. The client blindly trusts that the advertised OID tips

+are relevant, and issues them as 'have' lines, it then requests any

+tips it would like (usually from the "ls-refs" advertisement) via

+'want' lines. The server will then compute a (hopefully small) PACK

+with the expected difference between the tips from the bundle(s) and

+the data requested.

++

+The only connection the client then needs to keep active is to the

+concurrently downloading static bundle(s), when those and the

+incremental PACK are retrieved they should be inflated and

+validated. Any errors at this point should be gracefully recovered

+from, see above.

+

+bundle-uri PROTOCOL FEATURES

+^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+

+The client constructs a bundle list from the `<key>=<value>` pairs

+provided by the server. These pairs are part of the `bundle.*` namespace

+as documented in linkgit:git-config[1]. In this section, we discuss some

+of these keys and describe the actions the client will do in response to

+this information.

+

+In particular, the `bundle.version` key specifies an integer value. The

+only accepted value at the moment is `1`, but if the client sees an

+unexpected value here then the client MUST ignore the bundle list.

+

+As long as `bundle.version` is understood, all other unknown keys MAY be

+ignored by the client. The server will guarantee compatibility with older

+clients, though newer clients may be better able to use the extra keys to

+minimize downloads.

+

+Any backwards-incompatible addition of pre-URI key-value will be

+guarded by a new `bundle.version` value or values in 'bundle-uri'

+capability advertisement itself, and/or by new future `bundle-uri`

+request arguments.

+

+Some example key-value pairs that are not currently implemented but could

+be implemented in the future include:

+

+ * Add a "hash=<val>" or "size=<bytes>" advertise the expected hash or

+ size of the bundle file.

+

+ * Advertise that one or more bundle files are the same (to e.g. have

+ clients round-robin or otherwise choose one of N possible files).

+

+ * A "oid=<OID>" shortcut and "prerequisite=<OID>" shortcut. For

+ expressing the common case of a bundle with one tip and no

+ prerequisites, or one tip and one prerequisite.

++

+This would allow for optimizing the common case of servers who'd like

+to provide one "big bundle" containing only their "main" branch,

+and/or incremental updates thereof.

++

+A client receiving such a a response MAY assume that they can skip

+retrieving the header from a bundle at the indicated URI, and thus

+save themselves and the server(s) the request(s) needed to inspect the

+headers of that bundle or bundles.

+

+ Git requires version "7.19.5" or later of "libcurl" to build

+ unsigned int attr_nr; /* unique attribute number */

+static const struct git_attr *git_attr_internal(const char *name, size_t namelen)

+ if (a->attr_nr != hashmap_get_size(&g_attr_hashmap.map) - 1)

+ die(_("unable to add additional attribute"));

+ size_t num_attr;

+ size_t len;

+ size_t namelen, num_attr, i;

+ if (strlen(line) >= ATTR_MAX_LINE_LENGTH) {

+ warning(_("ignoring overly long attributes line %d"), lineno);

+ return NULL;

+ }

+

+ res = xcalloc(1, st_add3(sizeof(*res),

+ st_mult(sizeof(struct attr_state), num_attr),

+ is_macro ? 0 : namelen + 1));

+ unsigned i;

+ size_t j;

+

+ ALLOC_GROW_BY(res->attrs, res->num_matches, 1, res->alloc);

+ res->attrs[res->num_matches - 1] = a;

+ struct strbuf buf = STRBUF_INIT;

+ struct stat st;

+ if (fstat(fd, &st)) {

+ warning_errno(_("cannot fstat gitattributes file '%s'"), path);

+ fclose(fp);

+ return NULL;

+ }

+ if (st.st_size >= ATTR_MAX_FILE_SIZE) {

+ warning(_("ignoring overly large gitattributes file '%s'"), path);

+ fclose(fp);

+ return NULL;

+ }

+ while (strbuf_getline(&buf, fp) != EOF) {

+ if (!lineno && starts_with(buf.buf, utf8_bom))

+ strbuf_remove(&buf, 0, strlen(utf8_bom));

+ handle_attr_line(res, buf.buf, path, ++lineno, flags);

+

+ strbuf_release(&buf);

+ unsigned long size;

+ buf = read_blob_data_from_index(istate, path, &size);

+ if (size >= ATTR_MAX_FILE_SIZE) {

+ warning(_("ignoring overly large gitattributes blob '%s'"), path);

+ return NULL;

+ }

+ size_t i;

+ for (i = a->num_attr; rem > 0 && i > 0; i--) {

+ const struct git_attr *attr = a->state[i - 1].attr;

+ const char *v = a->state[i - 1].setto;

+ unsigned i;

+ for (i = stack->num_matches; 0 < rem && 0 < i; i--) {

+ const struct match_attr *a = stack->attrs[i - 1];

+ unsigned i;

+ for (i = stack->num_matches; i > 0; i--) {

+ const struct match_attr *ma = stack->attrs[i - 1];

+ unsigned int n = ma->u.attr->attr_nr;

+ unsigned int n = check->items[i].attr->attr_nr;

+/**

+ * The maximum line length for a gitattributes file. If the line exceeds this

+ * length we will ignore it.

+ */

+#define ATTR_MAX_LINE_LENGTH 2048

+

+ /**

+ * The maximum size of the giattributes file. If the file exceeds this size we

+ * will ignore it.

+ */

+#define ATTR_MAX_FILE_SIZE (100 * 1024 * 1024)

+

+ int no_verify;

+ int ret = 0;

+

+ if (!state->no_verify)

+ ret = run_hooks_l("applypatch-msg", am_path(state, "final-commit"), NULL);

+ if (!state->no_verify && run_hooks("pre-applypatch"))

+ OPT_BOOL('n', "no-verify", &state.no_verify,

+ N_("bypass pre-applypatch and applypatch-msg hooks")),

+ argc = parse_options(argc, argv, NULL, options, usagestr,

+ if (!argc)

+ usage_msg_opt(_("need a <file> argument"), usagestr, options);

+ return argc;

+

+ if (use_mailmap) {

+ oi.typep = &type;

+ oi.contentp = (void**)&buf;

+ }

+

+

+ if (use_mailmap && (type == OBJ_COMMIT || type == OBJ_TAG)) {

+ size_t s = size;

+ buf = replace_idents_using_mailmap(buf, &s);

+ size = cast_size_t_to_ulong(s);

+ }

+

+ if (use_mailmap)

+ data->info.typep = &data->type;

+

+

+ if (use_mailmap && (data->type == OBJ_COMMIT || data->type == OBJ_TAG)) {

+ size_t s = data->size;

+ char *buf = NULL;

+

+ buf = repo_read_object_file(the_repository, &data->oid, &data->type,

+ &data->size);

+ buf = replace_idents_using_mailmap(buf, &s);

+ data->size = cast_size_t_to_ulong(s);

+

+ free(buf);

+ }

+ unlink_entry(ce, NULL);

+ * or <something> is not a path, no -t or -b was given,

+ if (!bundle_uri) {

+ /*

+ * Populate transport->got_remote_bundle_uri and

+ * transport->bundle_uri. We might get nothing.

+ */

+ transport_get_remote_bundle_uri(transport);

+

+ if (transport->bundles &&

+ hashmap_get_size(&transport->bundles->bundles)) {

+ /* At this point, we need the_repository to match the cloned repo. */

+ if (repo_init(the_repository, git_dir, work_tree))

+ warning(_("failed to initialize the repo, skipping bundle URI"));

+ else if (fetch_bundle_list(the_repository,

+ transport->bundles))

+ warning(_("failed to fetch advertised bundles"));

+ } else {

+ clear_bundle_list(transport->bundles);

+ FREE_AND_NULL(transport->bundles);

+ }

+ }

+

+static int stdout_mboxrd;

+ if (!strcmp(var, "format.mboxrd")) {

+ stdout_mboxrd = git_config_bool(var, value);

+ return 0;

+ }

+ if (use_stdout && stdout_mboxrd)

+ rev.commit_format = CMIT_FMT_MBOXRD;

+

+ OPT__SUPER_PREFIX(&opts.super_prefix),

+ const char *arg;

+

+ } else if (skip_prefix(buffer, "connect ", &arg)) {

+ return run_child(child, arg);

+ } else if (starts_with(buffer, "connect ")) {

+ absorb_git_dir_into_superproject(name, NULL);

+static char *get_submodule_displaypath(const char *path, const char *prefix,

+ const char *super_prefix)

+ const char *super_prefix;

+ displaypath = get_submodule_displaypath(path, info->prefix,

+ info->super_prefix);

+ strvec_pushl(&cpr.args, "--super-prefix", NULL);

+ strvec_pushf(&cpr.args, "%s/", displaypath);

+ OPT__SUPER_PREFIX(&info.super_prefix),

+ const char *super_prefix;

+ const char *super_prefix,

+ displaypath = get_submodule_displaypath(path, prefix, super_prefix);

+ init_submodule(list_item->name, info->prefix, info->super_prefix,

+ info->flags);

+ const char *super_prefix;

+ const char *super_prefix, unsigned int flags)

+ displaypath = get_submodule_displaypath(path, prefix, super_prefix);

+ strvec_push(&cpr.args, "--super-prefix");

+ strvec_pushf(&cpr.args, "%s/", displaypath);

+ info->prefix, info->super_prefix, info->flags);

+ OPT__SUPER_PREFIX(&info.super_prefix),

+ const char *super_prefix;

+ displaypath = get_submodule_displaypath(p->sm_path, info->prefix,

+ info->super_prefix);

+ const char *super_prefix;

+ const char *super_prefix, unsigned int flags)

+ displaypath = get_submodule_displaypath(path, prefix, super_prefix);

+ strvec_push(&cpr.args, "--super-prefix");

+ strvec_pushf(&cpr.args, "%s/", displaypath);

+

+ sync_submodule(list_item->name, info->prefix, info->super_prefix,

+ info->flags);

+ OPT__SUPER_PREFIX(&info.super_prefix),

+ displaypath = get_submodule_displaypath(path, prefix, NULL);

+ absorb_git_dir_into_superproject(path, NULL);

+ const char *super_prefix;

+ char *displaypath = get_submodule_displaypath(ce->name, ud->prefix,

+ ud->super_prefix);

+ strvec_pushl(args, "submodule--helper", "update", "--recursive", NULL);

+ update_data->sm_path, update_data->prefix,

+ update_data->super_prefix);

+ OPT__SUPER_PREFIX(&opt.super_prefix),

+ info.super_prefix = opt.super_prefix;

+ const char *super_prefix = NULL;

+ OPT__SUPER_PREFIX(&super_prefix),

+ absorb_git_dir_into_superproject(list.entries[i]->name,

+ super_prefix);

+ sync_submodule(path, prefix, NULL, quiet ? OPT_QUIET : 0);

+ * Since there is only one pathspec, we just need to

+ * check ps_matched[0] to know if a cache entry matched.

+#include "remote.h"

+ free(list->baseURI);

+ bundle->uri = relative_url(list->baseURI, value, NULL);

+ if (!list->baseURI) {

+ struct strbuf baseURI = STRBUF_INIT;

+ strbuf_addstr(&baseURI, uri);

+

+ /*

+ * If the URI does not end with a trailing slash, then

+ * remove the filename portion of the path. This is

+ * important for relative URIs.

+ */

+ strbuf_strip_file_from_path(&baseURI);

+ list->baseURI = strbuf_detach(&baseURI, NULL);

+ }

+int fetch_bundle_list(struct repository *r, struct bundle_list *list)

+{

+ int result;

+ struct bundle_list global_list;

+

+ init_bundle_list(&global_list);

+

+ /* If a bundle is added to this global list, then it is required. */

+ global_list.mode = BUNDLE_MODE_ALL;

+

+ if ((result = download_bundle_list(r, list, &global_list, 0)))

+ goto cleanup;

+

+ result = unbundle_all_bundles(r, &global_list);

+

+cleanup:

+ for_all_bundles_in_list(&global_list, unlink_bundle, NULL);

+ clear_bundle_list(&global_list);

+ return result;

+}

+

+/**

+ * API for serve.c.

+ */

+

+int bundle_uri_advertise(struct repository *r, struct strbuf *value UNUSED)

+{

+ static int advertise_bundle_uri = -1;

+

+ if (advertise_bundle_uri != -1)

+ goto cached;

+

+ advertise_bundle_uri = 0;

+ repo_config_get_maybe_bool(r, "uploadpack.advertisebundleuris", &advertise_bundle_uri);

+

+cached:

+ return advertise_bundle_uri;

+}

+

+static int config_to_packet_line(const char *key, const char *value, void *data)

+{

+ struct packet_reader *writer = data;

+

+ if (starts_with(key, "bundle."))

+ packet_write_fmt(writer->fd, "%s=%s", key, value);

+

+ return 0;

+}

+

+int bundle_uri_command(struct repository *r,

+ struct packet_reader *request)

+{

+ struct packet_writer writer;

+ packet_writer_init(&writer, 1);

+

+ while (packet_reader_read(request) == PACKET_READ_NORMAL)

+ die(_("bundle-uri: unexpected argument: '%s'"), request->line);

+ if (request->status != PACKET_READ_FLUSH)

+ die(_("bundle-uri: expected flush after arguments"));

+

+ /*

+ * Read all "bundle.*" config lines to the client as key=value

+ * packet lines.

+ */

+ git_config(config_to_packet_line, &writer);

+

+ packet_writer_flush(&writer);

+

+ return 0;

+}

+

+struct packet_reader;

+

+ /**

+ * The baseURI of a bundle_list is the URI that provided the list.

+ *

+ * In the case of the 'bundle-uri' protocol v2 command, the base

+ * URI is the URI of the Git remote.

+ *

+ * Otherwise, the bundle list was downloaded over HTTP from some

+ * known URI. 'baseURI' is set to that value.

+ *

+ * The baseURI is used as the base for any relative URIs

+ * advertised by the bundle list at that location.

+ */

+ char *baseURI;

+ * Given a bundle list that was already advertised (likely by the

+ * bundle-uri protocol v2 verb) at the given uri, fetch and unbundle the

+ * bundles according to the bundle strategy of that list.

+ *

+ * It is expected that the given 'list' is initialized, including its

+ * 'baseURI' value.

+ *

+ * Returns non-zero if there was an error trying to download the list

+ * or any of its advertised bundles.

+ */

+int fetch_bundle_list(struct repository *r,

+ struct bundle_list *list);

+

+/**

+ * API for serve.c.

+ */

+int bundle_uri_advertise(struct repository *r, struct strbuf *value);

+int bundle_uri_command(struct repository *r, struct packet_reader *request);

+

+/**

+ * CE_INTENT_TO_ADD entries exist in on-disk index but

+ return utf8_strnwidth(s, strlen(s), 1);

+ struct object_info oi = {

+ .typep = &type,

+ .sizep = &size,

+ .contentp = &buffer,

+ };

+ /*

+ * Git does not support partial clones that exclude commits, so set

+ * OBJECT_INFO_SKIP_FETCH_OBJECT to fail fast when an object is missing.

+ */

+ int flags = OBJECT_INFO_LOOKUP_REPLACE | OBJECT_INFO_SKIP_FETCH_OBJECT |

+ OBJECT_INFO_DIE_IF_CORRUPT;

+

+ if (oid_object_info_extended(r, &item->object.oid, &oi, flags) < 0)

+ strbuf_addf(report, "'%s' is on a file system that does "

+ _endthreadex((unsigned)(uintptr_t)ret);

+ /* Only use worktree-specific config if it is already enabled. */

+#include "bundle-uri.h"

+int get_remote_bundle_uri(int fd_out, struct packet_reader *reader,

+ struct bundle_list *bundles, int stateless_rpc)

+{

+ int line_nr = 1;

+

+ /* Assert bundle-uri support */

+ ensure_server_supports_v2("bundle-uri");

+

+ /* (Re-)send capabilities */

+ send_capabilities(fd_out, reader);

+

+ /* Send command */

+ packet_write_fmt(fd_out, "command=bundle-uri\n");

+ packet_delim(fd_out);

+

+ packet_flush(fd_out);

+

+ /* Process response from server */

+ while (packet_reader_read(reader) == PACKET_READ_NORMAL) {

+ const char *line = reader->line;

+ line_nr++;

+

+ if (!bundle_uri_parse_line(bundles, line))

+ continue;

+

+ return error(_("error on bundle-uri response line %d: %s"),

+ line_nr, line);

+ }

+

+ if (reader->status != PACKET_READ_FLUSH)

+ return error(_("expected flush after bundle-uri listing"));

+

+ /*

+ * Might die(), but obscure enough that that's OK, e.g. in

+ * serve.c we'll call BUG() on its equivalent (the

+ * PACKET_READ_RESPONSE_END check).

+ */

+ check_stateless_delimiter(stateless_rpc, reader,

+ _("expected response end packet after ref listing"));

+

+ return 0;

+}

+

+ if (!f->skip_hash)

+ the_hash_algo->update_fn(&f->ctx, f->buffer, offset);

+

+ if (f->skip_hash)

+ hashclr(f->buffer);

+ else

+ the_hash_algo->final_fn(f->buffer, &f->ctx);

+

+ if (!f->skip_hash)

+ the_hash_algo->update_fn(&f->ctx, buf, nr);

+ f->skip_hash = 0;

+

+ /**

+ * If non-zero, skip_hash indicates that we should

+ * not actually compute the hash for this hashfile and

+ * instead only use it as a buffered write.

+ */

+ int skip_hash;

+ reuse_worktree_file(r->index, one->path, &one->oid, 1))) {

+ if (lstat(one->path, &st) < 0) {

+ die_errno("stat(%s)", one->path);

+ if (strbuf_readlink(&sb, one->path, st.st_size) < 0)

+ die_errno("readlink(%s)", one->path);

+ prep_temp_blob(r->index, one->path, temp, sb.buf, sb.len,

+ temp->name = one->path;

+ prep_temp_blob(r->index, one->path, temp,

+ struct diff_tempfile *temp = prepare_temp_file(r, df);

+ add_external_diff_name(o->repo, &cmd.args, one);

+ add_external_diff_name(o->repo, &cmd.args, two);

+ if (other) {

+ temp = prepare_temp_file(r, spec);

+ if (!(given->flags & PATTERN_FLAG_MUSTBEDIR) &&

+ strcmp(given->pattern, "/*")) {

+ /* Not a cone pattern. */

+ warning(_("unrecognized pattern: '%s'"), given->pattern);

+ goto clear_hashmaps;

+ }

+

+ return submodule_move_head(ce->name, state->super_prefix,

+ unlink_entry(ce, state->super_prefix);

+ return submodule_move_head(ce->name, state->super_prefix,

+ return submodule_move_head(ce->name, state->super_prefix,

+void unlink_entry(const struct cache_entry *ce, const char *super_prefix)

+ submodule_move_head(ce->name, super_prefix, "HEAD", NULL,

+ const char *super_prefix;

+ *

+ * The "super_prefix" is either NULL, or the "--super-prefix" passed

+ * down from "read-tree" et al.

+void unlink_entry(const struct cache_entry *ce, const char *super_prefix);

+#include "attr.h"

+ if (is_hfs_dotgitattributes(name) || is_ntfs_dotgitattributes(name)) {

+ if (!S_ISLNK(mode))

+ oidset_insert(&options->gitattributes_found,

+ entry_oid);

+ else

+ retval += report(options, tree_oid, OBJ_TREE,

+ FSCK_MSG_GITATTRIBUTES_SYMLINK,

+ ".gitattributes is a symlink");

+ }

+

+ int ret = 0;

+ if (oidset_contains(&options->gitmodules_found, oid)) {

+ struct config_options config_opts = { 0 };

+ struct fsck_gitmodules_data data;

+

+ oidset_insert(&options->gitmodules_done, oid);

+

+ if (!buf) {

+ /*

+ * A missing buffer here is a sign that the caller found the

+ * blob too gigantic to load into memory. Let's just consider

+ * that an error.

+ */

+ return report(options, oid, OBJ_BLOB,

+ FSCK_MSG_GITMODULES_LARGE,

+ ".gitmodules too large to parse");

+ }

+

+ data.oid = oid;

+ data.options = options;

+ data.ret = 0;

+ config_opts.error_action = CONFIG_ERROR_SILENT;

+ if (git_config_from_mem(fsck_gitmodules_fn, CONFIG_ORIGIN_BLOB,

+ ".gitmodules", buf, size, &data, &config_opts))

+ data.ret |= report(options, oid, OBJ_BLOB,

+ FSCK_MSG_GITMODULES_PARSE,

+ "could not parse gitmodules blob");

+ ret |= data.ret;

+ if (oidset_contains(&options->gitattributes_found, oid)) {

+ const char *ptr;

+

+ oidset_insert(&options->gitattributes_done, oid);

+

+ if (!buf || size > ATTR_MAX_FILE_SIZE) {

+ /*

+ * A missing buffer here is a sign that the caller found the

+ * blob too gigantic to load into memory. Let's just consider

+ * that an error.

+ */

+ return report(options, oid, OBJ_BLOB,

+ FSCK_MSG_GITATTRIBUTES_LARGE,

+ ".gitattributes too large to parse");

+ }

+

+ for (ptr = buf; *ptr; ) {

+ const char *eol = strchrnul(ptr, '\n');

+ if (eol - ptr >= ATTR_MAX_LINE_LENGTH) {

+ ret |= report(options, oid, OBJ_BLOB,

+ FSCK_MSG_GITATTRIBUTES_LINE_LENGTH,

+ ".gitattributes has too long lines to parse");

+ break;

+ }

+

+ ptr = *eol ? eol + 1 : eol;

+ }

+ }

+

+ return ret;

+static int fsck_blobs(struct oidset *blobs_found, struct oidset *blobs_done,

+ enum fsck_msg_id msg_missing, enum fsck_msg_id msg_type,

+ struct fsck_options *options, const char *blob_type)

+ oidset_iter_init(blobs_found, &iter);

+ if (oidset_contains(blobs_done, oid))

+ oid, OBJ_BLOB, msg_missing,

+ "unable to read %s blob", blob_type);

+ ret |= report(options, oid, type, msg_type,

+ "non-blob found at %s", blob_type);

+ oidset_clear(blobs_found);

+ oidset_clear(blobs_done);

+

+ return ret;

+}

+

+int fsck_finish(struct fsck_options *options)

+{

+ int ret = 0;

+

+ ret |= fsck_blobs(&options->gitmodules_found, &options->gitmodules_done,

+ FSCK_MSG_GITMODULES_MISSING, FSCK_MSG_GITMODULES_BLOB,

+ options, ".gitmodules");

+ ret |= fsck_blobs(&options->gitattributes_found, &options->gitattributes_done,

+ FSCK_MSG_GITATTRIBUTES_MISSING, FSCK_MSG_GITATTRIBUTES_BLOB,

+ options, ".gitattributes");

+ FUNC(GITATTRIBUTES_MISSING, ERROR) \

+ FUNC(GITATTRIBUTES_LARGE, ERROR) \

+ FUNC(GITATTRIBUTES_LINE_LENGTH, ERROR) \

+ FUNC(GITATTRIBUTES_BLOB, ERROR) \

+ struct oidset gitattributes_found;

+ struct oidset gitattributes_done;

+ .gitattributes_found = OIDSET_INIT, \

+ .gitattributes_done = OIDSET_INIT, \

+ .gitattributes_found = OIDSET_INIT, \

+ .gitattributes_done = OIDSET_INIT, \

+ .gitattributes_found = OIDSET_INIT, \

+ .gitattributes_done = OIDSET_INIT, \

+static inline int cast_size_t_to_int(size_t a)

+{

+ if (a > INT_MAX)

+ die("number too large to represent as int on this platform: %"PRIuMAX,

+ (uintmax_t)a);

+ return (int)a;

+}

+

+/**

+ * CURLOPT_PROTOCOLS_STR and CURLOPT_REDIR_PROTOCOLS_STR were added in 7.85.0,

+ * released in August 2022.

+ */

+#if LIBCURL_VERSION_NUM >= 0x075500

+#define GIT_CURL_HAVE_CURLOPT_PROTOCOLS_STR 1

+#endif

+

+#define DELAY_PAGER_CONFIG (1<<4)

+#define NO_PARSEOPT (1<<5) /* parse-options is not used */

+ " [--config-env=<name>=<envvar>] <command> [<args>]");

+ RUN_SETUP | NEED_WORK_TREE },

+ { "fsmonitor--daemon", cmd_fsmonitor__daemon, RUN_SETUP },

+ { "read-tree", cmd_read_tree, RUN_SETUP },

+ { "submodule--helper", cmd_submodule__helper, RUN_SETUP },

+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);

+ curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, seek_buffer);

+ curl_easy_setopt(curl, CURLOPT_SEEKDATA, buffer);

+int seek_buffer(void *clientp, curl_off_t offset, int origin)

+ if (origin != SEEK_SET)

+ BUG("seek_buffer only handles SEEK_SET");

+ if (offset < 0 || offset >= buffer->buf.len) {

+ error("curl seek would be outside of buffer");

+ return CURL_SEEKFUNC_FAIL;

+

+ buffer->posn = offset;

+ return CURL_SEEKFUNC_OK;

+static void proto_list_append(struct strbuf *list, const char *proto)

+ if (!list)

+ return;

+ if (list->len)

+ strbuf_addch(list, ',');

+ strbuf_addstr(list, proto);

+}

+static long get_curl_allowed_protocols(int from_user, struct strbuf *list)

+{

+ long bits = 0;

+ if (is_transport_allowed("http", from_user)) {

+ bits |= CURLPROTO_HTTP;

+ proto_list_append(list, "http");

+ }

+ if (is_transport_allowed("https", from_user)) {

+ bits |= CURLPROTO_HTTPS;

+ proto_list_append(list, "https");

+ }

+ if (is_transport_allowed("ftp", from_user)) {

+ bits |= CURLPROTO_FTP;

+ proto_list_append(list, "ftp");

+ }

+ if (is_transport_allowed("ftps", from_user)) {

+ bits |= CURLPROTO_FTPS;

+ proto_list_append(list, "ftps");

+ }

+

+ return bits;

+

+#ifdef GIT_CURL_HAVE_CURLOPT_PROTOCOLS_STR

+ {

+ struct strbuf buf = STRBUF_INIT;

+

+ get_curl_allowed_protocols(0, &buf);

+ curl_easy_setopt(result, CURLOPT_REDIR_PROTOCOLS_STR, buf.buf);

+ strbuf_reset(&buf);

+

+ get_curl_allowed_protocols(-1, &buf);

+ curl_easy_setopt(result, CURLOPT_PROTOCOLS_STR, buf.buf);

+ strbuf_release(&buf);

+ }

+#else

+ get_curl_allowed_protocols(0, NULL));

+ get_curl_allowed_protocols(-1, NULL));

+#endif

+

+int seek_buffer(void *clientp, curl_off_t offset, int origin);

+ while (*start) {

+ while (bol > start && *--bol != '\n')

+ ; /* nothing */

+ return NULL;

+ * Map and close the given loose object fd. The path argument is used for

+ * error reporting.

+static void *map_fd(int fd, const char *path, unsigned long *size)

+ void *map = NULL;

+ struct stat st;

+ if (!fstat(fd, &st)) {

+ *size = xsize_t(st.st_size);

+ if (!*size) {

+ /* mmap() is forbidden on empty files */

+ error(_("object file %s is empty"), path);

+ close(fd);

+ return NULL;

+ map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);

+ close(fd);

+ const char *p;

+ int fd = open_loose_object(r, oid, &p);

+

+ if (fd < 0)

+ return NULL;

+ return map_fd(fd, p, size);

+ int fd;

+ const char *path;

+ fd = open_loose_object(r, oid, &path);

+ if (fd < 0) {

+ if (errno != ENOENT)

+ error_errno(_("unable to open loose object %s"), oid_to_hex(oid));

+ return -1;

+ }

+ map = map_fd(fd, path, &mapsize);

+ if (status && (flags & OBJECT_INFO_DIE_IF_CORRUPT))

+ die(_("loose object %s (stored in %s) is corrupt"),

+ oid_to_hex(oid), path);

+

+ if (flags & OBJECT_INFO_DIE_IF_CORRUPT) {

+ const struct packed_git *p;

+ if ((flags & OBJECT_INFO_LOOKUP_REPLACE) && !oideq(real, oid))

+ die(_("replacement %s not found for %s"),

+ oid_to_hex(real), oid_to_hex(oid));

+ if ((p = has_packed_and_bad(r, real)))

+ die(_("packed object %s (stored in %s) is corrupt"),

+ oid_to_hex(real), p->pack_name);

+ }

+ * deal with them should arrange to call oid_object_info_extended() and give

+ * error messages themselves.

+void *repo_read_object_file(struct repository *r,

+ const struct object_id *oid,

+ enum object_type *type,

+ unsigned long *size)

+ struct object_info oi = OBJECT_INFO_INIT;

+ unsigned flags = OBJECT_INFO_DIE_IF_CORRUPT | OBJECT_INFO_LOOKUP_REPLACE;

+ oi.typep = type;

+ oi.sizep = size;

+ oi.contentp = &data;

+ if (oid_object_info_extended(r, oid, &oi, flags))

+ return NULL;

+ return data;

+ struct object_info oi = OBJECT_INFO_INIT;

+ oi.typep = &type;

+ oi.sizep = &len;

+ oi.contentp = &buf;

+ if (oid_object_info_extended(the_repository, oid, &oi, 0))

+ int fd;

+ fd = git_open(path);

+ if (fd >= 0)

+ map = map_fd(fd, path, &mapsize);

+void *repo_read_object_file(struct repository *r,

+ const struct object_id *oid,

+ enum object_type *type,

+ unsigned long *size);

+ * read_object_with_reference(), oid_object_info() and oid_object_info_extended().

+#define OBJECT_INFO_SKIP_FETCH_OBJECT 16

+/* Die if object corruption (not just an object being missing) was detected. */

+#define OBJECT_INFO_DIE_IF_CORRUPT 32

+

+ struct object_info oi = OBJECT_INFO_INIT;

+

+

+ oi.typep = &type;

+ oi.sizep = &base_size;

+ oi.contentp = &base;

+ if (oid_object_info_extended(r, &base_oid, &oi, 0) < 0)

+ base = NULL;

+

+#define OPT__SUPER_PREFIX(var) \

+ OPT_STRING_F(0, "super-prefix", (var), N_("prefix"), \

+ N_("prefixed path to initial superproject"), PARSE_OPT_HIDDEN)

+

+/*

+ * The limit for formatting directives, which enable the caller to append

+ * arbitrarily many bytes to the formatted buffer. This includes padding

+ * and wrapping formatters.

+ */

+#define FORMATTING_LIMIT (16 * 1024)

+

+ cast_size_t_to_int(indent1),

+ cast_size_t_to_int(indent2),

+ cast_size_t_to_int(width));

+ if (!*end || end == start)

+

+ /*

+ * We need to limit the amount of padding, or otherwise this

+ * would allow the user to pad the buffer by arbitrarily many

+ * bytes and thus cause resource exhaustion.

+ */

+ if (width < -FORMATTING_LIMIT || width > FORMATTING_LIMIT)

+ return 0;

+

+

+ /*

+ * We need to limit the format here as it allows the

+ * user to prepend arbitrarily many bytes to the buffer

+ * when rewrapping.

+ */

+ if (width > FORMATTING_LIMIT ||

+ indent1 > FORMATTING_LIMIT ||

+ indent2 > FORMATTING_LIMIT)

+ return 0;

+ size_t total_consumed = 0;

+ int len, padding = c->padding;

+

+ occupied = utf8_strnwidth(start, strlen(start), 1);

+ size_t consumed = format_commit_one(&local_sb, placeholder, c);

+ len = utf8_strnwidth(local_sb.buf, local_sb.len, 1);

+ while (p > sb->buf && ch - p < 10 && *p != '\033')

+ size_t sb_len = sb->len, offset = 0;

+ size_t consumed, orig_len;

+ if (magic != NO_MAGIC) {

+ switch (placeholder[0]) {

+ case 'w':

+ /*

+ * `%+w()` cannot ever expand to a non-empty string,

+ * and it potentially changes the layout of preceding

+ * contents. We're thus not able to handle the magic in

+ * this combination and refuse the pattern.

+ */

+ return 0;

+ };

+ }

+

+ unsigned char *start, *end;

+ struct object_id oid;

+ end = (unsigned char *)hdr + size;

+ start = end - the_hash_algo->rawsz;

+ oidread(&oid, start);

+ if (oideq(&oid, null_oid()))

+ return 0;

+

+ if (!hasheq(hash, start))

+ struct repository *r = istate->repo ? istate->repo : the_repository;

+ prepare_repo_settings(r);

+ f->skip_hash = r->settings.index_skip_hash;

+

+ if (starts_with(cp, " <"))

+ if (fflush(out) ||

+ fsync_component(FSYNC_COMPONENT_REFERENCE, get_tempfile_fd(refs->tempfile)) ||

+static int rpc_seek(void *clientp, curl_off_t offset, int origin)

+ if (origin != SEEK_SET)

+ BUG("rpc_seek only handles SEEK_SET, not %d", origin);

+ if (rpc->initial_buffer) {

+ if (offset < 0 || offset > rpc->len) {

+ error("curl seek would be outside of rpc buffer");

+ return CURL_SEEKFUNC_FAIL;

+ rpc->pos = offset;

+ return CURL_SEEKFUNC_OK;

+ error(_("unable to rewind rpc post data - try increasing http.postBuffer"));

+ return CURL_SEEKFUNC_FAIL;

+ curl_easy_setopt(slot->curl, CURLOPT_SEEKFUNCTION, rpc_seek);

+ curl_easy_setopt(slot->curl, CURLOPT_SEEKDATA, rpc);

+/* Used for protocol v2 in order to retrieve refs from a remote */

+struct bundle_list;

+int get_remote_bundle_uri(int fd_out, struct packet_reader *reader,

+ struct bundle_list *bundles, int stateless_rpc);

+

+ r->settings.index_skip_hash = 1;

+ repo_cfg_bool(r, "index.skiphash", &r->settings.index_skip_hash, r->settings.index_skip_hash);

+ int index_skip_hash;

+ * `child_process_clear()`.

+ { "index.skipHash", "false", 1 },

+#include "bundle-uri.h"

+ {

+ .name = "bundle-uri",

+ .advertise = bundle_uri_advertise,

+ .command = bundle_uri_command,

+ },

+

+void strbuf_strip_file_from_path(struct strbuf *sb)

+{

+ char *path_sep = find_last_dir_sep(sb->buf);

+ strbuf_setlen(sb, path_sep ? path_sep - sb->buf + 1 : 0);

+}

+/*

+ * Remove the filename from the provided path string. If the path

+ * contains a trailing separator, then the path is considered a directory

+ * and nothing is modified.

+ *

+ * Examples:

+ * - "/path/to/file" -> "/path/to/"

+ * - "/path/to/dir/" -> "/path/to/dir/"

+ */

+void strbuf_strip_file_from_path(struct strbuf *sb);

+

+ char *buf; /* from oid_object_info_extended() */

+ struct object_info oi = OBJECT_INFO_INIT;

+

+ oi.typep = type;

+ oi.sizep = &st->size;

+ oi.contentp = (void **)&st->u.incore.buf;

+ return oid_object_info_extended(r, oid, &oi,

+ OBJECT_INFO_DIE_IF_CORRUPT);

+static void submodule_reset_index(const char *path, const char *super_prefix)

+ strvec_pushf(&cp.args, "--super-prefix=%s%s/",

+ (super_prefix ? super_prefix : ""), path);

+int submodule_move_head(const char *path, const char *super_prefix,

+ const char *old_head, const char *new_head,

+ unsigned flags)

+ absorb_git_dir_into_superproject(path,

+ super_prefix);

+ submodule_reset_index(path, super_prefix);

+ strvec_pushf(&cp.args, "--super-prefix=%s%s/",

+ (super_prefix ? super_prefix : ""), path);

+static void relocate_single_git_dir_into_superproject(const char *path,

+ const char *super_prefix)

+ super_prefix ? super_prefix : "", path,

+static void absorb_git_dir_into_superproject_recurse(const char *path,

+ const char *super_prefix)

+ strvec_pushf(&cp.args, "--super-prefix=%s%s/", super_prefix ?

+ super_prefix : "", path);

+

+void absorb_git_dir_into_superproject(const char *path,

+ const char *super_prefix)

+ relocate_single_git_dir_into_superproject(path, super_prefix);

+ absorb_git_dir_into_superproject_recurse(path, super_prefix);

+int submodule_move_head(const char *path, const char *super_prefix,

+ const char *old_head, const char *new_head,

+void absorb_git_dir_into_superproject(const char *path,

+ const char *super_prefix);

+#include "transport.h"

+#include "ref-filter.h"

+#include "remote.h"

+#include "refs.h"

+ list.baseURI = xstrdup("<uri>");

+

+static int cmd_ls_remote(int argc, const char **argv)

+{

+ const char *dest;

+ struct remote *remote;

+ struct transport *transport;

+ int status = 0;

+

+ dest = argc > 1 ? argv[1] : NULL;

+

+ remote = remote_get(dest);

+ if (!remote) {

+ if (dest)

+ die(_("bad repository '%s'"), dest);

+ die(_("no remote configured to get bundle URIs from"));

+ }

+ if (!remote->url_nr)

+ die(_("remote '%s' has no configured URL"), dest);

+

+ transport = transport_get(remote, NULL);

+ if (transport_get_remote_bundle_uri(transport) < 0) {

+ error(_("could not get the bundle-uri list"));

+ status = 1;

+ goto cleanup;

+ }

+

+ print_bundle_list(stdout, transport->bundles);

+

+cleanup:

+ if (transport_disconnect(transport))

+ return 1;

+ return status;

+}

+

+ if (!strcmp(argv[1], "ls-remote"))

+ return cmd_ls_remote(argc - 1, argv + 1);

+# Set up and run tests of the 'bundle-uri' command in protocol v2

+#

+# The test that includes this script should set BUNDLE_URI_PROTOCOL

+# to one of "file", "git", or "http".

+

+BUNDLE_URI_TEST_PARENT=

+BUNDLE_URI_TEST_URI=

+BUNDLE_URI_TEST_BUNDLE_URI=

+case "$BUNDLE_URI_PROTOCOL" in

+file)

+ BUNDLE_URI_PARENT=file_parent

+ BUNDLE_URI_REPO_URI="file://$PWD/file_parent"

+ BUNDLE_URI_BUNDLE_URI="$BUNDLE_URI_REPO_URI/fake.bdl"

+ test_set_prereq BUNDLE_URI_FILE

+ ;;

+git)

+ . "$TEST_DIRECTORY"/lib-git-daemon.sh

+ start_git_daemon --export-all --enable=receive-pack

+ BUNDLE_URI_PARENT="$GIT_DAEMON_DOCUMENT_ROOT_PATH/parent"

+ BUNDLE_URI_REPO_URI="$GIT_DAEMON_URL/parent"

+ BUNDLE_URI_BUNDLE_URI="https://example.com/fake.bdl"

+ test_set_prereq BUNDLE_URI_GIT

+ ;;

+http)

+ . "$TEST_DIRECTORY"/lib-httpd.sh

+ start_httpd

+ BUNDLE_URI_PARENT="$HTTPD_DOCUMENT_ROOT_PATH/http_parent"

+ BUNDLE_URI_REPO_URI="$HTTPD_URL/smart/http_parent"

+ BUNDLE_URI_BUNDLE_URI="https://example.com/fake.bdl"

+ test_set_prereq BUNDLE_URI_HTTP

+ ;;

+*)

+ BUG "Need to pass valid BUNDLE_URI_PROTOCOL (was \"$BUNDLE_URI_PROTOCOL\")"

+ ;;

+esac

+

+test_expect_success "setup protocol v2 $BUNDLE_URI_PROTOCOL:// tests" '

+ git init "$BUNDLE_URI_PARENT" &&

+ test_commit -C "$BUNDLE_URI_PARENT" one &&

+ git -C "$BUNDLE_URI_PARENT" config uploadpack.advertiseBundleURIs true

+'

+

+case "$BUNDLE_URI_PROTOCOL" in

+http)

+ test_expect_success "setup config for $BUNDLE_URI_PROTOCOL:// tests" '

+ git -C "$BUNDLE_URI_PARENT" config http.receivepack true

+ '

+ ;;

+*)

+ ;;

+esac

+BUNDLE_URI_BUNDLE_URI_ESCAPED=$(echo "$BUNDLE_URI_BUNDLE_URI" | test_uri_escape)

+

+test_expect_success "connect with $BUNDLE_URI_PROTOCOL:// using protocol v2: no bundle-uri" '

+ test_when_finished "rm -f log" &&

+ test_when_finished "git -C \"$BUNDLE_URI_PARENT\" config uploadpack.advertiseBundleURIs true" &&

+ git -C "$BUNDLE_URI_PARENT" config uploadpack.advertiseBundleURIs false &&

+

+ GIT_TRACE_PACKET="$PWD/log" \

+ git \

+ -c protocol.version=2 \

+ ls-remote --symref "$BUNDLE_URI_REPO_URI" \

+ >actual 2>err &&

+

+ # Server responded using protocol v2

+ grep "< version 2" log &&

+

+ ! grep bundle-uri log

+'

+

+test_expect_success "connect with $BUNDLE_URI_PROTOCOL:// using protocol v2: have bundle-uri" '

+ test_when_finished "rm -f log" &&

+

+ GIT_TRACE_PACKET="$PWD/log" \

+ git \

+ -c protocol.version=2 \

+ ls-remote --symref "$BUNDLE_URI_REPO_URI" \

+ >actual 2>err &&

+

+ # Server responded using protocol v2

+ grep "< version 2" log &&

+

+ # Server advertised bundle-uri capability

+ grep "< bundle-uri" log

+'

+

+test_expect_success "clone with $BUNDLE_URI_PROTOCOL:// using protocol v2: request bundle-uris" '

+ test_when_finished "rm -rf log* cloned*" &&

+

+ GIT_TRACE_PACKET="$PWD/log" \

+ git \

+ -c transfer.bundleURI=false \

+ -c protocol.version=2 \

+ clone "$BUNDLE_URI_REPO_URI" cloned \

+ >actual 2>err &&

+

+ # Server responded using protocol v2

+ grep "< version 2" log &&

+

+ # Server advertised bundle-uri capability

+ grep "< bundle-uri" log &&

+

+ # Client did not issue bundle-uri command

+ ! grep "> command=bundle-uri" log &&

+

+ GIT_TRACE_PACKET="$PWD/log" \

+ git \

+ -c transfer.bundleURI=true \

+ -c protocol.version=2 \

+ clone "$BUNDLE_URI_REPO_URI" cloned2 \

+ >actual 2>err &&

+

+ # Server responded using protocol v2

+ grep "< version 2" log &&

+

+ # Server advertised bundle-uri capability

+ grep "< bundle-uri" log &&

+

+ # Client issued bundle-uri command

+ grep "> command=bundle-uri" log &&

+

+ GIT_TRACE_PACKET="$PWD/log3" \

+ git \

+ -c transfer.bundleURI=true \

+ -c protocol.version=2 \

+ clone --bundle-uri="$BUNDLE_URI_BUNDLE_URI" \

+ "$BUNDLE_URI_REPO_URI" cloned3 \

+ >actual 2>err &&

+

+ # Server responded using protocol v2

+ grep "< version 2" log3 &&

+

+ # Server advertised bundle-uri capability

+ grep "< bundle-uri" log3 &&

+

+ # Client did not issue bundle-uri command (--bundle-uri override)

+ ! grep "> command=bundle-uri" log3

+'

+

+# The remaining tests will all assume transfer.bundleURI=true

+#

+# This test can be removed when transfer.bundleURI is enabled by default.

+test_expect_success 'enable transfer.bundleURI for remaining tests' '

+ git config --global transfer.bundleURI true

+'

+

+test_expect_success "test bundle-uri with $BUNDLE_URI_PROTOCOL:// using protocol v2" '

+ test_config -C "$BUNDLE_URI_PARENT" \

+ bundle.only.uri "$BUNDLE_URI_BUNDLE_URI_ESCAPED" &&

+

+ # All data about bundle URIs

+ cat >expect <<-EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "only"]

+ uri = $BUNDLE_URI_BUNDLE_URI_ESCAPED

+ EOF

+

+ test-tool bundle-uri \

+ ls-remote \

+ "$BUNDLE_URI_REPO_URI" \

+ >actual &&

+ test_cmp_config_output expect actual

+'

+

+test_expect_success "test bundle-uri with $BUNDLE_URI_PROTOCOL:// using protocol v2 and extra data" '

+ test_config -C "$BUNDLE_URI_PARENT" \

+ bundle.only.uri "$BUNDLE_URI_BUNDLE_URI_ESCAPED" &&

+

+ # Extra data should be ignored

+ test_config -C "$BUNDLE_URI_PARENT" bundle.only.extra bogus &&

+

+ # All data about bundle URIs

+ cat >expect <<-EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "only"]

+ uri = $BUNDLE_URI_BUNDLE_URI_ESCAPED

+ EOF

+

+ test-tool bundle-uri \

+ ls-remote \

+ "$BUNDLE_URI_REPO_URI" \

+ >actual &&

+ test_cmp_config_output expect actual

+'

+

+test_expect_success "test bundle-uri with $BUNDLE_URI_PROTOCOL:// using protocol v2 with list" '

+ test_config -C "$BUNDLE_URI_PARENT" \

+ bundle.bundle1.uri "$BUNDLE_URI_BUNDLE_URI_ESCAPED-1.bdl" &&

+ test_config -C "$BUNDLE_URI_PARENT" \

+ bundle.bundle2.uri "$BUNDLE_URI_BUNDLE_URI_ESCAPED-2.bdl" &&

+ test_config -C "$BUNDLE_URI_PARENT" \

+ bundle.bundle3.uri "$BUNDLE_URI_BUNDLE_URI_ESCAPED-3.bdl" &&

+

+ # All data about bundle URIs

+ cat >expect <<-EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "bundle1"]

+ uri = $BUNDLE_URI_BUNDLE_URI_ESCAPED-1.bdl

+ [bundle "bundle2"]

+ uri = $BUNDLE_URI_BUNDLE_URI_ESCAPED-2.bdl

+ [bundle "bundle3"]

+ uri = $BUNDLE_URI_BUNDLE_URI_ESCAPED-3.bdl

+ EOF

+

+ test-tool bundle-uri \

+ ls-remote \

+ "$BUNDLE_URI_REPO_URI" \

+ >actual &&

+ test_cmp_config_output expect actual

+'

+ # +1 accounts for the trailing newline

+ test $(( $hexsz + 1)) -eq $(wc -c <actual) &&

+ test $(wc -c <actual) -eq 41 &&

+ test $(wc -c <actual) -eq 65 &&

+test_expect_success 'large attributes line ignored in tree' '

+ test_when_finished "rm .gitattributes" &&

+ printf "path %02043d" 1 >.gitattributes &&

+ git check-attr --all path >actual 2>err &&

+ echo "warning: ignoring overly long attributes line 1" >expect &&

+ test_cmp expect err &&

+ test_must_be_empty actual

+'

+

+test_expect_success 'large attributes line ignores trailing content in tree' '

+ test_when_finished "rm .gitattributes" &&

+ # older versions of Git broke lines at 2048 bytes; the 2045 bytes

+ # of 0-padding here is accounting for the three bytes of "a 1", which

+ # would knock "trailing" to the "next" line, where it would be

+ # erroneously parsed.

+ printf "a %02045dtrailing attribute\n" 1 >.gitattributes &&

+ git check-attr --all trailing >actual 2>err &&

+ echo "warning: ignoring overly long attributes line 1" >expect &&

+ test_cmp expect err &&

+ test_must_be_empty actual

+'

+

+test_expect_success EXPENSIVE 'large attributes file ignored in tree' '

+ test_when_finished "rm .gitattributes" &&

+ dd if=/dev/zero of=.gitattributes bs=101M count=1 2>/dev/null &&

+ git check-attr --all path >/dev/null 2>err &&

+ echo "warning: ignoring overly large gitattributes file ${SQ}.gitattributes${SQ}" >expect &&

+ test_cmp expect err

+'

+

+test_expect_success 'large attributes line ignored in index' '

+ test_when_finished "git update-index --remove .gitattributes" &&

+ blob=$(printf "path %02043d" 1 | git hash-object -w --stdin) &&

+ git update-index --add --cacheinfo 100644,$blob,.gitattributes &&

+ git check-attr --cached --all path >actual 2>err &&

+ echo "warning: ignoring overly long attributes line 1" >expect &&

+ test_cmp expect err &&

+ test_must_be_empty actual

+'

+

+test_expect_success 'large attributes line ignores trailing content in index' '

+ test_when_finished "git update-index --remove .gitattributes" &&

+ blob=$(printf "a %02045dtrailing attribute\n" 1 | git hash-object -w --stdin) &&

+ git update-index --add --cacheinfo 100644,$blob,.gitattributes &&

+ git check-attr --cached --all trailing >actual 2>err &&

+ echo "warning: ignoring overly long attributes line 1" >expect &&

+ test_cmp expect err &&

+ test_must_be_empty actual

+'

+

+test_expect_success EXPENSIVE 'large attributes file ignored in index' '

+ test_when_finished "git update-index --remove .gitattributes" &&

+ blob=$(dd if=/dev/zero bs=101M count=1 2>/dev/null | git hash-object -w --stdin) &&

+ git update-index --add --cacheinfo 100644,$blob,.gitattributes &&

+ git check-attr --cached --all path >/dev/null 2>err &&

+ echo "warning: ignoring overly large gitattributes blob ${SQ}.gitattributes${SQ}" >expect &&

+ test_cmp expect err

+'

+

+ test_must_fail git read-tree --super-prefix fictional/ -u -m "$treeH" "$treeM" 2>actual &&

+ echo "!/deep/deeper/*/" >>repo/.git/info/sparse-checkout &&

+test_expect_success 'pattern-checks: non directory pattern' '

+ cat >repo/.git/info/sparse-checkout <<-\EOF &&

+ /deep/deeper1/a

+ EOF

+ check_read_tree_errors repo deep "disabling cone pattern matching" &&

+ check_files repo/deep deeper1 &&

+ check_files repo/deep/deeper1 a

+'

+

+TEST_CREATE_REPO_NO_TEMPLATE=1

+ test_when_finished "rm -rf sub" &&

+ test_when_finished "rm -rf new" &&

+ git init --shared=0660 --template=../templates &&

+ test_path_is_file .git/hooks/post-update &&

+ test_when_finished "rm -rf child.git" &&

+ test_when_finished "rm -rf child.git" &&

+ test_when_finished "rm -rf child.git" &&

+ test_oid version >expect &&

+test_expect_success 'fsck error on gitattributes with excessive line lengths' '

+ blob=$(printf "pattern %02048d" 1 | git hash-object -w --stdin) &&

+ test_when_finished "remove_object $blob" &&

+ tree=$(printf "100644 blob %s\t%s\n" $blob .gitattributes | git mktree) &&

+ test_when_finished "remove_object $tree" &&

+ cat >expected <<-EOF &&

+ error in blob $blob: gitattributesLineLength: .gitattributes has too long lines to parse

+ EOF

+ test_must_fail git fsck --no-dangling >actual 2>&1 &&

+ test_cmp expected actual

+'

+

+test_expect_success 'fsck error on gitattributes with excessive size' '

+ blob=$(test-tool genzeros $((100 * 1024 * 1024 + 1)) | git hash-object -w --stdin) &&

+ test_when_finished "remove_object $blob" &&

+ tree=$(printf "100644 blob %s\t%s\n" $blob .gitattributes | git mktree) &&

+ test_when_finished "remove_object $tree" &&

+ cat >expected <<-EOF &&

+ error in blob $blob: gitattributesLarge: .gitattributes too large to parse

+ EOF

+ test_must_fail git fsck --no-dangling >actual 2>&1 &&

+ test_cmp expected actual

+'

+

+ test_oid algo >expect &&

+ test_cmp expected result &&

+ git config --global --add safe.directory /

+ rm -f /HEAD /expected /ls.expected /me /result &&

+test_expect_success 'cleanup root' '

+ rm -rf /.git /refs /objects /info /hooks /branches /foo &&

+ rm -f /HEAD /config /description /expected /ls.expected /me /result

+'

+

+test_expect_success 'index.skipHash config option' '

+ rm -f .git/index &&

+ git -c index.skipHash=true add a &&

+ test_trailing_hash .git/index >hash &&

+ echo $(test_oid zero) >expect &&

+ test_cmp expect hash &&

+ git fsck &&

+

+ rm -f .git/index &&

+ git -c feature.manyFiles=true add a &&

+ test_trailing_hash .git/index >hash &&

+ cmp expect hash &&

+

+ rm -f .git/index &&

+ git -c feature.manyFiles=true \

+ -c index.skipHash=false add a &&

+ test_trailing_hash .git/index >hash &&

+ ! cmp expect hash &&

+

+ test_commit start &&

+ git -c protocol.file.allow=always submodule add ./ sub &&

+ git config index.skipHash false &&

+ git -C sub config index.skipHash true &&

+ >sub/file &&

+ git -C sub add a &&

+ test_trailing_hash .git/modules/sub/index >hash &&

+ test_cmp expect hash &&

+ git -C sub fsck

+'

+

+test_expect_success '-c format.mboxrd format-patch' '

+ git -c format.mboxrd format-patch --stdout -1 $C~1..$C >patch &&

+ git format-patch --pretty=mboxrd --stdout -1 $C~1..$C >compat &&

+ test_cmp patch compat &&

+ test_oid val1 > foo &&

+ test_oid val2 > foo &&

+test_expect_success 'external diff with --relative' '

+ test_when_finished "git reset --hard" &&

+ echo changed >file1 &&

+ echo changed >subdir/file2 &&

+

+ write_script mydiff <<-\EOF &&

+ # hacky pretend diff; the goal here is just to make sure we got

+ # passed sensible input that we _could_ diff, without relying on

+ # the specific output of a system diff tool.

+ echo "diff a/$1 b/$1" &&

+ echo "--- a/$1" &&

+ echo "+++ b/$1" &&

+ echo "@@ -1 +0,0 @@" &&

+ sed "s/^/-/" "$2" &&

+ sed "s/^/+/" "$5"

+ EOF

+

+ cat >expect <<-\EOF &&

+ diff a/file2 b/file2

+ --- a/file2

+ +++ b/file2

+ @@ -1 +0,0 @@

+ -other content

+ +changed

+ EOF

+ GIT_EXTERNAL_DIFF=./mydiff git diff --relative=subdir >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'am with failing applypatch-msg hook (no verify)' '

+ rm -fr .git/rebase-apply &&

+ git reset --hard &&

+ git checkout first &&

+ test_hook applypatch-msg <<-\EOF &&

+ echo hook-message >"$1"

+ exit 1

+ EOF

+ git am --no-verify patch1 &&

+ test_path_is_missing .git/rebase-apply &&

+ git diff --exit-code second &&

+ git log -1 --format=format:%B >actual &&

+ test_cmp msg actual

+'

+

+test_expect_success 'am with failing pre-applypatch hook (no verify)' '

+ rm -fr .git/rebase-apply &&

+ git reset --hard &&

+ git checkout first &&

+ touch empty-file &&

+ test_hook pre-applypatch <<-\EOF &&

+ rm empty-file

+ exit 1

+ EOF

+ git am --no-verify patch1 &&

+ test_path_is_missing .git/rebase-apply &&

+ test_path_is_file empty-file &&

+ git diff --exit-code second &&

+ git log -1 --format=format:%B >actual &&

+ test_cmp msg actual

+'

+

+ git -c format.mboxrd format-patch --stdout -1 >mboxrd1 &&

+test_expect_success 'git cat-file -s returns correct size with --use-mailmap' '

+ test_when_finished "rm .mailmap" &&

+ cat >.mailmap <<-\EOF &&

+ C O Mitter <committer@example.com> Orig <orig@example.com>

+ EOF

+ git cat-file commit HEAD >commit.out &&

+ echo $(wc -c <commit.out) >expect &&

+ git cat-file --use-mailmap commit HEAD >commit.out &&

+ echo $(wc -c <commit.out) >>expect &&

+ git cat-file -s HEAD >actual &&

+ git cat-file --use-mailmap -s HEAD >>actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'git cat-file -s returns correct size with --use-mailmap for tag objects' '

+ test_when_finished "rm .mailmap" &&

+ cat >.mailmap <<-\EOF &&

+ Orig <orig@example.com> C O Mitter <committer@example.com>

+ EOF

+ git tag -a -m "annotated tag" v3 &&

+ git cat-file tag v3 >tag.out &&

+ echo $(wc -c <tag.out) >expect &&

+ git cat-file --use-mailmap tag v3 >tag.out &&

+ echo $(wc -c <tag.out) >>expect &&

+ git cat-file -s v3 >actual &&

+ git cat-file --use-mailmap -s v3 >>actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'git cat-file --batch-check returns correct size with --use-mailmap' '

+ test_when_finished "rm .mailmap" &&

+ cat >.mailmap <<-\EOF &&

+ C O Mitter <committer@example.com> Orig <orig@example.com>

+ EOF

+ git cat-file commit HEAD >commit.out &&

+ commit_size=$(wc -c <commit.out) &&

+ commit_sha=$(git rev-parse HEAD) &&

+ echo $commit_sha commit $commit_size >expect &&

+ git cat-file --use-mailmap commit HEAD >commit.out &&

+ commit_size=$(wc -c <commit.out) &&

+ echo $commit_sha commit $commit_size >>expect &&

+ echo "HEAD" >in &&

+ git cat-file --batch-check <in >actual &&

+ git cat-file --use-mailmap --batch-check <in >>actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'git cat-file --batch-command returns correct size with --use-mailmap' '

+ test_when_finished "rm .mailmap" &&

+ cat >.mailmap <<-\EOF &&

+ C O Mitter <committer@example.com> Orig <orig@example.com>

+ EOF

+ git cat-file commit HEAD >commit.out &&

+ commit_size=$(wc -c <commit.out) &&

+ commit_sha=$(git rev-parse HEAD) &&

+ echo $commit_sha commit $commit_size >expect &&

+ git cat-file --use-mailmap commit HEAD >commit.out &&

+ commit_size=$(wc -c <commit.out) &&

+ echo $commit_sha commit $commit_size >>expect &&

+ echo "info HEAD" >in &&

+ git cat-file --batch-command <in >actual &&

+ git cat-file --use-mailmap --batch-command <in >>actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'log --pretty with space stealing' '

+ printf mm0 >expect &&

+ git log -1 --pretty="format:mm%>>|(1)%x30" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'log --pretty with invalid padding format' '

+ printf "%s%%<(20" "$(git rev-parse HEAD)" >expect &&

+ git log -1 --pretty="format:%H%<(20" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'log --pretty with magical wrapping directives' '

+ commit_id=$(git commit-tree HEAD^{tree} -m "describe me") &&

+ git tag describe-me $commit_id &&

+ printf "\n(tag:\ndescribe-me)%%+w(2)" >expect &&

+ git log -1 --pretty="format:%w(1)%+d%+w(2)" $commit_id >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success SIZE_T_IS_64BIT 'log --pretty with overflowing wrapping directive' '

+ printf "%%w(2147483649,1,1)0" >expect &&

+ git log -1 --pretty="format:%w(2147483649,1,1)%x30" >actual &&

+ test_cmp expect actual &&

+ printf "%%w(1,2147483649,1)0" >expect &&

+ git log -1 --pretty="format:%w(1,2147483649,1)%x30" >actual &&

+ test_cmp expect actual &&

+ printf "%%w(1,1,2147483649)0" >expect &&

+ git log -1 --pretty="format:%w(1,1,2147483649)%x30" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success SIZE_T_IS_64BIT 'log --pretty with overflowing padding directive' '

+ printf "%%<(2147483649)0" >expect &&

+ git log -1 --pretty="format:%<(2147483649)%x30" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'log --pretty with padding and preceding control chars' '

+ printf "\20\20 0" >expect &&

+ git log -1 --pretty="format:%x10%x10%>|(4)%x30" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'log --pretty truncation with control chars' '

+ test_commit "$(printf "\20\20\20\20xxxx")" file contents commit-with-control-chars &&

+ printf "\20\20\20\20x.." >expect &&

+ git log -1 --pretty="format:%<(3,trunc)%s" commit-with-control-chars >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success EXPENSIVE,SIZE_T_IS_64BIT 'log --pretty with huge commit message' '

+ # We only assert that this command does not crash. This needs to be

+ # executed with the address sanitizer to demonstrate failure.

+ git log -1 --pretty="format:%>(2147483646)%x41%41%>(2147483646)%x41" >/dev/null

+'

+

+test_expect_success EXPENSIVE,SIZE_T_IS_64BIT 'set up huge commit' '

+ test-tool genzeros 2147483649 | tr "\000" "1" >expect &&

+ huge_commit=$(git commit-tree -F expect HEAD^{tree})

+'

+

+test_expect_success EXPENSIVE,SIZE_T_IS_64BIT 'log --pretty with huge commit message' '

+ git log -1 --format="%B%<(1)%x30" $huge_commit >actual &&

+ echo 0 >>expect &&

+ test_cmp expect actual

+'

+

+test_expect_success EXPENSIVE,SIZE_T_IS_64BIT 'log --pretty with huge commit message does not cause allocation failure' '

+ test_must_fail git log -1 --format="%<(1)%B" $huge_commit 2>error &&

+ cat >expect <<-EOF &&

+ fatal: number too large to represent as int on this platform: 2147483649

+ EOF

+ test_cmp expect error

+'

+

+test_expect_success 'setup tests for zero-width regular expressions' '

+ cat >expect <<-EOF

+ Modify func1() in file.c

+ Add func1() and func2() in file.c

+ EOF

+'

+

+test_expect_success 'zero-width regex $ matches any function name' '

+ git log --format="%s" --no-patch "-L:$:file.c" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'zero-width regex ^ matches any function name' '

+ git log --format="%s" --no-patch "-L:^:file.c" >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'zero-width regex .* matches any function name' '

+ git log --format="%s" --no-patch "-L:.*:file.c" >actual &&

+ test_cmp expect actual

+'

+

+# Expected: CONFLICT(content) for newdir/bar (not olddir/bar or foo)

+# Expected: CONFLICT(content) for newdir/bar (not olddir/bar or foo)

+ test_oid oidfff >file &&

+test_expect_success 'auto-discover bundle URI from HTTP clone' '

+ test_when_finished rm -rf trace.txt repo2 "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" &&

+ git -C src bundle create "$HTTPD_DOCUMENT_ROOT_PATH/everything.bundle" --all &&

+ git clone --bare --no-local src "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" &&

+

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" config \

+ uploadpack.advertiseBundleURIs true &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" config \

+ bundle.version 1 &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" config \

+ bundle.mode all &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo2.git" config \

+ bundle.everything.uri "$HTTPD_URL/everything.bundle" &&

+

+ GIT_TRACE2_EVENT="$(pwd)/trace.txt" \

+ git -c protocol.version=2 \

+ -c transfer.bundleURI=true clone \

+ $HTTPD_URL/smart/repo2.git repo2 &&

+ cat >pattern <<-EOF &&

+ "event":"child_start".*"argv":\["git-remote-https","$HTTPD_URL/everything.bundle"\]

+ EOF

+ grep -f pattern trace.txt

+'

+

+test_expect_success 'auto-discover multiple bundles from HTTP clone' '

+ test_when_finished rm -rf trace.txt repo3 "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" &&

+

+ test_commit -C src new &&

+ git -C src bundle create "$HTTPD_DOCUMENT_ROOT_PATH/new.bundle" HEAD~1..HEAD &&

+ git clone --bare --no-local src "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" &&

+

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" config \

+ uploadpack.advertiseBundleURIs true &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" config \

+ bundle.version 1 &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" config \

+ bundle.mode all &&

+

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" config \

+ bundle.everything.uri "$HTTPD_URL/everything.bundle" &&

+ git -C "$HTTPD_DOCUMENT_ROOT_PATH/repo3.git" config \

+ bundle.new.uri "$HTTPD_URL/new.bundle" &&

+

+ GIT_TRACE2_EVENT="$(pwd)/trace.txt" \

+ git -c protocol.version=2 \

+ -c transfer.bundleURI=true clone \

+ $HTTPD_URL/smart/repo3.git repo3 &&

+

+ # We should fetch _both_ bundles

+ cat >pattern <<-EOF &&

+ "event":"child_start".*"argv":\["git-remote-https","$HTTPD_URL/everything.bundle"\]

+ EOF

+ grep -f pattern trace.txt &&

+ cat >pattern <<-EOF &&

+ "event":"child_start".*"argv":\["git-remote-https","$HTTPD_URL/new.bundle"\]

+ EOF

+ grep -f pattern trace.txt

+'

+

+test_expect_success 'lazy-fetch in submodule succeeds' '

+ # setup

+ test_config_global protocol.file.allow always &&

+

+ test_when_finished "rm -rf src-sub" &&

+ git init src-sub &&

+ git -C src-sub config uploadpack.allowfilter 1 &&

+ git -C src-sub config uploadpack.allowanysha1inwant 1 &&

+

+ # This blob must be missing in the subsequent commit.

+ echo foo >src-sub/file &&

+ git -C src-sub add file &&

+ git -C src-sub commit -m "submodule one" &&

+ SUB_ONE=$(git -C src-sub rev-parse HEAD) &&

+

+ echo bar >src-sub/file &&

+ git -C src-sub add file &&

+ git -C src-sub commit -m "submodule two" &&

+ SUB_TWO=$(git -C src-sub rev-parse HEAD) &&

+

+ test_when_finished "rm -rf src-super" &&

+ git init src-super &&

+ git -C src-super config uploadpack.allowfilter 1 &&

+ git -C src-super config uploadpack.allowanysha1inwant 1 &&

+ git -C src-super submodule add ../src-sub src-sub &&

+

+ git -C src-super/src-sub checkout $SUB_ONE &&

+ git -C src-super add src-sub &&

+ git -C src-super commit -m "superproject one" &&

+

+ git -C src-super/src-sub checkout $SUB_TWO &&

+ git -C src-super add src-sub &&

+ git -C src-super commit -m "superproject two" &&

+

+ # the fetch

+ test_when_finished "rm -rf client" &&

+ git clone --filter=blob:none --also-filter-submodules \

+ --recurse-submodules "file://$(pwd)/src-super" client &&

+

+ # Trigger lazy-fetch from the superproject

+ git -C client restore --recurse-submodules --source=HEAD^ :/

+'

+

+ cat >expect.base <<-EOF &&

+ EOF

+ cat >expect.trailer <<-EOF &&

+ cat expect.base expect.trailer >expect &&

+test_expect_success 'test capability advertisement with uploadpack.advertiseBundleURIs' '

+ test_config uploadpack.advertiseBundleURIs true &&

+

+ cat >expect.extra <<-EOF &&

+ bundle-uri

+ EOF

+ cat expect.base \

+ expect.extra \

+ expect.trailer >expect &&

+

+ GIT_TEST_SIDEBAND_ALL=0 test-tool serve-v2 \

+ --advertise-capabilities >out &&

+ test-tool pkt-line unpack <out >actual &&

+ test_cmp expect actual

+'

+

+test_expect_success 'basics of bundle-uri: dies if not enabled' '

+ test-tool pkt-line pack >in <<-EOF &&

+ command=bundle-uri

+ 0000

+ EOF

+

+ cat >err.expect <<-\EOF &&

+ fatal: invalid command '"'"'bundle-uri'"'"'

+ EOF

+

+ cat >expect <<-\EOF &&

+ ERR serve: invalid command '"'"'bundle-uri'"'"'

+ EOF

+

+ test_must_fail test-tool serve-v2 --stateless-rpc <in >out 2>err.actual &&

+ test_cmp err.expect err.actual &&

+ test_must_be_empty out

+'

+

+#!/bin/sh

+

+test_description="Test bundle-uri with protocol v2 and 'file://' transport"

+

+TEST_NO_CREATE_REPO=1

+

+GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main

+export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

+

+. ./test-lib.sh

+

+# Test protocol v2 with 'file://' transport

+#

+BUNDLE_URI_PROTOCOL=file

+. "$TEST_DIRECTORY"/lib-bundle-uri-protocol.sh

+

+test_done

+#!/bin/sh

+

+test_description="Test bundle-uri with protocol v2 and 'git://' transport"

+

+TEST_NO_CREATE_REPO=1

+

+GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main

+export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

+

+. ./test-lib.sh

+

+# Test protocol v2 with 'git://' transport

+#

+BUNDLE_URI_PROTOCOL=git

+. "$TEST_DIRECTORY"/lib-bundle-uri-protocol.sh

+

+test_done

+#!/bin/sh

+

+test_description="Test bundle-uri with protocol v2 and 'http://' transport"

+

+TEST_NO_CREATE_REPO=1

+

+GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main

+export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

+

+. ./test-lib.sh

+

+# Test protocol v2 with 'http://' transport

+#

+BUNDLE_URI_PROTOCOL=http

+. "$TEST_DIRECTORY"/lib-bundle-uri-protocol.sh

+

+test_done

+test_expect_success 'bundle_uri_parse_line(): relative URIs' '

+ cat >in <<-\EOF &&

+ bundle.one.uri=bundle.bdl

+ bundle.two.uri=../bundle.bdl

+ bundle.three.uri=sub/dir/bundle.bdl

+ EOF

+

+ cat >expect <<-\EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "one"]

+ uri = <uri>/bundle.bdl

+ [bundle "two"]

+ uri = bundle.bdl

+ [bundle "three"]

+ uri = <uri>/sub/dir/bundle.bdl

+ EOF

+

+ test-tool bundle-uri parse-key-values in >actual 2>err &&

+ test_must_be_empty err &&

+ test_cmp_config_output expect actual

+'

+

+test_expect_success 'bundle_uri_parse_line(): relative URIs and parent paths' '

+ cat >in <<-\EOF &&

+ bundle.one.uri=bundle.bdl

+ bundle.two.uri=../bundle.bdl

+ bundle.three.uri=../../bundle.bdl

+ EOF

+

+ cat >expect <<-\EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "one"]

+ uri = <uri>/bundle.bdl

+ [bundle "two"]

+ uri = bundle.bdl

+ [bundle "three"]

+ uri = <uri>/../bundle.bdl

+ EOF

+

+ # TODO: We would prefer if parsing a bundle list would not cause

+ # a die() and instead would give a warning and allow the rest of

+ # a Git command to continue. This test_must_fail is necessary for

+ # now until the interface for relative_url() allows for reporting

+ # an error instead of die()ing.

+ test_must_fail test-tool bundle-uri parse-key-values in >actual 2>err &&

+ grep "fatal: cannot strip one component off url" err

+'

+

+test_expect_success 'parse config format: relative URIs' '

+ cat >in <<-\EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "one"]

+ uri = bundle.bdl

+ [bundle "two"]

+ uri = ../bundle.bdl

+ [bundle "three"]

+ uri = sub/dir/bundle.bdl

+ EOF

+

+ cat >expect <<-\EOF &&

+ [bundle]

+ version = 1

+ mode = all

+ [bundle "one"]

+ uri = <uri>/bundle.bdl

+ [bundle "two"]

+ uri = bundle.bdl

+ [bundle "three"]

+ uri = <uri>/sub/dir/bundle.bdl

+ EOF

+

+ test-tool bundle-uri parse-config in >actual 2>err &&

+ test_must_be_empty err &&

+ test_cmp_config_output expect actual

+'

+

+for cmd in create verify list-heads unbundle

+do

+ test_expect_success "usage: git bundle $cmd needs an argument" '

+ test_expect_code 129 git bundle $cmd

+ '

+done

+

+# both Makefiles and jumps)

+# both Makefiles and jumps)

+ cwd="$(pwd)" &&

+ >expect &&

+ >actual &&

+ cat >expect <<-EOF &&

+ Migrating git directory of '\''sub1'\'' from

+ '\''$cwd/sub1/.git'\'' to

+ '\''$cwd/.git/modules/sub1'\''

+ EOF

+ git submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual &&

+ git submodule absorbgitdirs 2>err &&

+ test_must_be_empty err &&

+ cat >expect <<-EOF &&

+ Migrating git directory of '\''sub1/nested'\'' from

+ '\''$cwd/sub1/nested/.git'\'' to

+ '\''$cwd/.git/modules/sub1/modules/nested'\''

+ EOF

+ git submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual &&

+ cat >expect <<-EOF &&

+ Migrating git directory of '\''sub1'\'' from

+ '\''$cwd/sub1/.git'\'' to

+ '\''$cwd/.git/modules/sub1'\''

+ EOF

+ git submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual &&

+test_expect_success 'absorb the git dir outside of primary worktree' '

+ test_when_finished "rm -rf repo-bare.git" &&

+ git clone --bare . repo-bare.git &&

+ test_when_finished "rm -rf repo-wt" &&

+ git -C repo-bare.git worktree add ../repo-wt &&

+

+ test_when_finished "rm -f .gitconfig" &&

+ test_config_global protocol.file.allow always &&

+ git -C repo-wt submodule update --init &&

+ git init repo-wt/sub2 &&

+ test_commit -C repo-wt/sub2 A &&

+ git -C repo-wt submodule add ./sub2 sub2 &&

+ cat >expect <<-EOF &&

+ Migrating git directory of '\''sub2'\'' from

+ '\''$cwd/repo-wt/sub2/.git'\'' to

+ '\''$cwd/repo-bare.git/worktrees/repo-wt/modules/sub2'\''

+ EOF

+ git -C repo-wt submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual

+'

+

+ cat >expect <<-\EOF &&

+ fatal: could not lookup name for submodule '\''sub2'\''

+ EOF

+ test_must_fail git submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual &&

+ cat >expect <<-\EOF &&

+ fatal: could not lookup name for submodule '\''sub2'\''

+ EOF

+ test_must_fail git submodule absorbgitdirs 2>actual &&

+ test_cmp expect actual

+# try to start the daemon in the submodule.

+test_expect_success "submodule absorbgitdirs implicitly starts daemon" '

+ cwd="$(cd super && pwd)" &&

+ cat >expect <<-EOF &&

+ Migrating git directory of '\''dir_1/dir_2/sub'\'' from

+ '\''$cwd/dir_1/dir_2/sub/.git'\'' to

+ '\''$cwd/.git/modules/dir_1/dir_2/sub'\''

+ EOF

+ git -C super submodule absorbgitdirs >out 2>actual &&

+ test_cmp expect actual &&

+ test_must_be_empty out &&

+ # Confirm that the trace2 log contains a record of the

+ # daemon starting.

+ test_subcommand git fsmonitor--daemon start <super-sub.trace

+# regardless of how it is spelled in the FS event.

+ # Rename .git using an alternate spelling to verify that

+ # the daemon detects it and automatically shuts down.

+quoted_svnrepo="$(echo $svnrepo | test_uri_escape)"

+ eval "printf '%s\n' \"\${$var}\""

+# Poor man's URI escaping. Good enough for the test suite whose trash

+# directory has a space in it. See 93c3fcbe4d4 (git-svn: attempt to

+# mimic SVN 1.7 URL canonicalization, 2012-07-28) for prior art.

+test_uri_escape() {

+ sed 's/ /%20/g'

+}

+

+

+# Given a filename, extract its trailing hash as a hex string

+test_trailing_hash () {

+ local file="$1" &&

+ tail -c $(test_oid rawsz) "$file" |

+ test-tool hexdump |

+ sed "s/ //g"

+}

+ GIT_TEST_CMP="GIT_DIR=/dev/null git diff --no-index --ignore-cr-at-eol --"

+static int get_bundle_uri(struct transport *transport)

+{

+ get_helper(transport);

+

+ if (process_connect(transport, 0)) {

+ do_take_over(transport);

+ return transport->vtable->get_bundle_uri(transport);

+ }

+

+ return -1;

+}

+

+ .get_bundle_uri = get_bundle_uri,

+ * Populates the remote side's bundle-uri under protocol v2,

+ * if the "bundle-uri" capability was advertised. Returns 0 if

+ * OK, negative values on error.

+ */

+ int (*get_bundle_uri)(struct transport *transport);

+

+ /**

+#include "bundle-uri.h"

+ unsigned finished_handshake : 1;

+ data->finished_handshake = 1;

+static int get_bundle_uri(struct transport *transport)

+{

+ struct git_transport_data *data = transport->data;

+ struct packet_reader reader;

+ int stateless_rpc = transport->stateless_rpc;

+

+ if (!transport->bundles) {

+ CALLOC_ARRAY(transport->bundles, 1);

+ init_bundle_list(transport->bundles);

+ }

+

+ if (!data->finished_handshake) {

+ struct ref *refs = handshake(transport, 0, NULL, 0);

+

+ if (refs)

+ free_refs(refs);

+ }

+

+ /*

+ * "Support" protocol v0 and v2 without bundle-uri support by

+ * silently degrading to a NOOP.

+ */

+ if (!server_supports_v2("bundle-uri"))

+ return 0;

+

+ packet_reader_init(&reader, data->fd[0], NULL, 0,

+ PACKET_READ_CHOMP_NEWLINE |

+ PACKET_READ_GENTLE_ON_EOF);

+

+ return get_remote_bundle_uri(data->fd[1], &reader,

+ transport->bundles, stateless_rpc);

+}

+

+ if (!data->finished_handshake) {

+ data->finished_handshake = 0;

+ if (!data->finished_handshake)