Git v2.45.3 Release Notes

=========================

'master' front during the development towards Git 2.46, the next

feature release.

or https URL to be important. Defaults to false. See

linkgit:gitcredentials[7] for more information.

credential.username::

If no username is set for a network authentication, use this username

by default. See credential.<context>.* below, and

Set this option to `true` to make the diff driver cache the text

conversion outputs. See linkgit:gitattributes[5] for details.

`diff.indentHeuristic`::

Set this option to `false` to disable the default heuristics

that shift diff hunk boundaries to make patches easier to read.

and requires that a corresponding difftool.<guitool>.cmd variable

is defined.

difftool.<tool>.cmd::

Specify the command to invoke the specified diff tool.

The specified command is evaluated in shell with the following

The merge driver can learn the pathname in which the merged result

will be stored via placeholder `%P`. The conflict labels to be used

for the common ancestor, local head and other head can be passed by

`conflict-marker-size`

^^^^^^^^^^^^^^^^^^^^^^

command: asciidoc_html_options,

input: article,

output: fs.stem(article) + '.html',

install: true,

install_dir: get_option('datadir') / 'doc/git-doc/technical',

)

#!/bin/sh

LF='

'

THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/%

CLAR_TEST_SUITES += u-ctype

CLAR_TEST_SUITES += u-strvec

CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)

CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))

CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o

UNIT_TEST_PROGRAMS += t-example-decorate

UNIT_TEST_PROGRAMS += t-hashmap

UNIT_TEST_PROGRAMS += t-mem-pool

UNIT_TEST_PROGRAMS += t-oid-array

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

s->use_color ? GIT_COLOR_RESET : "", COLOR_MAXLEN);

FREE_AND_NULL(s->interactive_diff_filter);

FREE_AND_NULL(s->interactive_diff_algorithm);

if (s->use_single_key)

setbuf(stdin, NULL);

}

size_t *binary_count)

{

struct object_id head_oid;

"HEAD", RESOLVE_REF_READING,

&head_oid, NULL);

struct collection_status s = { 0 };

s.skip_unseen = filter && i;

opt.def = is_initial ?

repo_init_revisions(r, &rev, NULL);

setup_revisions(0, NULL, &rev, &opt);

size_t count, i, j;

struct object_id oid;

"HEAD", RESOLVE_REF_READING,

&oid,

NULL);

ssize_t count, i;

struct object_id oid;

"HEAD", RESOLVE_REF_READING,

&oid,

NULL);

