static svn_error_t *
test_svn_subst_translate_string2(apr_pool_t *pool)
{
static const struct translate_string2_data_t tests[] =
{
/* No reencoding, no translation of line endings */
{ "abcdefz",
"abcdefz", FALSE, FALSE },
/* No reencoding, translation of line endings */
{ " \r\n\r\n \r\n \r\n",
" \n\n \n \n", FALSE, TRUE },
/* Reencoding, no translation of line endings */
{ "\xc7\xa9\xf4\xdf",
"\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f", TRUE, FALSE },
/* Reencoding, translation of line endings */
{ "\xc7\xa9\xf4\xdf\r\n",
"\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f\n", TRUE, TRUE },
{ NULL, NULL, FALSE, FALSE }
};
const struct translate_string2_data_t *t;
for (t = tests; t->source != NULL; t++)
{
svn_string_t *source_string = svn_string_create(t->source, pool);
svn_string_t *new_value = NULL;
svn_boolean_t translated_line_endings = ! t->translated_line_endings;
svn_boolean_t translated_to_utf8;
SVN_ERR(svn_subst_translate_string2(&new_value,
NULL, &translated_line_endings,
source_string, "ISO-8859-1", FALSE,
pool, pool));
SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str);
SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings);
new_value = NULL;
translated_to_utf8 = ! t->translated_to_utf8;
translated_line_endings = ! t->translated_line_endings;
SVN_ERR(svn_subst_translate_string2(&new_value, &translated_to_utf8,
&translated_line_endings,
source_string, "ISO-8859-1", FALSE,
pool, pool));
SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str);
SVN_TEST_ASSERT(translated_to_utf8 == t->translated_to_utf8);
SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings);
}
/* Test that when REPAIR is FALSE, SVN_ERR_IO_INCONSISTENT_EOL is returned. */
{
svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool);
svn_string_t *new_value = NULL;
svn_error_t *err = svn_subst_translate_string2(&new_value, NULL, NULL,
source_string,
"ISO-8859-1", FALSE, pool,
pool);
SVN_TEST_ASSERT_ERROR(err, SVN_ERR_IO_INCONSISTENT_EOL);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_get_commit_editor4(const svn_delta_editor_t **editor,
void **edit_baton,
svn_repos_t *repos,
svn_fs_txn_t *txn,
const char *repos_url,
const char *base_path,
const char *user,
const char *log_msg,
svn_commit_callback2_t callback,
void *callback_baton,
svn_repos_authz_callback_t authz_callback,
void *authz_baton,
apr_pool_t *pool)
{
apr_hash_t *revprop_table = apr_hash_make(pool);
if (user)
apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING,
svn_string_create(user, pool));
if (log_msg)
apr_hash_set(revprop_table, SVN_PROP_REVISION_LOG,
APR_HASH_KEY_STRING,
svn_string_create(log_msg, pool));
return svn_repos_get_commit_editor5(editor, edit_baton, repos, txn,
repos_url, base_path, revprop_table,
callback, callback_baton,
authz_callback, authz_baton, pool);
}
static dav_error *
db_store(dav_db *db,
const dav_prop_name *name,
const apr_xml_elem *elem,
dav_namespace_map *mapping)
{
const svn_string_t *const *old_propval_p;
const svn_string_t *old_propval;
const svn_string_t *propval;
svn_boolean_t absent;
apr_pool_t *pool = db->p;
dav_error *derr;
/* SVN sends property values as a big blob of bytes. Thus, there should be
no child elements of the property-name element. That also means that
the entire contents of the blob is located in elem->first_cdata. The
dav_xml_get_cdata() will figure it all out for us, but (normally) it
should be awfully fast and not need to copy any data. */
propval = svn_string_create
(dav_xml_get_cdata(elem, pool, 0 /* strip_white */), pool);
derr = decode_property_value(&propval, &absent, propval, elem, pool);
if (derr)
return derr;
if (absent && ! elem->first_child)
/* ### better error check */
return dav_svn__new_error(pool, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(pool,
"'%s' cannot be specified on the "
"value without specifying an "
"expectation",
SVN_DAV__OLD_VALUE__ABSENT));
/* ### namespace check? */
if (elem->first_child && !strcmp(elem->first_child->name, SVN_DAV__OLD_VALUE))
{
const char *propname;
get_repos_propname(db, name, &propname);
/* Parse OLD_PROPVAL. */
old_propval = svn_string_create(dav_xml_get_cdata(elem->first_child, pool,
0 /* strip_white */),
pool);
derr = decode_property_value(&old_propval, &absent,
old_propval, elem->first_child, pool);
if (derr)
return derr;
old_propval_p = (const svn_string_t *const *) &old_propval;
}
else
old_propval_p = NULL;
return save_value(db, name, old_propval_p, propval);
}
/**
* set property in @a path no matter whether local or
* repository
*
* @param path
* @param revision
* @param propName
* @param propValue
* @param recurse
* @param revprop
* @return PropertiesList
*/
svn_revnum_t
Client::revpropset(const char *propName,
const char *propValue,
const Path &path,
const Revision &revision,
bool force)
{
Pool pool;
const svn_string_t * propval
= svn_string_create((const char *) propValue, pool);
svn_revnum_t revnum;
svn_error_t * error =
svn_client_revprop_set(propName,
propval,
path.c_str(),
revision.revision(),
&revnum,
force,
*m_context,
pool);
if (error != nullptr)
throw ClientException(error);
return revnum;
}
/* Check that reading a line from HUNK equals what's inside EXPECTED.
* If ORIGINAL is TRUE, read the original hunk text; else, read the
* modified hunk text. */
static svn_error_t *
check_content(svn_diff_hunk_t *hunk, svn_boolean_t original,
const char *expected, apr_pool_t *pool)
{
svn_stream_t *exp;
svn_stringbuf_t *exp_buf;
svn_stringbuf_t *hunk_buf;
svn_boolean_t exp_eof;
svn_boolean_t hunk_eof;
exp = svn_stream_from_string(svn_string_create(expected, pool),
pool);
while (TRUE)
{
SVN_ERR(svn_stream_readline(exp, &exp_buf, NL, &exp_eof, pool));
if (original)
SVN_ERR(svn_diff_hunk_readline_original_text(hunk, &hunk_buf, NULL,
&hunk_eof, pool, pool));
else
SVN_ERR(svn_diff_hunk_readline_modified_text(hunk, &hunk_buf, NULL,
&hunk_eof, pool, pool));
SVN_TEST_ASSERT(exp_eof == hunk_eof);
if (exp_eof)
break;
SVN_TEST_STRING_ASSERT(exp_buf->data, hunk_buf->data);
}
if (!hunk_eof)
SVN_TEST_ASSERT(hunk_buf->len == 0);
return SVN_NO_ERROR;
}
/* Implementation of svn_auth__password_get_t that decrypts
the incoming password using the Windows CryptoAPI and verifies its
validity. */
static svn_error_t *
windows_ssl_client_cert_pw_decrypter(svn_boolean_t *done,
const char **out,
apr_hash_t *creds,
const char *realmstring,
const char *username,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool)
{
const svn_string_t *orig;
const char *in;
SVN_ERR(svn_auth__ssl_client_cert_pw_get(done, &in, creds, realmstring,
username, parameters,
non_interactive, pool));
if (!*done)
return SVN_NO_ERROR;
orig = svn_base64_decode_string(svn_string_create(in, pool), pool);
orig = decrypt_data(orig, pool);
if (orig)
{
*out = orig->data;
*done = TRUE;
}
else
{
*done = FALSE;
}
return SVN_NO_ERROR;
}
static int
l_propset (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
err = svn_client_propset2 (propname_utf8, sstring, path, TRUE, FALSE, ctx, pool);
} else {
err = svn_client_propset2 (propname_utf8, NULL, path, TRUE, FALSE, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
apr_hash_t *hashOfStringsFromDistOfStrings( Py::Object arg, SvnPool &pool )
{
Py::Dict dict( arg );
apr_hash_t *hash = apr_hash_make( pool );
std::string type_error_message;
try
{
Py::List all_keys( dict.keys() );
for( Py::List::size_type i=0; i<all_keys.length(); i++ )
{
type_error_message = "expecting string key in dict";
Py::Bytes key( asUtf8Bytes( all_keys[i] ) );
type_error_message = "expecting string value in dict";
Py::Bytes value( asUtf8Bytes( dict[ key ] ) );
char *hash_key = apr_pstrdup( pool, key.as_std_string().c_str() );
svn_string_t *hash_value = svn_string_create( value.as_std_string().c_str(), pool );
apr_hash_set( hash, hash_key, APR_HASH_KEY_STRING, hash_value );
}
}
catch( Py::TypeError & )
{
throw Py::TypeError( type_error_message );
}
return hash;
}
static svn_error_t *
ssl_server_trust_file_save_credentials(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
svn_auth_cred_ssl_server_trust_t *creds = credentials;
const svn_auth_ssl_server_cert_info_t *cert_info;
apr_hash_t *creds_hash = NULL;
const char *config_dir;
if (! creds->may_save)
return SVN_NO_ERROR;
config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);
cert_info = svn_hash_gets(parameters, SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO);
creds_hash = apr_hash_make(pool);
svn_hash_sets(creds_hash, SVN_CONFIG_AUTHN_ASCII_CERT_KEY,
svn_string_create(cert_info->ascii_cert, pool));
svn_hash_sets(creds_hash, SVN_CONFIG_AUTHN_FAILURES_KEY,
svn_string_createf(pool, "%lu",
(unsigned long)creds->accepted_failures));
SVN_ERR(svn_config_write_auth_data(creds_hash,
SVN_AUTH_CRED_SSL_SERVER_TRUST,
realmstring,
config_dir,
pool));
*saved = TRUE;
return SVN_NO_ERROR;
}
/* Send a property named NAME with value VAL in an element named ELEM_NAME.
Quote NAME and base64-encode VAL if necessary. */
static svn_error_t *
send_prop(struct file_rev_baton *frb,
const char *elem_name,
const char *name,
const svn_string_t *val,
apr_pool_t *pool)
{
name = apr_xml_quote_string(pool, name, 1);
if (svn_xml_is_xml_safe(val->data, val->len))
{
svn_stringbuf_t *tmp = NULL;
svn_xml_escape_cdata_string(&tmp, val, pool);
val = svn_string_create(tmp->data, pool);
SVN_ERR(dav_svn__brigade_printf(frb->bb, frb->output,
"<S:%s name=\"%s\">%s</S:%s>" DEBUG_CR,
elem_name, name, val->data, elem_name));
}
else
{
val = svn_base64_encode_string2(val, TRUE, pool);
SVN_ERR(dav_svn__brigade_printf(frb->bb, frb->output,
"<S:%s name=\"%s\" encoding=\"base64\">"
"%s</S:%s>" DEBUG_CR,
elem_name, name, val->data, elem_name));
}
return SVN_NO_ERROR;
}
const apr_hash_t *RevpropTable::hash(const SVN::Pool &pool)
{
if (m_revprops.size() == 0)
return NULL;
apr_hash_t *revprop_table = apr_hash_make(pool.getPool());
std::map<std::string, std::string>::const_iterator it;
for (it = m_revprops.begin(); it != m_revprops.end(); ++it)
{
const char *propname = apr_pstrdup(pool.getPool(), it->first.c_str());
if (!svn_prop_name_is_valid(propname))
{
const char *msg = apr_psprintf(pool.getPool(),
"Invalid property name: '%s'",
propname);
JNIUtil::throwNativeException(JAVA_PACKAGE "/ClientException", msg,
NULL, SVN_ERR_CLIENT_PROPERTY_NAME);
return NULL;
}
svn_string_t *propval = svn_string_create(it->second.c_str(),
pool.getPool());
apr_hash_set(revprop_table, propname, APR_HASH_KEY_STRING, propval);
}
return revprop_table;
}
/* Helper for svn_repos_dump_fs.
Write a revision record of REV in FS to writable STREAM, using POOL.
*/
static svn_error_t *
write_revision_record(svn_stream_t *stream,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool)
{
apr_size_t len;
apr_hash_t *props;
svn_stringbuf_t *encoded_prophash;
apr_time_t timetemp;
svn_string_t *datevalue;
svn_stream_t *propstream;
/* Read the revision props even if we're aren't going to dump
them for verification purposes */
SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, pool));
/* Run revision date properties through the time conversion to
canonicalize them. */
/* ### Remove this when it is no longer needed for sure. */
datevalue = apr_hash_get(props, SVN_PROP_REVISION_DATE,
APR_HASH_KEY_STRING);
if (datevalue)
{
SVN_ERR(svn_time_from_cstring(&timetemp, datevalue->data, pool));
datevalue = svn_string_create(svn_time_to_cstring(timetemp, pool),
pool);
apr_hash_set(props, SVN_PROP_REVISION_DATE, APR_HASH_KEY_STRING,
datevalue);
}
encoded_prophash = svn_stringbuf_create_ensure(0, pool);
propstream = svn_stream_from_stringbuf(encoded_prophash, pool);
SVN_ERR(svn_hash_write2(props, propstream, "PROPS-END", pool));
SVN_ERR(svn_stream_close(propstream));
/* ### someday write a revision-content-checksum */
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_REVISION_NUMBER
": %ld\n", rev));
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n",
encoded_prophash->len));
/* Write out a regular Content-length header for the benefit of
non-Subversion RFC-822 parsers. */
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n\n",
encoded_prophash->len));
len = encoded_prophash->len;
SVN_ERR(svn_stream_write(stream, encoded_prophash->data, &len));
len = 1;
return svn_stream_write(stream, "\n", &len);
}
/* retrieve ssl server CA failure overrides (if any) from servers
config */
static svn_error_t *
ssl_server_trust_file_first_credentials(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
apr_uint32_t *failures = svn_hash_gets(parameters,
SVN_AUTH_PARAM_SSL_SERVER_FAILURES);
const svn_auth_ssl_server_cert_info_t *cert_info =
svn_hash_gets(parameters, SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO);
apr_hash_t *creds_hash = NULL;
const char *config_dir;
svn_error_t *error = SVN_NO_ERROR;
*credentials = NULL;
*iter_baton = NULL;
/* Check if this is a permanently accepted certificate */
config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);
error =
svn_config_read_auth_data(&creds_hash, SVN_AUTH_CRED_SSL_SERVER_TRUST,
realmstring, config_dir, pool);
svn_error_clear(error);
if (! error && creds_hash)
{
svn_string_t *trusted_cert, *this_cert, *failstr;
apr_uint32_t last_failures = 0;
trusted_cert = svn_hash_gets(creds_hash, SVN_CONFIG_AUTHN_ASCII_CERT_KEY);
this_cert = svn_string_create(cert_info->ascii_cert, pool);
failstr = svn_hash_gets(creds_hash, SVN_CONFIG_AUTHN_FAILURES_KEY);
if (failstr)
SVN_ERR(svn_cstring_atoui(&last_failures, failstr->data));
/* If the cert is trusted and there are no new failures, we
* accept it by clearing all failures. */
if (trusted_cert &&
svn_string_compare(this_cert, trusted_cert) &&
(*failures & ~last_failures) == 0)
{
*failures = 0;
}
}
/* If all failures are cleared now, we return the creds */
if (! *failures)
{
svn_auth_cred_ssl_server_trust_t *creds =
apr_pcalloc(pool, sizeof(*creds));
creds->may_save = FALSE; /* No need to save it again... */
*credentials = creds;
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_begin_txn_for_commit(svn_fs_txn_t **txn_p,
svn_repos_t *repos,
svn_revnum_t rev,
const char *author,
const char *log_msg,
apr_pool_t *pool)
{
apr_hash_t *revprop_table = apr_hash_make(pool);
if (author)
svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,
svn_string_create(author, pool));
if (log_msg)
svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
svn_string_create(log_msg, pool));
return svn_repos_fs_begin_txn_for_commit2(txn_p, repos, rev, revprop_table,
pool);
}
/* For one auto-props config entry (NAME, VALUE), if the filename pattern
NAME matches BATON->filename case insensitively then add the properties
listed in VALUE into BATON->properties.
BATON must point to an auto_props_baton_t.
*/
static svn_boolean_t
auto_props_enumerator(const char *name,
const char *value,
void *baton,
apr_pool_t *pool)
{
auto_props_baton_t *autoprops = baton;
char *property;
char *last_token;
/* nothing to do here without a value */
if (strlen(value) == 0)
return TRUE;
/* check if filename matches and return if it doesn't */
if (apr_fnmatch(name, autoprops->filename, APR_FNM_CASE_BLIND) == APR_FNM_NOMATCH)
return TRUE;
/* parse the value (we dup it first to effectively lose the
'const', and to avoid messing up the original value) */
property = apr_pstrdup(autoprops->pool, value);
property = apr_strtok(property, ";", &last_token);
while (property)
{
int len;
const char *this_value;
char *equal_sign = strchr(property, '=');
if (equal_sign)
{
*equal_sign = '\0';
equal_sign++;
trim_string(&equal_sign);
this_value = equal_sign;
}
else
{
this_value = "";
}
trim_string(&property);
len = strlen(property);
if (len > 0)
{
svn_string_t *propval = svn_string_create(this_value,
autoprops->pool);
apr_hash_set(autoprops->properties, property, len, propval);
if (strcmp(property, SVN_PROP_MIME_TYPE) == 0)
autoprops->mimetype = this_value;
else if (strcmp(property, SVN_PROP_EXECUTABLE) == 0)
autoprops->have_executable = TRUE;
}
property = apr_strtok(NULL, ";", &last_token);
}
return TRUE;
}
svn_error_t *
svn_ra_neon__get_activity_collection(const svn_string_t **activity_coll,
svn_ra_neon__session_t *ras,
apr_pool_t *pool)
{
if (! ras->act_coll)
SVN_ERR(svn_ra_neon__exchange_capabilities(ras, pool));
*activity_coll = svn_string_create(ras->act_coll, pool);
return SVN_NO_ERROR;
}
static int
l_revprop_set (lua_State *L) {
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
svn_opt_revision_t revision;
svn_revnum_t rev;
const char *url = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
const char *propname_utf8 = NULL;
int itable = 5;
svn_boolean_t force = FALSE;
if (lua_gettop (L) < 4 || lua_isnil (L, 4)) {
revision.kind = get_revision_kind (url);
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 4);
}
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
init_function (&ctx, &pool, L);
url = svn_path_canonicalize (url, pool);
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
if (svn_prop_needs_translation (propname_utf8)) {
err = svn_subst_translate_string (&sstring, sstring, APR_LOCALE_CHARSET, pool);
IF_ERROR_RETURN (err, pool, L);
}
err = svn_client_revprop_set (propname_utf8, sstring, url, &revision, &rev, force, ctx, pool);
} else {
err = svn_client_revprop_set (propname_utf8, NULL, url, &revision, &rev, force, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
static svn_error_t *
test_invalid_bom(apr_pool_t *pool)
{
svn_config_t *cfg;
svn_error_t *err;
svn_string_t *cfg_string;
svn_stream_t *stream;
cfg_string = svn_string_create("\xEF", pool);
stream = svn_stream_from_string(cfg_string, pool);
err = svn_config_parse(&cfg, stream, TRUE, TRUE, pool);
SVN_TEST_ASSERT_ERROR(err, SVN_ERR_MALFORMED_FILE);
cfg_string = svn_string_create("\xEF\xBB", pool);
stream = svn_stream_from_string(cfg_string, pool);
err = svn_config_parse(&cfg, stream, TRUE, TRUE, pool);
SVN_TEST_ASSERT_ERROR(err, SVN_ERR_MALFORMED_FILE);
return SVN_NO_ERROR;
}
static svn_error_t *
get_node_props(apr_hash_t **props,
svn_ra_local__session_baton_t *sess,
svn_fs_root_t *root,
const char *path,
apr_pool_t *pool)
{
svn_revnum_t cmt_rev;
const char *cmt_date, *cmt_author;
/* Create a hash with props attached to the fs node. */
SVN_ERR(svn_fs_node_proplist(props, root, path, pool));
/* Now add some non-tweakable metadata to the hash as well... */
/* The so-called 'entryprops' with info about CR & friends. */
SVN_ERR(svn_repos_get_committed_info(&cmt_rev, &cmt_date,
&cmt_author, root, path, pool));
apr_hash_set(*props,
SVN_PROP_ENTRY_COMMITTED_REV,
APR_HASH_KEY_STRING,
svn_string_createf(pool, "%ld", cmt_rev));
apr_hash_set(*props,
SVN_PROP_ENTRY_COMMITTED_DATE,
APR_HASH_KEY_STRING,
cmt_date ? svn_string_create(cmt_date, pool) : NULL);
apr_hash_set(*props,
SVN_PROP_ENTRY_LAST_AUTHOR,
APR_HASH_KEY_STRING,
cmt_author ? svn_string_create(cmt_author, pool) : NULL);
apr_hash_set(*props,
SVN_PROP_ENTRY_UUID,
APR_HASH_KEY_STRING,
svn_string_create(sess->uuid, pool));
/* We have no 'wcprops' in ra_local, but might someday. */
return SVN_NO_ERROR;
}
static int
l_propset (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3);
svn_boolean_t recursive = FALSE;
svn_boolean_t force = FALSE;
int itable = 4;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
if (propval != NULL) {
svn_string_t *sstring = svn_string_create (propval, pool);
err = svn_client_propset2 (propname_utf8, sstring, path, recursive, force, ctx, pool);
} else {
err = svn_client_propset2 (propname_utf8, NULL, path, recursive, force, ctx, pool);
}
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
/* This implements the svn_auth__password_set_t interface.
Store PASSPHRASE in CREDS; ignore other parameters. */
svn_boolean_t
svn_auth__ssl_client_cert_pw_set(apr_hash_t *creds,
const char *realmstring,
const char *username,
const char *passphrase,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool)
{
apr_hash_set(creds, AUTHN_PASSPHRASE_KEY, APR_HASH_KEY_STRING,
svn_string_create(passphrase, pool));
return TRUE;
}
static svn_error_t *
test_svn_subst_truncated_keywords(apr_pool_t *pool)
{
svn_string_t *src_string
= svn_string_create("$Qq: "
"01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"012345678901234567890123456789012345678901234567"
" $", pool);
svn_stream_t *src_stream = svn_stream_from_string(src_string, pool);
svn_stringbuf_t *dst_stringbuf = svn_stringbuf_create_empty(pool);
svn_stream_t *dst_stream = svn_stream_from_stringbuf(dst_stringbuf, pool);
apr_hash_t *keywords = apr_hash_make(pool);
svn_string_t *expanded
= svn_string_create("01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890123456789"
"012345678901234567890123456789012345678901234567"
"xxxxxxxxxx",
pool);
/* The source is already at the maximum length. */
SVN_TEST_ASSERT(src_string->len == SVN_KEYWORD_MAX_LEN);
svn_hash_sets(keywords, "Qq", expanded);
dst_stream = svn_subst_stream_translated(dst_stream, NULL, FALSE, keywords,
TRUE, pool);
SVN_ERR(svn_stream_copy3(src_stream, dst_stream, NULL, NULL, pool));
/* The expanded value would make the keyword longer than the maximum
allowed so it must be truncated; the remaining part of the
expanded value is the same as the source. */
SVN_TEST_STRING_ASSERT(dst_stringbuf->data, src_string->data);
return SVN_NO_ERROR;
}
/* Get a lock comment, allocate it in POOL and store it in *COMMENT. */
static svn_error_t *
get_comment(const char **comment, svn_client_ctx_t *ctx,
svn_cl__opt_state_t *opt_state, apr_pool_t *pool)
{
svn_string_t *comment_string;
if (opt_state->filedata)
{
/* Get it from the -F argument. */
if (strlen(opt_state->filedata->data) < opt_state->filedata->len)
{
/* A message containing a zero byte can't be represented as a C
string. */
return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL,
_("Lock comment contains a zero byte"));
}
comment_string = svn_string_create(opt_state->filedata->data, pool);
}
else if (opt_state->message)
{
/* Get if from the -m option. */
comment_string = svn_string_create(opt_state->message, pool);
}
else
{
*comment = NULL;
return SVN_NO_ERROR;
}
/* Translate to UTF8/LF. */
SVN_ERR(svn_subst_translate_string2(&comment_string, NULL, NULL,
comment_string, opt_state->encoding,
FALSE, pool, pool));
*comment = comment_string->data;
return SVN_NO_ERROR;
}
dav_error *
dav_svn__create_txn(dav_svn_repos *repos,
const char **ptxn_name,
apr_hash_t *revprops,
apr_pool_t *pool)
{
svn_revnum_t rev;
svn_fs_txn_t *txn;
svn_error_t *serr;
if (! revprops)
{
revprops = apr_hash_make(pool);
}
if (repos->username)
{
svn_hash_sets(revprops,
SVN_PROP_REVISION_AUTHOR,
svn_string_create(repos->username, pool));
}
serr = dav_svn__get_youngest_rev(&rev, repos, pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not determine youngest revision",
repos->pool);
}
serr = svn_repos_fs_begin_txn_for_commit2(&txn, repos->repos, rev,
revprops, repos->pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not begin a transaction",
repos->pool);
}
serr = svn_fs_txn_name(ptxn_name, txn, pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not fetch transaction name",
repos->pool);
}
return NULL;
}
static svn_error_t *
test_ignore_bom(apr_pool_t *pool)
{
svn_config_t *cfg;
svn_string_t *cfg_string = svn_string_create("\xEF\xBB\xBF[s1]\nfoo=bar\n",
pool);
svn_stream_t *stream = svn_stream_from_string(cfg_string, pool);
SVN_ERR(svn_config_parse(&cfg, stream, TRUE, TRUE, pool));
if (! svn_config_has_section(cfg, "s1"))
return fail(pool, "failed to find section s1");
return SVN_NO_ERROR;
}
static svn_error_t *
test_repairing_svn_subst_translate_string2(apr_pool_t *pool)
{
{
svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool);
svn_string_t *new_value = NULL;
SVN_ERR(svn_subst_translate_string2(&new_value, NULL, NULL, source_string,
"ISO-8859-1", TRUE, pool, pool));
SVN_TEST_ASSERT(new_value != NULL);
SVN_TEST_ASSERT(new_value->data != NULL);
SVN_TEST_STRING_ASSERT(new_value->data, " \n \n \n ");
}
return SVN_NO_ERROR;
}
/* This implements the svn_auth__password_set_t interface.
Store PASSPHRASE in CREDS; ignore other parameters. */
svn_error_t *
svn_auth__ssl_client_cert_pw_set(svn_boolean_t *done,
apr_hash_t *creds,
const char *realmstring,
const char *username,
const char *passphrase,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool)
{
svn_hash_sets(creds, AUTHN_PASSPHRASE_KEY,
svn_string_create(passphrase, pool));
*done = TRUE;
return SVN_NO_ERROR;
}
svn_error_t *
svn_opt_parse_revprop(apr_hash_t **revprop_table_p, const char *revprop_spec,
apr_pool_t *pool)
{
const char *sep, *propname;
svn_string_t *propval;
if (! *revprop_spec)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Revision property pair is empty"));
if (! *revprop_table_p)
*revprop_table_p = apr_hash_make(pool);
sep = strchr(revprop_spec, '=');
if (sep)
{
propname = apr_pstrndup(pool, revprop_spec, sep - revprop_spec);
SVN_ERR(svn_utf_cstring_to_utf8(&propname, propname, pool));
propval = svn_string_create(sep + 1, pool);
}
else
{
SVN_ERR(svn_utf_cstring_to_utf8(&propname, revprop_spec, pool));
propval = svn_string_create("", pool);
}
if (!svn_prop_name_is_valid(propname))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
propname);
apr_hash_set(*revprop_table_p, propname, APR_HASH_KEY_STRING, propval);
return SVN_NO_ERROR;
}
svn_error_t *
svn_rdump__normalize_prop(const char *name,
const svn_string_t **value,
apr_pool_t *result_pool)
{
if (svn_prop_needs_translation(name))
{
const char *cstring;
SVN_ERR(svn_subst_translate_cstring2((*value)->data, &cstring,
"\n", TRUE,
NULL, FALSE,
result_pool));
*value = svn_string_create(cstring, result_pool);
}
return SVN_NO_ERROR;
}
svn_error_t *
sbox_wc_propset(svn_test__sandbox_t *b,
const char *name,
const char *value,
const char *path)
{
svn_client_ctx_t *ctx;
apr_array_header_t *paths = apr_array_make(b->pool, 1,
sizeof(const char *));
svn_string_t *pval = value ? svn_string_create(value, b->pool) : NULL;
SVN_ERR(svn_client_create_context2(&ctx, NULL, b->pool));
ctx->wc_ctx = b->wc_ctx;
APR_ARRAY_PUSH(paths, const char *) = sbox_wc_path(b, path);
return svn_client_propset_local(name, pval, paths, svn_depth_empty,
TRUE /* skip_checks */,
NULL, ctx, b->pool);
}