mirror of
https://github.com/git/git
synced 2024-08-25 02:35:46 +00:00
![René Scharfe](/assets/img/avatar_default.png)
OPT_PARSE_LIST_OBJECTS_FILTER_INIT() with a non-NULL second argument passes a function pointer via an object pointer, which is undefined. It may work fine on platforms that implement C99 extension J.5.7 (Function pointer casts). Remove the unused macro and avoid the dependency on that extension. Signed-off-by: René Scharfe <l.s.r@web.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
419 lines
11 KiB
C
419 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;
|
|
|
|
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));
|
|
}
|