if (file_diff->hunk_nr) {

if (rendered_hunk_index != hunk_index) {

if (use_pager) {

sigchain_push(SIGPIPE, SIG_IGN);

}

render_hunk(s, hunk, 0, colored, &s->buf);

}

static struct commit **get_bad_and_good_commits(struct repository *r,

{

struct commit **rev;

ALLOC_ARRAY(rev, 1 + good_revs.nr);

rev[n++] = get_commit_reference(r, current_bad_oid);

* for early success, this will be converted back to 0 in

* check_good_are_ancestors_of_bad().

*/

{

enum bisect_error res = BISECT_OK;

struct commit_list *result = NULL;

return res;

}

struct commit **rev, const char *prefix)

{

struct strvec rev_argv = STRVEC_INIT;

{

char *filename;

struct stat st;

enum bisect_error res = BISECT_OK;

struct commit **rev;

int ret = 0;

struct mailinfo mi;

if (state->utf8)

mi.metainfo_charset = get_commit_output_encoding();

}

strbuf_release(&msg);

} else if (*reply == 'v' || *reply == 'V') {

struct child_process cp = CHILD_PROCESS_INIT;

if (!pager)

if (len < 0)

die_errno(_("failed to read '%s'"), patch_path);

write_in_full(1, sb.buf, sb.len);

strbuf_release(&sb);

return 0;

sb.found_guilty_entry = &found_guilty_entry;

sb.found_guilty_entry_data = &pi;

if (show_progress)

assign_blame(&sb, opt);

stop_progress(&pi.progress);

if (!incremental)

else

goto cleanup;

strbuf_addftime(&zip_path, option_suffix, localtime_r(&now, &tm), 0, 0);

strbuf_addstr(&zip_path, ".zip");

die_errno(_("unable to create diagnostics archive %s"), zip_path.buf);

strbuf_release(&zip_path);

oidset_init(&commits, 0);

if (opts.progress)

progress = start_delayed_progress(

_("Collecting commits from input"), 0);

while (strbuf_getline(&buf, stdin) != EOF) {

die("unable to read credential from stdin");

if (!strcmp(op, "fill")) {

credential_next_state(&c);

credential_write(&c, stdout, CREDENTIAL_OP_RESPONSE);

} else if (!strcmp(op, "approve")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else if (!strcmp(op, "reject")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else {

usage(usage_msg);

}

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

}

/* Prepare diagnostics */

die_errno(_("unable to create diagnostics archive %s"),

zip_path.buf);

unsigned int nr = 0;

int result = 0;

if (show_progress)

while (pending.nr) {

result |= traverse_one_object(object_array_pop(&pending));

display_progress(progress, ++nr);

fprintf_ln(stderr, _("Checking object directory"));

if (show_progress)

for_each_loose_file_in_objdir(path, fsck_loose, fsck_cruft, fsck_subdir,

&cb_data);

if (show_progress) {

for (struct packed_git *p = get_all_packs(r); p; p = p->next)

pack_count++;

pack_count = 0;

}

total += p->num_objects;

}

}

for (p = get_all_packs(the_repository); p;

p = p->next) {

if (getenv("GIT_TEST_MAINT_SCHEDULER"))

return 13;

}

static int is_launchctl_available(void)

}

if (show_in_pager == default_pager)

if (show_in_pager) {

opt.color = 0;

opt.name_only = 1;

}

if (!show_in_pager && !opt.status_only)

die_for_incompatible_opt3(!use_index, "--no-index",

untracked, "--untracked",

case HELP_ACTION_ALL:

opt_mode_usage(argc, "--all", help_format);

if (verbose) {

list_all_cmds_help(show_external_commands,

show_aliases);

return 0;

return 0;

case HELP_ACTION_CONFIG:

opt_mode_usage(argc, "--config", help_format);

list_config_help(SHOW_CONFIG_HUMAN);

printf("\n%s\n", _("'git help config' for more information"));

return 0;

max = get_max_object_index();

if (verbose)

for (i = 0; i < max; i++) {

foreign_nr += check_object(get_indexed_object(i));

if (verbose)

progress = start_progress(

progress_title ? progress_title :

from_stdin ? _("Receiving objects") : _("Indexing objects"),

nr_objects);

QSORT(ref_deltas, nr_ref_deltas, compare_ref_delta_entry);

if (verbose || show_resolving_progress)

nr_ref_deltas + nr_ofs_deltas);

nr_dispatched = 0;

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

static void set_default_decoration_filter(struct decoration_filter *decoration_filter)

{

char *value = NULL;

struct string_list *include = decoration_filter->include_ref_pattern;

const struct string_list *config_exclude;

* No command-line or config options were given, so

* populate with sensible defaults.

*/

if (!ref_namespace[i].decoration)

continue;

if (rev->line_level_traverse)

line_log_init(rev, line_cb.prefix, &line_cb.args);

}

static void cmd_log_init(int argc, const char **argv, const char *prefix,

unsigned long size;

enum object_type type;

char *buf = repo_read_object_file(the_repository, oid, &type, &size);

if (!buf)

return error(_("could not read object %s"), oid_to_hex(oid));

assert(type == OBJ_TAG);

while (offset < size && buf[offset] != '\n') {

const char *ident;

while (new_offset < size && buf[new_offset++] != '\n')

; /* do nothing */

static char *find_branch_name(struct rev_info *rev)

{

struct object_id branch_oid;

const struct object_id *tip_oid;

const char *ref, *v;

char *full_ref, *branch = NULL;

if (rev->cmdline.rev[i].flags & UNINTERESTING)

continue;

return NULL;

}

return NULL;

if (repo_dwim_ref(the_repository, ref, strlen(ref), &branch_oid,

&full_ref, 0) &&

skip_prefix(full_ref, "refs/heads/", &v) &&

static struct commit *get_base_commit(const struct format_config *cfg,

struct commit **list,

{

struct commit *base = NULL;

struct commit **rev;

switch (cfg->auto_base) {

case AUTO_BASE_NEVER:

static void prepare_bases(struct base_tree_info *bases,

struct commit *base,

struct commit **list,

{

struct commit *commit;

struct rev_info revs;

struct diff_options diffopt;

struct commit_base commit_base;

if (!base)

return;

repo_init_revisions(the_repository, &revs, NULL);

revs.max_parents = 1;

revs.topo_order = 1;

list[i]->object.flags &= ~UNINTERESTING;

add_pending_object(&revs, &list[i]->object, "rev_list");

*commit_base_at(&commit_base, list[i]) = 1;

struct rev_info rev;

char *to_free = NULL;

struct setup_revision_opt s_r_opt;

int use_stdout = 0;

int start_number = -1;

int just_numbers = 0;

fmt_patch_suffix = cfg.fmt_patch_suffix;

/* Make sure "0000-$sub.patch" gives non-negative length for $sub */

cfg.log.fmt_patch_name_max = strlen("0000-") + strlen(fmt_patch_suffix);

if (cover_from_description_arg)

rev.commit_format = CMIT_FMT_MBOXRD;

if (use_stdout) {

} else if (!rev.diffopt.close_file) {

int saved;

rev.add_signoff = cfg.do_signoff;

if (show_progress)

int shown;

/* Make the second and subsequent mails replies to the first */

if (cfg.thread) {

/* Have we already had a message ID? */

OPT_END()

};

meta_charset.policy = CHARSET_DEFAULT;

argc = parse_options(argc, argv, prefix, options, mailinfo_usage, 0);

#include "parse-options.h"

#include "commit-reach.h"

{

struct commit_list *result = NULL, *r;

struct repository *repo UNUSED)

{

struct commit **rev;

int show_all = 0;

int cmdmode = 0;

int ret;

struct object_entry **write_order;

if (progress > pack_to_stdout)

ALLOC_ARRAY(written_list, to_pack.nr_objects);

write_order = compute_write_order();

struct object_entry **sorted_by_offset;

if (progress)

to_pack.nr_objects);

CALLOC_ARRAY(sorted_by_offset, to_pack.nr_objects);

unsigned nr_done = 0;

if (progress)

nr_deltas);

QSORT(delta_list, n, type_size_sort);

ll_find_deltas(delta_list, n, window+1, depth, &nr_done);

static void enumerate_cruft_objects(void)

{

if (progress)

add_objects_in_unpacked_packs();

add_unreachable_loose_objects();

revs.ignore_missing_links = 1;

if (progress)

ret = add_unseen_recent_objects_to_traversal(&revs, cruft_expiration,

set_cruft_mtime, 1);

stop_progress(&progress_state);

if (prepare_revision_walk(&revs))

die(_("revision walk setup failed"));

if (progress)

nr_seen = 0;

traverse_commit_list(&revs, show_cruft_commit, show_cruft_object, NULL);

prepare_packing_data(the_repository, &to_pack);

if (progress && !cruft)

if (stdin_packs) {

/* avoids adding objects in excluded packs */

ignore_packed_keep_in_core = 1;

return;

if (show_progress)

mark_reachable_objects(revs, 1, expire, progress);

stop_progress(&progress);

initialized = 1;

char *path;

if (git_config_pathname(&path, var, value))

strbuf_addf(&fsck_msg_types, "%cskiplist=%s",

fsck_msg_types.len ? ',' : '=', path);

free(path);

strvec_push(&child.args, alt_shallow_file);

}

if (!tmp_objdir) {

if (err_fd > 0)

close(err_fd);

}

}

if (auto_update_server_info)

clear_shallow_info(&si);

}

if (use_sideband)

* Count symrefs twice, since "renaming" them is done by

* deleting and recreating them in two separate passes.

*/

rename.remote_branches->nr + rename.symrefs_nr);

}

for (i = 0; i < remote_branches.nr; i++) {

}

if (run_update_server_info)

if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX, 0)) {

unsigned flags = 0;

revs.limited = 1;

if (show_progress)

if (use_bitmap_index) {

if (!try_bitmap_count(&revs, filter_provided_objects))

set_ref_status_for_push(remote_refs, args.send_mirror,

args.force_update);

if (helper_status)

print_helper_status(remote_refs);

use(sizeof(struct pack_header));

if (!quiet)

CALLOC_ARRAY(obj_list, nr_objects);

begin_odb_transaction();

for (i = 0; i < nr_objects; i++) {

if (argc > 0)

usage_with_options(update_server_info_usage, options);

}

#include "builtin.h"

#include "exec-cmd.h"

#include "gettext.h"

switch (determine_protocol_version_server()) {

case protocol_v2:

if (advertise_refs)

else

break;

case protocol_v1:

/*

static char *pager(int ident_flag UNUSED)

{

if (!pgm)

pgm = "cat";

if (!odb_transaction_nesting || bulk_fsync_objdir)

return;

if (bulk_fsync_objdir)

tmp_objdir_replace_primary_odb(bulk_fsync_objdir, 0);

}

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Loading known commits in commit graph"),

ctx->oids.nr);

for (i = 0; i < ctx->oids.nr; i++) {

*/

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Expanding reachable commits in commit graph"),

0);

for (i = 0; i < ctx->oids.nr; i++) {

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Clearing commit marks in commit graph"),

ctx->oids.nr);

for (i = 0; i < ctx->oids.nr; i++) {

if (ctx->report_progress)

info.progress = ctx->progress

= start_delayed_progress(

_("Computing commit graph topological levels"),

ctx->commits.nr);

if (ctx->report_progress)

info.progress = ctx->progress

= start_delayed_progress(

_("Computing commit graph generation numbers"),

ctx->commits.nr);

if (ctx->report_progress)

progress = start_delayed_progress(

_("Computing commit changed paths Bloom filters"),

ctx->commits.nr);

data.commits = &commits;

if (flags & COMMIT_GRAPH_WRITE_PROGRESS)

data.progress = start_delayed_progress(

_("Collecting referenced commits"), 0);

refs_for_each_ref(get_main_ref_store(the_repository), add_ref_to_set,

"Finding commits for commit graph in %"PRIuMAX" packs",

pack_indexes->nr),

(uintmax_t)pack_indexes->nr);

ctx->progress_done = 0;

}

for (i = 0; i < pack_indexes->nr; i++) {

{

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Finding commits for commit graph among packed objects"),

ctx->approx_nr_objects);

for_each_packed_object(ctx->r, add_packed_commits, ctx,

ctx->num_extra_edges = 0;

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Finding extra edges in commit graph"),

ctx->oids.nr);

oid_array_sort(&ctx->oids);

get_num_chunks(cf)),

get_num_chunks(cf));

ctx->progress = start_delayed_progress(

progress_title.buf,

st_mult(get_num_chunks(cf), ctx->commits.nr));

}

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Scanning merged commits"),

ctx->commits.nr);

current_graph_number--;

if (ctx->report_progress)

merge_commit_graph(ctx, g);

stop_progress(&ctx->progress);

if (!(flags & COMMIT_GRAPH_VERIFY_SHALLOW))

total += g->num_commits_in_base;

total);

}

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "commit.h"

static int queue_has_nonstale(struct prio_queue *queue)

{

struct commit *commit = queue->array[i].data;

if (!(commit->object.flags & STALE))

return 1;

}

static int remove_redundant_no_gen(struct repository *r,

{

struct commit **work;

unsigned char *redundant;

CALLOC_ARRAY(work, cnt);

redundant = xcalloc(cnt, 1);

for (i = filled = 0; i < cnt; i++)

if (!redundant[i])

array[filled++] = work[i];

free(work);

free(redundant);

free(filled_index);

}

static int remove_redundant_with_gen(struct repository *r,

{

timestamp_t min_generation = GENERATION_NUMBER_INFINITY;

struct commit **walk_start, **sorted;

size_t walk_start_nr = 0, walk_start_alloc = cnt;

/*

* Sort the input by generation number, ascending. This allows

* terminate early. Otherwise, we will do the same amount of work

* as before.

*/

/* push the STALE bits up to min generation */

struct commit_list *stack = NULL;

while (stack) {

struct commit_list *parents;

clear_commit_marks_many(walk_start_nr, walk_start, STALE);

free(walk_start);

}

{

/*

* Some commit in the array may be an ancestor of

* that number.

*/

if (generation_numbers_enabled(r)) {

/*

* If we have a single commit with finite generation

* number, then the _with_gen algorithm is preferred.

*/

if (commit_graph_generation(array[i]) < GENERATION_NUMBER_INFINITY)

}

}

}

static int get_merge_bases_many_0(struct repository *r,

struct commit *one,

struct commit **twos,

int cleanup,

struct commit_list **result)

{

struct commit_list *list;

struct commit **rslt;

if (merge_bases_many(r, one, n, twos, result) < 0)

return -1;

clear_commit_marks(one, all_flags);

clear_commit_marks_many(n, twos, all_flags);

free(rslt);

return -1;

}

int repo_get_merge_bases_many(struct repository *r,

struct commit *one,

struct commit **twos,

struct commit_list **result)

{

int repo_get_merge_bases_many_dirty(struct repository *r,

struct commit *one,

struct commit **twos,

struct commit_list **result)

{

struct commit_list *p;

struct commit_list *result = NULL, **tail = &result;

struct commit **array;

if (!heads)

return NULL;

p->item->object.flags &= ~STALE;

}

}

free(array);

return NULL;

}

for (i = 0; i < num_head; i++)

tail = &commit_list_insert(array[i], tail)->next;

free(array);

int can_all_from_reach_with_flag(struct object_array *from,

unsigned int with_flag,

unsigned int assign_flag,

timestamp_t min_generation)

{

struct commit **list = NULL;

int result = 1;

ALLOC_ARRAY(list, from->nr);

int cutoff_by_min_date)

{

struct object_array from_objs = OBJECT_ARRAY_INIT;

struct commit_list *from_iter = from, *to_iter = to;

int result;

timestamp_t min_generation = GENERATION_NUMBER_INFINITY;

while (from_iter) {

return result;

}

unsigned int reachable_flag)

{

struct commit **item;

struct commit *rev2,

struct commit_list **result);

int repo_get_merge_bases_many(struct repository *r,

struct commit **twos,

struct commit_list **result);

/* To be used only when object flags after this call no longer matter */

int repo_get_merge_bases_many_dirty(struct repository *r,

struct commit **twos,

struct commit_list **result);

int can_all_from_reach_with_flag(struct object_array *from,

unsigned int with_flag,

unsigned int assign_flag,

timestamp_t min_generation);

int can_all_from_reach(struct commit_list *from, struct commit_list *to,

int commit_date_cutoff);

* This method uses the PARENT1 and PARENT2 flags during its operation,

* so be sure these flags are not set before calling the method.

*/

unsigned int reachable_flag);

struct ahead_behind_count {

}

}

{

struct commit_list *list = NULL;

clear_commit_marks_1(&list, *commit, mark);

commit++;

}

struct commit *pop_commit(struct commit_list **stack);

void clear_commit_marks(struct commit *commit, unsigned int mark);

enum rev_sort_order {

__git_config_vars_all="$(git --no-pager help --config)"

}

__git_compute_first_level_config_vars_for_section ()

{

local section="$1"

__git_compute_config_vars

local this_section="__git_first_level_config_vars_for_section_${section}"

printf -v "__git_first_level_config_vars_for_section_${section}" %s \

"$(echo "$__git_config_vars" | awk -F. "/^${section}\.[a-z]/ { print \$2 }")"

}

local section="$1"

__git_compute_config_vars_all

local this_section="__git_second_level_config_vars_for_section_${section}"

printf -v "__git_second_level_config_vars_for_section_${section}" %s \

"$(echo "$__git_config_vars_all" | awk -F. "/^${section}\.</ { print \$3 }")"

}

local section="${pfx%.*.}"

__git_compute_second_level_config_vars_for_section "${section}"

local this_section="__git_second_level_config_vars_for_section_${section}"

return

;;

branch.*)

__gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

pager.*)

__gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

submodule.*)

__gitcomp_nl "$(__git config -f "$(__git rev-parse --show-toplevel)/.gitmodules" --get-regexp 'submodule.*.path' | awk -F. '{print $2}')" "$pfx" "$cur_" "."

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

*.*)

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "sigchain.h"

#include "strbuf.h"

#include "urlmatch.h"

#include "trace2.h"

#include "repository.h"

}

else if (!strcmp(key, "usehttppath"))

c->use_http_path = git_config_bool(var, value);

return 0;

}

return matches;

}

{

char *normalized_url;

struct urlmatch_config config = URLMATCH_CONFIG_INIT;

credential_format(c, &url);

normalized_url = url_normalize(url.buf, &config.url);

string_list_clear(&config.vars, 1);

free(normalized_url);

urlmatch_config_release(&config);

strbuf_addch(out, '@');

}

if (c->host)

if (c->path) {

strbuf_addch(out, '/');

strbuf_add_percentencode(out, c->path, 0);

struct strbuf prompt = STRBUF_INIT;

char *r;

if (desc.len)

strbuf_addf(&prompt, "%s for '%s': ", what, desc.buf);

else

return xstrdup(r);

}

{

int interactive;

char *value;

!interactive) {

"interactive/skipped", 1);

return -1;

}

int same = !strcmp(value, "never");

free(value);

if (same) {

"interactive/skipped", 1);

return -1;

}

}

if (!c->username)

c->username = credential_ask_one("Username", c,

PROMPT_ASKPASS|PROMPT_ECHO);

if (!c->password)

c->password = credential_ask_one("Password", c,

PROMPT_ASKPASS);

return 0;

}

return 0;

}

int required)

{

if (!value && required)

return;

if (strchr(value, '\n'))

die("credential value for %s contains newline", key);

fprintf(fp, "%s=%s\n", key, value);

}

enum credential_op_type op_type)

{

if (credential_has_capability(&c->capa_authtype, op_type))

if (credential_has_capability(&c->capa_state, op_type))

if (credential_has_capability(&c->capa_authtype, op_type)) {

if (c->ephemeral)

}

if (c->password_expiry_utc != TIME_MAX) {

char *s = xstrfmt("%"PRItime, c->password_expiry_utc);

free(s);

}

for (size_t i = 0; i < c->wwwauth_headers.nr; i++)

if (credential_has_capability(&c->capa_state, op_type)) {

if (c->multistage)

for (size_t i = 0; i < c->state_headers_to_send.nr; i++)

}

}

return r;

}

{

int i;

credential_next_state(c);

c->multistage = 0;

if (all_capabilities)

credential_set_all_capabilities(c, CREDENTIAL_OP_INITIAL);

c->helpers.items[i].string);

}

(!c->username && !c->password && !c->credential))

die("unable to get password from user");

}

{

int i;

credential_next_state(c);

for (i = 0; i < c->helpers.nr; i++)

credential_do(c, c->helpers.items[i].string, "store");

c->approved = 1;

}

{

int i;

credential_next_state(c);

for (i = 0; i < c->helpers.nr; i++)

credential_do(c, c->helpers.items[i].string, "erase");

#include "string-list.h"

#include "strvec.h"

/**

* The credentials API provides an abstracted way of gathering

* authentication credentials from the user.

* // Fill in the username and password fields by contacting

* // helpers and/or asking the user. The function will die if it

* // fails.

*

* // Otherwise, we have a username and password. Try to use it.

*

multistage: 1,

quit:1,

use_http_path:1,

struct credential_capability capa_authtype;

struct credential_capability capa_state;

.wwwauth_headers = STRVEC_INIT, \

.state_headers = STRVEC_INIT, \

.state_headers_to_send = STRVEC_INIT, \

}

/* Initialize a credential structure, setting all fields to empty. */

* If all_capabilities is set, this is an internal user that is prepared

* to deal with all known capabilities, and we should advertise that fact.

*/

/**

* Inform the credential subsystem that the provided credentials

* that they may store the result to be used again. Any errors

* from helpers are ignored.

*/

/**

* Inform the credential subsystem that the provided credentials

* for another call to `credential_fill`). Any errors from helpers

* are ignored.

*/

/**

* Enable all of the supported credential flags in this credential.

QSORT(todo, nr, tree_depth_compare);

if (progress)

for (i = 0; i < nr; i++) {

struct object_entry *ent = todo[i].entry;

#include "git-compat-util.h"

#include "diagnose.h"

#include "compat/disk.h"

#include "object-store-ll.h"

#include "packfile.h"

#include "parse-options.h"

#include "write-or-die.h"

struct archive_dir {

return res;

}

{

struct strvec archiver_args = STRVEC_INIT;

char **argv_copy = NULL;

strbuf_addstr(&buf, "Collecting diagnostic info\n\n");

get_version_info(&buf, 1);

get_disk_info(&buf);

write_or_die(stdout_fd, buf.buf, buf.len);

strvec_pushf(&archiver_args,

strbuf_reset(&buf);

strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:");

foreach_alt_odb(dir_file_stats, &buf);

strvec_push(&archiver_args, buf.buf);

}

strvec_pushl(&archiver_args, "--prefix=",

/* `write_archive()` modifies the `argv` passed to it. Let it. */

argv_copy = xmemdupz(archiver_args.v,

sizeof(char *) * archiver_args.nr);

res = write_archive(archiver_args.nr, (const char **)argv_copy, NULL,

if (res) {

error(_("failed to write archive"));

goto diagnose_cleanup;

#include "strbuf.h"

struct option;

enum diagnose_mode {

DIAGNOSE_NONE,

int option_parse_diagnose(const struct option *opt, const char *arg, int unset);

#endif /* DIAGNOSE_H */

* --exit-code" in hooks and other scripts, we do not do so.

*/

if (!opt->flags.exit_with_status &&

}

trace2_region_enter("diff", "inexact renames", options->repo);

if (options->show_rename_progress) {

progress = start_delayed_progress(

_("Performing inexact rename detection"),

(uint64_t)num_destinations * (uint64_t)num_sources);

}

dco->state = CE_RETRY;

if (show_progress)

while (dco->filters.nr > 0) {

for_each_string_list_item(filter, &dco->filters) {

struct string_list available_paths = STRING_LIST_INIT_DUP;

char *path ;

if (git_config_pathname(&path, var, value))

strbuf_addf(msg_types, "%cskiplist=%s",

msg_types->len ? ',' : '=', path);

free(path);

struct strbuf sb = STRBUF_INIT;

if (git_config_pathname(&path, var, value))

strbuf_addf(&sb, "skiplist=%s", path);

free(path);

fsck_set_msg_types(options, sb.buf);

return result

if "$local" == "true":

# Set our http root directory

# This is a work around for a missing directory argument in older Python versions

require_init=

files=

remote=

rebase=

merge=

checkout=

depth=

progress=

dissociate=

jobs=

recommend_shallow=

filter=

#

# Add a new submodule to the working tree, .gitmodules and the index

cmd_add()

{

# parse $args after "submodule ... add".

while test $# -ne 0

do

case "$1" in

-b | --branch)

case "$2" in '') usage ;; esac

shift

;;

-f | --force)

force=$1

;;

-q|--quiet)

;;

--progress)

;;

--reference)

case "$2" in '') usage ;; esac

shift

;;

--reference=*)

;;

--ref-format)

case "$2" in '') usage ;; esac

ref_format="$1"

;;

--dissociate)

;;

--name)

case "$2" in '') usage ;; esac

shift

;;

--depth)

case "$2" in '') usage ;; esac

