mirror of
https://github.com/git/git
synced 2024-10-30 04:01:21 +00:00
4eaed7c2f2
Since commitc54980ab83
(list-objects-filter: convert filter_spec to a strbuf, 2022-09-11), building with SANITIZE=undefined triggers an error in t5616. The problem is that we end up with a strbuf that has been zero-initialized instead of via STRBUF_INIT. Feeding that strbuf to strbuf_addbuf() in list_objects_filter_copy() means we will call memcpy like: memcpy(some_actual_buffer, NULL, 0); This works on most systems because we're copying zero bytes, but it is technically undefined behavior to ever pass NULL to memcpy. Even thoughc54980ab83
is where the bug manifests, that is only because we switched away from a string_list, which is OK with being zero-initialized (though it may cause other problems by not duplicating the strings, it happened to be OK in this instance). The actual bug is caused by the commit before that,2a01bdedf8
(list-objects-filter: add and use initializers, 2022-09-11). There we consistently initialize the top-level filter structs, but we forgot the dynamically allocated ones we stick in filter_options->sub when creating combined filters. Note that we need to fix two spots here: where we parse a "combine:" filter, but also where we transform from a single-filter into a combined one after seeing multiple "--filter" options. In the second spot, we'll do some minor refactoring to avoid repeating our very-long array index. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
422 lines
11 KiB
C
422 lines
11 KiB
C
#include "cache.h"
|
|
#include "commit.h"
|
|
#include "config.h"
|
|
#include "revision.h"
|
|
#include "strvec.h"
|
|
#include "list-objects.h"
|
|
#include "list-objects-filter.h"
|
|
#include "list-objects-filter-options.h"
|
|
#include "promisor-remote.h"
|
|
#include "trace.h"
|
|
#include "url.h"
|
|
|
|
static int parse_combine_filter(
|
|
struct list_objects_filter_options *filter_options,
|
|
const char *arg,
|
|
struct strbuf *errbuf);
|
|
|
|
const char *list_object_filter_config_name(enum list_objects_filter_choice c)
|
|
{
|
|
switch (c) {
|
|
case LOFC_DISABLED:
|
|
/* we have no name for "no filter at all" */
|
|
break;
|
|
case LOFC_BLOB_NONE:
|
|
return "blob:none";
|
|
case LOFC_BLOB_LIMIT:
|
|
return "blob:limit";
|
|
case LOFC_TREE_DEPTH:
|
|
return "tree";
|
|
case LOFC_SPARSE_OID:
|
|
return "sparse:oid";
|
|
case LOFC_OBJECT_TYPE:
|
|
return "object:type";
|
|
case LOFC_COMBINE:
|
|
return "combine";
|
|
case LOFC__COUNT:
|
|
/* not a real filter type; just the count of all filters */
|
|
break;
|
|
}
|
|
BUG("list_object_filter_config_name: invalid argument '%d'", c);
|
|
}
|
|
|
|
int gently_parse_list_objects_filter(
|
|
struct list_objects_filter_options *filter_options,
|
|
const char *arg,
|
|
struct strbuf *errbuf)
|
|
{
|
|
const char *v0;
|
|
|
|
if (!arg)
|
|
return 0;
|
|
|
|
if (filter_options->choice)
|
|
BUG("filter_options already populated");
|
|
|
|
if (!strcmp(arg, "blob:none")) {
|
|
filter_options->choice = LOFC_BLOB_NONE;
|
|
return 0;
|
|
|
|
} else if (skip_prefix(arg, "blob:limit=", &v0)) {
|
|
if (git_parse_ulong(v0, &filter_options->blob_limit_value)) {
|
|
filter_options->choice = LOFC_BLOB_LIMIT;
|
|
return 0;
|
|
}
|
|
|
|
} else if (skip_prefix(arg, "tree:", &v0)) {
|
|
if (!git_parse_ulong(v0, &filter_options->tree_exclude_depth)) {
|
|
strbuf_addstr(errbuf, _("expected 'tree:<depth>'"));
|
|
return 1;
|
|
}
|
|
filter_options->choice = LOFC_TREE_DEPTH;
|
|
return 0;
|
|
|
|
} else if (skip_prefix(arg, "sparse:oid=", &v0)) {
|
|
filter_options->sparse_oid_name = xstrdup(v0);
|
|
filter_options->choice = LOFC_SPARSE_OID;
|
|
return 0;
|
|
|
|
} else if (skip_prefix(arg, "sparse:path=", &v0)) {
|
|
if (errbuf) {
|
|
strbuf_addstr(
|
|
errbuf,
|
|
_("sparse:path filters support has been dropped"));
|
|
}
|
|
return 1;
|
|
|
|
} else if (skip_prefix(arg, "object:type=", &v0)) {
|
|
int type = type_from_string_gently(v0, strlen(v0), 1);
|
|
if (type < 0) {
|
|
strbuf_addf(errbuf, _("'%s' for 'object:type=<type>' is "
|
|
"not a valid object type"), v0);
|
|
return 1;
|
|
}
|
|
|
|
filter_options->object_type = type;
|
|
filter_options->choice = LOFC_OBJECT_TYPE;
|
|
|
|
return 0;
|
|
|
|
} else if (skip_prefix(arg, "combine:", &v0)) {
|
|
return parse_combine_filter(filter_options, v0, errbuf);
|
|
|
|
}
|
|
/*
|
|
* Please update _git_fetch() in git-completion.bash when you
|
|
* add new filters
|
|
*/
|
|
|
|
strbuf_addf(errbuf, _("invalid filter-spec '%s'"), arg);
|
|
|
|
list_objects_filter_init(filter_options);
|
|
return 1;
|
|
}
|
|
|
|
static const char *RESERVED_NON_WS = "~`!@#$^&*()[]{}\\;'\",<>?";
|
|
|
|
static int has_reserved_character(
|
|
struct strbuf *sub_spec, struct strbuf *errbuf)
|
|
{
|
|
const char *c = sub_spec->buf;
|
|
while (*c) {
|
|
if (*c <= ' ' || strchr(RESERVED_NON_WS, *c)) {
|
|
strbuf_addf(
|
|
errbuf,
|
|
_("must escape char in sub-filter-spec: '%c'"),
|
|
*c);
|
|
return 1;
|
|
}
|
|
c++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int parse_combine_subfilter(
|
|
struct list_objects_filter_options *filter_options,
|
|
struct strbuf *subspec,
|
|
struct strbuf *errbuf)
|
|
{
|
|
size_t new_index = filter_options->sub_nr;
|
|
char *decoded;
|
|
int result;
|
|
|
|
ALLOC_GROW_BY(filter_options->sub, filter_options->sub_nr, 1,
|
|
filter_options->sub_alloc);
|
|
list_objects_filter_init(&filter_options->sub[new_index]);
|
|
|
|
decoded = url_percent_decode(subspec->buf);
|
|
|
|
result = has_reserved_character(subspec, errbuf) ||
|
|
gently_parse_list_objects_filter(
|
|
&filter_options->sub[new_index], decoded, errbuf);
|
|
|
|
free(decoded);
|
|
return result;
|
|
}
|
|
|
|
static int parse_combine_filter(
|
|
struct list_objects_filter_options *filter_options,
|
|
const char *arg,
|
|
struct strbuf *errbuf)
|
|
{
|
|
struct strbuf **subspecs = strbuf_split_str(arg, '+', 0);
|
|
size_t sub;
|
|
int result = 0;
|
|
|
|
if (!subspecs[0]) {
|
|
strbuf_addstr(errbuf, _("expected something after combine:"));
|
|
result = 1;
|
|
goto cleanup;
|
|
}
|
|
|
|
for (sub = 0; subspecs[sub] && !result; sub++) {
|
|
if (subspecs[sub + 1]) {
|
|
/*
|
|
* This is not the last subspec. Remove trailing "+" so
|
|
* we can parse it.
|
|
*/
|
|
size_t last = subspecs[sub]->len - 1;
|
|
assert(subspecs[sub]->buf[last] == '+');
|
|
strbuf_remove(subspecs[sub], last, 1);
|
|
}
|
|
result = parse_combine_subfilter(
|
|
filter_options, subspecs[sub], errbuf);
|
|
}
|
|
|
|
filter_options->choice = LOFC_COMBINE;
|
|
|
|
cleanup:
|
|
strbuf_list_free(subspecs);
|
|
if (result)
|
|
list_objects_filter_release(filter_options);
|
|
return result;
|
|
}
|
|
|
|
static int allow_unencoded(char ch)
|
|
{
|
|
if (ch <= ' ' || ch == '%' || ch == '+')
|
|
return 0;
|
|
return !strchr(RESERVED_NON_WS, ch);
|
|
}
|
|
|
|
static void filter_spec_append_urlencode(
|
|
struct list_objects_filter_options *filter, const char *raw)
|
|
{
|
|
size_t orig_len = filter->filter_spec.len;
|
|
strbuf_addstr_urlencode(&filter->filter_spec, raw, allow_unencoded);
|
|
trace_printf("Add to combine filter-spec: %s\n",
|
|
filter->filter_spec.buf + orig_len);
|
|
}
|
|
|
|
/*
|
|
* Changes filter_options into an equivalent LOFC_COMBINE filter options
|
|
* instance. Does not do anything if filter_options is already LOFC_COMBINE.
|
|
*/
|
|
static void transform_to_combine_type(
|
|
struct list_objects_filter_options *filter_options)
|
|
{
|
|
assert(filter_options->choice);
|
|
if (filter_options->choice == LOFC_COMBINE)
|
|
return;
|
|
{
|
|
const int initial_sub_alloc = 2;
|
|
struct list_objects_filter_options *sub_array =
|
|
xcalloc(initial_sub_alloc, sizeof(*sub_array));
|
|
sub_array[0] = *filter_options;
|
|
list_objects_filter_init(filter_options);
|
|
filter_options->sub = sub_array;
|
|
filter_options->sub_alloc = initial_sub_alloc;
|
|
}
|
|
filter_options->sub_nr = 1;
|
|
filter_options->choice = LOFC_COMBINE;
|
|
strbuf_addstr(&filter_options->filter_spec, "combine:");
|
|
filter_spec_append_urlencode(
|
|
filter_options,
|
|
list_objects_filter_spec(&filter_options->sub[0]));
|
|
/*
|
|
* We don't need the filter_spec strings for subfilter specs, only the
|
|
* top level.
|
|
*/
|
|
strbuf_release(&filter_options->sub[0].filter_spec);
|
|
}
|
|
|
|
void list_objects_filter_die_if_populated(
|
|
struct list_objects_filter_options *filter_options)
|
|
{
|
|
if (filter_options->choice)
|
|
die(_("multiple filter-specs cannot be combined"));
|
|
}
|
|
|
|
void parse_list_objects_filter(
|
|
struct list_objects_filter_options *filter_options,
|
|
const char *arg)
|
|
{
|
|
struct strbuf errbuf = STRBUF_INIT;
|
|
int parse_error;
|
|
|
|
if (!filter_options->filter_spec.buf)
|
|
BUG("filter_options not properly initialized");
|
|
|
|
if (!filter_options->choice) {
|
|
strbuf_addstr(&filter_options->filter_spec, arg);
|
|
|
|
parse_error = gently_parse_list_objects_filter(
|
|
filter_options, arg, &errbuf);
|
|
} else {
|
|
struct list_objects_filter_options *sub;
|
|
|
|
/*
|
|
* Make filter_options an LOFC_COMBINE spec so we can trivially
|
|
* add subspecs to it.
|
|
*/
|
|
transform_to_combine_type(filter_options);
|
|
|
|
strbuf_addch(&filter_options->filter_spec, '+');
|
|
filter_spec_append_urlencode(filter_options, arg);
|
|
ALLOC_GROW_BY(filter_options->sub, filter_options->sub_nr, 1,
|
|
filter_options->sub_alloc);
|
|
sub = &filter_options->sub[filter_options->sub_nr - 1];
|
|
|
|
list_objects_filter_init(sub);
|
|
parse_error = gently_parse_list_objects_filter(sub, arg,
|
|
&errbuf);
|
|
}
|
|
if (parse_error)
|
|
die("%s", errbuf.buf);
|
|
}
|
|
|
|
int opt_parse_list_objects_filter(const struct option *opt,
|
|
const char *arg, int unset)
|
|
{
|
|
struct list_objects_filter_options *filter_options = opt->value;
|
|
opt_lof_init init = (opt_lof_init)opt->defval;
|
|
|
|
if (init)
|
|
filter_options = init(opt->value);
|
|
|
|
if (unset || !arg)
|
|
list_objects_filter_set_no_filter(filter_options);
|
|
else
|
|
parse_list_objects_filter(filter_options, arg);
|
|
return 0;
|
|
}
|
|
|
|
const char *list_objects_filter_spec(struct list_objects_filter_options *filter)
|
|
{
|
|
if (!filter->filter_spec.len)
|
|
BUG("no filter_spec available for this filter");
|
|
return filter->filter_spec.buf;
|
|
}
|
|
|
|
const char *expand_list_objects_filter_spec(
|
|
struct list_objects_filter_options *filter)
|
|
{
|
|
if (filter->choice == LOFC_BLOB_LIMIT) {
|
|
strbuf_release(&filter->filter_spec);
|
|
strbuf_addf(&filter->filter_spec, "blob:limit=%lu",
|
|
filter->blob_limit_value);
|
|
}
|
|
|
|
return list_objects_filter_spec(filter);
|
|
}
|
|
|
|
void list_objects_filter_release(
|
|
struct list_objects_filter_options *filter_options)
|
|
{
|
|
size_t sub;
|
|
|
|
if (!filter_options)
|
|
return;
|
|
strbuf_release(&filter_options->filter_spec);
|
|
free(filter_options->sparse_oid_name);
|
|
for (sub = 0; sub < filter_options->sub_nr; sub++)
|
|
list_objects_filter_release(&filter_options->sub[sub]);
|
|
free(filter_options->sub);
|
|
list_objects_filter_init(filter_options);
|
|
}
|
|
|
|
void partial_clone_register(
|
|
const char *remote,
|
|
struct list_objects_filter_options *filter_options)
|
|
{
|
|
struct promisor_remote *promisor_remote;
|
|
char *cfg_name;
|
|
char *filter_name;
|
|
|
|
/* Check if it is already registered */
|
|
if ((promisor_remote = promisor_remote_find(remote))) {
|
|
if (promisor_remote->partial_clone_filter)
|
|
/*
|
|
* Remote is already registered and a filter is already
|
|
* set, so we don't need to do anything here.
|
|
*/
|
|
return;
|
|
} else {
|
|
if (upgrade_repository_format(1) < 0)
|
|
die(_("unable to upgrade repository format to support partial clone"));
|
|
|
|
/* Add promisor config for the remote */
|
|
cfg_name = xstrfmt("remote.%s.promisor", remote);
|
|
git_config_set(cfg_name, "true");
|
|
free(cfg_name);
|
|
}
|
|
|
|
/*
|
|
* Record the initial filter-spec in the config as
|
|
* the default for subsequent fetches from this remote.
|
|
*/
|
|
filter_name = xstrfmt("remote.%s.partialclonefilter", remote);
|
|
/* NEEDSWORK: 'expand' result leaking??? */
|
|
git_config_set(filter_name,
|
|
expand_list_objects_filter_spec(filter_options));
|
|
free(filter_name);
|
|
|
|
/* Make sure the config info are reset */
|
|
promisor_remote_reinit();
|
|
}
|
|
|
|
void partial_clone_get_default_filter_spec(
|
|
struct list_objects_filter_options *filter_options,
|
|
const char *remote)
|
|
{
|
|
struct promisor_remote *promisor = promisor_remote_find(remote);
|
|
struct strbuf errbuf = STRBUF_INIT;
|
|
|
|
/*
|
|
* Parse default value, but silently ignore it if it is invalid.
|
|
*/
|
|
if (!promisor || !promisor->partial_clone_filter)
|
|
return;
|
|
|
|
strbuf_addstr(&filter_options->filter_spec,
|
|
promisor->partial_clone_filter);
|
|
gently_parse_list_objects_filter(filter_options,
|
|
promisor->partial_clone_filter,
|
|
&errbuf);
|
|
strbuf_release(&errbuf);
|
|
}
|
|
|
|
void list_objects_filter_copy(
|
|
struct list_objects_filter_options *dest,
|
|
const struct list_objects_filter_options *src)
|
|
{
|
|
int i;
|
|
|
|
/* Copy everything. We will overwrite the pointers shortly. */
|
|
memcpy(dest, src, sizeof(struct list_objects_filter_options));
|
|
|
|
strbuf_init(&dest->filter_spec, 0);
|
|
strbuf_addbuf(&dest->filter_spec, &src->filter_spec);
|
|
dest->sparse_oid_name = xstrdup_or_null(src->sparse_oid_name);
|
|
|
|
ALLOC_ARRAY(dest->sub, dest->sub_alloc);
|
|
for (i = 0; i < src->sub_nr; i++)
|
|
list_objects_filter_copy(&dest->sub[i], &src->sub[i]);
|
|
}
|
|
|
|
void list_objects_filter_init(struct list_objects_filter_options *filter_options)
|
|
{
|
|
struct list_objects_filter_options blank = LIST_OBJECTS_FILTER_INIT;
|
|
memcpy(filter_options, &blank, sizeof(*filter_options));
|
|
}
|