mirror of
https://github.com/git/git
synced 2024-10-30 04:01:21 +00:00
7ce4088ab7
When handling OPT_FILENAME(), we have to stick the "prefix" (if any) in
front of the filename to make up for the fact that Git has chdir()'d to
the top of the repository. We can do this with prefix_filename(), but
there are a few special cases we handle ourselves.
Unfortunately the memory allocation is inconsistent here; if we do make
it to prefix_filename(), we'll allocate a string which the caller must
free to avoid a leak. But if we hit our special cases, we'll return the
string as-is, and a caller which tries to free it will crash. So there's
no way to win.
Let's consistently allocate, so that callers can do the right thing.
There are now three cases to care about in the function (and hence a
three-armed if/else):
1. we got a NULL input (and should leave it as NULL, though arguably
this is the sign of a bug; let's keep the status quo for now and we
can pick at that scab later)
2. we hit a special case that means we leave the name intact; we
should duplicate the string. This includes our special "-"
matching. Prior to this patch, it also included empty prefixes and
absolute filenames. But we can observe that prefix_filename()
already handles these, so we don't need to detect them.
3. everything else goes to prefix_filename()
I've dropped the "const" from the "char **file" parameter to indicate
that we're allocating, though in practice it's not really important.
This is all being shuffled through a void pointer via opt->value before
it hits code which ever looks at the string. And it's even a bit weird,
because we are really taking _in_ a const string and using the same
out-parameter for a non-const string. A better function signature would
be:
static char *fix_filename(const char *prefix, const char *file);
but that would mean the caller dereferences the double-pointer (and the
NULL check is currently handled inside this function). So I took the
path of least-change here.
Note that we have to fix several callers in this commit, too, or we'll
break the leak-checking tests. These are "new" leaks in the sense that
they are now triggered by the test suite, but these spots have always
been leaky when Git is run in a subdirectory of the repository. I fixed
all of the cases that trigger with GIT_TEST_PASSING_SANITIZE_LEAK. There
may be others in scripts that have other leaks, but we can fix them
later along with those other leaks (and again, you _couldn't_ fix them
before this patch, so this is the necessary first step).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
111 lines
3.1 KiB
C
111 lines
3.1 KiB
C
/*
|
|
* Copyright (c) 2006 Franck Bui-Huu
|
|
* Copyright (c) 2006 Rene Scharfe
|
|
*/
|
|
#include "cache.h"
|
|
#include "builtin.h"
|
|
#include "archive.h"
|
|
#include "transport.h"
|
|
#include "parse-options.h"
|
|
#include "pkt-line.h"
|
|
#include "sideband.h"
|
|
|
|
static void create_output_file(const char *output_file)
|
|
{
|
|
int output_fd = xopen(output_file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
|
|
if (output_fd != 1) {
|
|
if (dup2(output_fd, 1) < 0)
|
|
die_errno(_("could not redirect output"));
|
|
else
|
|
close(output_fd);
|
|
}
|
|
}
|
|
|
|
static int run_remote_archiver(int argc, const char **argv,
|
|
const char *remote, const char *exec,
|
|
const char *name_hint)
|
|
{
|
|
int fd[2], i, rv;
|
|
struct transport *transport;
|
|
struct remote *_remote;
|
|
struct packet_reader reader;
|
|
|
|
_remote = remote_get(remote);
|
|
if (!_remote->url[0])
|
|
die(_("git archive: Remote with no URL"));
|
|
transport = transport_get(_remote, _remote->url[0]);
|
|
transport_connect(transport, "git-upload-archive", exec, fd);
|
|
|
|
/*
|
|
* Inject a fake --format field at the beginning of the
|
|
* arguments, with the format inferred from our output
|
|
* filename. This way explicit --format options can override
|
|
* it.
|
|
*/
|
|
if (name_hint) {
|
|
const char *format = archive_format_from_filename(name_hint);
|
|
if (format)
|
|
packet_write_fmt(fd[1], "argument --format=%s\n", format);
|
|
}
|
|
for (i = 1; i < argc; i++)
|
|
packet_write_fmt(fd[1], "argument %s\n", argv[i]);
|
|
packet_flush(fd[1]);
|
|
|
|
packet_reader_init(&reader, fd[0], NULL, 0,
|
|
PACKET_READ_CHOMP_NEWLINE |
|
|
PACKET_READ_DIE_ON_ERR_PACKET);
|
|
|
|
if (packet_reader_read(&reader) != PACKET_READ_NORMAL)
|
|
die(_("git archive: expected ACK/NAK, got a flush packet"));
|
|
if (strcmp(reader.line, "ACK")) {
|
|
if (starts_with(reader.line, "NACK "))
|
|
die(_("git archive: NACK %s"), reader.line + 5);
|
|
die(_("git archive: protocol error"));
|
|
}
|
|
|
|
if (packet_reader_read(&reader) != PACKET_READ_FLUSH)
|
|
die(_("git archive: expected a flush"));
|
|
|
|
/* Now, start reading from fd[0] and spit it out to stdout */
|
|
rv = recv_sideband("archive", fd[0], 1);
|
|
rv |= transport_disconnect(transport);
|
|
|
|
return !!rv;
|
|
}
|
|
|
|
#define PARSE_OPT_KEEP_ALL ( PARSE_OPT_KEEP_DASHDASH | \
|
|
PARSE_OPT_KEEP_ARGV0 | \
|
|
PARSE_OPT_KEEP_UNKNOWN_OPT | \
|
|
PARSE_OPT_NO_INTERNAL_HELP )
|
|
|
|
int cmd_archive(int argc, const char **argv, const char *prefix)
|
|
{
|
|
const char *exec = "git-upload-archive";
|
|
char *output = NULL;
|
|
const char *remote = NULL;
|
|
struct option local_opts[] = {
|
|
OPT_FILENAME('o', "output", &output,
|
|
N_("write the archive to this file")),
|
|
OPT_STRING(0, "remote", &remote, N_("repo"),
|
|
N_("retrieve the archive from remote repository <repo>")),
|
|
OPT_STRING(0, "exec", &exec, N_("command"),
|
|
N_("path to the remote git-upload-archive command")),
|
|
OPT_END()
|
|
};
|
|
|
|
argc = parse_options(argc, argv, prefix, local_opts, NULL,
|
|
PARSE_OPT_KEEP_ALL);
|
|
|
|
init_archivers();
|
|
|
|
if (output)
|
|
create_output_file(output);
|
|
|
|
if (remote)
|
|
return run_remote_archiver(argc, argv, remote, exec, output);
|
|
|
|
setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
|
|
|
|
UNLEAK(output);
|
|
return write_archive(argc, argv, prefix, the_repository, output, 0);
|
|
}
|