mirror of
https://gitlab.torproject.org/tpo/core/tor.git
synced 2024-11-11 13:43:47 +01:00
Consdiff: use lengths on inputs so they don't need NUL at the end
This is part of #27244, so that we can safely mmap consensus documents.
This commit is contained in:
Nick Mathewson
parent
e5601f14ed
commit
5595b21227
@ -1496,7 +1496,10 @@ consensus_diff_worker_threadfn(void *state_, void *work_)
|
||||
// XXXX ugh; this is going to calculate the SHA3 of both its
|
||||
// XXXX inputs again, even though we already have that. Maybe it's time
|
||||
// XXXX to change the API here?
|
||||
consensus_diff = consensus_diff_generate(diff_from_nt, diff_to_nt);
|
||||
consensus_diff = consensus_diff_generate(diff_from_nt,
|
||||
strlen(diff_from_nt),
|
||||
diff_to_nt,
|
||||
strlen(diff_to_nt));
|
||||
tor_free(diff_from_nt);
|
||||
tor_free(diff_to_nt);
|
||||
}
|
||||
@ -1746,8 +1749,8 @@ consensus_compress_worker_threadfn(void *state_, void *work_)
|
||||
(const uint8_t *)consensus, bodylen);
|
||||
{
|
||||
const char *start, *end;
|
||||
if (router_get_networkstatus_v3_signed_boundaries(consensus,
|
||||
&start, &end) < 0) {
|
||||
if (router_get_networkstatus_v3_signed_boundaries(consensus, bodylen,
|
||||
&start, &end) < 0) {
|
||||
start = consensus;
|
||||
end = consensus+bodylen;
|
||||
}
|
||||
|
||||
@ -2607,12 +2607,17 @@ handle_response_fetch_consensus(dir_connection_t *conn,
|
||||
/* First find our previous consensus. Maybe it's in ram, maybe not. */
|
||||
cached_dir_t *cd = dirserv_get_consensus(flavname);
|
||||
const char *consensus_body;
|
||||
size_t consensus_body_len;
|
||||
char *owned_consensus = NULL;
|
||||
if (cd) {
|
||||
consensus_body = cd->dir;
|
||||
consensus_body_len = cd->dir_len;
|
||||
} else {
|
||||
owned_consensus = networkstatus_read_cached_consensus(flavname);
|
||||
consensus_body = owned_consensus;
|
||||
if (owned_consensus) {
|
||||
consensus_body = owned_consensus;
|
||||
consensus_body_len = strlen(consensus_body);
|
||||
}
|
||||
}
|
||||
if (!consensus_body) {
|
||||
log_warn(LD_DIR, "Received a consensus diff, but we can't find "
|
||||
@ -2622,7 +2627,8 @@ handle_response_fetch_consensus(dir_connection_t *conn,
|
||||
return -1;
|
||||
}
|
||||
|
||||
new_consensus = consensus_diff_apply(consensus_body, body);
|
||||
new_consensus = consensus_diff_apply(consensus_body, consensus_body_len,
|
||||
body, body_len);
|
||||
tor_free(owned_consensus);
|
||||
if (new_consensus == NULL) {
|
||||
log_warn(LD_DIR, "Could not apply consensus diff received from server "
|
||||
|
||||
@ -101,11 +101,11 @@ smartlist_add_linecpy(smartlist_t *lst, memarea_t *area, const char *s)
|
||||
/* This is a separate, mockable function so that we can override it when
|
||||
* fuzzing. */
|
||||
MOCK_IMPL(STATIC int,
|
||||
consensus_compute_digest,(const char *cons,
|
||||
consensus_compute_digest,(const char *cons, size_t len,
|
||||
consensus_digest_t *digest_out))
|
||||
{
|
||||
int r = crypto_digest256((char*)digest_out->sha3_256,
|
||||
cons, strlen(cons), DIGEST_SHA3_256);
|
||||
cons, len, DIGEST_SHA3_256);
|
||||
return r;
|
||||
}
|
||||
|
||||
@ -114,11 +114,11 @@ consensus_compute_digest,(const char *cons,
|
||||
/* This is a separate, mockable function so that we can override it when
|
||||
* fuzzing. */
|
||||
MOCK_IMPL(STATIC int,
|
||||
consensus_compute_digest_as_signed,(const char *cons,
|
||||
consensus_compute_digest_as_signed,(const char *cons, size_t len,
|
||||
consensus_digest_t *digest_out))
|
||||
{
|
||||
return router_get_networkstatus_v3_sha3_as_signed(digest_out->sha3_256,
|
||||
cons);
|
||||
cons, len);
|
||||
}
|
||||
|
||||
/** Return true iff <b>d1</b> and <b>d2</b> contain the same digest */
|
||||
@ -1229,7 +1229,8 @@ consdiff_apply_diff(const smartlist_t *cons1,
|
||||
cons2_str = consensus_join_lines(cons2);
|
||||
|
||||
consensus_digest_t cons2_digests;
|
||||
if (consensus_compute_digest(cons2_str, &cons2_digests) < 0) {
|
||||
if (consensus_compute_digest(cons2_str, strlen(cons2_str),
|
||||
&cons2_digests) < 0) {
|
||||
/* LCOV_EXCL_START -- digest can't fail */
|
||||
log_warn(LD_CONSDIFF, "Could not compute digests of the consensus "
|
||||
"resulting from applying a consensus diff.");
|
||||
@ -1283,12 +1284,13 @@ consdiff_apply_diff(const smartlist_t *cons1,
|
||||
* generated cdlines will become invalid.
|
||||
*/
|
||||
STATIC int
|
||||
consensus_split_lines(smartlist_t *out, const char *s, memarea_t *area)
|
||||
consensus_split_lines(smartlist_t *out,
|
||||
const char *s, size_t len,
|
||||
memarea_t *area)
|
||||
{
|
||||
const char *end_of_str = s + strlen(s);
|
||||
tor_assert(*end_of_str == '\0');
|
||||
const char *end_of_str = s + len;
|
||||
|
||||
while (*s) {
|
||||
while (s < end_of_str) {
|
||||
const char *eol = memchr(s, '\n', end_of_str - s);
|
||||
if (!eol) {
|
||||
/* File doesn't end with newline. */
|
||||
@ -1334,25 +1336,25 @@ consensus_join_lines(const smartlist_t *inp)
|
||||
* success, retun a newly allocated string containing that diff. On failure,
|
||||
* return NULL. */
|
||||
char *
|
||||
consensus_diff_generate(const char *cons1,
|
||||
const char *cons2)
|
||||
consensus_diff_generate(const char *cons1, size_t cons1len,
|
||||
const char *cons2, size_t cons2len)
|
||||
{
|
||||
consensus_digest_t d1, d2;
|
||||
smartlist_t *lines1 = NULL, *lines2 = NULL, *result_lines = NULL;
|
||||
int r1, r2;
|
||||
char *result = NULL;
|
||||
|
||||
r1 = consensus_compute_digest_as_signed(cons1, &d1);
|
||||
r2 = consensus_compute_digest(cons2, &d2);
|
||||
r1 = consensus_compute_digest_as_signed(cons1, cons1len, &d1);
|
||||
r2 = consensus_compute_digest(cons2, cons2len, &d2);
|
||||
if (BUG(r1 < 0 || r2 < 0))
|
||||
return NULL; // LCOV_EXCL_LINE
|
||||
|
||||
memarea_t *area = memarea_new();
|
||||
lines1 = smartlist_new();
|
||||
lines2 = smartlist_new();
|
||||
if (consensus_split_lines(lines1, cons1, area) < 0)
|
||||
if (consensus_split_lines(lines1, cons1, cons1len, area) < 0)
|
||||
goto done;
|
||||
if (consensus_split_lines(lines2, cons2, area) < 0)
|
||||
if (consensus_split_lines(lines2, cons2, cons2len, area) < 0)
|
||||
goto done;
|
||||
|
||||
result_lines = consdiff_gen_diff(lines1, lines2, &d1, &d2, area);
|
||||
@ -1375,7 +1377,9 @@ consensus_diff_generate(const char *cons1,
|
||||
* consensus. On failure, return NULL. */
|
||||
char *
|
||||
consensus_diff_apply(const char *consensus,
|
||||
const char *diff)
|
||||
size_t consensus_len,
|
||||
const char *diff,
|
||||
size_t diff_len)
|
||||
{
|
||||
consensus_digest_t d1;
|
||||
smartlist_t *lines1 = NULL, *lines2 = NULL;
|
||||
@ -1383,15 +1387,15 @@ consensus_diff_apply(const char *consensus,
|
||||
char *result = NULL;
|
||||
memarea_t *area = memarea_new();
|
||||
|
||||
r1 = consensus_compute_digest_as_signed(consensus, &d1);
|
||||
r1 = consensus_compute_digest_as_signed(consensus, consensus_len, &d1);
|
||||
if (BUG(r1 < 0))
|
||||
return NULL; // LCOV_EXCL_LINE
|
||||
|
||||
lines1 = smartlist_new();
|
||||
lines2 = smartlist_new();
|
||||
if (consensus_split_lines(lines1, consensus, area) < 0)
|
||||
if (consensus_split_lines(lines1, consensus, consensus_len, area) < 0)
|
||||
goto done;
|
||||
if (consensus_split_lines(lines2, diff, area) < 0)
|
||||
if (consensus_split_lines(lines2, diff, diff_len, area) < 0)
|
||||
goto done;
|
||||
|
||||
result = consdiff_apply_diff(lines1, lines2, &d1);
|
||||
|
||||
@ -7,10 +7,10 @@
|
||||
|
||||
#include "core/or/or.h"
|
||||
|
||||
char *consensus_diff_generate(const char *cons1,
|
||||
const char *cons2);
|
||||
char *consensus_diff_apply(const char *consensus,
|
||||
const char *diff);
|
||||
char *consensus_diff_generate(const char *cons1, size_t cons1len,
|
||||
const char *cons2, size_t cons2len);
|
||||
char *consensus_diff_apply(const char *consensus, size_t consensus_len,
|
||||
const char *diff, size_t diff_len);
|
||||
|
||||
int looks_like_a_consensus_diff(const char *document, size_t len);
|
||||
|
||||
@ -78,7 +78,8 @@ STATIC int smartlist_slice_string_pos(const smartlist_slice_t *slice,
|
||||
STATIC void set_changed(bitarray_t *changed1, bitarray_t *changed2,
|
||||
const smartlist_slice_t *slice1,
|
||||
const smartlist_slice_t *slice2);
|
||||
STATIC int consensus_split_lines(smartlist_t *out, const char *s,
|
||||
STATIC int consensus_split_lines(smartlist_t *out,
|
||||
const char *s, size_t len,
|
||||
struct memarea_t *area);
|
||||
STATIC void smartlist_add_linecpy(smartlist_t *lst, struct memarea_t *area,
|
||||
const char *s);
|
||||
@ -86,10 +87,10 @@ STATIC int lines_eq(const cdline_t *a, const cdline_t *b);
|
||||
STATIC int line_str_eq(const cdline_t *a, const char *b);
|
||||
|
||||
MOCK_DECL(STATIC int,
|
||||
consensus_compute_digest,(const char *cons,
|
||||
consensus_compute_digest,(const char *cons, size_t len,
|
||||
consensus_digest_t *digest_out));
|
||||
MOCK_DECL(STATIC int,
|
||||
consensus_compute_digest_as_signed,(const char *cons,
|
||||
consensus_compute_digest_as_signed,(const char *cons, size_t len,
|
||||
consensus_digest_t *digest_out));
|
||||
MOCK_DECL(STATIC int,
|
||||
consensus_digest_eq,(const uint8_t *d1,
|
||||
|
||||
@ -1024,10 +1024,11 @@ router_get_router_hash(const char *s, size_t s_len, char *digest)
|
||||
* -1. */
|
||||
int
|
||||
router_get_networkstatus_v3_signed_boundaries(const char *s,
|
||||
size_t len,
|
||||
const char **start_out,
|
||||
const char **end_out)
|
||||
{
|
||||
return router_get_hash_impl_helper(s, strlen(s),
|
||||
return router_get_hash_impl_helper(s, len,
|
||||
"network-status-version",
|
||||
"\ndirectory-signature",
|
||||
' ', LOG_INFO,
|
||||
@ -1039,12 +1040,13 @@ router_get_networkstatus_v3_signed_boundaries(const char *s,
|
||||
* signed portion can be identified. Return 0 on success, -1 on failure. */
|
||||
int
|
||||
router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out,
|
||||
const char *s)
|
||||
const char *s, size_t len)
|
||||
{
|
||||
const char *start, *end;
|
||||
if (router_get_networkstatus_v3_signed_boundaries(s, &start, &end) < 0) {
|
||||
if (router_get_networkstatus_v3_signed_boundaries(s, len,
|
||||
&start, &end) < 0) {
|
||||
start = s;
|
||||
end = s + strlen(s);
|
||||
end = s + len;
|
||||
}
|
||||
tor_assert(start);
|
||||
tor_assert(end);
|
||||
@ -3415,7 +3417,8 @@ networkstatus_parse_vote_from_string(const char *s, const char **eos_out,
|
||||
*eos_out = NULL;
|
||||
|
||||
if (router_get_networkstatus_v3_hashes(s, &ns_digests) ||
|
||||
router_get_networkstatus_v3_sha3_as_signed(sha3_as_signed, s)<0) {
|
||||
router_get_networkstatus_v3_sha3_as_signed(sha3_as_signed,
|
||||
s, strlen(s))<0) {
|
||||
log_warn(LD_DIR, "Unable to compute digest of network-status");
|
||||
goto err;
|
||||
}
|
||||
|
||||
@ -32,11 +32,11 @@ int router_get_router_hash(const char *s, size_t s_len, char *digest);
|
||||
int router_get_dir_hash(const char *s, char *digest);
|
||||
int router_get_networkstatus_v3_hashes(const char *s,
|
||||
common_digests_t *digests);
|
||||
int router_get_networkstatus_v3_signed_boundaries(const char *s,
|
||||
int router_get_networkstatus_v3_signed_boundaries(const char *s, size_t len,
|
||||
const char **start_out,
|
||||
const char **end_out);
|
||||
int router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out,
|
||||
const char *s);
|
||||
const char *s, size_t len);
|
||||
int router_get_extrainfo_hash(const char *s, size_t s_len, char *digest);
|
||||
#define DIROBJ_MAX_SIG_LEN 256
|
||||
char *router_get_dirobj_signature(const char *digest,
|
||||
|
||||
@ -702,11 +702,13 @@ main(int argc, const char **argv)
|
||||
perror("X");
|
||||
return 1;
|
||||
}
|
||||
size_t f1len = strlen(f1);
|
||||
size_t f2len = strlen(f2);
|
||||
for (i = 0; i < N; ++i) {
|
||||
char *diff = consensus_diff_generate(f1, f2);
|
||||
char *diff = consensus_diff_generate(f1, f1len, f2, f2len);
|
||||
tor_free(diff);
|
||||
}
|
||||
char *diff = consensus_diff_generate(f1, f2);
|
||||
char *diff = consensus_diff_generate(f1, f1len, f2, f2len);
|
||||
printf("%s", diff);
|
||||
tor_free(f1);
|
||||
tor_free(f2);
|
||||
|
||||
@ -10,9 +10,11 @@
|
||||
#include "test/fuzz/fuzzing.h"
|
||||
|
||||
static int
|
||||
mock_consensus_compute_digest_(const char *c, consensus_digest_t *d)
|
||||
mock_consensus_compute_digest_(const char *c, size_t len,
|
||||
consensus_digest_t *d)
|
||||
{
|
||||
(void)c;
|
||||
(void)len;
|
||||
memset(d->sha3_256, 3, sizeof(d->sha3_256));
|
||||
return 0;
|
||||
}
|
||||
@ -42,14 +44,14 @@ fuzz_main(const uint8_t *stdin_buf, size_t data_size)
|
||||
if (! separator)
|
||||
return 0;
|
||||
size_t c1_len = separator - stdin_buf;
|
||||
char *c1 = tor_memdup_nulterm(stdin_buf, c1_len);
|
||||
const char *c1 = (const char *)stdin_buf;
|
||||
size_t c2_len = data_size - c1_len - SEPLEN;
|
||||
char *c2 = tor_memdup_nulterm(separator + SEPLEN, c2_len);
|
||||
const char *c2 = (const char *)separator + SEPLEN;
|
||||
|
||||
char *c3 = consensus_diff_generate(c1, c2);
|
||||
char *c3 = consensus_diff_generate(c1, c1_len, c2, c2_len);
|
||||
|
||||
if (c3) {
|
||||
char *c4 = consensus_diff_apply(c1, c3);
|
||||
char *c4 = consensus_diff_apply(c1, c1_len, c3, strlen(c3));
|
||||
tor_assert(c4);
|
||||
if (strcmp(c2, c4)) {
|
||||
printf("%s\n", escaped(c1));
|
||||
@ -61,9 +63,6 @@ fuzz_main(const uint8_t *stdin_buf, size_t data_size)
|
||||
tor_free(c3);
|
||||
tor_free(c4);
|
||||
}
|
||||
tor_free(c1);
|
||||
tor_free(c2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -10,9 +10,11 @@
|
||||
#include "test/fuzz/fuzzing.h"
|
||||
|
||||
static int
|
||||
mock_consensus_compute_digest_(const char *c, consensus_digest_t *d)
|
||||
mock_consensus_compute_digest_(const char *c, size_t len,
|
||||
consensus_digest_t *d)
|
||||
{
|
||||
(void)c;
|
||||
(void)len;
|
||||
memset(d->sha3_256, 3, sizeof(d->sha3_256));
|
||||
return 0;
|
||||
}
|
||||
@ -50,16 +52,13 @@ fuzz_main(const uint8_t *stdin_buf, size_t data_size)
|
||||
if (! separator)
|
||||
return 0;
|
||||
size_t c1_len = separator - stdin_buf;
|
||||
char *c1 = tor_memdup_nulterm(stdin_buf, c1_len);
|
||||
const char *c1 = (const char *)stdin_buf;
|
||||
size_t c2_len = data_size - c1_len - SEPLEN;
|
||||
char *c2 = tor_memdup_nulterm(separator + SEPLEN, c2_len);
|
||||
const char *c2 = (const char *)separator + SEPLEN;
|
||||
|
||||
char *c3 = consensus_diff_apply(c1, c2);
|
||||
char *c3 = consensus_diff_apply(c1, c1_len, c2, c2_len);
|
||||
|
||||
tor_free(c1);
|
||||
tor_free(c2);
|
||||
tor_free(c3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -14,6 +14,39 @@
|
||||
#define tt_str_eq_line(a,b) \
|
||||
tt_assert(line_str_eq((b),(a)))
|
||||
|
||||
static int
|
||||
consensus_split_lines_(smartlist_t *out, const char *s, memarea_t *area)
|
||||
{
|
||||
size_t len = strlen(s);
|
||||
return consensus_split_lines(out, s, len, area);
|
||||
}
|
||||
|
||||
static int
|
||||
consensus_compute_digest_(const char *cons,
|
||||
consensus_digest_t *digest_out)
|
||||
{
|
||||
size_t len = strlen(cons);
|
||||
char *tmp = tor_memdup(cons, len);
|
||||
// We use memdup here to ensure that the input is NOT nul-terminated.
|
||||
// This makes it likelier for us to spot bugs.
|
||||
int r = consensus_compute_digest(tmp, len, digest_out);
|
||||
tor_free(tmp);
|
||||
return r;
|
||||
}
|
||||
|
||||
static int
|
||||
consensus_compute_digest_as_signed_(const char *cons,
|
||||
consensus_digest_t *digest_out)
|
||||
{
|
||||
size_t len = strlen(cons);
|
||||
char *tmp = tor_memdup(cons, len);
|
||||
// We use memdup here to ensure that the input is NOT nul-terminated.
|
||||
// This makes it likelier for us to spot bugs.
|
||||
int r = consensus_compute_digest_as_signed(tmp, len, digest_out);
|
||||
tor_free(tmp);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void
|
||||
test_consdiff_smartlist_slice(void *arg)
|
||||
{
|
||||
@ -58,7 +91,7 @@ test_consdiff_smartlist_slice_string_pos(void *arg)
|
||||
|
||||
/* Create a regular smartlist. */
|
||||
(void)arg;
|
||||
consensus_split_lines(sl, "a\nd\nc\na\nb\n", area);
|
||||
consensus_split_lines_(sl, "a\nd\nc\na\nb\n", area);
|
||||
|
||||
/* See that smartlist_slice_string_pos respects the bounds of the slice. */
|
||||
sls = smartlist_slice(sl, 2, 5);
|
||||
@ -87,8 +120,8 @@ test_consdiff_lcs_lengths(void *arg)
|
||||
int e_lengths2[] = { 0, 1, 1, 2, 3, 4 };
|
||||
|
||||
(void)arg;
|
||||
consensus_split_lines(sl1, "a\nb\nc\nd\ne\n", area);
|
||||
consensus_split_lines(sl2, "a\nc\nd\ni\ne\n", area);
|
||||
consensus_split_lines_(sl1, "a\nb\nc\nd\ne\n", area);
|
||||
consensus_split_lines_(sl2, "a\nc\nd\ni\ne\n", area);
|
||||
|
||||
sls1 = smartlist_slice(sl1, 0, -1);
|
||||
sls2 = smartlist_slice(sl2, 0, -1);
|
||||
@ -119,10 +152,10 @@ test_consdiff_trim_slices(void *arg)
|
||||
memarea_t *area = memarea_new();
|
||||
|
||||
(void)arg;
|
||||
consensus_split_lines(sl1, "a\nb\nb\nb\nd\n", area);
|
||||
consensus_split_lines(sl2, "a\nc\nc\nc\nd\n", area);
|
||||
consensus_split_lines(sl3, "a\nb\nb\nb\na\n", area);
|
||||
consensus_split_lines(sl4, "c\nb\nb\nb\nc\n", area);
|
||||
consensus_split_lines_(sl1, "a\nb\nb\nb\nd\n", area);
|
||||
consensus_split_lines_(sl2, "a\nc\nc\nc\nd\n", area);
|
||||
consensus_split_lines_(sl3, "a\nb\nb\nb\na\n", area);
|
||||
consensus_split_lines_(sl4, "c\nb\nb\nb\nc\n", area);
|
||||
sls1 = smartlist_slice(sl1, 0, -1);
|
||||
sls2 = smartlist_slice(sl2, 0, -1);
|
||||
sls3 = smartlist_slice(sl3, 0, -1);
|
||||
@ -165,8 +198,8 @@ test_consdiff_set_changed(void *arg)
|
||||
memarea_t *area = memarea_new();
|
||||
|
||||
(void)arg;
|
||||
consensus_split_lines(sl1, "a\nb\na\na\n", area);
|
||||
consensus_split_lines(sl2, "a\na\na\na\n", area);
|
||||
consensus_split_lines_(sl1, "a\nb\na\na\n", area);
|
||||
consensus_split_lines_(sl2, "a\na\na\na\n", area);
|
||||
|
||||
/* Length of sls1 is 0. */
|
||||
sls1 = smartlist_slice(sl1, 0, 0);
|
||||
@ -240,8 +273,8 @@ test_consdiff_calc_changes(void *arg)
|
||||
memarea_t *area = memarea_new();
|
||||
|
||||
(void)arg;
|
||||
consensus_split_lines(sl1, "a\na\na\na\n", area);
|
||||
consensus_split_lines(sl2, "a\na\na\na\n", area);
|
||||
consensus_split_lines_(sl1, "a\na\na\na\n", area);
|
||||
consensus_split_lines_(sl2, "a\na\na\na\n", area);
|
||||
|
||||
sls1 = smartlist_slice(sl1, 0, -1);
|
||||
sls2 = smartlist_slice(sl2, 0, -1);
|
||||
@ -259,7 +292,7 @@ test_consdiff_calc_changes(void *arg)
|
||||
tt_assert(!bitarray_is_set(changed2, 3));
|
||||
|
||||
smartlist_clear(sl2);
|
||||
consensus_split_lines(sl2, "a\nb\na\nb\n", area);
|
||||
consensus_split_lines_(sl2, "a\nb\na\nb\n", area);
|
||||
tor_free(sls1);
|
||||
tor_free(sls2);
|
||||
sls1 = smartlist_slice(sl1, 0, -1);
|
||||
@ -282,7 +315,7 @@ test_consdiff_calc_changes(void *arg)
|
||||
bitarray_clear(changed1, 3);
|
||||
|
||||
smartlist_clear(sl2);
|
||||
consensus_split_lines(sl2, "b\nb\nb\nb\n", area);
|
||||
consensus_split_lines_(sl2, "b\nb\nb\nb\n", area);
|
||||
tor_free(sls1);
|
||||
tor_free(sls2);
|
||||
sls1 = smartlist_slice(sl1, 0, -1);
|
||||
@ -610,8 +643,8 @@ test_consdiff_gen_ed_diff(void *arg)
|
||||
/* Test 'a', 'c' and 'd' together. See that it is done in reverse order. */
|
||||
smartlist_clear(cons1);
|
||||
smartlist_clear(cons2);
|
||||
consensus_split_lines(cons1, "A\nB\nC\nD\nE\n", area);
|
||||
consensus_split_lines(cons2, "A\nC\nO\nE\nU\n", area);
|
||||
consensus_split_lines_(cons1, "A\nB\nC\nD\nE\n", area);
|
||||
consensus_split_lines_(cons2, "A\nC\nO\nE\nU\n", area);
|
||||
diff = gen_ed_diff(cons1, cons2, area);
|
||||
tt_ptr_op(NULL, OP_NE, diff);
|
||||
tt_int_op(7, OP_EQ, smartlist_len(diff));
|
||||
@ -627,8 +660,8 @@ test_consdiff_gen_ed_diff(void *arg)
|
||||
|
||||
smartlist_clear(cons1);
|
||||
smartlist_clear(cons2);
|
||||
consensus_split_lines(cons1, "B\n", area);
|
||||
consensus_split_lines(cons2, "A\nB\n", area);
|
||||
consensus_split_lines_(cons1, "B\n", area);
|
||||
consensus_split_lines_(cons2, "A\nB\n", area);
|
||||
diff = gen_ed_diff(cons1, cons2, area);
|
||||
tt_ptr_op(NULL, OP_NE, diff);
|
||||
tt_int_op(3, OP_EQ, smartlist_len(diff));
|
||||
@ -656,7 +689,7 @@ test_consdiff_apply_ed_diff(void *arg)
|
||||
diff = smartlist_new();
|
||||
setup_capture_of_logs(LOG_WARN);
|
||||
|
||||
consensus_split_lines(cons1, "A\nB\nC\nD\nE\n", area);
|
||||
consensus_split_lines_(cons1, "A\nB\nC\nD\nE\n", area);
|
||||
|
||||
/* Command without range. */
|
||||
smartlist_add_linecpy(diff, area, "a");
|
||||
@ -829,7 +862,7 @@ test_consdiff_apply_ed_diff(void *arg)
|
||||
smartlist_clear(diff);
|
||||
|
||||
/* Test appending text, 'a'. */
|
||||
consensus_split_lines(diff, "3a\nU\nO\n.\n0a\nV\n.\n", area);
|
||||
consensus_split_lines_(diff, "3a\nU\nO\n.\n0a\nV\n.\n", area);
|
||||
cons2 = apply_ed_diff(cons1, diff, 0);
|
||||
tt_ptr_op(NULL, OP_NE, cons2);
|
||||
tt_int_op(8, OP_EQ, smartlist_len(cons2));
|
||||
@ -846,7 +879,7 @@ test_consdiff_apply_ed_diff(void *arg)
|
||||
smartlist_free(cons2);
|
||||
|
||||
/* Test deleting text, 'd'. */
|
||||
consensus_split_lines(diff, "4d\n1,2d\n", area);
|
||||
consensus_split_lines_(diff, "4d\n1,2d\n", area);
|
||||
cons2 = apply_ed_diff(cons1, diff, 0);
|
||||
tt_ptr_op(NULL, OP_NE, cons2);
|
||||
tt_int_op(2, OP_EQ, smartlist_len(cons2));
|
||||
@ -857,7 +890,7 @@ test_consdiff_apply_ed_diff(void *arg)
|
||||
smartlist_free(cons2);
|
||||
|
||||
/* Test changing text, 'c'. */
|
||||
consensus_split_lines(diff, "4c\nT\nX\n.\n1,2c\nM\n.\n", area);
|
||||
consensus_split_lines_(diff, "4c\nT\nX\n.\n1,2c\nM\n.\n", area);
|
||||
cons2 = apply_ed_diff(cons1, diff, 0);
|
||||
tt_ptr_op(NULL, OP_NE, cons2);
|
||||
tt_int_op(5, OP_EQ, smartlist_len(cons2));
|
||||
@ -871,7 +904,7 @@ test_consdiff_apply_ed_diff(void *arg)
|
||||
smartlist_free(cons2);
|
||||
|
||||
/* Test 'a', 'd' and 'c' together. */
|
||||
consensus_split_lines(diff, "4c\nT\nX\n.\n2d\n0a\nM\n.\n", area);
|
||||
consensus_split_lines_(diff, "4c\nT\nX\n.\n2d\n0a\nM\n.\n", area);
|
||||
cons2 = apply_ed_diff(cons1, diff, 0);
|
||||
tt_ptr_op(NULL, OP_NE, cons2);
|
||||
tt_int_op(6, OP_EQ, smartlist_len(cons2));
|
||||
@ -918,12 +951,12 @@ test_consdiff_gen_diff(void *arg)
|
||||
);
|
||||
|
||||
tt_int_op(0, OP_EQ,
|
||||
consensus_compute_digest_as_signed(cons1_str, &digests1));
|
||||
consensus_compute_digest_as_signed_(cons1_str, &digests1));
|
||||
tt_int_op(0, OP_EQ,
|
||||
consensus_compute_digest(cons2_str, &digests2));
|
||||
consensus_compute_digest_(cons2_str, &digests2));
|
||||
|
||||
consensus_split_lines(cons1, cons1_str, area);
|
||||
consensus_split_lines(cons2, cons2_str, area);
|
||||
consensus_split_lines_(cons1, cons1_str, area);
|
||||
consensus_split_lines_(cons2, cons2_str, area);
|
||||
|
||||
diff = consdiff_gen_diff(cons1, cons2, &digests1, &digests2, area);
|
||||
tt_ptr_op(NULL, OP_EQ, diff);
|
||||
@ -937,9 +970,9 @@ test_consdiff_gen_diff(void *arg)
|
||||
"directory-signature foo bar\nbar\n"
|
||||
);
|
||||
tt_int_op(0, OP_EQ,
|
||||
consensus_compute_digest_as_signed(cons1_str, &digests1));
|
||||
consensus_compute_digest_as_signed_(cons1_str, &digests1));
|
||||
smartlist_clear(cons1);
|
||||
consensus_split_lines(cons1, cons1_str, area);
|
||||
consensus_split_lines_(cons1, cons1_str, area);
|
||||
diff = consdiff_gen_diff(cons1, cons2, &digests1, &digests2, area);
|
||||
tt_ptr_op(NULL, OP_NE, diff);
|
||||
tt_int_op(11, OP_EQ, smartlist_len(diff));
|
||||
@ -991,8 +1024,8 @@ test_consdiff_apply_diff(void *arg)
|
||||
"directory-signature foo bar\nbar\n"
|
||||
);
|
||||
tt_int_op(0, OP_EQ,
|
||||
consensus_compute_digest(cons1_str, &digests1));
|
||||
consensus_split_lines(cons1, cons1_str, area);
|
||||
consensus_compute_digest_(cons1_str, &digests1));
|
||||
consensus_split_lines_(cons1, cons1_str, area);
|
||||
|
||||
/* diff doesn't have enough lines. */
|
||||
cons2 = consdiff_apply_diff(cons1, diff, &digests1);
|
||||
@ -1182,4 +1215,3 @@ struct testcase_t consdiff_tests[] = {
|
||||
CONSDIFF_LEGACY(apply_diff),
|
||||
END_OF_TESTCASES
|
||||
};
|
||||
|
||||
|
||||
@ -21,6 +21,21 @@
|
||||
#include "test/test.h"
|
||||
#include "test/log_test_helpers.h"
|
||||
|
||||
static char *
|
||||
consensus_diff_apply_(const char *c, const char *d)
|
||||
{
|
||||
size_t c_len = strlen(c);
|
||||
size_t d_len = strlen(d);
|
||||
// We use memdup here to ensure that the input is NOT nul-terminated.
|
||||
// This makes it likelier for us to spot bugs.
|
||||
char *c_tmp = tor_memdup(c, c_len);
|
||||
char *d_tmp = tor_memdup(d, d_len);
|
||||
char *result = consensus_diff_apply(c_tmp, c_len, d_tmp, d_len);
|
||||
tor_free(c_tmp);
|
||||
tor_free(d_tmp);
|
||||
return result;
|
||||
}
|
||||
|
||||
// ============================== Setup/teardown the consdiffmgr
|
||||
// These functions get run before/after each test in this module
|
||||
|
||||
@ -153,7 +168,8 @@ lookup_diff_from(consensus_cache_entry_t **out,
|
||||
const char *str1)
|
||||
{
|
||||
uint8_t digest[DIGEST256_LEN];
|
||||
if (router_get_networkstatus_v3_sha3_as_signed(digest, str1)<0) {
|
||||
if (router_get_networkstatus_v3_sha3_as_signed(digest,
|
||||
str1, strlen(str1))<0) {
|
||||
TT_FAIL(("Unable to compute sha3-as-signed"));
|
||||
return CONSDIFF_NOT_FOUND;
|
||||
}
|
||||
@ -181,7 +197,7 @@ lookup_apply_and_verify_diff(consensus_flavor_t flav,
|
||||
if (diff_string == NULL || r < 0)
|
||||
return -1;
|
||||
|
||||
char *applied = consensus_diff_apply(str1, diff_string);
|
||||
char *applied = consensus_diff_apply_(str1, diff_string);
|
||||
tor_free(diff_string);
|
||||
if (applied == NULL)
|
||||
return -1;
|
||||
@ -370,7 +386,8 @@ test_consdiffmgr_make_diffs(void *arg)
|
||||
ns = fake_ns_new(FLAV_MICRODESC, now-3600);
|
||||
md_ns_body = fake_ns_body_new(FLAV_MICRODESC, now-3600);
|
||||
r = consdiffmgr_add_consensus(md_ns_body, ns);
|
||||
router_get_networkstatus_v3_sha3_as_signed(md_ns_sha3, md_ns_body);
|
||||
router_get_networkstatus_v3_sha3_as_signed(md_ns_sha3, md_ns_body,
|
||||
strlen(md_ns_body));
|
||||
networkstatus_vote_free(ns);
|
||||
tt_int_op(r, OP_EQ, 0);
|
||||
|
||||
@ -414,7 +431,7 @@ test_consdiffmgr_make_diffs(void *arg)
|
||||
r = consensus_cache_entry_get_body(diff, &diff_body, &diff_size);
|
||||
tt_int_op(r, OP_EQ, 0);
|
||||
diff_text = tor_memdup_nulterm(diff_body, diff_size);
|
||||
applied = consensus_diff_apply(md_ns_body, diff_text);
|
||||
applied = consensus_diff_apply_(md_ns_body, diff_text);
|
||||
tt_assert(applied);
|
||||
tt_str_op(applied, OP_EQ, md_ns_body_2);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user