depth="--depth=$2"

shift

;;

--depth=*)

;;

--)

shift

fi

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper add \

${ref_format:+"$ref_format"} \

${depth:+"$depth"} \

-- \

"$@"

do

case "$1" in

-q|--quiet)

;;

--recursive)

;;

-*)

usage

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper foreach \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper init \

-- \

"$@"

}

cmd_deinit()

{

# parse $args after "submodule ... deinit".

while test $# -ne 0

do

case "$1" in

force=$1

;;

-q|--quiet)

;;

--all)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

-v|--verbose)

;;

--progress)

;;

-i|--init)

;;

--require-init)

;;

--remote)

;;

-N|--no-fetch)

;;

-f|--force)

force=$1

;;

-r|--rebase)

;;

--ref-format)

case "$2" in '') usage ;; esac

reference="$1"

;;

--dissociate)

;;

-m|--merge)

;;

--recursive)

;;

--checkout)

;;

;;

--depth)

case "$2" in '') usage ;; esac

shift

;;

--depth=*)

;;

-j|--jobs)

case "$2" in '') usage ;; esac

jobs="--jobs=$2"

shift

;;

;;

;;

--filter)

case "$2" in '') usage ;; esac

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper update \

${ref_format:+"$ref_format"} \

${reference:+"$reference"} \

${depth:+"$depth"} \

$single_branch \

$recommend_shallow \

$jobs \

# $@ = requested path

#

cmd_set_branch() {

while test $# -ne 0

do

case "$1" in

# we don't do anything with this but we need to accept it

;;

-d|--default)

;;

-b|--branch)

case "$2" in '') usage ;; esac

shift

;;

--)

shift

break

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-branch \

-- \

"$@"

}

# $@ = requested path, requested url

#

cmd_set_url() {

while test $# -ne 0

do

case "$1" in

-q|--quiet)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-url \

-- \

"$@"

}

# $@ = [commit (default 'HEAD'),] requested paths (default all)

#

cmd_summary() {

# parse $args after "submodule ... summary".

while test $# -ne 0

do

case "$1" in

--cached)

;;

--files)

;;

--for-status)

;;

-n|--summary-limit)

shift

;;

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper summary \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

--cached)

;;

--recursive)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper status \

-- \

"$@"

}

#

cmd_sync()

{

while test $# -ne 0

do

case "$1" in

-q|--quiet)

shift

;;

--recursive)

shift

;;

--)

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper sync \

-- \

"$@"

}

command=$1

;;

-q|--quiet)

;;

--cached)

;;

--)

break

setenv("GIT_PAGER", "cat", 1);

break;

case 1:

break;

default:

break;

{

if (use_pager != -1 || pager_in_use())

return;

if (use_pager == -1)

use_pager = def;

commit_pager_choice();

precompose_argv_prefix(argc, argv, NULL);

if (use_pager == -1 && run_setup &&

!(p->option & DELAY_PAGER_CONFIG))

if (use_pager == -1 && p->option & USE_PAGER)

use_pager = 1;

if (run_setup && startup_info->have_repository)

/* get_git_dir() may set up repo, avoid that */

commit_pager_choice();

if (!help && p->option & NEED_WORK_TREE)

int status;

if (use_pager == -1 && !is_builtin(argv[0]))

commit_pager_choice();

strvec_pushf(&cmd.args, "git-%s", argv[0]);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

if (!column_colors) {

char *string;

/* not configured -- use default */

graph_set_column_colors(column_colors_ansi,

column_colors_ansi_max);

}

}

if (http_auth.password) {

if (always_auth_proactively()) {

{

if (proxy_auth.username) {

if (!proxy_auth.password && !proxy_auth.credential)

set_proxyauth_name_password(result);

}

cert_auth.host = xstrdup("");

cert_auth.username = xstrdup("");

cert_auth.path = xstrdup(ssl_cert);

}

return 1;

}

proxy_cert_auth.host = xstrdup("");

proxy_cert_auth.username = xstrdup("");

proxy_cert_auth.path = xstrdup(http_proxy_ssl_cert);

}

return 1;

}

curl_errorstr, sizeof(curl_errorstr));

if (results->curl_result == CURLE_OK) {

return HTTP_OK;

} else if (results->curl_result == CURLE_SSL_CERTPROBLEM) {

/*

* with the certificate. So we reject the credential to

* avoid caching or saving a bad password.

*/

return HTTP_NOAUTH;

} else if (results->curl_result == CURLE_SSL_PINNEDPUBKEYNOTMATCH) {

return HTTP_NOMATCHPUBLICKEY;

credential_clear_secrets(&http_auth);

return HTTP_REAUTH;

}

if (always_auth_proactively())

http_proactive_auth = PROACTIVE_AUTH_NONE;

return HTTP_NOAUTH;

}

} else {

if (results->http_connectcode == 407)

if (!curl_errorstr[0])

strlcpy(curl_errorstr,

curl_easy_strerror(results->curl_result),

int ret;

if (always_auth_proactively())

ret = http_request(url, result, target, options);

BUG("Unknown http_request target");

}

ret = http_request(url, result, target, options);

}

cred->username = xstrdup_or_null(srvc->user);

cred->password = xstrdup_or_null(srvc->pass);

if (!srvc->user)

srvc->user = xstrdup(cred->username);

} /* !preauth */

if (cred.username)

credential_clear(&cred);

/* check the target mailbox exists */

bail:

if (cred.username)

credential_clear(&cred);

out:

if (cred.username) {

if (res == CURLE_OK)

else if (res == CURLE_LOGIN_DENIED)

}

credential_clear(&cred);

* into the alternative object store list as the primary.

*/

if (opt->remerge_diff && !opt->remerge_objdir) {

if (!opt->remerge_objdir)

return error(_("unable to create temporary object directory"));

tmp_objdir_replace_primary_odb(opt->remerge_objdir, 1);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

return 0;

}

{

memset(mi, 0, sizeof(*mi));

strbuf_init(&mi->name, 0);

mi->header_stage = 1;

mi->use_inbody_headers = 1;

mi->content_top = mi->content;

}

void clear_mailinfo(struct mailinfo *mi)

#define MAX_BOUNDARIES 5

enum quoted_cr_action {

quoted_cr_unset = -1,

quoted_cr_nowarn,

};

int mailinfo_parse_quoted_cr_action(const char *actionstr, int *action);

int mailinfo(struct mailinfo *, const char *msg, const char *patch);

void clear_mailinfo(struct mailinfo *);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "tree.h"

#include "tree-walk.h"

#include "object-store-ll.h"

static int score_missing(unsigned mode)

{

return score;

}

const struct object_id *hash)

