mirror of
https://github.com/git/git
synced 2024-07-17 02:57:48 +00:00
Merge branch 'db/delta-applier' into db/text-delta
* db/delta-applier: vcs-svn: let deltas use data from preimage vcs-svn: let deltas use data from postimage vcs-svn: verify that deltas consume all inline data vcs-svn: implement copyfrom_data delta instruction vcs-svn: read instructions from deltas vcs-svn: read inline data from deltas vcs-svn: read the preimage when applying deltas vcs-svn: parse svndiff0 window header vcs-svn: skeleton of an svn delta parser vcs-svn: make buffer_read_binary API more convenient vcs-svn: learn to maintain a sliding view of a file Makefile: list one vcs-svn/xdiff object or header per line Conflicts: Makefile vcs-svn/LICENSE
This commit is contained in:
Jonathan Nieder
commit
e9f3f8b6f4
51
Makefile
51
Makefile
|
|
@ -342,6 +342,11 @@ BUILTIN_OBJS =
|
|||
BUILT_INS =
|
||||
COMPAT_CFLAGS =
|
||||
COMPAT_OBJS =
|
||||
XDIFF_H =
|
||||
XDIFF_OBJS =
|
||||
VCSSVN_H =
|
||||
VCSSVN_OBJS =
|
||||
VCSSVN_TEST_OBJS =
|
||||
EXTRA_CPPFLAGS =
|
||||
LIB_H =
|
||||
LIB_OBJS =
|
||||
|
|
@ -1832,11 +1837,23 @@ GIT_OBJS := $(LIB_OBJS) $(BUILTIN_OBJS) $(PROGRAM_OBJS) $(TEST_OBJS) \
|
|||
ifndef NO_CURL
|
||||
GIT_OBJS += http.o http-walker.o remote-curl.o
|
||||
endif
|
||||
XDIFF_OBJS = xdiff/xdiffi.o xdiff/xprepare.o xdiff/xutils.o xdiff/xemit.o \
|
||||
xdiff/xmerge.o xdiff/xpatience.o
|
||||
VCSSVN_OBJS = vcs-svn/line_buffer.o vcs-svn/repo_tree.o \
|
||||
vcs-svn/fast_export.o vcs-svn/svndump.o
|
||||
VCSSVN_TEST_OBJS = test-line-buffer.o
|
||||
|
||||
XDIFF_OBJS += xdiff/xdiffi.o
|
||||
XDIFF_OBJS += xdiff/xprepare.o
|
||||
XDIFF_OBJS += xdiff/xutils.o
|
||||
XDIFF_OBJS += xdiff/xemit.o
|
||||
XDIFF_OBJS += xdiff/xmerge.o
|
||||
XDIFF_OBJS += xdiff/xpatience.o
|
||||
|
||||
VCSSVN_OBJS += vcs-svn/line_buffer.o
|
||||
VCSSVN_OBJS += vcs-svn/sliding_window.o
|
||||
VCSSVN_OBJS += vcs-svn/repo_tree.o
|
||||
VCSSVN_OBJS += vcs-svn/fast_export.o
|
||||
VCSSVN_OBJS += vcs-svn/svndiff.o
|
||||
VCSSVN_OBJS += vcs-svn/svndump.o
|
||||
|
||||
VCSSVN_TEST_OBJS += test-line-buffer.o
|
||||
|
||||
OBJECTS := $(GIT_OBJS) $(XDIFF_OBJS) $(VCSSVN_OBJS)
|
||||
|
||||
dep_files := $(foreach f,$(OBJECTS),$(dir $f).depend/$(notdir $f).d)
|
||||
|
|
@ -1955,15 +1972,25 @@ connect.o transport.o http-backend.o: url.h
|
|||
http-fetch.o http-walker.o remote-curl.o transport.o walker.o: walker.h
|
||||
http.o http-walker.o http-push.o http-fetch.o remote-curl.o: http.h url.h
|
||||
|
||||
xdiff-interface.o $(XDIFF_OBJS): \
|
||||
xdiff/xinclude.h xdiff/xmacros.h xdiff/xdiff.h xdiff/xtypes.h \
|
||||
xdiff/xutils.h xdiff/xprepare.h xdiff/xdiffi.h xdiff/xemit.h
|
||||
XDIFF_H += xdiff/xinclude.h
|
||||
XDIFF_H += xdiff/xmacros.h
|
||||
XDIFF_H += xdiff/xdiff.h
|
||||
XDIFF_H += xdiff/xtypes.h
|
||||
XDIFF_H += xdiff/xutils.h
|
||||
XDIFF_H += xdiff/xprepare.h
|
||||
XDIFF_H += xdiff/xdiffi.h
|
||||
XDIFF_H += xdiff/xemit.h
|
||||
|
||||
$(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) \
|
||||
vcs-svn/line_buffer.h vcs-svn/repo_tree.h vcs-svn/fast_export.h \
|
||||
vcs-svn/svndump.h
|
||||
xdiff-interface.o $(XDIFF_OBJS): $(XDIFF_H)
|
||||
|
||||
test-svn-fe.o: vcs-svn/svndump.h
|
||||
VCSSVN_H += vcs-svn/line_buffer.h
|
||||
VCSSVN_H += vcs-svn/sliding_window.h
|
||||
VCSSVN_H += vcs-svn/repo_tree.h
|
||||
VCSSVN_H += vcs-svn/fast_export.h
|
||||
VCSSVN_H += vcs-svn/svndiff.h
|
||||
VCSSVN_H += vcs-svn/svndump.h
|
||||
|
||||
$(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) $(VCSSVN_H)
|
||||
endif
|
||||
|
||||
exec_cmd.s exec_cmd.o: EXTRA_CPPFLAGS = \
|
||||
|
|
|
|||
248
t/t9011-svn-da.sh
Executable file
248
t/t9011-svn-da.sh
Executable file
|
|
@ -0,0 +1,248 @@
|
|||
#!/bin/sh
|
||||
|
||||
test_description='test parsing of svndiff0 files
|
||||
|
||||
Using the "test-svn-fe -d" helper, check that svn-fe correctly
|
||||
interprets deltas using various facilities (some from the spec,
|
||||
some only learned from practice).
|
||||
'
|
||||
. ./test-lib.sh
|
||||
|
||||
>empty
|
||||
printf foo >preimage
|
||||
|
||||
test_expect_success 'reject empty delta' '
|
||||
test_must_fail test-svn-fe -d preimage empty 0
|
||||
'
|
||||
|
||||
test_expect_success 'delta can empty file' '
|
||||
printf "SVNQ" | q_to_nul >clear.delta &&
|
||||
test-svn-fe -d preimage clear.delta 4 >actual &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'reject svndiff2' '
|
||||
printf "SVN\002" >bad.filetype &&
|
||||
test_must_fail test-svn-fe -d preimage bad.filetype 4
|
||||
'
|
||||
|
||||
test_expect_success 'one-window empty delta' '
|
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
|
||||
test-svn-fe -d preimage clear.onewindow 9 >actual &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'reject incomplete window header' '
|
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
|
||||
printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow &&
|
||||
test_must_fail test-svn-fe -d preimage clear.onewindow 6 &&
|
||||
test_must_fail test-svn-fe -d preimage clear.partialwindow 6
|
||||
'
|
||||
|
||||
test_expect_success 'reject declared delta longer than actual delta' '
|
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
|
||||
printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow &&
|
||||
test_must_fail test-svn-fe -d preimage clear.onewindow 14 &&
|
||||
test_must_fail test-svn-fe -d preimage clear.partialwindow 9
|
||||
'
|
||||
|
||||
test_expect_success 'two-window empty delta' '
|
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQQ" | q_to_nul >clear.twowindow &&
|
||||
test-svn-fe -d preimage clear.twowindow 14 >actual &&
|
||||
test_must_fail test-svn-fe -d preimage clear.twowindow 13 &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'noisy zeroes' '
|
||||
printf "SVNQ%s" \
|
||||
"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRQQQQQ" |
|
||||
tr R "\200" |
|
||||
q_to_nul >clear.noisy &&
|
||||
len=$(wc -c <clear.noisy) &&
|
||||
test-svn-fe -d preimage clear.noisy $len &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'reject variable-length int in magic' '
|
||||
printf "SVNRQ" | tr R "\200" | q_to_nul >clear.badmagic &&
|
||||
test_must_fail test-svn-fe -d preimage clear.badmagic 5
|
||||
'
|
||||
|
||||
test_expect_success 'reject truncated integer' '
|
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQRRQ" |
|
||||
tr R "\200" |
|
||||
q_to_nul >clear.fullint &&
|
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQRR" |
|
||||
tr RT "\201" |
|
||||
q_to_nul >clear.partialint &&
|
||||
test_must_fail test-svn-fe -d preimage clear.fullint 15 &&
|
||||
test-svn-fe -d preimage clear.fullint 16 &&
|
||||
test_must_fail test-svn-fe -d preimage clear.partialint 15
|
||||
'
|
||||
|
||||
test_expect_success 'nonempty (but unused) preimage view' '
|
||||
printf "SVNQ%b" "Q\003QQQ" | q_to_nul >clear.readpreimage &&
|
||||
test-svn-fe -d preimage clear.readpreimage 9 >actual &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'preimage view: right endpoint cannot backtrack' '
|
||||
printf "SVNQ%b%b" "Q\003QQQ" "Q\002QQQ" |
|
||||
q_to_nul >clear.backtrack &&
|
||||
test_must_fail test-svn-fe -d preimage clear.backtrack 14
|
||||
'
|
||||
|
||||
test_expect_success 'preimage view: left endpoint can advance' '
|
||||
printf "SVNQ%b%b" "Q\003QQQ" "\001\002QQQ" |
|
||||
q_to_nul >clear.preshrink &&
|
||||
printf "SVNQ%b%b" "Q\003QQQ" "\001\001QQQ" |
|
||||
q_to_nul >clear.shrinkbacktrack &&
|
||||
test-svn-fe -d preimage clear.preshrink 14 >actual &&
|
||||
test_must_fail test-svn-fe -d preimage clear.shrinkbacktrack 14 &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'preimage view: offsets compared by value' '
|
||||
printf "SVNQ%b%b" "\001\001QQQ" "\0200Q\003QQQ" |
|
||||
q_to_nul >clear.noisybacktrack &&
|
||||
printf "SVNQ%b%b" "\001\001QQQ" "\0200\001\002QQQ" |
|
||||
q_to_nul >clear.noisyadvance &&
|
||||
test_must_fail test-svn-fe -d preimage clear.noisybacktrack 15 &&
|
||||
test-svn-fe -d preimage clear.noisyadvance 15 &&
|
||||
test_cmp empty actual
|
||||
'
|
||||
|
||||
test_expect_success 'preimage view: reject truncated preimage' '
|
||||
printf "SVNQ%b" "\010QQQQ" | q_to_nul >clear.lateemptyread &&
|
||||
printf "SVNQ%b" "\010\001QQQ" | q_to_nul >clear.latenonemptyread &&
|
||||
printf "SVNQ%b" "\001\010QQQ" | q_to_nul >clear.longread &&
|
||||
test_must_fail test-svn-fe -d preimage clear.lateemptyread 9 &&
|
||||
test_must_fail test-svn-fe -d preimage clear.latenonemptyread 9 &&
|
||||
test_must_fail test-svn-fe -d preimage clear.longread 9
|
||||
'
|
||||
|
||||
test_expect_success 'forbid unconsumed inline data' '
|
||||
printf "SVNQ%b%s%b%s" "QQQQ\003" "bar" "QQQQ\001" "x" |
|
||||
q_to_nul >inline.clear &&
|
||||
test_must_fail test-svn-fe -d preimage inline.clear 18 >actual
|
||||
'
|
||||
|
||||
test_expect_success 'reject truncated inline data' '
|
||||
printf "SVNQ%b%s" "QQQQ\003" "b" | q_to_nul >inline.trunc &&
|
||||
test_must_fail test-svn-fe -d preimage inline.trunc 10
|
||||
'
|
||||
|
||||
test_expect_success 'reject truncated inline data (after instruction section)' '
|
||||
printf "SVNQ%b%b%s" "QQ\001\001\003" "\0201" "b" | q_to_nul >insn.trunc &&
|
||||
test_must_fail test-svn-fe -d preimage insn.trunc 11
|
||||
'
|
||||
|
||||
test_expect_success 'copyfrom_data' '
|
||||
echo hi >expect &&
|
||||
printf "SVNQ%b%b%b" "QQ\003\001\003" "\0203" "hi\n" | q_to_nul >copydat &&
|
||||
test-svn-fe -d preimage copydat 13 >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'multiple copyfrom_data' '
|
||||
echo hi >expect &&
|
||||
printf "SVNQ%b%b%b%b%b" "QQ\003\002\003" "\0201\0202" "hi\n" \
|
||||
"QQQ\002Q" "\0200Q" | q_to_nul >copy.multi &&
|
||||
len=$(wc -c <copy.multi) &&
|
||||
test-svn-fe -d preimage copy.multi $len >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'incomplete multiple insn' '
|
||||
printf "SVNQ%b%b%b" "QQ\003\002\003" "\0203\0200" "hi\n" |
|
||||
q_to_nul >copy.partial &&
|
||||
len=$(wc -c <copy.partial) &&
|
||||
test_must_fail test-svn-fe -d preimage copy.partial $len
|
||||
'
|
||||
|
||||
test_expect_success 'catch attempt to copy missing data' '
|
||||
printf "SVNQ%b%b%s%b%s" "QQ\002\002\001" "\0201\0201" "X" \
|
||||
"QQQQ\002" "YZ" |
|
||||
q_to_nul >copy.incomplete &&
|
||||
len=$(wc -c <copy.incomplete) &&
|
||||
test_must_fail test-svn-fe -d preimage copy.incomplete $len
|
||||
'
|
||||
|
||||
test_expect_success 'copyfrom target to repeat data' '
|
||||
printf foofoo >expect &&
|
||||
printf "SVNQ%b%b%s" "QQ\006\004\003" "\0203\0100\003Q" "foo" |
|
||||
q_to_nul >copytarget.repeat &&
|
||||
len=$(wc -c <copytarget.repeat) &&
|
||||
test-svn-fe -d preimage copytarget.repeat $len >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'copyfrom target out of order' '
|
||||
printf foooof >expect &&
|
||||
printf "SVNQ%b%b%s" \
|
||||
"QQ\006\007\003" "\0203\0101\002\0101\001\0101Q" "foo" |
|
||||
q_to_nul >copytarget.reverse &&
|
||||
len=$(wc -c <copytarget.reverse) &&
|
||||
test-svn-fe -d preimage copytarget.reverse $len >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'catch copyfrom future' '
|
||||
printf "SVNQ%b%b%s" "QQ\004\004\003" "\0202\0101\002\0201" "XYZ" |
|
||||
q_to_nul >copytarget.infuture &&
|
||||
len=$(wc -c <copytarget.infuture) &&
|
||||
test_must_fail test-svn-fe -d preimage copytarget.infuture $len
|
||||
'
|
||||
|
||||
test_expect_success 'copy to sustain' '
|
||||
printf XYXYXYXYXYXZ >expect &&
|
||||
printf "SVNQ%b%b%s" "QQ\014\004\003" "\0202\0111Q\0201" "XYZ" |
|
||||
q_to_nul >copytarget.sustain &&
|
||||
len=$(wc -c <copytarget.sustain) &&
|
||||
test-svn-fe -d preimage copytarget.sustain $len >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'catch copy that overflows' '
|
||||
printf "SVNQ%b%b%s" "QQ\003\003\001" "\0201\0177Q" X |
|
||||
q_to_nul >copytarget.overflow &&
|
||||
len=$(wc -c <copytarget.overflow) &&
|
||||
test_must_fail test-svn-fe -d preimage copytarget.overflow $len
|
||||
'
|
||||
|
||||
test_expect_success 'copyfrom source' '
|
||||
printf foo >expect &&
|
||||
printf "SVNQ%b%b" "Q\003\003\002Q" "\003Q" | q_to_nul >copysource.all &&
|
||||
test-svn-fe -d preimage copysource.all 11 >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'copy backwards' '
|
||||
printf oof >expect &&
|
||||
printf "SVNQ%b%b" "Q\003\003\006Q" "\001\002\001\001\001Q" |
|
||||
q_to_nul >copysource.rev &&
|
||||
test-svn-fe -d preimage copysource.rev 15 >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'offsets are relative to window' '
|
||||
printf fo >expect &&
|
||||
printf "SVNQ%b%b%b%b" "Q\003\001\002Q" "\001Q" \
|
||||
"\002\001\001\002Q" "\001Q" |
|
||||
q_to_nul >copysource.two &&
|
||||
test-svn-fe -d preimage copysource.two 18 >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'example from notes/svndiff' '
|
||||
printf aaaaccccdddddddd >expect &&
|
||||
printf aaaabbbbcccc >source &&
|
||||
printf "SVNQ%b%b%s" "Q\014\020\007\001" \
|
||||
"\004Q\004\010\0201\0107\010" d |
|
||||
q_to_nul >delta.example &&
|
||||
len=$(wc -c <delta.example) &&
|
||||
test-svn-fe -d source delta.example $len >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_done
|
||||
|
|
@ -4,15 +4,41 @@
|
|||
|
||||
#include "git-compat-util.h"
|
||||
#include "vcs-svn/svndump.h"
|
||||
#include "vcs-svn/svndiff.h"
|
||||
#include "vcs-svn/sliding_window.h"
|
||||
#include "vcs-svn/line_buffer.h"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
if (argc != 2)
|
||||
usage("test-svn-fe <file>");
|
||||
if (svndump_init(argv[1]))
|
||||
return 1;
|
||||
svndump_read(NULL);
|
||||
svndump_deinit();
|
||||
svndump_reset();
|
||||
return 0;
|
||||
static const char test_svnfe_usage[] =
|
||||
"test-svn-fe (<dumpfile> | [-d] <preimage> <delta> <len>)";
|
||||
if (argc == 2) {
|
||||
if (svndump_init(argv[1]))
|
||||
return 1;
|
||||
svndump_read(NULL);
|
||||
svndump_deinit();
|
||||
svndump_reset();
|
||||
return 0;
|
||||
}
|
||||
if (argc == 5 && !strcmp(argv[1], "-d")) {
|
||||
struct line_buffer preimage = LINE_BUFFER_INIT;
|
||||
struct line_buffer delta = LINE_BUFFER_INIT;
|
||||
struct sliding_view preimage_view = SLIDING_VIEW_INIT(&preimage);
|
||||
if (buffer_init(&preimage, argv[2]))
|
||||
die_errno("cannot open preimage");
|
||||
if (buffer_init(&delta, argv[3]))
|
||||
die_errno("cannot open delta");
|
||||
if (svndiff0_apply(&delta, (off_t) strtoull(argv[4], NULL, 0),
|
||||
&preimage_view, stdout))
|
||||
return 1;
|
||||
if (buffer_deinit(&preimage))
|
||||
die_errno("cannot close preimage");
|
||||
if (buffer_deinit(&delta))
|
||||
die_errno("cannot close delta");
|
||||
buffer_reset(&preimage);
|
||||
strbuf_release(&preimage_view.buf);
|
||||
buffer_reset(&delta);
|
||||
return 0;
|
||||
}
|
||||
usage(test_svnfe_usage);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
Copyright (C) 2010 David Barr <david.barr@cordelta.com>.
|
||||
All rights reserved.
|
||||
|
||||
Copyright (C) 2010 Jonathan Nieder <jrnieder@gmail.com>.
|
||||
|
||||
Copyright (C) 2005 Stefan Hegny, hydrografix Consulting GmbH,
|
||||
Frankfurt/Main, Germany
|
||||
and others, see http://svn2cc.sarovar.org
|
||||
|
|
|
|||
|
|
@ -91,10 +91,10 @@ char *buffer_read_line(struct line_buffer *buf)
|
|||
return buf->line_buffer;
|
||||
}
|
||||
|
||||
void buffer_read_binary(struct line_buffer *buf,
|
||||
struct strbuf *sb, uint32_t size)
|
||||
size_t buffer_read_binary(struct line_buffer *buf,
|
||||
struct strbuf *sb, size_t size)
|
||||
{
|
||||
strbuf_fread(sb, size, buf->infile);
|
||||
return strbuf_fread(sb, size, buf->infile);
|
||||
}
|
||||
|
||||
off_t buffer_copy_bytes(struct line_buffer *buf, off_t nbytes)
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ long buffer_tmpfile_prepare_to_read(struct line_buffer *buf);
|
|||
int buffer_ferror(struct line_buffer *buf);
|
||||
char *buffer_read_line(struct line_buffer *buf);
|
||||
int buffer_read_char(struct line_buffer *buf);
|
||||
void buffer_read_binary(struct line_buffer *buf, struct strbuf *sb, uint32_t len);
|
||||
size_t buffer_read_binary(struct line_buffer *buf, struct strbuf *sb, size_t len);
|
||||
/* Returns number of bytes read (not necessarily written). */
|
||||
off_t buffer_copy_bytes(struct line_buffer *buf, off_t len);
|
||||
off_t buffer_skip_bytes(struct line_buffer *buf, off_t len);
|
||||
|
|
|
|||
77
vcs-svn/sliding_window.c
Normal file
77
vcs-svn/sliding_window.c
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/*
|
||||
* Licensed under a two-clause BSD-style license.
|
||||
* See LICENSE for details.
|
||||
*/
|
||||
|
||||
#include "git-compat-util.h"
|
||||
#include "sliding_window.h"
|
||||
#include "line_buffer.h"
|
||||
#include "strbuf.h"
|
||||
|
||||
static int input_error(struct line_buffer *file)
|
||||
{
|
||||
if (!buffer_ferror(file))
|
||||
return error("delta preimage ends early");
|
||||
return error("cannot read delta preimage: %s", strerror(errno));
|
||||
}
|
||||
|
||||
static int skip_or_whine(struct line_buffer *file, off_t gap)
|
||||
{
|
||||
if (buffer_skip_bytes(file, gap) != gap)
|
||||
return input_error(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_to_fill_or_whine(struct line_buffer *file,
|
||||
struct strbuf *buf, size_t width)
|
||||
{
|
||||
buffer_read_binary(file, buf, width - buf->len);
|
||||
if (buf->len != width)
|
||||
return input_error(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int check_overflow(off_t a, size_t b)
|
||||
{
|
||||
if (b > maximum_signed_value_of_type(off_t))
|
||||
return error("unrepresentable length in delta: "
|
||||
"%"PRIuMAX" > OFF_MAX", (uintmax_t) b);
|
||||
if (signed_add_overflows(a, (off_t) b))
|
||||
return error("unrepresentable offset in delta: "
|
||||
"%"PRIuMAX" + %"PRIuMAX" > OFF_MAX",
|
||||
(uintmax_t) a, (uintmax_t) b);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int move_window(struct sliding_view *view, off_t off, size_t width)
|
||||
{
|
||||
off_t file_offset;
|
||||
assert(view);
|
||||
assert(view->width <= view->buf.len);
|
||||
assert(!check_overflow(view->off, view->buf.len));
|
||||
|
||||
if (check_overflow(off, width))
|
||||
return -1;
|
||||
if (off < view->off || off + width < view->off + view->width)
|
||||
return error("invalid delta: window slides left");
|
||||
|
||||
file_offset = view->off + view->buf.len;
|
||||
if (off < file_offset) {
|
||||
/* Move the overlapping region into place. */
|
||||
strbuf_remove(&view->buf, 0, off - view->off);
|
||||
} else {
|
||||
/* Seek ahead to skip the gap. */
|
||||
if (skip_or_whine(view->file, off - file_offset))
|
||||
return -1;
|
||||
strbuf_setlen(&view->buf, 0);
|
||||
}
|
||||
|
||||
if (view->buf.len > width)
|
||||
; /* Already read. */
|
||||
else if (read_to_fill_or_whine(view->file, &view->buf, width))
|
||||
return -1;
|
||||
|
||||
view->off = off;
|
||||
view->width = width;
|
||||
return 0;
|
||||
}
|
||||
17
vcs-svn/sliding_window.h
Normal file
17
vcs-svn/sliding_window.h
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
#ifndef SLIDING_WINDOW_H_
|
||||
#define SLIDING_WINDOW_H_
|
||||
|
||||
#include "strbuf.h"
|
||||
|
||||
struct sliding_view {
|
||||
struct line_buffer *file;
|
||||
off_t off;
|
||||
size_t width;
|
||||
struct strbuf buf;
|
||||
};
|
||||
|
||||
#define SLIDING_VIEW_INIT(input) { (input), 0, 0, STRBUF_INIT }
|
||||
|
||||
extern int move_window(struct sliding_view *view, off_t off, size_t width);
|
||||
|
||||
#endif
|
||||
308
vcs-svn/svndiff.c
Normal file
308
vcs-svn/svndiff.c
Normal file
|
|
@ -0,0 +1,308 @@
|
|||
/*
|
||||
* Licensed under a two-clause BSD-style license.
|
||||
* See LICENSE for details.
|
||||
*/
|
||||
|
||||
#include "git-compat-util.h"
|
||||
#include "sliding_window.h"
|
||||
#include "line_buffer.h"
|
||||
#include "svndiff.h"
|
||||
|
||||
/*
|
||||
* svndiff0 applier
|
||||
*
|
||||
* See http://svn.apache.org/repos/asf/subversion/trunk/notes/svndiff.
|
||||
*
|
||||
* svndiff0 ::= 'SVN\0' window*
|
||||
* window ::= int int int int int instructions inline_data;
|
||||
* instructions ::= instruction*;
|
||||
* instruction ::= view_selector int int
|
||||
* | copyfrom_data int
|
||||
* | packed_view_selector int
|
||||
* | packed_copyfrom_data
|
||||
* ;
|
||||
* view_selector ::= copyfrom_source
|
||||
* | copyfrom_target
|
||||
* ;
|
||||
* copyfrom_source ::= # binary 00 000000;
|
||||
* copyfrom_target ::= # binary 01 000000;
|
||||
* copyfrom_data ::= # binary 10 000000;
|
||||
* packed_view_selector ::= # view_selector OR-ed with 6 bit value;
|
||||
* packed_copyfrom_data ::= # copyfrom_data OR-ed with 6 bit value;
|
||||
* int ::= highdigit* lowdigit;
|
||||
* highdigit ::= # binary 1000 0000 OR-ed with 7 bit value;
|
||||
* lowdigit ::= # 7 bit value;
|
||||
*/
|
||||
|
||||
#define INSN_MASK 0xc0
|
||||
#define INSN_COPYFROM_SOURCE 0x00
|
||||
#define INSN_COPYFROM_TARGET 0x40
|
||||
#define INSN_COPYFROM_DATA 0x80
|
||||
#define OPERAND_MASK 0x3f
|
||||
|
||||
#define VLI_CONTINUE 0x80
|
||||
#define VLI_DIGIT_MASK 0x7f
|
||||
#define VLI_BITS_PER_DIGIT 7
|
||||
|
||||
struct window {
|
||||
struct sliding_view *in;
|
||||
struct strbuf out;
|
||||
struct strbuf instructions;
|
||||
struct strbuf data;
|
||||
};
|
||||
|
||||
#define WINDOW_INIT(w) { (w), STRBUF_INIT, STRBUF_INIT, STRBUF_INIT }
|
||||
|
||||
static void window_release(struct window *ctx)
|
||||
{
|
||||
strbuf_release(&ctx->out);
|
||||
strbuf_release(&ctx->instructions);
|
||||
strbuf_release(&ctx->data);
|
||||
}
|
||||
|
||||
static int write_strbuf(struct strbuf *sb, FILE *out)
|
||||
{
|
||||
if (fwrite(sb->buf, 1, sb->len, out) == sb->len) /* Success. */
|
||||
return 0;
|
||||
return error("cannot write delta postimage: %s", strerror(errno));
|
||||
}
|
||||
|
||||
static int error_short_read(struct line_buffer *input)
|
||||
{
|
||||
if (buffer_ferror(input))
|
||||
return error("error reading delta: %s", strerror(errno));
|
||||
return error("invalid delta: unexpected end of file");
|
||||
}
|
||||
|
||||
static int read_chunk(struct line_buffer *delta, off_t *delta_len,
|
||||
struct strbuf *buf, size_t len)
|
||||
{
|
||||
strbuf_reset(buf);
|
||||
if (len > *delta_len ||
|
||||
buffer_read_binary(delta, buf, len) != len)
|
||||
return error_short_read(delta);
|
||||
*delta_len -= buf->len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_magic(struct line_buffer *in, off_t *len)
|
||||
{
|
||||
static const char magic[] = {'S', 'V', 'N', '\0'};
|
||||
struct strbuf sb = STRBUF_INIT;
|
||||
|
||||
if (read_chunk(in, len, &sb, sizeof(magic))) {
|
||||
strbuf_release(&sb);
|
||||
return -1;
|
||||
}
|
||||
if (memcmp(sb.buf, magic, sizeof(magic))) {
|
||||
strbuf_release(&sb);
|
||||
return error("invalid delta: unrecognized file type");
|
||||
}
|
||||
strbuf_release(&sb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_int(struct line_buffer *in, uintmax_t *result, off_t *len)
|
||||
{
|
||||
uintmax_t rv = 0;
|
||||
off_t sz;
|
||||
for (sz = *len; sz; sz--) {
|
||||
const int ch = buffer_read_char(in);
|
||||
if (ch == EOF)
|
||||
break;
|
||||
|
||||
rv <<= VLI_BITS_PER_DIGIT;
|
||||
rv += (ch & VLI_DIGIT_MASK);
|
||||
if (ch & VLI_CONTINUE)
|
||||
continue;
|
||||
|
||||
*result = rv;
|
||||
*len = sz - 1;
|
||||
return 0;
|
||||
}
|
||||
return error_short_read(in);
|
||||
}
|
||||
|
||||
static int parse_int(const char **buf, size_t *result, const char *end)
|
||||
{
|
||||
size_t rv = 0;
|
||||
const char *pos;
|
||||
for (pos = *buf; pos != end; pos++) {
|
||||
unsigned char ch = *pos;
|
||||
|
||||
rv <<= VLI_BITS_PER_DIGIT;
|
||||
rv += (ch & VLI_DIGIT_MASK);
|
||||
if (ch & VLI_CONTINUE)
|
||||
continue;
|
||||
|
||||
*result = rv;
|
||||
*buf = pos + 1;
|
||||
return 0;
|
||||
}
|
||||
return error("invalid delta: unexpected end of instructions section");
|
||||
}
|
||||
|
||||
static int read_offset(struct line_buffer *in, off_t *result, off_t *len)
|
||||
{
|
||||
uintmax_t val;
|
||||
if (read_int(in, &val, len))
|
||||
return -1;
|
||||
if (val > maximum_signed_value_of_type(off_t))
|
||||
return error("unrepresentable offset in delta: %"PRIuMAX"", val);
|
||||
*result = val;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_length(struct line_buffer *in, size_t *result, off_t *len)
|
||||
{
|
||||
uintmax_t val;
|
||||
if (read_int(in, &val, len))
|
||||
return -1;
|
||||
if (val > SIZE_MAX)
|
||||
return error("unrepresentable length in delta: %"PRIuMAX"", val);
|
||||
*result = val;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int copyfrom_source(struct window *ctx, const char **instructions,
|
||||
size_t nbytes, const char *insns_end)
|
||||
{
|
||||
size_t offset;
|
||||
if (parse_int(instructions, &offset, insns_end))
|
||||
return -1;
|
||||
if (unsigned_add_overflows(offset, nbytes) ||
|
||||
offset + nbytes > ctx->in->width)
|
||||
return error("invalid delta: copies source data outside view");
|
||||
strbuf_add(&ctx->out, ctx->in->buf.buf + offset, nbytes);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int copyfrom_target(struct window *ctx, const char **instructions,
|
||||
size_t nbytes, const char *instructions_end)
|
||||
{
|
||||
size_t offset;
|
||||
if (parse_int(instructions, &offset, instructions_end))
|
||||
return -1;
|
||||
if (offset >= ctx->out.len)
|
||||
return error("invalid delta: copies from the future");
|
||||
for (; nbytes > 0; nbytes--)
|
||||
strbuf_addch(&ctx->out, ctx->out.buf[offset++]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int copyfrom_data(struct window *ctx, size_t *data_pos, size_t nbytes)
|
||||
{
|
||||
const size_t pos = *data_pos;
|
||||
if (unsigned_add_overflows(pos, nbytes) ||
|
||||
pos + nbytes > ctx->data.len)
|
||||
return error("invalid delta: copies unavailable inline data");
|
||||
strbuf_add(&ctx->out, ctx->data.buf + pos, nbytes);
|
||||
*data_pos += nbytes;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_first_operand(const char **buf, size_t *out, const char *end)
|
||||
{
|
||||
size_t result = (unsigned char) *(*buf)++ & OPERAND_MASK;
|
||||
if (result) { /* immediate operand */
|
||||
*out = result;
|
||||
return 0;
|
||||
}
|
||||
return parse_int(buf, out, end);
|
||||
}
|
||||
|
||||
static int execute_one_instruction(struct window *ctx,
|
||||
const char **instructions, size_t *data_pos)
|
||||
{
|
||||
unsigned int instruction;
|
||||
const char *insns_end = ctx->instructions.buf + ctx->instructions.len;
|
||||
size_t nbytes;
|
||||
assert(ctx);
|
||||
assert(instructions && *instructions);
|
||||
assert(data_pos);
|
||||
|
||||
instruction = (unsigned char) **instructions;
|
||||
if (parse_first_operand(instructions, &nbytes, insns_end))
|
||||
return -1;
|
||||
switch (instruction & INSN_MASK) {
|
||||
case INSN_COPYFROM_SOURCE:
|
||||
return copyfrom_source(ctx, instructions, nbytes, insns_end);
|
||||
case INSN_COPYFROM_TARGET:
|
||||
return copyfrom_target(ctx, instructions, nbytes, insns_end);
|
||||
case INSN_COPYFROM_DATA:
|
||||
return copyfrom_data(ctx, data_pos, nbytes);
|
||||
default:
|
||||
return error("invalid delta: unrecognized instruction");
|
||||
}
|
||||
}
|
||||
|
||||
static int apply_window_in_core(struct window *ctx)
|
||||
{
|
||||
const char *instructions;
|
||||
size_t data_pos = 0;
|
||||
|
||||
/*
|
||||
* Fill ctx->out.buf using data from the source, target,
|
||||
* and inline data views.
|
||||
*/
|
||||
for (instructions = ctx->instructions.buf;
|
||||
instructions != ctx->instructions.buf + ctx->instructions.len;
|
||||
)
|
||||
if (execute_one_instruction(ctx, &instructions, &data_pos))
|
||||
return -1;
|
||||
if (data_pos != ctx->data.len)
|
||||
return error("invalid delta: does not copy all inline data");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_one_window(struct line_buffer *delta, off_t *delta_len,
|
||||
struct sliding_view *preimage, FILE *out)
|
||||
{
|
||||
struct window ctx = WINDOW_INIT(preimage);
|
||||
size_t out_len;
|
||||
size_t instructions_len;
|
||||
size_t data_len;
|
||||
assert(delta_len);
|
||||
|
||||
/* "source view" offset and length already handled; */
|
||||
if (read_length(delta, &out_len, delta_len) ||
|
||||
read_length(delta, &instructions_len, delta_len) ||
|
||||
read_length(delta, &data_len, delta_len) ||
|
||||
read_chunk(delta, delta_len, &ctx.instructions, instructions_len) ||
|
||||
read_chunk(delta, delta_len, &ctx.data, data_len))
|
||||
goto error_out;
|
||||
strbuf_grow(&ctx.out, out_len);
|
||||
if (apply_window_in_core(&ctx))
|
||||
goto error_out;
|
||||
if (ctx.out.len != out_len) {
|
||||
error("invalid delta: incorrect postimage length");
|
||||
goto error_out;
|
||||
}
|
||||
if (write_strbuf(&ctx.out, out))
|
||||
goto error_out;
|
||||
window_release(&ctx);
|
||||
return 0;
|
||||
error_out:
|
||||
window_release(&ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int svndiff0_apply(struct line_buffer *delta, off_t delta_len,
|
||||
struct sliding_view *preimage, FILE *postimage)
|
||||
{
|
||||
assert(delta && preimage && postimage);
|
||||
|
||||
if (read_magic(delta, &delta_len))
|
||||
return -1;
|
||||
while (delta_len) { /* For each window: */
|
||||
off_t pre_off;
|
||||
size_t pre_len;
|
||||
|
||||
if (read_offset(delta, &pre_off, &delta_len) ||
|
||||
read_length(delta, &pre_len, &delta_len) ||
|
||||
move_window(preimage, pre_off, pre_len) ||
|
||||
apply_one_window(delta, &delta_len, preimage, postimage))
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
10
vcs-svn/svndiff.h
Normal file
10
vcs-svn/svndiff.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef SVNDIFF_H_
|
||||
#define SVNDIFF_H_
|
||||
|
||||
struct line_buffer;
|
||||
struct sliding_view;
|
||||
|
||||
extern int svndiff0_apply(struct line_buffer *delta, off_t delta_len,
|
||||
struct sliding_view *preimage, FILE *postimage);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue