mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Johannes Schindelin](/assets/img/avatar_default.png)
These were not caught by the previous commit, as they did not match the regular expression. While at it, remove the localization from one instance: we never want BUG() messages to be translated, as they target Git developers, not the end user (hence it would be quite unhelpful to not only burden the translators, but then even end up with a bug report in a language that no core Git contributor understands). Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
366 lines
9.7 KiB
C
366 lines
9.7 KiB
C
/*
|
|
* Licensed under a two-clause BSD-style license.
|
|
* See LICENSE for details.
|
|
*/
|
|
|
|
#include "cache.h"
|
|
#include "quote.h"
|
|
#include "fast_export.h"
|
|
#include "strbuf.h"
|
|
#include "svndiff.h"
|
|
#include "sliding_window.h"
|
|
#include "line_buffer.h"
|
|
|
|
#define MAX_GITSVN_LINE_LEN 4096
|
|
|
|
static uint32_t first_commit_done;
|
|
static struct line_buffer postimage = LINE_BUFFER_INIT;
|
|
static struct line_buffer report_buffer = LINE_BUFFER_INIT;
|
|
|
|
/* NEEDSWORK: move to fast_export_init() */
|
|
static int init_postimage(void)
|
|
{
|
|
static int postimage_initialized;
|
|
if (postimage_initialized)
|
|
return 0;
|
|
postimage_initialized = 1;
|
|
return buffer_tmpfile_init(&postimage);
|
|
}
|
|
|
|
void fast_export_init(int fd)
|
|
{
|
|
first_commit_done = 0;
|
|
if (buffer_fdinit(&report_buffer, fd))
|
|
die_errno("cannot read from file descriptor %d", fd);
|
|
}
|
|
|
|
void fast_export_deinit(void)
|
|
{
|
|
if (buffer_deinit(&report_buffer))
|
|
die_errno("error closing fast-import feedback stream");
|
|
}
|
|
|
|
void fast_export_delete(const char *path)
|
|
{
|
|
putchar('D');
|
|
putchar(' ');
|
|
quote_c_style(path, NULL, stdout, 0);
|
|
putchar('\n');
|
|
}
|
|
|
|
static void fast_export_truncate(const char *path, uint32_t mode)
|
|
{
|
|
fast_export_modify(path, mode, "inline");
|
|
printf("data 0\n\n");
|
|
}
|
|
|
|
void fast_export_modify(const char *path, uint32_t mode, const char *dataref)
|
|
{
|
|
/* Mode must be 100644, 100755, 120000, or 160000. */
|
|
if (!dataref) {
|
|
fast_export_truncate(path, mode);
|
|
return;
|
|
}
|
|
printf("M %06"PRIo32" %s ", mode, dataref);
|
|
quote_c_style(path, NULL, stdout, 0);
|
|
putchar('\n');
|
|
}
|
|
|
|
void fast_export_begin_note(uint32_t revision, const char *author,
|
|
const char *log, timestamp_t timestamp, const char *note_ref)
|
|
{
|
|
static int firstnote = 1;
|
|
size_t loglen = strlen(log);
|
|
printf("commit %s\n", note_ref);
|
|
printf("committer %s <%s@%s> %"PRItime" +0000\n", author, author, "local", timestamp);
|
|
printf("data %"PRIuMAX"\n", (uintmax_t)loglen);
|
|
fwrite(log, loglen, 1, stdout);
|
|
if (firstnote) {
|
|
if (revision > 1)
|
|
printf("from %s^0", note_ref);
|
|
firstnote = 0;
|
|
}
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
void fast_export_note(const char *committish, const char *dataref)
|
|
{
|
|
printf("N %s %s\n", dataref, committish);
|
|
}
|
|
|
|
static char gitsvnline[MAX_GITSVN_LINE_LEN];
|
|
void fast_export_begin_commit(uint32_t revision, const char *author,
|
|
const struct strbuf *log,
|
|
const char *uuid, const char *url,
|
|
timestamp_t timestamp, const char *local_ref)
|
|
{
|
|
static const struct strbuf empty = STRBUF_INIT;
|
|
if (!log)
|
|
log = ∅
|
|
if (*uuid && *url) {
|
|
snprintf(gitsvnline, MAX_GITSVN_LINE_LEN,
|
|
"\n\ngit-svn-id: %s@%"PRIu32" %s\n",
|
|
url, revision, uuid);
|
|
} else {
|
|
*gitsvnline = '\0';
|
|
}
|
|
printf("commit %s\n", local_ref);
|
|
printf("mark :%"PRIu32"\n", revision);
|
|
printf("committer %s <%s@%s> %"PRItime" +0000\n",
|
|
*author ? author : "nobody",
|
|
*author ? author : "nobody",
|
|
*uuid ? uuid : "local", timestamp);
|
|
printf("data %"PRIuMAX"\n",
|
|
(uintmax_t) (log->len + strlen(gitsvnline)));
|
|
fwrite(log->buf, log->len, 1, stdout);
|
|
printf("%s\n", gitsvnline);
|
|
if (!first_commit_done) {
|
|
if (revision > 1)
|
|
printf("from :%"PRIu32"\n", revision - 1);
|
|
first_commit_done = 1;
|
|
}
|
|
}
|
|
|
|
void fast_export_end_commit(uint32_t revision)
|
|
{
|
|
printf("progress Imported commit %"PRIu32".\n\n", revision);
|
|
}
|
|
|
|
static void ls_from_rev(uint32_t rev, const char *path)
|
|
{
|
|
/* ls :5 path/to/old/file */
|
|
printf("ls :%"PRIu32" ", rev);
|
|
quote_c_style(path, NULL, stdout, 0);
|
|
putchar('\n');
|
|
fflush(stdout);
|
|
}
|
|
|
|
static void ls_from_active_commit(const char *path)
|
|
{
|
|
/* ls "path/to/file" */
|
|
printf("ls \"");
|
|
quote_c_style(path, NULL, stdout, 1);
|
|
printf("\"\n");
|
|
fflush(stdout);
|
|
}
|
|
|
|
static const char *get_response_line(void)
|
|
{
|
|
const char *line = buffer_read_line(&report_buffer);
|
|
if (line)
|
|
return line;
|
|
if (buffer_ferror(&report_buffer))
|
|
die_errno("error reading from fast-import");
|
|
die("unexpected end of fast-import feedback");
|
|
}
|
|
|
|
static void die_short_read(struct line_buffer *input)
|
|
{
|
|
if (buffer_ferror(input))
|
|
die_errno("error reading dump file");
|
|
die("invalid dump: unexpected end of file");
|
|
}
|
|
|
|
static int parse_cat_response_line(const char *header, off_t *len)
|
|
{
|
|
uintmax_t n;
|
|
const char *type;
|
|
const char *end;
|
|
|
|
if (ends_with(header, " missing"))
|
|
return error("cat-blob reports missing blob: %s", header);
|
|
type = strstr(header, " blob ");
|
|
if (!type)
|
|
return error("cat-blob header has wrong object type: %s", header);
|
|
n = strtoumax(type + strlen(" blob "), (char **) &end, 10);
|
|
if (end == type + strlen(" blob "))
|
|
return error("cat-blob header does not contain length: %s", header);
|
|
if (memchr(type + strlen(" blob "), '-', end - type - strlen(" blob ")))
|
|
return error("cat-blob header contains negative length: %s", header);
|
|
if (n == UINTMAX_MAX || n > maximum_signed_value_of_type(off_t))
|
|
return error("blob too large for current definition of off_t");
|
|
*len = n;
|
|
if (*end)
|
|
return error("cat-blob header contains garbage after length: %s", header);
|
|
return 0;
|
|
}
|
|
|
|
static void check_preimage_overflow(off_t a, off_t b)
|
|
{
|
|
if (signed_add_overflows(a, b))
|
|
die("blob too large for current definition of off_t");
|
|
}
|
|
|
|
static long apply_delta(off_t len, struct line_buffer *input,
|
|
const char *old_data, uint32_t old_mode)
|
|
{
|
|
long ret;
|
|
struct sliding_view preimage = SLIDING_VIEW_INIT(&report_buffer, 0);
|
|
FILE *out;
|
|
|
|
if (init_postimage() || !(out = buffer_tmpfile_rewind(&postimage)))
|
|
die("cannot open temporary file for blob retrieval");
|
|
if (old_data) {
|
|
const char *response;
|
|
printf("cat-blob %s\n", old_data);
|
|
fflush(stdout);
|
|
response = get_response_line();
|
|
if (parse_cat_response_line(response, &preimage.max_off))
|
|
die("invalid cat-blob response: %s", response);
|
|
check_preimage_overflow(preimage.max_off, 1);
|
|
}
|
|
if (old_mode == S_IFLNK) {
|
|
strbuf_addstr(&preimage.buf, "link ");
|
|
check_preimage_overflow(preimage.max_off, strlen("link "));
|
|
preimage.max_off += strlen("link ");
|
|
check_preimage_overflow(preimage.max_off, 1);
|
|
}
|
|
if (svndiff0_apply(input, len, &preimage, out))
|
|
die("cannot apply delta");
|
|
if (old_data) {
|
|
/* Read the remainder of preimage and trailing newline. */
|
|
assert(!signed_add_overflows(preimage.max_off, 1));
|
|
preimage.max_off++; /* room for newline */
|
|
if (move_window(&preimage, preimage.max_off - 1, 1))
|
|
die("cannot seek to end of input");
|
|
if (preimage.buf.buf[0] != '\n')
|
|
die("missing newline after cat-blob response");
|
|
}
|
|
ret = buffer_tmpfile_prepare_to_read(&postimage);
|
|
if (ret < 0)
|
|
die("cannot read temporary file for blob retrieval");
|
|
strbuf_release(&preimage.buf);
|
|
return ret;
|
|
}
|
|
|
|
void fast_export_buf_to_data(const struct strbuf *data)
|
|
{
|
|
printf("data %"PRIuMAX"\n", (uintmax_t)data->len);
|
|
fwrite(data->buf, data->len, 1, stdout);
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
void fast_export_data(uint32_t mode, off_t len, struct line_buffer *input)
|
|
{
|
|
assert(len >= 0);
|
|
if (mode == S_IFLNK) {
|
|
/* svn symlink blobs start with "link " */
|
|
if (len < 5)
|
|
die("invalid dump: symlink too short for \"link\" prefix");
|
|
len -= 5;
|
|
if (buffer_skip_bytes(input, 5) != 5)
|
|
die_short_read(input);
|
|
}
|
|
printf("data %"PRIuMAX"\n", (uintmax_t) len);
|
|
if (buffer_copy_bytes(input, len) != len)
|
|
die_short_read(input);
|
|
fputc('\n', stdout);
|
|
}
|
|
|
|
static int parse_ls_response(const char *response, uint32_t *mode,
|
|
struct strbuf *dataref)
|
|
{
|
|
const char *tab;
|
|
const char *response_end;
|
|
|
|
assert(response);
|
|
response_end = response + strlen(response);
|
|
|
|
if (*response == 'm') { /* Missing. */
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
|
|
/* Mode. */
|
|
if (response_end - response < (signed) strlen("100644") ||
|
|
response[strlen("100644")] != ' ')
|
|
die("invalid ls response: missing mode: %s", response);
|
|
*mode = 0;
|
|
for (; *response != ' '; response++) {
|
|
char ch = *response;
|
|
if (ch < '0' || ch > '7')
|
|
die("invalid ls response: mode is not octal: %s", response);
|
|
*mode *= 8;
|
|
*mode += ch - '0';
|
|
}
|
|
|
|
/* ' blob ' or ' tree ' */
|
|
if (response_end - response < (signed) strlen(" blob ") ||
|
|
(response[1] != 'b' && response[1] != 't'))
|
|
die("unexpected ls response: not a tree or blob: %s", response);
|
|
response += strlen(" blob ");
|
|
|
|
/* Dataref. */
|
|
tab = memchr(response, '\t', response_end - response);
|
|
if (!tab)
|
|
die("invalid ls response: missing tab: %s", response);
|
|
strbuf_add(dataref, response, tab - response);
|
|
return 0;
|
|
}
|
|
|
|
int fast_export_ls_rev(uint32_t rev, const char *path,
|
|
uint32_t *mode, struct strbuf *dataref)
|
|
{
|
|
ls_from_rev(rev, path);
|
|
return parse_ls_response(get_response_line(), mode, dataref);
|
|
}
|
|
|
|
int fast_export_ls(const char *path, uint32_t *mode, struct strbuf *dataref)
|
|
{
|
|
ls_from_active_commit(path);
|
|
return parse_ls_response(get_response_line(), mode, dataref);
|
|
}
|
|
|
|
const char *fast_export_read_path(const char *path, uint32_t *mode_out)
|
|
{
|
|
int err;
|
|
static struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_reset(&buf);
|
|
err = fast_export_ls(path, mode_out, &buf);
|
|
if (err) {
|
|
if (errno != ENOENT)
|
|
BUG("unexpected fast_export_ls error: %s",
|
|
strerror(errno));
|
|
/* Treat missing paths as directories. */
|
|
*mode_out = S_IFDIR;
|
|
return NULL;
|
|
}
|
|
return buf.buf;
|
|
}
|
|
|
|
void fast_export_copy(uint32_t revision, const char *src, const char *dst)
|
|
{
|
|
int err;
|
|
uint32_t mode;
|
|
static struct strbuf data = STRBUF_INIT;
|
|
|
|
strbuf_reset(&data);
|
|
err = fast_export_ls_rev(revision, src, &mode, &data);
|
|
if (err) {
|
|
if (errno != ENOENT)
|
|
BUG("unexpected fast_export_ls_rev error: %s",
|
|
strerror(errno));
|
|
fast_export_delete(dst);
|
|
return;
|
|
}
|
|
fast_export_modify(dst, mode, data.buf);
|
|
}
|
|
|
|
void fast_export_blob_delta(uint32_t mode,
|
|
uint32_t old_mode, const char *old_data,
|
|
off_t len, struct line_buffer *input)
|
|
{
|
|
long postimage_len;
|
|
|
|
assert(len >= 0);
|
|
postimage_len = apply_delta(len, input, old_data, old_mode);
|
|
if (mode == S_IFLNK) {
|
|
buffer_skip_bytes(&postimage, strlen("link "));
|
|
postimage_len -= strlen("link ");
|
|
}
|
|
printf("data %ld\n", postimage_len);
|
|
buffer_copy_bytes(&postimage, postimage_len);
|
|
fputc('\n', stdout);
|
|
}
|