{

void *buffer;

enum object_type type;

unsigned long size;

if (!buffer)

die("unable to read tree (%s)", oid_to_hex(hash));

if (type != OBJ_TREE)

/*

* Inspect two trees, and give a score that tells how similar they are.

*/

{

struct tree_desc one;

struct tree_desc two;

int score = 0;

for (;;) {

/*

* Match one itself and its subtrees with two and pick the best match.

*/

const struct object_id *hash2,

int *best_score,

char **best_match,

int recurse_limit)

{

struct tree_desc one;

while (one.size) {

const char *path;

elem = tree_entry_extract(&one, &path, &mode);

if (!S_ISDIR(mode))

goto next;

if (*best_score < score) {

free(*best_match);

*best_match = xstrfmt("%s%s", base, path);

}

if (recurse_limit) {

char *newbase = xstrfmt("%s%s/", base, path);

newbase, recurse_limit - 1);

free(newbase);

}

* A tree "oid1" has a subdirectory at "prefix". Come up with a tree object by

* replacing it with another tree "oid2".

*/

const struct object_id *oid2, struct object_id *result)

{

char *subpath;

if (*subpath)

subpath++;

if (!buf)

die("cannot read tree %s", oid_to_hex(oid1));

init_tree_desc(&desc, oid1, buf, sz);

oid_to_hex(oid1));

if (*subpath) {

struct object_id tree_oid;

if (status)

return status;

rewrite_with = &subtree;

} else {

rewrite_with = oid2;

}

status = write_object_file(buf, sz, OBJ_TREE, result);

free(buf);

return status;

if (!depth_limit)

depth_limit = 2;

add_prefix = xcalloc(1, 1);

del_prefix = xcalloc(1, 1);

* See if one's subtree resembles two; if so we need to prefix

* two with a few fake trees to match the prefix.

*/

/*

* See if two's subtree resembles one; if so we need to

* pick only subtree of two.

*/

/* Assume we do not have to do any shifting */

oidcpy(shifted, hash2);

if (!*add_prefix)

goto out;

out:

free(add_prefix);

if (candidate == 3) {

/* Both are plausible -- we need to evaluate the score */

int score;

candidate = 0;

if (score > best_score) {

candidate = 1;

best_score = score;

}

if (score > best_score)

candidate = 2;

}

* shift tree2 down by adding shift_prefix above it

* to match tree1.

*/

else

/*

* shift tree2 up by removing shift_prefix from it

endif

https_backend = get_option('https_backend')

core_foundation_framework = dependency('CoreFoundation', required: security_framework.found())

if https_backend == 'auto' and security_framework.found()

https_backend = 'CommonCrypto'

endif

openssl = dependency('openssl', required: openssl_required, default_options: ['default_library=static'])

if https_backend == 'auto' and openssl.found()

https_backend = 'openssl'

libgit_c_args += '-DNO_OPENSSL'

endif

if sha1_backend == 'sha1dc'

libgit_c_args += '-DSHA1_DC'

libgit_c_args += '-DSHA1DC_NO_STANDARD_INCLUDES=1'

'sha1dc/sha1.c',

'sha1dc/ubc_check.c',

]

libgit_c_args += '-DCOMMON_DIGEST_FOR_OPENSSL'

# Apple CommonCrypto requires chunking

libgit_c_args += '-DSHA1_MAX_BLOCK_SIZE=1024L*1024L*1024L'

libgit_dependencies += openssl

libgit_sources += 'block-sha1/sha1.c'

endif

if sha256_backend == 'openssl'

libgit_c_args += '-DSHA256_OPENSSL'

libgit_dependencies += openssl

'version.c',

version_def_h,

],

dependencies: libgit_dependencies,

include_directories: libgit_include_directories,

)

'perl': perl_features_enabled,

'python': python.found(),

}, section: 'Auto-detected features')

# Backends.

option('https_backend', type: 'combo', value: 'auto', choices: ['auto', 'openssl', 'CommonCrypto', 'none'],

description: 'The HTTPS backend to use when connecting to remotes.')

option('sha256_backend', type: 'combo', choices: ['openssl', 'nettle', 'gcrypt', 'block'], value: 'block',

# Build tweaks.

option('macos_use_homebrew_gettext', type: 'boolean', value: true,

ctx.pack_paths_checked = 0;

if (flags & MIDX_PROGRESS)

else

ctx.progress = NULL;

CALLOC_ARRAY(count, m->num_packs);

if (flags & MIDX_PROGRESS)

m->num_objects);

for (i = 0; i < m->num_objects; i++) {

int pack_int_id = nth_midxed_pack_int_id(m, i);

stop_progress(&progress);

if (flags & MIDX_PROGRESS)

m->num_packs);

for (i = 0; i < m->num_packs; i++) {

char *pack_name;

midx_report(_("incorrect checksum"));

if (flags & MIDX_PROGRESS)

m->num_packs + m->num_packs_in_base);

for (i = 0; i < m->num_packs + m->num_packs_in_base; i++) {

if (prepare_midx_pack(r, m, i))

}

if (flags & MIDX_PROGRESS)

m->num_objects - 1);

for (curr = m; curr; curr = curr->base_midx) {

}

if (flags & MIDX_PROGRESS)

m->num_objects);

display_progress(progress, 0); /* TODO: Measure QSORT() progress */

QSORT(pairs, m->num_objects, compare_pair_pos_vs_id);

stop_progress(&progress);

if (flags & MIDX_PROGRESS)

for (i = 0; i < m->num_objects + m->num_objects_in_base; i++) {

struct object_id oid;

struct pack_entry e;

hash_object_body(algo, &c, buf, len, oid, hdr, hdrlen);

}

{

int ret = 0;

goto out;

}

goto out;

}

while (1) {

ssize_t sz_a, sz_b;

if (sz_a < 0) {

goto out;

}

if (sz_b < 0) {

goto out;

}

ret = error(_("files '%s' and '%s' differ in contents"),

goto out;

}

break;

}

out:

return ret;

}

int finalize_object_file_flags(const char *tmpfile, const char *filename,

enum finalize_object_file_flags flags)

{

if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)

goto try_rename;

* left to unlink.

*/

if (ret && ret != EEXIST) {

try_rename:

if (!stat(filename, &st))

ret = EEXIST;

errno = saved_errno;

return error_errno(_("unable to write file %s"), filename);

}

return -1;

unlink_or_warn(tmpfile);

}

return 0;

}

static int get_describe_name(struct repository *r,

const char *name, int len,

struct object_id *oid)

/* We must be looking at g in "SOMETHING-g"

* for it to be describe output.

*/

cp++;

len -= cp - name;

return get_short_oid(r,

return -1;

}

for (cp = name, bracket_depth = 0; *cp; cp++) {

bracket_depth++;

bracket_depth--;

break;

}

if (*cp == ':') {

struct object_id tree_oid;

res = parse_attr_line(buf, "dummy", 0, 0);

if (res) {

for (j = 0; j < res->num_attr; j++) {

const char *setto = res->state[j].setto;

if (ATTR_TRUE(setto) || ATTR_FALSE(setto) ||

int closed = 1; /* until proven otherwise */

if (writer->show_progress)

writer->selected_nr);

trace2_region_enter("pack-bitmap-write", "building_bitmaps_total",

the_repository);

}

if (writer->show_progress)

for (;;) {

struct commit *chosen = NULL;

tdata.trees = ewah_to_bitmap(bitmap_git->trees);

tdata.blobs = ewah_to_bitmap(bitmap_git->blobs);

tdata.tags = ewah_to_bitmap(bitmap_git->tags);

tdata.seen = 0;

traverse_commit_list(revs, &test_show_commit, &test_show_object, &tdata);

#include "git-compat-util.h"

#include "config.h"

#include "editor.h"

return 0;

}

{

const char *pager;

pager = getenv("GIT_PAGER");

if (!pager) {

if (!pager_program)

core_pager_config, NULL);

pager = pager_program;

}

pager_process->trace2_child_class = "pager";

}

{

static int once = 0;

if (!pager)

return;

}

/* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */

{

struct pager_command_config_data data;

data.want = -1;

data.value = NULL;

if (data.value)

pager_program = data.value;

#define PAGER_H

struct child_process;

void wait_for_pager(void);

int pager_in_use(void);

int term_columns(void);

void term_clear_line(void);

int decimal_width(uintmax_t);

void prepare_pager_args(struct child_process *, const char *pager);

extern int pager_use_color;

!opts->argh || !!strpbrk(opts->argh, "()<>[]|");

if (opts->flags & PARSE_OPT_OPTARG)

if (opts->long_name)

else

else

return utf8_fprintf(outfile, s, opts->argh ? _(opts->argh) : _("..."));

}

memset(&pd, 0, sizeof(pd));

if (refresh_flags & REFRESH_PROGRESS && isatty(2)) {

pthread_mutex_init(&pd.mutex, NULL);

}

typedef int (*prio_queue_compare_fn)(const void *one, const void *two, void *cb_data);

struct prio_queue_entry {

void *data;

};

struct prio_queue {

prio_queue_compare_fn compare;

void *cb_data;

size_t alloc, nr;

struct prio_queue_entry *array;

*/

#define GIT_TEST_PROGRESS_ONLY

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

};

struct progress {

const char *title;

uint64_t last_value;

uint64_t total;

display(progress, n, NULL);

}

unsigned delay, unsigned sparse)

{

struct progress *progress = xmalloc(sizeof(*progress));

progress->title = title;

progress->total = total;

progress->last_value = -1;

progress->title_len = utf8_strwidth(title);

progress->split = 0;

set_progress_signal();

return progress;

}

return delay_in_secs;

}

{

}

{

}

/*

* When "sparse" is set, stop_progress() will automatically force the done

* message to show 100%.

*/

{

}

uint64_t total)

{

}

static void finish_if_sparse(struct progress *progress)

static void log_trace2(struct progress *progress)

{

progress->total);

if (progress->throughput)

progress->throughput->curr_total);

}

void stop_progress_msg(struct progress **p_progress, const char *msg)

#include "gettext.h"

struct progress;

#ifdef GIT_TEST_PROGRESS_ONLY

void display_throughput(struct progress *progress, uint64_t total);

void display_progress(struct progress *progress, uint64_t n);

uint64_t total);

void stop_progress_msg(struct progress **p_progress, const char *msg);

static inline void stop_progress(struct progress **p_progress)

void prune_packed_objects(int opts)

{

if (opts & PRUNE_PACKED_VERBOSE)

for_each_loose_file_in_objdir(repo_get_object_directory(the_repository),

prune_object, NULL, prune_subdir, &opts);

return;

if (writer->show_progress)

writer->pseudo_merge_groups.nr);

refs_for_each_ref(get_main_ref_store(the_repository),

int t2_sum_scan = 0;

if (flags & REFRESH_PROGRESS && isatty(2))

istate->cache_nr);

trace_performance_enter();

istate->cache_tree = cache_tree_read(data, sz);

break;

case CACHE_EXT_RESOLVE_UNDO:

break;

case CACHE_EXT_LINK:

if (read_link_extension(istate, data, sz))

istate->resolve_undo) {

strbuf_reset(&sb);

err = write_index_ext_header(f, eoie_c, CACHE_EXT_RESOLVE_UNDO,

sb.len) < 0;

hashwrite(f, sb.buf, sb.len);

struct commit_list **check_reachable,

int include_reached)

{

struct commit **to_clear;

if (!*check_reachable)

close(fd);

fd = -1;

sleep_millisec(delay);

}

static int format_name(struct reftable_buf *dest, uint64_t min, uint64_t max)

{

char buf[100];

snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x",

min, max, rnd);

reftable_buf_reset(dest);

do {

err = probe_rpc(rpc, &results);

if (err == HTTP_REAUTH)

} while (err == HTTP_REAUTH);

if (err != HTTP_OK)

return -1;

rpc->any_written = 0;

err = run_slot(slot, NULL);

if (err == HTTP_REAUTH && !large_request) {

curl_slist_free_all(headers);

goto retry;

}

