int
ACE_TMAIN(int argc, ACE_TCHAR *argv[]){
ACE_FILE_Info fileinfo;
ACE_FILE_IO cli_file;
ACE_FILE_Connector con;
if(con.connect(cli_file,
ACE_FILE_Addr(argv[1]),
0,
ACE_Addr::sap_any,0,O_RDWR|O_APPEND|O_CREAT, ACE_DEFAULT_FILE_PERMS) == -1){
ACE_ERROR_RETURN((LM_ERROR,
"%p\n to %s",
"connect","abc"), -1);
ssize_t len =
ACE_Utils::truncate_cast<ssize_t> (ACE_OS::strlen(argv[2] )+1);
if(cli_file.send(argv[2],len)!= len){
ACE_ERROR_RETURN((LM_ERROR,
"%p\n","send"),1);
}
cli_file.close();
}
return 0;
}
Callback_i::Callback_i (int *request_count)
: file_ (ACE_sap_any_cast (ACE_FILE_Addr &)),
file_io_ (),
ami_handler_ (),
metadata_ (),
last_chunk_ (0),
lock_ (),
request_count_ (request_count)
{
// Create a temporary file to store the retrieved data.
ACE_FILE_Connector connector;
if (connector.connect (this->file_io_,
this->file_,
0,
ACE_Addr::sap_any,
0,
O_CREAT | O_TRUNC | O_WRONLY,
ACE_DEFAULT_FILE_PERMS) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Could not open file \"%s\"%p\n"),
this->file_.get_path_name ()));
}
else
(*this->request_count_)++;
}
virtual int open (void *) {
ACE_FILE_Addr name (filename_.c_str ());
ACE_FILE_Connector connector;
if (connector.connect (logfile_, name) == -1)
return -1;
return activate ();
}
int Logging_Server::make_log_file(ACE_FILE_IO& logging_file, ACE_SOCK_Stream* logging_peer)
{
// sizeof operator could be used on string literal
// which will return the size including the NULL terminator
char filename[MAXHOSTNAMELEN + sizeof(".log")];
if (0 != logging_peer)
{
// Use client host name as file name.
ACE_INET_Addr logging_peer_addr;
logging_peer->get_remote_addr(logging_peer_addr);
logging_peer_addr.get_host_name(filename, MAXHOSTNAMELEN);
strcat(filename, ".log");
}
else
{
strcpy(filename, "logging_server.log");
}
ACE_FILE_Connector connector;
return connector.connect(logging_file,
ACE_FILE_Addr(filename),
0, // No time-out.
ACE_Addr::sap_any, // Ignored.
0, // Don't try to reuse the addr.
O_RDWR | O_CREAT | O_APPEND,
ACE_DEFAULT_FILE_PERMS);
}
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;
}
bool LameMP3::NewFile(const ACE_TString& filename, int samplerate,
int channels, int bitrate)
{
if(m_hMp3Stream)
return false;
//init MP3 encoder
BE_CONFIG conf = {};
conf.dwConfig = BE_CONFIG_LAME;
conf.format.LHV1.dwStructVersion = CURRENT_STRUCT_VERSION;
conf.format.LHV1.dwStructSize = CURRENT_STRUCT_SIZE;
conf.format.LHV1.dwSampleRate = samplerate;
conf.format.LHV1.dwReSampleRate = 0;
conf.format.LHV1.nMode = channels == 1? BE_MP3_MODE_MONO : BE_MP3_MODE_STEREO;
conf.format.LHV1.dwBitrate = bitrate;
conf.format.LHV1.nPreset = 0; //LQP_NORMAL_QUALITY;
conf.format.LHV1.nQuality = 0;
conf.format.LHV1.bEnableVBR = 1;
conf.format.LHV1.nVBRQuality = 4;
conf.format.LHV1.bWriteVBRHeader = 1;
conf.format.LHV1.bStrictIso = 0;
DWORD dwBufferSize = 0;
int err = initStream(&conf, &m_dwInSamples, &dwBufferSize, &m_hMp3Stream);
if(err != 0)
return false;
m_dwChannels = channels;
m_out_mp3data.resize(dwBufferSize);
ACE_FILE_Connector con;
#if !defined(UNDER_CE)
int ret = con.connect(m_outfile, ACE_FILE_Addr(filename.c_str()), 0,
ACE_Addr::sap_any, 0, O_RDWR | O_CREAT | O_TRUNC);
#else
int ret = con.connect(m_outfile, ACE_FILE_Addr(filename.c_str()),
0, ACE_Addr::sap_any, 0, O_RDWR | O_CREAT, FILE_SHARE_READ | FILE_SHARE_WRITE);
#endif
if(ret < 0)
{
closeStream(m_hMp3Stream);
m_hMp3Stream = 0;
}
return ret >= 0;
}
bool OggFile::Open(const ACE_TString& filename)
{
ACE_FILE_Connector con;
if(con.connect(m_out_file, ACE_FILE_Addr(filename.c_str()),
0, ACE_Addr::sap_any, 0, O_RDWR | O_CREAT | O_TRUNC) < 0)
return false;
return true;
}
//FUZZ: disable check_for_lack_ACE_OS
virtual int open (void *) {
//FUZZ: enable check_for_lack_ACE_OS
ACE_FILE_Addr name (filename_.c_str ());
ACE_FILE_Connector connector;
if (connector.connect (logfile_, name) == -1)
return -1;
return activate ();
}
void
Callback_Handler::open_file (void)
{
// Create a temporary file to store the retrieved data.
ACE_FILE_Connector connector;
if (connector.connect (this->file_io_,
this->file_,
0,
ACE_Addr::sap_any,
0,
O_RDONLY) == -1)
// HTTP 1.1 "Not Found"
throw Web_Server::Error_Result (404);
}
int Logging_Event_Handler::open () {
static const char LOGFILE_SUFFIX[] = ".log";
char filename[MAXHOSTNAMELEN + sizeof (LOGFILE_SUFFIX)];
ACE_INET_Addr logging_peer_addr;
logging_handler_.peer ().get_remote_addr (logging_peer_addr);
logging_peer_addr.get_host_name (filename, MAXHOSTNAMELEN);
ACE_OS::strcat (filename, LOGFILE_SUFFIX);
ACE_FILE_Connector connector;
connector.connect (log_file_,
ACE_FILE_Addr (filename),
0, // No timeout.
ACE_Addr::sap_any, // Ignored.
0, // Don't try to reuse the addr.
O_RDWR|O_CREAT|O_APPEND,
ACE_DEFAULT_FILE_PERMS);
return reactor ()->register_handler
(this, ACE_Event_Handler::READ_MASK);
}
int TPC_Logging_Handler::open (void *) {
static const ACE_TCHAR LOGFILE_SUFFIX[] = ACE_TEXT (".log");
ACE_TCHAR filename[MAXHOSTNAMELEN + sizeof (LOGFILE_SUFFIX)];
ACE_INET_Addr logging_peer_addr;
peer ().get_remote_addr (logging_peer_addr);
logging_peer_addr.get_host_name (filename, MAXHOSTNAMELEN);
ACE_OS::strcat (filename, LOGFILE_SUFFIX);
ACE_FILE_Connector connector;
connector.connect (log_file_,
ACE_FILE_Addr (filename),
0, // No timeout.
ACE_Addr::sap_any, // Ignored.
0, // Don't try to reuse the addr.
O_RDWR | O_CREAT | O_APPEND,
ACE_DEFAULT_FILE_PERMS);
logging_handler_.peer ().set_handle (peer ().get_handle ());
return activate (THR_NEW_LWP | THR_DETACHED);
}
int
Content_Iterator_i::init (void)
{
// Open the requested file.
ACE_FILE_Connector connector;
if (connector.connect (this->file_io_,
this->file_,
0,
ACE_Addr::sap_any,
0,
O_RDONLY) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%s %p\n"),
ACE_TEXT ("Could not open file"),
this->file_.get_path_name ()),
-1);
}
return 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;
}
int Logging_Server::make_log_file (ACE_FILE_IO &logging_file,
ACE_SOCK_Stream *logging_peer)
{
char filename[MAXHOSTNAMELEN + sizeof (".log")];
if (logging_peer != 0) { // Use client's hostname as log file name.
ACE_INET_Addr logging_peer_addr;
logging_peer->get_remote_addr (logging_peer_addr);
logging_peer_addr.get_host_name (filename, MAXHOSTNAMELEN);
strcat (filename, ".log");
}
else
strcpy (filename, "logging_server.log");
ACE_FILE_Connector connector;
return connector.connect (logging_file,
ACE_FILE_Addr (filename),
0, // No timeout.
ACE_Addr::sap_any, // Ignored.
0, // Don't try to reuse the addr.
O_RDWR|O_CREAT|O_APPEND,
ACE_DEFAULT_FILE_PERMS);
}
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 ();
}
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;
}
Iterator_Handler::Iterator_Handler (void)
: file_ (ACE_sap_any_cast (const ACE_FILE_Addr &)),
file_io_ (),
contents_ (),
metadata_ (),
offset_ (0),
ami_handler_ (),
request_count_ (0)
{
// Nothing else
}
Iterator_Handler::~Iterator_Handler (void)
{
(void) this->file_io_.close ();
}
void
Iterator_Handler::next_chunk (CORBA::Boolean pending_data,
const Web_Server::Chunk_Type &chunk_data)
{
if (pending_data)
{
Web_Server::Chunk_Type_var chunk = chunk_data;
// Append the received data to the corresponding
// buffer/temporary file.
if (this->file_io_.send (chunk->get_buffer (),
chunk->length ()) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Unable to write retrieved data to ")
ACE_TEXT ("file")));
return;
}
else
this->offset_ += chunk->length ();
this->contents_->sendc_next_chunk (this->ami_handler_.in (),
this->offset_);
}
else
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("Wrote retrieved data to file <%s>\n"),
this->file_.get_path_name ()));
(*this->request_count_)--; // No more data.
// Done with the iterator, so destroy it.
this->contents_->sendc_destroy (this->ami_handler_.in ());
// File retrieval has completed, so spawn an external viewer to
// display its contents.
(void) this->spawn_viewer ();
}
}
void
Iterator_Handler::destroy (void)
{
// Deactivate this reply handler.
this->deactivate ();
}
void
Iterator_Handler::run (int *request_count,
const char *pathname,
Web_Server::Iterator_Factory_ptr factory)
{
if (request_count != 0)
this->request_count_ = request_count;
else
// @@ Application code shouldn't throw system exceptions.
throw CORBA::BAD_PARAM ();
// Initialize the Content Iterator
this->initialize_content_iterator (pathname,
factory);
// Activate this Reply Handler.
this->ami_handler_ = this->_this ();
// Begin the asynchronous invocation.
this->contents_->sendc_next_chunk (this->ami_handler_.in (),
this->offset_);
}
void
Iterator_Handler::initialize_content_iterator
(const char *pathname,
Web_Server::Iterator_Factory_ptr factory)
{
// Obtain a Content Iterator for the desired file.
factory->get_iterator (pathname,
this->contents_,
this->metadata_);
// Create a temporary file to store the retrieved data.
ACE_FILE_Connector connector;
if (connector.connect (this->file_io_,
this->file_,
0,
ACE_Addr::sap_any,
0,
O_CREAT | O_TRUNC | O_WRONLY,
ACE_DEFAULT_FILE_PERMS) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Could not open file %p\n"),
this->file_.get_path_name ()));
else
(*this->request_count_)++;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
if (argc < 3 || argc > 3)
ACE_ERROR_RETURN ((LM_ERROR,
"usage: %s filename string\n",
argv[0]),
1);
ACE_TCHAR *readback = new ACE_TCHAR[ACE_OS::strlen (argv[1]) + 1];
ACE_FILE_Info fileinfo;
ACE_FILE_IO cli_file;
ACE_FILE_Connector con;
if (con.connect (cli_file,
ACE_FILE_Addr (argv[1]),
0,
ACE_Addr::sap_any, 0,
O_RDWR|O_APPEND|O_CREAT,
ACE_DEFAULT_FILE_PERMS) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n to %s",
"connect",
argv[1]),
-1);
ssize_t len = ACE_OS::strlen (argv[2]) + 1;
if (cli_file.send (argv[2], len) != len)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send"),
1);
if (cli_file.get_info (&fileinfo) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"get_info"),
1);
else
ACE_OS::printf ("fileinfo : mode = %o\nno of links = %lu\nsize = %lu\n",
(u_int) fileinfo.mode_ & 0777,
static_cast<u_long > (fileinfo.nlink_),
(u_long) fileinfo.size_);
ACE_OFF_T fpos = cli_file.tell ();
if (fpos == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"tell"),
1);
else
ACE_OS::printf ("current filepointer is at %ld\n",
(long int) fpos);
if (cli_file.seek (0,
SEEK_SET) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"seek"),
1);
if (cli_file.recv (readback, len) != len)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"recv"),
1);
ACE_OS::printf ("read back :%s\n",
readback);
if (cli_file.close () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"close"),
1);
return 0;
}
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
run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("Svc_Handler_Test"));
{
size_t max_buffer_size = BUFSIZ;
size_t iterations = 10;
if (argc > 1)
max_buffer_size = ACE_OS::atoi (argv[1]);
if (argc > 2)
iterations = ACE_OS::atoi (argv[2]);
ACE_FILE_Connector connector;
ACE_FILE_IO file_io;
// Create a temporary filename.
ACE_FILE_Addr file (ACE_sap_any_cast (ACE_FILE_Addr &));
// Open up the temp file.
if (connector.connect (file_io, file) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("connect failed for %p\n"),
file.get_path_name ()),
1);
#if (!defined (ACE_WIN32) \
|| (defined (ACE_HAS_WINNT4) && ACE_HAS_WINNT4 == 1)) && \
!defined (VXWORKS)
# define TEST_CAN_UNLINK_IN_ADVANCE
#endif
// Create the service handler and assign it <file_io> as its data
// sink.
SVC_HANDLER svc_handler (0,
0,
0,
max_buffer_size,
0);
svc_handler.peer () = file_io;
// Run the test.
run_test (svc_handler, iterations);
file_io.close ();
// Open up the temp file.
if (connector.connect (file_io, file) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("connect failed for %p\n"),
file.get_path_name ()),
1);
char buf[ACE_MAXLOGMSGLEN + 1];
ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
ACE_FILE_Info info;
file_io.get_info (info);
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("file size = %d\n"), info.size_));
for (ssize_t n_bytes; (n_bytes = file_io.recv (buf, ACE_MAXLOGMSGLEN)) > 0; )
{
buf[n_bytes] = '\0';
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("%s"), ACE_TEXT_CHAR_TO_TCHAR(buf)));
}
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("\n")));
file_io.close ();
if (file_io.unlink () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("unlink failed for %p\n"),
file.get_path_name ()),
1);
}
ACE_END_TEST;
return 0;
}