mirror of
https://github.com/git/git.git
synced 2024-10-18 11:08:10 +02:00
Merge branch 'ps/no-writable-strings'
Building with "-Werror -Wwrite-strings" is now supported. * ps/no-writable-strings: (27 commits) config.mak.dev: enable `-Wwrite-strings` warning builtin/merge: always store allocated strings in `pull_twohead` builtin/rebase: always store allocated string in `options.strategy` builtin/rebase: do not assign default backend to non-constant field imap-send: fix leaking memory in `imap_server_conf` imap-send: drop global `imap_server_conf` variable mailmap: always store allocated strings in mailmap blob revision: always store allocated strings in output encoding remote-curl: avoid assigning string constant to non-const variable send-pack: always allocate receive status parse-options: cast long name for OPTION_ALIAS http: do not assign string constant to non-const field compat/win32: fix const-correctness with string constants pretty: add casts for decoration option pointers object-file: make `buf` parameter of `index_mem()` a constant object-file: mark cached object buffers as const ident: add casts for fallback name and GECOS entry: refactor how we remove items for delayed checkouts line-log: always allocate the output prefix line-log: stop assigning string constant to file parent buffer ...
This commit is contained in:
commit
4216329457
@ -262,7 +262,8 @@ static int bisect_reset(const char *commit)
|
||||
return bisect_clean_state();
|
||||
}
|
||||
|
||||
static void log_commit(FILE *fp, char *fmt, const char *state,
|
||||
static void log_commit(FILE *fp,
|
||||
const char *fmt, const char *state,
|
||||
struct commit *commit)
|
||||
{
|
||||
struct pretty_print_context pp = {0};
|
||||
|
@ -134,7 +134,7 @@ static void get_ac_line(const char *inbuf, const char *what,
|
||||
{
|
||||
struct ident_split ident;
|
||||
size_t len, maillen, namelen;
|
||||
char *tmp, *endp;
|
||||
const char *tmp, *endp;
|
||||
const char *namebuf, *mailbuf;
|
||||
|
||||
tmp = strstr(inbuf, what);
|
||||
|
@ -107,7 +107,7 @@ int cmd_bugreport(int argc, const char **argv, const char *prefix)
|
||||
struct tm tm;
|
||||
enum diagnose_mode diagnose = DIAGNOSE_NONE;
|
||||
char *option_output = NULL;
|
||||
char *option_suffix = "%Y-%m-%d-%H%M";
|
||||
const char *option_suffix = "%Y-%m-%d-%H%M";
|
||||
const char *user_relative_path = NULL;
|
||||
char *prefixed_filename;
|
||||
size_t output_path_len;
|
||||
|
@ -35,8 +35,8 @@ static const struct option check_ignore_options[] = {
|
||||
|
||||
static void output_pattern(const char *path, struct path_pattern *pattern)
|
||||
{
|
||||
char *bang = (pattern && pattern->flags & PATTERN_FLAG_NEGATIVE) ? "!" : "";
|
||||
char *slash = (pattern && pattern->flags & PATTERN_FLAG_MUSTBEDIR) ? "/" : "";
|
||||
const char *bang = (pattern && pattern->flags & PATTERN_FLAG_NEGATIVE) ? "!" : "";
|
||||
const char *slash = (pattern && pattern->flags & PATTERN_FLAG_MUSTBEDIR) ? "/" : "";
|
||||
if (!nul_term_line) {
|
||||
if (!verbose) {
|
||||
write_name_quoted(path, stdout, '\n');
|
||||
|
@ -71,7 +71,7 @@ static char *option_branch = NULL;
|
||||
static struct string_list option_not = STRING_LIST_INIT_NODUP;
|
||||
static const char *real_git_dir;
|
||||
static const char *ref_format;
|
||||
static char *option_upload_pack = "git-upload-pack";
|
||||
static const char *option_upload_pack = "git-upload-pack";
|
||||
static int option_verbosity;
|
||||
static int option_progress = -1;
|
||||
static int option_sparse_checkout;
|
||||
@ -177,8 +177,8 @@ static struct option builtin_clone_options[] = {
|
||||
|
||||
static const char *get_repo_path_1(struct strbuf *path, int *is_bundle)
|
||||
{
|
||||
static char *suffix[] = { "/.git", "", ".git/.git", ".git" };
|
||||
static char *bundle_suffix[] = { ".bundle", "" };
|
||||
static const char *suffix[] = { "/.git", "", ".git/.git", ".git" };
|
||||
static const char *bundle_suffix[] = { ".bundle", "" };
|
||||
size_t baselen = path->len;
|
||||
struct stat st;
|
||||
int i;
|
||||
@ -523,6 +523,9 @@ static struct ref *wanted_peer_refs(const struct ref *refs,
|
||||
struct ref *head = copy_ref(find_ref_by_name(refs, "HEAD"));
|
||||
struct ref *local_refs = head;
|
||||
struct ref **tail = head ? &head->next : &local_refs;
|
||||
struct refspec_item tag_refspec;
|
||||
|
||||
refspec_item_init(&tag_refspec, TAG_REFSPEC, 0);
|
||||
|
||||
if (option_single_branch) {
|
||||
struct ref *remote_head = NULL;
|
||||
@ -545,7 +548,7 @@ static struct ref *wanted_peer_refs(const struct ref *refs,
|
||||
&tail, 0);
|
||||
|
||||
/* if --branch=tag, pull the requested tag explicitly */
|
||||
get_fetch_map(remote_head, tag_refspec, &tail, 0);
|
||||
get_fetch_map(remote_head, &tag_refspec, &tail, 0);
|
||||
}
|
||||
free_refs(remote_head);
|
||||
} else {
|
||||
@ -555,8 +558,9 @@ static struct ref *wanted_peer_refs(const struct ref *refs,
|
||||
}
|
||||
|
||||
if (!option_mirror && !option_single_branch && !option_no_tags)
|
||||
get_fetch_map(refs, tag_refspec, &tail, 0);
|
||||
get_fetch_map(refs, &tag_refspec, &tail, 0);
|
||||
|
||||
refspec_item_clear(&tag_refspec);
|
||||
return local_refs;
|
||||
}
|
||||
|
||||
|
@ -113,7 +113,7 @@ static char *template_file;
|
||||
* the commit message and/or authorship.
|
||||
*/
|
||||
static const char *author_message, *author_message_buffer;
|
||||
static char *edit_message, *use_message;
|
||||
static const char *edit_message, *use_message;
|
||||
static char *fixup_message, *fixup_commit, *squash_message;
|
||||
static const char *fixup_prefix;
|
||||
static int all, also, interactive, patch_interactive, only, amend, signoff;
|
||||
@ -121,8 +121,8 @@ static int edit_flag = -1; /* unspecified */
|
||||
static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
|
||||
static int config_commit_verbose = -1; /* unspecified */
|
||||
static int no_post_rewrite, allow_empty_message, pathspec_file_nul;
|
||||
static char *untracked_files_arg, *force_date, *ignore_submodule_arg, *ignored_arg;
|
||||
static char *sign_commit, *pathspec_from_file;
|
||||
static const char *untracked_files_arg, *force_date, *ignore_submodule_arg, *ignored_arg;
|
||||
static const char *sign_commit, *pathspec_from_file;
|
||||
static struct strvec trailer_args = STRVEC_INIT;
|
||||
|
||||
/*
|
||||
|
@ -18,7 +18,7 @@ int cmd_diagnose(int argc, const char **argv, const char *prefix)
|
||||
struct tm tm;
|
||||
enum diagnose_mode mode = DIAGNOSE_STATS;
|
||||
char *option_output = NULL;
|
||||
char *option_suffix = "%Y-%m-%d-%H%M";
|
||||
const char *option_suffix = "%Y-%m-%d-%H%M";
|
||||
char *prefixed_filename;
|
||||
|
||||
const struct option diagnose_options[] = {
|
||||
|
@ -582,11 +582,16 @@ static struct ref *get_ref_map(struct remote *remote,
|
||||
}
|
||||
}
|
||||
|
||||
if (tags == TAGS_SET)
|
||||
if (tags == TAGS_SET) {
|
||||
struct refspec_item tag_refspec;
|
||||
|
||||
/* also fetch all tags */
|
||||
get_fetch_map(remote_refs, tag_refspec, &tail, 0);
|
||||
else if (tags == TAGS_DEFAULT && *autotags)
|
||||
refspec_item_init(&tag_refspec, TAG_REFSPEC, 0);
|
||||
get_fetch_map(remote_refs, &tag_refspec, &tail, 0);
|
||||
refspec_item_clear(&tag_refspec);
|
||||
} else if (tags == TAGS_DEFAULT && *autotags) {
|
||||
find_non_local_tags(remote_refs, NULL, &ref_map, &tail);
|
||||
}
|
||||
|
||||
/* Now append any refs to be updated opportunistically: */
|
||||
*tail = orefs;
|
||||
|
@ -1283,7 +1283,7 @@ static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids)
|
||||
o2->flags = flags2;
|
||||
}
|
||||
|
||||
static void gen_message_id(struct rev_info *info, char *base)
|
||||
static void gen_message_id(struct rev_info *info, const char *base)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
strbuf_addf(&buf, "%s.%"PRItime".git.%s", base,
|
||||
|
@ -113,8 +113,8 @@ static int populate_maildir_list(struct string_list *list, const char *path)
|
||||
DIR *dir;
|
||||
struct dirent *dent;
|
||||
char *name = NULL;
|
||||
char *subs[] = { "cur", "new", NULL };
|
||||
char **sub;
|
||||
const char *subs[] = { "cur", "new", NULL };
|
||||
const char **sub;
|
||||
int ret = -1;
|
||||
|
||||
for (sub = subs; *sub; ++sub) {
|
||||
|
@ -611,17 +611,19 @@ static int git_merge_config(const char *k, const char *v,
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat"))
|
||||
if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat")) {
|
||||
show_diffstat = git_config_bool(k, v);
|
||||
else if (!strcmp(k, "merge.verifysignatures"))
|
||||
} else if (!strcmp(k, "merge.verifysignatures")) {
|
||||
verify_signatures = git_config_bool(k, v);
|
||||
else if (!strcmp(k, "pull.twohead"))
|
||||
} else if (!strcmp(k, "pull.twohead")) {
|
||||
FREE_AND_NULL(pull_twohead);
|
||||
return git_config_string(&pull_twohead, k, v);
|
||||
else if (!strcmp(k, "pull.octopus"))
|
||||
} else if (!strcmp(k, "pull.octopus")) {
|
||||
FREE_AND_NULL(pull_octopus);
|
||||
return git_config_string(&pull_octopus, k, v);
|
||||
else if (!strcmp(k, "commit.cleanup"))
|
||||
} else if (!strcmp(k, "commit.cleanup")) {
|
||||
return git_config_string(&cleanup_arg, k, v);
|
||||
else if (!strcmp(k, "merge.ff")) {
|
||||
} else if (!strcmp(k, "merge.ff")) {
|
||||
int boolval = git_parse_maybe_bool(v);
|
||||
if (0 <= boolval) {
|
||||
fast_forward = boolval ? FF_ALLOW : FF_NO;
|
||||
@ -1294,7 +1296,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
|
||||
if (!pull_twohead) {
|
||||
char *default_strategy = getenv("GIT_TEST_MERGE_ALGORITHM");
|
||||
if (default_strategy && !strcmp(default_strategy, "ort"))
|
||||
pull_twohead = "ort";
|
||||
pull_twohead = xstrdup("ort");
|
||||
}
|
||||
|
||||
init_diff_ui_defaults();
|
||||
@ -1793,6 +1795,8 @@ done:
|
||||
}
|
||||
strbuf_release(&buf);
|
||||
free(branch_to_free);
|
||||
free(pull_twohead);
|
||||
free(pull_octopus);
|
||||
discard_index(the_repository->index);
|
||||
return ret;
|
||||
}
|
||||
|
@ -71,48 +71,48 @@ static const char * const pull_usage[] = {
|
||||
|
||||
/* Shared options */
|
||||
static int opt_verbosity;
|
||||
static char *opt_progress;
|
||||
static const char *opt_progress;
|
||||
static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
|
||||
static int recurse_submodules_cli = RECURSE_SUBMODULES_DEFAULT;
|
||||
|
||||
/* Options passed to git-merge or git-rebase */
|
||||
static enum rebase_type opt_rebase = -1;
|
||||
static char *opt_diffstat;
|
||||
static char *opt_log;
|
||||
static char *opt_signoff;
|
||||
static char *opt_squash;
|
||||
static char *opt_commit;
|
||||
static char *opt_edit;
|
||||
static char *cleanup_arg;
|
||||
static char *opt_ff;
|
||||
static char *opt_verify_signatures;
|
||||
static char *opt_verify;
|
||||
static const char *opt_diffstat;
|
||||
static const char *opt_log;
|
||||
static const char *opt_signoff;
|
||||
static const char *opt_squash;
|
||||
static const char *opt_commit;
|
||||
static const char *opt_edit;
|
||||
static const char *cleanup_arg;
|
||||
static const char *opt_ff;
|
||||
static const char *opt_verify_signatures;
|
||||
static const char *opt_verify;
|
||||
static int opt_autostash = -1;
|
||||
static int config_autostash;
|
||||
static int check_trust_level = 1;
|
||||
static struct strvec opt_strategies = STRVEC_INIT;
|
||||
static struct strvec opt_strategy_opts = STRVEC_INIT;
|
||||
static char *opt_gpg_sign;
|
||||
static const char *opt_gpg_sign;
|
||||
static int opt_allow_unrelated_histories;
|
||||
|
||||
/* Options passed to git-fetch */
|
||||
static char *opt_all;
|
||||
static char *opt_append;
|
||||
static char *opt_upload_pack;
|
||||
static const char *opt_all;
|
||||
static const char *opt_append;
|
||||
static const char *opt_upload_pack;
|
||||
static int opt_force;
|
||||
static char *opt_tags;
|
||||
static char *opt_prune;
|
||||
static char *max_children;
|
||||
static const char *opt_tags;
|
||||
static const char *opt_prune;
|
||||
static const char *max_children;
|
||||
static int opt_dry_run;
|
||||
static char *opt_keep;
|
||||
static char *opt_depth;
|
||||
static char *opt_unshallow;
|
||||
static char *opt_update_shallow;
|
||||
static char *opt_refmap;
|
||||
static char *opt_ipv4;
|
||||
static char *opt_ipv6;
|
||||
static const char *opt_keep;
|
||||
static const char *opt_depth;
|
||||
static const char *opt_unshallow;
|
||||
static const char *opt_update_shallow;
|
||||
static const char *opt_refmap;
|
||||
static const char *opt_ipv4;
|
||||
static const char *opt_ipv6;
|
||||
static int opt_show_forced_updates = -1;
|
||||
static char *set_upstream;
|
||||
static const char *set_upstream;
|
||||
static struct strvec opt_fetch = STRVEC_INIT;
|
||||
|
||||
static struct option pull_options[] = {
|
||||
|
@ -135,7 +135,7 @@ struct rebase_options {
|
||||
.type = REBASE_UNSPECIFIED, \
|
||||
.empty = EMPTY_UNSPECIFIED, \
|
||||
.keep_empty = 1, \
|
||||
.default_backend = "merge", \
|
||||
.default_backend = xstrdup("merge"), \
|
||||
.flags = REBASE_NO_QUIET, \
|
||||
.git_am_opts = STRVEC_INIT, \
|
||||
.exec = STRING_LIST_INIT_NODUP, \
|
||||
@ -151,6 +151,19 @@ struct rebase_options {
|
||||
.strategy_opts = STRING_LIST_INIT_NODUP,\
|
||||
}
|
||||
|
||||
static void rebase_options_release(struct rebase_options *opts)
|
||||
{
|
||||
free(opts->default_backend);
|
||||
free(opts->reflog_action);
|
||||
free(opts->head_name);
|
||||
strvec_clear(&opts->git_am_opts);
|
||||
free(opts->gpg_sign_opt);
|
||||
string_list_clear(&opts->exec, 0);
|
||||
free(opts->strategy);
|
||||
string_list_clear(&opts->strategy_opts, 0);
|
||||
strbuf_release(&opts->git_format_patch_opt);
|
||||
}
|
||||
|
||||
static struct replay_opts get_replay_opts(const struct rebase_options *opts)
|
||||
{
|
||||
struct replay_opts replay = REPLAY_OPTS_INIT;
|
||||
@ -796,6 +809,7 @@ static int rebase_config(const char *var, const char *value,
|
||||
}
|
||||
|
||||
if (!strcmp(var, "rebase.backend")) {
|
||||
FREE_AND_NULL(opts->default_backend);
|
||||
return git_config_string(&opts->default_backend, var, value);
|
||||
}
|
||||
|
||||
@ -1047,6 +1061,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
|
||||
{
|
||||
struct rebase_options options = REBASE_OPTIONS_INIT;
|
||||
const char *branch_name;
|
||||
const char *strategy_opt = NULL;
|
||||
int ret, flags, total_argc, in_progress = 0;
|
||||
int keep_base = 0;
|
||||
int ok_to_skip_pre_rebase = 0;
|
||||
@ -1161,7 +1176,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
|
||||
PARSE_OPT_OPTARG, parse_opt_rebase_merges),
|
||||
OPT_BOOL(0, "fork-point", &options.fork_point,
|
||||
N_("use 'merge-base --fork-point' to refine upstream")),
|
||||
OPT_STRING('s', "strategy", &options.strategy,
|
||||
OPT_STRING('s', "strategy", &strategy_opt,
|
||||
N_("strategy"), N_("use the given merge strategy")),
|
||||
OPT_STRING_LIST('X', "strategy-option", &options.strategy_opts,
|
||||
N_("option"),
|
||||
@ -1470,13 +1485,12 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
|
||||
}
|
||||
}
|
||||
|
||||
if (options.strategy_opts.nr && !options.strategy)
|
||||
options.strategy = "ort";
|
||||
|
||||
if (options.strategy) {
|
||||
options.strategy = xstrdup(options.strategy);
|
||||
if (strategy_opt)
|
||||
options.strategy = xstrdup(strategy_opt);
|
||||
else if (options.strategy_opts.nr && !options.strategy)
|
||||
options.strategy = xstrdup("ort");
|
||||
if (options.strategy)
|
||||
imply_merge(&options, "--strategy");
|
||||
}
|
||||
|
||||
if (options.root && !options.onto_name)
|
||||
imply_merge(&options, "--root without --onto");
|
||||
@ -1833,14 +1847,7 @@ run_rebase:
|
||||
cleanup:
|
||||
strbuf_release(&buf);
|
||||
strbuf_release(&revisions);
|
||||
free(options.reflog_action);
|
||||
free(options.head_name);
|
||||
strvec_clear(&options.git_am_opts);
|
||||
free(options.gpg_sign_opt);
|
||||
string_list_clear(&options.exec, 0);
|
||||
free(options.strategy);
|
||||
string_list_clear(&options.strategy_opts, 0);
|
||||
strbuf_release(&options.git_format_patch_opt);
|
||||
rebase_options_release(&options);
|
||||
free(squash_onto_name);
|
||||
free(keep_base_onto_name);
|
||||
return !!ret;
|
||||
|
@ -1249,7 +1249,7 @@ cleanup:
|
||||
return code;
|
||||
}
|
||||
|
||||
static char *refuse_unconfigured_deny_msg =
|
||||
static const char *refuse_unconfigured_deny_msg =
|
||||
N_("By default, updating the current branch in a non-bare repository\n"
|
||||
"is denied, because it will make the index and work tree inconsistent\n"
|
||||
"with what you pushed, and will require 'git reset --hard' to match\n"
|
||||
@ -1269,7 +1269,7 @@ static void refuse_unconfigured_deny(void)
|
||||
rp_error("%s", _(refuse_unconfigured_deny_msg));
|
||||
}
|
||||
|
||||
static char *refuse_unconfigured_deny_delete_current_msg =
|
||||
static const char *refuse_unconfigured_deny_delete_current_msg =
|
||||
N_("By default, deleting the current branch is denied, because the next\n"
|
||||
"'git clone' won't result in any file checked out, causing confusion.\n"
|
||||
"\n"
|
||||
|
@ -493,12 +493,13 @@ static int get_head_names(const struct ref *remote_refs, struct ref_states *stat
|
||||
{
|
||||
struct ref *ref, *matches;
|
||||
struct ref *fetch_map = NULL, **fetch_map_tail = &fetch_map;
|
||||
struct refspec_item refspec;
|
||||
struct refspec_item refspec = {
|
||||
.force = 0,
|
||||
.pattern = 1,
|
||||
.src = (char *) "refs/heads/*",
|
||||
.dst = (char *) "refs/heads/*",
|
||||
};
|
||||
|
||||
memset(&refspec, 0, sizeof(refspec));
|
||||
refspec.force = 0;
|
||||
refspec.pattern = 1;
|
||||
refspec.src = refspec.dst = "refs/heads/*";
|
||||
get_fetch_map(remote_refs, &refspec, &fetch_map_tail, 0);
|
||||
matches = guess_remote_head(find_ref_by_name(remote_refs, "HEAD"),
|
||||
fetch_map, 1);
|
||||
@ -507,7 +508,6 @@ static int get_head_names(const struct ref *remote_refs, struct ref_states *stat
|
||||
|
||||
free_refs(fetch_map);
|
||||
free_refs(matches);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -179,7 +179,7 @@ static int run_sequencer(int argc, const char **argv, const char *prefix,
|
||||
|
||||
/* Check for incompatible command line arguments */
|
||||
if (cmd) {
|
||||
char *this_operation;
|
||||
const char *this_operation;
|
||||
if (cmd == 'q')
|
||||
this_operation = "--quit";
|
||||
else if (cmd == 'c')
|
||||
|
@ -336,5 +336,7 @@ int cmd_send_pack(int argc, const char **argv, const char *prefix)
|
||||
/* stable plumbing output; do not modify or localize */
|
||||
fprintf(stderr, "Everything up-to-date\n");
|
||||
|
||||
free_refs(remote_refs);
|
||||
free_refs(local_refs);
|
||||
return ret;
|
||||
}
|
||||
|
@ -10,7 +10,13 @@ char *gitbasename (char *path)
|
||||
skip_dos_drive_prefix(&path);
|
||||
|
||||
if (!path || !*path)
|
||||
return ".";
|
||||
/*
|
||||
* basename(3P) is mis-specified because it returns a
|
||||
* non-constant pointer even though it is specified to return a
|
||||
* pointer to internal memory at times. The cast is a result of
|
||||
* that.
|
||||
*/
|
||||
return (char *) ".";
|
||||
|
||||
for (base = path; *path; path++) {
|
||||
if (!is_dir_sep(*path))
|
||||
@ -34,7 +40,13 @@ char *gitdirname(char *path)
|
||||
int dos_drive_prefix;
|
||||
|
||||
if (!p)
|
||||
return ".";
|
||||
/*
|
||||
* dirname(3P) is mis-specified because it returns a
|
||||
* non-constant pointer even though it is specified to return a
|
||||
* pointer to internal memory at times. The cast is a result of
|
||||
* that.
|
||||
*/
|
||||
return (char *) ".";
|
||||
|
||||
if ((dos_drive_prefix = skip_dos_drive_prefix(&p)) && !*p)
|
||||
goto dot;
|
||||
|
@ -2279,7 +2279,11 @@ struct passwd *getpwuid(int uid)
|
||||
p->pw_name = user_name;
|
||||
p->pw_gecos = get_extended_user_info(NameDisplay);
|
||||
if (!p->pw_gecos)
|
||||
p->pw_gecos = "unknown";
|
||||
/*
|
||||
* Data returned by getpwuid(3P) is treated as internal and
|
||||
* must never be written to or freed.
|
||||
*/
|
||||
p->pw_gecos = (char *) "unknown";
|
||||
p->pw_dir = NULL;
|
||||
|
||||
initialized = 1;
|
||||
@ -2800,16 +2804,16 @@ int is_path_owned_by_current_sid(const char *path, struct strbuf *report)
|
||||
strbuf_addf(report, "'%s' is on a file system that does "
|
||||
"not record ownership\n", path);
|
||||
} else if (report) {
|
||||
LPSTR str1, str2, str3, str4, to_free1 = NULL,
|
||||
to_free3 = NULL, to_local_free2 = NULL,
|
||||
to_local_free4 = NULL;
|
||||
PCSTR str1, str2, str3, str4;
|
||||
LPSTR to_free1 = NULL, to_free3 = NULL,
|
||||
to_local_free2 = NULL, to_local_free4 = NULL;
|
||||
|
||||
if (user_sid_to_user_name(sid, &str1))
|
||||
to_free1 = str1;
|
||||
if (user_sid_to_user_name(sid, &to_free1))
|
||||
str1 = to_free1;
|
||||
else
|
||||
str1 = "(inconvertible)";
|
||||
if (ConvertSidToStringSidA(sid, &str2))
|
||||
to_local_free2 = str2;
|
||||
if (ConvertSidToStringSidA(sid, &to_local_free2))
|
||||
str2 = to_local_free2;
|
||||
else
|
||||
str2 = "(inconvertible)";
|
||||
|
||||
@ -2822,13 +2826,13 @@ int is_path_owned_by_current_sid(const char *path, struct strbuf *report)
|
||||
str4 = "(invalid)";
|
||||
} else {
|
||||
if (user_sid_to_user_name(current_user_sid,
|
||||
&str3))
|
||||
to_free3 = str3;
|
||||
&to_free3))
|
||||
str3 = to_free3;
|
||||
else
|
||||
str3 = "(inconvertible)";
|
||||
if (ConvertSidToStringSidA(current_user_sid,
|
||||
&str4))
|
||||
to_local_free4 = str4;
|
||||
&to_local_free4))
|
||||
str4 = to_local_free4;
|
||||
else
|
||||
str4 = "(inconvertible)";
|
||||
}
|
||||
|
@ -848,7 +848,7 @@ init_dfa (re_dfa_t *dfa, size_t pat_len)
|
||||
{
|
||||
unsigned int table_size;
|
||||
#ifndef _LIBC
|
||||
char *codeset_name;
|
||||
const char *codeset_name;
|
||||
#endif
|
||||
|
||||
memset (dfa, '\0', sizeof (re_dfa_t));
|
||||
|
@ -139,7 +139,7 @@ static void write_console(unsigned char *str, size_t len)
|
||||
/* convert utf-8 to utf-16 */
|
||||
int wlen = xutftowcsn(wbuf, (char*) str, ARRAY_SIZE(wbuf), len);
|
||||
if (wlen < 0) {
|
||||
wchar_t *err = L"[invalid]";
|
||||
const wchar_t *err = L"[invalid]";
|
||||
WriteConsoleW(console, err, wcslen(err), &dummy, NULL);
|
||||
return;
|
||||
}
|
||||
|
@ -37,6 +37,7 @@ DEVELOPER_CFLAGS += -Wpointer-arith
|
||||
DEVELOPER_CFLAGS += -Wstrict-prototypes
|
||||
DEVELOPER_CFLAGS += -Wunused
|
||||
DEVELOPER_CFLAGS += -Wvla
|
||||
DEVELOPER_CFLAGS += -Wwrite-strings
|
||||
DEVELOPER_CFLAGS += -fno-common
|
||||
|
||||
ifneq ($(filter clang4,$(COMPILER_FEATURES)),)
|
||||
|
6
diff.c
6
diff.c
@ -3764,7 +3764,7 @@ static void builtin_diff(const char *name_a,
|
||||
return;
|
||||
}
|
||||
|
||||
static char *get_compact_summary(const struct diff_filepair *p, int is_renamed)
|
||||
static const char *get_compact_summary(const struct diff_filepair *p, int is_renamed)
|
||||
{
|
||||
if (!is_renamed) {
|
||||
if (p->status == DIFF_STATUS_ADDED) {
|
||||
@ -4076,7 +4076,7 @@ static int reuse_worktree_file(struct index_state *istate,
|
||||
static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
char *dirty = "";
|
||||
const char *dirty = "";
|
||||
|
||||
/* Are we looking at the work tree? */
|
||||
if (s->dirty_submodule)
|
||||
@ -7235,7 +7235,7 @@ size_t fill_textconv(struct repository *r,
|
||||
|
||||
if (!driver) {
|
||||
if (!DIFF_FILE_VALID(df)) {
|
||||
*outbuf = "";
|
||||
*outbuf = (char *) "";
|
||||
return 0;
|
||||
}
|
||||
if (diff_populate_filespec(r, df, NULL))
|
||||
|
@ -406,7 +406,7 @@ static const char *get_highest_rename_path(struct strintmap *counts)
|
||||
return highest_destination_dir;
|
||||
}
|
||||
|
||||
static char *UNKNOWN_DIR = "/"; /* placeholder -- short, illegal directory */
|
||||
static const char *UNKNOWN_DIR = "/"; /* placeholder -- short, illegal directory */
|
||||
|
||||
static int dir_rename_already_determinable(struct strintmap *counts)
|
||||
{
|
||||
@ -429,8 +429,8 @@ static int dir_rename_already_determinable(struct strintmap *counts)
|
||||
}
|
||||
|
||||
static void increment_count(struct dir_rename_info *info,
|
||||
char *old_dir,
|
||||
char *new_dir)
|
||||
const char *old_dir,
|
||||
const char *new_dir)
|
||||
{
|
||||
struct strintmap *counts;
|
||||
struct strmap_entry *e;
|
||||
|
14
entry.c
14
entry.c
@ -167,6 +167,11 @@ static int remove_available_paths(struct string_list_item *item, void *cb_data)
|
||||
return !available;
|
||||
}
|
||||
|
||||
static int string_is_not_null(struct string_list_item *item, void *data UNUSED)
|
||||
{
|
||||
return !!item->string;
|
||||
}
|
||||
|
||||
int finish_delayed_checkout(struct checkout *state, int show_progress)
|
||||
{
|
||||
int errs = 0;
|
||||
@ -189,7 +194,7 @@ int finish_delayed_checkout(struct checkout *state, int show_progress)
|
||||
if (!async_query_available_blobs(filter->string, &available_paths)) {
|
||||
/* Filter reported an error */
|
||||
errs = 1;
|
||||
filter->string = "";
|
||||
filter->string = NULL;
|
||||
continue;
|
||||
}
|
||||
if (available_paths.nr <= 0) {
|
||||
@ -199,7 +204,7 @@ int finish_delayed_checkout(struct checkout *state, int show_progress)
|
||||
* filter from the list (see
|
||||
* "string_list_remove_empty_items" call below).
|
||||
*/
|
||||
filter->string = "";
|
||||
filter->string = NULL;
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -225,7 +230,7 @@ int finish_delayed_checkout(struct checkout *state, int show_progress)
|
||||
* Do not ask the filter for available blobs,
|
||||
* again, as the filter is likely buggy.
|
||||
*/
|
||||
filter->string = "";
|
||||
filter->string = NULL;
|
||||
continue;
|
||||
}
|
||||
ce = index_file_exists(state->istate, path->string,
|
||||
@ -239,7 +244,8 @@ int finish_delayed_checkout(struct checkout *state, int show_progress)
|
||||
errs = 1;
|
||||
}
|
||||
}
|
||||
string_list_remove_empty_items(&dco->filters, 0);
|
||||
|
||||
filter_string_list(&dco->filters, 0, string_is_not_null, NULL);
|
||||
}
|
||||
stop_progress(&progress);
|
||||
string_list_clear(&dco->filters, 0);
|
||||
|
@ -447,7 +447,7 @@ static void fmt_merge_msg_title(struct strbuf *out,
|
||||
const char *current_branch)
|
||||
{
|
||||
int i = 0;
|
||||
char *sep = "";
|
||||
const char *sep = "";
|
||||
|
||||
strbuf_addstr(out, "Merge ");
|
||||
for (i = 0; i < srcs.nr; i++) {
|
||||
|
2
fsck.c
2
fsck.c
@ -1179,7 +1179,7 @@ int fsck_object(struct object *obj, void *data, unsigned long size,
|
||||
}
|
||||
|
||||
int fsck_buffer(const struct object_id *oid, enum object_type type,
|
||||
void *data, unsigned long size,
|
||||
const void *data, unsigned long size,
|
||||
struct fsck_options *options)
|
||||
{
|
||||
if (type == OBJ_BLOB)
|
||||
|
2
fsck.h
2
fsck.h
@ -190,7 +190,7 @@ int fsck_object(struct object *obj, void *data, unsigned long size,
|
||||
* struct.
|
||||
*/
|
||||
int fsck_buffer(const struct object_id *oid, enum object_type,
|
||||
void *data, unsigned long size,
|
||||
const void *data, unsigned long size,
|
||||
struct fsck_options *options);
|
||||
|
||||
/*
|
||||
|
@ -34,7 +34,7 @@ static enum signature_trust_level configured_min_trust_level = TRUST_UNDEFINED;
|
||||
|
||||
struct gpg_format {
|
||||
const char *name;
|
||||
char *program;
|
||||
const char *program;
|
||||
const char **verify_args;
|
||||
const char **sigs;
|
||||
int (*verify_signed_buffer)(struct signature_check *sigc,
|
||||
@ -727,7 +727,7 @@ static int git_gpg_config(const char *var, const char *value,
|
||||
void *cb UNUSED)
|
||||
{
|
||||
struct gpg_format *fmt = NULL;
|
||||
char *fmtname = NULL;
|
||||
const char *fmtname = NULL;
|
||||
char *trust;
|
||||
int ret;
|
||||
|
||||
@ -783,7 +783,7 @@ static int git_gpg_config(const char *var, const char *value,
|
||||
|
||||
if (fmtname) {
|
||||
fmt = get_format_by_name(fmtname);
|
||||
return git_config_string(&fmt->program, var, value);
|
||||
return git_config_string((char **) &fmt->program, var, value);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -753,7 +753,7 @@ static int bad_request(struct strbuf *hdr, const struct service_cmd *c)
|
||||
|
||||
int cmd_main(int argc UNUSED, const char **argv UNUSED)
|
||||
{
|
||||
char *method = getenv("REQUEST_METHOD");
|
||||
const char *method = getenv("REQUEST_METHOD");
|
||||
const char *proto_header;
|
||||
char *dir;
|
||||
struct service_cmd *cmd = NULL;
|
||||
|
5
http.c
5
http.c
@ -1974,7 +1974,7 @@ static void write_accept_language(struct strbuf *buf)
|
||||
|
||||
/* add '*' */
|
||||
REALLOC_ARRAY(language_tags, num_langs + 1);
|
||||
language_tags[num_langs++] = "*"; /* it's OK; this won't be freed */
|
||||
language_tags[num_langs++] = xstrdup("*");
|
||||
|
||||
/* compute decimal_places */
|
||||
for (max_q = 1, decimal_places = 0;
|
||||
@ -2004,8 +2004,7 @@ static void write_accept_language(struct strbuf *buf)
|
||||
}
|
||||
}
|
||||
|
||||
/* free language tags -- last one is a static '*' */
|
||||
for (i = 0; i < num_langs - 1; i++)
|
||||
for (i = 0; i < num_langs; i++)
|
||||
free(language_tags[i]);
|
||||
free(language_tags);
|
||||
}
|
||||
|
4
ident.c
4
ident.c
@ -46,9 +46,9 @@ static struct passwd *xgetpwuid_self(int *is_bogus)
|
||||
pw = getpwuid(getuid());
|
||||
if (!pw) {
|
||||
static struct passwd fallback;
|
||||
fallback.pw_name = "unknown";
|
||||
fallback.pw_name = (char *) "unknown";
|
||||
#ifndef NO_GECOS_IN_PWENT
|
||||
fallback.pw_gecos = "Unknown";
|
||||
fallback.pw_gecos = (char *) "Unknown";
|
||||
#endif
|
||||
pw = &fallback;
|
||||
if (is_bogus)
|
||||
|
126
imap-send.c
126
imap-send.c
@ -69,7 +69,6 @@ static void imap_warn(const char *, ...);
|
||||
static char *next_arg(char **);
|
||||
|
||||
struct imap_server_conf {
|
||||
const char *name;
|
||||
char *tunnel;
|
||||
char *host;
|
||||
int port;
|
||||
@ -82,10 +81,6 @@ struct imap_server_conf {
|
||||
char *auth_method;
|
||||
};
|
||||
|
||||
static struct imap_server_conf server = {
|
||||
.ssl_verify = 1,
|
||||
};
|
||||
|
||||
struct imap_socket {
|
||||
int fd[2];
|
||||
SSL *ssl;
|
||||
@ -110,6 +105,7 @@ struct imap {
|
||||
};
|
||||
|
||||
struct imap_store {
|
||||
const struct imap_server_conf *cfg;
|
||||
/* currently open mailbox */
|
||||
const char *name; /* foreign! maybe preset? */
|
||||
int uidvalidity;
|
||||
@ -194,8 +190,8 @@ static void socket_perror(const char *func, struct imap_socket *sock, int ret)
|
||||
|
||||
#ifdef NO_OPENSSL
|
||||
static int ssl_socket_connect(struct imap_socket *sock UNUSED,
|
||||
int use_tls_only UNUSED,
|
||||
int verify UNUSED)
|
||||
const struct imap_server_conf *cfg,
|
||||
int use_tls_only UNUSED)
|
||||
{
|
||||
fprintf(stderr, "SSL requested but SSL support not compiled in\n");
|
||||
return -1;
|
||||
@ -250,7 +246,9 @@ static int verify_hostname(X509 *cert, const char *hostname)
|
||||
cname, hostname);
|
||||
}
|
||||
|
||||
static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int verify)
|
||||
static int ssl_socket_connect(struct imap_socket *sock,
|
||||
const struct imap_server_conf *cfg,
|
||||
int use_tls_only)
|
||||
{
|
||||
#if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
|
||||
const SSL_METHOD *meth;
|
||||
@ -279,7 +277,7 @@ static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int ve
|
||||
if (use_tls_only)
|
||||
SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
|
||||
|
||||
if (verify)
|
||||
if (cfg->ssl_verify)
|
||||
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
|
||||
|
||||
if (!SSL_CTX_set_default_verify_paths(ctx)) {
|
||||
@ -306,9 +304,9 @@ static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int ve
|
||||
* OpenSSL does not document this function, but the implementation
|
||||
* returns 1 on success, 0 on failure after calling SSLerr().
|
||||
*/
|
||||
ret = SSL_set_tlsext_host_name(sock->ssl, server.host);
|
||||
ret = SSL_set_tlsext_host_name(sock->ssl, cfg->host);
|
||||
if (ret != 1)
|
||||
warning("SSL_set_tlsext_host_name(%s) failed.", server.host);
|
||||
warning("SSL_set_tlsext_host_name(%s) failed.", cfg->host);
|
||||
#endif
|
||||
|
||||
ret = SSL_connect(sock->ssl);
|
||||
@ -317,12 +315,12 @@ static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int ve
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (verify) {
|
||||
if (cfg->ssl_verify) {
|
||||
/* make sure the hostname matches that of the certificate */
|
||||
cert = SSL_get_peer_certificate(sock->ssl);
|
||||
if (!cert)
|
||||
return error("unable to get peer certificate.");
|
||||
if (verify_hostname(cert, server.host) < 0)
|
||||
if (verify_hostname(cert, cfg->host) < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -895,7 +893,7 @@ static int auth_cram_md5(struct imap_store *ctx, const char *prompt)
|
||||
int ret;
|
||||
char *response;
|
||||
|
||||
response = cram(prompt, server.user, server.pass);
|
||||
response = cram(prompt, ctx->cfg->user, ctx->cfg->pass);
|
||||
|
||||
ret = socket_write(&ctx->imap->buf.sock, response, strlen(response));
|
||||
if (ret != strlen(response))
|
||||
@ -935,6 +933,7 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc, const c
|
||||
|
||||
CALLOC_ARRAY(ctx, 1);
|
||||
|
||||
ctx->cfg = srvc;
|
||||
ctx->imap = CALLOC_ARRAY(imap, 1);
|
||||
imap->buf.sock.fd[0] = imap->buf.sock.fd[1] = -1;
|
||||
imap->in_progress_append = &imap->in_progress;
|
||||
@ -1035,7 +1034,7 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc, const c
|
||||
imap->buf.sock.fd[1] = dup(s);
|
||||
|
||||
if (srvc->use_ssl &&
|
||||
ssl_socket_connect(&imap->buf.sock, 0, srvc->ssl_verify)) {
|
||||
ssl_socket_connect(&imap->buf.sock, srvc, 0)) {
|
||||
close(s);
|
||||
goto bail;
|
||||
}
|
||||
@ -1068,8 +1067,7 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc, const c
|
||||
if (!srvc->use_ssl && CAP(STARTTLS)) {
|
||||
if (imap_exec(ctx, NULL, "STARTTLS") != RESP_OK)
|
||||
goto bail;
|
||||
if (ssl_socket_connect(&imap->buf.sock, 1,
|
||||
srvc->ssl_verify))
|
||||
if (ssl_socket_connect(&imap->buf.sock, srvc, 1))
|
||||
goto bail;
|
||||
/* capabilities may have changed, so get the new capabilities */
|
||||
if (imap_exec(ctx, NULL, "CAPABILITY") != RESP_OK)
|
||||
@ -1215,9 +1213,9 @@ static int imap_store_msg(struct imap_store *ctx, struct strbuf *msg)
|
||||
static void wrap_in_html(struct strbuf *msg)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
static char *content_type = "Content-Type: text/html;\n";
|
||||
static char *pre_open = "<pre>\n";
|
||||
static char *pre_close = "</pre>\n";
|
||||
static const char *content_type = "Content-Type: text/html;\n";
|
||||
static const char *pre_open = "<pre>\n";
|
||||
static const char *pre_close = "</pre>\n";
|
||||
const char *body = strstr(msg->buf, "\n\n");
|
||||
|
||||
if (!body)
|
||||
@ -1299,24 +1297,30 @@ static int split_msg(struct strbuf *all_msgs, struct strbuf *msg, int *ofs)
|
||||
static int git_imap_config(const char *var, const char *val,
|
||||
const struct config_context *ctx, void *cb)
|
||||
{
|
||||
struct imap_server_conf *cfg = cb;
|
||||
|
||||
if (!strcmp("imap.sslverify", var))
|
||||
server.ssl_verify = git_config_bool(var, val);
|
||||
else if (!strcmp("imap.preformattedhtml", var))
|
||||
server.use_html = git_config_bool(var, val);
|
||||
else if (!strcmp("imap.folder", var))
|
||||
return git_config_string(&server.folder, var, val);
|
||||
else if (!strcmp("imap.user", var))
|
||||
return git_config_string(&server.user, var, val);
|
||||
else if (!strcmp("imap.pass", var))
|
||||
return git_config_string(&server.pass, var, val);
|
||||
else if (!strcmp("imap.tunnel", var))
|
||||
return git_config_string(&server.tunnel, var, val);
|
||||
else if (!strcmp("imap.authmethod", var))
|
||||
return git_config_string(&server.auth_method, var, val);
|
||||
else if (!strcmp("imap.port", var))
|
||||
server.port = git_config_int(var, val, ctx->kvi);
|
||||
else if (!strcmp("imap.host", var)) {
|
||||
if (!strcmp("imap.sslverify", var)) {
|
||||
cfg->ssl_verify = git_config_bool(var, val);
|
||||
} else if (!strcmp("imap.preformattedhtml", var)) {
|
||||
cfg->use_html = git_config_bool(var, val);
|
||||
} else if (!strcmp("imap.folder", var)) {
|
||||
FREE_AND_NULL(cfg->folder);
|
||||
return git_config_string(&cfg->folder, var, val);
|
||||
} else if (!strcmp("imap.user", var)) {
|
||||
FREE_AND_NULL(cfg->folder);
|
||||
return git_config_string(&cfg->user, var, val);
|
||||
} else if (!strcmp("imap.pass", var)) {
|
||||
FREE_AND_NULL(cfg->folder);
|
||||
return git_config_string(&cfg->pass, var, val);
|
||||
} else if (!strcmp("imap.tunnel", var)) {
|
||||
FREE_AND_NULL(cfg->folder);
|
||||
return git_config_string(&cfg->tunnel, var, val);
|
||||
} else if (!strcmp("imap.authmethod", var)) {
|
||||
FREE_AND_NULL(cfg->folder);
|
||||
return git_config_string(&cfg->auth_method, var, val);
|
||||
} else if (!strcmp("imap.port", var)) {
|
||||
cfg->port = git_config_int(var, val, ctx->kvi);
|
||||
} else if (!strcmp("imap.host", var)) {
|
||||
if (!val) {
|
||||
return config_error_nonbool(var);
|
||||
} else {
|
||||
@ -1324,14 +1328,15 @@ static int git_imap_config(const char *var, const char *val,
|
||||
val += 5;
|
||||
else if (starts_with(val, "imaps:")) {
|
||||
val += 6;
|
||||
server.use_ssl = 1;
|
||||
cfg->use_ssl = 1;
|
||||
}
|
||||
if (starts_with(val, "//"))
|
||||
val += 2;
|
||||
server.host = xstrdup(val);
|
||||
cfg->host = xstrdup(val);
|
||||
}
|
||||
} else
|
||||
} else {
|
||||
return git_default_config(var, val, ctx, cb);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1497,12 +1502,16 @@ static int curl_append_msgs_to_imap(struct imap_server_conf *server,
|
||||
|
||||
int cmd_main(int argc, const char **argv)
|
||||
{
|
||||
struct imap_server_conf server = {
|
||||
.ssl_verify = 1,
|
||||
};
|
||||
struct strbuf all_msgs = STRBUF_INIT;
|
||||
int total;
|
||||
int nongit_ok;
|
||||
int ret;
|
||||
|
||||
setup_git_directory_gently(&nongit_ok);
|
||||
git_config(git_imap_config, NULL);
|
||||
git_config(git_imap_config, &server);
|
||||
|
||||
argc = parse_options(argc, (const char **)argv, "", imap_send_options, imap_send_usage, 0);
|
||||
|
||||
@ -1526,43 +1535,56 @@ int cmd_main(int argc, const char **argv)
|
||||
|
||||
if (!server.folder) {
|
||||
fprintf(stderr, "no imap store specified\n");
|
||||
return 1;
|
||||
ret = 1;
|
||||
goto out;
|
||||
}
|
||||
if (!server.host) {
|
||||
if (!server.tunnel) {
|
||||
fprintf(stderr, "no imap host specified\n");
|
||||
return 1;
|
||||
ret = 1;
|
||||
goto out;
|
||||
}
|
||||
server.host = "tunnel";
|
||||
server.host = xstrdup("tunnel");
|
||||
}
|
||||
|
||||
/* read the messages */
|
||||
if (strbuf_read(&all_msgs, 0, 0) < 0) {
|
||||
error_errno(_("could not read from stdin"));
|
||||
return 1;
|
||||
ret = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (all_msgs.len == 0) {
|
||||
strbuf_release(&all_msgs);
|
||||
fprintf(stderr, "nothing to send\n");
|
||||
return 1;
|
||||
ret = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
total = count_messages(&all_msgs);
|
||||
if (!total) {
|
||||
fprintf(stderr, "no messages to send\n");
|
||||
return 1;
|
||||
ret = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* write it to the imap server */
|
||||
|
||||
if (server.tunnel)
|
||||
return append_msgs_to_imap(&server, &all_msgs, total);
|
||||
|
||||
ret = append_msgs_to_imap(&server, &all_msgs, total);
|
||||
#ifdef USE_CURL_FOR_IMAP_SEND
|
||||
if (use_curl)
|
||||
return curl_append_msgs_to_imap(&server, &all_msgs, total);
|
||||
else if (use_curl)
|
||||
ret = curl_append_msgs_to_imap(&server, &all_msgs, total);
|
||||
#endif
|
||||
else
|
||||
ret = append_msgs_to_imap(&server, &all_msgs, total);
|
||||
|
||||
return append_msgs_to_imap(&server, &all_msgs, total);
|
||||
out:
|
||||
free(server.tunnel);
|
||||
free(server.host);
|
||||
free(server.folder);
|
||||
free(server.user);
|
||||
free(server.pass);
|
||||
free(server.auth_method);
|
||||
return ret;
|
||||
}
|
||||
|
22
line-log.c
22
line-log.c
@ -899,14 +899,12 @@ static void print_line(const char *prefix, char first,
|
||||
|
||||
static char *output_prefix(struct diff_options *opt)
|
||||
{
|
||||
char *prefix = "";
|
||||
|
||||
if (opt->output_prefix) {
|
||||
struct strbuf *sb = opt->output_prefix(opt, opt->output_prefix_data);
|
||||
prefix = sb->buf;
|
||||
return sb->buf;
|
||||
} else {
|
||||
return xstrdup("");
|
||||
}
|
||||
|
||||
return prefix;
|
||||
}
|
||||
|
||||
static void dump_diff_hacky_one(struct rev_info *rev, struct line_log_data *range)
|
||||
@ -927,7 +925,7 @@ static void dump_diff_hacky_one(struct rev_info *rev, struct line_log_data *rang
|
||||
const char *c_context = diff_get_color(opt->use_color, DIFF_CONTEXT);
|
||||
|
||||
if (!pair || !diff)
|
||||
return;
|
||||
goto out;
|
||||
|
||||
if (pair->one->oid_valid)
|
||||
fill_line_ends(rev->diffopt.repo, pair->one, &p_lines, &p_ends);
|
||||
@ -1002,8 +1000,10 @@ static void dump_diff_hacky_one(struct rev_info *rev, struct line_log_data *rang
|
||||
c_context, c_reset, opt->file);
|
||||
}
|
||||
|
||||
out:
|
||||
free(p_ends);
|
||||
free(t_ends);
|
||||
free(prefix);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1012,7 +1012,11 @@ static void dump_diff_hacky_one(struct rev_info *rev, struct line_log_data *rang
|
||||
*/
|
||||
static void dump_diff_hacky(struct rev_info *rev, struct line_log_data *range)
|
||||
{
|
||||
fprintf(rev->diffopt.file, "%s\n", output_prefix(&rev->diffopt));
|
||||
char *prefix = output_prefix(&rev->diffopt);
|
||||
|
||||
fprintf(rev->diffopt.file, "%s\n", prefix);
|
||||
free(prefix);
|
||||
|
||||
while (range) {
|
||||
dump_diff_hacky_one(rev, range);
|
||||
range = range->next;
|
||||
@ -1032,6 +1036,7 @@ static int process_diff_filepair(struct rev_info *rev,
|
||||
struct range_set tmp;
|
||||
struct diff_ranges diff;
|
||||
mmfile_t file_parent, file_target;
|
||||
char *parent_data_to_free = NULL;
|
||||
|
||||
assert(pair->two->path);
|
||||
while (rg) {
|
||||
@ -1056,7 +1061,7 @@ static int process_diff_filepair(struct rev_info *rev,
|
||||
file_parent.ptr = pair->one->data;
|
||||
file_parent.size = pair->one->size;
|
||||
} else {
|
||||
file_parent.ptr = "";
|
||||
file_parent.ptr = parent_data_to_free = xstrdup("");
|
||||
file_parent.size = 0;
|
||||
}
|
||||
|
||||
@ -1075,6 +1080,7 @@ static int process_diff_filepair(struct rev_info *rev,
|
||||
|
||||
diff_ranges_release(&diff);
|
||||
|
||||
free(parent_data_to_free);
|
||||
return ((*diff_out)->parent.nr > 0);
|
||||
}
|
||||
|
||||
|
@ -216,7 +216,7 @@ int read_mailmap(struct string_list *map)
|
||||
map->cmp = namemap_cmp;
|
||||
|
||||
if (!git_mailmap_blob && is_bare_repository())
|
||||
git_mailmap_blob = "HEAD:.mailmap";
|
||||
git_mailmap_blob = xstrdup("HEAD:.mailmap");
|
||||
|
||||
if (!startup_info->have_repository || !is_bare_repository())
|
||||
err |= read_mailmap_file(map, ".mailmap",
|
||||
|
11
merge-ll.c
11
merge-ll.c
@ -27,7 +27,7 @@ typedef enum ll_merge_result (*ll_merge_fn)(const struct ll_merge_driver *,
|
||||
|
||||
struct ll_merge_driver {
|
||||
const char *name;
|
||||
char *description;
|
||||
const char *description;
|
||||
ll_merge_fn fn;
|
||||
char *recursive;
|
||||
struct ll_merge_driver *next;
|
||||
@ -304,8 +304,13 @@ static int read_merge_config(const char *var, const char *value,
|
||||
ll_user_merge_tail = &(fn->next);
|
||||
}
|
||||
|
||||
if (!strcmp("name", key))
|
||||
return git_config_string(&fn->description, var, value);
|
||||
if (!strcmp("name", key)) {
|
||||
/*
|
||||
* The description is leaking, but that's okay as we want to
|
||||
* keep around the merge drivers anyway.
|
||||
*/
|
||||
return git_config_string((char **) &fn->description, var, value);
|
||||
}
|
||||
|
||||
if (!strcmp("driver", key)) {
|
||||
if (!value)
|
||||
|
@ -277,7 +277,7 @@ int hash_algo_by_length(int len)
|
||||
static struct cached_object {
|
||||
struct object_id oid;
|
||||
enum object_type type;
|
||||
void *buf;
|
||||
const void *buf;
|
||||
unsigned long size;
|
||||
} *cached_objects;
|
||||
static int cached_object_nr, cached_object_alloc;
|
||||
@ -1778,6 +1778,7 @@ int pretend_object_file(void *buf, unsigned long len, enum object_type type,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct cached_object *co;
|
||||
char *co_buf;
|
||||
|
||||
hash_object_file(the_hash_algo, buf, len, type, oid);
|
||||
if (repo_has_object_file_with_flags(the_repository, oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
|
||||
@ -1787,8 +1788,9 @@ int pretend_object_file(void *buf, unsigned long len, enum object_type type,
|
||||
co = &cached_objects[cached_object_nr++];
|
||||
co->size = len;
|
||||
co->type = type;
|
||||
co->buf = xmalloc(len);
|
||||
memcpy(co->buf, buf, len);
|
||||
co_buf = xmalloc(len);
|
||||
memcpy(co_buf, buf, len);
|
||||
co->buf = co_buf;
|
||||
oidcpy(&co->oid, oid);
|
||||
return 0;
|
||||
}
|
||||
@ -2482,12 +2484,13 @@ static int hash_format_check_report(struct fsck_options *opts UNUSED,
|
||||
}
|
||||
|
||||
static int index_mem(struct index_state *istate,
|
||||
struct object_id *oid, void *buf, size_t size,
|
||||
struct object_id *oid,
|
||||
const void *buf, size_t size,
|
||||
enum object_type type,
|
||||
const char *path, unsigned flags)
|
||||
{
|
||||
struct strbuf nbuf = STRBUF_INIT;
|
||||
int ret = 0;
|
||||
int re_allocated = 0;
|
||||
int write_object = flags & HASH_WRITE_OBJECT;
|
||||
|
||||
if (!type)
|
||||
@ -2497,11 +2500,10 @@ static int index_mem(struct index_state *istate,
|
||||
* Convert blobs to git internal format
|
||||
*/
|
||||
if ((type == OBJ_BLOB) && path) {
|
||||
struct strbuf nbuf = STRBUF_INIT;
|
||||
if (convert_to_git(istate, path, buf, size, &nbuf,
|
||||
get_conv_flags(flags))) {
|
||||
buf = strbuf_detach(&nbuf, &size);
|
||||
re_allocated = 1;
|
||||
buf = nbuf.buf;
|
||||
size = nbuf.len;
|
||||
}
|
||||
}
|
||||
if (flags & HASH_FORMAT_CHECK) {
|
||||
@ -2518,8 +2520,8 @@ static int index_mem(struct index_state *istate,
|
||||
ret = write_object_file(buf, size, type, oid);
|
||||
else
|
||||
hash_object_file(the_hash_algo, buf, size, type, oid);
|
||||
if (re_allocated)
|
||||
free(buf);
|
||||
|
||||
strbuf_release(&nbuf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -355,7 +355,7 @@ struct option {
|
||||
.type = OPTION_ALIAS, \
|
||||
.short_name = (s), \
|
||||
.long_name = (l), \
|
||||
.value = (source_long_name), \
|
||||
.value = (char *)(source_long_name), \
|
||||
}
|
||||
|
||||
#define OPT_SUBCOMMAND_F(l, v, fn, f) { \
|
||||
|
6
pretty.c
6
pretty.c
@ -1325,7 +1325,7 @@ int format_set_trailers_options(struct process_trailer_options *opts,
|
||||
static size_t parse_describe_args(const char *start, struct strvec *args)
|
||||
{
|
||||
struct {
|
||||
char *name;
|
||||
const char *name;
|
||||
enum {
|
||||
DESCRIBE_ARG_BOOL,
|
||||
DESCRIBE_ARG_INTEGER,
|
||||
@ -1584,8 +1584,8 @@ static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
|
||||
case 'D':
|
||||
{
|
||||
const struct decoration_options opts = {
|
||||
.prefix = "",
|
||||
.suffix = ""
|
||||
.prefix = (char *) "",
|
||||
.suffix = (char *) "",
|
||||
};
|
||||
|
||||
format_decorations(sb, commit, c->auto_color, &opts);
|
||||
|
2
refs.c
2
refs.c
@ -159,7 +159,7 @@ void update_ref_namespace(enum ref_namespace namespace, char *ref)
|
||||
{
|
||||
struct ref_namespace_info *info = &ref_namespace[namespace];
|
||||
if (info->ref_updated)
|
||||
free(info->ref);
|
||||
free((char *)info->ref);
|
||||
info->ref = ref;
|
||||
info->ref_updated = 1;
|
||||
}
|
||||
|
2
refs.h
2
refs.h
@ -985,7 +985,7 @@ struct ref_store *get_worktree_ref_store(const struct worktree *wt);
|
||||
*/
|
||||
|
||||
struct ref_namespace_info {
|
||||
char *ref;
|
||||
const char *ref;
|
||||
enum decoration_type decoration;
|
||||
|
||||
/*
|
||||
|
@ -1450,10 +1450,10 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
* old reference.
|
||||
*/
|
||||
refs[0] = old_ref;
|
||||
refs[0].refname = (char *)arg->newname;
|
||||
refs[0].refname = xstrdup(arg->newname);
|
||||
refs[0].update_index = creation_ts;
|
||||
if (arg->delete_old) {
|
||||
refs[1].refname = (char *)arg->oldname;
|
||||
refs[1].refname = xstrdup(arg->oldname);
|
||||
refs[1].value_type = REFTABLE_REF_DELETION;
|
||||
refs[1].update_index = deletion_ts;
|
||||
}
|
||||
@ -1476,7 +1476,7 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
ALLOC_GROW(logs, logs_nr + 1, logs_alloc);
|
||||
memset(&logs[logs_nr], 0, sizeof(logs[logs_nr]));
|
||||
fill_reftable_log_record(&logs[logs_nr], &committer_ident);
|
||||
logs[logs_nr].refname = (char *)arg->newname;
|
||||
logs[logs_nr].refname = xstrdup(arg->newname);
|
||||
logs[logs_nr].update_index = deletion_ts;
|
||||
logs[logs_nr].value.update.message =
|
||||
xstrndup(arg->logmsg, arg->refs->write_options.block_size / 2);
|
||||
@ -1497,7 +1497,13 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
if (append_head_reflog) {
|
||||
ALLOC_GROW(logs, logs_nr + 1, logs_alloc);
|
||||
logs[logs_nr] = logs[logs_nr - 1];
|
||||
logs[logs_nr].refname = "HEAD";
|
||||
logs[logs_nr].refname = xstrdup("HEAD");
|
||||
logs[logs_nr].value.update.name =
|
||||
xstrdup(logs[logs_nr].value.update.name);
|
||||
logs[logs_nr].value.update.email =
|
||||
xstrdup(logs[logs_nr].value.update.email);
|
||||
logs[logs_nr].value.update.message =
|
||||
xstrdup(logs[logs_nr].value.update.message);
|
||||
logs_nr++;
|
||||
}
|
||||
}
|
||||
@ -1508,7 +1514,7 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
ALLOC_GROW(logs, logs_nr + 1, logs_alloc);
|
||||
memset(&logs[logs_nr], 0, sizeof(logs[logs_nr]));
|
||||
fill_reftable_log_record(&logs[logs_nr], &committer_ident);
|
||||
logs[logs_nr].refname = (char *)arg->newname;
|
||||
logs[logs_nr].refname = xstrdup(arg->newname);
|
||||
logs[logs_nr].update_index = creation_ts;
|
||||
logs[logs_nr].value.update.message =
|
||||
xstrndup(arg->logmsg, arg->refs->write_options.block_size / 2);
|
||||
@ -1541,7 +1547,7 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
*/
|
||||
ALLOC_GROW(logs, logs_nr + 1, logs_alloc);
|
||||
logs[logs_nr] = old_log;
|
||||
logs[logs_nr].refname = (char *)arg->newname;
|
||||
logs[logs_nr].refname = xstrdup(arg->newname);
|
||||
logs_nr++;
|
||||
|
||||
/*
|
||||
@ -1550,7 +1556,7 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
|
||||
if (arg->delete_old) {
|
||||
ALLOC_GROW(logs, logs_nr + 1, logs_alloc);
|
||||
memset(&logs[logs_nr], 0, sizeof(logs[logs_nr]));
|
||||
logs[logs_nr].refname = (char *)arg->oldname;
|
||||
logs[logs_nr].refname = xstrdup(arg->oldname);
|
||||
logs[logs_nr].value_type = REFTABLE_LOG_DELETION;
|
||||
logs[logs_nr].update_index = old_log.update_index;
|
||||
logs_nr++;
|
||||
@ -1573,13 +1579,11 @@ done:
|
||||
reftable_iterator_destroy(&it);
|
||||
string_list_clear(&skip, 0);
|
||||
strbuf_release(&errbuf);
|
||||
for (i = 0; i < logs_nr; i++) {
|
||||
if (!strcmp(logs[i].refname, "HEAD"))
|
||||
continue;
|
||||
logs[i].refname = NULL;
|
||||
for (i = 0; i < logs_nr; i++)
|
||||
reftable_log_record_release(&logs[i]);
|
||||
}
|
||||
free(logs);
|
||||
for (i = 0; i < ARRAY_SIZE(refs); i++)
|
||||
reftable_ref_record_release(&refs[i]);
|
||||
reftable_ref_record_release(&old_ref);
|
||||
reftable_log_record_release(&old_log);
|
||||
return ret;
|
||||
|
13
refspec.c
13
refspec.c
@ -7,19 +7,6 @@
|
||||
#include "refspec.h"
|
||||
#include "strbuf.h"
|
||||
|
||||
static struct refspec_item s_tag_refspec = {
|
||||
.force = 0,
|
||||
.pattern = 1,
|
||||
.matching = 0,
|
||||
.exact_sha1 = 0,
|
||||
.negative = 0,
|
||||
.src = "refs/tags/*",
|
||||
.dst = "refs/tags/*",
|
||||
};
|
||||
|
||||
/* See TAG_REFSPEC for the string version */
|
||||
const struct refspec_item *tag_refspec = &s_tag_refspec;
|
||||
|
||||
/*
|
||||
* Parses the provided refspec 'refspec' and populates the refspec_item 'item'.
|
||||
* Returns 1 if successful and 0 if the refspec is invalid.
|
||||
|
@ -2,7 +2,6 @@
|
||||
#define REFSPEC_H
|
||||
|
||||
#define TAG_REFSPEC "refs/tags/*:refs/tags/*"
|
||||
extern const struct refspec_item *tag_refspec;
|
||||
|
||||
/**
|
||||
* A struct refspec_item holds the parsed interpretation of a refspec. If it
|
||||
|
@ -67,9 +67,9 @@ void free_names(char **a)
|
||||
reftable_free(a);
|
||||
}
|
||||
|
||||
size_t names_length(char **names)
|
||||
size_t names_length(const char **names)
|
||||
{
|
||||
char **p = names;
|
||||
const char **p = names;
|
||||
while (*p)
|
||||
p++;
|
||||
return p - names;
|
||||
@ -102,15 +102,12 @@ void parse_names(char *buf, int size, char ***namesp)
|
||||
*namesp = names;
|
||||
}
|
||||
|
||||
int names_equal(char **a, char **b)
|
||||
int names_equal(const char **a, const char **b)
|
||||
{
|
||||
int i = 0;
|
||||
for (; a[i] && b[i]; i++) {
|
||||
if (strcmp(a[i], b[i])) {
|
||||
size_t i = 0;
|
||||
for (; a[i] && b[i]; i++)
|
||||
if (strcmp(a[i], b[i]))
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return a[i] == b[i];
|
||||
}
|
||||
|
||||
|
@ -42,10 +42,10 @@ void free_names(char **a);
|
||||
void parse_names(char *buf, int size, char ***namesp);
|
||||
|
||||
/* compares two NULL-terminated arrays of strings. */
|
||||
int names_equal(char **a, char **b);
|
||||
int names_equal(const char **a, const char **b);
|
||||
|
||||
/* returns the array size of a NULL-terminated array of strings. */
|
||||
size_t names_length(char **names);
|
||||
size_t names_length(const char **names);
|
||||
|
||||
/* Allocation routines; they invoke the functions set through
|
||||
* reftable_set_alloc() */
|
||||
|
@ -42,7 +42,7 @@ static void test_block_read_write(void)
|
||||
block_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,
|
||||
header_off, hash_size(GIT_SHA1_FORMAT_ID));
|
||||
|
||||
rec.u.ref.refname = "";
|
||||
rec.u.ref.refname = (char *) "";
|
||||
rec.u.ref.value_type = REFTABLE_REF_DELETION;
|
||||
n = block_writer_add(&bw, &rec);
|
||||
EXPECT(n == REFTABLE_API_ERROR);
|
||||
|
@ -125,13 +125,13 @@ static void readers_destroy(struct reftable_reader **readers, size_t n)
|
||||
static void test_merged_between(void)
|
||||
{
|
||||
struct reftable_ref_record r1[] = { {
|
||||
.refname = "b",
|
||||
.refname = (char *) "b",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 1, 2, 3, 0 },
|
||||
} };
|
||||
struct reftable_ref_record r2[] = { {
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 2,
|
||||
.value_type = REFTABLE_REF_DELETION,
|
||||
} };
|
||||
@ -169,38 +169,38 @@ static void test_merged(void)
|
||||
{
|
||||
struct reftable_ref_record r1[] = {
|
||||
{
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 1 },
|
||||
},
|
||||
{
|
||||
.refname = "b",
|
||||
.refname = (char *) "b",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 1 },
|
||||
},
|
||||
{
|
||||
.refname = "c",
|
||||
.refname = (char *) "c",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 1 },
|
||||
}
|
||||
};
|
||||
struct reftable_ref_record r2[] = { {
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 2,
|
||||
.value_type = REFTABLE_REF_DELETION,
|
||||
} };
|
||||
struct reftable_ref_record r3[] = {
|
||||
{
|
||||
.refname = "c",
|
||||
.refname = (char *) "c",
|
||||
.update_index = 3,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 2 },
|
||||
},
|
||||
{
|
||||
.refname = "d",
|
||||
.refname = (char *) "d",
|
||||
.update_index = 3,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = { 1 },
|
||||
@ -296,46 +296,46 @@ static void test_merged_logs(void)
|
||||
{
|
||||
struct reftable_log_record r1[] = {
|
||||
{
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 2,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value.update = {
|
||||
.old_hash = { 2 },
|
||||
/* deletion */
|
||||
.name = "jane doe",
|
||||
.email = "jane@invalid",
|
||||
.message = "message2",
|
||||
.name = (char *) "jane doe",
|
||||
.email = (char *) "jane@invalid",
|
||||
.message = (char *) "message2",
|
||||
}
|
||||
},
|
||||
{
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value.update = {
|
||||
.old_hash = { 1 },
|
||||
.new_hash = { 2 },
|
||||
.name = "jane doe",
|
||||
.email = "jane@invalid",
|
||||
.message = "message1",
|
||||
.name = (char *) "jane doe",
|
||||
.email = (char *) "jane@invalid",
|
||||
.message = (char *) "message1",
|
||||
}
|
||||
},
|
||||
};
|
||||
struct reftable_log_record r2[] = {
|
||||
{
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 3,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value.update = {
|
||||
.new_hash = { 3 },
|
||||
.name = "jane doe",
|
||||
.email = "jane@invalid",
|
||||
.message = "message3",
|
||||
.name = (char *) "jane doe",
|
||||
.email = (char *) "jane@invalid",
|
||||
.message = (char *) "message3",
|
||||
}
|
||||
},
|
||||
};
|
||||
struct reftable_log_record r3[] = {
|
||||
{
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 2,
|
||||
.value_type = REFTABLE_LOG_DELETION,
|
||||
},
|
||||
@ -413,7 +413,7 @@ static void test_default_write_opts(void)
|
||||
reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
|
||||
|
||||
struct reftable_ref_record rec = {
|
||||
.refname = "master",
|
||||
.refname = (char *) "master",
|
||||
.update_index = 1,
|
||||
};
|
||||
int err;
|
||||
|
@ -86,7 +86,7 @@ static void write_table(char ***names, struct strbuf *buf, int N,
|
||||
log.update_index = update_index;
|
||||
log.value_type = REFTABLE_LOG_UPDATE;
|
||||
set_test_hash(log.value.update.new_hash, i);
|
||||
log.value.update.message = "message";
|
||||
log.value.update.message = (char *) "message";
|
||||
|
||||
n = reftable_writer_add_log(w, &log);
|
||||
EXPECT(n == 0);
|
||||
@ -118,15 +118,15 @@ static void test_log_buffer_size(void)
|
||||
int err;
|
||||
int i;
|
||||
struct reftable_log_record
|
||||
log = { .refname = "refs/heads/master",
|
||||
log = { .refname = (char *) "refs/heads/master",
|
||||
.update_index = 0xa,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value = { .update = {
|
||||
.name = "Han-Wen Nienhuys",
|
||||
.email = "hanwen@google.com",
|
||||
.name = (char *) "Han-Wen Nienhuys",
|
||||
.email = (char *) "hanwen@google.com",
|
||||
.tz_offset = 100,
|
||||
.time = 0x5e430672,
|
||||
.message = "commit: 9\n",
|
||||
.message = (char *) "commit: 9\n",
|
||||
} } };
|
||||
struct reftable_writer *w =
|
||||
reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
|
||||
@ -156,15 +156,15 @@ static void test_log_overflow(void)
|
||||
};
|
||||
int err;
|
||||
struct reftable_log_record log = {
|
||||
.refname = "refs/heads/master",
|
||||
.refname = (char *) "refs/heads/master",
|
||||
.update_index = 0xa,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value = {
|
||||
.update = {
|
||||
.old_hash = { 1 },
|
||||
.new_hash = { 2 },
|
||||
.name = "Han-Wen Nienhuys",
|
||||
.email = "hanwen@google.com",
|
||||
.name = (char *) "Han-Wen Nienhuys",
|
||||
.email = (char *) "hanwen@google.com",
|
||||
.tz_offset = 100,
|
||||
.time = 0x5e430672,
|
||||
.message = msg,
|
||||
@ -297,14 +297,14 @@ static void test_log_zlib_corruption(void)
|
||||
char message[100] = { 0 };
|
||||
int err, i, n;
|
||||
struct reftable_log_record log = {
|
||||
.refname = "refname",
|
||||
.refname = (char *) "refname",
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value = {
|
||||
.update = {
|
||||
.new_hash = { 1 },
|
||||
.old_hash = { 2 },
|
||||
.name = "My Name",
|
||||
.email = "myname@invalid",
|
||||
.name = (char *) "My Name",
|
||||
.email = (char *) "myname@invalid",
|
||||
.message = message,
|
||||
},
|
||||
},
|
||||
@ -739,7 +739,7 @@ static void test_write_empty_key(void)
|
||||
struct reftable_writer *w =
|
||||
reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
|
||||
struct reftable_ref_record ref = {
|
||||
.refname = "",
|
||||
.refname = (char *) "",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_DELETION,
|
||||
};
|
||||
@ -763,18 +763,18 @@ static void test_write_key_order(void)
|
||||
reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
|
||||
struct reftable_ref_record refs[2] = {
|
||||
{
|
||||
.refname = "b",
|
||||
.refname = (char *) "b",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value = {
|
||||
.symref = "target",
|
||||
.symref = (char *) "target",
|
||||
},
|
||||
}, {
|
||||
.refname = "a",
|
||||
.refname = (char *) "a",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value = {
|
||||
.symref = "target",
|
||||
.symref = (char *) "target",
|
||||
},
|
||||
}
|
||||
};
|
||||
|
@ -116,7 +116,7 @@ static int decode_string(struct strbuf *dest, struct string_view in)
|
||||
return start_len - in.len;
|
||||
}
|
||||
|
||||
static int encode_string(char *str, struct string_view s)
|
||||
static int encode_string(const char *str, struct string_view s)
|
||||
{
|
||||
struct string_view start = s;
|
||||
int l = strlen(str);
|
||||
@ -969,9 +969,9 @@ done:
|
||||
return REFTABLE_FORMAT_ERROR;
|
||||
}
|
||||
|
||||
static int null_streq(char *a, char *b)
|
||||
static int null_streq(const char *a, const char *b)
|
||||
{
|
||||
char *empty = "";
|
||||
const char *empty = "";
|
||||
if (!a)
|
||||
a = empty;
|
||||
|
||||
|
@ -221,7 +221,8 @@ static struct reftable_reader **stack_copy_readers(struct reftable_stack *st,
|
||||
return cur;
|
||||
}
|
||||
|
||||
static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
|
||||
static int reftable_stack_reload_once(struct reftable_stack *st,
|
||||
const char **names,
|
||||
int reuse_open)
|
||||
{
|
||||
size_t cur_len = !st->merged ? 0 : st->merged->stack_len;
|
||||
@ -239,7 +240,7 @@ static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
|
||||
|
||||
while (*names) {
|
||||
struct reftable_reader *rd = NULL;
|
||||
char *name = *names++;
|
||||
const char *name = *names++;
|
||||
|
||||
/* this is linear; we assume compaction keeps the number of
|
||||
tables under control so this is not quadratic. */
|
||||
@ -369,7 +370,7 @@ static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = reftable_stack_reload_once(st, names, reuse_open);
|
||||
err = reftable_stack_reload_once(st, (const char **) names, reuse_open);
|
||||
if (!err)
|
||||
break;
|
||||
if (err != REFTABLE_NOT_EXIST_ERROR)
|
||||
@ -383,7 +384,8 @@ static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
|
||||
err = read_lines(st->list_file, &names_after);
|
||||
if (err < 0)
|
||||
goto out;
|
||||
if (names_equal(names_after, names)) {
|
||||
if (names_equal((const char **) names_after,
|
||||
(const char **) names)) {
|
||||
err = REFTABLE_NOT_EXIST_ERROR;
|
||||
goto out;
|
||||
}
|
||||
|
@ -83,7 +83,7 @@ static void test_read_file(void)
|
||||
char out[1024] = "line1\n\nline2\nline3";
|
||||
int n, err;
|
||||
char **names = NULL;
|
||||
char *want[] = { "line1", "line2", "line3" };
|
||||
const char *want[] = { "line1", "line2", "line3" };
|
||||
int i = 0;
|
||||
|
||||
EXPECT(fd > 0);
|
||||
@ -133,10 +133,10 @@ static void test_reftable_stack_add_one(void)
|
||||
struct reftable_stack *st = NULL;
|
||||
int err;
|
||||
struct reftable_ref_record ref = {
|
||||
.refname = "HEAD",
|
||||
.refname = (char *) "HEAD",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
struct reftable_ref_record dest = { NULL };
|
||||
struct stat stat_result = { 0 };
|
||||
@ -193,16 +193,16 @@ static void test_reftable_stack_uptodate(void)
|
||||
|
||||
int err;
|
||||
struct reftable_ref_record ref1 = {
|
||||
.refname = "HEAD",
|
||||
.refname = (char *) "HEAD",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
struct reftable_ref_record ref2 = {
|
||||
.refname = "branch2",
|
||||
.refname = (char *) "branch2",
|
||||
.update_index = 2,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
|
||||
|
||||
@ -240,10 +240,10 @@ static void test_reftable_stack_transaction_api(void)
|
||||
struct reftable_addition *add = NULL;
|
||||
|
||||
struct reftable_ref_record ref = {
|
||||
.refname = "HEAD",
|
||||
.refname = (char *) "HEAD",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
struct reftable_ref_record dest = { NULL };
|
||||
|
||||
@ -288,7 +288,7 @@ static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
|
||||
struct reftable_ref_record ref = {
|
||||
.update_index = reftable_stack_next_update_index(st),
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
char name[100];
|
||||
|
||||
@ -331,7 +331,7 @@ static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
|
||||
static void test_reftable_stack_auto_compaction_fails_gracefully(void)
|
||||
{
|
||||
struct reftable_ref_record ref = {
|
||||
.refname = "refs/heads/master",
|
||||
.refname = (char *) "refs/heads/master",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_VAL1,
|
||||
.value.val1 = {0x01},
|
||||
@ -383,16 +383,16 @@ static void test_reftable_stack_update_index_check(void)
|
||||
struct reftable_stack *st = NULL;
|
||||
int err;
|
||||
struct reftable_ref_record ref1 = {
|
||||
.refname = "name1",
|
||||
.refname = (char *) "name1",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
struct reftable_ref_record ref2 = {
|
||||
.refname = "name2",
|
||||
.refname = (char *) "name2",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
|
||||
err = reftable_new_stack(&st, dir, &opts);
|
||||
@ -534,7 +534,7 @@ static void test_reftable_stack_log_normalize(void)
|
||||
struct reftable_stack *st = NULL;
|
||||
char *dir = get_tmp_dir(__LINE__);
|
||||
struct reftable_log_record input = {
|
||||
.refname = "branch",
|
||||
.refname = (char *) "branch",
|
||||
.update_index = 1,
|
||||
.value_type = REFTABLE_LOG_UPDATE,
|
||||
.value = {
|
||||
@ -555,11 +555,11 @@ static void test_reftable_stack_log_normalize(void)
|
||||
err = reftable_new_stack(&st, dir, &opts);
|
||||
EXPECT_ERR(err);
|
||||
|
||||
input.value.update.message = "one\ntwo";
|
||||
input.value.update.message = (char *) "one\ntwo";
|
||||
err = reftable_stack_add(st, &write_test_log, &arg);
|
||||
EXPECT(err == REFTABLE_API_ERROR);
|
||||
|
||||
input.value.update.message = "one";
|
||||
input.value.update.message = (char *) "one";
|
||||
err = reftable_stack_add(st, &write_test_log, &arg);
|
||||
EXPECT_ERR(err);
|
||||
|
||||
@ -567,7 +567,7 @@ static void test_reftable_stack_log_normalize(void)
|
||||
EXPECT_ERR(err);
|
||||
EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
|
||||
|
||||
input.value.update.message = "two\n";
|
||||
input.value.update.message = (char *) "two\n";
|
||||
arg.update_index = 2;
|
||||
err = reftable_stack_add(st, &write_test_log, &arg);
|
||||
EXPECT_ERR(err);
|
||||
@ -667,9 +667,9 @@ static void test_reftable_stack_hash_id(void)
|
||||
int err;
|
||||
|
||||
struct reftable_ref_record ref = {
|
||||
.refname = "master",
|
||||
.refname = (char *) "master",
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "target",
|
||||
.value.symref = (char *) "target",
|
||||
.update_index = 1,
|
||||
};
|
||||
struct reftable_write_options opts32 = { .hash_id = GIT_SHA256_FORMAT_ID };
|
||||
@ -844,7 +844,7 @@ static void test_reftable_stack_auto_compaction(void)
|
||||
.refname = name,
|
||||
.update_index = reftable_stack_next_update_index(st),
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
snprintf(name, sizeof(name), "branch%04d", i);
|
||||
|
||||
@ -878,7 +878,7 @@ static void test_reftable_stack_add_performs_auto_compaction(void)
|
||||
struct reftable_ref_record ref = {
|
||||
.update_index = reftable_stack_next_update_index(st),
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
|
||||
/*
|
||||
@ -928,7 +928,7 @@ static void test_reftable_stack_compaction_concurrent(void)
|
||||
.refname = name,
|
||||
.update_index = reftable_stack_next_update_index(st1),
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
snprintf(name, sizeof(name), "branch%04d", i);
|
||||
|
||||
@ -977,7 +977,7 @@ static void test_reftable_stack_compaction_concurrent_clean(void)
|
||||
.refname = name,
|
||||
.update_index = reftable_stack_next_update_index(st1),
|
||||
.value_type = REFTABLE_REF_SYMREF,
|
||||
.value.symref = "master",
|
||||
.value.symref = (char *) "master",
|
||||
};
|
||||
snprintf(name, sizeof(name), "branch%04d", i);
|
||||
|
||||
|
@ -58,9 +58,9 @@ struct options {
|
||||
static struct options options;
|
||||
static struct string_list cas_options = STRING_LIST_INIT_DUP;
|
||||
|
||||
static int set_option(const char *name, const char *value)
|
||||
static int set_option(const char *name, size_t namelen, const char *value)
|
||||
{
|
||||
if (!strcmp(name, "verbosity")) {
|
||||
if (!strncmp(name, "verbosity", namelen)) {
|
||||
char *end;
|
||||
int v = strtol(value, &end, 10);
|
||||
if (value == end || *end)
|
||||
@ -68,7 +68,7 @@ static int set_option(const char *name, const char *value)
|
||||
options.verbosity = v;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "progress")) {
|
||||
else if (!strncmp(name, "progress", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.progress = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -77,7 +77,7 @@ static int set_option(const char *name, const char *value)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "depth")) {
|
||||
else if (!strncmp(name, "depth", namelen)) {
|
||||
char *end;
|
||||
unsigned long v = strtoul(value, &end, 10);
|
||||
if (value == end || *end)
|
||||
@ -85,15 +85,15 @@ static int set_option(const char *name, const char *value)
|
||||
options.depth = v;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "deepen-since")) {
|
||||
else if (!strncmp(name, "deepen-since", namelen)) {
|
||||
options.deepen_since = xstrdup(value);
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "deepen-not")) {
|
||||
else if (!strncmp(name, "deepen-not", namelen)) {
|
||||
string_list_append(&options.deepen_not, value);
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "deepen-relative")) {
|
||||
else if (!strncmp(name, "deepen-relative", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.deepen_relative = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -102,7 +102,7 @@ static int set_option(const char *name, const char *value)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "followtags")) {
|
||||
else if (!strncmp(name, "followtags", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.followtags = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -111,7 +111,7 @@ static int set_option(const char *name, const char *value)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "dry-run")) {
|
||||
else if (!strncmp(name, "dry-run", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.dry_run = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -120,7 +120,7 @@ static int set_option(const char *name, const char *value)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "check-connectivity")) {
|
||||
else if (!strncmp(name, "check-connectivity", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.check_self_contained_and_connected = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -129,7 +129,7 @@ static int set_option(const char *name, const char *value)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp(name, "cas")) {
|
||||
else if (!strncmp(name, "cas", namelen)) {
|
||||
struct strbuf val = STRBUF_INIT;
|
||||
strbuf_addstr(&val, "--force-with-lease=");
|
||||
if (*value != '"')
|
||||
@ -139,7 +139,7 @@ static int set_option(const char *name, const char *value)
|
||||
string_list_append(&cas_options, val.buf);
|
||||
strbuf_release(&val);
|
||||
return 0;
|
||||
} else if (!strcmp(name, TRANS_OPT_FORCE_IF_INCLUDES)) {
|
||||
} else if (!strncmp(name, TRANS_OPT_FORCE_IF_INCLUDES, namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.force_if_includes = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -147,7 +147,7 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "cloning")) {
|
||||
} else if (!strncmp(name, "cloning", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.cloning = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -155,7 +155,7 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "update-shallow")) {
|
||||
} else if (!strncmp(name, "update-shallow", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.update_shallow = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -163,7 +163,7 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "pushcert")) {
|
||||
} else if (!strncmp(name, "pushcert", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.push_cert = SEND_PACK_PUSH_CERT_ALWAYS;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -173,7 +173,7 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "atomic")) {
|
||||
} else if (!strncmp(name, "atomic", namelen)) {
|
||||
if (!strcmp(value, "true"))
|
||||
options.atomic = 1;
|
||||
else if (!strcmp(value, "false"))
|
||||
@ -181,7 +181,7 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "push-option")) {
|
||||
} else if (!strncmp(name, "push-option", namelen)) {
|
||||
if (*value != '"')
|
||||
string_list_append(&options.push_options, value);
|
||||
else {
|
||||
@ -192,7 +192,7 @@ static int set_option(const char *name, const char *value)
|
||||
strbuf_detach(&unquoted, NULL));
|
||||
}
|
||||
return 0;
|
||||
} else if (!strcmp(name, "family")) {
|
||||
} else if (!strncmp(name, "family", namelen)) {
|
||||
if (!strcmp(value, "ipv4"))
|
||||
git_curl_ipresolve = CURL_IPRESOLVE_V4;
|
||||
else if (!strcmp(value, "ipv6"))
|
||||
@ -202,16 +202,16 @@ static int set_option(const char *name, const char *value)
|
||||
else
|
||||
return -1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "from-promisor")) {
|
||||
} else if (!strncmp(name, "from-promisor", namelen)) {
|
||||
options.from_promisor = 1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "refetch")) {
|
||||
} else if (!strncmp(name, "refetch", namelen)) {
|
||||
options.refetch = 1;
|
||||
return 0;
|
||||
} else if (!strcmp(name, "filter")) {
|
||||
} else if (!strncmp(name, "filter", namelen)) {
|
||||
options.filter = xstrdup(value);
|
||||
return 0;
|
||||
} else if (!strcmp(name, "object-format")) {
|
||||
} else if (!strncmp(name, "object-format", namelen)) {
|
||||
options.object_format = 1;
|
||||
if (strcmp(value, "true"))
|
||||
die(_("unknown value for object-format: %s"), value);
|
||||
@ -1605,15 +1605,16 @@ int cmd_main(int argc, const char **argv)
|
||||
parse_push(&buf);
|
||||
|
||||
} else if (skip_prefix(buf.buf, "option ", &arg)) {
|
||||
char *value = strchr(arg, ' ');
|
||||
const char *value = strchrnul(arg, ' ');
|
||||
size_t arglen = value - arg;
|
||||
int result;
|
||||
|
||||
if (value)
|
||||
*value++ = '\0';
|
||||
if (*value)
|
||||
value++; /* skip over SP */
|
||||
else
|
||||
value = "true";
|
||||
|
||||
result = set_option(arg, value);
|
||||
result = set_option(arg, arglen, value);
|
||||
if (!result)
|
||||
printf("ok\n");
|
||||
else if (result < 0)
|
||||
|
@ -2650,10 +2650,11 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
|
||||
} else if (!strcmp(arg, "--invert-grep")) {
|
||||
revs->grep_filter.no_body_match = 1;
|
||||
} else if ((argcount = parse_long_opt("encoding", argv, &optarg))) {
|
||||
free(git_log_output_encoding);
|
||||
if (strcmp(optarg, "none"))
|
||||
git_log_output_encoding = xstrdup(optarg);
|
||||
else
|
||||
git_log_output_encoding = "";
|
||||
git_log_output_encoding = xstrdup("");
|
||||
return argcount;
|
||||
} else if (!strcmp(arg, "--reverse")) {
|
||||
revs->reverse ^= 1;
|
||||
|
@ -663,7 +663,7 @@ int start_command(struct child_process *cmd)
|
||||
int need_in, need_out, need_err;
|
||||
int fdin[2], fdout[2], fderr[2];
|
||||
int failed_errno;
|
||||
char *str;
|
||||
const char *str;
|
||||
|
||||
/*
|
||||
* In case of errors we must keep the promise to close FDs
|
||||
|
@ -259,7 +259,7 @@ static int receive_status(struct packet_reader *reader, struct ref *refs)
|
||||
if (p)
|
||||
hint->remote_status = xstrdup(p);
|
||||
else
|
||||
hint->remote_status = "failed";
|
||||
hint->remote_status = xstrdup("failed");
|
||||
} else {
|
||||
hint->status = REF_STATUS_OK;
|
||||
hint->remote_status = xstrdup_or_null(p);
|
||||
|
@ -36,7 +36,8 @@ static int test_entry_cmp(const void *cmp_data,
|
||||
}
|
||||
|
||||
static struct test_entry *alloc_test_entry(unsigned int hash,
|
||||
char *key, char *value)
|
||||
const char *key,
|
||||
const char *value)
|
||||
{
|
||||
size_t klen = strlen(key);
|
||||
size_t vlen = strlen(value);
|
||||
|
@ -174,7 +174,7 @@ static void make_arr4(int pretty)
|
||||
jw_end(&arr4);
|
||||
}
|
||||
|
||||
static char *expect_nest1 =
|
||||
static const char *expect_nest1 =
|
||||
"{\"obj1\":{\"a\":\"abc\",\"b\":42,\"c\":true},\"arr1\":[\"abc\",42,true]}";
|
||||
|
||||
static struct json_writer nest1 = JSON_WRITER_INIT;
|
||||
@ -195,10 +195,10 @@ static void make_nest1(int pretty)
|
||||
jw_release(&arr1);
|
||||
}
|
||||
|
||||
static char *expect_inline1 =
|
||||
static const char *expect_inline1 =
|
||||
"{\"obj1\":{\"a\":\"abc\",\"b\":42,\"c\":true},\"arr1\":[\"abc\",42,true]}";
|
||||
|
||||
static char *pretty_inline1 =
|
||||
static const char *pretty_inline1 =
|
||||
("{\n"
|
||||
" \"obj1\": {\n"
|
||||
" \"a\": \"abc\",\n"
|
||||
@ -236,10 +236,10 @@ static void make_inline1(int pretty)
|
||||
jw_end(&inline1);
|
||||
}
|
||||
|
||||
static char *expect_inline2 =
|
||||
static const char *expect_inline2 =
|
||||
"[[1,2],[3,4],{\"a\":\"abc\"}]";
|
||||
|
||||
static char *pretty_inline2 =
|
||||
static const char *pretty_inline2 =
|
||||
("[\n"
|
||||
" [\n"
|
||||
" 1,\n"
|
||||
|
@ -20,8 +20,8 @@ static struct reg_flag reg_flags[] = {
|
||||
|
||||
static int test_regex_bug(void)
|
||||
{
|
||||
char *pat = "[^={} \t]+";
|
||||
char *str = "={}\nfred";
|
||||
const char *pat = "[^={} \t]+";
|
||||
const char *str = "={}\nfred";
|
||||
regex_t r;
|
||||
regmatch_t m[1];
|
||||
|
||||
|
@ -136,7 +136,7 @@ static void free_delay_entries(void)
|
||||
strmap_clear(&delay, 0);
|
||||
}
|
||||
|
||||
static void add_delay_entry(char *pathname, int count, int requested)
|
||||
static void add_delay_entry(const char *pathname, int count, int requested)
|
||||
{
|
||||
struct delay_entry *entry = xcalloc(1, sizeof(*entry));
|
||||
entry->count = count;
|
||||
@ -189,7 +189,8 @@ static void reply_list_available_blobs_cmd(void)
|
||||
static void command_loop(void)
|
||||
{
|
||||
for (;;) {
|
||||
char *buf, *output;
|
||||
char *buf;
|
||||
const char *output;
|
||||
char *pathname;
|
||||
struct delay_entry *entry;
|
||||
struct strbuf input = STRBUF_INIT;
|
||||
|
@ -5,6 +5,7 @@
|
||||
|
||||
test_description='commit and log output encodings'
|
||||
|
||||
TEST_PASSES_SANITIZE_LEAK=true
|
||||
. ./test-lib.sh
|
||||
|
||||
compare_with () {
|
||||
|
@ -8,6 +8,7 @@ test_description='i18n settings and format-patch | am pipe'
|
||||
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
||||
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
||||
|
||||
TEST_PASSES_SANITIZE_LEAK=true
|
||||
. ./test-lib.sh
|
||||
|
||||
check_encoding () {
|
||||
|
@ -54,15 +54,15 @@ static void test_binsearch(void)
|
||||
|
||||
static void test_names_length(void)
|
||||
{
|
||||
char *a[] = { "a", "b", NULL };
|
||||
const char *a[] = { "a", "b", NULL };
|
||||
check_int(names_length(a), ==, 2);
|
||||
}
|
||||
|
||||
static void test_names_equal(void)
|
||||
{
|
||||
char *a[] = { "a", "b", "c", NULL };
|
||||
char *b[] = { "a", "b", "d", NULL };
|
||||
char *c[] = { "a", "b", NULL };
|
||||
const char *a[] = { "a", "b", "c", NULL };
|
||||
const char *b[] = { "a", "b", "d", NULL };
|
||||
const char *c[] = { "a", "b", NULL };
|
||||
|
||||
check(names_equal(a, a));
|
||||
check(!names_equal(a, b));
|
||||
|
@ -2,7 +2,8 @@
|
||||
#include "strbuf.h"
|
||||
|
||||
/* wrapper that supplies tests with an empty, initialized strbuf */
|
||||
static void setup(void (*f)(struct strbuf*, void*), void *data)
|
||||
static void setup(void (*f)(struct strbuf*, const void*),
|
||||
const void *data)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
|
||||
@ -13,7 +14,8 @@ static void setup(void (*f)(struct strbuf*, void*), void *data)
|
||||
}
|
||||
|
||||
/* wrapper that supplies tests with a populated, initialized strbuf */
|
||||
static void setup_populated(void (*f)(struct strbuf*, void*), char *init_str, void *data)
|
||||
static void setup_populated(void (*f)(struct strbuf*, const void*),
|
||||
const char *init_str, const void *data)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
|
||||
@ -64,7 +66,7 @@ static void t_dynamic_init(void)
|
||||
strbuf_release(&buf);
|
||||
}
|
||||
|
||||
static void t_addch(struct strbuf *buf, void *data)
|
||||
static void t_addch(struct strbuf *buf, const void *data)
|
||||
{
|
||||
const char *p_ch = data;
|
||||
const char ch = *p_ch;
|
||||
@ -83,7 +85,7 @@ static void t_addch(struct strbuf *buf, void *data)
|
||||
check_char(buf->buf[buf->len], ==, '\0');
|
||||
}
|
||||
|
||||
static void t_addstr(struct strbuf *buf, void *data)
|
||||
static void t_addstr(struct strbuf *buf, const void *data)
|
||||
{
|
||||
const char *text = data;
|
||||
size_t len = strlen(text);
|
||||
|
@ -63,7 +63,7 @@ struct arg_item {
|
||||
|
||||
static LIST_HEAD(conf_head);
|
||||
|
||||
static char *separators = ":";
|
||||
static const char *separators = ":";
|
||||
|
||||
static int configured;
|
||||
|
||||
|
10
userdiff.c
10
userdiff.c
@ -399,7 +399,7 @@ static struct userdiff_driver *userdiff_find_by_namelen(const char *name, size_t
|
||||
static int parse_funcname(struct userdiff_funcname *f, const char *k,
|
||||
const char *v, int cflags)
|
||||
{
|
||||
if (git_config_string(&f->pattern, k, v) < 0)
|
||||
if (git_config_string((char **) &f->pattern, k, v) < 0)
|
||||
return -1;
|
||||
f->cflags = cflags;
|
||||
return 0;
|
||||
@ -445,15 +445,15 @@ int userdiff_config(const char *k, const char *v)
|
||||
if (!strcmp(type, "binary"))
|
||||
return parse_tristate(&drv->binary, k, v);
|
||||
if (!strcmp(type, "command"))
|
||||
return git_config_string(&drv->external, k, v);
|
||||
return git_config_string((char **) &drv->external, k, v);
|
||||
if (!strcmp(type, "textconv"))
|
||||
return git_config_string(&drv->textconv, k, v);
|
||||
return git_config_string((char **) &drv->textconv, k, v);
|
||||
if (!strcmp(type, "cachetextconv"))
|
||||
return parse_bool(&drv->textconv_want_cache, k, v);
|
||||
if (!strcmp(type, "wordregex"))
|
||||
return git_config_string(&drv->word_regex, k, v);
|
||||
return git_config_string((char **) &drv->word_regex, k, v);
|
||||
if (!strcmp(type, "algorithm"))
|
||||
return git_config_string(&drv->algorithm, k, v);
|
||||
return git_config_string((char **) &drv->algorithm, k, v);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
12
userdiff.h
12
userdiff.h
@ -7,19 +7,19 @@ struct index_state;
|
||||
struct repository;
|
||||
|
||||
struct userdiff_funcname {
|
||||
char *pattern;
|
||||
const char *pattern;
|
||||
int cflags;
|
||||
};
|
||||
|
||||
struct userdiff_driver {
|
||||
const char *name;
|
||||
char *external;
|
||||
char *algorithm;
|
||||
const char *external;
|
||||
const char *algorithm;
|
||||
int binary;
|
||||
struct userdiff_funcname funcname;
|
||||
char *word_regex;
|
||||
char *word_regex_multi_byte;
|
||||
char *textconv;
|
||||
const char *word_regex;
|
||||
const char *word_regex_multi_byte;
|
||||
const char *textconv;
|
||||
struct notes_cache *textconv_cache;
|
||||
int textconv_want_cache;
|
||||
};
|
||||
|
@ -2409,7 +2409,7 @@ static void wt_porcelain_v2_print_unmerged_entry(
|
||||
int mode;
|
||||
struct object_id oid;
|
||||
} stages[3];
|
||||
char *key;
|
||||
const char *key;
|
||||
char submodule_token[5];
|
||||
char unmerged_prefix = 'u';
|
||||
char eol_char = s->null_termination ? '\0' : '\n';
|
||||
|
Loading…
Reference in New Issue
Block a user