int main()
{
std::cout << "sizeof(unsigned char) = " << sizeof(unsigned char) << std::endl;
std::cout << "sizeof(char) = " << sizeof(char) << std::endl;
std::cout << "p is unsigned char*" << std::endl;
std::cout << "p_oc is char*" << std::endl;
std::cout << "p_rc is char*" << std::endl;
unsigned char c = 'c';
unsigned char* p = &c;
char* p_oc = (char*) p; // old-style pointer: compiles
//char* p_sc = static_cast<char*>(p); // static_cast: compiler error
char* p_rc = reinterpret_cast<char*>(p); // reinterpret_cat: compiles
check_content(p, p_oc, p_rc);
*p = 127;
check_content(p, p_oc, p_rc);
*p = 128;
check_content(p, p_oc, p_rc);
*p = 254;
check_content(p, p_oc, p_rc);
// If we assign the maximum value of an unsigned char to *p and *p_xx is
// signed, *p_xx won't be able to represent this value. We will overflow
// *p_xx and it will, most likely, end up having the value of -1.
*p = UCHAR_MAX;
check_content(p, p_oc, p_rc);
}
/* Tests to parse non-valid git diffs. */
static svn_error_t *
test_bad_git_diff_headers(apr_pool_t *pool)
{
svn_patch_file_t *patch_file;
svn_patch_t *patch;
svn_diff_hunk_t *hunk;
SVN_ERR(create_patch_file(&patch_file, bad_git_diff_header, pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "iota");
SVN_TEST_STRING_ASSERT(patch->new_filename, "iota.copied");
SVN_TEST_ASSERT(patch->operation == svn_diff_op_copied);
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"This is the file 'iota'." NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"This is the file 'iota'." NL
"some more bytes to 'iota'" NL,
pool));
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
return SVN_NO_ERROR;
}
static svn_error_t *
test_parse_property_and_text_diff(apr_pool_t *pool)
{
svn_patch_file_t *patch_file;
svn_patch_t *patch;
svn_prop_patch_t *prop_patch;
svn_diff_hunk_t *hunk;
apr_array_header_t *hunks;
SVN_ERR(create_patch_file(&patch_file, property_and_text_unidiff, pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "iota");
SVN_TEST_STRING_ASSERT(patch->new_filename, "iota");
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 1);
/* Check contents of text hunk */
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"This is the file 'iota'." NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"This is the file 'iota'." NL
"some more bytes to 'iota'" NL,
pool));
/* Check the added property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_add",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 1);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"",
pool));
SVN_ERR(check_content(hunk, FALSE,
"value" NL,
pool));
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
return SVN_NO_ERROR;
}
int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
const unsigned char *key, size_t keylen,
BIO *dcont, BIO *out, unsigned int flags)
{
BIO *cont;
int r;
if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_encrypted)
{
CMSerr(CMS_F_CMS_ENCRYPTEDDATA_DECRYPT,
CMS_R_TYPE_NOT_ENCRYPTED_DATA);
return 0;
}
if (!dcont && !check_content(cms))
return 0;
if (CMS_EncryptedData_set1_key(cms, NULL, key, keylen) <= 0)
return 0;
cont = CMS_dataInit(cms, dcont);
if (!cont)
return 0;
r = cms_copy_content(out, cont, flags);
do_free_upto(cont, dcont);
return r;
}
static svn_error_t *
test_parse_unidiff_lacking_trailing_eol(apr_pool_t *pool)
{
svn_patch_file_t *patch_file;
svn_boolean_t reverse;
svn_boolean_t ignore_whitespace;
int i;
apr_pool_t *iterpool;
reverse = FALSE;
ignore_whitespace = FALSE;
iterpool = svn_pool_create(pool);
for (i = 0; i < 2; i++)
{
svn_patch_t *patch;
svn_diff_hunk_t *hunk;
svn_pool_clear(iterpool);
SVN_ERR(create_patch_file(&patch_file, unidiff_lacking_trailing_eol,
pool));
/* We have one patch with one hunk. Parse it. */
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, reverse,
ignore_whitespace, iterpool,
iterpool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/C/gamma");
SVN_TEST_STRING_ASSERT(patch->new_filename, "A/C/gamma");
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, ! reverse,
"This is the file 'gamma'." NL,
pool));
SVN_ERR(check_content(hunk, reverse,
"This is the file 'gamma'." NL
"some more bytes to 'gamma'",
pool));
reverse = !reverse;
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
unsigned int flags)
{
BIO *cont;
int r;
if (OBJ_obj2nid(CMS_get0_type(cms)) != NID_pkcs7_digest) {
CMSerr(CMS_F_CMS_DIGEST_VERIFY, CMS_R_TYPE_NOT_DIGESTED_DATA);
return 0;
}
if (!dcont && !check_content(cms))
return 0;
cont = CMS_dataInit(cms, dcont);
if (!cont)
return 0;
r = cms_copy_content(out, cont, flags);
if (r)
r = cms_DigestedData_do_final(cms, cont, 1);
do_free_upto(cont, dcont);
return r;
}
END_TEST
START_TEST(test_bld_env_variables_realloc_block)
{
struct var_table vtable;
char *envp, *block;
int rc;
setup_vtable(&vtable, 120, 1024);
envp = (char *)vtable.v_envp;
block = (char *)vtable.v_block_start;
rc = add_env_variables(&vtable, 10, 2048);
fail_unless(rc == PBSE_NONE, "something went wrong in bld_env_variables unexpectely");
fail_unless((char *)vtable.v_envp == (char *)envp, "bld_env_variables should not have reallocated env pointers");
fail_unless(vtable.v_block_start != block, "bld_env_variables should have been reallocated the block of memory");
rc = 1024 + EXTRA_VARIABLE_SPACE;
fail_unless(vtable.v_ensize == 120, "size of env pointers were readjusted incorrectly: expected 120, actual %d", vtable.v_ensize);
fail_unless(vtable.v_used == 10, "env used were not correctly updated; expected 10, actual %d", vtable.v_used);
rc = check_content(&vtable);
fail_unless(rc == PBSE_NONE, "env variables were not written as expected");
free_used_mem(&vtable);
}
static svn_error_t *
test_parse_diff_symbols_in_prop_unidiff(apr_pool_t *pool)
{
svn_patch_t *patch;
svn_patch_file_t *patch_file;
svn_prop_patch_t *prop_patch;
svn_diff_hunk_t *hunk;
apr_array_header_t *hunks;
SVN_ERR(create_patch_file(&patch_file, diff_symbols_in_prop_unidiff, pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "iota");
SVN_TEST_STRING_ASSERT(patch->new_filename, "iota");
SVN_TEST_ASSERT(patch->hunks->nelts == 0);
SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 3);
/* Check the added property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_add",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 1);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"",
pool));
SVN_ERR(check_content(hunk, FALSE,
"Added: bogus_prop" NL
"## -0,0 +20 ##" NL
"@@ -1,2 +0,0 @@" NL,
pool));
/* Check the deleted property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_del",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_deleted);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 1);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"--- iota" NL
"+++ iota" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"",
pool));
/* Check the modified property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_mod",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_modified);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 2);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"## -1,2 +1,2 ##" NL
"## -1,5 -0,0 ##" NL
"@@ -1,5 -0,0 @@" NL
"Modified: prop_mod" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"## -1,3 +1,3 ##" NL
"## -1,5 -0,0 ##" NL
"@@ -1,5 -0,0 @@" NL
"Modified: prop_mod" NL,
pool));
hunk = APR_ARRAY_IDX(hunks, 1 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"context" NL
"context" NL
"context" NL
"## -0,0 +1 ##" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"context" NL
"context" NL
"context" NL
"## -1,2 +1,4 ##" NL,
pool));
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
return SVN_NO_ERROR;
}
/* Tests to parse a diff with three property changes, one is added, one is
* modified and one is deleted. */
static svn_error_t *
test_parse_property_diff(apr_pool_t *pool)
{
svn_patch_file_t *patch_file;
svn_patch_t *patch;
svn_prop_patch_t *prop_patch;
svn_diff_hunk_t *hunk;
apr_array_header_t *hunks;
SVN_ERR(create_patch_file(&patch_file, property_unidiff, pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "iota");
SVN_TEST_STRING_ASSERT(patch->new_filename, "iota");
SVN_TEST_ASSERT(patch->hunks->nelts == 0);
SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 3);
/* Check the deleted property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_del",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_deleted);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 1);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"value" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"",
pool));
/* Check the added property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_add",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(!strcmp("prop_add", prop_patch->name));
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 1);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"",
pool));
SVN_ERR(check_content(hunk, FALSE,
"value" NL,
pool));
/* Check the modified property */
prop_patch = apr_hash_get(patch->prop_patches, "prop_mod",
APR_HASH_KEY_STRING);
SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_modified);
hunks = prop_patch->hunks;
SVN_TEST_ASSERT(hunks->nelts == 2);
hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"value" NL
"context" NL
"context" NL
"context" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"new value" NL
"context" NL
"context" NL
"context" NL,
pool));
hunk = APR_ARRAY_IDX(hunks, 1 , svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"context" NL
"context" NL
"context" NL
"value" NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"context" NL
"context" NL
"context" NL
"new value" NL,
pool));
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
return SVN_NO_ERROR;
}
static svn_error_t *
test_parse_git_tree_and_text_diff(apr_pool_t *pool)
{
/* ### Should we check for reversed diffs? */
svn_patch_file_t *patch_file;
svn_patch_t *patch;
svn_diff_hunk_t *hunk;
SVN_ERR(create_patch_file(&patch_file, git_tree_and_text_unidiff, pool));
/* Parse a copied file with text modifications. */
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "iota");
SVN_TEST_STRING_ASSERT(patch->new_filename, "iota.copied");
SVN_TEST_ASSERT(patch->operation == svn_diff_op_copied);
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"This is the file 'iota'." NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"This is the file 'iota'." NL
"some more bytes to 'iota'" NL,
pool));
/* Parse a moved file with text modifications. */
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/mu");
SVN_TEST_STRING_ASSERT(patch->new_filename, "A/mu.moved");
SVN_TEST_ASSERT(patch->operation == svn_diff_op_moved);
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"This is the file 'mu'." NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"This is the file 'mu'." NL
"some more bytes to 'mu'" NL,
pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "/dev/null");
SVN_TEST_STRING_ASSERT(patch->new_filename, "new");
SVN_TEST_ASSERT(patch->operation == svn_diff_op_added);
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"",
pool));
SVN_ERR(check_content(hunk, FALSE,
"This is the file 'new'." NL,
pool));
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file,
FALSE, /* reverse */
FALSE, /* ignore_whitespace */
pool, pool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/B/lambda");
SVN_TEST_STRING_ASSERT(patch->new_filename, "/dev/null");
SVN_TEST_ASSERT(patch->operation == svn_diff_op_deleted);
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, TRUE,
"This is the file 'lambda'." NL,
pool));
SVN_ERR(check_content(hunk, FALSE,
"",
pool));
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
return SVN_NO_ERROR;
}
int main(int argc, char *argv[])
{
char *owner, *user, *instance;
char filename[400];
struct DataBlock *data, *encrypted, *hk;
#ifndef WINDOWS
struct passwd *userpw;
#endif
int curlen = 0;
char buf[MAX_DATA_LEN] = "";
char passwd[MAX_DATA_LEN] = "";
int i;
umask(077);
if (argc != 4) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, "\t%s <owner> <user> <instance>\n", argv[0]);
fprintf(stderr, "\t<owner> is the owner userid of this userid/password\n");
#ifdef WINDOWS
fprintf(stderr, "\t<owner> is ignored on windows builds\n");
#endif
fprintf(stderr, "\t<user> is the userid for this password\n");
fprintf(stderr, "\t<instance> is the particular instance\n");
fprintf(stderr, "\t<password> is passed via stdin\n");
exit(1);
}
owner = argv[1];
user = argv[2];
instance = argv[3];
/* Check if valid */
if (!owner || !user || !instance) {
Log("error-parameters", owner, user, instance);
OUTPUT_ERROR("Invalid parameters.\n");
exit(1);
}
if (check_element(owner)) {
Log("error-owner", owner, user, instance);
OUTPUT_ERROR("error on owner: %s\n", check_element(owner));
exit(1);
}
if (check_element(user)) {
Log("error-user", owner, user, instance);
OUTPUT_ERROR("error on user: %s\n", check_element(user));
exit(1);
}
if (check_element(instance)) {
Log("error-instance", owner, user, instance);
OUTPUT_ERROR("error on instance: %s\n", check_element(instance));
exit(1);
}
#ifndef WINDOWS
if (!(userpw = getpwuid(getuid()))) {
Log("error-username", owner, user, instance);
OUTPUT_ERROR("couldn't get real username\n");
exit(1);
}
if (getuid() != 0 && strcmp(owner, userpw->pw_name)) {
Log("error-mismatch", owner, user, instance);
OUTPUT_ERROR("owner does not match and you are not root\n");
exit(1);
}
#else
/* No security on windows! Force owner to 'common' */
owner = strdup("common");
#endif
buf[0] = 0;
curlen = 0;
passwd[0] = 0;
while (curlen < (MAX_DATA_LEN - 1000)) {
i = read(fileno(stdin), buf, 1000);
if (i > 0) {
memcpy(passwd + curlen, buf, i);
curlen += i;
} else {
break;
}
}
if (curlen == 0) {
Log("error-pwlen", owner, user, instance);
OUTPUT_ERROR("error on password: must be specified\n");
exit(1);
}
if (check_content(passwd)) {
Log("error-pw", owner, user, instance);
OUTPUT_ERROR("error on password: %s\n", check_content(passwd));
exit(1);
}
data = AllocDataBlock();
data->data = (unsigned char *)passwd;
data->length = strlen(passwd) + 1;
#ifndef WINDOWS
#define MKDIR(x,y) mkdir(x,y)
#else
#define MKDIR(x,y) mkdir(x)
#endif
/* Make each directory and build the file name */
sprintf(filename, DATADIR DIRSEP "keys" DIRSEP "%s", owner);
if (MKDIR(filename, 0755) == -1 && errno != EEXIST) {
Log("error-mkdir1", owner, user, instance);
OUTPUT_ERROR("couldn't create dir (%s)\n", filename);
exit(1);
}
sprintf(filename, DATADIR DIRSEP "keys" DIRSEP "%s" DIRSEP "%s", owner, user);
if (MKDIR(filename, 0755) == -1 && errno != EEXIST) {
Log("error-mkdir2", owner, user, instance);
OUTPUT_ERROR("couldn't create dir (%s)\n", filename);
exit(1);
}
sprintf(filename, DATADIR DIRSEP "keys" DIRSEP "%s" DIRSEP "%s" DIRSEP "%s", owner, user, instance);
Log("encrypt", owner, user, instance);
hk = FetchHostKey();
encrypted = wrap_blowfish(hk, data, BF_ENCRYPT);
FreeDataBlock(hk);
DataBlockToFile(filename, encrypted);
FreeDataBlock(encrypted);
data->data = 0;
FreeDataBlock(data);
exit(0);
}