* [PATCH v3 7/8] doc: describe the url-parse builtin
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
The new url-parse builtin validates git URLs
and optionally extracts their components.
Helped-by: Ghanshyam Thakkar <shyamthakkar001@gmail.com>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
Documentation/git-url-parse.adoc | 80 ++++++++++++++++++++++++++++++++
Documentation/meson.build | 1 +
2 files changed, 81 insertions(+)
create mode 100644 Documentation/git-url-parse.adoc
diff --git a/Documentation/git-url-parse.adoc b/Documentation/git-url-parse.adoc
new file mode 100644
index 0000000000..9d0d93da4a
--- /dev/null
+++ b/Documentation/git-url-parse.adoc
@@ -0,0 +1,80 @@
+git-url-parse(1)
+================
+
+NAME
+----
+git-url-parse - Parse and extract git URL components
+
+SYNOPSIS
+--------
+[synopsis]
+git url-parse [-c <component>] [--] <url>...
+
+DESCRIPTION
+-----------
+
+Git supports many ways to specify URLs, some of them non-standard.
+For example, git supports the scp style [user@]host:[path] format.
+This command eases interoperability with git URLs by enabling the
+parsing and extraction of the components of all git URLs.
+
+Any syntactically valid URL is parsed, even if the scheme is not one
+git supports for fetching or pushing.
+
+OPTIONS
+-------
+
+`-c <component>`::
+`--component <component>`::
+ Extract the _<component>_ component from the given Git URLs.
+ _<component>_ can be one of:
+ `scheme`, `user`, `password`, `host`, `port`, `path`.
+
+OUTPUT
+------
+
+When `--component` is given, the requested component of each URL
+is printed on its own line, in the order the URLs were given. If
+the URL has no such component (for example, a port in a URL that
+does not specify one), an empty line is printed in its place.
+
+When `--component` is not given, no output is produced. The exit
+status is zero if every URL parses successfully and non-zero
+otherwise, allowing the command to be used purely as a validator.
+
+EXAMPLES
+--------
+
+* Print the host name:
++
+------------
+$ git url-parse --component host https://example.com/user/repo
+example.com
+------------
+
+* Print the path:
++
+------------
+$ git url-parse --component path https://example.com/user/repo
+/user/repo
+$ git url-parse --component path example.com:~user/repo
+~user/repo
+$ git url-parse --component path example.com:user/repo
+/user/repo
+------------
+
+* Validate URLs without outputting anything:
++
+------------
+$ git url-parse https://example.com/user/repo example.com:~user/repo
+------------
+
+SEE ALSO
+--------
+linkgit:git-clone[1],
+linkgit:git-fetch[1],
+linkgit:git-config[1]
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Documentation/meson.build b/Documentation/meson.build
index d6365b888b..32c8606a80 100644
--- a/Documentation/meson.build
+++ b/Documentation/meson.build
@@ -155,6 +155,7 @@ manpages = {
'git-update-server-info.adoc' : 1,
'git-upload-archive.adoc' : 1,
'git-upload-pack.adoc' : 1,
+ 'git-url-parse.adoc' : 1,
'git-var.adoc' : 1,
'git-verify-commit.adoc' : 1,
'git-verify-pack.adoc' : 1,
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 6/8] builtin: create url-parse command
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Git commands can accept a rather wide variety of URLs syntaxes.
The range of accepted inputs might expand even more in the future.
This makes the parsing of URL components difficult since standard URL
parsers cannot be used. Extracting the components of a git URL would
require implementing all the schemes that git itself supports, not to
mention tracking its development continuously in case new URL schemes
are added.
The url-parse builtin command is designed to solve this problem
by exposing git's native URL parsing facilities as a plumbing command.
Other programs can then call upon git itself to parse the git URLs
and extract their components. This should be quite useful for scripts.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
.gitignore | 1 +
Makefile | 1 +
builtin.h | 1 +
builtin/url-parse.c | 135 ++++++++++++++++++++++++++++++++++++++++++++
command-list.txt | 1 +
git.c | 1 +
meson.build | 1 +
7 files changed, 141 insertions(+)
create mode 100644 builtin/url-parse.c
diff --git a/.gitignore b/.gitignore
index 24635cf2d6..c5673daa6e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -182,6 +182,7 @@
/git-update-server-info
/git-upload-archive
/git-upload-pack
+/git-url-parse
/git-var
/git-verify-commit
/git-verify-pack
diff --git a/Makefile b/Makefile
index cedc234173..1c757a1aa0 100644
--- a/Makefile
+++ b/Makefile
@@ -1497,6 +1497,7 @@ BUILTIN_OBJS += builtin/update-ref.o
BUILTIN_OBJS += builtin/update-server-info.o
BUILTIN_OBJS += builtin/upload-archive.o
BUILTIN_OBJS += builtin/upload-pack.o
+BUILTIN_OBJS += builtin/url-parse.o
BUILTIN_OBJS += builtin/var.o
BUILTIN_OBJS += builtin/verify-commit.o
BUILTIN_OBJS += builtin/verify-pack.o
diff --git a/builtin.h b/builtin.h
index 235c51f30e..c6f7672991 100644
--- a/builtin.h
+++ b/builtin.h
@@ -271,6 +271,7 @@ int cmd_update_server_info(int argc, const char **argv, const char *prefix, stru
int cmd_upload_archive(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_upload_archive_writer(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_upload_pack(int argc, const char **argv, const char *prefix, struct repository *repo);
+int cmd_url_parse(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_var(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_verify_commit(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_verify_tag(int argc, const char **argv, const char *prefix, struct repository *repo);
diff --git a/builtin/url-parse.c b/builtin/url-parse.c
new file mode 100644
index 0000000000..7e705538c0
--- /dev/null
+++ b/builtin/url-parse.c
@@ -0,0 +1,135 @@
+#include "builtin.h"
+#include "gettext.h"
+#include "parse-options.h"
+#include "url.h"
+#include "urlmatch.h"
+
+static const char * const builtin_url_parse_usage[] = {
+ N_("git url-parse [-c <component>] [--] <url>..."),
+ NULL
+};
+
+static char *component_arg;
+
+static struct option builtin_url_parse_options[] = {
+ OPT_STRING('c', "component", &component_arg, N_("component"),
+ N_("which URL component to extract")),
+ OPT_END(),
+};
+
+enum url_component {
+ URL_NONE = 0,
+ URL_SCHEME,
+ URL_USER,
+ URL_PASSWORD,
+ URL_HOST,
+ URL_PORT,
+ URL_PATH,
+};
+
+static void parse_or_die(const char *url, struct url_info *info)
+{
+ if (url_is_local_not_ssh(url)) {
+ if (*url == '/')
+ die("'%s' is not a URL; if you meant a local "
+ "repository, use 'file://%s'", url, url);
+ if (has_dos_drive_prefix(url))
+ die("'%s' is not a URL; if you meant a local "
+ "repository, use 'file:///%s'", url, url);
+ die("'%s' is not a URL; if you meant a local repository, "
+ "use a 'file://' URL with an absolute path", url);
+ }
+ if (!url_parse(url, info))
+ die("invalid git URL '%s': %s", url, info->err);
+}
+
+static enum url_component get_component_or_die(const char *arg)
+{
+ if (!strcmp("path", arg))
+ return URL_PATH;
+ if (!strcmp("host", arg))
+ return URL_HOST;
+ if (!strcmp("scheme", arg))
+ return URL_SCHEME;
+ if (!strcmp("user", arg))
+ return URL_USER;
+ if (!strcmp("password", arg))
+ return URL_PASSWORD;
+ if (!strcmp("port", arg))
+ return URL_PORT;
+ die("invalid git URL component '%s'", arg);
+}
+
+static char *extract_component(enum url_component component,
+ struct url_info *info)
+{
+ size_t offset, length;
+
+ switch (component) {
+ case URL_SCHEME:
+ offset = 0;
+ length = info->scheme_len;
+ break;
+ case URL_USER:
+ offset = info->user_off;
+ length = info->user_len;
+ break;
+ case URL_PASSWORD:
+ offset = info->passwd_off;
+ length = info->passwd_len;
+ break;
+ case URL_HOST:
+ offset = info->host_off;
+ length = info->host_len;
+ break;
+ case URL_PORT:
+ offset = info->port_off;
+ length = info->port_len;
+ break;
+ case URL_PATH:
+ offset = info->path_off;
+ length = info->path_len;
+ break;
+ case URL_NONE:
+ return NULL;
+ }
+
+ return xstrndup(info->url + offset, length);
+}
+
+int cmd_url_parse(int argc,
+ const char **argv,
+ const char *prefix,
+ struct repository *repo UNUSED)
+{
+ struct url_info info;
+ enum url_component selected = URL_NONE;
+ char *extracted;
+ int i;
+
+ argc = parse_options(argc, argv, prefix, builtin_url_parse_options,
+ builtin_url_parse_usage, 0);
+
+ if (argc == 0)
+ usage_with_options(builtin_url_parse_usage,
+ builtin_url_parse_options);
+
+ if (component_arg)
+ selected = get_component_or_die(component_arg);
+
+ for (i = 0; i < argc; i++) {
+ parse_or_die(argv[i], &info);
+
+ if (selected != URL_NONE) {
+ extracted = extract_component(selected, &info);
+ if (extracted) {
+ puts(extracted);
+ free(extracted);
+ }
+ }
+
+ free(info.url);
+ }
+
+ return 0;
+}
diff --git a/command-list.txt b/command-list.txt
index f9005cf459..1ede48186f 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -202,6 +202,7 @@ git-update-ref plumbingmanipulators
git-update-server-info synchingrepositories
git-upload-archive synchelpers
git-upload-pack synchelpers
+git-url-parse purehelpers
git-var plumbinginterrogators
git-verify-commit ancillaryinterrogators
git-verify-pack plumbinginterrogators
diff --git a/git.c b/git.c
index 5a40eab8a2..a073eed931 100644
--- a/git.c
+++ b/git.c
@@ -670,6 +670,7 @@ static struct cmd_struct commands[] = {
{ "upload-archive", cmd_upload_archive, NO_PARSEOPT },
{ "upload-archive--writer", cmd_upload_archive_writer, NO_PARSEOPT },
{ "upload-pack", cmd_upload_pack },
+ { "url-parse", cmd_url_parse },
{ "var", cmd_var, RUN_SETUP_GENTLY | NO_PARSEOPT },
{ "verify-commit", cmd_verify_commit, RUN_SETUP },
{ "verify-pack", cmd_verify_pack },
diff --git a/meson.build b/meson.build
index 11488623bf..dc3cf68ee5 100644
--- a/meson.build
+++ b/meson.build
@@ -686,6 +686,7 @@ builtin_sources = [
'builtin/update-server-info.c',
'builtin/upload-archive.c',
'builtin/upload-pack.c',
+ 'builtin/url-parse.c',
'builtin/var.c',
'builtin/verify-commit.c',
'builtin/verify-pack.c',
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 5/8] urlmatch: define url_parse function
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Define url_parse, a general parsing function that supports all Git URLs
including scp style URLs such as hostname:~user/repo.
It is adapted from the algorithm in connect.c's parse_connect_url
and reuses the shared enum url_scheme and url_get_scheme function
that previous commits made available in url.h. The new parser and
the connect path agree on scheme classification. url_parse has the
same interface as url_normalize and uses the same data structures.
Both functions accept the same URL forms with one deliberate
exception. Bare local paths such as "/abs/path", "./rel"
or "repo" are accepted by parse_connect_url as URL_SCHEME_LOCAL,
but rejected by url_parse because url_normalize requires a URL
with a scheme://host form. A consumer that wants to handle both
URLs and local paths needs to dispatch on url_is_local_not_ssh
before calling url_parse, just as the connect path does internally.
The duplication with parse_connect_url is intentional.
The two functions have different contracts:
- parse_connect_url
Calls die() on an unknown scheme
and returns NUL-terminated host/path
strings for the connect path
- url_parse
Returns NULL on failure while populating
out_info->err, and exposes components
as offset/length pairs into the normalized
URL buffer, matching url_normalize.
Reconciling both is possible, but not in the scope
of the current patch set.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
t/unit-tests/u-urlmatch-normalization.c | 45 +++++++++
urlmatch.c | 127 ++++++++++++++++++++++++
urlmatch.h | 1 +
3 files changed, 173 insertions(+)
diff --git a/t/unit-tests/u-urlmatch-normalization.c b/t/unit-tests/u-urlmatch-normalization.c
index 39f6e1ba26..3595d893a2 100644
--- a/t/unit-tests/u-urlmatch-normalization.c
+++ b/t/unit-tests/u-urlmatch-normalization.c
@@ -245,3 +245,48 @@ void test_urlmatch_normalization__equivalents(void)
compare_normalized_urls("https://@x.y/^/../abc", "httpS://@x.y:0443/abc", 1);
compare_normalized_urls("https://@x.y/^/..", "httpS://@x.y:0443/", 1);
}
+
+static void check_parsed_path(const char *url, const char *expected_path)
+{
+ struct url_info info;
+ char *parsed = url_parse(url, &info);
+ char *path;
+
+ cl_assert(parsed != NULL);
+ path = xstrndup(parsed + info.path_off, info.path_len);
+ cl_assert_equal_s(path, expected_path);
+ free(path);
+ free(parsed);
+}
+
+void test_urlmatch_normalization__parse_scp(void)
+{
+ check_parsed_path("host:path", "/path");
+ check_parsed_path("user@host:path", "/path");
+ check_parsed_path("host:~user/repo", "~user/repo");
+ check_parsed_path("user@host:~user/repo", "~user/repo");
+ check_parsed_path("[host]:src", "/src");
+ check_parsed_path("[host:123]:src", "/src");
+ check_parsed_path("[::1]:repo", "/repo");
+ check_parsed_path("user@[::1]:repo", "/repo");
+}
+
+void test_urlmatch_normalization__parse_url_form(void)
+{
+ check_parsed_path("ssh://host/repo", "/repo");
+ check_parsed_path("ssh://host/~user/repo", "~user/repo");
+ check_parsed_path("git://host:9418/repo", "/repo");
+ check_parsed_path("git://host/~user/repo", "~user/repo");
+ check_parsed_path("ssh://[::1]:1234/repo", "/repo");
+ check_parsed_path("http://[2001:db8::1]/repo", "/repo");
+}
+
+void test_urlmatch_normalization__parse_strips_query_and_fragment(void)
+{
+ check_parsed_path("ssh://host/~user/repo?q", "~user/repo");
+ check_parsed_path("ssh://host/~user/repo#frag", "~user/repo");
+ check_parsed_path("git://host/~user/repo?q", "~user/repo");
+ check_parsed_path("user@host:~user/repo?q", "~user/repo");
+ check_parsed_path("https://host/repo?q", "/repo");
+ check_parsed_path("https://host/repo#frag", "/repo");
+}
diff --git a/urlmatch.c b/urlmatch.c
index eea8300489..bf8cce6de9 100644
--- a/urlmatch.c
+++ b/urlmatch.c
@@ -5,6 +5,7 @@
#include "hex-ll.h"
#include "strbuf.h"
#include "urlmatch.h"
+#include "url.h"
#define URL_ALPHA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
#define URL_DIGIT "0123456789"
@@ -440,6 +441,132 @@ char *url_normalize(const char *url, struct url_info *out_info)
return url_normalize_1(url, out_info, 0);
}
+char *url_parse(const char *url_orig, struct url_info *out_info)
+{
+ struct strbuf url;
+ char *host, *separator;
+ char *detached, *normalized;
+ char *url_decoded;
+ enum url_scheme scheme = URL_SCHEME_LOCAL;
+ struct url_info local_info;
+ struct url_info *info = out_info ? out_info : &local_info;
+ bool scp_syntax = false;
+
+ if (is_url(url_orig))
+ url_decoded = url_decode(url_orig);
+ else
+ url_decoded = xstrdup(url_orig);
+
+ strbuf_init(&url, strlen(url_decoded) + sizeof("ssh://"));
+ strbuf_addstr(&url, url_decoded);
+ free(url_decoded);
+
+ host = strstr(url.buf, "://");
+ if (host) {
+ /*
+ * Temporarily NUL-terminate the scheme name
+ * so we can pass it to url_get_scheme(),
+ * then restore the ':' so the buffer
+ * is intact for url_normalize() below.
+ */
+ char saved = *host;
+ *host = '\0';
+ scheme = url_get_scheme(url.buf);
+ *host = saved;
+ host += 3;
+ } else {
+ if (!url_is_local_not_ssh(url.buf)) {
+ scp_syntax = true;
+ scheme = URL_SCHEME_SSH;
+ strbuf_insertstr(&url, 0, "ssh://");
+ host = url.buf + strlen("ssh://");
+ }
+ }
+
+ /*
+ * Path starts after ':' in scp style SSH URLs.
+ *
+ * The host portion can begin with an optional "user@",
+ * and the host itself can be wrapped in '[' ']' brackets.
+ * The bracket form is git's legacy way of supporting:
+ *
+ * - IPv6 literals: [::1]:repo
+ * - host:port pairs in the short form: [myhost:123]:src
+ * - Plain hostnames that happen to need bracketing: [host]:path
+ *
+ * Treat '[' followed by 0 or 1 inner colons as the host:port
+ * or plain hostname form and strip the brackets so url_normalize
+ * sees host[:port] natively. Two or more inner colons mark an
+ * IPv6 literal: keep the brackets for url_normalize to recognize.
+ *
+ * The scp path separator is the ':' that follows the host part,
+ * and we must skip over user@ and any '[...]' before searching.
+ */
+ if (scp_syntax) {
+ char *user_at;
+ char *host_start;
+ char *bracket_end;
+
+ user_at = strchr(host, '@');
+ host_start = user_at ? user_at + 1 : host;
+
+ if (*host_start == '[') {
+ char *p;
+ int inner_colons;
+
+ bracket_end = strchr(host_start, ']');
+ inner_colons = 0;
+ for (p = host_start + 1; bracket_end && p < bracket_end; p++)
+ if (*p == ':')
+ inner_colons++;
+
+ if (bracket_end && inner_colons <= 1) {
+ size_t close_off = bracket_end - url.buf;
+ size_t open_off = host_start - url.buf;
+ strbuf_remove(&url, close_off, 1);
+ strbuf_remove(&url, open_off, 1);
+ separator = url.buf + close_off - 1;
+ } else if (bracket_end) {
+ separator = strchr(bracket_end + 1, ':');
+ } else {
+ separator = strchr(host_start, ':');
+ }
+ } else {
+ separator = strchr(host_start, ':');
+ }
+
+ if (separator) {
+ if (separator[1] == '/')
+ strbuf_remove(&url, separator - url.buf, 1);
+ else
+ *separator = '/';
+ }
+ }
+
+ detached = strbuf_detach(&url, NULL);
+ normalized = url_normalize(detached, info);
+ free(detached);
+
+ if (!normalized)
+ return NULL;
+
+ /*
+ * Point path to ~ for URLs like this:
+ *
+ * ssh://host.xz/~user/repo
+ * git://host.xz/~user/repo
+ * host.xz:~user/repo
+ */
+ if (scheme == URL_SCHEME_GIT || scheme == URL_SCHEME_SSH) {
+ if (normalized[info->path_off + 1] == '~') {
+ info->path_off++;
+ info->path_len--;
+ }
+ }
+
+ return normalized;
+}
+
static size_t url_match_prefix(const char *url,
const char *url_prefix,
size_t url_prefix_len)
diff --git a/urlmatch.h b/urlmatch.h
index 5ba85cea13..6b3ce42858 100644
--- a/urlmatch.h
+++ b/urlmatch.h
@@ -35,6 +35,7 @@ struct url_info {
};
char *url_normalize(const char *, struct url_info *);
+char *url_parse(const char *, struct url_info *);
struct urlmatch_item {
size_t hostmatch_len;
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 4/8] url: return URL_SCHEME_UNKNOWN instead of dying
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Enumerate a URL_SCHEME_UNKNOWN result with value 0.
Have url_get_scheme() return it for unrecognized
schemes instead of calling die() itself.
Move the die() call to parse_connect_url()
where url_get_scheme() is used.
This lets url_get_scheme() be used from contexts
that need to identify a URL's scheme without aborting
the program. For example, a future plumbing command
that validates URLs.
No external behavior change. parse_connect_url() still dies
with the same translated message for unrecognized schemes.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 2 ++
url.c | 3 +--
url.h | 7 ++++---
3 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/connect.c b/connect.c
index 1ac7acc6e8..73d7a6b8d0 100644
--- a/connect.c
+++ b/connect.c
@@ -1071,6 +1071,8 @@ static enum url_scheme parse_connect_url(const char *url_orig, char **ret_host,
if (host) {
*host = '\0';
scheme = url_get_scheme(url);
+ if (scheme == URL_SCHEME_UNKNOWN)
+ die(_("protocol '%s' is not supported"), url);
host += 3;
} else {
host = url;
diff --git a/url.c b/url.c
index 300acf98fe..a59818278f 100644
--- a/url.c
+++ b/url.c
@@ -1,5 +1,4 @@
#include "git-compat-util.h"
-#include "gettext.h"
#include "hex-ll.h"
#include "strbuf.h"
#include "url.h"
@@ -154,5 +153,5 @@ enum url_scheme url_get_scheme(const char *name)
return URL_SCHEME_SSH;
if (!strcmp(name, "file"))
return URL_SCHEME_FILE;
- die(_("protocol '%s' is not supported"), name);
+ return URL_SCHEME_UNKNOWN;
}
diff --git a/url.h b/url.h
index 24c8cd91d0..7289523605 100644
--- a/url.h
+++ b/url.h
@@ -24,15 +24,16 @@ void str_end_url_with_slash(const char *url, char **dest);
int url_is_local_not_ssh(const char *url);
enum url_scheme {
- URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_UNKNOWN = 0,
+ URL_SCHEME_LOCAL,
URL_SCHEME_FILE,
URL_SCHEME_SSH,
URL_SCHEME_GIT,
};
/*
- * Identify the URL scheme by name. Dies if the name does not match
- * any scheme that Git knows about.
+ * Identify the URL scheme by name. Returns URL_SCHEME_UNKNOWN
+ * if the name does not match any scheme that Git knows about.
*/
enum url_scheme url_get_scheme(const char *name);
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 3/8] url: move scheme detection to URL header/source
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Move enum url_scheme and url_get_scheme()
from connect.c to url.h and url.c
so that other code can identify
a URL's scheme without depending
on connect.c.
No behavior change. url_get_scheme() still dies
on an unrecognized scheme name, with the same
translated message as before.
scheme_name() stays in connect.c
because it has no other callers.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 22 ----------------------
url.c | 16 ++++++++++++++++
url.h | 13 +++++++++++++
3 files changed, 29 insertions(+), 22 deletions(-)
diff --git a/connect.c b/connect.c
index cb145de30e..1ac7acc6e8 100644
--- a/connect.c
+++ b/connect.c
@@ -700,13 +700,6 @@ int server_supports(const char *feature)
return !!server_feature_value(feature, NULL);
}
-enum url_scheme {
- URL_SCHEME_LOCAL = 1,
- URL_SCHEME_FILE,
- URL_SCHEME_SSH,
- URL_SCHEME_GIT
-};
-
static const char *url_scheme_name(enum url_scheme scheme)
{
switch (scheme) {
@@ -722,21 +715,6 @@ static const char *url_scheme_name(enum url_scheme scheme)
}
}
-static enum url_scheme url_get_scheme(const char *name)
-{
- if (!strcmp(name, "ssh"))
- return URL_SCHEME_SSH;
- if (!strcmp(name, "git"))
- return URL_SCHEME_GIT;
- if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
- return URL_SCHEME_SSH;
- if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
- return URL_SCHEME_SSH;
- if (!strcmp(name, "file"))
- return URL_SCHEME_FILE;
- die(_("protocol '%s' is not supported"), name);
-}
-
static char *host_end(char **hoststart, int removebrackets)
{
char *host = *hoststart;
diff --git a/url.c b/url.c
index 057576042a..300acf98fe 100644
--- a/url.c
+++ b/url.c
@@ -1,4 +1,5 @@
#include "git-compat-util.h"
+#include "gettext.h"
#include "hex-ll.h"
#include "strbuf.h"
#include "url.h"
@@ -140,3 +141,18 @@ int url_is_local_not_ssh(const char *url)
return !colon || (slash && slash < colon) ||
(has_dos_drive_prefix(url) && is_valid_path(url));
}
+
+enum url_scheme url_get_scheme(const char *name)
+{
+ if (!strcmp(name, "ssh"))
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "git"))
+ return URL_SCHEME_GIT;
+ if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "file"))
+ return URL_SCHEME_FILE;
+ die(_("protocol '%s' is not supported"), name);
+}
diff --git a/url.h b/url.h
index 39d621312f..24c8cd91d0 100644
--- a/url.h
+++ b/url.h
@@ -23,6 +23,19 @@ void str_end_url_with_slash(const char *url, char **dest);
int url_is_local_not_ssh(const char *url);
+enum url_scheme {
+ URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_FILE,
+ URL_SCHEME_SSH,
+ URL_SCHEME_GIT,
+};
+
+/*
+ * Identify the URL scheme by name. Dies if the name does not match
+ * any scheme that Git knows about.
+ */
+enum url_scheme url_get_scheme(const char *name);
+
/*
* The set of unreserved characters as per STD66 (RFC3986) is
* '[A-Za-z0-9-._~]'. These characters are safe to appear in URI
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 2/8] url: move url_is_local_not_ssh to url.h
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Move url_is_local_not_ssh from connect.c/connect.h
to url.c/url.h so that the new url_parse function
in urlmatch.c, and any future code that needs to
distinguish a local path from an scp style SSH URL,
can reuse the heuristic without depending on connect.c.
No behavior change.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 8 --------
connect.h | 1 -
remote.c | 1 +
url.c | 8 ++++++++
url.h | 2 ++
5 files changed, 11 insertions(+), 9 deletions(-)
diff --git a/connect.c b/connect.c
index 46da89905e..cb145de30e 100644
--- a/connect.c
+++ b/connect.c
@@ -707,14 +707,6 @@ enum url_scheme {
URL_SCHEME_GIT
};
-int url_is_local_not_ssh(const char *url)
-{
- const char *colon = strchr(url, ':');
- const char *slash = strchr(url, '/');
- return !colon || (slash && slash < colon) ||
- (has_dos_drive_prefix(url) && is_valid_path(url));
-}
-
static const char *url_scheme_name(enum url_scheme scheme)
{
switch (scheme) {
diff --git a/connect.h b/connect.h
index 1645126c17..8d84f6656b 100644
--- a/connect.h
+++ b/connect.h
@@ -13,7 +13,6 @@ int git_connection_is_socket(struct child_process *conn);
int server_supports(const char *feature);
int parse_feature_request(const char *features, const char *feature);
const char *server_feature_value(const char *feature, size_t *len_ret);
-int url_is_local_not_ssh(const char *url);
struct packet_reader;
enum protocol_version discover_version(struct packet_reader *reader);
diff --git a/remote.c b/remote.c
index a664cd166a..24a8118d25 100644
--- a/remote.c
+++ b/remote.c
@@ -8,6 +8,7 @@
#include "gettext.h"
#include "hex.h"
#include "remote.h"
+#include "url.h"
#include "urlmatch.h"
#include "refs.h"
#include "refspec.h"
diff --git a/url.c b/url.c
index 3ca5987e90..057576042a 100644
--- a/url.c
+++ b/url.c
@@ -132,3 +132,11 @@ void str_end_url_with_slash(const char *url, char **dest)
free(*dest);
*dest = strbuf_detach(&buf, NULL);
}
+
+int url_is_local_not_ssh(const char *url)
+{
+ const char *colon = strchr(url, ':');
+ const char *slash = strchr(url, '/');
+ return !colon || (slash && slash < colon) ||
+ (has_dos_drive_prefix(url) && is_valid_path(url));
+}
diff --git a/url.h b/url.h
index cd9140e994..39d621312f 100644
--- a/url.h
+++ b/url.h
@@ -21,6 +21,8 @@ char *url_decode_parameter_value(const char **query);
void end_url_with_slash(struct strbuf *buf, const char *url);
void str_end_url_with_slash(const char *url, char **dest);
+int url_is_local_not_ssh(const char *url);
+
/*
* The set of unreserved characters as per STD66 (RFC3986) is
* '[A-Za-z0-9-._~]'. These characters are safe to appear in URI
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 1/8] connect: rename enum protocol to url_scheme
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v3.git.git.1777699722.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
RFC 1738 names the part of a URL before the colon a "scheme".
connect.c calls it "protocol", which is more generic
and collides with the unrelated enum protocol_version.
Rename:
enum protocol -> enum url_scheme
PROTO_* -> URL_SCHEME_*
prot_name -> url_scheme_name
get_protocol -> url_get_scheme
The local variables in parse_connect_url and git_connect
are renamed accordingly, from protocol to scheme.
No behavior change. The user-visible diagnostics
and translated error messages are preserved:
"Diag: protocol=..."
"protocol '%s' is not supported"
"unknown protocol"
This rename also prepares for moving the scheme-detection functions
to a shared header so that a future plumbing command can parse URLs
using the same logic as the connect path.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 68 +++++++++++++++++++++++++++----------------------------
1 file changed, 34 insertions(+), 34 deletions(-)
diff --git a/connect.c b/connect.c
index fcd35c5539..46da89905e 100644
--- a/connect.c
+++ b/connect.c
@@ -700,11 +700,11 @@ int server_supports(const char *feature)
return !!server_feature_value(feature, NULL);
}
-enum protocol {
- PROTO_LOCAL = 1,
- PROTO_FILE,
- PROTO_SSH,
- PROTO_GIT
+enum url_scheme {
+ URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_FILE,
+ URL_SCHEME_SSH,
+ URL_SCHEME_GIT
};
int url_is_local_not_ssh(const char *url)
@@ -715,33 +715,33 @@ int url_is_local_not_ssh(const char *url)
(has_dos_drive_prefix(url) && is_valid_path(url));
}
-static const char *prot_name(enum protocol protocol)
+static const char *url_scheme_name(enum url_scheme scheme)
{
- switch (protocol) {
- case PROTO_LOCAL:
- case PROTO_FILE:
+ switch (scheme) {
+ case URL_SCHEME_LOCAL:
+ case URL_SCHEME_FILE:
return "file";
- case PROTO_SSH:
+ case URL_SCHEME_SSH:
return "ssh";
- case PROTO_GIT:
+ case URL_SCHEME_GIT:
return "git";
default:
return "unknown protocol";
}
}
-static enum protocol get_protocol(const char *name)
+static enum url_scheme url_get_scheme(const char *name)
{
if (!strcmp(name, "ssh"))
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "git"))
- return PROTO_GIT;
+ return URL_SCHEME_GIT;
if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "file"))
- return PROTO_FILE;
+ return URL_SCHEME_FILE;
die(_("protocol '%s' is not supported"), name);
}
@@ -1083,14 +1083,14 @@ static char *get_port(char *host)
* Extract protocol and relevant parts from the specified connection URL.
* The caller must free() the returned strings.
*/
-static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
- char **ret_path)
+static enum url_scheme parse_connect_url(const char *url_orig, char **ret_host,
+ char **ret_path)
{
char *url;
char *host, *path;
char *end;
int separator = '/';
- enum protocol protocol = PROTO_LOCAL;
+ enum url_scheme scheme = URL_SCHEME_LOCAL;
if (is_url(url_orig))
url = url_decode(url_orig);
@@ -1100,12 +1100,12 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
host = strstr(url, "://");
if (host) {
*host = '\0';
- protocol = get_protocol(url);
+ scheme = url_get_scheme(url);
host += 3;
} else {
host = url;
if (!url_is_local_not_ssh(url)) {
- protocol = PROTO_SSH;
+ scheme = URL_SCHEME_SSH;
separator = ':';
}
}
@@ -1116,13 +1116,13 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
*/
end = host_end(&host, 0);
- if (protocol == PROTO_LOCAL)
+ if (scheme == URL_SCHEME_LOCAL)
path = end;
- else if (protocol == PROTO_FILE && *host != '/' &&
+ else if (scheme == URL_SCHEME_FILE && *host != '/' &&
!has_dos_drive_prefix(host) &&
offset_1st_component(host - 2) > 1)
path = host - 2; /* include the leading "//" */
- else if (protocol == PROTO_FILE && has_dos_drive_prefix(end))
+ else if (scheme == URL_SCHEME_FILE && has_dos_drive_prefix(end))
path = end; /* "file://$(pwd)" may be "file://C:/projects/repo" */
else
path = strchr(end, separator);
@@ -1138,7 +1138,7 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
end = path; /* Need to \0 terminate host here */
if (separator == ':')
path++; /* path starts after ':' */
- if (protocol == PROTO_GIT || protocol == PROTO_SSH) {
+ if (scheme == URL_SCHEME_GIT || scheme == URL_SCHEME_SSH) {
if (path[1] == '~')
path++;
}
@@ -1149,7 +1149,7 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
*ret_host = xstrdup(host);
*ret_path = path;
free(url);
- return protocol;
+ return scheme;
}
static const char *get_ssh_command(void)
@@ -1434,7 +1434,7 @@ struct child_process *git_connect(int fd[2], const char *url,
{
char *hostandport, *path;
struct child_process *conn;
- enum protocol protocol;
+ enum url_scheme scheme;
enum protocol_version version = get_protocol_version_config();
/*
@@ -1451,14 +1451,14 @@ struct child_process *git_connect(int fd[2], const char *url,
*/
signal(SIGCHLD, SIG_DFL);
- protocol = parse_connect_url(url, &hostandport, &path);
- if ((flags & CONNECT_DIAG_URL) && (protocol != PROTO_SSH)) {
+ scheme = parse_connect_url(url, &hostandport, &path);
+ if ((flags & CONNECT_DIAG_URL) && (scheme != URL_SCHEME_SSH)) {
printf("Diag: url=%s\n", url ? url : "NULL");
- printf("Diag: protocol=%s\n", prot_name(protocol));
+ printf("Diag: protocol=%s\n", url_scheme_name(scheme));
printf("Diag: hostandport=%s\n", hostandport ? hostandport : "NULL");
printf("Diag: path=%s\n", path ? path : "NULL");
conn = NULL;
- } else if (protocol == PROTO_GIT) {
+ } else if (scheme == URL_SCHEME_GIT) {
conn = git_connect_git(fd, hostandport, path, prog, version, flags);
conn->trace2_child_class = "transport/git";
} else {
@@ -1481,7 +1481,7 @@ struct child_process *git_connect(int fd[2], const char *url,
conn->use_shell = 1;
conn->in = conn->out = -1;
- if (protocol == PROTO_SSH) {
+ if (scheme == URL_SCHEME_SSH) {
char *ssh_host = hostandport;
const char *port = NULL;
transport_check_allowed("ssh");
@@ -1492,7 +1492,7 @@ struct child_process *git_connect(int fd[2], const char *url,
if (flags & CONNECT_DIAG_URL) {
printf("Diag: url=%s\n", url ? url : "NULL");
- printf("Diag: protocol=%s\n", prot_name(protocol));
+ printf("Diag: protocol=%s\n", url_scheme_name(scheme));
printf("Diag: userandhost=%s\n", ssh_host ? ssh_host : "NULL");
printf("Diag: port=%s\n", port ? port : "NONE");
printf("Diag: path=%s\n", path ? path : "NULL");
--
gitgitgadget
^ permalink raw reply related
* [PATCH v3 0/8] builtin: implement, document and test url-parse
From: Matheus Moreira via GitGitGadget @ 2026-05-02 5:28 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
This series adds git url-parse, a plumbing builtin for inspecting git URLs.
Git accepts a wider variety of URL forms than any standard parser handles.
The supported forms include RFC URLs, file:// URLs, scp-style
[user@]host:path for SSH, and IPv6 in brackets. Tools wanting to reason
about them have historically had to reimplement git's parsing or shell out
indirectly. With git url-parse, scripts can ask git directly: validate a
URL, extract a component (scheme, user, host, port, path, password), or
both.
The series consists of eight commits.
The first four are preparatory. They rename enum protocol to enum url_scheme
for RFC alignment, move url_is_local_not_ssh and the scheme-detection
routines from connect.c to url.h/url.c, and stop url_get_scheme from dying
on unknown schemes so other parsers can handle unknowns gracefully.
The fifth commit defines the new parser, url_parse, in urlmatch.c. It is
adapted from parse_connect_url and uses the same data structures as
url_normalize. The parser returns NULL on failure with err populated, and
exposes URL components as offset/length pairs into the normalized URL
buffer.
The sixth commit adds the user-facing command, with a helpful error when the
input looks like a local path rather than a URL.
The last two commits are documentation (a manpage) and 53 tests covering URL
form, scp form, IPv6 in URL and scp forms, bracket forms, username
expansion, query/fragment stripping, the local-path error, and
validation-only mode.
Several choices in this series are judgment calls. Happy to amend or follow
up on any of them.
The component name is scheme, not protocol. RFC 1738/3986 calls them
schemes. The series renames enum protocol to enum url_scheme internally, and
the user-facing component name follows the same direction. I considered
accepting both as aliases but decided against the precedent for a new
command. If you would rather see protocol, or both protocol and scheme, that
is easy to change.
Local paths are deliberately not URLs. parse_connect_url accepts bare paths
like /abs/path or ./rel as URL_SCHEME_LOCAL. url_parse rejects them, since
url_normalize requires a scheme://host form, and silent conversion to
file:// has no good answer for relative or tilde forms. The builtin emits a
helpful error suggesting the explicit file:// form. If full git clone parity
is preferred (bare paths accepted via auto-conversion or a new flag), that
could be added.
Absent and empty components are conflated in output. --component user
http://host/ and --component user http://@host/ both produce empty lines.
The underlying struct url_info preserves the distinction: *_off == 0 vs
*_off != 0 with *_len == 0. A future option can expose it without breaking
change. Can amend this patch set if necessary.
Changes since v1:
* Bug fix: ~user paths with a query string or fragment were leaking the ?
or # into the path output. The ~user-skip logic in url_parse previously
ran only for file://. It now runs for git/ssh/scp URLs as well, matching
what parse_connect_url does and what users expect.
* Helpful error for local paths instead of the cryptic "invalid URL scheme
name or missing '://' suffix".
* -c protocol renamed to -c scheme for consistency with the internal rename
and the RFC.
* Documented the deliberate divergence from parse_connect_url (local paths
and unknown schemes) in the urlmatch commit message.
* Doc and command-list polish: purehelpers category, asciidoc placeholder
convention, [synopsis] form.
* Original micro commit style staged buildup of the builtin collapsed to a
single self-contained commit. The rest of the series is unchanged in
shape.
Changes since v2:
* Fix Windows CI failure: handle DOS drive prefix in the helpful local-path
error. With this, the message for a drive-letter input like C:/repo (or
an MSYS-mangled /abs/path that bash rewrites to D:/.../abs/path before
git sees it) gets the specific file:///<input> suggestion rather than the
generic fallback. No effect on Linux or macOS, since has_dos_drive_prefix
is a no-op on non-Windows builds.
* t9904: relax the grep on the absolute-path test from the literal
file:///abs/path to the structural file:/// (three slashes). The original
assertion depended on the input being preserved verbatim, which MSYS does
not do. The relaxed grep verifies the structurally meaningful property
(specific URL suggestion was produced, not the generic fallback) and runs
cross-platform.
Range-diff against v2:
1: 38f797362d = 1: 38f797362d connect: rename enum protocol to url_scheme 2:
a4153e1d24 = 2: a4153e1d24 url: move url_is_local_not_ssh to url.h 3:
e584fb03f3 = 3: e584fb03f3 url: move scheme detection to URL header/source
4: 7381704c38 = 4: 7381704c38 url: return URL_SCHEME_UNKNOWN instead of
dying 5: 89932a70f3 = 5: 89932a70f3 urlmatch: define url_parse function 6:
886a7d659e ! 6: af6c71227b builtin: create url-parse command @@
builtin/url-parse.c (new) + if (*url == '/') + die("'%s' is not a URL; if
you meant a local " + "repository, use 'file://%s'", url, url); ++ if
(has_dos_drive_prefix(url)) ++ die("'%s' is not a URL; if you meant a local
" ++ "repository, use 'file:///%s'", url, url); + die("'%s' is not a URL; if
you meant a local repository, " + "use a 'file://' URL with an absolute
path", url); + } 7: 3c44e0f478 = 7: 2b32cb71a3 doc: describe the url-parse
builtin 8: cf2ae409e6 ! 8: ce41d2ec50 t9904: add tests for the new url-parse
builtin @@ t/t9904-url-parse.sh (new) +test_expect_success 'git url-parse
helpful error for absolute local path' ' + test_must_fail git url-parse
"/abs/path" 2>err && + test_grep "is not a URL" err && -+ test_grep
"file:///abs/path" err ++ test_grep "file:///" err +' + +test_expect_success
'git url-parse helpful error for relative local path' '
Matheus Afonso Martins Moreira (8):
connect: rename enum protocol to url_scheme
url: move url_is_local_not_ssh to url.h
url: move scheme detection to URL header/source
url: return URL_SCHEME_UNKNOWN instead of dying
urlmatch: define url_parse function
builtin: create url-parse command
doc: describe the url-parse builtin
t9904: add tests for the new url-parse builtin
.gitignore | 1 +
Documentation/git-url-parse.adoc | 80 ++++++
Documentation/meson.build | 1 +
Makefile | 1 +
builtin.h | 1 +
builtin/url-parse.c | 135 ++++++++++
command-list.txt | 1 +
connect.c | 78 ++----
connect.h | 1 -
git.c | 1 +
meson.build | 1 +
remote.c | 1 +
t/meson.build | 1 +
t/t9904-url-parse.sh | 319 ++++++++++++++++++++++++
t/unit-tests/u-urlmatch-normalization.c | 45 ++++
url.c | 23 ++
url.h | 16 ++
urlmatch.c | 127 ++++++++++
urlmatch.h | 1 +
19 files changed, 780 insertions(+), 54 deletions(-)
create mode 100644 Documentation/git-url-parse.adoc
create mode 100644 builtin/url-parse.c
create mode 100755 t/t9904-url-parse.sh
base-commit: 94f057755b7941b321fd11fec1b2e3ca5313a4e0
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1715%2Fmatheusmoreira%2Furl-parse-v3
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1715/matheusmoreira/url-parse-v3
Pull-Request: https://github.com/git/git/pull/1715
Range-diff vs v2:
1: 38f797362d = 1: 38f797362d connect: rename enum protocol to url_scheme
2: a4153e1d24 = 2: a4153e1d24 url: move url_is_local_not_ssh to url.h
3: e584fb03f3 = 3: e584fb03f3 url: move scheme detection to URL header/source
4: 7381704c38 = 4: 7381704c38 url: return URL_SCHEME_UNKNOWN instead of dying
5: 89932a70f3 = 5: 89932a70f3 urlmatch: define url_parse function
6: 886a7d659e ! 6: af6c71227b builtin: create url-parse command
@@ builtin/url-parse.c (new)
+ if (*url == '/')
+ die("'%s' is not a URL; if you meant a local "
+ "repository, use 'file://%s'", url, url);
++ if (has_dos_drive_prefix(url))
++ die("'%s' is not a URL; if you meant a local "
++ "repository, use 'file:///%s'", url, url);
+ die("'%s' is not a URL; if you meant a local repository, "
+ "use a 'file://' URL with an absolute path", url);
+ }
7: 3c44e0f478 = 7: 2b32cb71a3 doc: describe the url-parse builtin
8: cf2ae409e6 ! 8: ce41d2ec50 t9904: add tests for the new url-parse builtin
@@ t/t9904-url-parse.sh (new)
+test_expect_success 'git url-parse helpful error for absolute local path' '
+ test_must_fail git url-parse "/abs/path" 2>err &&
+ test_grep "is not a URL" err &&
-+ test_grep "file:///abs/path" err
++ test_grep "file:///" err
+'
+
+test_expect_success 'git url-parse helpful error for relative local path' '
--
gitgitgadget
^ permalink raw reply
* [PATCH v2 8/8] t9904: add tests for the new url-parse builtin
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Test git URL parsing, validation and component extraction
on all documented git URL schemes and syntaxes.
Add IPv6 host coverage in URL form:
ssh://[::1]/path
ssh://user@[::1]:1234/path
git://[::1]:9418/path
http://[2001:db8::1]/path
https://[2001:db8::1]/path
In URL form the brackets are kept in the host component (RFC 3986
syntax for IPv6 literals).
Also exercise the bracketed scp short forms that t5601-clone.sh
covers via parse_connect_url:
[host]:path
[host:port]:path
[::1]:repo
user@[::1]:repo
user@[host:port]:path
In scp form, brackets are kept for IPv6 literals (two or more inner
colons) and stripped for plain hostnames or host:port pairs.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
t/meson.build | 1 +
t/t9904-url-parse.sh | 319 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 320 insertions(+)
create mode 100755 t/t9904-url-parse.sh
diff --git a/t/meson.build b/t/meson.build
index 7528e5cda5..41b389a472 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -1114,6 +1114,7 @@ integration_tests = [
't9901-git-web--browse.sh',
't9902-completion.sh',
't9903-bash-prompt.sh',
+ 't9904-url-parse.sh',
]
benchmarks = [
diff --git a/t/t9904-url-parse.sh b/t/t9904-url-parse.sh
new file mode 100755
index 0000000000..32b3f4a286
--- /dev/null
+++ b/t/t9904-url-parse.sh
@@ -0,0 +1,319 @@
+#!/bin/sh
+#
+# Copyright (c) 2024 Matheus Afonso Martins Moreira
+#
+
+test_description='git url-parse tests'
+
+. ./test-lib.sh
+
+test_expect_success 'git url-parse -- ssh syntax' '
+ git url-parse "ssh://user@example.com:1234/repository/path" &&
+ git url-parse "ssh://user@example.com/repository/path" &&
+ git url-parse "ssh://example.com:1234/repository/path" &&
+ git url-parse "ssh://example.com/repository/path"
+'
+
+test_expect_success 'git url-parse -- git syntax' '
+ git url-parse "git://example.com:1234/repository/path" &&
+ git url-parse "git://example.com/repository/path"
+'
+
+test_expect_success 'git url-parse -- http syntax' '
+ git url-parse "https://example.com:1234/repository/path" &&
+ git url-parse "https://example.com/repository/path" &&
+ git url-parse "http://example.com:1234/repository/path" &&
+ git url-parse "http://example.com/repository/path"
+'
+
+test_expect_success 'git url-parse -- scp syntax' '
+ git url-parse "user@example.com:/repository/path" &&
+ git url-parse "example.com:/repository/path"
+'
+
+test_expect_success 'git url-parse -- username expansion - ssh syntax' '
+ git url-parse "ssh://user@example.com:1234/~user/repository" &&
+ git url-parse "ssh://user@example.com/~user/repository" &&
+ git url-parse "ssh://example.com:1234/~user/repository" &&
+ git url-parse "ssh://example.com/~user/repository"
+'
+
+test_expect_success 'git url-parse -- username expansion - git syntax' '
+ git url-parse "git://example.com:1234/~user/repository" &&
+ git url-parse "git://example.com/~user/repository"
+'
+
+test_expect_success 'git url-parse -- username expansion - scp syntax' '
+ git url-parse "user@example.com:~user/repository" &&
+ git url-parse "example.com:~user/repository"
+'
+
+test_expect_success 'git url-parse -- file urls' '
+ git url-parse "file:///repository/path" &&
+ git url-parse "file://"
+'
+
+test_expect_success 'git url-parse -c scheme -- ssh syntax' '
+ test ssh = "$(git url-parse -c scheme "ssh://user@example.com:1234/repository/path")" &&
+ test ssh = "$(git url-parse -c scheme "ssh://user@example.com/repository/path")" &&
+ test ssh = "$(git url-parse -c scheme "ssh://example.com:1234/repository/path")" &&
+ test ssh = "$(git url-parse -c scheme "ssh://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c scheme -- git syntax' '
+ test git = "$(git url-parse -c scheme "git://example.com:1234/repository/path")" &&
+ test git = "$(git url-parse -c scheme "git://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c scheme -- http syntax' '
+ test https = "$(git url-parse -c scheme "https://example.com:1234/repository/path")" &&
+ test https = "$(git url-parse -c scheme "https://example.com/repository/path")" &&
+ test http = "$(git url-parse -c scheme "http://example.com:1234/repository/path")" &&
+ test http = "$(git url-parse -c scheme "http://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c scheme -- scp syntax' '
+ test ssh = "$(git url-parse -c scheme "user@example.com:/repository/path")" &&
+ test ssh = "$(git url-parse -c scheme "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c user -- ssh syntax' '
+ test user = "$(git url-parse -c user "ssh://user@example.com:1234/repository/path")" &&
+ test user = "$(git url-parse -c user "ssh://user@example.com/repository/path")" &&
+ test "" = "$(git url-parse -c user "ssh://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c user "ssh://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c user -- git syntax' '
+ test "" = "$(git url-parse -c user "git://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c user "git://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c user -- http syntax' '
+ test "" = "$(git url-parse -c user "https://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c user "https://example.com/repository/path")" &&
+ test "" = "$(git url-parse -c user "http://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c user "http://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c user -- scp syntax' '
+ test user = "$(git url-parse -c user "user@example.com:/repository/path")" &&
+ test "" = "$(git url-parse -c user "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c password -- http syntax' '
+ test secret = "$(git url-parse -c password "https://user:secret@example.com:1234/repository/path")" &&
+ test secret = "$(git url-parse -c password "http://user:secret@example.com/repository/path")" &&
+ test "" = "$(git url-parse -c password "https://user@example.com/repository/path")" &&
+ test "" = "$(git url-parse -c password "https://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c host -- ssh syntax' '
+ test example.com = "$(git url-parse -c host "ssh://user@example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "ssh://user@example.com/repository/path")" &&
+ test example.com = "$(git url-parse -c host "ssh://example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "ssh://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c host -- git syntax' '
+ test example.com = "$(git url-parse -c host "git://example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "git://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c host -- http syntax' '
+ test example.com = "$(git url-parse -c host "https://example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "https://example.com/repository/path")" &&
+ test example.com = "$(git url-parse -c host "http://example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "http://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c host -- scp syntax' '
+ test example.com = "$(git url-parse -c host "user@example.com:/repository/path")" &&
+ test example.com = "$(git url-parse -c host "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c port -- ssh syntax' '
+ test 1234 = "$(git url-parse -c port "ssh://user@example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "ssh://user@example.com/repository/path")" &&
+ test 1234 = "$(git url-parse -c port "ssh://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "ssh://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c port -- git syntax' '
+ test 1234 = "$(git url-parse -c port "git://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "git://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c port -- http syntax' '
+ test 1234 = "$(git url-parse -c port "https://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "https://example.com/repository/path")" &&
+ test 1234 = "$(git url-parse -c port "http://example.com:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "http://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c port -- scp syntax' '
+ test "" = "$(git url-parse -c port "user@example.com:/repository/path")" &&
+ test "" = "$(git url-parse -c port "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c path -- ssh syntax' '
+ test "/repository/path" = "$(git url-parse -c path "ssh://user@example.com:1234/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "ssh://user@example.com/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "ssh://example.com:1234/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "ssh://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c path -- git syntax' '
+ test "/repository/path" = "$(git url-parse -c path "git://example.com:1234/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "git://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c path -- http syntax' '
+ test "/repository/path" = "$(git url-parse -c path "https://example.com:1234/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "https://example.com/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "http://example.com:1234/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "http://example.com/repository/path")"
+'
+
+test_expect_success 'git url-parse -c path -- scp syntax' '
+ test "/repository/path" = "$(git url-parse -c path "user@example.com:/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c path -- username expansion - ssh syntax' '
+ test "~user/repository" = "$(git url-parse -c path "ssh://user@example.com:1234/~user/repository")" &&
+ test "~user/repository" = "$(git url-parse -c path "ssh://user@example.com/~user/repository")" &&
+ test "~user/repository" = "$(git url-parse -c path "ssh://example.com:1234/~user/repository")" &&
+ test "~user/repository" = "$(git url-parse -c path "ssh://example.com/~user/repository")"
+'
+
+test_expect_success 'git url-parse -c path -- username expansion - git syntax' '
+ test "~user/repository" = "$(git url-parse -c path "git://example.com:1234/~user/repository")" &&
+ test "~user/repository" = "$(git url-parse -c path "git://example.com/~user/repository")"
+'
+
+test_expect_success 'git url-parse -c path -- username expansion - scp syntax' '
+ test "~user/repository" = "$(git url-parse -c path "user@example.com:~user/repository")" &&
+ test "~user/repository" = "$(git url-parse -c path "example.com:~user/repository")"
+'
+
+test_expect_success 'git url-parse -c path -- username expansion strips query and fragment' '
+ test "~user/repository" = "$(git url-parse -c path "ssh://example.com/~user/repository?query")" &&
+ test "~user/repository" = "$(git url-parse -c path "ssh://example.com/~user/repository#fragment")" &&
+ test "~user/repository" = "$(git url-parse -c path "git://example.com/~user/repository?query")" &&
+ test "~user/repository" = "$(git url-parse -c path "user@example.com:~user/repository?query")"
+'
+
+test_expect_success 'git url-parse -- ssh syntax with IPv6' '
+ git url-parse "ssh://user@[::1]:1234/repository/path" &&
+ git url-parse "ssh://user@[::1]/repository/path" &&
+ git url-parse "ssh://[::1]:1234/repository/path" &&
+ git url-parse "ssh://[::1]/repository/path" &&
+ git url-parse "ssh://[2001:db8::1]/repository/path"
+'
+
+test_expect_success 'git url-parse -- git syntax with IPv6' '
+ git url-parse "git://[::1]:9418/repository/path" &&
+ git url-parse "git://[::1]/repository/path"
+'
+
+test_expect_success 'git url-parse -- http syntax with IPv6' '
+ git url-parse "https://[::1]:1234/repository/path" &&
+ git url-parse "https://[::1]/repository/path" &&
+ git url-parse "http://[2001:db8::1]/repository/path"
+'
+
+test_expect_success 'git url-parse -c host -- IPv6 in URL form' '
+ test "[::1]" = "$(git url-parse -c host "ssh://user@[::1]:1234/repository/path")" &&
+ test "[::1]" = "$(git url-parse -c host "ssh://[::1]/repository/path")" &&
+ test "[2001:db8::1]" = "$(git url-parse -c host "ssh://[2001:db8::1]/repository/path")" &&
+ test "[::1]" = "$(git url-parse -c host "git://[::1]/repository/path")" &&
+ test "[2001:db8::1]" = "$(git url-parse -c host "https://[2001:db8::1]/repository/path")"
+'
+
+test_expect_success 'git url-parse -c port -- IPv6 in URL form' '
+ test 1234 = "$(git url-parse -c port "ssh://user@[::1]:1234/repository/path")" &&
+ test "" = "$(git url-parse -c port "ssh://[::1]/repository/path")" &&
+ test 9418 = "$(git url-parse -c port "git://[::1]:9418/repository/path")"
+'
+
+test_expect_success 'git url-parse -- scp syntax with IPv6' '
+ git url-parse "[::1]:repository/path" &&
+ git url-parse "user@[::1]:repository/path" &&
+ git url-parse "[2001:db8::1]:repo"
+'
+
+test_expect_success 'git url-parse -- scp syntax with bracketed hostname' '
+ git url-parse "[myhost]:src" &&
+ git url-parse "user@[myhost]:src"
+'
+
+test_expect_success 'git url-parse -- scp syntax with bracketed host:port' '
+ git url-parse "[myhost:123]:src" &&
+ git url-parse "user@[myhost:123]:src"
+'
+
+test_expect_success 'git url-parse -c host -- scp+IPv6' '
+ test "[::1]" = "$(git url-parse -c host "[::1]:repository/path")" &&
+ test "[::1]" = "$(git url-parse -c host "user@[::1]:repository/path")" &&
+ test "[2001:db8::1]" = "$(git url-parse -c host "[2001:db8::1]:repo")"
+'
+
+test_expect_success 'git url-parse -c path -- scp+IPv6' '
+ test "/repository/path" = "$(git url-parse -c path "[::1]:/repository/path")" &&
+ test "/repository/path" = "$(git url-parse -c path "[::1]:repository/path")" &&
+ test "/repo" = "$(git url-parse -c path "[2001:db8::1]:repo")"
+'
+
+test_expect_success 'git url-parse -c host,port,path -- scp [host:port]:src' '
+ test myhost = "$(git url-parse -c host "[myhost:123]:src")" &&
+ test 123 = "$(git url-parse -c port "[myhost:123]:src")" &&
+ test "/src" = "$(git url-parse -c path "[myhost:123]:src")"
+'
+
+test_expect_success 'git url-parse -c host,path -- scp [host]:src' '
+ test myhost = "$(git url-parse -c host "[myhost]:src")" &&
+ test "/src" = "$(git url-parse -c path "[myhost]:src")"
+'
+
+test_expect_success 'git url-parse -c user -- scp with user@ and brackets' '
+ test user = "$(git url-parse -c user "user@[::1]:repo")" &&
+ test user = "$(git url-parse -c user "user@[myhost:123]:src")" &&
+ test user = "$(git url-parse -c user "user@[myhost]:src")"
+'
+
+test_expect_success 'git url-parse -- scp+IPv6 with username expansion' '
+ test "~user/repo" = "$(git url-parse -c path "[::1]:~user/repo")" &&
+ test "~user/repo" = "$(git url-parse -c path "user@[::1]:~user/repo")"
+'
+
+test_expect_success 'git url-parse fails on invalid URL' '
+ test_must_fail git url-parse "not a url"
+'
+
+test_expect_success 'git url-parse helpful error for absolute local path' '
+ test_must_fail git url-parse "/abs/path" 2>err &&
+ test_grep "is not a URL" err &&
+ test_grep "file:///abs/path" err
+'
+
+test_expect_success 'git url-parse helpful error for relative local path' '
+ test_must_fail git url-parse "./rel" 2>err &&
+ test_grep "is not a URL" err &&
+ test_grep "absolute path" err
+'
+
+test_expect_success 'git url-parse fails on unknown -c component name' '
+ test_must_fail git url-parse -c bogus "https://example.com/repo"
+'
+
+test_expect_success 'git url-parse fails on URL missing host' '
+ test_must_fail git url-parse "https://"
+'
+
+test_expect_success 'git url-parse with no URL prints usage' '
+ test_must_fail git url-parse 2>err &&
+ test_grep "usage:" err
+'
+
+test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 7/8] doc: describe the url-parse builtin
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
The new url-parse builtin validates git URLs
and optionally extracts their components.
Helped-by: Ghanshyam Thakkar <shyamthakkar001@gmail.com>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
Documentation/git-url-parse.adoc | 80 ++++++++++++++++++++++++++++++++
Documentation/meson.build | 1 +
2 files changed, 81 insertions(+)
create mode 100644 Documentation/git-url-parse.adoc
diff --git a/Documentation/git-url-parse.adoc b/Documentation/git-url-parse.adoc
new file mode 100644
index 0000000000..9d0d93da4a
--- /dev/null
+++ b/Documentation/git-url-parse.adoc
@@ -0,0 +1,80 @@
+git-url-parse(1)
+================
+
+NAME
+----
+git-url-parse - Parse and extract git URL components
+
+SYNOPSIS
+--------
+[synopsis]
+git url-parse [-c <component>] [--] <url>...
+
+DESCRIPTION
+-----------
+
+Git supports many ways to specify URLs, some of them non-standard.
+For example, git supports the scp style [user@]host:[path] format.
+This command eases interoperability with git URLs by enabling the
+parsing and extraction of the components of all git URLs.
+
+Any syntactically valid URL is parsed, even if the scheme is not one
+git supports for fetching or pushing.
+
+OPTIONS
+-------
+
+`-c <component>`::
+`--component <component>`::
+ Extract the _<component>_ component from the given Git URLs.
+ _<component>_ can be one of:
+ `scheme`, `user`, `password`, `host`, `port`, `path`.
+
+OUTPUT
+------
+
+When `--component` is given, the requested component of each URL
+is printed on its own line, in the order the URLs were given. If
+the URL has no such component (for example, a port in a URL that
+does not specify one), an empty line is printed in its place.
+
+When `--component` is not given, no output is produced. The exit
+status is zero if every URL parses successfully and non-zero
+otherwise, allowing the command to be used purely as a validator.
+
+EXAMPLES
+--------
+
+* Print the host name:
++
+------------
+$ git url-parse --component host https://example.com/user/repo
+example.com
+------------
+
+* Print the path:
++
+------------
+$ git url-parse --component path https://example.com/user/repo
+/user/repo
+$ git url-parse --component path example.com:~user/repo
+~user/repo
+$ git url-parse --component path example.com:user/repo
+/user/repo
+------------
+
+* Validate URLs without outputting anything:
++
+------------
+$ git url-parse https://example.com/user/repo example.com:~user/repo
+------------
+
+SEE ALSO
+--------
+linkgit:git-clone[1],
+linkgit:git-fetch[1],
+linkgit:git-config[1]
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Documentation/meson.build b/Documentation/meson.build
index d6365b888b..32c8606a80 100644
--- a/Documentation/meson.build
+++ b/Documentation/meson.build
@@ -155,6 +155,7 @@ manpages = {
'git-update-server-info.adoc' : 1,
'git-upload-archive.adoc' : 1,
'git-upload-pack.adoc' : 1,
+ 'git-url-parse.adoc' : 1,
'git-var.adoc' : 1,
'git-verify-commit.adoc' : 1,
'git-verify-pack.adoc' : 1,
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 6/8] builtin: create url-parse command
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Git commands can accept a rather wide variety of URLs syntaxes.
The range of accepted inputs might expand even more in the future.
This makes the parsing of URL components difficult since standard URL
parsers cannot be used. Extracting the components of a git URL would
require implementing all the schemes that git itself supports, not to
mention tracking its development continuously in case new URL schemes
are added.
The url-parse builtin command is designed to solve this problem
by exposing git's native URL parsing facilities as a plumbing command.
Other programs can then call upon git itself to parse the git URLs
and extract their components. This should be quite useful for scripts.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
.gitignore | 1 +
Makefile | 1 +
builtin.h | 1 +
builtin/url-parse.c | 132 ++++++++++++++++++++++++++++++++++++++++++++
command-list.txt | 1 +
git.c | 1 +
meson.build | 1 +
7 files changed, 138 insertions(+)
create mode 100644 builtin/url-parse.c
diff --git a/.gitignore b/.gitignore
index 24635cf2d6..c5673daa6e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -182,6 +182,7 @@
/git-update-server-info
/git-upload-archive
/git-upload-pack
+/git-url-parse
/git-var
/git-verify-commit
/git-verify-pack
diff --git a/Makefile b/Makefile
index cedc234173..1c757a1aa0 100644
--- a/Makefile
+++ b/Makefile
@@ -1497,6 +1497,7 @@ BUILTIN_OBJS += builtin/update-ref.o
BUILTIN_OBJS += builtin/update-server-info.o
BUILTIN_OBJS += builtin/upload-archive.o
BUILTIN_OBJS += builtin/upload-pack.o
+BUILTIN_OBJS += builtin/url-parse.o
BUILTIN_OBJS += builtin/var.o
BUILTIN_OBJS += builtin/verify-commit.o
BUILTIN_OBJS += builtin/verify-pack.o
diff --git a/builtin.h b/builtin.h
index 235c51f30e..c6f7672991 100644
--- a/builtin.h
+++ b/builtin.h
@@ -271,6 +271,7 @@ int cmd_update_server_info(int argc, const char **argv, const char *prefix, stru
int cmd_upload_archive(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_upload_archive_writer(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_upload_pack(int argc, const char **argv, const char *prefix, struct repository *repo);
+int cmd_url_parse(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_var(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_verify_commit(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_verify_tag(int argc, const char **argv, const char *prefix, struct repository *repo);
diff --git a/builtin/url-parse.c b/builtin/url-parse.c
new file mode 100644
index 0000000000..6c70c131e1
--- /dev/null
+++ b/builtin/url-parse.c
@@ -0,0 +1,132 @@
+#include "builtin.h"
+#include "gettext.h"
+#include "parse-options.h"
+#include "url.h"
+#include "urlmatch.h"
+
+static const char * const builtin_url_parse_usage[] = {
+ N_("git url-parse [-c <component>] [--] <url>..."),
+ NULL
+};
+
+static char *component_arg;
+
+static struct option builtin_url_parse_options[] = {
+ OPT_STRING('c', "component", &component_arg, N_("component"),
+ N_("which URL component to extract")),
+ OPT_END(),
+};
+
+enum url_component {
+ URL_NONE = 0,
+ URL_SCHEME,
+ URL_USER,
+ URL_PASSWORD,
+ URL_HOST,
+ URL_PORT,
+ URL_PATH,
+};
+
+static void parse_or_die(const char *url, struct url_info *info)
+{
+ if (url_is_local_not_ssh(url)) {
+ if (*url == '/')
+ die("'%s' is not a URL; if you meant a local "
+ "repository, use 'file://%s'", url, url);
+ die("'%s' is not a URL; if you meant a local repository, "
+ "use a 'file://' URL with an absolute path", url);
+ }
+ if (!url_parse(url, info))
+ die("invalid git URL '%s': %s", url, info->err);
+}
+
+static enum url_component get_component_or_die(const char *arg)
+{
+ if (!strcmp("path", arg))
+ return URL_PATH;
+ if (!strcmp("host", arg))
+ return URL_HOST;
+ if (!strcmp("scheme", arg))
+ return URL_SCHEME;
+ if (!strcmp("user", arg))
+ return URL_USER;
+ if (!strcmp("password", arg))
+ return URL_PASSWORD;
+ if (!strcmp("port", arg))
+ return URL_PORT;
+ die("invalid git URL component '%s'", arg);
+}
+
+static char *extract_component(enum url_component component,
+ struct url_info *info)
+{
+ size_t offset, length;
+
+ switch (component) {
+ case URL_SCHEME:
+ offset = 0;
+ length = info->scheme_len;
+ break;
+ case URL_USER:
+ offset = info->user_off;
+ length = info->user_len;
+ break;
+ case URL_PASSWORD:
+ offset = info->passwd_off;
+ length = info->passwd_len;
+ break;
+ case URL_HOST:
+ offset = info->host_off;
+ length = info->host_len;
+ break;
+ case URL_PORT:
+ offset = info->port_off;
+ length = info->port_len;
+ break;
+ case URL_PATH:
+ offset = info->path_off;
+ length = info->path_len;
+ break;
+ case URL_NONE:
+ return NULL;
+ }
+
+ return xstrndup(info->url + offset, length);
+}
+
+int cmd_url_parse(int argc,
+ const char **argv,
+ const char *prefix,
+ struct repository *repo UNUSED)
+{
+ struct url_info info;
+ enum url_component selected = URL_NONE;
+ char *extracted;
+ int i;
+
+ argc = parse_options(argc, argv, prefix, builtin_url_parse_options,
+ builtin_url_parse_usage, 0);
+
+ if (argc == 0)
+ usage_with_options(builtin_url_parse_usage,
+ builtin_url_parse_options);
+
+ if (component_arg)
+ selected = get_component_or_die(component_arg);
+
+ for (i = 0; i < argc; i++) {
+ parse_or_die(argv[i], &info);
+
+ if (selected != URL_NONE) {
+ extracted = extract_component(selected, &info);
+ if (extracted) {
+ puts(extracted);
+ free(extracted);
+ }
+ }
+
+ free(info.url);
+ }
+
+ return 0;
+}
diff --git a/command-list.txt b/command-list.txt
index f9005cf459..1ede48186f 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -202,6 +202,7 @@ git-update-ref plumbingmanipulators
git-update-server-info synchingrepositories
git-upload-archive synchelpers
git-upload-pack synchelpers
+git-url-parse purehelpers
git-var plumbinginterrogators
git-verify-commit ancillaryinterrogators
git-verify-pack plumbinginterrogators
diff --git a/git.c b/git.c
index 5a40eab8a2..a073eed931 100644
--- a/git.c
+++ b/git.c
@@ -670,6 +670,7 @@ static struct cmd_struct commands[] = {
{ "upload-archive", cmd_upload_archive, NO_PARSEOPT },
{ "upload-archive--writer", cmd_upload_archive_writer, NO_PARSEOPT },
{ "upload-pack", cmd_upload_pack },
+ { "url-parse", cmd_url_parse },
{ "var", cmd_var, RUN_SETUP_GENTLY | NO_PARSEOPT },
{ "verify-commit", cmd_verify_commit, RUN_SETUP },
{ "verify-pack", cmd_verify_pack },
diff --git a/meson.build b/meson.build
index 11488623bf..dc3cf68ee5 100644
--- a/meson.build
+++ b/meson.build
@@ -686,6 +686,7 @@ builtin_sources = [
'builtin/update-server-info.c',
'builtin/upload-archive.c',
'builtin/upload-pack.c',
+ 'builtin/url-parse.c',
'builtin/var.c',
'builtin/verify-commit.c',
'builtin/verify-pack.c',
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 5/8] urlmatch: define url_parse function
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Define url_parse, a general parsing function that supports all Git URLs
including scp style URLs such as hostname:~user/repo.
It is adapted from the algorithm in connect.c's parse_connect_url
and reuses the shared enum url_scheme and url_get_scheme function
that previous commits made available in url.h. The new parser and
the connect path agree on scheme classification. url_parse has the
same interface as url_normalize and uses the same data structures.
Both functions accept the same URL forms with one deliberate
exception. Bare local paths such as "/abs/path", "./rel"
or "repo" are accepted by parse_connect_url as URL_SCHEME_LOCAL,
but rejected by url_parse because url_normalize requires a URL
with a scheme://host form. A consumer that wants to handle both
URLs and local paths needs to dispatch on url_is_local_not_ssh
before calling url_parse, just as the connect path does internally.
The duplication with parse_connect_url is intentional.
The two functions have different contracts:
- parse_connect_url
Calls die() on an unknown scheme
and returns NUL-terminated host/path
strings for the connect path
- url_parse
Returns NULL on failure while populating
out_info->err, and exposes components
as offset/length pairs into the normalized
URL buffer, matching url_normalize.
Reconciling both is possible, but not in the scope
of the current patch set.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
t/unit-tests/u-urlmatch-normalization.c | 45 +++++++++
urlmatch.c | 127 ++++++++++++++++++++++++
urlmatch.h | 1 +
3 files changed, 173 insertions(+)
diff --git a/t/unit-tests/u-urlmatch-normalization.c b/t/unit-tests/u-urlmatch-normalization.c
index 39f6e1ba26..3595d893a2 100644
--- a/t/unit-tests/u-urlmatch-normalization.c
+++ b/t/unit-tests/u-urlmatch-normalization.c
@@ -245,3 +245,48 @@ void test_urlmatch_normalization__equivalents(void)
compare_normalized_urls("https://@x.y/^/../abc", "httpS://@x.y:0443/abc", 1);
compare_normalized_urls("https://@x.y/^/..", "httpS://@x.y:0443/", 1);
}
+
+static void check_parsed_path(const char *url, const char *expected_path)
+{
+ struct url_info info;
+ char *parsed = url_parse(url, &info);
+ char *path;
+
+ cl_assert(parsed != NULL);
+ path = xstrndup(parsed + info.path_off, info.path_len);
+ cl_assert_equal_s(path, expected_path);
+ free(path);
+ free(parsed);
+}
+
+void test_urlmatch_normalization__parse_scp(void)
+{
+ check_parsed_path("host:path", "/path");
+ check_parsed_path("user@host:path", "/path");
+ check_parsed_path("host:~user/repo", "~user/repo");
+ check_parsed_path("user@host:~user/repo", "~user/repo");
+ check_parsed_path("[host]:src", "/src");
+ check_parsed_path("[host:123]:src", "/src");
+ check_parsed_path("[::1]:repo", "/repo");
+ check_parsed_path("user@[::1]:repo", "/repo");
+}
+
+void test_urlmatch_normalization__parse_url_form(void)
+{
+ check_parsed_path("ssh://host/repo", "/repo");
+ check_parsed_path("ssh://host/~user/repo", "~user/repo");
+ check_parsed_path("git://host:9418/repo", "/repo");
+ check_parsed_path("git://host/~user/repo", "~user/repo");
+ check_parsed_path("ssh://[::1]:1234/repo", "/repo");
+ check_parsed_path("http://[2001:db8::1]/repo", "/repo");
+}
+
+void test_urlmatch_normalization__parse_strips_query_and_fragment(void)
+{
+ check_parsed_path("ssh://host/~user/repo?q", "~user/repo");
+ check_parsed_path("ssh://host/~user/repo#frag", "~user/repo");
+ check_parsed_path("git://host/~user/repo?q", "~user/repo");
+ check_parsed_path("user@host:~user/repo?q", "~user/repo");
+ check_parsed_path("https://host/repo?q", "/repo");
+ check_parsed_path("https://host/repo#frag", "/repo");
+}
diff --git a/urlmatch.c b/urlmatch.c
index eea8300489..bf8cce6de9 100644
--- a/urlmatch.c
+++ b/urlmatch.c
@@ -5,6 +5,7 @@
#include "hex-ll.h"
#include "strbuf.h"
#include "urlmatch.h"
+#include "url.h"
#define URL_ALPHA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
#define URL_DIGIT "0123456789"
@@ -440,6 +441,132 @@ char *url_normalize(const char *url, struct url_info *out_info)
return url_normalize_1(url, out_info, 0);
}
+char *url_parse(const char *url_orig, struct url_info *out_info)
+{
+ struct strbuf url;
+ char *host, *separator;
+ char *detached, *normalized;
+ char *url_decoded;
+ enum url_scheme scheme = URL_SCHEME_LOCAL;
+ struct url_info local_info;
+ struct url_info *info = out_info ? out_info : &local_info;
+ bool scp_syntax = false;
+
+ if (is_url(url_orig))
+ url_decoded = url_decode(url_orig);
+ else
+ url_decoded = xstrdup(url_orig);
+
+ strbuf_init(&url, strlen(url_decoded) + sizeof("ssh://"));
+ strbuf_addstr(&url, url_decoded);
+ free(url_decoded);
+
+ host = strstr(url.buf, "://");
+ if (host) {
+ /*
+ * Temporarily NUL-terminate the scheme name
+ * so we can pass it to url_get_scheme(),
+ * then restore the ':' so the buffer
+ * is intact for url_normalize() below.
+ */
+ char saved = *host;
+ *host = '\0';
+ scheme = url_get_scheme(url.buf);
+ *host = saved;
+ host += 3;
+ } else {
+ if (!url_is_local_not_ssh(url.buf)) {
+ scp_syntax = true;
+ scheme = URL_SCHEME_SSH;
+ strbuf_insertstr(&url, 0, "ssh://");
+ host = url.buf + strlen("ssh://");
+ }
+ }
+
+ /*
+ * Path starts after ':' in scp style SSH URLs.
+ *
+ * The host portion can begin with an optional "user@",
+ * and the host itself can be wrapped in '[' ']' brackets.
+ * The bracket form is git's legacy way of supporting:
+ *
+ * - IPv6 literals: [::1]:repo
+ * - host:port pairs in the short form: [myhost:123]:src
+ * - Plain hostnames that happen to need bracketing: [host]:path
+ *
+ * Treat '[' followed by 0 or 1 inner colons as the host:port
+ * or plain hostname form and strip the brackets so url_normalize
+ * sees host[:port] natively. Two or more inner colons mark an
+ * IPv6 literal: keep the brackets for url_normalize to recognize.
+ *
+ * The scp path separator is the ':' that follows the host part,
+ * and we must skip over user@ and any '[...]' before searching.
+ */
+ if (scp_syntax) {
+ char *user_at;
+ char *host_start;
+ char *bracket_end;
+
+ user_at = strchr(host, '@');
+ host_start = user_at ? user_at + 1 : host;
+
+ if (*host_start == '[') {
+ char *p;
+ int inner_colons;
+
+ bracket_end = strchr(host_start, ']');
+ inner_colons = 0;
+ for (p = host_start + 1; bracket_end && p < bracket_end; p++)
+ if (*p == ':')
+ inner_colons++;
+
+ if (bracket_end && inner_colons <= 1) {
+ size_t close_off = bracket_end - url.buf;
+ size_t open_off = host_start - url.buf;
+ strbuf_remove(&url, close_off, 1);
+ strbuf_remove(&url, open_off, 1);
+ separator = url.buf + close_off - 1;
+ } else if (bracket_end) {
+ separator = strchr(bracket_end + 1, ':');
+ } else {
+ separator = strchr(host_start, ':');
+ }
+ } else {
+ separator = strchr(host_start, ':');
+ }
+
+ if (separator) {
+ if (separator[1] == '/')
+ strbuf_remove(&url, separator - url.buf, 1);
+ else
+ *separator = '/';
+ }
+ }
+
+ detached = strbuf_detach(&url, NULL);
+ normalized = url_normalize(detached, info);
+ free(detached);
+
+ if (!normalized)
+ return NULL;
+
+ /*
+ * Point path to ~ for URLs like this:
+ *
+ * ssh://host.xz/~user/repo
+ * git://host.xz/~user/repo
+ * host.xz:~user/repo
+ */
+ if (scheme == URL_SCHEME_GIT || scheme == URL_SCHEME_SSH) {
+ if (normalized[info->path_off + 1] == '~') {
+ info->path_off++;
+ info->path_len--;
+ }
+ }
+
+ return normalized;
+}
+
static size_t url_match_prefix(const char *url,
const char *url_prefix,
size_t url_prefix_len)
diff --git a/urlmatch.h b/urlmatch.h
index 5ba85cea13..6b3ce42858 100644
--- a/urlmatch.h
+++ b/urlmatch.h
@@ -35,6 +35,7 @@ struct url_info {
};
char *url_normalize(const char *, struct url_info *);
+char *url_parse(const char *, struct url_info *);
struct urlmatch_item {
size_t hostmatch_len;
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 4/8] url: return URL_SCHEME_UNKNOWN instead of dying
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Enumerate a URL_SCHEME_UNKNOWN result with value 0.
Have url_get_scheme() return it for unrecognized
schemes instead of calling die() itself.
Move the die() call to parse_connect_url()
where url_get_scheme() is used.
This lets url_get_scheme() be used from contexts
that need to identify a URL's scheme without aborting
the program. For example, a future plumbing command
that validates URLs.
No external behavior change. parse_connect_url() still dies
with the same translated message for unrecognized schemes.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 2 ++
url.c | 3 +--
url.h | 7 ++++---
3 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/connect.c b/connect.c
index 1ac7acc6e8..73d7a6b8d0 100644
--- a/connect.c
+++ b/connect.c
@@ -1071,6 +1071,8 @@ static enum url_scheme parse_connect_url(const char *url_orig, char **ret_host,
if (host) {
*host = '\0';
scheme = url_get_scheme(url);
+ if (scheme == URL_SCHEME_UNKNOWN)
+ die(_("protocol '%s' is not supported"), url);
host += 3;
} else {
host = url;
diff --git a/url.c b/url.c
index 300acf98fe..a59818278f 100644
--- a/url.c
+++ b/url.c
@@ -1,5 +1,4 @@
#include "git-compat-util.h"
-#include "gettext.h"
#include "hex-ll.h"
#include "strbuf.h"
#include "url.h"
@@ -154,5 +153,5 @@ enum url_scheme url_get_scheme(const char *name)
return URL_SCHEME_SSH;
if (!strcmp(name, "file"))
return URL_SCHEME_FILE;
- die(_("protocol '%s' is not supported"), name);
+ return URL_SCHEME_UNKNOWN;
}
diff --git a/url.h b/url.h
index 24c8cd91d0..7289523605 100644
--- a/url.h
+++ b/url.h
@@ -24,15 +24,16 @@ void str_end_url_with_slash(const char *url, char **dest);
int url_is_local_not_ssh(const char *url);
enum url_scheme {
- URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_UNKNOWN = 0,
+ URL_SCHEME_LOCAL,
URL_SCHEME_FILE,
URL_SCHEME_SSH,
URL_SCHEME_GIT,
};
/*
- * Identify the URL scheme by name. Dies if the name does not match
- * any scheme that Git knows about.
+ * Identify the URL scheme by name. Returns URL_SCHEME_UNKNOWN
+ * if the name does not match any scheme that Git knows about.
*/
enum url_scheme url_get_scheme(const char *name);
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 3/8] url: move scheme detection to URL header/source
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Move enum url_scheme and url_get_scheme()
from connect.c to url.h and url.c
so that other code can identify
a URL's scheme without depending
on connect.c.
No behavior change. url_get_scheme() still dies
on an unrecognized scheme name, with the same
translated message as before.
scheme_name() stays in connect.c
because it has no other callers.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 22 ----------------------
url.c | 16 ++++++++++++++++
url.h | 13 +++++++++++++
3 files changed, 29 insertions(+), 22 deletions(-)
diff --git a/connect.c b/connect.c
index cb145de30e..1ac7acc6e8 100644
--- a/connect.c
+++ b/connect.c
@@ -700,13 +700,6 @@ int server_supports(const char *feature)
return !!server_feature_value(feature, NULL);
}
-enum url_scheme {
- URL_SCHEME_LOCAL = 1,
- URL_SCHEME_FILE,
- URL_SCHEME_SSH,
- URL_SCHEME_GIT
-};
-
static const char *url_scheme_name(enum url_scheme scheme)
{
switch (scheme) {
@@ -722,21 +715,6 @@ static const char *url_scheme_name(enum url_scheme scheme)
}
}
-static enum url_scheme url_get_scheme(const char *name)
-{
- if (!strcmp(name, "ssh"))
- return URL_SCHEME_SSH;
- if (!strcmp(name, "git"))
- return URL_SCHEME_GIT;
- if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
- return URL_SCHEME_SSH;
- if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
- return URL_SCHEME_SSH;
- if (!strcmp(name, "file"))
- return URL_SCHEME_FILE;
- die(_("protocol '%s' is not supported"), name);
-}
-
static char *host_end(char **hoststart, int removebrackets)
{
char *host = *hoststart;
diff --git a/url.c b/url.c
index 057576042a..300acf98fe 100644
--- a/url.c
+++ b/url.c
@@ -1,4 +1,5 @@
#include "git-compat-util.h"
+#include "gettext.h"
#include "hex-ll.h"
#include "strbuf.h"
#include "url.h"
@@ -140,3 +141,18 @@ int url_is_local_not_ssh(const char *url)
return !colon || (slash && slash < colon) ||
(has_dos_drive_prefix(url) && is_valid_path(url));
}
+
+enum url_scheme url_get_scheme(const char *name)
+{
+ if (!strcmp(name, "ssh"))
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "git"))
+ return URL_SCHEME_GIT;
+ if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
+ return URL_SCHEME_SSH;
+ if (!strcmp(name, "file"))
+ return URL_SCHEME_FILE;
+ die(_("protocol '%s' is not supported"), name);
+}
diff --git a/url.h b/url.h
index 39d621312f..24c8cd91d0 100644
--- a/url.h
+++ b/url.h
@@ -23,6 +23,19 @@ void str_end_url_with_slash(const char *url, char **dest);
int url_is_local_not_ssh(const char *url);
+enum url_scheme {
+ URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_FILE,
+ URL_SCHEME_SSH,
+ URL_SCHEME_GIT,
+};
+
+/*
+ * Identify the URL scheme by name. Dies if the name does not match
+ * any scheme that Git knows about.
+ */
+enum url_scheme url_get_scheme(const char *name);
+
/*
* The set of unreserved characters as per STD66 (RFC3986) is
* '[A-Za-z0-9-._~]'. These characters are safe to appear in URI
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 2/8] url: move url_is_local_not_ssh to url.h
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
Move url_is_local_not_ssh from connect.c/connect.h
to url.c/url.h so that the new url_parse function
in urlmatch.c, and any future code that needs to
distinguish a local path from an scp style SSH URL,
can reuse the heuristic without depending on connect.c.
No behavior change.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 8 --------
connect.h | 1 -
remote.c | 1 +
url.c | 8 ++++++++
url.h | 2 ++
5 files changed, 11 insertions(+), 9 deletions(-)
diff --git a/connect.c b/connect.c
index 46da89905e..cb145de30e 100644
--- a/connect.c
+++ b/connect.c
@@ -707,14 +707,6 @@ enum url_scheme {
URL_SCHEME_GIT
};
-int url_is_local_not_ssh(const char *url)
-{
- const char *colon = strchr(url, ':');
- const char *slash = strchr(url, '/');
- return !colon || (slash && slash < colon) ||
- (has_dos_drive_prefix(url) && is_valid_path(url));
-}
-
static const char *url_scheme_name(enum url_scheme scheme)
{
switch (scheme) {
diff --git a/connect.h b/connect.h
index 1645126c17..8d84f6656b 100644
--- a/connect.h
+++ b/connect.h
@@ -13,7 +13,6 @@ int git_connection_is_socket(struct child_process *conn);
int server_supports(const char *feature);
int parse_feature_request(const char *features, const char *feature);
const char *server_feature_value(const char *feature, size_t *len_ret);
-int url_is_local_not_ssh(const char *url);
struct packet_reader;
enum protocol_version discover_version(struct packet_reader *reader);
diff --git a/remote.c b/remote.c
index a664cd166a..24a8118d25 100644
--- a/remote.c
+++ b/remote.c
@@ -8,6 +8,7 @@
#include "gettext.h"
#include "hex.h"
#include "remote.h"
+#include "url.h"
#include "urlmatch.h"
#include "refs.h"
#include "refspec.h"
diff --git a/url.c b/url.c
index 3ca5987e90..057576042a 100644
--- a/url.c
+++ b/url.c
@@ -132,3 +132,11 @@ void str_end_url_with_slash(const char *url, char **dest)
free(*dest);
*dest = strbuf_detach(&buf, NULL);
}
+
+int url_is_local_not_ssh(const char *url)
+{
+ const char *colon = strchr(url, ':');
+ const char *slash = strchr(url, '/');
+ return !colon || (slash && slash < colon) ||
+ (has_dos_drive_prefix(url) && is_valid_path(url));
+}
diff --git a/url.h b/url.h
index cd9140e994..39d621312f 100644
--- a/url.h
+++ b/url.h
@@ -21,6 +21,8 @@ char *url_decode_parameter_value(const char **query);
void end_url_with_slash(struct strbuf *buf, const char *url);
void str_end_url_with_slash(const char *url, char **dest);
+int url_is_local_not_ssh(const char *url);
+
/*
* The set of unreserved characters as per STD66 (RFC3986) is
* '[A-Za-z0-9-._~]'. These characters are safe to appear in URI
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 1/8] connect: rename enum protocol to url_scheme
From: Matheus Afonso Martins Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git
Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira,
Matheus Afonso Martins Moreira
In-Reply-To: <pull.1715.v2.git.git.1777677310.gitgitgadget@gmail.com>
From: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
RFC 1738 names the part of a URL before the colon a "scheme".
connect.c calls it "protocol", which is more generic
and collides with the unrelated enum protocol_version.
Rename:
enum protocol -> enum url_scheme
PROTO_* -> URL_SCHEME_*
prot_name -> url_scheme_name
get_protocol -> url_get_scheme
The local variables in parse_connect_url and git_connect
are renamed accordingly, from protocol to scheme.
No behavior change. The user-visible diagnostics
and translated error messages are preserved:
"Diag: protocol=..."
"protocol '%s' is not supported"
"unknown protocol"
This rename also prepares for moving the scheme-detection functions
to a shared header so that a future plumbing command can parse URLs
using the same logic as the connect path.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
---
connect.c | 68 +++++++++++++++++++++++++++----------------------------
1 file changed, 34 insertions(+), 34 deletions(-)
diff --git a/connect.c b/connect.c
index fcd35c5539..46da89905e 100644
--- a/connect.c
+++ b/connect.c
@@ -700,11 +700,11 @@ int server_supports(const char *feature)
return !!server_feature_value(feature, NULL);
}
-enum protocol {
- PROTO_LOCAL = 1,
- PROTO_FILE,
- PROTO_SSH,
- PROTO_GIT
+enum url_scheme {
+ URL_SCHEME_LOCAL = 1,
+ URL_SCHEME_FILE,
+ URL_SCHEME_SSH,
+ URL_SCHEME_GIT
};
int url_is_local_not_ssh(const char *url)
@@ -715,33 +715,33 @@ int url_is_local_not_ssh(const char *url)
(has_dos_drive_prefix(url) && is_valid_path(url));
}
-static const char *prot_name(enum protocol protocol)
+static const char *url_scheme_name(enum url_scheme scheme)
{
- switch (protocol) {
- case PROTO_LOCAL:
- case PROTO_FILE:
+ switch (scheme) {
+ case URL_SCHEME_LOCAL:
+ case URL_SCHEME_FILE:
return "file";
- case PROTO_SSH:
+ case URL_SCHEME_SSH:
return "ssh";
- case PROTO_GIT:
+ case URL_SCHEME_GIT:
return "git";
default:
return "unknown protocol";
}
}
-static enum protocol get_protocol(const char *name)
+static enum url_scheme url_get_scheme(const char *name)
{
if (!strcmp(name, "ssh"))
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "git"))
- return PROTO_GIT;
+ return URL_SCHEME_GIT;
if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
- return PROTO_SSH;
+ return URL_SCHEME_SSH;
if (!strcmp(name, "file"))
- return PROTO_FILE;
+ return URL_SCHEME_FILE;
die(_("protocol '%s' is not supported"), name);
}
@@ -1083,14 +1083,14 @@ static char *get_port(char *host)
* Extract protocol and relevant parts from the specified connection URL.
* The caller must free() the returned strings.
*/
-static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
- char **ret_path)
+static enum url_scheme parse_connect_url(const char *url_orig, char **ret_host,
+ char **ret_path)
{
char *url;
char *host, *path;
char *end;
int separator = '/';
- enum protocol protocol = PROTO_LOCAL;
+ enum url_scheme scheme = URL_SCHEME_LOCAL;
if (is_url(url_orig))
url = url_decode(url_orig);
@@ -1100,12 +1100,12 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
host = strstr(url, "://");
if (host) {
*host = '\0';
- protocol = get_protocol(url);
+ scheme = url_get_scheme(url);
host += 3;
} else {
host = url;
if (!url_is_local_not_ssh(url)) {
- protocol = PROTO_SSH;
+ scheme = URL_SCHEME_SSH;
separator = ':';
}
}
@@ -1116,13 +1116,13 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
*/
end = host_end(&host, 0);
- if (protocol == PROTO_LOCAL)
+ if (scheme == URL_SCHEME_LOCAL)
path = end;
- else if (protocol == PROTO_FILE && *host != '/' &&
+ else if (scheme == URL_SCHEME_FILE && *host != '/' &&
!has_dos_drive_prefix(host) &&
offset_1st_component(host - 2) > 1)
path = host - 2; /* include the leading "//" */
- else if (protocol == PROTO_FILE && has_dos_drive_prefix(end))
+ else if (scheme == URL_SCHEME_FILE && has_dos_drive_prefix(end))
path = end; /* "file://$(pwd)" may be "file://C:/projects/repo" */
else
path = strchr(end, separator);
@@ -1138,7 +1138,7 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
end = path; /* Need to \0 terminate host here */
if (separator == ':')
path++; /* path starts after ':' */
- if (protocol == PROTO_GIT || protocol == PROTO_SSH) {
+ if (scheme == URL_SCHEME_GIT || scheme == URL_SCHEME_SSH) {
if (path[1] == '~')
path++;
}
@@ -1149,7 +1149,7 @@ static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
*ret_host = xstrdup(host);
*ret_path = path;
free(url);
- return protocol;
+ return scheme;
}
static const char *get_ssh_command(void)
@@ -1434,7 +1434,7 @@ struct child_process *git_connect(int fd[2], const char *url,
{
char *hostandport, *path;
struct child_process *conn;
- enum protocol protocol;
+ enum url_scheme scheme;
enum protocol_version version = get_protocol_version_config();
/*
@@ -1451,14 +1451,14 @@ struct child_process *git_connect(int fd[2], const char *url,
*/
signal(SIGCHLD, SIG_DFL);
- protocol = parse_connect_url(url, &hostandport, &path);
- if ((flags & CONNECT_DIAG_URL) && (protocol != PROTO_SSH)) {
+ scheme = parse_connect_url(url, &hostandport, &path);
+ if ((flags & CONNECT_DIAG_URL) && (scheme != URL_SCHEME_SSH)) {
printf("Diag: url=%s\n", url ? url : "NULL");
- printf("Diag: protocol=%s\n", prot_name(protocol));
+ printf("Diag: protocol=%s\n", url_scheme_name(scheme));
printf("Diag: hostandport=%s\n", hostandport ? hostandport : "NULL");
printf("Diag: path=%s\n", path ? path : "NULL");
conn = NULL;
- } else if (protocol == PROTO_GIT) {
+ } else if (scheme == URL_SCHEME_GIT) {
conn = git_connect_git(fd, hostandport, path, prog, version, flags);
conn->trace2_child_class = "transport/git";
} else {
@@ -1481,7 +1481,7 @@ struct child_process *git_connect(int fd[2], const char *url,
conn->use_shell = 1;
conn->in = conn->out = -1;
- if (protocol == PROTO_SSH) {
+ if (scheme == URL_SCHEME_SSH) {
char *ssh_host = hostandport;
const char *port = NULL;
transport_check_allowed("ssh");
@@ -1492,7 +1492,7 @@ struct child_process *git_connect(int fd[2], const char *url,
if (flags & CONNECT_DIAG_URL) {
printf("Diag: url=%s\n", url ? url : "NULL");
- printf("Diag: protocol=%s\n", prot_name(protocol));
+ printf("Diag: protocol=%s\n", url_scheme_name(scheme));
printf("Diag: userandhost=%s\n", ssh_host ? ssh_host : "NULL");
printf("Diag: port=%s\n", port ? port : "NONE");
printf("Diag: path=%s\n", path ? path : "NULL");
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 0/8] builtin: implement, document and test url-parse
From: Matheus Moreira via GitGitGadget @ 2026-05-01 23:15 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen, Ghanshyam Thakkar, Matheus Moreira
In-Reply-To: <pull.1715.git.git.1714343461.gitgitgadget@gmail.com>
This series adds git url-parse, a plumbing builtin for inspecting git URLs.
Git accepts a wider variety of URL forms than any standard parser handles.
The supported forms include RFC URLs, file:// URLs, scp-style
[user@]host:path for SSH, and IPv6 in brackets. Tools wanting to reason
about them have historically had to reimplement git's parsing or shell out
indirectly. With git url-parse, scripts can ask git directly: validate a
URL, extract a component (scheme, user, host, port, path, password), or
both.
The series consists of eight commits.
The first four are preparatory. They rename enum protocol to enum url_scheme
for RFC alignment, move url_is_local_not_ssh and the scheme-detection
routines from connect.c to url.h/url.c, and stop url_get_scheme from dying
on unknown schemes so other parsers can handle unknowns gracefully.
The fifth commit defines the new parser, url_parse, in urlmatch.c. It is
adapted from parse_connect_url and uses the same data structures as
url_normalize. The parser returns NULL on failure with err populated, and
exposes URL components as offset/length pairs into the normalized URL
buffer.
The sixth commit adds the user-facing command, with a helpful error when the
input looks like a local path rather than a URL.
The last two commits are documentation (a manpage) and 53 tests covering URL
form, scp form, IPv6 in URL and scp forms, bracket forms, username
expansion, query/fragment stripping, the local-path error, and
validation-only mode.
Several choices in this series are judgment calls. Happy to amend or follow
up on any of them.
The component name is scheme, not protocol. RFC 1738/3986 calls them
schemes. The series renames enum protocol to enum url_scheme internally, and
the user-facing component name follows the same direction. I considered
accepting both as aliases but decided against the precedent for a new
command. If you would rather see protocol, or both protocol and scheme, that
is easy to change.
Local paths are deliberately not URLs. parse_connect_url accepts bare paths
like /abs/path or ./rel as URL_SCHEME_LOCAL. url_parse rejects them, since
url_normalize requires a scheme://host form, and silent conversion to
file:// has no good answer for relative or tilde forms. The builtin emits a
helpful error suggesting the explicit file:// form. If full git clone parity
is preferred (bare paths accepted via auto-conversion or a new flag), that
could be added.
Absent and empty components are conflated in output. --component user
http://host/ and --component user http://@host/ both produce empty lines.
The underlying struct url_info preserves the distinction: *_off == 0 vs
*_off != 0 with *_len == 0. A future option can expose it without breaking
change. Can amend this patch set if necessary.
Changes since v1:
* Bug fix: ~user paths with a query string or fragment were leaking the ?
or # into the path output. The ~user-skip logic in url_parse previously
ran only for file://. It now runs for git/ssh/scp URLs as well, matching
what parse_connect_url does and what users expect.
* Helpful error for local paths instead of the cryptic "invalid URL scheme
name or missing '://' suffix".
* -c protocol renamed to -c scheme for consistency with the internal rename
and the RFC.
* Documented the deliberate divergence from parse_connect_url (local paths
and unknown schemes) in the urlmatch commit message.
* Doc and command-list polish: purehelpers category, asciidoc placeholder
convention, [synopsis] form.
* Original micro commit style staged buildup of the builtin collapsed to a
single self-contained commit. The rest of the series is unchanged in
shape.
Matheus Afonso Martins Moreira (8):
connect: rename enum protocol to url_scheme
url: move url_is_local_not_ssh to url.h
url: move scheme detection to URL header/source
url: return URL_SCHEME_UNKNOWN instead of dying
urlmatch: define url_parse function
builtin: create url-parse command
doc: describe the url-parse builtin
t9904: add tests for the new url-parse builtin
.gitignore | 1 +
Documentation/git-url-parse.adoc | 80 ++++++
Documentation/meson.build | 1 +
Makefile | 1 +
builtin.h | 1 +
builtin/url-parse.c | 132 ++++++++++
command-list.txt | 1 +
connect.c | 78 ++----
connect.h | 1 -
git.c | 1 +
meson.build | 1 +
remote.c | 1 +
t/meson.build | 1 +
t/t9904-url-parse.sh | 319 ++++++++++++++++++++++++
t/unit-tests/u-urlmatch-normalization.c | 45 ++++
url.c | 23 ++
url.h | 16 ++
urlmatch.c | 127 ++++++++++
urlmatch.h | 1 +
19 files changed, 777 insertions(+), 54 deletions(-)
create mode 100644 Documentation/git-url-parse.adoc
create mode 100644 builtin/url-parse.c
create mode 100755 t/t9904-url-parse.sh
base-commit: 94f057755b7941b321fd11fec1b2e3ca5313a4e0
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1715%2Fmatheusmoreira%2Furl-parse-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1715/matheusmoreira/url-parse-v2
Pull-Request: https://github.com/git/git/pull/1715
Range-diff vs v1:
-: ---------- > 1: 38f797362d connect: rename enum protocol to url_scheme
1: 42eb0cbf68 ! 2: a4153e1d24 url: move helper function to URL header and source
@@ Metadata
Author: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
## Commit message ##
- url: move helper function to URL header and source
+ url: move url_is_local_not_ssh to url.h
- It will be used in more places so it should be placed in url.h.
+ Move url_is_local_not_ssh from connect.c/connect.h
+ to url.c/url.h so that the new url_parse function
+ in urlmatch.c, and any future code that needs to
+ distinguish a local path from an scp style SSH URL,
+ can reuse the heuristic without depending on connect.c.
+
+ No behavior change.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
## connect.c ##
-@@ connect.c: enum protocol {
- PROTO_GIT
+@@ connect.c: enum url_scheme {
+ URL_SCHEME_GIT
};
-int url_is_local_not_ssh(const char *url)
@@ connect.c: enum protocol {
- (has_dos_drive_prefix(url) && is_valid_path(url));
-}
-
- static const char *prot_name(enum protocol protocol)
+ static const char *url_scheme_name(enum url_scheme scheme)
{
- switch (protocol) {
+ switch (scheme) {
## connect.h ##
@@ connect.h: int git_connection_is_socket(struct child_process *conn);
@@ url.h: char *url_decode_parameter_value(const char **query);
+int url_is_local_not_ssh(const char *url);
+
- #endif /* URL_H */
+ /*
+ * The set of unreserved characters as per STD66 (RFC3986) is
+ * '[A-Za-z0-9-._~]'. These characters are safe to appear in URI
-: ---------- > 3: e584fb03f3 url: move scheme detection to URL header/source
-: ---------- > 4: 7381704c38 url: return URL_SCHEME_UNKNOWN instead of dying
2: 13b81b8aa0 ! 5: 89932a70f3 urlmatch: define url_parse function
@@ Metadata
## Commit message ##
urlmatch: define url_parse function
- Define general parsing function that supports all Git URLs
+ Define url_parse, a general parsing function that supports all Git URLs
including scp style URLs such as hostname:~user/repo.
- Has the same interface as the URL normalization function
- and uses the same data structures, facilitating its use.
- It's adapted from the algorithm used to process URLs in connect.c,
- so it should support the same inputs.
+
+ It is adapted from the algorithm in connect.c's parse_connect_url
+ and reuses the shared enum url_scheme and url_get_scheme function
+ that previous commits made available in url.h. The new parser and
+ the connect path agree on scheme classification. url_parse has the
+ same interface as url_normalize and uses the same data structures.
+
+ Both functions accept the same URL forms with one deliberate
+ exception. Bare local paths such as "/abs/path", "./rel"
+ or "repo" are accepted by parse_connect_url as URL_SCHEME_LOCAL,
+ but rejected by url_parse because url_normalize requires a URL
+ with a scheme://host form. A consumer that wants to handle both
+ URLs and local paths needs to dispatch on url_is_local_not_ssh
+ before calling url_parse, just as the connect path does internally.
+
+ The duplication with parse_connect_url is intentional.
+ The two functions have different contracts:
+
+ - parse_connect_url
+
+ Calls die() on an unknown scheme
+ and returns NUL-terminated host/path
+ strings for the connect path
+
+ - url_parse
+
+ Returns NULL on failure while populating
+ out_info->err, and exposes components
+ as offset/length pairs into the normalized
+ URL buffer, matching url_normalize.
+
+ Reconciling both is possible, but not in the scope
+ of the current patch set.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
+ ## t/unit-tests/u-urlmatch-normalization.c ##
+@@ t/unit-tests/u-urlmatch-normalization.c: void test_urlmatch_normalization__equivalents(void)
+ compare_normalized_urls("https://@x.y/^/../abc", "httpS://@x.y:0443/abc", 1);
+ compare_normalized_urls("https://@x.y/^/..", "httpS://@x.y:0443/", 1);
+ }
++
++static void check_parsed_path(const char *url, const char *expected_path)
++{
++ struct url_info info;
++ char *parsed = url_parse(url, &info);
++ char *path;
++
++ cl_assert(parsed != NULL);
++ path = xstrndup(parsed + info.path_off, info.path_len);
++ cl_assert_equal_s(path, expected_path);
++ free(path);
++ free(parsed);
++}
++
++void test_urlmatch_normalization__parse_scp(void)
++{
++ check_parsed_path("host:path", "/path");
++ check_parsed_path("user@host:path", "/path");
++ check_parsed_path("host:~user/repo", "~user/repo");
++ check_parsed_path("user@host:~user/repo", "~user/repo");
++ check_parsed_path("[host]:src", "/src");
++ check_parsed_path("[host:123]:src", "/src");
++ check_parsed_path("[::1]:repo", "/repo");
++ check_parsed_path("user@[::1]:repo", "/repo");
++}
++
++void test_urlmatch_normalization__parse_url_form(void)
++{
++ check_parsed_path("ssh://host/repo", "/repo");
++ check_parsed_path("ssh://host/~user/repo", "~user/repo");
++ check_parsed_path("git://host:9418/repo", "/repo");
++ check_parsed_path("git://host/~user/repo", "~user/repo");
++ check_parsed_path("ssh://[::1]:1234/repo", "/repo");
++ check_parsed_path("http://[2001:db8::1]/repo", "/repo");
++}
++
++void test_urlmatch_normalization__parse_strips_query_and_fragment(void)
++{
++ check_parsed_path("ssh://host/~user/repo?q", "~user/repo");
++ check_parsed_path("ssh://host/~user/repo#frag", "~user/repo");
++ check_parsed_path("git://host/~user/repo?q", "~user/repo");
++ check_parsed_path("user@host:~user/repo?q", "~user/repo");
++ check_parsed_path("https://host/repo?q", "/repo");
++ check_parsed_path("https://host/repo#frag", "/repo");
++}
+
## urlmatch.c ##
@@
#include "hex-ll.h"
@@ urlmatch.c: char *url_normalize(const char *url, struct url_info *out_info)
return url_normalize_1(url, out_info, 0);
}
-+enum protocol {
-+ PROTO_UNKNOWN = 0,
-+ PROTO_LOCAL,
-+ PROTO_FILE,
-+ PROTO_SSH,
-+ PROTO_GIT,
-+};
-+
-+static enum protocol url_get_protocol(const char *name, size_t n)
-+{
-+ if (!strncmp(name, "ssh", n))
-+ return PROTO_SSH;
-+ if (!strncmp(name, "git", n))
-+ return PROTO_GIT;
-+ if (!strncmp(name, "git+ssh", n)) /* deprecated - do not use */
-+ return PROTO_SSH;
-+ if (!strncmp(name, "ssh+git", n)) /* deprecated - do not use */
-+ return PROTO_SSH;
-+ if (!strncmp(name, "file", n))
-+ return PROTO_FILE;
-+ return PROTO_UNKNOWN;
-+}
-+
+char *url_parse(const char *url_orig, struct url_info *out_info)
+{
+ struct strbuf url;
+ char *host, *separator;
+ char *detached, *normalized;
-+ enum protocol protocol = PROTO_LOCAL;
++ char *url_decoded;
++ enum url_scheme scheme = URL_SCHEME_LOCAL;
+ struct url_info local_info;
-+ struct url_info *info = out_info? out_info : &local_info;
++ struct url_info *info = out_info ? out_info : &local_info;
+ bool scp_syntax = false;
+
-+ if (is_url(url_orig)) {
-+ url_orig = url_decode(url_orig);
-+ } else {
-+ url_orig = xstrdup(url_orig);
-+ }
++ if (is_url(url_orig))
++ url_decoded = url_decode(url_orig);
++ else
++ url_decoded = xstrdup(url_orig);
+
-+ strbuf_init(&url, strlen(url_orig) + sizeof("ssh://"));
-+ strbuf_addstr(&url, url_orig);
++ strbuf_init(&url, strlen(url_decoded) + sizeof("ssh://"));
++ strbuf_addstr(&url, url_decoded);
++ free(url_decoded);
+
+ host = strstr(url.buf, "://");
+ if (host) {
-+ protocol = url_get_protocol(url.buf, host - url.buf);
++ /*
++ * Temporarily NUL-terminate the scheme name
++ * so we can pass it to url_get_scheme(),
++ * then restore the ':' so the buffer
++ * is intact for url_normalize() below.
++ */
++ char saved = *host;
++ *host = '\0';
++ scheme = url_get_scheme(url.buf);
++ *host = saved;
+ host += 3;
+ } else {
+ if (!url_is_local_not_ssh(url.buf)) {
+ scp_syntax = true;
-+ protocol = PROTO_SSH;
++ scheme = URL_SCHEME_SSH;
+ strbuf_insertstr(&url, 0, "ssh://");
-+ host = url.buf + 6;
++ host = url.buf + strlen("ssh://");
+ }
+ }
+
-+ /* path starts after ':' in scp style SSH URLs */
++ /*
++ * Path starts after ':' in scp style SSH URLs.
++ *
++ * The host portion can begin with an optional "user@",
++ * and the host itself can be wrapped in '[' ']' brackets.
++ * The bracket form is git's legacy way of supporting:
++ *
++ * - IPv6 literals: [::1]:repo
++ * - host:port pairs in the short form: [myhost:123]:src
++ * - Plain hostnames that happen to need bracketing: [host]:path
++ *
++ * Treat '[' followed by 0 or 1 inner colons as the host:port
++ * or plain hostname form and strip the brackets so url_normalize
++ * sees host[:port] natively. Two or more inner colons mark an
++ * IPv6 literal: keep the brackets for url_normalize to recognize.
++ *
++ * The scp path separator is the ':' that follows the host part,
++ * and we must skip over user@ and any '[...]' before searching.
++ */
+ if (scp_syntax) {
-+ separator = strchr(host, ':');
++ char *user_at;
++ char *host_start;
++ char *bracket_end;
++
++ user_at = strchr(host, '@');
++ host_start = user_at ? user_at + 1 : host;
++
++ if (*host_start == '[') {
++ char *p;
++ int inner_colons;
++
++ bracket_end = strchr(host_start, ']');
++ inner_colons = 0;
++ for (p = host_start + 1; bracket_end && p < bracket_end; p++)
++ if (*p == ':')
++ inner_colons++;
++
++ if (bracket_end && inner_colons <= 1) {
++ size_t close_off = bracket_end - url.buf;
++ size_t open_off = host_start - url.buf;
++ strbuf_remove(&url, close_off, 1);
++ strbuf_remove(&url, open_off, 1);
++ separator = url.buf + close_off - 1;
++ } else if (bracket_end) {
++ separator = strchr(bracket_end + 1, ':');
++ } else {
++ separator = strchr(host_start, ':');
++ }
++ } else {
++ separator = strchr(host_start, ':');
++ }
++
+ if (separator) {
+ if (separator[1] == '/')
+ strbuf_remove(&url, separator - url.buf, 1);
@@ urlmatch.c: char *url_normalize(const char *url, struct url_info *out_info)
+ normalized = url_normalize(detached, info);
+ free(detached);
+
-+ if (!normalized) {
++ if (!normalized)
+ return NULL;
-+ }
+
-+ /* point path to ~ for URL's like this:
++ /*
++ * Point path to ~ for URLs like this:
+ *
+ * ssh://host.xz/~user/repo
+ * git://host.xz/~user/repo
+ * host.xz:~user/repo
-+ *
+ */
-+ if (protocol == PROTO_GIT || protocol == PROTO_SSH) {
-+ if (normalized[info->path_off + 1] == '~')
++ if (scheme == URL_SCHEME_GIT || scheme == URL_SCHEME_SSH) {
++ if (normalized[info->path_off + 1] == '~') {
+ info->path_off++;
++ info->path_len--;
++ }
+ }
+
+ return normalized;
3: e4781b36d5 ! 6: 886a7d659e builtin: create url-parse command
@@ Commit message
The url-parse builtin command is designed to solve this problem
by exposing git's native URL parsing facilities as a plumbing command.
- Other programs can then call upon git itself to parse the git URLs and
- extract their components. This should be quite useful for scripts.
+ Other programs can then call upon git itself to parse the git URLs
+ and extract their components. This should be quite useful for scripts.
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
@@ Makefile: BUILTIN_OBJS += builtin/update-ref.o
BUILTIN_OBJS += builtin/verify-pack.o
## builtin.h ##
-@@ builtin.h: int cmd_update_server_info(int argc, const char **argv, const char *prefix);
- int cmd_upload_archive(int argc, const char **argv, const char *prefix);
- int cmd_upload_archive_writer(int argc, const char **argv, const char *prefix);
- int cmd_upload_pack(int argc, const char **argv, const char *prefix);
-+int cmd_url_parse(int argc, const char **argv, const char *prefix);
- int cmd_var(int argc, const char **argv, const char *prefix);
- int cmd_verify_commit(int argc, const char **argv, const char *prefix);
- int cmd_verify_tag(int argc, const char **argv, const char *prefix);
+@@ builtin.h: int cmd_update_server_info(int argc, const char **argv, const char *prefix, stru
+ int cmd_upload_archive(int argc, const char **argv, const char *prefix, struct repository *repo);
+ int cmd_upload_archive_writer(int argc, const char **argv, const char *prefix, struct repository *repo);
+ int cmd_upload_pack(int argc, const char **argv, const char *prefix, struct repository *repo);
++int cmd_url_parse(int argc, const char **argv, const char *prefix, struct repository *repo);
+ int cmd_var(int argc, const char **argv, const char *prefix, struct repository *repo);
+ int cmd_verify_commit(int argc, const char **argv, const char *prefix, struct repository *repo);
+ int cmd_verify_tag(int argc, const char **argv, const char *prefix, struct repository *repo);
## builtin/url-parse.c (new) ##
@@
-+/* SPDX-License-Identifier: GPL-2.0-only
-+ *
-+ * url-parse - parses git URLs and extracts their components
-+ *
-+ * Copyright © 2024 Matheus Afonso Martins Moreira
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation; version 2.
-+ */
-+
+#include "builtin.h"
+#include "gettext.h"
++#include "parse-options.h"
++#include "url.h"
++#include "urlmatch.h"
++
++static const char * const builtin_url_parse_usage[] = {
++ N_("git url-parse [-c <component>] [--] <url>..."),
++ NULL
++};
++
++static char *component_arg;
++
++static struct option builtin_url_parse_options[] = {
++ OPT_STRING('c', "component", &component_arg, N_("component"),
++ N_("which URL component to extract")),
++ OPT_END(),
++};
++
++enum url_component {
++ URL_NONE = 0,
++ URL_SCHEME,
++ URL_USER,
++ URL_PASSWORD,
++ URL_HOST,
++ URL_PORT,
++ URL_PATH,
++};
++
++static void parse_or_die(const char *url, struct url_info *info)
++{
++ if (url_is_local_not_ssh(url)) {
++ if (*url == '/')
++ die("'%s' is not a URL; if you meant a local "
++ "repository, use 'file://%s'", url, url);
++ die("'%s' is not a URL; if you meant a local repository, "
++ "use a 'file://' URL with an absolute path", url);
++ }
++ if (!url_parse(url, info))
++ die("invalid git URL '%s': %s", url, info->err);
++}
++
++static enum url_component get_component_or_die(const char *arg)
++{
++ if (!strcmp("path", arg))
++ return URL_PATH;
++ if (!strcmp("host", arg))
++ return URL_HOST;
++ if (!strcmp("scheme", arg))
++ return URL_SCHEME;
++ if (!strcmp("user", arg))
++ return URL_USER;
++ if (!strcmp("password", arg))
++ return URL_PASSWORD;
++ if (!strcmp("port", arg))
++ return URL_PORT;
++ die("invalid git URL component '%s'", arg);
++}
++
++static char *extract_component(enum url_component component,
++ struct url_info *info)
++{
++ size_t offset, length;
++
++ switch (component) {
++ case URL_SCHEME:
++ offset = 0;
++ length = info->scheme_len;
++ break;
++ case URL_USER:
++ offset = info->user_off;
++ length = info->user_len;
++ break;
++ case URL_PASSWORD:
++ offset = info->passwd_off;
++ length = info->passwd_len;
++ break;
++ case URL_HOST:
++ offset = info->host_off;
++ length = info->host_len;
++ break;
++ case URL_PORT:
++ offset = info->port_off;
++ length = info->port_len;
++ break;
++ case URL_PATH:
++ offset = info->path_off;
++ length = info->path_len;
++ break;
++ case URL_NONE:
++ return NULL;
++ }
++
++ return xstrndup(info->url + offset, length);
++}
+
-+int cmd_url_parse(int argc, const char **argv, const char *prefix)
++int cmd_url_parse(int argc,
++ const char **argv,
++ const char *prefix,
++ struct repository *repo UNUSED)
+{
++ struct url_info info;
++ enum url_component selected = URL_NONE;
++ char *extracted;
++ int i;
++
++ argc = parse_options(argc, argv, prefix, builtin_url_parse_options,
++ builtin_url_parse_usage, 0);
++
++ if (argc == 0)
++ usage_with_options(builtin_url_parse_usage,
++ builtin_url_parse_options);
++
++ if (component_arg)
++ selected = get_component_or_die(component_arg);
++
++ for (i = 0; i < argc; i++) {
++ parse_or_die(argv[i], &info);
++
++ if (selected != URL_NONE) {
++ extracted = extract_component(selected, &info);
++ if (extracted) {
++ puts(extracted);
++ free(extracted);
++ }
++ }
++
++ free(info.url);
++ }
++
+ return 0;
+}
@@ command-list.txt: git-update-ref plumbingmanipulators
git-update-server-info synchingrepositories
git-upload-archive synchelpers
git-upload-pack synchelpers
-+git-url-parse plumbinginterrogators
++git-url-parse purehelpers
git-var plumbinginterrogators
git-verify-commit ancillaryinterrogators
git-verify-pack plumbinginterrogators
@@ git.c: static struct cmd_struct commands[] = {
{ "upload-archive", cmd_upload_archive, NO_PARSEOPT },
{ "upload-archive--writer", cmd_upload_archive_writer, NO_PARSEOPT },
{ "upload-pack", cmd_upload_pack },
-+ { "url-parse", cmd_url_parse, NO_PARSEOPT },
++ { "url-parse", cmd_url_parse },
{ "var", cmd_var, RUN_SETUP_GENTLY | NO_PARSEOPT },
{ "verify-commit", cmd_verify_commit, RUN_SETUP },
{ "verify-pack", cmd_verify_pack },
+
+ ## meson.build ##
+@@ meson.build: builtin_sources = [
+ 'builtin/update-server-info.c',
+ 'builtin/upload-archive.c',
+ 'builtin/upload-pack.c',
++ 'builtin/url-parse.c',
+ 'builtin/var.c',
+ 'builtin/verify-commit.c',
+ 'builtin/verify-pack.c',
4: 1e0895651c < -: ---------- url-parse: add URL parsing helper function
5: 0bf83ee122 < -: ---------- url-parse: enumerate possible URL components
6: 149c476b1e < -: ---------- url-parse: define component extraction helper fn
7: eb9ef8a17b < -: ---------- url-parse: define string to component converter fn
8: a2acfdbc76 < -: ---------- url-parse: define usage and options
9: 5de00324fb < -: ---------- url-parse: parse options given on the command line
10: 15d355a43c < -: ---------- url-parse: validate all given git URLs
11: 4e93509c80 < -: ---------- url-parse: output URL components selected by user
12: abda074aee ! 7: 3c44e0f478 Documentation: describe the url-parse builtin
@@ Metadata
Author: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
## Commit message ##
- Documentation: describe the url-parse builtin
+ doc: describe the url-parse builtin
The new url-parse builtin validates git URLs
and optionally extracts their components.
+ Helped-by: Ghanshyam Thakkar <shyamthakkar001@gmail.com>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
- ## Documentation/git-url-parse.txt (new) ##
+ ## Documentation/git-url-parse.adoc (new) ##
@@
+git-url-parse(1)
+================
@@ Documentation/git-url-parse.txt (new)
+
+SYNOPSIS
+--------
-+[verse]
-+'git url-parse' [<options>] [--] <url>...
++[synopsis]
++git url-parse [-c <component>] [--] <url>...
+
+DESCRIPTION
+-----------
@@ Documentation/git-url-parse.txt (new)
+This command eases interoperability with git URLs by enabling the
+parsing and extraction of the components of all git URLs.
+
++Any syntactically valid URL is parsed, even if the scheme is not one
++git supports for fetching or pushing.
++
+OPTIONS
+-------
+
-+-c <arg>::
-+--component <arg>::
-+ Extract the `<arg>` component from the given git URLs.
-+ `<arg>` can be one of:
-+ `protocol`, `user`, `password`, `host`, `port`, `path`.
++`-c <component>`::
++`--component <component>`::
++ Extract the _<component>_ component from the given Git URLs.
++ _<component>_ can be one of:
++ `scheme`, `user`, `password`, `host`, `port`, `path`.
++
++OUTPUT
++------
++
++When `--component` is given, the requested component of each URL
++is printed on its own line, in the order the URLs were given. If
++the URL has no such component (for example, a port in a URL that
++does not specify one), an empty line is printed in its place.
++
++When `--component` is not given, no output is produced. The exit
++status is zero if every URL parses successfully and non-zero
++otherwise, allowing the command to be used purely as a validator.
+
+EXAMPLES
+--------
@@ Documentation/git-url-parse.txt (new)
++
+------------
+$ git url-parse --component path https://example.com/user/repo
-+/usr/repo
++/user/repo
+$ git url-parse --component path example.com:~user/repo
+~user/repo
+$ git url-parse --component path example.com:user/repo
@@ Documentation/git-url-parse.txt (new)
+$ git url-parse https://example.com/user/repo example.com:~user/repo
+------------
+
++SEE ALSO
++--------
++linkgit:git-clone[1],
++linkgit:git-fetch[1],
++linkgit:git-config[1]
++
+GIT
+---
+Part of the linkgit:git[1] suite
+
+ ## Documentation/meson.build ##
+@@ Documentation/meson.build: manpages = {
+ 'git-update-server-info.adoc' : 1,
+ 'git-upload-archive.adoc' : 1,
+ 'git-upload-pack.adoc' : 1,
++ 'git-url-parse.adoc' : 1,
+ 'git-var.adoc' : 1,
+ 'git-verify-commit.adoc' : 1,
+ 'git-verify-pack.adoc' : 1,
13: 33e128496b ! 8: cf2ae409e6 tests: add tests for the new url-parse builtin
@@ Metadata
Author: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
## Commit message ##
- tests: add tests for the new url-parse builtin
+ t9904: add tests for the new url-parse builtin
Test git URL parsing, validation and component extraction
on all documented git URL schemes and syntaxes.
+ Add IPv6 host coverage in URL form:
+
+ ssh://[::1]/path
+ ssh://user@[::1]:1234/path
+ git://[::1]:9418/path
+ http://[2001:db8::1]/path
+ https://[2001:db8::1]/path
+
+ In URL form the brackets are kept in the host component (RFC 3986
+ syntax for IPv6 literals).
+
+ Also exercise the bracketed scp short forms that t5601-clone.sh
+ covers via parse_connect_url:
+
+ [host]:path
+ [host:port]:path
+ [::1]:repo
+ user@[::1]:repo
+ user@[host:port]:path
+
+ In scp form, brackets are kept for IPv6 literals (two or more inner
+ colons) and stripped for plain hostnames or host:port pairs.
+
+ Suggested-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Matheus Afonso Martins Moreira <matheus@matheusmoreira.com>
+ ## t/meson.build ##
+@@ t/meson.build: integration_tests = [
+ 't9901-git-web--browse.sh',
+ 't9902-completion.sh',
+ 't9903-bash-prompt.sh',
++ 't9904-url-parse.sh',
+ ]
+
+ benchmarks = [
+
## t/t9904-url-parse.sh (new) ##
@@
+#!/bin/sh
+#
-+# Copyright © 2024 Matheus Afonso Martins Moreira
++# Copyright (c) 2024 Matheus Afonso Martins Moreira
+#
+
+test_description='git url-parse tests'
@@ t/t9904-url-parse.sh (new)
+
+test_expect_success 'git url-parse -- file urls' '
+ git url-parse "file:///repository/path" &&
-+ git url-parse "file:///" &&
+ git url-parse "file://"
+'
+
-+test_expect_success 'git url-parse -c protocol -- ssh syntax' '
-+ test ssh = "$(git url-parse -c protocol "ssh://user@example.com:1234/repository/path")" &&
-+ test ssh = "$(git url-parse -c protocol "ssh://user@example.com/repository/path")" &&
-+ test ssh = "$(git url-parse -c protocol "ssh://example.com:1234/repository/path")" &&
-+ test ssh = "$(git url-parse -c protocol "ssh://example.com/repository/path")"
++test_expect_success 'git url-parse -c scheme -- ssh syntax' '
++ test ssh = "$(git url-parse -c scheme "ssh://user@example.com:1234/repository/path")" &&
++ test ssh = "$(git url-parse -c scheme "ssh://user@example.com/repository/path")" &&
++ test ssh = "$(git url-parse -c scheme "ssh://example.com:1234/repository/path")" &&
++ test ssh = "$(git url-parse -c scheme "ssh://example.com/repository/path")"
+'
+
-+test_expect_success 'git url-parse -c protocol -- git syntax' '
-+ test git = "$(git url-parse -c protocol "git://example.com:1234/repository/path")" &&
-+ test git = "$(git url-parse -c protocol "git://example.com/repository/path")"
++test_expect_success 'git url-parse -c scheme -- git syntax' '
++ test git = "$(git url-parse -c scheme "git://example.com:1234/repository/path")" &&
++ test git = "$(git url-parse -c scheme "git://example.com/repository/path")"
+'
+
-+test_expect_success 'git url-parse -c protocol -- http syntax' '
-+ test https = "$(git url-parse -c protocol "https://example.com:1234/repository/path")" &&
-+ test https = "$(git url-parse -c protocol "https://example.com/repository/path")" &&
-+ test http = "$(git url-parse -c protocol "http://example.com:1234/repository/path")" &&
-+ test http = "$(git url-parse -c protocol "http://example.com/repository/path")"
++test_expect_success 'git url-parse -c scheme -- http syntax' '
++ test https = "$(git url-parse -c scheme "https://example.com:1234/repository/path")" &&
++ test https = "$(git url-parse -c scheme "https://example.com/repository/path")" &&
++ test http = "$(git url-parse -c scheme "http://example.com:1234/repository/path")" &&
++ test http = "$(git url-parse -c scheme "http://example.com/repository/path")"
+'
+
-+test_expect_success 'git url-parse -c protocol -- scp syntax' '
-+ test ssh = "$(git url-parse -c protocol "user@example.com:/repository/path")" &&
-+ test ssh = "$(git url-parse -c protocol "example.com:/repository/path")"
++test_expect_success 'git url-parse -c scheme -- scp syntax' '
++ test ssh = "$(git url-parse -c scheme "user@example.com:/repository/path")" &&
++ test ssh = "$(git url-parse -c scheme "example.com:/repository/path")"
+'
+
+test_expect_success 'git url-parse -c user -- ssh syntax' '
@@ t/t9904-url-parse.sh (new)
+ test "" = "$(git url-parse -c user "example.com:/repository/path")"
+'
+
++test_expect_success 'git url-parse -c password -- http syntax' '
++ test secret = "$(git url-parse -c password "https://user:secret@example.com:1234/repository/path")" &&
++ test secret = "$(git url-parse -c password "http://user:secret@example.com/repository/path")" &&
++ test "" = "$(git url-parse -c password "https://user@example.com/repository/path")" &&
++ test "" = "$(git url-parse -c password "https://example.com/repository/path")"
++'
++
+test_expect_success 'git url-parse -c host -- ssh syntax' '
+ test example.com = "$(git url-parse -c host "ssh://user@example.com:1234/repository/path")" &&
+ test example.com = "$(git url-parse -c host "ssh://user@example.com/repository/path")" &&
@@ t/t9904-url-parse.sh (new)
+ test "~user/repository" = "$(git url-parse -c path "example.com:~user/repository")"
+'
+
++test_expect_success 'git url-parse -c path -- username expansion strips query and fragment' '
++ test "~user/repository" = "$(git url-parse -c path "ssh://example.com/~user/repository?query")" &&
++ test "~user/repository" = "$(git url-parse -c path "ssh://example.com/~user/repository#fragment")" &&
++ test "~user/repository" = "$(git url-parse -c path "git://example.com/~user/repository?query")" &&
++ test "~user/repository" = "$(git url-parse -c path "user@example.com:~user/repository?query")"
++'
++
++test_expect_success 'git url-parse -- ssh syntax with IPv6' '
++ git url-parse "ssh://user@[::1]:1234/repository/path" &&
++ git url-parse "ssh://user@[::1]/repository/path" &&
++ git url-parse "ssh://[::1]:1234/repository/path" &&
++ git url-parse "ssh://[::1]/repository/path" &&
++ git url-parse "ssh://[2001:db8::1]/repository/path"
++'
++
++test_expect_success 'git url-parse -- git syntax with IPv6' '
++ git url-parse "git://[::1]:9418/repository/path" &&
++ git url-parse "git://[::1]/repository/path"
++'
++
++test_expect_success 'git url-parse -- http syntax with IPv6' '
++ git url-parse "https://[::1]:1234/repository/path" &&
++ git url-parse "https://[::1]/repository/path" &&
++ git url-parse "http://[2001:db8::1]/repository/path"
++'
++
++test_expect_success 'git url-parse -c host -- IPv6 in URL form' '
++ test "[::1]" = "$(git url-parse -c host "ssh://user@[::1]:1234/repository/path")" &&
++ test "[::1]" = "$(git url-parse -c host "ssh://[::1]/repository/path")" &&
++ test "[2001:db8::1]" = "$(git url-parse -c host "ssh://[2001:db8::1]/repository/path")" &&
++ test "[::1]" = "$(git url-parse -c host "git://[::1]/repository/path")" &&
++ test "[2001:db8::1]" = "$(git url-parse -c host "https://[2001:db8::1]/repository/path")"
++'
++
++test_expect_success 'git url-parse -c port -- IPv6 in URL form' '
++ test 1234 = "$(git url-parse -c port "ssh://user@[::1]:1234/repository/path")" &&
++ test "" = "$(git url-parse -c port "ssh://[::1]/repository/path")" &&
++ test 9418 = "$(git url-parse -c port "git://[::1]:9418/repository/path")"
++'
++
++test_expect_success 'git url-parse -- scp syntax with IPv6' '
++ git url-parse "[::1]:repository/path" &&
++ git url-parse "user@[::1]:repository/path" &&
++ git url-parse "[2001:db8::1]:repo"
++'
++
++test_expect_success 'git url-parse -- scp syntax with bracketed hostname' '
++ git url-parse "[myhost]:src" &&
++ git url-parse "user@[myhost]:src"
++'
++
++test_expect_success 'git url-parse -- scp syntax with bracketed host:port' '
++ git url-parse "[myhost:123]:src" &&
++ git url-parse "user@[myhost:123]:src"
++'
++
++test_expect_success 'git url-parse -c host -- scp+IPv6' '
++ test "[::1]" = "$(git url-parse -c host "[::1]:repository/path")" &&
++ test "[::1]" = "$(git url-parse -c host "user@[::1]:repository/path")" &&
++ test "[2001:db8::1]" = "$(git url-parse -c host "[2001:db8::1]:repo")"
++'
++
++test_expect_success 'git url-parse -c path -- scp+IPv6' '
++ test "/repository/path" = "$(git url-parse -c path "[::1]:/repository/path")" &&
++ test "/repository/path" = "$(git url-parse -c path "[::1]:repository/path")" &&
++ test "/repo" = "$(git url-parse -c path "[2001:db8::1]:repo")"
++'
++
++test_expect_success 'git url-parse -c host,port,path -- scp [host:port]:src' '
++ test myhost = "$(git url-parse -c host "[myhost:123]:src")" &&
++ test 123 = "$(git url-parse -c port "[myhost:123]:src")" &&
++ test "/src" = "$(git url-parse -c path "[myhost:123]:src")"
++'
++
++test_expect_success 'git url-parse -c host,path -- scp [host]:src' '
++ test myhost = "$(git url-parse -c host "[myhost]:src")" &&
++ test "/src" = "$(git url-parse -c path "[myhost]:src")"
++'
++
++test_expect_success 'git url-parse -c user -- scp with user@ and brackets' '
++ test user = "$(git url-parse -c user "user@[::1]:repo")" &&
++ test user = "$(git url-parse -c user "user@[myhost:123]:src")" &&
++ test user = "$(git url-parse -c user "user@[myhost]:src")"
++'
++
++test_expect_success 'git url-parse -- scp+IPv6 with username expansion' '
++ test "~user/repo" = "$(git url-parse -c path "[::1]:~user/repo")" &&
++ test "~user/repo" = "$(git url-parse -c path "user@[::1]:~user/repo")"
++'
++
++test_expect_success 'git url-parse fails on invalid URL' '
++ test_must_fail git url-parse "not a url"
++'
++
++test_expect_success 'git url-parse helpful error for absolute local path' '
++ test_must_fail git url-parse "/abs/path" 2>err &&
++ test_grep "is not a URL" err &&
++ test_grep "file:///abs/path" err
++'
++
++test_expect_success 'git url-parse helpful error for relative local path' '
++ test_must_fail git url-parse "./rel" 2>err &&
++ test_grep "is not a URL" err &&
++ test_grep "absolute path" err
++'
++
++test_expect_success 'git url-parse fails on unknown -c component name' '
++ test_must_fail git url-parse -c bogus "https://example.com/repo"
++'
++
++test_expect_success 'git url-parse fails on URL missing host' '
++ test_must_fail git url-parse "https://"
++'
++
++test_expect_success 'git url-parse with no URL prints usage' '
++ test_must_fail git url-parse 2>err &&
++ test_grep "usage:" err
++'
++
+test_done
--
gitgitgadget
^ permalink raw reply
* [PATCH] fetch: add fetch.pruneLocalBranches config
From: Harald Nordgren via GitGitGadget @ 2026-05-01 21:35 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
From: Harald Nordgren <haraldnordgren@gmail.com>
Introduce a tri-state config option that, when --prune (or
fetch.prune / remote.<name>.prune) removes a remote-tracking
ref, also deletes local branches whose configured upstream is
that ref.
Values:
- false (default): no change in behavior.
- safe: delete only if the local tip is reachable from the
upstream tip, preserving any unpushed work.
- force: delete unconditionally; recoverable only via reflog.
The currently checked-out branch is always preserved.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
fetch: add fetch.pruneBranches config
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2285%2FHaraldNordgren%2Ffetch-prune-local-branches-v1
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2285/HaraldNordgren/fetch-prune-local-branches-v1
Pull-Request: https://github.com/git/git/pull/2285
Documentation/config/fetch.adoc | 39 +++++++
Documentation/config/remote.adoc | 7 ++
Documentation/fetch-options.adoc | 9 ++
Documentation/git-fetch.adoc | 6 ++
builtin/fetch.c | 172 ++++++++++++++++++++++++++++++-
remote.c | 16 +++
remote.h | 10 ++
t/t5510-fetch.sh | 84 +++++++++++++++
8 files changed, 339 insertions(+), 4 deletions(-)
diff --git a/Documentation/config/fetch.adoc b/Documentation/config/fetch.adoc
index cd40db0cad..5a60507a84 100644
--- a/Documentation/config/fetch.adoc
+++ b/Documentation/config/fetch.adoc
@@ -50,6 +50,45 @@
refs. See also `remote.<name>.pruneTags` and the PRUNING
section of linkgit:git-fetch[1].
+`fetch.pruneBranches`::
+ When set in addition to `fetch.prune` (or `--prune`), also
+ delete local branches whose configured upstream
+ (`branch.<name>.merge`) is one of the remote-tracking refs
+ just removed by pruning. This is useful for cleaning up topic
+ branches whose upstream counterpart has been merged and then
+ removed. The same effect can be requested per-invocation with
+ `--prune-branches[=<mode>]`, or per-remote with
+ `remote.<name>.pruneBranches`.
++
+The currently checked-out branch (in any worktree) is never
+deleted. The value is one of:
++
+--
+`false` (the default);;
+ Do not delete any local branches. Equivalent to leaving
+ the option unset.
+`safe`;;
+ Delete a local branch only if its tip is an ancestor of
+ the upstream remote-tracking ref's last-known position.
+ In other words, only delete the branch if it contains no
+ commits that the upstream did not also have at the moment
+ it was deleted. This catches the common case of a branch
+ that was pushed and then squash- or rebase-merged
+ upstream (the local branch has no extra commits beyond
+ what was pushed), but preserves any branch with unpushed
+ local work.
+`force`;;
+ Delete the local branch unconditionally, even if it
+ contains unpushed commits. Use with care: if a remote
+ branch is deleted for any reason other than that its
+ contents were merged, the corresponding local commits
+ will only be retrievable through the reflog.
+--
++
+This option has no effect unless pruning is also enabled, since
+local branches are only considered for deletion when their
+upstream remote-tracking ref is being pruned in the same fetch.
+
`fetch.all`::
If true, fetch will attempt to update all available remotes.
This behavior can be overridden by passing `--no-all` or by
diff --git a/Documentation/config/remote.adoc b/Documentation/config/remote.adoc
index 91e46f66f5..60fd5841c6 100644
--- a/Documentation/config/remote.adoc
+++ b/Documentation/config/remote.adoc
@@ -87,6 +87,13 @@ remote.<name>.pruneTags::
See also `remote.<name>.prune` and the PRUNING section of
linkgit:git-fetch[1].
+remote.<name>.pruneBranches::
+ When pruning is active for this remote and this is set to `safe`
+ or `force`, also delete local branches whose upstream
+ remote-tracking ref is being pruned. Overrides
+ `fetch.pruneBranches` settings, if any. See `fetch.pruneBranches`
+ for the meaning of the values.
+
remote.<name>.promisor::
When set to true, this remote will be used to fetch promisor
objects.
diff --git a/Documentation/fetch-options.adoc b/Documentation/fetch-options.adoc
index 81a9d7f9bb..0764f67cc3 100644
--- a/Documentation/fetch-options.adoc
+++ b/Documentation/fetch-options.adoc
@@ -185,6 +185,15 @@ See the PRUNING section below for more details.
+
See the PRUNING section below for more details.
+`--prune-branches[=(safe|force)]`::
+ When pruning, also delete local branches whose configured
+ upstream (`branch.<name>.merge`) is one of the remote-tracking
+ refs being pruned. With no value or `safe`, refuse to delete a
+ branch with unpushed commits; with `force`, delete it
+ regardless. The currently checked-out branch is never
+ deleted. See `fetch.pruneBranches` in linkgit:git-config[1] for
+ details.
+
endif::git-pull[]
ifndef::git-pull[]
diff --git a/Documentation/git-fetch.adoc b/Documentation/git-fetch.adoc
index db03541915..a50b9672a1 100644
--- a/Documentation/git-fetch.adoc
+++ b/Documentation/git-fetch.adoc
@@ -179,6 +179,12 @@ It's reasonable to e.g. configure `fetch.pruneTags=true` in
run, without making every invocation of `git fetch` without `--prune`
an error.
+Local branches whose upstream remote-tracking ref is being pruned can
+also be deleted automatically with `--prune-branches[=<mode>]` (or its
+config equivalents `fetch.pruneBranches` and `remote.<name>.pruneBranches`).
+See linkgit:git-config[1] for the data-loss tradeoff between the
+`safe` and `force` modes.
+
Pruning tags with `--prune-tags` also works when fetching a URL
instead of a named remote. These will all prune tags not found on
origin:
diff --git a/builtin/fetch.c b/builtin/fetch.c
index a22c319467..c6c2f00be0 100644
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -82,6 +82,21 @@ static int prune = -1; /* unspecified */
static int prune_tags = -1; /* unspecified */
#define PRUNE_TAGS_BY_DEFAULT 0 /* do we prune tags by default? */
+static int prune_branches = PRUNE_BRANCHES_UNSPECIFIED;
+
+static int parse_prune_branches_opt(const struct option *opt,
+ const char *arg, int unset)
+{
+ int *v = opt->value;
+ if (unset)
+ *v = PRUNE_BRANCHES_OFF;
+ else if (arg)
+ *v = parse_prune_branches_value(opt->long_name, arg);
+ else
+ *v = PRUNE_BRANCHES_SAFE;
+ return 0;
+}
+
static int append, dry_run, force, keep, update_head_ok;
static int write_fetch_head = 1;
static int verbosity, deepen_relative, set_upstream, refetch;
@@ -105,6 +120,7 @@ struct fetch_config {
int all;
int prune;
int prune_tags;
+ enum prune_branches_mode prune_branches;
int show_forced_updates;
int recurse_submodules;
int parallel;
@@ -131,6 +147,11 @@ static int git_fetch_config(const char *k, const char *v,
return 0;
}
+ if (!strcmp(k, "fetch.prunebranches")) {
+ fetch_config->prune_branches = parse_prune_branches_value(k, v);
+ return 0;
+ }
+
if (!strcmp(k, "fetch.showforcedupdates")) {
fetch_config->show_forced_updates = git_config_bool(k, v);
return 0;
@@ -1445,7 +1466,8 @@ out:
static int prune_refs(struct display_state *display_state,
struct refspec *rs,
struct ref_transaction *transaction,
- struct ref *ref_map)
+ struct ref *ref_map,
+ struct ref **stale_refs_out)
{
int result = 0;
struct ref *ref, *stale_refs = get_stale_heads(rs, ref_map);
@@ -1487,7 +1509,126 @@ static int prune_refs(struct display_state *display_state,
cleanup:
string_list_clear(&refnames, 0);
strbuf_release(&err);
- free_refs(stale_refs);
+ if (!result && stale_refs_out)
+ *stale_refs_out = stale_refs;
+ else
+ free_refs(stale_refs);
+ return result;
+}
+
+struct prune_branches_cb {
+ struct string_list *pruned_refs;
+ struct string_list *to_delete;
+ struct string_list *skipped_unmerged;
+ enum prune_branches_mode mode;
+};
+
+static int collect_branches_to_prune(const struct reference *ref, void *cb_data)
+{
+ struct prune_branches_cb *cb = cb_data;
+ const char *short_name = ref->name;
+ char *full_ref = xstrfmt("refs/heads/%s", short_name);
+ const char *upstream;
+ struct string_list_item *pruned;
+ int result = 0;
+
+ if (ref->flags & REF_ISSYMREF)
+ goto out;
+ if (branch_checked_out(full_ref))
+ goto out;
+
+ upstream = branch_get_upstream(branch_get(short_name), NULL);
+ if (!upstream)
+ goto out;
+
+ pruned = string_list_lookup(cb->pruned_refs, upstream);
+ if (!pruned)
+ goto out;
+
+ if (cb->mode == PRUNE_BRANCHES_SAFE) {
+ struct commit *local = lookup_commit_reference(the_repository,
+ ref->oid);
+ struct commit *up = lookup_commit_reference(the_repository,
+ pruned->util);
+ int reachable = local && up &&
+ repo_in_merge_bases(the_repository, local, up);
+
+ if (reachable < 0) {
+ result = -1;
+ goto out;
+ }
+ if (!reachable) {
+ string_list_append(cb->skipped_unmerged, short_name);
+ goto out;
+ }
+ }
+
+ string_list_append(cb->to_delete, full_ref);
+
+out:
+ free(full_ref);
+ return result;
+}
+
+static int do_prune_branches(struct display_state *display_state,
+ struct ref *stale_refs,
+ enum prune_branches_mode mode)
+{
+ struct string_list pruned_refs = STRING_LIST_INIT_NODUP;
+ struct string_list to_delete = STRING_LIST_INIT_DUP;
+ struct string_list skipped_unmerged = STRING_LIST_INIT_DUP;
+ struct prune_branches_cb cb = {
+ .pruned_refs = &pruned_refs,
+ .to_delete = &to_delete,
+ .skipped_unmerged = &skipped_unmerged,
+ .mode = mode,
+ };
+ struct ref *ref;
+ struct string_list_item *item;
+ int result = 0;
+
+ if (!stale_refs)
+ return 0;
+
+ for (ref = stale_refs; ref; ref = ref->next)
+ string_list_append(&pruned_refs, ref->name)->util = &ref->new_oid;
+ string_list_sort(&pruned_refs);
+
+ if (refs_for_each_branch_ref(get_main_ref_store(the_repository),
+ collect_branches_to_prune, &cb)) {
+ result = -1;
+ goto cleanup;
+ }
+
+ if (!dry_run && to_delete.nr)
+ result = refs_delete_refs(get_main_ref_store(the_repository),
+ "fetch: prune branches",
+ &to_delete, REF_NO_DEREF);
+
+ if (verbosity >= 0) {
+ const struct object_id *zero = null_oid(the_repository->hash_algo);
+ for_each_string_list_item(item, &to_delete) {
+ const char *short_name;
+ if (skip_prefix(item->string, "refs/heads/", &short_name))
+ display_ref_update(display_state, '-',
+ _("[deleted local]"), NULL,
+ _("(none)"), short_name,
+ zero, zero,
+ transport_summary_width(NULL));
+ }
+ }
+ for_each_string_list_item(item, &skipped_unmerged)
+ warning(_("not deleting local branch '%s' that is not "
+ "fully merged into its upstream;\n"
+ " set fetch.pruneBranches=force to "
+ "delete anyway, or delete manually with "
+ "'git branch -D %s'"),
+ item->string, item->string);
+
+cleanup:
+ string_list_clear(&pruned_refs, 0);
+ string_list_clear(&to_delete, 0);
+ string_list_clear(&skipped_unmerged, 0);
return result;
}
@@ -1945,19 +2086,28 @@ static int do_fetch(struct transport *transport,
if (tags == TAGS_DEFAULT && autotags)
transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
if (prune) {
+ struct ref *stale_refs = NULL;
+ struct ref **stale_refs_out = prune_branches != PRUNE_BRANCHES_OFF
+ ? &stale_refs : NULL;
/*
* We only prune based on refspecs specified
* explicitly (via command line or configuration); we
* don't care whether --tags was specified.
*/
if (rs->nr) {
- retcode = prune_refs(&display_state, rs, transaction, ref_map);
+ retcode = prune_refs(&display_state, rs, transaction,
+ ref_map, stale_refs_out);
} else {
retcode = prune_refs(&display_state, &transport->remote->fetch,
- transaction, ref_map);
+ transaction, ref_map, stale_refs_out);
}
if (retcode != 0)
retcode = 1;
+ else if (stale_refs &&
+ do_prune_branches(&display_state, stale_refs,
+ prune_branches))
+ retcode = 1;
+ free_refs(stale_refs);
}
/*
@@ -2419,6 +2569,16 @@ static int fetch_one(struct remote *remote, int argc, const char **argv,
prune_tags = PRUNE_TAGS_BY_DEFAULT;
}
+ if (prune_branches == PRUNE_BRANCHES_UNSPECIFIED) {
+ /* no command line request */
+ if (remote->prune_branches >= 0)
+ prune_branches = remote->prune_branches;
+ else if (config->prune_branches >= 0)
+ prune_branches = config->prune_branches;
+ else
+ prune_branches = PRUNE_BRANCHES_OFF;
+ }
+
maybe_prune_tags = prune_tags_ok && prune_tags;
if (maybe_prune_tags && remote_via_config)
refspec_append(&remote->fetch, TAG_REFSPEC);
@@ -2469,6 +2629,7 @@ int cmd_fetch(int argc,
.display_format = DISPLAY_FORMAT_FULL,
.prune = -1,
.prune_tags = -1,
+ .prune_branches = PRUNE_BRANCHES_UNSPECIFIED,
.show_forced_updates = 1,
.recurse_submodules = RECURSE_SUBMODULES_DEFAULT,
.parallel = 1,
@@ -2520,6 +2681,9 @@ int cmd_fetch(int argc,
N_("prune remote-tracking branches no longer on remote")),
OPT_BOOL('P', "prune-tags", &prune_tags,
N_("prune local tags no longer on remote and clobber changed tags")),
+ OPT_CALLBACK_F(0, "prune-branches", &prune_branches, N_("mode"),
+ N_("delete local branches whose upstream was pruned ('safe' or 'force')"),
+ PARSE_OPT_OPTARG, parse_prune_branches_opt),
OPT_CALLBACK_F(0, "recurse-submodules", &recurse_submodules_cli, N_("on-demand"),
N_("control recursive fetching of submodules"),
PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules),
diff --git a/remote.c b/remote.c
index a664cd166a..1e2b4803e7 100644
--- a/remote.c
+++ b/remote.c
@@ -148,6 +148,7 @@ static struct remote *make_remote(struct remote_state *remote_state,
CALLOC_ARRAY(ret, 1);
ret->prune = -1; /* unspecified */
ret->prune_tags = -1; /* unspecified */
+ ret->prune_branches = -1; /* unspecified */
ret->name = xstrndup(name, len);
refspec_init_push(&ret->push);
refspec_init_fetch(&ret->fetch);
@@ -423,6 +424,19 @@ out:
}
#endif /* WITH_BREAKING_CHANGES */
+int parse_prune_branches_value(const char *k, const char *v)
+{
+ if (v) {
+ if (!strcasecmp(v, "safe"))
+ return PRUNE_BRANCHES_SAFE;
+ if (!strcasecmp(v, "force"))
+ return PRUNE_BRANCHES_FORCE;
+ }
+ if (git_parse_maybe_bool(v) == 0)
+ return PRUNE_BRANCHES_OFF;
+ die(_("invalid value for '%s': '%s'"), k, v);
+}
+
static int handle_config(const char *key, const char *value,
const struct config_context *ctx, void *cb)
{
@@ -507,6 +521,8 @@ static int handle_config(const char *key, const char *value,
remote->prune = git_config_bool(key, value);
else if (!strcmp(subkey, "prunetags"))
remote->prune_tags = git_config_bool(key, value);
+ else if (!strcmp(subkey, "prunebranches"))
+ remote->prune_branches = parse_prune_branches_value(key, value);
else if (!strcmp(subkey, "url")) {
if (!value)
return config_error_nonbool(key);
diff --git a/remote.h b/remote.h
index fc052945ee..5b750c8229 100644
--- a/remote.h
+++ b/remote.h
@@ -28,6 +28,15 @@ enum {
#endif /* WITH_BREAKING_CHANGES */
};
+enum prune_branches_mode {
+ PRUNE_BRANCHES_UNSPECIFIED = -1,
+ PRUNE_BRANCHES_OFF = 0,
+ PRUNE_BRANCHES_SAFE,
+ PRUNE_BRANCHES_FORCE,
+};
+
+int parse_prune_branches_value(const char *k, const char *v);
+
struct rewrite {
const char *base;
size_t baselen;
@@ -102,6 +111,7 @@ struct remote {
int mirror;
int prune;
int prune_tags;
+ int prune_branches;
/**
* The configured helper programs to run on the remote side, for
diff --git a/t/t5510-fetch.sh b/t/t5510-fetch.sh
index 6fe21e2b3a..5a2ff40132 100755
--- a/t/t5510-fetch.sh
+++ b/t/t5510-fetch.sh
@@ -386,6 +386,90 @@ test_expect_success REFFILES 'fetch --prune fails to delete branches' '
)
'
+test_expect_success 'fetch.pruneBranches: setup parent' '
+ git init -b main prune-branches-parent &&
+ test_commit -C prune-branches-parent base
+'
+
+test_expect_success 'fetch.pruneBranches=safe deletes merged local branch' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-safe &&
+ git -C prune-branches-safe checkout -b doomed --track origin/doomed &&
+ git -C prune-branches-safe checkout -b stay &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-safe -c fetch.pruneBranches=safe fetch --prune origin &&
+ test_must_fail git -C prune-branches-safe rev-parse refs/remotes/origin/doomed &&
+ test_must_fail git -C prune-branches-safe rev-parse refs/heads/doomed
+'
+
+test_expect_success 'fetch.pruneBranches=safe keeps unmerged local branch' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-safe-unmerged &&
+ git -C prune-branches-safe-unmerged checkout -b doomed --track origin/doomed &&
+ test_commit -C prune-branches-safe-unmerged local-only &&
+ git -C prune-branches-safe-unmerged checkout -b stay &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-safe-unmerged -c fetch.pruneBranches=safe fetch --prune origin 2>err &&
+ test_must_fail git -C prune-branches-safe-unmerged rev-parse refs/remotes/origin/doomed &&
+ git -C prune-branches-safe-unmerged rev-parse refs/heads/doomed &&
+ test_grep "not fully merged" err
+'
+
+test_expect_success 'fetch.pruneBranches=force deletes unmerged local branch' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-force &&
+ git -C prune-branches-force checkout -b doomed --track origin/doomed &&
+ test_commit -C prune-branches-force local-only-force &&
+ git -C prune-branches-force checkout -b stay &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-force -c fetch.pruneBranches=force fetch --prune origin &&
+ test_must_fail git -C prune-branches-force rev-parse refs/remotes/origin/doomed &&
+ test_must_fail git -C prune-branches-force rev-parse refs/heads/doomed
+'
+
+test_expect_success 'fetch.pruneBranches=force never deletes checked-out branch' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-checked-out &&
+ git -C prune-branches-checked-out checkout -b doomed --track origin/doomed &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-checked-out -c fetch.pruneBranches=force fetch --prune origin &&
+ test_must_fail git -C prune-branches-checked-out rev-parse refs/remotes/origin/doomed &&
+ git -C prune-branches-checked-out rev-parse refs/heads/doomed
+'
+
+test_expect_success '--prune-branches deletes merged local branch' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-cli &&
+ git -C prune-branches-cli checkout -b doomed --track origin/doomed &&
+ git -C prune-branches-cli checkout -b stay &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-cli fetch --prune --prune-branches origin &&
+ test_must_fail git -C prune-branches-cli rev-parse refs/heads/doomed
+'
+
+test_expect_success '--no-prune-branches overrides fetch.pruneBranches' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-no-cli &&
+ git -C prune-branches-no-cli checkout -b doomed --track origin/doomed &&
+ git -C prune-branches-no-cli checkout -b stay &&
+ git -C prune-branches-no-cli config fetch.pruneBranches force &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-no-cli fetch --prune --no-prune-branches origin &&
+ git -C prune-branches-no-cli rev-parse refs/heads/doomed
+'
+
+test_expect_success 'remote.<name>.pruneBranches overrides fetch.pruneBranches' '
+ git -C prune-branches-parent branch doomed base &&
+ git clone prune-branches-parent prune-branches-per-remote &&
+ git -C prune-branches-per-remote checkout -b doomed --track origin/doomed &&
+ git -C prune-branches-per-remote checkout -b stay &&
+ git -C prune-branches-per-remote config fetch.pruneBranches force &&
+ git -C prune-branches-per-remote config remote.origin.pruneBranches false &&
+ git -C prune-branches-parent branch -D doomed &&
+ git -C prune-branches-per-remote fetch --prune origin &&
+ git -C prune-branches-per-remote rev-parse refs/heads/doomed
+'
+
test_expect_success 'fetch --atomic works with a single branch' '
test_when_finished "rm -rf atomic" &&
base-commit: 94f057755b7941b321fd11fec1b2e3ca5313a4e0
--
gitgitgadget
^ permalink raw reply related
* [PATCH 1/1] http: reject unsupported proxy URL schemes
From: aminnimaj @ 2026-05-01 19:04 UTC (permalink / raw)
To: git; +Cc: peff, ryan.hendrickson, Aliwoto
In-Reply-To: <20260501190401.1580-1-aminnimaj@gmail.com>
From: Aliwoto <aminnimaj@gmail.com>
An explicit proxy URL with an unrecognized scheme such as
htpp://127.0.0.1 is currently accepted.
Git parses the URL, extracts the host part, and then passes only that
host to libcurl. Because no proxy type is selected for the unknown
scheme, Git leaves libcurl at its default HTTP proxy type, so the typo
is silently treated as an HTTP proxy.
Reject proxy URLs with explicit unsupported schemes instead of silently
accepting them. Keep the existing host:port-without-scheme behavior
unchanged.
Add a regression test to cover the unsupported-scheme case.
Signed-off-by: Aliwoto <aminnimaj@gmail.com>
---
http.c | 79 +++++++++++++++++++++++++++++--------------
t/t5564-http-proxy.sh | 5 +++
2 files changed, 59 insertions(+), 25 deletions(-)
diff --git a/http.c b/http.c
index 7815f144de..0628dc5aab 100644
--- a/http.c
+++ b/http.c
@@ -722,6 +722,55 @@ static int has_proxy_cert_password(void)
return 1;
}
+static int is_socks_proxy_protocol(const char *protocol)
+{
+ return protocol &&
+ (!strcmp(protocol, "socks") ||
+ !strcmp(protocol, "socks4") ||
+ !strcmp(protocol, "socks4a") ||
+ !strcmp(protocol, "socks5") ||
+ !strcmp(protocol, "socks5h"));
+}
+
+static int set_curl_proxy_type(CURL *result, const char *protocol)
+{
+ if (!protocol || !strcmp(protocol, "http"))
+ return 0;
+
+ if (!strcmp(protocol, "socks5h"))
+ curl_easy_setopt(result, CURLOPT_PROXYTYPE,
+ (long)CURLPROXY_SOCKS5_HOSTNAME);
+ else if (!strcmp(protocol, "socks5"))
+ curl_easy_setopt(result, CURLOPT_PROXYTYPE,
+ (long)CURLPROXY_SOCKS5);
+ else if (!strcmp(protocol, "socks4a"))
+ curl_easy_setopt(result, CURLOPT_PROXYTYPE,
+ (long)CURLPROXY_SOCKS4A);
+ else if (!strcmp(protocol, "socks") ||
+ !strcmp(protocol, "socks4"))
+ curl_easy_setopt(result, CURLOPT_PROXYTYPE,
+ (long)CURLPROXY_SOCKS4);
+ else if (!strcmp(protocol, "https")) {
+ curl_easy_setopt(result, CURLOPT_PROXYTYPE, (long)CURLPROXY_HTTPS);
+
+ if (http_proxy_ssl_cert)
+ curl_easy_setopt(result, CURLOPT_PROXY_SSLCERT,
+ http_proxy_ssl_cert);
+
+ if (http_proxy_ssl_key)
+ curl_easy_setopt(result, CURLOPT_PROXY_SSLKEY,
+ http_proxy_ssl_key);
+
+ if (has_proxy_cert_password())
+ curl_easy_setopt(result, CURLOPT_PROXY_KEYPASSWD,
+ proxy_cert_auth.password);
+ } else {
+ return -1;
+ }
+
+ return 0;
+}
+
/* Return 1 if redactions have been made, 0 otherwise. */
static int redact_sensitive_header(struct strbuf *header, size_t offset)
{
@@ -1192,30 +1241,6 @@ static CURL *get_curl_handle(void)
} else if (curl_http_proxy) {
struct strbuf proxy = STRBUF_INIT;
- if (starts_with(curl_http_proxy, "socks5h"))
- curl_easy_setopt(result,
- CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5_HOSTNAME);
- else if (starts_with(curl_http_proxy, "socks5"))
- curl_easy_setopt(result,
- CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5);
- else if (starts_with(curl_http_proxy, "socks4a"))
- curl_easy_setopt(result,
- CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4A);
- else if (starts_with(curl_http_proxy, "socks"))
- curl_easy_setopt(result,
- CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4);
- else if (starts_with(curl_http_proxy, "https")) {
- curl_easy_setopt(result, CURLOPT_PROXYTYPE, (long)CURLPROXY_HTTPS);
-
- if (http_proxy_ssl_cert)
- curl_easy_setopt(result, CURLOPT_PROXY_SSLCERT, http_proxy_ssl_cert);
-
- if (http_proxy_ssl_key)
- curl_easy_setopt(result, CURLOPT_PROXY_SSLKEY, http_proxy_ssl_key);
-
- if (has_proxy_cert_password())
- curl_easy_setopt(result, CURLOPT_PROXY_KEYPASSWD, proxy_cert_auth.password);
- }
if (strstr(curl_http_proxy, "://"))
credential_from_url(&proxy_auth, curl_http_proxy);
else {
@@ -1225,6 +1250,10 @@ static CURL *get_curl_handle(void)
strbuf_release(&url);
}
+ if (set_curl_proxy_type(result, proxy_auth.protocol) < 0)
+ die("Invalid proxy URL '%s': unsupported proxy scheme '%s'",
+ curl_http_proxy, proxy_auth.protocol);
+
if (!proxy_auth.host)
die("Invalid proxy URL '%s'", curl_http_proxy);
@@ -1235,7 +1264,7 @@ static CURL *get_curl_handle(void)
if (ver->version_num < 0x075400)
die("libcurl 7.84 or later is required to support paths in proxy URLs");
- if (!starts_with(proxy_auth.protocol, "socks"))
+ if (!is_socks_proxy_protocol(proxy_auth.protocol))
die("Invalid proxy URL '%s': only SOCKS proxies support paths",
curl_http_proxy);
diff --git a/t/t5564-http-proxy.sh b/t/t5564-http-proxy.sh
index 3bcbdef409..db69aa2295 100755
--- a/t/t5564-http-proxy.sh
+++ b/t/t5564-http-proxy.sh
@@ -95,4 +95,9 @@ test_expect_success 'Unix socket requires localhost' - <<\EOT
}
EOT
+test_expect_success 'unknown proxy scheme is rejected' '
+ ! git clone -c http.proxy=htpp://127.0.0.1 https://example.com/repo.git 2>err &&
+ grep -Fx "fatal: Invalid proxy URL '\''htpp://127.0.0.1'\'': unsupported proxy scheme '\''htpp'\''" err
+'
+
test_done
--
2.49.0.windows.1
^ permalink raw reply related
* [PATCH 0/1] http: reject unsupported proxy URL schemes
From: aminnimaj @ 2026-05-01 19:04 UTC (permalink / raw)
To: git; +Cc: peff, ryan.hendrickson, Aliwoto
From: Aliwoto <aminnimaj@gmail.com>
An explicit proxy URL with an unsupported scheme such as
htpp://127.0.0.1 is currently accepted and treated as an HTTP proxy.
This happens because Git parses the URL, extracts the host part, and
passes only that host to libcurl without rejecting the unsupported
scheme. As a result, the typo is silently accepted.
This patch rejects explicit unsupported proxy schemes while keeping the
existing host:port-without-scheme behavior unchanged, and adds a
regression test for the unsupported-scheme case.
Aliwoto (1):
http: reject unsupported proxy URL schemes
http.c | 79 +++++++++++++++++++++++++++++--------------
t/t5564-http-proxy.sh | 5 +++
2 files changed, 59 insertions(+), 25 deletions(-)
base-commit: 67ad42147a7acc2af6074753ebd03d904476118f
--
2.49.0.windows.1
^ permalink raw reply
* Re: [PATCH v3 5/5] format-rev: introduce builtin for on-demand pretty formatting
From: kristofferhaugsbakk @ 2026-05-01 18:27 UTC (permalink / raw)
To: phillip.wood123; +Cc: ben.knoble, git, kristofferhaugsbakk
In-Reply-To: <e8bb57a2-8eff-4f72-96ca-72d8880901e0@gmail.com>
On Fri, May 1, 2026, at 12:16, Phillip Wood wrote:
>>[snip]
>> • You can’t feed commits piecemeal to these commands, one input
>> for one output; they block until standard in is closed
>
> So you can feed them piecemeal but you don't get any output until you
> close stdin. That can be helpful as it means the calling process can
> write to "git log --stdin" and then read the output without worrying
> about getting deadlocked.
Okay. I don’t have much experience with concurrent programming.
> The Implementation below works fine if there
> are separate processes or threads writing to and reading from "git
> format-rev", but if we want a single process to be able to read from and
> write to "git format-rev --stdin-mode=text" there will need to be a way
> to delimit message boundaries so that git knows where the input message
> ends and the caller knows where the response ends.
Okay, so I guess a null-terminator mode for output.
> We'll also need to be
> careful about flushing the output at the end of a processed message.
I don’t get why this takes special care. I’ll think about it.
> For "--stdin-mode=revs" the caller cannot know how many lines the output
> will span because formats like %(trailers) will produce a variable
> number of lines depending on which trailers are present. It is also
> possible for a rev name to span more than one line. The following
> example finds the most recent commit that mentions 'cherry-pick' in the
> subject line
>
> :/^[^
> ]cherry-pick
>
> so we need a way to delimit the input and output records there as well.
Okay, so a null-terminator mode for input as well?
> I think the functionality implemented here is useful (transforming the
> output of 'git blame' or 'git-last-modified' are convicing examples) and
> it is probably better to do it as a command rather than adding a
> "--format" option to name-rev.
>
>> • You can’t feed a list of possibly duplicate commits, like the output
>> of git-last-modified(1); they effectively deduplicate the output
>
> That is definitely a problem
Great, thanks.
>> Beyond these two points there’s also the input massage problem: you
>
> s/massagge/message/?
No. I meant massaging the input so that it can be processed by whatever
tool you have. :) In this case splitting the object name column and file
column because tools like git-log(1) can only deal with revision input.
Thanks for reviewing the usability design.
--
Happy May Day
^ permalink raw reply
* Re: [PATCH v2 0/2] status: improve rebase todo list parsing
From: Phillip Wood @ 2026-05-01 18:19 UTC (permalink / raw)
To: Phillip Wood, git; +Cc: Elijah Newren, Patrick Steinhardt, Tian Yuchen
In-Reply-To: <cover.1777648598.git.phillip.wood@dunelm.org.uk>
On 01/05/2026 16:16, Phillip Wood wrote:
> When there is rebase in progress "git status" displays the last couple
> of completed and the next couple of pending commands from the todo
> list. When it does this is tries to abbreviate the object ids of
> the commits to be picked. Unfortunately it does not abbreviate the
> object ids when the line starts with "fixup -C" or "merge -C". It
> also mistakenly replaces the refname in "reset main" and "update-ref
> refs/heads/main" with the object id that the ref points to.
>
> This series fixes that. The first patch factors out the sequencer
> code that parses the command names in the todo list. The second patch
> uses that function in "git status" to parse the command names so that
> it knows whether the line may contain "-C" and whether there is an
> object id that should be abbreviated.
>
> Thanks to Elijah and Patrick for their comments in V1.
Sorry Tian, I'd forgotten that you'd commented on these patches as well
- thanks for your comments too.
Phillip
>
> Changes since V1:
>
> Patch 1 - Expanded commit message and added a code comment.
>
> Patch 2 - Fixed some typos, added a code comment and clarified that -Wswitch
> is included by -Wall.
>
> Base-Commit: 8c9303b1ffae5b745d1b0a1f98330cf7944d8db0
> Published-As: https://github.com/phillipwood/git/releases/tag/pw%2Fimprove-status-todo-list-parsing%2Fv2
> View-Changes-At: https://github.com/phillipwood/git/compare/8c9303b1f...b80bc1e0a
> Fetch-It-Via: git fetch https://github.com/phillipwood/git pw/improve-status-todo-list-parsing/v2
>
>
> Phillip Wood (2):
> sequencer: factor out parsing of todo commands
> status: improve rebase todo list parsing
>
> sequencer.c | 45 +++++++++-----
> sequencer.h | 8 +++
> t/t7512-status-help.sh | 74 +++++++++++++++--------
> wt-status.c | 131 +++++++++++++++++++++++++++++++++--------
> 4 files changed, 191 insertions(+), 67 deletions(-)
>
> Range-diff against v1:
> 1: 3d5135a719 ! 1: d27dddff93 sequencer: factor out parsing of todo commands
> @@ Metadata
> ## Commit message ##
> sequencer: factor out parsing of todo commands
>
> - Move the code that parses todo commands into a separate function so that
> - it can be shared with "git status" in the next commit.
> + Move the code that parses todo commands into a separate function so
> + that it can be shared with "git status" in the next commit. As we
> + know the input is NUL terminated we do not pass a pointer to the end
> + of the line and instead test for a blank line by looking for NUL, CR
> + LF, or LF. We use starts_with() instead of starts_with_mem() for the
> + same reason. This results in slightly different behavior when there
> + a CR at the start of the line that is not followed by LF. Previously
> + such a line was treated as a comment rather than an invalid line.
>
> Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
>
> @@ sequencer.h: int read_author_script(const char *path, char **name, char **email,
> int write_basic_state(struct replay_opts *opts, const char *head_name,
> struct commit *onto, const struct object_id *orig_head);
> void sequencer_post_commit_cleanup(struct repository *r, int verbose);
> ++
> ++/*
> ++ * Try to parse the todo command pointed to by *p. On success sets cmd,
> ++ * advances p and returns true. On failure returns false, leaves p and
> ++ * cmd unchanged.
> ++ */
> +bool sequencer_parse_todo_command(const char **p, enum todo_command *cmd);
> ++
> int sequencer_get_last_command(struct repository* r,
> enum replay_action *action);
> int sequencer_determine_whence(struct repository *r, enum commit_whence *whence);
> 2: d20dc1f655 ! 2: b80bc1e0a2 status: improve rebase todo list parsing
> @@ Commit message
>
> When there is rebase in progress "git status" displays the last couple
> of completed and the next couple of pending commands from the todo
> - list. When it does this is tries to abbreviate the object ids of
> + list. When it does this it tries to abbreviate the object ids of
> the commits to be picked. Unfortunately it does not abbreviate the
> object ids when the line starts with "fixup -C" or "merge -C". It
> also mistakenly replaces the refname in "reset main" and "update-ref
> @@ Commit message
> wider variety of commands. Only the pending commands in the tests
> are changed to avoid removing existing coverage.
>
> + Helped-by: Elijah Newren <newren@gmail.com>
> Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
>
> ## t/t7512-status-help.sh ##
> @@ wt-status.c: static int split_commit_in_progress(struct wt_status *s)
> return split_in_progress;
> +}
> +
> ++/*
> ++ * If the whitespace-delimited token starting at or just after *pp *
> ++ * is a hex object id that is longer than its default abbreviation, *
> ++ * abbreviate it in-place, shrinking `line` accordingly. On return
> ++ * *pp points one past the (possibly abbreviated) token. Leaves both
> ++ * `line` and *pp-advanced-past-the-token unchanged in all other cases
> ++ * (non-hex token, unresolvable, or a refname that happens to consist
> ++ * only of hex digits).
> ++ */
> +static void abbrev_oid_in_line(struct repository *r,
> + struct strbuf *line, char **pp)
> +{
> @@ wt-status.c: static int split_commit_in_progress(struct wt_status *s)
> + p += strspn(p, " \t");
> + end_of_object_name = p + strcspn(p, " \t");
> + /*
> -+ * The for "merge" and "reset" the object name may be a label or
> ++ * For "merge" and "reset" the object name may be a label or
> + * ref rather than a hex object id. Only abbreviate the object
> + * name if it is a hex object id.
> + */
> @@ wt-status.c: static int split_commit_in_progress(struct wt_status *s)
> + *pp = end_of_object_name;
> +}
> +
> -+static void skip_dash_c(char **pp) {
> ++static void skip_dash_c(char **pp)
> ++{
> + char *p = *pp;
> +
> + p += strspn(p, " \t");
> -+ /* The (void) cast is required to silence -Wunused_value */
> ++ /* The (void) cast is required to silence -Wunused-value */
> + (void)(skip_prefix(p, "-C", &p) || skip_prefix(p, "-c", &p));
> + *pp = p;
> }
> @@ wt-status.c: static int split_commit_in_progress(struct wt_status *s)
> +
> + /*
> + * Avoid "default" and instead list all the other commands so
> -+ * that -Wswitch warns if a new command is added without handling
> -+ * it in this function.
> ++ * that -Wswitch (which is included in -Wall) warns if a new
> ++ * command is added without handling it in this function.
> + */
> + case TODO_BREAK:
> + case TODO_EXEC:
^ permalink raw reply
* Re: [PATCH v3 3/5] name-rev: factor code for sharing with a new command
From: kristofferhaugsbakk @ 2026-05-01 17:24 UTC (permalink / raw)
To: phillip.wood123; +Cc: ben.knoble, git, kristofferhaugsbakk, phillip.wood
In-Reply-To: <8016697f-9eb7-4c75-be87-d9479186919c@gmail.com>
Hi Phillip. Thanks for taking a look.
On Thu, Apr 30, 2026, at 15:54, Phillip Wood wrote:
>>[snip]
>> @@ -524,25 +543,32 @@ static void name_rev_line(char *p, struct name_ref_data *data)
>> const char *name = NULL;
>> char c = *(p + 1);
>> int p_len = p - p_start + 1;
>> + struct object *o = NULL;
>> + int oid_ret = 1;
>>
>> counter = 0;
>>
>> *(p + 1) = 0;
>> - if (!repo_get_oid(the_repository, p - (hexsz - 1), &oid)) {
>> - struct object *o =
>> - lookup_object(the_repository, &oid);
>> + oid_ret = repo_get_oid(the_repository, p - (hexsz - 1), &oid);
>
> It would be safer to restore *(p + 1) here rather that relying on each
> case block to do it.
Yeah, I didn’t want to repeat that bookkeeping but in some iteration it
looked necessary. But it’s good that it isn’t.
>
> *(p + 1) = c;
>> +
>> + switch (cmd->type) {
>> + case NAME_REV:
>> + if (!oid_ret)
>> + o = lookup_object(the_repository, &oid);
>> if (o)
>> name = get_rev_name(o, &buf);
>> + *(p + 1) = c;
>> + if (!name)
>> + goto start;
>
> The pre-image uses "continue" which will increment p - why the change in
> behavior?
They looked the same to me. So I will need to think about this some
more. Just a lack of C experience on my part.
Replacing the `continue` with a goto at the start of the loop was also
unnecessary. Of course the `continue` breaks out of the loop and not the
switch-block (unlike `break`).
But I didn’t break `t6120-describe.sh`. So I’ll also take a look to see
if there are any holes.
Thanks again.
>[snip]
--
Happy May Day
^ permalink raw reply
* Re: [PATCH v3 1/1] git-gui: handle missing worktree and separated gitdir
From: Mark Levedahl @ 2026-05-01 16:42 UTC (permalink / raw)
To: Johannes Sixt, Shroom Moo; +Cc: git
In-Reply-To: <77219c75-7968-413f-a642-0446145c8023@kdbg.org>
On 5/1/26 9:13 AM, Johannes Sixt wrote:
> Am 30.04.26 um 18:18 schrieb Mark Levedahl:
>>
>> On 4/30/26 6:02 AM, Shroom Moo wrote:
>> We have quite a bit of code that attempts to make Git GUI work from the
> .git directory and also in bare repositories.
>
> 87cd09f43e56 ("git-gui: work from the .git dir", 2010-01-23) made the
> first step. The original code just used the $_gitdir as the working
> directory. However, at that time we did not have alternate worktrees,
> and the old code, when used today, does not work in a `git
> worktree`-created worktree. Later, the `git rev-parse --show-toplevel`
> call came with 38ec8d3e2652 ("git-gui: correct assignment of work-tree",
> 2010-10-20). However, it also changes the fall-back code slightly, so
> that running Git GUI from the .git directory would not work the same way
> as before and takes the .git directory as the work tree (because in the
> .git directory --show-cdup is not "..", but empty).
>
> I think we need to restructure the existing flow a bit and not just fix
> a single spot in the code. I suggest this order of operation:
>
> 1. Handle the bare repository case. If not enabled, fail. Otherwise, we
> can work with an empty $_gitworktree.
>
> 2. Collect --show-toplevel into $_gitworktree.
>
> 2a. If this failed: If --is-inside-git-dir is true, and the last
> $_gitdir directory component is exactly ".git", take the parent
> repository as $_gitworktree. Otherwise, fail.
>
> 3. Handle all the other edge cases, if any, with the so determined
> $_gitworktree. (I didn't think through, yet, what needs to be done.)
>
> -- Hannes
>
I found one horrid edge case:
Start git-gui in a gitdir not embedded in a worktree, with core.bare=false as there are
one or more gitfile and/or symlinked worktrees elsewhere.
- current git-gui aborts with an uncaught error. Good.
- git-gui with the wrapped --show-toplevel call finds no worktree to switch to, so runs in
the gitdir allowing commits of the gitdir items.
- I just added and committed the *file* refs/heads/master to branch master in such a gitdir.
git-gui's normal gui must be started ONLY if rev-parse --is-inside-work-tree is true. (The
blame view invoked by gitk in theory could be allowed to run in a bare repository
read-only mode.).
For read/write mode:
if --is-inside-git-dir == true at startup, we must abort, or find a valid worktree and
switch to that.
My personal preference is for git-gui to abort:
I started git-gui where it cannot run.
My error. Let me learn and fix that.
Alternatively, ask me what to do:
e.g., prepare a dialog after looking at git-worktree list, and the parent dir IFF this
dir is named .git, telling me of my mistake and offering me one or more worktrees to
switch to.
But please, don't just switch to another directory without asking. This is just
encouraging me to make careless errors.
Mark
^ permalink raw reply
* Re: git rename/moved status unreliable in ruby
From: Phillip Wood @ 2026-05-01 15:30 UTC (permalink / raw)
To: sebastien.stettler, git@vger.kernel.org
In-Reply-To: <OsOzcjEwvHCQSghLE8LD_wHb_jDlil9I88OUuhpiRONnVd1o9p3gStbK1mx4q7OwY3ePtbZO-BBgTNOCeJ2DMyvBsdlMhRmDrTP894KP5xo=@proton.me>
Hi Sebastien
On 01/05/2026 06:05, sebastien.stettler wrote:
> 1. What did you do before the bug happened? (Steps to reproduce your issue)
>
> when moving ruby classes between namespaces they are marked as new files and the old
> ones are marked as deleted
>
> if i only change the class name it will mark it as renamed
Rename detection is based on how similar the two files are. Looking at
the example you linked to below you're changing a file that looks like
module Math
class Calculator
def add(a, b)
a + b
...
end
end
end
to
module Math
module Calculators
class Calculator
def add(a, b)
a + b
...
end
end
end
end
Which means that git sees that every line has changed because the
indentation has changed. If you want git to realize that the file has
been renamed you could move it in one commit and then add modify it in
the next commit.
Thanks
Phillip
> 2. What did you expect to happen? (Expected behavior)
>
> in the namespace state i would expected it to be marked as moved since
> nothing has fundementally changed
>
> 3. What happened instead? (Actual behavior)
>
> the file was marked as new file and the old file was marked as deleted
>
> What's different between what you expected and what actually happened
>
> 4. Anything else you want to add:
>
> I have demonstrated the behavior here https://github.com/billybonks/git-rename
>
> Mostly i would like to understand what is the expectation from gits point of view in these mutations.
> If this is considered something that can be improved i am happy to build out more test cases, and help with implementation.
>
> if not, understanding the reasoning would be great
>
> Thank you.
>
>
>
> [System Info]
> git version:
> git version 2.47.1
> cpu: arm64
> no commit associated with this build
> sizeof-long: 8
> sizeof-size_t: 8
> shell-path: /bin/sh
> feature: fsmonitor--daemon
> libcurl: 8.7.1
> zlib: 1.2.12
> uname: Darwin 25.3.0 Darwin Kernel Version 25.3.0: Wed Jan 28 20:51:28 PST 2026; root:xnu-12377.91.3~2/RELEASE_ARM64_T6041 arm64
> compiler info: clang: 16.0.0 (clang-1600.0.26.4)
> libc info: no libc information available
> $SHELL (typically, interactive shell): /bin/zsh
>
>
> [Enabled Hooks]
>
>
> Sent with Proton Mail secure email.
>
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox