void
I18nModeInit()
{
char *i18nuser = value_of(VarUser);
FILE *i18nspool;
if (i18n_initialize() != 0)
return;
if (!i18nuser)
i18nuser = zmMainName();
real_spoolfile =
ftrack_CreateStat(spoolfile, NULL, i18n_mirror_spool, NULL);
if (!real_spoolfile)
error(SysErrFatal,
catgets( catalog, CAT_SHELL, 819, "Cannot create monitor for mailbox." ));
i18nspool = open_tempfile(i18nuser, &spoolfile);
if (!i18nspool)
error(SysErrFatal,
catgets( catalog, CAT_SHELL, 820, "Cannot create copy of spoolfile for translation." ));
else
(void) fclose(i18nspool);
fake_spoolfile = ftrack_Create(spoolfile, NULL, NULL);
if (!fake_spoolfile) {
error(SysErrFatal,
catgets( catalog, CAT_SHELL, 821, "Cannot create monitor for mailbox update." ));
}
ftrack_Init(fake_spoolfile, NULL, i18n_update_spool,
vaptr((char *) fake_spoolfile, (char *) real_spoolfile, NULL));
ftrack_Add(global_ftlist, real_spoolfile);
}
/** set the filename and see if we need to do the plugin
*/
void content::set_filename(const string &filename)
{
this->evidence_filename = filename;
this->do_plugin = plugin_match(this->evidence_filename);
if(do_plugin || opt_magic) open_tempfile();
if(opt_save) open_savefile();
}
/* In the pinfo->file list, we replace all the instances of the target
* file (except the first) with a temporary file that we can read and
* write at will. If some replacements were performed, then tempfile is
* not null.
* The tempfile is opened exclusively, and should be kept open throughout
* the lifetime of xml-mv as a way of guaranteeing privacy.
*/
bool_t substitute_target(parserinfo_mv_t *pinfo) {
bool_t first = TRUE;
int i;
if( pinfo ) {
for(i = 0; i < pinfo->n; i++) {
if( strcmp(pinfo->files[i],pinfo->target) == 0 ) {
if( !first ) {
if( !pinfo->tempfile ) {
pinfo->tempfile = make_template_tempfile(progname);
pinfo->tempfd = open_tempfile(pinfo->tempfile);
if( pinfo->tempfd == -1 ) {
errormsg(E_FATAL,
"could not create temporary file %s, aborting.\n",
pinfo->tempfile);
}
}
pinfo->files[i] = pinfo->tempfile;
} else {
first = FALSE;
}
}
}
return (pinfo->tempfile != NULL);
}
return FALSE;
}
/* Generate a temporary file containing sort-of random data. Diffs
between files of random data tend to be pretty boring, so we try to
make sure there are a bunch of common substrings between two runs
of this function with the same seedbase. */
static apr_file_t *
generate_random_file(apr_uint32_t maxlen,
apr_uint32_t subseed_base,
apr_uint32_t *seed,
const char *random_bytes,
apr_size_t bytes_range,
int dump_files,
apr_pool_t *pool)
{
static char file_buffer[10240];
char *buf = file_buffer;
char *const end = buf + sizeof file_buffer;
apr_uint32_t len, seqlen;
apr_file_t *fp;
unsigned long r;
fp = open_tempfile("random_XXXXXX", pool);
len = svn_test_rand(seed) % maxlen; /* We might go over this by a bit. */
while (len > 0)
{
/* Generate a pseudo-random sequence of up to MAXSEQ bytes,
where the seed is in the range [seedbase..seedbase+MAXSEQ-1].
(Use our own pseudo-random number generator here to avoid
clobbering the seed of the libc random number generator.) */
seqlen = svn_test_rand(seed) % MAXSEQ;
if (seqlen > len) seqlen = len;
len -= seqlen;
r = subseed_base + svn_test_rand(seed) % SEEDS;
while (seqlen-- > 0)
{
const int ch = (random_bytes
? (unsigned)random_bytes[r % bytes_range]
: (int)(r % bytes_range));
if (buf == end)
{
apr_size_t ignore_length;
apr_file_write_full(fp, file_buffer, sizeof file_buffer,
&ignore_length);
buf = file_buffer;
}
*buf++ = (char)ch;
r = r * 1103515245 + 12345;
}
}
if (buf > file_buffer)
{
apr_size_t ignore_length;
apr_file_write_full(fp, file_buffer, buf - file_buffer, &ignore_length);
}
rewind_file(fp);
if (dump_files)
dump_file_contents(fp);
return fp;
}
int main ( int argc, char *argv[] ) {
Param params;
FlowCom *comPtr = NULL;
char line [ LINE_LEN ];
while ( argc > 1 ) {
if ( !strcmp( argv[1], "-D" ) ) {
setDebugFlag();
} else if ( !strcmp( argv[1], "-V" ) ) {
printf ( "%s\n", VERSION );
exit ( 0 );
} else {
break;
}
argv++;
argc--;
}
open_tempfile();
open_infile ( ( argc > 1 ) ? argv[ 1 ] : NULL );
tprintf ( "%% picture environment flowchart generated by flow " );
tprintf ( "%s\n", VERSION );
while ( readline_infile ( line, LINE_LEN ) != NULL ) {
if ( ( comPtr = getCommand ( line, params ) ) != NULL ) {
switch ( comPtr -> command ) {
case MACRO:
if ( doMacro ( params ) ) {
errout ( E_NO_END_MACRO );
}
break;
case EXPAND:
doExpand ( params );
break;
default:
if ( !doCommand ( comPtr, params ) ) {
return 10;
}
}
} else {
break;
}
}
close_infile();
close_tempfile();
apply_tempfile ( getPic(), ( argc > 2 ) ? argv[ 2 ] : NULL );
remove_tempfile();
// dumpFigure();
return 0; /* just to suppress the warning */
}
static apr_file_t *
copy_tempfile(apr_file_t *fp, apr_pool_t *pool)
{
static char file_buffer[10240];
apr_file_t *newfp;
apr_size_t length1, length2;
newfp = open_tempfile("copy_XXXXXX", pool);
rewind_file(fp);
do
{
apr_file_read_full(fp, file_buffer, sizeof file_buffer, &length1);
apr_file_write_full(newfp, file_buffer, length1, &length2);
assert(length1 == length2);
}
while (length1 == sizeof file_buffer);
rewind_file(fp);
rewind_file(newfp);
return newfp;
}
// Encrypt contents of stdin and write to stdout
void clean (const char* keyfile)
{
keys_t keys;
load_keys(keyfile, &keys);
// Read the entire file
hmac_sha1_state hmac(keys.hmac, HMAC_KEY_LEN); // Calculate the file's SHA1 HMAC as we go
uint64_t file_size = 0; // Keep track of the length, make sure it doesn't get too big
std::string file_contents; // First 8MB or so of the file go here
std::fstream temp_file; // The rest of the file spills into a temporary file on disk
temp_file.exceptions(std::fstream::badbit);
char buffer[1024];
while (std::cin && file_size < MAX_CRYPT_BYTES) {
std::cin.read(buffer, sizeof(buffer));
size_t bytes_read = std::cin.gcount();
hmac.add(reinterpret_cast<unsigned char*>(buffer), bytes_read);
file_size += bytes_read;
if (file_size <= 8388608) {
file_contents.append(buffer, bytes_read);
} else {
if (!temp_file.is_open()) {
open_tempfile(temp_file, std::fstream::in | std::fstream::out | std::fstream::binary | std::fstream::app);
}
temp_file.write(buffer, bytes_read);
}
}
// Make sure the file isn't so large we'll overflow the counter value (which would doom security)
if (file_size >= MAX_CRYPT_BYTES) {
std::clog << "File too long to encrypt securely\n";
std::exit(1);
}
// We use an HMAC of the file as the encryption nonce (IV) for CTR mode.
// By using a hash of the file we ensure that the encryption is
// deterministic so git doesn't think the file has changed when it really
// hasn't. CTR mode with a synthetic IV is provably semantically secure
// under deterministic CPA as long as the synthetic IV is derived from a
// secure PRF applied to the message. Since HMAC-SHA1 is a secure PRF, this
// encryption scheme is semantically secure under deterministic CPA.
//
// Informally, consider that if a file changes just a tiny bit, the IV will
// be completely different, resulting in a completely different ciphertext
// that leaks no information about the similarities of the plaintexts. Also,
// since we're using the output from a secure hash function plus a counter
// as the input to our block cipher, we should never have a situation where
// two different plaintext blocks get encrypted with the same CTR value. A
// nonce will be reused only if the entire file is the same, which leaks no
// information except that the files are the same.
//
// To prevent an attacker from building a dictionary of hash values and then
// looking up the nonce (which must be stored in the clear to allow for
// decryption), we use an HMAC as opposed to a straight hash.
uint8_t digest[SHA1_LEN];
hmac.get(digest);
// Write a header that...
std::cout.write("\0GITCRYPT\0", 10); // ...identifies this as an encrypted file
std::cout.write(reinterpret_cast<char*>(digest), NONCE_LEN); // ...includes the nonce
// Now encrypt the file and write to stdout
aes_ctr_state state(digest, NONCE_LEN);
// First read from the in-memory copy
const uint8_t* file_data = reinterpret_cast<const uint8_t*>(file_contents.data());
size_t file_data_len = file_contents.size();
for (size_t i = 0; i < file_data_len; i += sizeof(buffer)) {
size_t buffer_len = std::min(sizeof(buffer), file_data_len - i);
state.process(&keys.enc, file_data + i, reinterpret_cast<uint8_t*>(buffer), buffer_len);
std::cout.write(buffer, buffer_len);
}
// Then read from the temporary file if applicable
if (temp_file.is_open()) {
temp_file.seekg(0);
while (temp_file) {
temp_file.read(buffer, sizeof(buffer));
size_t buffer_len = temp_file.gcount();
state.process(&keys.enc, reinterpret_cast<uint8_t*>(buffer), reinterpret_cast<uint8_t*>(buffer), buffer_len);
std::cout.write(buffer, buffer_len);
}
}
}
/* (Note: *LAST_SEED is an output parameter.) */
static svn_error_t *
do_random_combine_test(const char **msg,
svn_boolean_t msg_only,
apr_pool_t *pool,
apr_uint32_t *last_seed)
{
static char msg_buff[256];
apr_uint32_t seed, bytes_range, maxlen;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
sprintf(msg_buff,
"random combine delta test, seed = %lu", (unsigned long) seed);
*msg = msg_buff;
if (msg_only)
return SVN_NO_ERROR;
else
printf("SEED: %s\n", msg_buff);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand((*last_seed = seed, &seed));
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *middle = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *middle_copy = copy_tempfile(middle, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream_A;
svn_txdelta_stream_t *txdelta_stream_B;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create two deltas, combine them
and convert the result to svndiff format, parse that back
into delta format, and apply it to a copy of the source file
to see if we get the same target back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format. */
svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1,
delta_pool);
/* Make stage 1: create the text deltas. */
svn_txdelta(&txdelta_stream_A,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(middle, delta_pool),
delta_pool);
svn_txdelta(&txdelta_stream_B,
svn_stream_from_aprfile(middle_copy, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
delta_pool);
{
svn_txdelta_window_t *window_A;
svn_txdelta_window_t *window_B;
svn_txdelta_window_t *composite;
apr_pool_t *wpool = svn_pool_create(delta_pool);
do
{
SVN_ERR(svn_txdelta_next_window(&window_A, txdelta_stream_A,
wpool));
if (print_windows)
delta_window_print(window_A, "A ", stdout);
SVN_ERR(svn_txdelta_next_window(&window_B, txdelta_stream_B,
wpool));
if (print_windows)
delta_window_print(window_B, "B ", stdout);
if (!window_B)
break;
assert(window_A != NULL || window_B->src_ops == 0);
if (window_B->src_ops == 0)
{
composite = window_B;
composite->sview_len = 0;
}
else
composite = svn_txdelta_compose_windows(window_A, window_B,
wpool);
if (print_windows)
delta_window_print(composite, "AB", stdout);
/* The source view length should not be 0 if there are
source copy ops in the window. */
if (composite
&& composite->sview_len == 0 && composite->src_ops > 0)
return svn_error_create
(SVN_ERR_FS_GENERAL, NULL,
"combined delta window is inconsistent");
SVN_ERR(handler(composite, handler_baton));
svn_pool_clear(wpool);
}
while (composite != NULL);
svn_pool_destroy(wpool);
}
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(middle);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(middle_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
/* Implements svn_test_driver_t. */
static svn_error_t *
random_test(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
static char msg_buff[256];
apr_uint32_t seed, bytes_range, maxlen;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
sprintf(msg_buff, "random delta test, seed = %lu", (unsigned long) seed);
*msg = msg_buff;
if (msg_only)
return SVN_NO_ERROR;
else
printf("SEED: %s\n", msg_buff);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand(&seed);
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create a delta, convert it to
svndiff format, parse it back into delta format, and apply it
to a copy of the source file to see if we get the same target
back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format. */
svn_txdelta_to_svndiff2(&handler, &handler_baton, stream, 1,
delta_pool);
/* Make stage 1: create the text delta. */
svn_txdelta(&txdelta_stream,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
delta_pool);
SVN_ERR(svn_txdelta_send_txstream(txdelta_stream,
handler,
handler_baton,
delta_pool));
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
/* Implements svn_test_driver_t. */
static svn_error_t *
random_test(apr_pool_t *pool)
{
apr_uint32_t seed, maxlen;
apr_size_t bytes_range;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand(&seed);
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create a delta, convert it to
svndiff format, parse it back into delta format, and apply it
to a copy of the source file to see if we get the same target
back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format using
varying compression levels. */
svn_txdelta_to_svndiff3(&handler, &handler_baton, stream, 1, i % 10,
delta_pool);
/* Make stage 1: create the text delta. */
svn_txdelta2(&txdelta_stream,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
FALSE,
delta_pool);
SVN_ERR(svn_txdelta_send_txstream(txdelta_stream,
handler,
handler_baton,
delta_pool));
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
