int
Nestea_i::load_data (void)
{
ACE_FILE_IO file;
ACE_FILE_Connector connector;
if (connector.connect (file,
ACE_FILE_Addr (this->data_filename_),
0,
ACE_Addr::sap_any) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n to %s",
"connect",
this->data_filename_),
-1);
char str[MAX_UINT32_STR_LEN];
int len = file.recv (str, MAX_UINT32_STR_LEN);
str[len] = 0;
if (len > 0)
this->cans_ = ACE_OS::atoi (str);
else
this->cans_ = 0;
return 0;
}
// Listing 04 code/ch18
int TextListener::play_message (ACE_FILE_Addr &addr)
{
MessageType *type = Util::identify_message (addr);
if (type->is_text ())
{
Command *c = new Command ();
c->command_ = Command::CMD_PLAY_MESSAGE;
c->extra_data_ = &addr;
c = this->command_stream_->execute (c);
return c->numeric_result_;
}
ACE_FILE_Addr temp (ACE_TEXT ("/tmp/outgoing_message.text"));
ACE_FILE_IO *file;
if (type->is_audio ())
file = Util::audio_to_text (addr, temp);
else if (type->is_video ())
file = Util::video_to_text (addr, temp);
else
ACE_ERROR_RETURN
((LM_ERROR, ACE_TEXT ("Invalid message type %d\n"),
type->get_codec ()), -1);
int rval = this->play_message (temp);
file->remove ();
return rval;
}
int
ACE_FILE_Connector::connect (ACE_FILE_IO &new_io,
const ACE_FILE_Addr &remote_sap,
ACE_Time_Value *timeout,
const ACE_Addr &,
int,
int flags,
int perms)
{
ACE_TRACE ("ACE_FILE_Connector::connect");
ACE_ASSERT (new_io.get_handle () == ACE_INVALID_HANDLE);
ACE_HANDLE handle = ACE_INVALID_HANDLE;
// Check to see if caller has requested that we create the filename.
if(reinterpret_cast<const ACE_Addr &> (
const_cast<ACE_FILE_Addr &> (remote_sap)) == ACE_Addr::sap_any)
{
// Create a new temporary file.
// Use ACE_OS::mkstemp() if it is available since it avoids a
// race condition, and subsequently a security hole due to that
// race condition (specifically, a denial-of-service attack).
//
// However, using mkstemp() prevents us from doing a timed open
// since it opens the file for us. Better to avoid the race
// condition.
char filename[] = "ace-file-XXXXXX";
handle = ACE_OS::mkstemp (filename); // mkstemp() replaces "XXXXXX"
if(handle == ACE_INVALID_HANDLE
|| new_io.addr_.set (ACE_TEXT_CHAR_TO_TCHAR (filename)) != 0)
return -1;
new_io.set_handle (handle);
return 0;
}
else
new_io.addr_ = remote_sap; // class copy.
handle = ACE::handle_timed_open (timeout,
new_io.addr_.get_path_name (),
flags,
perms);
new_io.set_handle (handle);
return handle == ACE_INVALID_HANDLE ? -1 : 0;
}
int
Nestea_i::save_data (void)
{
ACE_FILE_IO file;
ACE_FILE_Connector connector;
if (connector.connect (file,
ACE_FILE_Addr (this->data_filename_),
0,
ACE_Addr::sap_any) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n to %s",
"connect",
this->data_filename_),
-1);
char str[MAX_UINT32_STR_LEN];
ACE_OS::sprintf (str, "%d", this->cans_);
return file.send_n (str, ACE_OS::strlen (str) + 1);
}
virtual int process (Message *message)
{
ACE_TRACE ("SaveMetaData::process()");
ACE_TString path (message->addr ().get_path_name ());
path += ACE_TEXT (".xml");
ACE_FILE_Connector connector;
ACE_FILE_IO file;
ACE_FILE_Addr addr (path.c_str ());
if (connector.connect (file, addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("create meta-data file")),
0);
file.truncate (0);
this->write (file, "<Message>\n");
// ...
this->write (file, "</Message>\n");
file.close ();
return 0;
}
//FUZZ: disable check_for_lack_ACE_OS
int write (ACE_FILE_IO &file, const char *str)
{
//FUZZ: enable check_for_lack_ACE_OS
return file.send (str, ACE_OS::strlen (str));
}
void
JAWS_Config_File_Impl::parse_file (void)
{
ACE_FILE_Connector fconnector;
ACE_FILE_IO fio;
if (fconnector.connect ( fio
, this->faddr_
, 0
, ACE_Addr::sap_any
, 0
, O_RDONLY
) == -1)
return;
ACE_Message_Block buffer (8192);
ACE_Message_Block line (4096);
ssize_t count = 0;
const ACE_TCHAR *sym_name;
const ACE_TCHAR *sym_value;
int last_line_was_read = 0;
ACE_TCHAR *end_of_current_line = 0;
ACE_TCHAR *p = 0;
while (last_line_was_read
|| (count = fio.recv (buffer.wr_ptr (), buffer.space () - 2)) >= 0)
{
end_of_current_line = 0;
// Make sure input is newline terminated if it is the last line,
// and always null terminated.
if (! last_line_was_read)
{
if (count > 0)
{
buffer.wr_ptr (count);
// Scan forward for at least one newline character
p = buffer.rd_ptr ();
while (p != buffer.wr_ptr ())
{
if (*p == '\n')
break;
p++;
}
if (p == buffer.wr_ptr ())
continue;
end_of_current_line = p;
}
else
{
if (buffer.wr_ptr ()[-1] != '\n')
{
buffer.wr_ptr ()[0] = '\n';
buffer.wr_ptr (1);
}
last_line_was_read = 1;
}
buffer.wr_ptr ()[0] = '\0';
}
if (end_of_current_line == 0)
{
end_of_current_line = buffer.rd_ptr ();
while (*end_of_current_line != '\n')
end_of_current_line++;
}
// If buffer is not pointing to a continuation line, or there is
// no more input, then can commit the scanned configuration
// line.
if (line.length () != 0
&& ((last_line_was_read && buffer.length () == 0)
|| (buffer.rd_ptr ()[0] != ' '
&& buffer.rd_ptr ()[0] != '\t')))
{
ACE_TCHAR *name = 0;
ACE_TCHAR *value = 0;
name = line.rd_ptr ();
for (p = name; *p != '\0'; p++)
{
if (*p == '=')
{
line.rd_ptr (p+1);
while (p != name && (p[-1] == ' ' || p[-1] == '\t'))
p--;
*p = '\0';
}
}
if (*name)
{
value = line.rd_ptr ();
while (*value == ' ' || *value == '\t')
value++;
p = line.wr_ptr ();
while (p != value && (p[-1] == ' ' || p[-1] == '\t'))
p--;
*p = '\0';
sym_name = this->strings_->duplicate (name);
sym_value = this->strings_->duplicate (value);
this->symbols_->rebind (sym_name, sym_value);
}
line.reset ();
}
// If we are done, we are done!
if (last_line_was_read && buffer.length () == 0)
break;
// If the buffer is pointing at a comment line, ignore it.
if (buffer.rd_ptr ()[0] == '#'
|| buffer.rd_ptr ()[0] == '\n'
|| (buffer.rd_ptr ()[0] == '\r' && buffer.rd_ptr ()[1] == '\n'))
{
buffer.rd_ptr (end_of_current_line + 1);
buffer.crunch ();
continue;
}
// Whatever is left is either the start of a name-value-pair or a
// continuation of one.
line.copy (buffer.rd_ptr (),
end_of_current_line - buffer.rd_ptr ());
p = line.wr_ptr ();
while (p != line.rd_ptr () && (p[-1] == ' ' || p[-1] == '\t'))
p--;
line.wr_ptr (p);
line.wr_ptr ()[0] = '\0';
buffer.rd_ptr (end_of_current_line + 1);
buffer.crunch ();
}
fio.close ();
}
static int
test_ostream (void)
{
// This message should show up in the log file.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("first message\n")));
ACE_LOG_MSG->clr_flags (ACE_Log_Msg::OSTREAM);
// This message should not show up anywhere.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("second message\n")));
ACE_LOG_MSG->set_flags (ACE_Log_Msg::OSTREAM);
#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
// Create a persistent store.
const ACE_TCHAR *filename = ACE_TEXT ("output");
ofstream myostream (ACE_TEXT_ALWAYS_CHAR (filename), ios::out | ios::trunc);
// Check for errors.
if (myostream.bad ())
return -1;
// Set the ostream.
ACE_LOG_MSG->msg_ostream (&myostream);
// This message should show up in the ostream.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("fourth message\n")));
// Set the ostream back to the test's log file.
ACE_LOG_MSG->msg_ostream (ace_file_stream::instance ()->output_file ());
// Now close the ostream file and check its contents.
myostream.close ();
ACE_FILE_Connector connector;
ACE_FILE_IO file;
// Open up the file.
if (connector.connect (file,
ACE_FILE_Addr (filename)) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("connect failed for %p\n"),
filename),
1);
}
// Unlink this file right away so that it is automatically removed
// when the process exits.Ignore error returns in case this operation
// is not supported.
ACE_OS::unlink(filename);
ACE_FILE_Info info;
if (file.get_info (info) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("get_info failed on %p\n"),
filename),
-1);
}
// Allocate the input buffer
char *buffer;
ACE_NEW_RETURN (buffer,
char[info.size_ + 1],
-1);
// Make sure <buffer> is released automagically.
ACE_Auto_Basic_Array_Ptr<char> b (buffer);
// Read the file into the buffer.
ssize_t size = file.recv (buffer,
info.size_);
if (size != info.size_)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Read %d bytes, rather than expected %d bytes\n"),
size,
info.size_),
-1);
}
// Make sure to NUL-terminate this turkey!
buffer[size] = '\0';
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%s"),
buffer));
#endif /* ACE_LACKS_IOSTREAM_TOTALLY */
// This message should show up in stderr and the ostream (without
// ACE_LACKS_IOSTREAM_TOTALLY).
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("fifth message\n")));
return 0;
}
int FileIOHandler::Connect()
{
int result = 0;
// create an empty temporary file for the test
if(connector_.connect(peer_,
ACE_sap_any_cast (ACE_FILE_Addr &)) != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to create file")));
result = -1;
}
// close opened file but leave it where it is
if (peer_.close () != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to close file")));
peer_.remove ();
result = -1;
}
// get file address
ACE_FILE_Addr tmp_addr;
peer_.get_local_addr (tmp_addr);
// reopen new file for asynch IO
if(connector_.connect(peer_,
tmp_addr,
0, //timeout
ACE_Addr::sap_any,
0, //reuse
O_RDWR |FILE_FLAG_OVERLAPPED) != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to open file")));
peer_.remove ();
result = -1;
}
else // device connected successfully
{
// keep track of our writes for offset calculations (can't use O_APPEND since
// this is not supported for the Win32_Asynch implementation) and data verifications
this->block_count_ = 0; // start counting
// Set our I/O handle to that of the peer_ object handling our connection
handle(peer_.get_handle());
if (writer_.open(*this) != 0 || reader_.open(*this) != 0)
{
ACE_ERROR(
(LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("FileIOHandler reader or writer open failed")));
result = -1;
}
else // reader and writer opened successfully
{
// Allocate a new message block and initiate a read operation on it
// to prime the asynchronous read pipeline
// The message block is sized for the largest message we expect
ACE_Message_Block *mb;
ACE_NEW_NORETURN(mb, ACE_Message_Block(FILE_FRAME_SIZE));
if (reader_.read(*mb, mb->space()) != 0)
{
int errnr = ACE_OS::last_error ();
ACE_DEBUG(
(LM_INFO, ACE_TEXT("%p [%d]\n"), ACE_TEXT("FileIOHandler begin read failed"), errnr));
mb->release();
#if defined (ACE_WIN32)
// On older Win32 versions (WinXP, Win2003/2008) asynch IO with disk files is not
// reliable and may perform sync IO in certain cases like when the read offset denotes
// current end of file. Instead of scheduling a write operation the read will immediately
// return with an EOF error.
// We circumvent that situation here by not reporting an error and scheduling a read operation
// later when we are sure data has been written at the offset in question (after the write finishes).
if (errnr != ERROR_HANDLE_EOF)
#endif
result = -1;
}
#if defined (ACE_WIN32)
else
{
this->read_pending_ = true;
}
#endif
// If read worked, psMsg is now controlled by Proactor framework.
}
}
return result;
}