void NamedLogWriter::append(const boost::filesystem::path &path)
{
try {
open_(path, true);
} catch (std::exception &) {
BOOST_THROW_EXCEPTION(NamedLogWriterAppendError() <<
enable_nested_current());
}
}
void use_device(struct reader *reader, struct writer *writer, struct device *d)
/*@
requires
reader(reader) &*& writer(writer) &*& lockset(currentThread, nil) &*&
[?f1]d->ops |-> ?ops &*& [f1]file_ops(ops, ?device, ?file_) &*&
[?f2]device();
@*/
/*@
ensures
reader(reader) &*& writer(writer) &*& lockset(currentThread, nil) &*&
[f1]d->ops |-> ops &*& [f1]file_ops(ops, device, file_) &*&
[f2]device();
@*/
{
//@ open file_ops(ops, _, _);
device_open *open_ = d->ops->open_;
device_close *close_ = d->ops->close_;
void *file = open_();
bool exitMenu = false;
while (!exitMenu)
/*@
invariant
reader(reader) &*& writer(writer) &*& file_(f2, file) &*& lockset(currentThread, nil) &*&
[f1]d->ops |-> ops &*&
[f1]ops->read |-> ?read &*& [f1]ops->write |-> ?write &*&
[_]is_device_read(read, file_) &*&
[_]is_device_write(write, file_);
@*/
{
int choice = 0;
writer_write_string(writer,
"Device Menu:\r\n"
"1. Read Value\r\n"
"2. Write Value\r\n"
"0. Exit\r\n");
choice = reader_read_nonnegative_integer(reader);
if (choice == 1) {
device_read *read_ = d->ops->read;
int value = read_(file);
writer_write_string(writer, "Value read: ");
writer_write_integer_as_decimal(writer, value);
writer_write_string(writer, "\r\n");
} else if (choice == 2) {
int value = 0;
device_write *write_ = d->ops->write;
writer_write_string(writer, "Enter value:\r\n");
value = reader_read_nonnegative_integer(reader);
write_(file, value);
writer_write_string(writer, "The value has been written\r\n");
} else {
exitMenu = true;
}
}
close_(file);
//@ close [f1]file_ops(ops, device, file_);
}
static unrar_err_t reopen( unrar_t* p )
{
// Save and restore archive reader
unrar_read_func read = p->Arc.user_read;
void* user_data = p->Arc.user_read_data;
void (*close_file)( void* ) = p->close_file;
p->close_file = NULL;
p->~unrar_t();
new (p) unrar_t;
p->close_file = close_file;
return open_( p, read, user_data );
}
/**
* qdb->ping(): Checks whether the connection to the server is working.
*
* @param db a pointer of qdb_t object
*
* @return true if connection is alive, false if connection is not available
* and failed to reconnect
*
* @note
* If the connection has gone down, an attempt to reconnect.
*/
static bool ping(qdb_t *db)
{
if (db == NULL) return false;
#ifdef _Q_ENABLE_MYSQL
if (db->connected == true && mysql_ping(db->mysql) == 0) {
return true;
} else { // ping test failed
if (open_(db) == true) { // try re-connect
DEBUG("Connection recovered.");
return true;
}
}
return false;
#else
return false;
#endif
}
unrar_err_t unrar_open_custom( unrar_t** impl_out, unrar_read_func read, void* user_data )
{
*impl_out = NULL;
unrar_ptr ptr;
ptr.p = new unrar_t;
if ( !ptr.p )
return unrar_err_memory;
RETURN_ERR( NONLOCAL_ERROR( ptr.p ) );
RETURN_ERR( open_( ptr.p, read, user_data ) );
RETURN_ERR( next_( ptr.p, false ) );
*impl_out = ptr.p;
ptr.p = NULL;
//delete ptr.p; // done automatically at end of function
return unrar_ok;
}
/// Write a ldf data buffer to disk.
bool DATA_buffer::Write(std::ofstream *file_, char *data_, int nWords_, int &buffs_written){
if(!file_ || !file_->is_open() || !file_->good() || !data_ || nWords_ == 0){
if(debug_mode){ std::cout << "debug: !file_ || !file_->is_open() || !data_ || nWords_ == 0\n"; }
return false;
}
// Write a DATA header if needed
buffs_written = 0;
if(current_buff_pos < 2){ open_(file_); }
else if(current_buff_pos > ACTUAL_BUFF_SIZE){
if(debug_mode){ std::cout << "debug: previous buffer overfilled by " << current_buff_pos - ACTUAL_BUFF_SIZE << " words!!!\n"; }
Close(file_);
open_(file_);
buffs_written++;
}
else if(buff_words_remaining < SMALLEST_CHUNK_SIZE){ // Can't fit enough words in this buffer. Start a fresh one
Close(file_);
open_(file_);
buffs_written++;
}
// The entire spill needs to be chopped up to fit into buffers
// Calculate the number of data chunks we will need
int words_written = 0;
int this_chunk_sizeW, this_chunk_sizeB;
int total_num_chunks, current_chunk_num;
if((nWords_ + 10) >= good_words_remaining){ // Spill needs at least one more buffer
total_num_chunks = 2 + (nWords_ - good_words_remaining + 3) / OPTIMAL_CHUNK_SIZE;
if((nWords_ - good_words_remaining + 3) % OPTIMAL_CHUNK_SIZE != 0){
total_num_chunks++; // Account for the buffer fragment
}
}
else{ // Entire spill (plus footer) will fit in the current buffer
if(debug_mode){ std::cout << "debug: writing spill of nWords_=" << nWords_ << " + 10 words\n"; }
// Write the spill chunk header
this_chunk_sizeW = nWords_ + 3;
this_chunk_sizeB = 4 * this_chunk_sizeW;
total_num_chunks = 2;
current_chunk_num = 0;
file_->write((char*)&this_chunk_sizeB, 4);
file_->write((char*)&total_num_chunks, 4);
file_->write((char*)¤t_chunk_num, 4);
// Write the spill
file_->write((char*)data_, (this_chunk_sizeB - 12));
// Write the end of spill buffer (5 words + 2 end of buffer words)
current_chunk_num = 1;
file_->write((char*)&buffend, 4);
file_->write((char*)&end_spill_size, 4);
file_->write((char*)&total_num_chunks, 4);
file_->write((char*)¤t_chunk_num, 4);
file_->write((char*)&pacman_word1, 4);
file_->write((char*)&pacman_word2, 4);
file_->write((char*)&buffend, 4); // write 0xFFFFFFFF (signal end of spill footer)
current_buff_pos += this_chunk_sizeW + 7;
buff_words_remaining = ACTUAL_BUFF_SIZE - current_buff_pos;
return true;
}
if(debug_mode){
std::cout << "debug: nWords_=" << nWords_ << ", total_num_chunks=" << total_num_chunks << ", current_buff_pos=" << current_buff_pos << std::endl;
std::cout << "debug: buff_words_remaining=" << buff_words_remaining << ", good_words_remaining=" << good_words_remaining << std::endl;
}
current_chunk_num = 0;
while(words_written < nWords_){
// Calculate the size of this chunk
if((nWords_ - words_written + 10) >= good_words_remaining){ // Spill chunk will require more than this buffer
this_chunk_sizeW = good_words_remaining;
// Write the chunk header
this_chunk_sizeB = 4 * this_chunk_sizeW;
file_->write((char*)&this_chunk_sizeB, 4);
file_->write((char*)&total_num_chunks, 4);
file_->write((char*)¤t_chunk_num, 4);
// Actually write the data
if(debug_mode){ std::cout << "debug: writing spill chunk " << current_chunk_num << " of " << total_num_chunks << " with " << this_chunk_sizeW << " words\n"; }
file_->write((char*)&data_[4*words_written], (this_chunk_sizeB - 12));
file_->write((char*)&buffend, 4); // Mark the end of this chunk
current_chunk_num++;
current_buff_pos += this_chunk_sizeW + 1;
buff_words_remaining = ACTUAL_BUFF_SIZE - current_buff_pos;
good_words_remaining = 0;
words_written += this_chunk_sizeW - 3;
Close(file_);
open_(file_);
buffs_written++;
}
else{ // Spill chunk (plus spill footer) will fit in this buffer. This is the final chunk
this_chunk_sizeW = (nWords_ - words_written + 3);
// Write the chunk header
this_chunk_sizeB = 4 * this_chunk_sizeW;
file_->write((char*)&this_chunk_sizeB, 4);
file_->write((char*)&total_num_chunks, 4);
file_->write((char*)¤t_chunk_num, 4);
// Actually write the data
if(debug_mode){ std::cout << "debug: writing final spill chunk " << current_chunk_num << " with " << this_chunk_sizeW << " words\n"; }
file_->write((char*)&data_[4*words_written], (this_chunk_sizeB - 12));
file_->write((char*)&buffend, 4); // Mark the end of this chunk
current_chunk_num++;
current_buff_pos += this_chunk_sizeW + 1;
buff_words_remaining = ACTUAL_BUFF_SIZE - current_buff_pos;
good_words_remaining = good_words_remaining - this_chunk_sizeW;
words_written += this_chunk_sizeW - 3;
}
}
// Can't fit spill footer. Fill with 0xFFFFFFFF and start new buffer instead
if(good_words_remaining < 7){
Close(file_);
open_(file_);
buffs_written++;
}
if(debug_mode){ std::cout << "debug: writing 24 bytes (6 words) for spill footer (chunk " << current_chunk_num << ")\n"; }
// Write the end of spill buffer (5 words + 1 end of buffer words)
file_->write((char*)&end_spill_size, 4);
file_->write((char*)&total_num_chunks, 4);
file_->write((char*)¤t_chunk_num, 4);
file_->write((char*)&pacman_word1, 4);
file_->write((char*)&pacman_word2, 4);
file_->write((char*)&buffend, 4); // write 0xFFFFFFFF (signal end of spill footer)
current_buff_pos += 6;
buff_words_remaining = ACTUAL_BUFF_SIZE - current_buff_pos;
good_words_remaining = good_words_remaining - 6;
if(debug_mode){
std::cout << "debug: finished writing spill into " << buffs_written << " new buffers\n";
if(total_num_chunks != current_chunk_num + 1){
std::cout << "debug: total number of chunks does not equal number of chunks written (" << total_num_chunks << " != " << current_chunk_num+1 << ")!!!\n";
}
std::cout << std::endl;
}
return true;
}
/*
* Execute command f, arg list t.
* Record error message if not found.
* Also do shell scripts here.
*/
void
texec(struct command *cmd, tchar *f, tchar **t)
{
int pfstatus = 0;
struct varent *v;
tchar **vp;
tchar *lastsh[2];
#ifdef TRACE
tprintf("TRACE- texec()\n");
#endif
/* convert cfname and cargs from tchar to char */
tconvert(cmd, f, t);
if (pfcshflag == 1) {
pfstatus = secpolicy_pfexec((const char *)(cmd->cfname),
cmd->cargs, (const char **)NULL);
if (pfstatus != NOATTRS) {
errno = pfstatus;
}
}
if ((pfcshflag == 0) || (pfstatus == NOATTRS)) {
execv(cmd->cfname, cmd->cargs);
}
/*
* exec returned, free up allocations from above
* tconvert(), zero cfname and cargs to prevent
* duplicate free() in freesyn()
*/
xfree(cmd->cfname);
chr_blkfree(cmd->cargs);
cmd->cfname = (char *)0;
cmd->cargs = (char **)0;
switch (errno) {
case ENOEXEC:
/* check that this is not a binary file */
{
int ff = open_(f, 0);
tchar ch[MB_LEN_MAX];
if (ff != -1 && read_(ff, ch, 1) == 1 &&
!isprint(ch[0]) && !isspace(ch[0])) {
printf("Cannot execute binary file.\n");
Perror(f);
(void) close(ff);
unsetfd(ff);
return;
}
(void) close(ff);
unsetfd(ff);
}
/*
* If there is an alias for shell, then
* put the words of the alias in front of the
* argument list replacing the command name.
* Note no interpretation of the words at this point.
*/
v = adrof1(S_shell /* "shell" */, &aliases);
if (v == 0) {
#ifdef OTHERSH
int ff = open_(f, 0);
tchar ch[MB_LEN_MAX];
#endif
vp = lastsh;
vp[0] = adrof(S_shell /* "shell" */) ? value(S_shell /* "shell" */) : S_SHELLPATH /* SHELLPATH */;
vp[1] = (tchar *) NULL;
#ifdef OTHERSH
if (ff != -1 && read_(ff, ch, 1) == 1 && ch[0] != '#')
vp[0] = S_OTHERSH /* OTHERSH */;
(void) close(ff);
unsetfd(ff);
#endif
} else
vp = v->vec;
t[0] = f;
t = blkspl(vp, t); /* Splice up the new arglst */
f = *t;
tconvert(cmd, f, t); /* convert tchar to char */
/*
* now done with tchar arg list t,
* free the space calloc'd by above blkspl()
*/
xfree((char *)t);
execv(cmd->cfname, cmd->cargs); /* exec the command */
/* exec returned, same free'ing as above */
xfree(cmd->cfname);
chr_blkfree(cmd->cargs);
cmd->cfname = (char *)0;
cmd->cargs = (char **)0;
/* The sky is falling, the sky is falling! */
case ENOMEM:
Perror(f);
case ENOENT:
break;
default:
if (exerr == 0) {
exerr = strerror(errno);
setname(f);
}
}
}
