static svn_error_t *
test3(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
char *tmp;
size_t old_len;
*msg = "append svn_stringbuf_t to svn_stringbuf_t";
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(phrase_1, pool);
b = svn_stringbuf_ncreate(phrase_2, 16, pool);
tmp = apr_palloc(pool, (a->len + b->len + 1));
strcpy(tmp, a->data);
strcat(tmp, b->data);
old_len = a->len;
svn_stringbuf_appendstr(a, b);
/* Test that length, data, and null-termination are correct. */
if ((a->len == (old_len + b->len)) && ((strcmp(a->data, tmp)) == 0))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
svn_stringbuf_t *
svn_fs_fs__unparse_representation(representation_t *rep,
int format,
svn_boolean_t mutable_rep_truncated,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
char buffer[SVN_INT64_BUFFER_SIZE];
if (svn_fs_fs__id_txn_used(&rep->txn_id) && mutable_rep_truncated)
return svn_stringbuf_ncreate("-1", 2, result_pool);
if (format < SVN_FS_FS__MIN_REP_SHARING_FORMAT || !rep->has_sha1)
return svn_stringbuf_createf
(result_pool, "%ld %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s",
rep->revision, rep->item_index, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5, FALSE,
scratch_pool));
svn__ui64tobase36(buffer, rep->uniquifier.number);
return svn_stringbuf_createf
(result_pool, "%ld %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s %s %s/_%s",
rep->revision, rep->item_index, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5,
FALSE, scratch_pool),
format_digest(rep->sha1_digest, svn_checksum_sha1,
!rep->has_sha1, scratch_pool),
svn_fs_fs__id_txn_unparse(&rep->uniquifier.noderev_txn_id,
scratch_pool),
buffer);
}
/* Free everything from pool, and return an empty Subversion string. */
static svn_stringbuf_t *
get_empty_string(apr_pool_t *pool)
{
svn_pool_clear(pool);
return svn_stringbuf_ncreate(0, 0, pool);
}
/* Read a field, possibly with escaped bytes, from [*BUF, END),
stopping at the terminator. Place the read string in *RESULT, or set
*RESULT to NULL if it is the empty string. Allocate the returned string
in POOL. Advance *BUF to point after the terminator. */
static svn_error_t *
read_str(const char **result,
char **buf, const char *end,
apr_pool_t *pool)
{
svn_stringbuf_t *s = NULL;
const char *start;
if (*buf == end)
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Unexpected end of entry"));
if (**buf == '\n')
{
*result = NULL;
(*buf)++;
return SVN_NO_ERROR;
}
start = *buf;
while (*buf != end && **buf != '\n')
{
if (**buf == '\\')
{
char c;
if (! s)
s = svn_stringbuf_ncreate(start, *buf - start, pool);
else
svn_stringbuf_appendbytes(s, start, *buf - start);
(*buf)++;
SVN_ERR(read_escaped(&c, buf, end));
svn_stringbuf_appendbyte(s, c);
start = *buf;
}
else
(*buf)++;
}
if (*buf == end)
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Unexpected end of entry"));
if (s)
{
svn_stringbuf_appendbytes(s, start, *buf - start);
*result = s->data;
}
else
*result = apr_pstrndup(pool, start, *buf - start);
(*buf)++;
return SVN_NO_ERROR;
}
static svn_error_t *
test2(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
*msg = "make svn_stringbuf_t from substring of cstring";
if (msg_only)
return SVN_NO_ERROR;
b = svn_stringbuf_ncreate(phrase_2, 16, pool);
/* Test that length, data, and null-termination are correct. */
if ((b->len == 16) && ((strncmp(b->data, phrase_2, 16)) == 0))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
svn_stringbuf_t *
svn_stringbuf_dup(const svn_stringbuf_t *original_string, apr_pool_t *pool)
{
return (svn_stringbuf_ncreate(original_string->data,
original_string->len, pool));
}
svn_stringbuf_t *
svn_stringbuf_create_from_string(const svn_string_t *str, apr_pool_t *pool)
{
return svn_stringbuf_ncreate(str->data, str->len, pool);
}
svn_stringbuf_t *
svn_stringbuf_create(const char *cstring, apr_pool_t *pool)
{
return svn_stringbuf_ncreate(cstring, strlen(cstring), pool);
}
/* Expand OPT_VALUE (which may be NULL) in SECTION into *OPT_X_VALUEP.
If no variable replacements are done, set *OPT_X_VALUEP to
NULL. Allocate from X_POOL. */
static void
expand_option_value(svn_config_t *cfg, cfg_section_t *section,
const char *opt_value, const char **opt_x_valuep,
apr_pool_t *x_pool)
{
svn_stringbuf_t *buf = NULL;
const char *parse_from = opt_value;
const char *copy_from = parse_from;
const char *name_start, *name_end;
while (parse_from != NULL
&& *parse_from != '\0'
&& (name_start = strstr(parse_from, FMT_START)) != NULL)
{
name_start += FMT_START_LEN;
if (*name_start == '\0')
/* FMT_START at end of opt_value. */
break;
name_end = strstr(name_start, FMT_END);
if (name_end != NULL)
{
cfg_option_t *x_opt;
apr_size_t len = name_end - name_start;
char *name = apr_pstrmemdup(x_pool, name_start, len);
x_opt = find_option(cfg, section->name, name, NULL);
if (x_opt != NULL)
{
const char *cstring;
/* Pass back the sub-pool originally provided by
make_string_from_option() as an indication of when it
should terminate. */
make_string_from_option(&cstring, cfg, section, x_opt, x_pool);
/* Append the plain text preceding the expansion. */
len = name_start - FMT_START_LEN - copy_from;
if (buf == NULL)
{
buf = svn_stringbuf_ncreate(copy_from, len, x_pool);
cfg->x_values = TRUE;
}
else
svn_stringbuf_appendbytes(buf, copy_from, len);
/* Append the expansion and adjust parse pointers. */
svn_stringbuf_appendcstr(buf, cstring);
parse_from = name_end + FMT_END_LEN;
copy_from = parse_from;
}
else
/* Though ConfigParser considers the failure to resolve
the requested expansion an exception condition, we
consider it to be plain text, and look for the start of
the next one. */
parse_from = name_end + FMT_END_LEN;
}
else
/* Though ConfigParser treats unterminated format specifiers
as an exception condition, we consider them to be plain
text. The fact that there are no more format specifier
endings means we're done parsing. */
parse_from = NULL;
}
if (buf != NULL)
{
/* Copy the remainder of the plain text. */
svn_stringbuf_appendcstr(buf, copy_from);
*opt_x_valuep = buf->data;
}
else
*opt_x_valuep = NULL;
}
static dav_error *
db_open(apr_pool_t *p,
const dav_resource *resource,
int ro,
dav_db **pdb)
{
dav_db *db;
dav_svn__authz_read_baton *arb;
/* Some resource types do not have deadprop databases.
Specifically: REGULAR, VERSION, WORKING, and our custom
transaction and transaction root resources have them. (SVN does
not have WORKSPACE resources, and isn't covered here.) */
if (resource->type == DAV_RESOURCE_TYPE_HISTORY
|| resource->type == DAV_RESOURCE_TYPE_ACTIVITY
|| (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& resource->info->restype != DAV_SVN_RESTYPE_TXN_COLLECTION
&& resource->info->restype != DAV_SVN_RESTYPE_TXNROOT_COLLECTION))
{
*pdb = NULL;
return NULL;
}
/* If the DB is being opened R/W, and this isn't a working resource, then
we have a problem! */
if ((! ro)
&& resource->type != DAV_RESOURCE_TYPE_WORKING
&& resource->type != DAV_RESOURCE_TYPE_PRIVATE
&& resource->info->restype != DAV_SVN_RESTYPE_TXN_COLLECTION)
{
/* ### Exception: in violation of deltaV, we *are* allowing a
baseline resource to receive a proppatch, as a way of
changing unversioned rev props. Remove this someday: see IZ #916. */
if (! (resource->baselined
&& resource->type == DAV_RESOURCE_TYPE_VERSION))
return dav_svn__new_error(p, HTTP_CONFLICT, 0,
"Properties may only be changed on working "
"resources.");
}
db = apr_pcalloc(p, sizeof(*db));
db->resource = resource;
db->p = svn_pool_create(p);
/* ### temp hack */
db->work = svn_stringbuf_ncreate("", 0, db->p);
/* make our path-based authz callback available to svn_repos_* funcs. */
arb = apr_pcalloc(p, sizeof(*arb));
arb->r = resource->info->r;
arb->repos = resource->info->repos;
db->authz_read_baton = arb;
db->authz_read_func = dav_svn__authz_read_func(arb);
/* ### use RO and node's mutable status to look for an error? */
*pdb = db;
return NULL;
}
static svn_error_t *
stream_readline_chunky(svn_stringbuf_t **stringbuf,
svn_boolean_t *eof,
const char *eol,
svn_stream_t *stream,
apr_pool_t *pool)
{
/* Read larger chunks of data at once into this buffer and scan
* that for EOL. A good chunk size should be about 80 chars since
* most text lines will be shorter. However, don't use a much
* larger value because filling the buffer from the stream takes
* time as well.
*/
char buffer[LINE_CHUNK_SIZE+1];
/* variables */
svn_stream_mark_t *mark;
apr_size_t numbytes;
const char *eol_pos;
apr_size_t total_parsed = 0;
/* invariant for this call */
const size_t eol_len = strlen(eol);
/* Remember the line start so this plus the line length will be
* the position to move to at the end of this function.
*/
SVN_ERR(svn_stream_mark(stream, &mark, pool));
/* Read the first chunk. */
numbytes = LINE_CHUNK_SIZE;
SVN_ERR(svn_stream_read(stream, buffer, &numbytes));
buffer[numbytes] = '\0';
/* Look for the EOL in this first chunk. If we find it, we are done here.
*/
eol_pos = strstr(buffer, eol);
if (eol_pos != NULL)
{
*stringbuf = svn_stringbuf_ncreate(buffer, eol_pos - buffer, pool);
total_parsed = eol_pos - buffer + eol_len;
}
else if (numbytes < LINE_CHUNK_SIZE)
{
/* We hit EOF but not EOL.
*/
*stringbuf = svn_stringbuf_ncreate(buffer, numbytes, pool);
*eof = TRUE;
return SVN_NO_ERROR;
}
else
{
/* A larger buffer for the string is needed. */
svn_stringbuf_t *str;
str = svn_stringbuf_create_ensure(2*LINE_CHUNK_SIZE, pool);
svn_stringbuf_appendbytes(str, buffer, numbytes);
*stringbuf = str;
/* Loop reading chunks until an EOL was found. If we hit EOF, fall
* back to the standard implementation. */
do
{
/* Append the next chunk to the string read so far.
*/
svn_stringbuf_ensure(str, str->len + LINE_CHUNK_SIZE);
numbytes = LINE_CHUNK_SIZE;
SVN_ERR(svn_stream_read(stream, str->data + str->len, &numbytes));
str->len += numbytes;
str->data[str->len] = '\0';
/* Look for the EOL in the new data plus the last part of the
* previous chunk because the EOL may span over the boundary
* between both chunks.
*/
eol_pos = strstr(str->data + str->len - numbytes - (eol_len-1), eol);
if ((numbytes < LINE_CHUNK_SIZE) && (eol_pos == NULL))
{
/* We hit EOF instead of EOL. */
*eof = TRUE;
return SVN_NO_ERROR;
}
}
while (eol_pos == NULL);
/* Number of bytes we actually consumed (i.e. line + EOF).
* We need to "return" the rest to the stream by moving its
* read pointer.
*/
total_parsed = eol_pos - str->data + eol_len;
/* Terminate the string at the EOL postion and return it. */
str->len = eol_pos - str->data;
str->data[str->len] = 0;
}
/* Move the stream read pointer to the first position behind the EOL.
*/
SVN_ERR(svn_stream_seek(stream, mark));
return svn_error_trace(svn_stream_skip(stream, total_parsed));
}
svn_error_t *
svn_fs_fs__dag_deserialize(void **out,
const char *data,
apr_size_t data_len,
apr_pool_t *pool)
{
dag_node_t *node = apr_pcalloc(pool, sizeof(*node));
if (data_len == 0)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
_("Empty noderev in cache"));
if (*data == 'M')
{
const char *newline;
int id_len;
data++;
data_len--;
if (data_len == 0)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
_("Kindless noderev in cache"));
if (*data == 'F')
node->kind = svn_node_file;
else if (*data == 'D')
node->kind = svn_node_dir;
else
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Unknown kind for noderev in cache: '%c'"),
*data);
data++;
data_len--;
newline = memchr(data, '\n', data_len);
if (!newline)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
_("Unterminated ID in cache"));
id_len = newline - 1 - data;
node->id = svn_fs_fs__id_parse(data, id_len, pool);
if (! node->id)
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Bogus ID '%s' in cache"),
apr_pstrndup(pool, data, id_len));
data += id_len;
data_len -= id_len;
data++;
data_len--;
if (data_len == 0)
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
_("No created path"));
node->created_path = apr_pstrndup(pool, data, data_len);
}
else if (*data == 'I')
{
node_revision_t *noderev;
apr_pool_t *subpool = svn_pool_create(pool);
svn_stream_t *stream =
svn_stream_from_stringbuf(svn_stringbuf_ncreate(data + 1,
data_len - 1,
subpool),
subpool);
SVN_ERR(svn_fs_fs__read_noderev(&noderev, stream, pool));
node->kind = noderev->kind;
node->id = svn_fs_fs__id_copy(noderev->id, pool);
node->created_path = apr_pstrdup(pool, noderev->created_path);
if (noderev->is_fresh_txn_root)
node->fresh_root_predecessor_id = noderev->predecessor_id;
node->node_revision = noderev;
svn_pool_destroy(subpool);
}
else
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Unknown node type in cache: '%c'"), *data);
*out = node;
return SVN_NO_ERROR;
}