struct tips {

struct commit **tip;

};

static void add_to_tips(struct tips *tips, const struct object_id *oid)

const int reachable_flag = 1;

struct commit_list *found_commits;

struct commit **src_commits;

ALLOC_ARRAY(src_commits, alloc_src_commits);

for_each_string_list_item(item, &src_tag) {

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

ui->mode[stage - 1] = ce->ce_mode;

}

{

struct string_list_item *item;

for_each_string_list_item(item, resolve_undo) {

for (i = 0; i < 3; i++) {

if (!ui->mode[i])

continue;

}

}

}

{

struct string_list *resolve_undo;

size_t len;

char *endptr;

int i;

CALLOC_ARRAY(resolve_undo, 1);

resolve_undo->strdup_strings = 1;

continue;

if (size < rawsz)

goto error;

size -= rawsz;

data += rawsz;

}

};

void record_resolve_undo(struct index_state *, struct cache_entry *);

void resolve_undo_clear_index(struct index_state *);

int unmerge_index_entry(struct index_state *, const char *, struct resolve_undo_info *, unsigned);

void unmerge_index(struct index_state *, const struct pathspec *, unsigned);

#include "git-compat-util.h"

#include "config.h"

#include "commit.h"

die("bad %s argument: %s", opt->long_name, arg);

}

{

if (negative &&

OBJECT_INFO_SKIP_FETCH_OBJECT |

OBJECT_INFO_QUICK))

return;

/*

* Make a pack stream and spit it out into file descriptor fd

*/

struct oid_array *negotiated,

struct send_pack_args *args)

{

FILE *po_in;

int rc;

strvec_push(&po.args, "pack-objects");

strvec_push(&po.args, "--all-progress-implied");

strvec_push(&po.args, "--revs");

strvec_push(&po.args, "-q");

if (args->progress)

strvec_push(&po.args, "--progress");

strvec_push(&po.args, "--shallow");

if (args->disable_bitmaps)

strvec_push(&po.args, "--no-use-bitmap-index");

*/

po_in = xfdopen(po.in, "w");

for (size_t i = 0; i < advertised->nr; i++)

for (size_t i = 0; i < negotiated->nr; i++)

while (refs) {

if (!is_null_oid(&refs->old_oid))

if (!is_null_oid(&refs->new_oid))

refs = refs->next;

}

*/

if (rc > 128 && rc != 141)

error("pack-objects died of signal %d", rc - 128);

return -1;

}

return 0;

}

return 0;

}

{

struct ref *hint;

int ret;

int new_report = 0;

int once = 0;

hint = NULL;

ret = receive_unpack_status(reader);

while (1) {

if (!strcmp(key, "refname"))

report->ref_name = xstrdup_or_null(val);

else if (!strcmp(key, "old-oid") && val &&

report->old_oid = oiddup(&old_oid);

else if (!strcmp(key, "new-oid") && val &&

report->new_oid = oiddup(&new_oid);

else if (!strcmp(key, "forced-update"))

report->forced_update = 1;

new_report = 1;

}

}

return ret;

}

return 0;

}

{

return;

for_each_commit_graft(advertise_shallow_grafts_cb, sb);

}

}

}

const struct ref *remote_refs,

struct oid_array *commons)

{

struct child_process child = CHILD_PROCESS_INIT;

const struct ref *ref;

int nr_negotiation_tip = 0;

child.git_cmd = 1;

break;

if (read_len != len)

die("invalid length read %d", read_len);

die("invalid hash");

oid_array_append(commons, &oid);

} while (1);

}

}

int fd[], struct child_process *conn,

struct ref *remote_refs,

struct oid_array *extra_have)

goto out;

}

if (push_negotiate) {

}

args->disable_bitmaps = !use_bitmaps;

/* Does the other end support the reporting? */

if (server_supports("report-status-v2"))

if (server_supports("push-options"))

push_options_supported = 1;

die(_("the receiving end does not support this repository's hash algorithm"));

if (args->push_cert != SEND_PACK_PUSH_CERT_NEVER) {

if (use_push_options)

strbuf_addstr(&cap_buf, " push-options");

if (object_format_supported)

if (agent_supported)

strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());

if (advertise_sid)

}

if (!args->dry_run)

/*

* Finally, tell the other end!

}

if (args->stateless_rpc) {

packet_buf_flush(&req_buf);

send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);

}

PACKET_READ_DIE_ON_ERR_PACKET);

if (need_pack_data && cmds_sent) {

if (args->stateless_rpc)

close(out);

if (git_connection_is_socket(conn))

* we get one).

*/

if (status_report)

if (use_sideband) {

close(demux.out);

packet_flush(out);

if (status_report && cmds_sent)

else

ret = 0;

if (args->stateless_rpc)

struct child_process;

struct oid_array;

struct ref;

/* Possible values for push_cert field in send_pack_args. */

#define SEND_PACK_PUSH_CERT_NEVER 0

int option_parse_push_signed(const struct option *opt,

const char *arg, int unset);

int fd[], struct child_process *conn,

struct ref *remote_refs, struct oid_array *extra_have);

#include "git-compat-util.h"

#include "repository.h"

#include "config.h"

},

};

{

struct strbuf capability = STRBUF_INIT;

struct strbuf value = STRBUF_INIT;

for (size_t i = 0; i < ARRAY_SIZE(capabilities); i++) {

struct protocol_capability *c = &capabilities[i];

strbuf_addstr(&capability, c->name);

if (value.len) {

return NULL;

}

{

const char *value;

const struct protocol_capability *c = get_capability(key, &value);

return 0;

if (c->receive)

return 1;

}

{

const char *out;

if (*command)

die("command '%s' requested after already requesting command '%s'",

out, (*command)->name);

die("invalid command '%s'", out);

*command = cmd;

PROCESS_REQUEST_DONE,

};

{

enum request_state state = PROCESS_REQUEST_KEYS;

struct packet_reader reader;

case PACKET_READ_EOF:

BUG("Should have already died when seeing EOF");

case PACKET_READ_NORMAL:

seen_capability_or_command = 1;

else

die("unknown capability '%s'", reader.line);

if (!command)

die("no command requested");

die("mismatched object format: server %s; client %s",

hash_algos[client_hash_algo].name);

return 0;

}

{

if (!stateless_rpc)

/*

* If stateless-rpc was requested then exit after

* a single request/response exchange

*/

if (stateless_rpc) {

} else {

for (;;)

break;

}

}

#ifndef SERVE_H

#define SERVE_H

#endif /* SERVE_H */

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "tempfile.h"

struct update_info_ctx {

FILE *cur_fp;

FILE *old_fp; /* becomes NULL if it differs from cur_fp */

struct strbuf cur_sb;

* it into place. The contents of the file come from "generate", which

* should return non-zero if it encounters an error.

*/

int (*generate)(struct update_info_ctx *),

int force)

{

struct tempfile *f = NULL;

int ret = -1;

struct update_info_ctx uic = {

.cur_fp = NULL,

.old_fp = NULL,

.cur_sb = STRBUF_INIT,

void *cb_data)

{

struct update_info_ctx *uic = cb_data;

if (!o)

return -1;

return -1;

if (o->type == OBJ_TAG) {

if (o)

if (uic_printf(uic, "%s %s^{}\n",

oid_to_hex(&o->oid), path) < 0)

static int generate_info_refs(struct update_info_ctx *uic)

{

add_info_ref, uic);

}

{

free(path);

return ret;

}

return 1;

}

{

struct packed_git *p;

int stale;

int i;

size_t alloc = 0;

/* we ignore things on alternate path since they are

* not available to the pullers in general.

*/

return 0;

}

{

char *infofile = mkpathdup("%s/info/packs",

int ret;

free_pack_info();

free(infofile);

return ret;

}

/* public */

{

/* We would add more dumb-server support files later,

* including index of available pack files and their

* intended audiences.

*/

int errs = 0;

/* remove leftover rev-cache file if there is any */

return errs;

}

#ifndef SERVER_INFO_H

#define SERVER_INFO_H

/* Dumb servers support */

#endif /* SERVER_INFO_H */

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "hex.h"

struct commit_list *get_shallow_commits(struct object_array *heads, int depth,

int shallow_flag, int not_shallow_flag)

{

struct commit_list *result = NULL;

struct object_array stack = OBJECT_ARRAY_INIT;

struct commit *commit = NULL;

const struct oid_array *extra,

unsigned flags)

{

for_each_commit_graft(write_one_shallow, &data);

if (!extra)

return data.count;

strbuf_addstr(out, oid_to_hex(extra->oid + i));

strbuf_addch(out, '\n');

data.count++;

*/

void prepare_shallow_info(struct shallow_info *info, struct oid_array *sa)

{

trace_printf_key(&trace_shallow, "shallow: prepare_shallow_info\n");

memset(info, 0, sizeof(*info));

info->shallow = sa;

return;

ALLOC_ARRAY(info->ours, sa->nr);

ALLOC_ARRAY(info->theirs, sa->nr);

if (repo_has_object_file(the_repository, sa->oid + i)) {

struct commit_graft *graft;

graft = lookup_commit_graft(the_repository,

void remove_nonexistent_theirs_shallow(struct shallow_info *info)

{

struct object_id *oid = info->shallow->oid;

trace_printf_key(&trace_shallow, "shallow: remove_nonexistent_theirs_shallow\n");

for (i = dst = 0; i < info->nr_theirs; i++) {

if (i != dst)

unsigned nr = DIV_ROUND_UP(info->nr_bits, 32);

unsigned size = nr * sizeof(uint32_t);

void *p;

if (size > POOL_SIZE)

BUG("pool size too small for %d in paint_alloc()",

size);

{

unsigned int i, nr;

struct commit_list *head = NULL;

size_t bitmap_size = st_mult(sizeof(uint32_t), bitmap_nr);

struct commit *c = lookup_commit_reference_gently(the_repository, oid,

1);

struct object_id *oid = info->shallow->oid;

struct oid_array *ref = info->ref;

unsigned int i, nr;

struct paint_info pi;

trace_printf_key(&trace_shallow, "shallow: assign_shallow_commits_to_refs\n");

struct commit_array {

struct commit **commits;

};

static int add_ref(const char *refname UNUSED,

return 0;

}

{

if (!ref_status)

return;

if (bitmap[i / 32] & (1U << (i % 32)))

ref_status[i]++;

}

struct object_id *oid = info->shallow->oid;

struct commit *c;

uint32_t **bitmap;

struct commit_array ca;

trace_printf_key(&trace_shallow, "shallow: post_assign_shallow\n");

*/

struct shallow_info {

struct oid_array *shallow;

struct oid_array *ref;

/* for receive-pack */

int *reachable;

int *shallow_ref;

struct commit **commits;

};

void prepare_shallow_info(struct shallow_info *, struct oid_array *);

unsigned char ch = src[i];

if (ch <= 0x1F || ch >= 0x7F ||

(ch == '/' && (flags & STRBUF_ENCODE_SLASH)) ||

strbuf_addf(dst, "%%%02X", (unsigned char)ch);

else

strbuf_addch(dst, ch);

void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src);

#define STRBUF_ENCODE_SLASH 1

/**

* Append the contents of a string to a strbuf, percent-encoding any characters

while (count) {

unsigned long chunk = count < sizeof(buf) ? count : sizeof(buf);

perror("failed to read");

return 5;

}

*

* See 't0500-progress-display.sh' for examples.

*/

#define GIT_TEST_PROGRESS_ONLY

#include "test-tool.h"

#include "parse-options.h"

#include "progress.h"

#include "strbuf.h"

#include "string-list.h"

else

die("invalid input: '%s'", line.buf);

} else if (skip_prefix(line.buf, "progress ", (const char **) &end)) {

uint64_t item_count = strtoull(end, &end, 10);

if (*end != '\0')

struct commit_list *X, *Y;

struct object_array X_obj = OBJECT_ARRAY_INIT;

struct commit **X_array, **Y_array;

struct strbuf buf = STRBUF_INIT;

struct repository *r = the_repository;

clear_contains_cache(&cache);

} else if (!strcmp(av[1], "get_reachable_subset")) {

const int reachable_flag = 1;

struct commit_list *current;

struct commit_list *list = get_reachable_subset(X_array, X_nr,

Y_array, Y_nr,

oid_to_hex(&list->item->object.oid));

count++;

}

if (Y_array[i]->object.flags & reachable_flag)

count--;

}

#include "test-tool.h"

#include "gettext.h"

#include "parse-options.h"

#include "serve.h"

#include "setup.h"

PARSE_OPT_KEEP_UNKNOWN_OPT);

if (advertise_capabilities)

else

return 0;

}

clar_test_suites = [

'unit-tests/u-ctype.c',

'unit-tests/u-strvec.c',

]

unit_test_programs = [

'unit-tests/t-example-decorate.c',

'unit-tests/t-hashmap.c',

'unit-tests/t-mem-pool.c',

'unit-tests/t-oid-array.c',

test -z "$pexpiry" || echo password_expiry_utc=$pexpiry

EOF

PATH="$PWD:$PATH"

'

EOF

'

test_expect_success 'fetch with multiple path components' '

test_unconfig credential.helper &&

test_config credential.https://example.com/foo/repo.git.helper "verbatim foo bar" &&

test_cmp expect stderr

'

test_expect_success 'host-less URLs are parsed as empty host' '

check fill "verbatim foo bar" <<-\EOF

url=cert:///path/to/cert.pem

test_grep "skipping credential lookup for key" stderr

'

test_done

git config extensions.objectformat $test_hash_algo &&

git config extensions.compatobjectformat $test_compat_hash_algo &&

echo_without_newline "$hello_content" > hello &&

'

run_blob_tests () {

test_cmp expect actual

'

test_expect_success 'setup blobs which are likely to delta' '

test-tool genrandom foo 10240 >foo &&

{ cat foo && echo plus; } >foo-plus &&

test_expect_success 'fsck with invalid or bogus skipList input' '

git -c fsck.skipList=/dev/null -c fsck.missingEmail=ignore fsck &&

test_must_fail git -c fsck.skipList=does-not-exist -c fsck.missingEmail=ignore fsck 2>err &&

test_grep "could not open.*: does-not-exist" err &&

test_must_fail git -c fsck.skipList=.git/config -c fsck.missingEmail=ignore fsck 2>err &&

test_must_be_empty err

'

test_expect_success 'push with receive.fsck.skipList' '

git push . $commit:refs/heads/bogus &&

rm -rf dst &&

test_must_fail git --git-dir=dst/.git fetch "file://$(pwd)" $refspec &&

# Invalid and/or bogus skipList input

git --git-dir=dst/.git config fetch.fsck.skipList /dev/null &&

test_must_fail git --git-dir=dst/.git fetch "file://$(pwd)" $refspec &&

git --git-dir=dst/.git config fetch.fsck.skipList does-not-exist &&

git push "$HTTPD_URL"/auth/smart/test_repo.git &&

git --git-dir="$HTTPD_DOCUMENT_ROOT_PATH/test_repo.git" \

log -1 --format=%s >actual &&

test_cmp expect actual

'

git push "$HTTPD_URL"/auth-push/smart/test_repo.git &&

git --git-dir="$HTTPD_DOCUMENT_ROOT_PATH/test_repo.git" \

log -1 --format=%s >actual &&

test_cmp expect actual

'

git push "$HTTPD_URL/half-auth-complete/smart/half-auth.git" &&

git --git-dir="$HTTPD_DOCUMENT_ROOT_PATH/half-auth.git" \

log -1 --format=%s >actual &&

test_cmp expect actual

'

test_expect_success 'http auth can use just user in URL' '

set_askpass wrong pass@host &&

git clone "$HTTPD_URL_USER/auth/dumb/repo.git" clone-auth-pass &&

'

test_expect_success 'http auth can request both user and pass' '

set_askpass user@host pass@host &&

git clone "$HTTPD_URL/auth/dumb/repo.git" clone-auth-both &&

'

test_expect_success 'http auth respects credential helper config' '

test_config_global "credential.$HTTPD_URL.username" user@host &&

set_askpass wrong pass@host &&

git clone "$HTTPD_URL/auth/dumb/repo.git" clone-auth-user &&

'

test_expect_success 'configured username does not override URL' '

test_config_global "credential.$HTTPD_URL.username" wrong &&

set_askpass wrong pass@host &&

git clone "$HTTPD_URL_USER/auth/dumb/repo.git" clone-auth-user2 &&

'

test_expect_success 'set up repo with http submodules' '

set_askpass wrong pass@host &&

git -c "credential.$HTTPD_URL.username=user@host" \

clone --recursive super super-clone &&

'

test_expect_success 'cmdline credential config passes submodule via fetch' '

git -C super-clone \

-c "credential.$HTTPD_URL.username=user@host" \

fetch --recurse-submodules &&

'

test_expect_success 'cmdline credential config passes submodule update' '

git -C super-clone \

-c "credential.$HTTPD_URL.username=user@host" \

submodule update &&

'

test_expect_success 'fetch changes via http' '

echo two >expect &&

set_askpass user@host pass@host &&

git clone --bare "$HTTPD_URL/auth/smart/repo.git" smart-auth &&

git --git-dir=smart-auth log -1 --format=%s >actual &&

test_cmp expect actual

'

echo two >expect &&

set_askpass user@host pass@host &&

git clone --bare "$HTTPD_URL/auth-fetch/smart/repo.git" half-auth &&

git --git-dir=half-auth log -1 --format=%s >actual &&

test_cmp expect actual

'

set_askpass user@host pass@host &&

git -c credential.useHttpPath=true \

clone $HTTPD_URL/smart-redir-auth/repo.git repo-redir-auth &&

'

test_expect_success 'GIT_TRACE_CURL redacts auth details' '

rm -rf redact-auth trace &&

set_askpass user@host pass@host &&

GIT_TRACE_CURL="$(pwd)/trace" git clone --bare "$HTTPD_URL/auth/smart/repo.git" redact-auth &&

# Ensure that there is no "Basic" followed by a base64 string, but that

# the auth details are redacted

rm -rf redact-auth trace &&

set_askpass user@host pass@host &&

GIT_CURL_VERBOSE=1 git clone --bare "$HTTPD_URL/auth/smart/repo.git" redact-auth 2>trace &&

# Ensure that there is no "Basic" followed by a base64 string, but that

# the auth details are redacted

set_askpass user@host pass@host &&

GIT_TRACE_REDACT=0 GIT_TRACE_CURL="$(pwd)/trace" \

git clone --bare "$HTTPD_URL/auth/smart/repo.git" redact-auth &&

grep -i "Authorization: Basic [0-9a-zA-Z+/]" trace

'

# the first request prompts the user...

set_askpass user@host pass@host &&

git ls-remote "$HTTPD_URL/auth/smart/repo.git" >/dev/null &&

# ...and the second one uses the stored value rather than

# prompting the user.

# us to prompt the user again.

set_askpass user@host pass@host &&

git ls-remote "$HTTPD_URL/auth/smart/repo.git" >/dev/null &&

'

test_expect_success 'client falls back from v2 to v0 to match server' '

check_describe A-3-gHASH HEAD^^2

check_describe B HEAD^^2^

check_describe R-1-gHASH HEAD^^^

check_describe c-7-gHASH --tags HEAD

check_describe c-6-gHASH --tags HEAD^

check_describe e-1-gHASH --tags HEAD^^

check_describe c-2-gHASH --tags HEAD^^2

check_describe B --tags HEAD^^2^

check_describe e --tags HEAD^^^

check_describe e --tags --exact-match HEAD^^^

test_must_fail git describe --exact-match --always

'

test_done

git reset --hard third &&

rm -f file2 &&

test_must_fail git merge branch3 &&

git diff --exit-code file3 &&

git diff --exit-code branch3 file3 &&

git reset --merge HEAD &&

git diff --exit-code --cached

'

git reset --hard third &&

rm -f file2 &&

test_must_fail git merge branch3 &&

git diff --exit-code file3 &&

git diff --exit-code branch3 file3 &&

test_must_fail git reset --keep HEAD 2>err.log &&

git submodule foreach "echo be --quiet" > ../expected &&

git submodule foreach echo be --quiet > ../actual

) &&

test_cmp expected actual

'

test_expect_success 'option-like arguments passed to foreach recurse correctly' '

git -C clone2 submodule foreach --recursive "echo be --an-option" >expect &&

git -C clone2 submodule foreach --recursive echo be --an-option >actual &&

test_cmp expect actual

'

test -n "$test_skip_test_preamble" ||

say >&3 "expecting success of $TEST_NUMBER.$test_count '$1': $test_body"

if test_run_ "$test_body" &&

then

test_ok_ "$1"

else

teardown_malloc_check

}

grep -qv sanitizer::GetThreadStackTopAndBottom

}

check_test_results_san_file_ () {

then

return

fi &&

hash, to ensure that the compressed part is larger than the original.

*/

for (i = 0; i < REFTABLE_HASH_SIZE_SHA1; i++) {

}

reftable_writer_set_limits(w, update_index, update_index);

err = reftable_writer_add_log(w, &log);

};

for (i = 0; i < sizeof(message) - 1; i++)

reftable_writer_set_limits(w, 1, 1);

#include "hex.h"

#include "strbuf.h"

static void check_hash_data(const void *data, size_t data_length,

const char *expected_hashes[])

{

for (size_t i = 1; i < ARRAY_SIZE(hash_algos); i++) {

git_hash_ctx ctx;

algop->update_fn(&ctx, data, data_length);

algop->final_fn(hash, &ctx);

}

}

/* Works with a NUL terminated string. Doesn't work if it should contain a NUL character. */

#define TEST_HASH_STR(data, expected_sha1, expected_sha256) do { \

const char *expected_hashes[] = { expected_sha1, expected_sha256 }; \

} while (0)

/* Only works with a literal string, useful when it contains a NUL character. */

#define TEST_HASH_LITERAL(literal, expected_sha1, expected_sha256) do { \

const char *expected_hashes[] = { expected_sha1, expected_sha256 }; \

} while (0)

{

TEST_HASH_STR("",

"da39a3ee5e6b4b0d3255bfef95601890afd80709",

"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

TEST_HASH_STR("a",

"86f7e437faa5a7fce15d1ddcb9eaeaea377667b8",

"ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb");

TEST_HASH_STR("abc",

"a9993e364706816aba3e25717850c26c9cd0d89d",

"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");

TEST_HASH_STR("message digest",

"c12252ceda8be8994d5fa0290a47231c1d16aae3",

"f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650");

TEST_HASH_STR("abcdefghijklmnopqrstuvwxyz",

"32d10c7b8cf96570ca04ce37f2a19d84240d3a89",

"71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73");

TEST_HASH_STR(aaaaaaaaaa_100000.buf,

"34aa973cd4c4daa4f61eeb2bdbad27316534016f",

"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");

TEST_HASH_STR(alphabet_100000.buf,

"e7da7c55b3484fdf52aebec9cbe7b85a98f02fd4",

"e406ba321ca712ad35a698bf0af8d61fc4dc40eca6bdcea4697962724ccbde35");

TEST_HASH_LITERAL("blob 0\0",

"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",

"473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813");

TEST_HASH_LITERAL("blob 3\0abc",

"f2ba8f84ab5c1bce84a7b441cb1959cfc7093b7f",

"c1cf6e465077930e88dc5136641d402f72a229ddd996f627d60e9639eaba35a6");

TEST_HASH_LITERAL("tree 0\0",

"4b825dc642cb6eb9a060e54bf8d69288fbee4904",

"6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321");

}

#include "git-compat-util.h"

#include "tmp-objdir.h"

#include "abspath.h"

#include "repository.h"

struct tmp_objdir {

struct strbuf path;

struct strvec env;

struct object_directory *prev_odb;

return ret;

}

{

static int installed_handlers;

struct tmp_objdir *t;

BUG("only one tmp_objdir can be used at a time");

t = xcalloc(1, sizeof(*t));

strbuf_init(&t->path, 0);

strvec_init(&t->env);

* them.

*/

strbuf_addf(&t->path, "%s/tmp_objdir-%s-XXXXXX",

if (!mkdtemp(t->path.buf)) {

/* free, not destroy, as we never touched the filesystem */

}

env_append(&t->env, ALTERNATE_DB_ENVIRONMENT,

env_replace(&t->env, DB_ENVIRONMENT, absolute_path(t->path.buf));

env_replace(&t->env, GIT_QUARANTINE_ENVIRONMENT,

absolute_path(t->path.buf));

return 0;

if (t->prev_odb) {

BUG("migrating an ODB that was marked for destruction");

restore_primary_odb(t->prev_odb, t->path.buf);

t->prev_odb = NULL;

}

strbuf_addbuf(&src, &t->path);

ret = migrate_paths(&src, &dst, 0);

* Example:

*

* struct child_process child = CHILD_PROCESS_INIT;

* strvec_push(&child.args, cmd);

* strvec_pushv(&child.env, tmp_objdir_env(t));

* if (!run_command(&child)) && !tmp_objdir_migrate(t))

*

*/

struct tmp_objdir;

/*

* Create a new temporary object directory with the specified prefix;

* returns NULL on failure.

*/

/*

* Return a list of environment strings, suitable for use with

* along with this program; if not, see <https://www.gnu.org/licenses/>.

*/

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

return new_path.buf;

}

{

const char *git_work_tree, *prefix = startup_info->prefix;

char *cwd;

cwd = xgetcwd();

git_work_tree = "(null)";

if (!startup_info->prefix)

prefix = "(null)";

trace_printf_key(&trace_setup_key, "setup: worktree: %s\n", quote_crnl(git_work_tree));

trace_printf_key(&trace_setup_key, "setup: cwd: %s\n", quote_crnl(cwd));

trace_printf_key(&trace_setup_key, "setup: prefix: %s\n", quote_crnl(prefix));

extern struct trace_key trace_perf_key;

extern struct trace_key trace_setup_key;

/**

* Checks whether the trace key is enabled. Used to prevent expensive

break;

case protocol_v1:

case protocol_v0:

&data->extra_have);

break;

case protocol_unknown_version:

total++;

}

}

static void setup_collided_checkout_detection(struct checkout *state,

strbuf_reset(&prefix);

if (show_progress)

istate->progress = start_delayed_progress(

_("Updating index flags"),

istate->cache_nr);

#include "git-compat-util.h"

#include "version.h"

#include "strbuf.h"

const char git_version_string[] = GIT_VERSION;

const char git_built_from_commit_string[] = GIT_BUILT_FROM_COMMIT;

uint64_t nr = 0;

if (walker->get_progress)

while (process_queue) {

struct object *obj = process_queue->item;

for (count = 0; count < TMP_MAX; ++count) {

int i;

uint64_t v;

return error_errno("unable to get random bytes for temporary file");

/* Fill in the random bits. */

#endif

}

{

#if defined(HAVE_ARC4RANDOM) || defined(HAVE_ARC4RANDOM_LIBBSD)

/* This function never returns an error. */

return -1;

return 0;

#elif defined(HAVE_OPENSSL_CSPRNG)

return 0;

errno = EIO;

#else

ssize_t res;

char *p = buf;

#endif

}

{

uint32_t result;

die(_("unable to get random bytes"));

return result;

void sleep_millisec(int millisec);

/*

* Generate len bytes from the system cryptographically secure PRNG.

* Returns 0 on success and -1 on error, setting errno. The inability to

*/

/*

* Returns a random uint32_t, uniformly distributed across all possible

*/

/* Provide log2 of the given `size_t`. */

static inline unsigned log2u(uintmax_t sz)